From 07fd6430f879d36928d179a62d9bdeed82286065 Mon Sep 17 00:00:00 2001
From: Mircea Trofin <mtrofin@google.com>
Date: Tue, 11 Apr 2017 13:21:50 -0700
Subject: [PATCH 001/329] Remove use of "stack" property on Error (#457)

Since stack is not standard, it fits oddly in a test suite for a standard.
---
 test/js-api/jsapi.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 710007ab3..61dd0a6d0 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -722,7 +722,6 @@ test(() => {
                 })
                 .catch(error => {
                     assert_equals(error instanceof err, true);
-                    assert_equals(Boolean(error.stack.match("jsapi.js")), true);
                 })
         }, 'unexpected success in assertInstantiateError');
     }

From e63040622fd428a57c86bc8628f9ce694e522bf1 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 12 Apr 2017 14:09:15 +0200
Subject: [PATCH 002/329] Add comments; refactor to match spec

---
 interpreter/host/import.ml  |  12 +---
 interpreter/host/js.ml      |   8 +--
 interpreter/spec/ast.ml     |  58 ++++++++--------
 interpreter/spec/decode.ml  |  21 +++---
 interpreter/spec/encode.ml  |  24 +++----
 interpreter/spec/eval.ml    |  22 +++---
 interpreter/spec/types.ml   |  23 +++++++
 interpreter/spec/valid.ml   |  42 +++++++----
 interpreter/text/arrange.ml |  38 +++++-----
 interpreter/text/parser.mly | 134 ++++++++++++++++++++----------------
 10 files changed, 211 insertions(+), 171 deletions(-)

diff --git a/interpreter/host/import.ml b/interpreter/host/import.ml
index b1d2bfe0f..31595b67d 100644
--- a/interpreter/host/import.ml
+++ b/interpreter/host/import.ml
@@ -1,6 +1,5 @@
 open Source
 open Ast
-open Types
 
 module Unknown = Error.Make ()
 exception Unknown = Unknown.Error  (* indicates unknown import name *)
@@ -10,16 +9,9 @@ let registry = ref Registry.empty
 
 let register name lookup = registry := Registry.add name lookup !registry
 
-let external_type_of_import_kind m ikind =
-  match ikind.it with
-  | FuncImport x -> ExternalFuncType (Lib.List32.nth m.it.types x.it)
-  | TableImport t -> ExternalTableType t
-  | MemoryImport t -> ExternalMemoryType t
-  | GlobalImport t -> ExternalGlobalType t
-
 let lookup (m : module_) (im : import) : Instance.extern =
-  let {module_name; item_name; ikind} = im.it in
-  let t = external_type_of_import_kind m ikind in
+  let {module_name; item_name; idesc} = im.it in
+  let t = import_type m im in
   try Registry.find module_name !registry item_name t with Not_found ->
     Unknown.error im.at
       ("unknown import \"" ^ module_name ^ "." ^ item_name ^ "\"")
diff --git a/interpreter/host/js.ml b/interpreter/host/js.ml
index 6a36b6a02..fff314c25 100644
--- a/interpreter/host/js.ml
+++ b/interpreter/host/js.ml
@@ -239,13 +239,13 @@ let assert_return_arithmetic_nan =
   assert_return_nan_bitpattern canonical_nan_of
 
 let wrap module_name item_name wrap_action wrap_assertion at =
-  let itypes, ikind, action = wrap_action at in
+  let itypes, idesc, action = wrap_action at in
   let locals, assertion = wrap_assertion at in
   let item = Lib.List32.length itypes @@ at in
   let types = FuncType ([], []) :: itypes in
-  let imports = [{module_name; item_name; ikind} @@ at] in
-  let ekind = FuncExport @@ at in
-  let exports = [{name = "run"; ekind; item} @@ at] in
+  let imports = [{module_name; item_name; idesc} @@ at] in
+  let edesc = FuncExport item @@ at in
+  let exports = [{name = "run"; edesc} @@ at] in
   let body =
     [ Block ([], action @ assertion @ [Return @@ at]) @@ at;
       Unreachable @@ at ]
diff --git a/interpreter/spec/ast.ml b/interpreter/spec/ast.ml
index b0c48ee3a..94822eb7a 100644
--- a/interpreter/spec/ast.ml
+++ b/interpreter/spec/ast.ml
@@ -146,19 +146,22 @@ type memory_segment = string segment
 
 (* Modules *)
 
-type export_kind = export_kind' Source.phrase
-and export_kind' = FuncExport | TableExport | MemoryExport | GlobalExport
+type export_desc = export_desc' Source.phrase
+and export_desc' =
+  | FuncExport of var
+  | TableExport of var
+  | MemoryExport of var
+  | GlobalExport of var
 
 type export = export' Source.phrase
 and export' =
 {
   name : string;
-  ekind : export_kind;
-  item : var;
+  edesc : export_desc;
 }
 
-type import_kind = import_kind' Source.phrase
-and import_kind' =
+type import_desc = import_desc' Source.phrase
+and import_desc' =
   | FuncImport of var
   | TableImport of table_type
   | MemoryImport of memory_type
@@ -169,7 +172,7 @@ and import' =
 {
   module_name : string;
   item_name : string;
-  ikind : import_kind;
+  idesc : import_desc;
 }
 
 type module_ = module_' Source.phrase
@@ -206,32 +209,29 @@ let empty_module =
 
 open Source
 
-let export_kind_of_import_kind = function
-  | FuncImport _ -> FuncExport
-  | TableImport _ -> TableExport
-  | MemoryImport _ -> MemoryExport
-  | GlobalImport _ -> GlobalExport
-
 let import_type (m : module_) (im : import) : external_type =
-  let {ikind; _} = im.it in
-  match ikind.it with
+  let {idesc; _} = im.it in
+  match idesc.it with
   | FuncImport x -> ExternalFuncType (Lib.List32.nth m.it.types x.it)
   | TableImport t -> ExternalTableType t
   | MemoryImport t -> ExternalMemoryType t
   | GlobalImport t -> ExternalGlobalType t
 
 let export_type (m : module_) (ex : export) : external_type =
-  let {ekind; item; _} = ex.it in
-  let rec find i = function
-    | im::ims when export_kind_of_import_kind im.it.ikind.it = ekind.it ->
-      if i = 0l then import_type m im else find (Int32.sub i 1l) ims
-    | im::ims -> find i ims
-    | [] ->
-      let open Lib.List32 in
-      match ekind.it with
-      | FuncExport ->
-        ExternalFuncType (nth m.it.types (nth m.it.funcs i).it.ftype.it)
-      | TableExport -> ExternalTableType (nth m.it.tables i).it.ttype
-      | MemoryExport -> ExternalMemoryType (nth m.it.memories i).it.mtype
-      | GlobalExport -> ExternalGlobalType (nth m.it.globals i).it.gtype
-  in find item.it m.it.imports
+  let {edesc; _} = ex.it in
+  let its = List.map (import_type m) m.it.imports in
+  let open Lib.List32 in
+  match edesc.it with
+  | FuncExport x ->
+    let fts =
+      funcs its @ List.map (fun f -> nth m.it.types f.it.ftype.it) m.it.funcs
+    in ExternalFuncType (nth fts x.it)
+  | TableExport x ->
+    let tts = tables its @ List.map (fun t -> t.it.ttype) m.it.tables in
+    ExternalTableType (nth tts x.it)
+  | MemoryExport x ->
+    let mts = memories its @ List.map (fun m -> m.it.mtype) m.it.memories in
+    ExternalMemoryType (nth mts x.it)
+  | GlobalExport x ->
+    let gts = globals its @ List.map (fun g -> g.it.gtype) m.it.globals in
+    ExternalGlobalType (nth gts x.it)
diff --git a/interpreter/spec/decode.ml b/interpreter/spec/decode.ml
index 6e5b7f12a..2cca12456 100644
--- a/interpreter/spec/decode.ml
+++ b/interpreter/spec/decode.ml
@@ -482,7 +482,7 @@ let type_section s =
 
 (* Import section *)
 
-let import_kind s =
+let import_desc s =
   match u8 s with
   | 0x00 -> FuncImport (at var s)
   | 0x01 -> TableImport (table_type s)
@@ -493,8 +493,8 @@ let import_kind s =
 let import s =
   let module_name = string s in
   let item_name = string s in
-  let ikind = at import_kind s in
-  {module_name; item_name; ikind}
+  let idesc = at import_desc s in
+  {module_name; item_name; idesc}
 
 let import_section s =
   section `ImportSection (vec (at import)) [] s
@@ -539,19 +539,18 @@ let global_section s =
 
 (* Export section *)
 
-let export_kind s =
+let export_desc s =
   match u8 s with
-  | 0x00 -> FuncExport
-  | 0x01 -> TableExport
-  | 0x02 -> MemoryExport
-  | 0x03 -> GlobalExport
+  | 0x00 -> FuncExport (at var s)
+  | 0x01 -> TableExport (at var s)
+  | 0x02 -> MemoryExport (at var s)
+  | 0x03 -> GlobalExport (at var s)
   | _ -> error s (pos s - 1) "invalid export kind"
 
 let export s =
   let name = string s in
-  let ekind = at export_kind s in
-  let item = at var s in
-  {name; ekind; item}
+  let edesc = at export_desc s in
+  {name; edesc}
 
 let export_section s =
   section `ExportSection (vec (at export)) [] s
diff --git a/interpreter/spec/encode.ml b/interpreter/spec/encode.ml
index e2f367580..c93e71edd 100644
--- a/interpreter/spec/encode.ml
+++ b/interpreter/spec/encode.ml
@@ -381,16 +381,16 @@ let encode m =
       section 1 (vec func_type) ts (ts <> [])
 
     (* Import section *)
-    let import_kind k =
-      match k.it with
+    let import_desc d =
+      match d.it with
       | FuncImport x -> u8 0x00; var x
       | TableImport t -> u8 0x01; table_type t
       | MemoryImport t -> u8 0x02; memory_type t
       | GlobalImport t -> u8 0x03; global_type t
 
     let import im =
-      let {module_name; item_name; ikind} = im.it in
-      string module_name; string item_name; import_kind ikind
+      let {module_name; item_name; idesc} = im.it in
+      string module_name; string item_name; import_desc idesc
 
     let import_section ims =
       section 2 (vec import) ims (ims <> [])
@@ -426,16 +426,16 @@ let encode m =
       section 6 (vec global) gs (gs <> [])
 
     (* Export section *)
-    let export_kind k =
-      match k.it with
-      | FuncExport -> u8 0
-      | TableExport -> u8 1
-      | MemoryExport -> u8 2
-      | GlobalExport -> u8 3
+    let export_desc d =
+      match d.it with
+      | FuncExport x -> u8 0; var x
+      | TableExport x -> u8 1; var x
+      | MemoryExport x -> u8 2; var x
+      | GlobalExport x -> u8 3; var x
 
     let export ex =
-      let {name; ekind; item} = ex.it in
-      string name; export_kind ekind; var item
+      let {name; edesc} = ex.it in
+      string name; export_desc edesc
 
     let export_section exs =
       section 7 (vec export) exs (exs <> [])
diff --git a/interpreter/spec/eval.ml b/interpreter/spec/eval.ml
index d7bf9f894..0511801bf 100644
--- a/interpreter/spec/eval.ml
+++ b/interpreter/spec/eval.ml
@@ -396,31 +396,31 @@ let check_limits actual expected at =
   then Link.error at "maximum size larger than declared"
 
 let add_import (ext : extern) (im : import) (inst : instance) : instance =
-  let {ikind; _} = im.it in
-  match ext, ikind.it with
+  let {idesc; _} = im.it in
+  match ext, idesc.it with
   | ExternalFunc clos, FuncImport x when func_type_of clos = type_ inst x ->
     {inst with funcs = clos :: inst.funcs}
   | ExternalTable tab, TableImport (TableType (lim, t))
     when Table.elem_type tab = t ->
-    check_limits (Table.limits tab) lim ikind.at;
+    check_limits (Table.limits tab) lim idesc.at;
     {inst with tables = tab :: inst.tables}
   | ExternalMemory mem, MemoryImport (MemoryType lim) ->
-    check_limits (Memory.limits mem) lim ikind.at;
+    check_limits (Memory.limits mem) lim idesc.at;
     {inst with memories = mem :: inst.memories}
   | ExternalGlobal v, GlobalImport (GlobalType (t, _)) when type_of v = t ->
     {inst with globals = ref v :: inst.globals}
   | _ ->
-    Link.error ikind.at "type mismatch"
+    Link.error idesc.at "type mismatch"
 
 let add_export (inst : instance) (ex : export) (map : extern ExportMap.t)
   : extern ExportMap.t =
-  let {name; ekind; item} = ex.it in
+  let {name; edesc} = ex.it in
   let ext =
-    match ekind.it with
-    | FuncExport -> ExternalFunc (func inst item)
-    | TableExport -> ExternalTable (table inst item)
-    | MemoryExport -> ExternalMemory (memory inst item)
-    | GlobalExport -> ExternalGlobal !(global inst item)
+    match edesc.it with
+    | FuncExport x -> ExternalFunc (func inst x)
+    | TableExport x -> ExternalTable (table inst x)
+    | MemoryExport x -> ExternalMemory (memory inst x)
+    | GlobalExport x -> ExternalGlobal !(global inst x)
   in ExportMap.add name ext map
 
 let init (m : module_) (exts : extern list) : instance =
diff --git a/interpreter/spec/types.ml b/interpreter/spec/types.ml
index eed8e68c5..9dc6e25de 100644
--- a/interpreter/spec/types.ml
+++ b/interpreter/spec/types.ml
@@ -24,6 +24,29 @@ let size = function
   | I64Type | F64Type -> 8
 
 
+(* Filters *)
+
+let rec funcs = function
+  | [] -> []
+  | ExternalFuncType ft :: ets -> ft :: funcs ets
+  | _ :: ets -> funcs ets
+
+let rec tables = function
+  | [] -> []
+  | ExternalTableType tt :: ets -> tt :: tables ets
+  | _ :: ets -> tables ets
+
+let rec memories = function
+  | [] -> []
+  | ExternalMemoryType mt :: ets -> mt :: memories ets
+  | _ :: ets -> memories ets
+
+let rec globals = function
+  | [] -> []
+  | ExternalGlobalType ft :: ets -> ft :: globals ets
+  | _ :: ets -> globals ets
+
+
 (* String conversion *)
 
 let string_of_value_type = function
diff --git a/interpreter/spec/valid.ml b/interpreter/spec/valid.ml
index 24f6b0a4c..77ce2c01f 100644
--- a/interpreter/spec/valid.ml
+++ b/interpreter/spec/valid.ml
@@ -46,6 +46,15 @@ let memory (c : context) x = lookup "memory" c.memories x
 
 (* Stack typing *)
 
+(*
+ * Note: The declarative typing rules are non-deterministic, that is, they
+ * have the liberty to locally "guess" the right types implied by the context.
+ * In the algorithmic formulation required here, stack types are hence modelled
+ * as lists of _options_ of types here, where `None` representss a locally
+ * unknown type. Furthermore, an ellipses flag represents arbitrary sequences
+ * of unknown types, in order to handle stack polymorphism algorithmically.
+ *)
+
 type ellipses = NoEllipses | Ellipses
 type infer_stack_type = ellipses * value_type option list
 type op_type = {ins : infer_stack_type; outs : infer_stack_type}
@@ -153,10 +162,16 @@ let check_arity n at =
  *   v  : value
  *   t  : value_type var
  *   ts : stack_type
+ *   x  : variable
  *
  * Note: To deal with the non-determinism in some of the declarative rules,
  * the function takes the current stack `s` as an additional argument, allowing
  * it to "peek" when it would otherwise have to guess an input type.
+ *
+ * Furthermore, stack-polymorphic types are given with the `-->...` operator:
+ * a type `ts1 -->... ts2` expresses any type `(ts1' @ ts1) -> (ts2' @ ts2)`
+ * where `ts1'` and `ts2'` would be chosen non-deterministically in the
+ * declarative typing rules.
  *)
 
 let rec check_instr (c : context) (e : instr) (s : infer_stack_type) : op_type =
@@ -301,6 +316,7 @@ and check_block (c : context) (es : instr list) (ts : stack_type) at =
  *   v : value
  *   t : value_type
  *   s : func_type
+ *   x : variable
  *)
 
 let check_func (c : context) (f : func) =
@@ -379,31 +395,31 @@ let check_start (c : context) (start : var option) =
   ) start
 
 let check_import (im : import) (c : context) : context =
-  let {module_name = _; item_name = _; ikind} = im.it in
-  match ikind.it with
+  let {module_name = _; item_name = _; idesc} = im.it in
+  match idesc.it with
   | FuncImport x ->
     {c with funcs = type_ c x :: c.funcs}
   | TableImport t ->
-    check_table_type t ikind.at; {c with tables = t :: c.tables}
+    check_table_type t idesc.at; {c with tables = t :: c.tables}
   | MemoryImport t ->
-    check_memory_type t ikind.at; {c with memories = t :: c.memories}
+    check_memory_type t idesc.at; {c with memories = t :: c.memories}
   | GlobalImport t ->
     let GlobalType (_, mut) = t in
-    require (mut = Immutable) ikind.at
+    require (mut = Immutable) idesc.at
       "mutable globals cannot be imported (yet)";
     {c with globals = t :: c.globals}
 
 module NameSet = Set.Make(String)
 
 let check_export (c : context) (set : NameSet.t) (ex : export) : NameSet.t =
-  let {name; ekind; item} = ex.it in
-  (match ekind.it with
-  | FuncExport -> ignore (func c item)
-  | TableExport -> ignore (table c item)
-  | MemoryExport -> ignore (memory c item)
-  | GlobalExport ->
-    let GlobalType (_, mut) = global c item in
-    require (mut = Immutable) ekind.at
+  let {name; edesc} = ex.it in
+  (match edesc.it with
+  | FuncExport x -> ignore (func c x)
+  | TableExport x -> ignore (table c x)
+  | MemoryExport x -> ignore (memory c x)
+  | GlobalExport x ->
+    let GlobalType (_, mut) = global c x in
+    require (mut = Immutable) edesc.at
       "mutable globals cannot be exported (yet)"
   );
   require (not (NameSet.mem name set)) ex.at "duplicate export name";
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 733480454..18bc51f48 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -296,32 +296,30 @@ let data seg =
 let typedef i t =
   Node ("type $" ^ nat i, [struct_type t])
 
-let import_kind i k =
-  match k.it with
+let import_desc i d =
+  match d.it with
   | FuncImport x ->
     Node ("func $" ^ nat i, [Node ("type", [atom var x])])
-  | TableImport t -> table 0 i ({ttype = t} @@ k.at)
-  | MemoryImport t -> memory 0 i ({mtype = t} @@ k.at)
+  | TableImport t -> table 0 i ({ttype = t} @@ d.at)
+  | MemoryImport t -> memory 0 i ({mtype = t} @@ d.at)
   | GlobalImport t -> Node ("global $" ^ nat i, [global_type t])
 
 let import i im =
-  let {module_name; item_name; ikind} = im.it in
+  let {module_name; item_name; idesc} = im.it in
   Node ("import",
-    [atom string module_name; atom string item_name; import_kind i ikind]
+    [atom string module_name; atom string item_name; import_desc i idesc]
   )
 
-let export_kind k =
-  match k.it with
-  | FuncExport -> "func"
-  | TableExport -> "table"
-  | MemoryExport -> "memory"
-  | GlobalExport -> "global"
+let export_desc d =
+  match d.it with
+  | FuncExport x -> Node ("func", [atom var x])
+  | TableExport x -> Node ("table", [atom var x])
+  | MemoryExport x -> Node ("memory", [atom var x])
+  | GlobalExport x -> Node ("global", [atom var x])
 
 let export ex =
-  let {name; ekind; item} = ex.it in
-  Node ("export",
-    [atom string name; Node (export_kind ekind, [atom var item])]
-  )
+  let {name; edesc} = ex.it in
+  Node ("export", [atom string name; export_desc edesc])
 
 let global off i g =
   let {gtype; value} = g.it in
@@ -335,13 +333,13 @@ let var_opt = function
   | Some x -> " " ^ x.it
 
 let is_func_import im =
-  match im.it.ikind.it with FuncImport _ -> true | _ -> false
+  match im.it.idesc.it with FuncImport _ -> true | _ -> false
 let is_table_import im =
-  match im.it.ikind.it with TableImport _ -> true | _ -> false
+  match im.it.idesc.it with TableImport _ -> true | _ -> false
 let is_memory_import im =
-  match im.it.ikind.it with MemoryImport _ -> true | _ -> false
+  match im.it.idesc.it with MemoryImport _ -> true | _ -> false
 let is_global_import im =
-  match im.it.ikind.it with GlobalImport _ -> true | _ -> false
+  match im.it.idesc.it with GlobalImport _ -> true | _ -> false
 
 let module_with_var_opt x_opt m =
   let func_imports = List.filter is_func_import m.it.imports in
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index def0b811b..e784a59c4 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -101,10 +101,12 @@ let anon_type (c : context) ty =
 let bind category space x =
   if VarMap.mem x.it space.map then
     error x.at ("duplicate " ^ category ^ " " ^ x.it);
+  let i = space.count in
   space.map <- VarMap.add x.it space.count space.map;
   space.count <- Int32.add space.count 1l;
   if space.count = 0l then 
-    error x.at ("too many " ^ category ^ " bindings")
+    error x.at ("too many " ^ category ^ " bindings");
+  i
 
 let bind_func (c : context) x = bind "function" c.funcs x
 let bind_local (c : context) x = bind "local" c.locals x
@@ -115,12 +117,15 @@ let bind_label (c : context) x =
   {c with labels = VarMap.add x.it 0l (VarMap.map (Int32.add 1l) c.labels)}
 
 let anon category space n =
+  let i = space.count in
   space.count <- Int32.add space.count n;
   if I32.lt_u space.count n then
-    error no_region ("too many " ^ category ^ " bindings")
+    error no_region ("too many " ^ category ^ " bindings");
+  i
 
 let anon_func (c : context) = anon "function" c.funcs 1l
-let anon_locals (c : context) ts = anon "local" c.locals (Lib.List32.length ts)
+let anon_locals (c : context) ts =
+  ignore (anon "local" c.locals (Lib.List32.length ts))
 let anon_global (c : context) = anon "global" c.globals 1l
 let anon_table (c : context) = anon "table" c.tables 1l
 let anon_memory (c : context) = anon "memory" c.memories 1l
@@ -141,8 +146,9 @@ let explicit_sig (c : context) var_sem ty at =
 
 let inline_type (c : context) ty at =
   match Lib.List.index_of ty c.types.tlist with
-  | None -> let i = Lib.List32.length c.types.tlist in anon_type c ty; i @@ at
   | Some i -> Int32.of_int i @@ at
+  | None ->
+    let i = Lib.List32.length c.types.tlist in ignore (anon_type c ty); i @@ at
 
 %}
 
@@ -387,10 +393,12 @@ func_fields :
       FuncType (ins, $3 @ out), fun c -> snd $5 c }
   | LPAR PARAM value_type_list RPAR func_fields
     { let FuncType (ins, out) = fst $5 in
-      FuncType ($3 @ ins, out), fun c -> anon_locals c $3; (snd $5) c }
+      FuncType ($3 @ ins, out),
+      fun c -> ignore (anon_locals c $3); (snd $5) c }
   | LPAR PARAM bind_var VALUE_TYPE RPAR func_fields  /* Sugar */
     { let FuncType (ins, out) = fst $6 in
-      FuncType ($4 :: ins, out), fun c -> bind_local c $3; (snd $6) c }
+      FuncType ($4 :: ins, out),
+      fun c -> ignore (bind_local c $3); (snd $6) c }
 
 func_body :
   | instr_list
@@ -399,37 +407,39 @@ func_body :
       {ftype = -1l @@ at(); locals = []; body = $1 c'} }
   | LPAR LOCAL value_type_list RPAR func_body
     { fst $5,
-      fun c -> anon_locals c $3; let f = (snd $5) c in
+      fun c -> ignore (anon_locals c $3); let f = (snd $5) c in
         {f with locals = $3 @ f.locals} }
   | LPAR LOCAL bind_var VALUE_TYPE RPAR func_body  /* Sugar */
     { fst $6,
-      fun c -> bind_local c $3; let f = (snd $6) c in
+      fun c -> ignore (bind_local c $3); let f = (snd $6) c in
         {f with locals = $4 :: f.locals} }
 
 func :
   | LPAR FUNC bind_var_opt inline_export type_use func_fields RPAR
     { let at = at () in
-      fun c -> $3 c anon_func bind_func;
+      fun c ->
+      let x = $3 c anon_func bind_func @@ at in
       let t = explicit_sig c $5 (fst $6) at in
       (fun () -> {(snd $6 (enter_func c)) with ftype = t} @@ at),
-      $4 FuncExport c.funcs.count c }
+      $4 (FuncExport x) c }
   /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */
   | LPAR FUNC bind_var_opt type_use func_fields RPAR
     { let at = at () in
-      fun c -> $3 c anon_func bind_func;
+      fun c -> ignore ($3 c anon_func bind_func);
       let t = explicit_sig c $4 (fst $5) at in
       (fun () -> {(snd $5 (enter_func c)) with ftype = t} @@ at),
       [] }
   | LPAR FUNC bind_var_opt inline_export func_fields RPAR  /* Sugar */
     { let at = at () in
-      fun c -> $3 c anon_func bind_func;
+      fun c -> 
+      let x = $3 c anon_func bind_func @@ at in
       let t = inline_type c (fst $5) at in
       (fun () -> {(snd $5 (enter_func c)) with ftype = t} @@ at),
-      $4 FuncExport c.funcs.count c }
+      $4 (FuncExport x) c }
   /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */
   | LPAR FUNC bind_var_opt func_fields RPAR  /* Sugar */
     { let at = at () in
-      fun c -> $3 c anon_func bind_func;
+      fun c -> ignore ($3 c anon_func bind_func);
       let t = inline_type c (fst $4) at in
       (fun () -> {(snd $4 (enter_func c)) with ftype = t} @@ at),
       [] }
@@ -452,19 +462,17 @@ elem :
 table :
   | LPAR TABLE bind_var_opt inline_export_opt table_sig RPAR
     { let at = at () in
-      fun c -> $3 c anon_table bind_table;
-      fun () ->
-      {ttype = $5} @@ at, [], $4 TableExport c.tables.count c }
+      fun c -> let x = $3 c anon_table bind_table @@ at in
+      fun () -> {ttype = $5} @@ at, [], $4 (TableExport x) c }
   | LPAR TABLE bind_var_opt inline_export_opt elem_type
       LPAR ELEM var_list RPAR RPAR  /* Sugar */
     { let at = at () in
-      fun c -> let i = c.tables.count in $3 c anon_table bind_table;
+      fun c -> let x = $3 c anon_table bind_table @@ at in
       fun () ->
       let init = $8 c func in let size = Int32.of_int (List.length init) in
       {ttype = TableType ({min = size; max = Some size}, $5)} @@ at,
-      [{index = i @@ at;
-        offset = [i32_const (0l @@ at) @@ at] @@ at; init} @@ at],
-      $4 TableExport c.tables.count c }
+      [{index = x; offset = [i32_const (0l @@ at) @@ at] @@ at; init} @@ at],
+      $4 (TableExport x) c }
 
 data :
   | LPAR DATA var offset text_list RPAR
@@ -477,104 +485,108 @@ data :
 memory :
   | LPAR MEMORY bind_var_opt inline_export_opt memory_sig RPAR
     { let at = at () in
-      fun c -> $3 c anon_memory bind_memory;
-      {mtype = $5} @@ at, [], $4 MemoryExport c.memories.count c }
+      fun c -> let x = $3 c anon_memory bind_memory @@ at in
+      {mtype = $5} @@ at, [], $4 (MemoryExport x) c }
   | LPAR MEMORY bind_var_opt inline_export LPAR DATA text_list RPAR RPAR
       /* Sugar */
     { let at = at () in
-      fun c -> let i = c.memories.count in $3 c anon_memory bind_memory;
+      fun c -> let x = $3 c anon_memory bind_memory @@ at in
       let size = Int32.(div (add (of_int (String.length $7)) 65535l) 65536l) in
       {mtype = MemoryType {min = size; max = Some size}} @@ at,
-      [{index = i @@ at;
+      [{index = x;
         offset = [i32_const (0l @@ at) @@ at] @@ at; init = $7} @@ at],
-      $4 MemoryExport c.memories.count c }
+      $4 (MemoryExport x) c }
   /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */
   | LPAR MEMORY bind_var_opt LPAR DATA text_list RPAR RPAR  /* Sugar */
     { let at = at () in
-      fun c -> let i = c.memories.count in $3 c anon_memory bind_memory;
+      fun c -> let x = $3 c anon_memory bind_memory @@ at in
       let size = Int32.(div (add (of_int (String.length $6)) 65535l) 65536l) in
       {mtype = MemoryType {min = size; max = Some size}} @@ at,
-      [{index = i @@ at;
+      [{index = x;
         offset = [i32_const (0l @@ at) @@ at] @@ at; init = $6} @@ at],
       [] }
 
 global :
   | LPAR GLOBAL bind_var_opt inline_export global_type const_expr RPAR
     { let at = at () in
-      fun c -> $3 c anon_global bind_global;
+      fun c -> let x = $3 c anon_global bind_global @@ at in
       (fun () -> {gtype = $5; value = $6 c} @@ at),
-      $4 GlobalExport c.globals.count c }
+      $4 (GlobalExport x) c }
   /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */
   | LPAR GLOBAL bind_var_opt global_type const_expr RPAR
     { let at = at () in
-      fun c -> $3 c anon_global bind_global;
+      fun c -> ignore ($3 c anon_global bind_global);
       (fun () -> {gtype = $4; value = $5 c} @@ at), [] }
 
 
 /* Imports & Exports */
 
-import_kind :
+import_desc :
   | LPAR FUNC bind_var_opt type_use RPAR
-    { fun c -> $3 c anon_func bind_func; FuncImport ($4 c type_) }
+    { fun c -> ignore ($3 c anon_func bind_func);
+      FuncImport ($4 c type_) }
   | LPAR FUNC bind_var_opt func_sig RPAR  /* Sugar */
     { let at4 = ati 4 in
-      fun c -> $3 c anon_func bind_func; FuncImport (inline_type c $4 at4) }
+      fun c -> ignore ($3 c anon_func bind_func);
+      FuncImport (inline_type c $4 at4) }
   | LPAR TABLE bind_var_opt table_sig RPAR
-    { fun c -> $3 c anon_table bind_table; TableImport $4 }
+    { fun c -> ignore ($3 c anon_table bind_table); TableImport $4 }
   | LPAR MEMORY bind_var_opt memory_sig RPAR
-    { fun c -> $3 c anon_memory bind_memory; MemoryImport $4 }
+    { fun c -> ignore ($3 c anon_memory bind_memory); MemoryImport $4 }
   | LPAR GLOBAL bind_var_opt global_type RPAR
-    { fun c -> $3 c anon_global bind_global; GlobalImport $4 }
+    { fun c -> ignore ($3 c anon_global bind_global); GlobalImport $4 }
 
 import :
-  | LPAR IMPORT TEXT TEXT import_kind RPAR
+  | LPAR IMPORT TEXT TEXT import_desc RPAR
     { let at = at () and at5 = ati 5 in
-      fun c -> {module_name = $3; item_name = $4; ikind = $5 c @@ at5} @@ at }
+      fun c -> {module_name = $3; item_name = $4; idesc = $5 c @@ at5} @@ at }
   | LPAR FUNC bind_var_opt inline_import type_use RPAR  /* Sugar */
     { let at = at () in
-      fun c -> $3 c anon_func bind_func;
-      {module_name = fst $4; item_name = snd $4; ikind = FuncImport ($5 c type_) @@ at} @@ at }
+      fun c -> ignore ($3 c anon_func bind_func);
+      { module_name = fst $4; item_name = snd $4;
+        idesc = FuncImport ($5 c type_) @@ at } @@ at }
   | LPAR FUNC bind_var_opt inline_import func_sig RPAR  /* Sugar */
     { let at = at () and at5 = ati 5 in
-      fun c -> $3 c anon_func bind_func;
-      {module_name = fst $4; item_name = snd $4; ikind = FuncImport (inline_type c $5 at5) @@ at} @@ at }
+      fun c -> ignore ($3 c anon_func bind_func);
+      { module_name = fst $4; item_name = snd $4;
+        idesc = FuncImport (inline_type c $5 at5) @@ at } @@ at }
   | LPAR TABLE bind_var_opt inline_import table_sig RPAR  /* Sugar */
     { let at = at () in
-      fun c -> $3 c anon_table bind_table;
-      {module_name = fst $4; item_name = snd $4; ikind = TableImport $5 @@ at} @@ at }
+      fun c -> ignore ($3 c anon_table bind_table);
+      { module_name = fst $4; item_name = snd $4;
+        idesc = TableImport $5 @@ at } @@ at }
   | LPAR MEMORY bind_var_opt inline_import memory_sig RPAR  /* Sugar */
     { let at = at () in
-      fun c -> $3 c anon_memory bind_memory;
-      {module_name = fst $4; item_name = snd $4; ikind = MemoryImport $5 @@ at} @@ at }
+      fun c -> ignore ($3 c anon_memory bind_memory);
+      { module_name = fst $4; item_name = snd $4;
+        idesc = MemoryImport $5 @@ at } @@ at }
   | LPAR GLOBAL bind_var_opt inline_import global_type RPAR  /* Sugar */
     { let at = at () in
-      fun c -> $3 c anon_global bind_global;
-      {module_name = fst $4; item_name = snd $4; ikind = GlobalImport $5 @@ at} @@ at }
+      fun c -> ignore ($3 c anon_global bind_global);
+      { module_name = fst $4; item_name = snd $4;
+        idesc = GlobalImport $5 @@ at } @@ at }
 
 inline_import :
   | LPAR IMPORT TEXT TEXT RPAR { $3, $4 }
 
-export_kind :
-  | LPAR FUNC var RPAR { fun c -> FuncExport, $3 c func }
-  | LPAR TABLE var RPAR { fun c -> TableExport, $3 c table }
-  | LPAR MEMORY var RPAR { fun c -> MemoryExport, $3 c memory }
-  | LPAR GLOBAL var RPAR { fun c -> GlobalExport, $3 c global }
+export_desc :
+  | LPAR FUNC var RPAR { fun c -> FuncExport ($3 c func) }
+  | LPAR TABLE var RPAR { fun c -> TableExport ($3 c table) }
+  | LPAR MEMORY var RPAR { fun c -> MemoryExport ($3 c memory) }
+  | LPAR GLOBAL var RPAR { fun c -> GlobalExport ($3 c global) }
 
 export :
-  | LPAR EXPORT TEXT export_kind RPAR
+  | LPAR EXPORT TEXT export_desc RPAR
     { let at = at () and at4 = ati 4 in
-      fun c -> let k, x = $4 c in
-      {name = $3; ekind = k @@ at4; item = x} @@ at }
+      fun c -> {name = $3; edesc = $4 c @@ at4} @@ at }
 
 inline_export_opt :
-  | /* empty */ { fun k count c -> [] }
+  | /* empty */ { fun d c -> [] }
   | inline_export { $1 }
 
 inline_export :
   | LPAR EXPORT TEXT RPAR
-    { let at = at () in
-      fun k count c ->
-      [{name = $3; ekind = k @@ at; item = Int32.sub count 1l @@ at} @@ at] }
+    { let at = at () in fun d c -> [{name = $3; edesc = d @@ at} @@ at] }
 
 
 /* Modules */

From 8c517ac81ca9f3f412ed88ef5d8eaf4189f3c53b Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Thu, 13 Apr 2017 08:49:23 +0200
Subject: [PATCH 003/329] Typo

---
 document/validation/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/validation/instructions.rst b/document/validation/instructions.rst
index ad3664533..918dd03cc 100644
--- a/document/validation/instructions.rst
+++ b/document/validation/instructions.rst
@@ -537,7 +537,7 @@ Control Instructions
    \frac{
      C,\LABELS\,[t^?] \vdash \instr^\ast : [] \to [t^?]
    }{
-     C \vdash \BLOCK~[^?]~\instr^\ast~\END : [] \to [t^?]
+     C \vdash \BLOCK~[t^?]~\instr^\ast~\END : [] \to [t^?]
    }
 
 .. note::

From 6a01dab6d29b7c2b5dfd3bb3879bbd6ab76fd5dc Mon Sep 17 00:00:00 2001
From: Lucas Mirelmann <lgalfaso@gmail.com>
Date: Fri, 14 Apr 2017 23:08:06 +0200
Subject: [PATCH 004/329] Fix typo (#460)

---
 interpreter/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index d9d0e06e8..07beedf5d 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -255,7 +255,7 @@ data:    ( data <var>? ( offset <instr>* ) <string>* )
 
 start:   ( start <var> )
 
-typedef: ( type <name>? ( func <funcsig> ) )
+typedef: ( type <name>? ( func <func_sig> ) )
 
 import:  ( import <string> <string> <imkind> )
 imkind:  ( func <name>? <func_sig> )

From 1f3e57989f733a116650446d17d02de6b4434931 Mon Sep 17 00:00:00 2001
From: Lucas Mirelmann <lgalfaso@gmail.com>
Date: Mon, 17 Apr 2017 19:27:53 +0200
Subject: [PATCH 005/329] Fix typo (#462)

Fix typo
---
 interpreter/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 07beedf5d..71df5f5b4 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -231,7 +231,7 @@ op:
   <type>.<cvtop>/<type>
 
 func:    ( func <name>? <func_sig> <local>* <instr>* )
-         ( func <name>? ( export <string> ) <func_sig> <local>* <instrr>* ) ;; = (export <string> (func <N>) (func <name>? <func_sig> <local>* <instr>*)
+         ( func <name>? ( export <string> ) <func_sig> <local>* <instr>* )  ;; = (export <string> (func <N>) (func <name>? <func_sig> <local>* <instr>*)
          ( func <name>? ( import <string> <string> ) <func_sig>)            ;; = (import <name>? <string> <string> (func <func_sig>))
 param:   ( param <type>* ) | ( param <name> <type> )
 result:  ( result <type> )

From 8f26284031f977e3086ec6f364252a494eeadfc1 Mon Sep 17 00:00:00 2001
From: Lucas Mirelmann <lgalfaso@gmail.com>
Date: Mon, 17 Apr 2017 22:25:59 +0200
Subject: [PATCH 006/329] Fix typo (#463)

Fix typo
---
 interpreter/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 71df5f5b4..04fd33d7b 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -231,7 +231,7 @@ op:
   <type>.<cvtop>/<type>
 
 func:    ( func <name>? <func_sig> <local>* <instr>* )
-         ( func <name>? ( export <string> ) <func_sig> <local>* <instr>* )  ;; = (export <string> (func <N>) (func <name>? <func_sig> <local>* <instr>*)
+         ( func <name>? ( export <string> ) <func_sig> <local>* <instr>* )  ;; = (export <string> (func <N>)) (func <name>? <func_sig> <local>* <instr>*)
          ( func <name>? ( import <string> <string> ) <func_sig>)            ;; = (import <name>? <string> <string> (func <func_sig>))
 param:   ( param <type>* ) | ( param <name> <type> )
 result:  ( result <type> )

From bac6e941659336dc6d6519b80a1917932a28e3dd Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 19 Apr 2017 13:07:11 +0200
Subject: [PATCH 007/329] Tweak grammar for func_sig

---
 interpreter/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 04fd33d7b..c0b42b775 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -181,7 +181,7 @@ align: align=(1|2|4|8|...)
 cvtop: trunc_s | trunc_u | extend_s | extend_u | ...
 
 block_sig : <type>*
-func_sig:   ( type <var> ) | <param>* <result>*
+func_sig:   ( type <var> )? <param>* <result>*
 global_sig: <type> | ( mut <type> )
 table_sig:  <nat> <nat>? <elem_type>
 memory_sig: <nat> <nat>?

From 968329b5178eed1548a3342a6c922adcd3a97a7b Mon Sep 17 00:00:00 2001
From: Andrew Scheidecker <andrew@scheidecker.net>
Date: Wed, 19 Apr 2017 07:59:23 -0400
Subject: [PATCH 008/329] Fix import-after-global.fail test (#464)

---
 test/core/import-after-global.fail.wast | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/core/import-after-global.fail.wast b/test/core/import-after-global.fail.wast
index 09cece1a0..348ef2703 100644
--- a/test/core/import-after-global.fail.wast
+++ b/test/core/import-after-global.fail.wast
@@ -1 +1 @@
-(module (global i64) (import "" "" (table 0 anyfunc)))
+(module (global i64 (i64.const 0)) (import "" "" (table 0 anyfunc)))

From c11a7ad9e79d873744e4b94377261b3b526f2791 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 19 Apr 2017 18:26:28 +0200
Subject: [PATCH 009/329] Add tests for malformed global initializer
 expressions (#465)

---
 test/core/globals.wast | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/test/core/globals.wast b/test/core/globals.wast
index 9e90bb552..9eb594057 100644
--- a/test/core/globals.wast
+++ b/test/core/globals.wast
@@ -81,11 +81,36 @@
   "constant expression required"
 )
 
+(assert_invalid
+  (module (global f32 (f32.neg (f32.const 1))))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (i32.const 0) (nop)))
+  "constant expression required"
+)
+
+(assert_invalid
+  (module (global i32 (nop)))
+  "constant expression required"
+)
+
 (assert_invalid
   (module (global i32 (f32.const 0)))
   "type mismatch"
 )
 
+(assert_invalid
+  (module (global i32 (i32.const 0) (i32.const 0)))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (global i32 (;empty instruction sequence;)))
+  "type mismatch"
+)
+
 (assert_invalid
   (module (global i32 (get_global 0)))
   "unknown global"

From dc46f28037349881635b9aa5208858a4b3182406 Mon Sep 17 00:00:00 2001
From: Michael Ferris <mike.ferris@hotmail.com>
Date: Wed, 19 Apr 2017 16:55:24 -0700
Subject: [PATCH 010/329] Add memory trapping tests for lower bound as well and
 test load as well as stores (#459)

---
 test/core/memory_trap.wast | 343 +++++++++++++++++++++++--------------
 1 file changed, 214 insertions(+), 129 deletions(-)

diff --git a/test/core/memory_trap.wast b/test/core/memory_trap.wast
index 26f100e21..5fd193de2 100644
--- a/test/core/memory_trap.wast
+++ b/test/core/memory_trap.wast
@@ -32,19 +32,71 @@
 (assert_trap (invoke "load" (i32.const 0x80000000)) "out of bounds memory access")
 (assert_return (invoke "grow_memory" (i32.const 0x10001)) (i32.const -1))
 
-
 (module
   (memory 1)
+  (data (i32.const 0) "abcdefgh")
+  (data (i32.const 0xfff8) "abcdefgh")
 
+  (func (export "i32.load") (param $a i32) (result i32)
+    (i32.load (get_local $a))
+  )
+  (func (export "i64.load") (param $a i32) (result i64)
+    (i64.load (get_local $a))
+  )
+  (func (export "f32.load") (param $a i32) (result f32)
+    (f32.load (get_local $a))
+  )
+  (func (export "f64.load") (param $a i32) (result f64)
+    (f64.load (get_local $a))
+  )
+  (func (export "i32.load8_s") (param $a i32) (result i32)
+    (i32.load8_s (get_local $a))
+  )
+  (func (export "i32.load8_u") (param $a i32) (result i32)
+    (i32.load8_u (get_local $a))
+  )
+  (func (export "i32.load16_s") (param $a i32) (result i32)
+    (i32.load16_s (get_local $a))
+  )
+  (func (export "i32.load16_u") (param $a i32) (result i32)
+    (i32.load16_u (get_local $a))
+  )
+  (func (export "i64.load8_s") (param $a i32) (result i64)
+    (i64.load8_s (get_local $a))
+  )
+  (func (export "i64.load8_u") (param $a i32) (result i64)
+    (i64.load8_u (get_local $a))
+  )
+  (func (export "i64.load16_s") (param $a i32) (result i64)
+    (i64.load16_s (get_local $a))
+  )
+  (func (export "i64.load16_u") (param $a i32) (result i64)
+    (i64.load16_u (get_local $a))
+  )
+  (func (export "i64.load32_s") (param $a i32) (result i64)
+    (i64.load32_s (get_local $a))
+  )
+  (func (export "i64.load32_u") (param $a i32) (result i64)
+    (i64.load32_u (get_local $a))
+  )
+  (func (export "i32.store") (param $a i32) (param $v i32)
+    (i32.store (get_local $a) (get_local $v))
+  )
+  (func (export "i64.store") (param $a i32) (param $v i64)
+    (i64.store (get_local $a) (get_local $v))
+  )
+  (func (export "f32.store") (param $a i32) (param $v f32)
+    (f32.store (get_local $a) (get_local $v))
+  )
+  (func (export "f64.store") (param $a i32) (param $v f64)
+    (f64.store (get_local $a) (get_local $v))
+  )
   (func (export "i32.store8") (param $a i32) (param $v i32)
     (i32.store8 (get_local $a) (get_local $v))
   )
   (func (export "i32.store16") (param $a i32) (param $v i32)
     (i32.store16 (get_local $a) (get_local $v))
   )
-  (func (export "i32.store") (param $a i32) (param $v i32)
-    (i32.store (get_local $a) (get_local $v))
-  )
   (func (export "i64.store8") (param $a i32) (param $v i64)
     (i64.store8 (get_local $a) (get_local $v))
   )
@@ -54,132 +106,165 @@
   (func (export "i64.store32") (param $a i32) (param $v i64)
     (i64.store32 (get_local $a) (get_local $v))
   )
-  (func (export "i64.store") (param $a i32) (param $v i64)
-    (i64.store (get_local $a) (get_local $v))
-  )
-  (func (export "f32.store") (param $a i32) (param $v i32)
-    (f32.store (get_local $a) (f32.reinterpret/i32 (get_local $v)))
-  )
-  (func (export "f64.store") (param $a i32) (param $v i64)
-    (f64.store (get_local $a) (f64.reinterpret/i64 (get_local $v)))
-  )
-
-  (func (export "i64.load") (param $a i32) (result i64)
-    (i64.load (get_local $a))
-  )
-)
-
-(assert_trap
-  (invoke "i32.store8" (i32.const 0x10000) (i32.const 0x01234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i32.store16" (i32.const 0xffff) (i32.const 0x01234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i32.store" (i32.const 0xffff) (i32.const 0x01234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i32.store" (i32.const 0xfffe) (i32.const 0x01234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i32.store" (i32.const 0xfffd) (i32.const 0x01234567))
-  "out of bounds memory access"
 )
 
-(assert_trap
-  (invoke "i64.store8" (i32.const 0x10000) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i64.store16" (i32.const 0xffff) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i64.store32" (i32.const 0xffff) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i64.store32" (i32.const 0xfffe) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i64.store32" (i32.const 0xfffd) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i64.store" (i32.const 0xffff) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i64.store" (i32.const 0xfffe) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i64.store" (i32.const 0xfffd) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i64.store" (i32.const 0xfffc) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i64.store" (i32.const 0xfffb) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i64.store" (i32.const 0xfffa) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "i64.store" (i32.const 0xfff9) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-
-(assert_trap
-  (invoke "f32.store" (i32.const 0xffff) (i32.const 0x01234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "f32.store" (i32.const 0xfffe) (i32.const 0x01234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "f32.store" (i32.const 0xfffd) (i32.const 0x01234567))
-  "out of bounds memory access"
-)
-
-(assert_trap
-  (invoke "f64.store" (i32.const 0xffff) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "f64.store" (i32.const 0xfffe) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "f64.store" (i32.const 0xfffd) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "f64.store" (i32.const 0xfffc) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "f64.store" (i32.const 0xfffb) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "f64.store" (i32.const 0xfffa) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
-(assert_trap
-  (invoke "f64.store" (i32.const 0xfff9) (i64.const 0x0123456701234567))
-  "out of bounds memory access"
-)
+(assert_trap (invoke "i32.store" (i32.const 0x10000) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const 0xffff) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const 0xfffe) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const 0xfffd) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const -1) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const -2) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const -3) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store" (i32.const -4) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0x10000) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xffff) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfffe) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfffd) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfffc) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfffb) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfffa) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const 0xfff9) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -1) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -2) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -3) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -4) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -5) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -6) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -7) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store" (i32.const -8) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const 0x10000) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const 0xffff) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const 0xfffe) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const 0xfffd) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const -1) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const -2) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const -3) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f32.store" (i32.const -4) (f32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0x10000) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xffff) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfffe) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfffd) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfffc) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfffb) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfffa) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const 0xfff9) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -1) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -2) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -3) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -4) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -5) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -6) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -7) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "f64.store" (i32.const -8) (f64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store8" (i32.const 0x10000) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store8" (i32.const -1) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store16" (i32.const 0x10000) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store16" (i32.const 0xffff) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store16" (i32.const -1) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.store16" (i32.const -2) (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store8" (i32.const 0x10000) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store8" (i32.const -1) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store16" (i32.const 0x10000) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store16" (i32.const 0xffff) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store16" (i32.const -1) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store16" (i32.const -2) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const 0x10000) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const 0xffff) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const 0xfffe) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const 0xfffd) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const -1) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const -2) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const -3) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i64.store32" (i32.const -4) (i64.const 0)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "i32.load" (i32.const -4)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfffc)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfffb)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfffa)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const 0xfff9)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -4)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -5)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -6)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -7)) "out of bounds memory access")
+(assert_trap (invoke "i64.load" (i32.const -8)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "f32.load" (i32.const -4)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfffc)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfffb)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfffa)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const 0xfff9)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -4)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -5)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -6)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -7)) "out of bounds memory access")
+(assert_trap (invoke "f64.load" (i32.const -8)) "out of bounds memory access")
+(assert_trap (invoke "i32.load8_s" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i32.load8_s" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i32.load8_u" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i32.load8_u" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_s" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_s" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_s" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_s" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_u" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_u" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_u" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i32.load16_u" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load8_s" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load8_s" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load8_u" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load8_u" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_s" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_s" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_s" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_s" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_u" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_u" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_u" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load16_u" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_s" (i32.const -4)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const 0x10000)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const 0xffff)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const 0xfffe)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const 0xfffd)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const -1)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const -2)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const -3)) "out of bounds memory access")
+(assert_trap (invoke "i64.load32_u" (i32.const -4)) "out of bounds memory access")
 
 ;; No memory was changed
-(assert_return (invoke "i64.load" (i32.const 0xfff8)) (i64.const 0))
+(assert_return (invoke "i64.load" (i32.const 0xfff8)) (i64.const 0x6867666564636261))
+(assert_return (invoke "i64.load" (i32.const 0)) (i64.const 0x6867666564636261))

From 671b08d0e72829acf512f8fbb5c1e007ca65ae94 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 20 Apr 2017 12:25:49 +0200
Subject: [PATCH 011/329] Update PLDI paper to final version

---
 papers/pldi2017.pdf | Bin 2485248 -> 2486556 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/papers/pldi2017.pdf b/papers/pldi2017.pdf
index 4af4d7323750cd8ea54b98055013c38f420624a8..ee581fc6a38b4ebac01994062cbb90b1ddd3047d 100644
GIT binary patch
delta 135962
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%0AZdlcJu%(3j(OeFgbca76OsC`T;{HNF=RX?3
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
Px^y(>X+cmjt~BjmMl(1X

delta 134770
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%0Aiy_
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


From 35bbfa571f81eff3d3b247facf9ce41348f77ec9 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 26 Apr 2017 08:45:51 +0200
Subject: [PATCH 012/329] [document] Specify binary format (#455)

---
 document/Makefile                |   2 +-
 document/binary/conventions.rst  |  98 ++++++
 document/binary/index.rst        |   2 +-
 document/binary/instructions.rst | 385 ++++++++++++++++++++++++
 document/binary/modules.rst      | 492 +++++++++++++++++++++++++++++++
 document/binary/types.rst        | 149 ++++++++++
 document/binary/values.rst       | 166 +++++++++++
 document/math.def                | 122 +++++++-
 document/syntax/modules.rst      |  13 +-
 document/syntax/types.rst        |   1 +
 document/syntax/values.rst       |  26 +-
 document/validation/modules.rst  |   8 +-
 12 files changed, 1438 insertions(+), 26 deletions(-)
 create mode 100644 document/binary/conventions.rst
 create mode 100644 document/binary/instructions.rst
 create mode 100644 document/binary/modules.rst
 create mode 100644 document/binary/types.rst
 create mode 100644 document/binary/values.rst

diff --git a/document/Makefile b/document/Makefile
index 5df0df135..ea7776e14 100644
--- a/document/Makefile
+++ b/document/Makefile
@@ -92,7 +92,7 @@ html:
 	for file in `ls $(BUILDDIR)/html/*/*.html`; \
 	do \
 	  sed s:BASEDIR:..:g <$$file >$$file.out; \
-	  sed 's;<body;<script type="text/javascript">MathJax.Hub.Config({TeX: {MAXBUFFER: 10*1024}})</script><body;' \
+	  sed 's;<body;<script type="text/javascript">MathJax.Hub.Config({TeX: {MAXBUFFER: 30*1024}})</script><body;' \
 	    <$$file.out >$$file; \
 	  rm -f $$file.out; \
 	done
diff --git a/document/binary/conventions.rst b/document/binary/conventions.rst
new file mode 100644
index 000000000..c48bc8484
--- /dev/null
+++ b/document/binary/conventions.rst
@@ -0,0 +1,98 @@
+.. index:: ! binary format
+
+Conventions
+-----------
+
+The binary format for WebAssembly :ref:`modules <modules>` is a dense linear *encoding* of their :ref:`abstract syntax <syntax-module>`.
+[#compression]_
+
+The format is defined by an *attribute grammar* whose only terminal symbols are :ref:`bytes <syntax-byte>`.
+A byte sequence is a well-formed encoding of a module if and only if it is generated by the grammar.
+
+Each production of this grammar has exactly one synthesized attribute: the abstract syntax that the respective byte sequence encodes.
+Thus, the attribute grammar implicitly defines a *decoding* function.
+
+Except for a few exceptions, the binary grammar closely mirrors the grammar of the abstract syntax.
+
+.. note::
+   Some phrases of abstract syntax have multiple possible encodings in the binary format.
+   For example, numbers may be encoded as if they had optional leading zeros.
+   Implementations of decoders must support all possible alternatives;
+   implementations of encoders can pick any one allowed encoding.
+
+.. [#compression]
+   Additional encoding layers -- for example, introducing compression -- may be defined on top of the basic representation defined here.
+   However, such layers are outside the scope of the current specification.
+
+
+.. _binary-grammar:
+.. index:: grammar notation, notation, byte
+   single: binary format; grammar
+   pair: binary format; notation
+
+Grammar
+~~~~~~~
+
+The following conventions are adopted in defining grammar rules for the binary format.
+They mirror the conventions used for :ref:`abstract syntax <grammar>`.
+In order to distinguish symbols of the binary syntax from symbols of the abstract syntax, typewriter font is adopted for the former.
+
+* Terminal symbols are :ref:`bytes <syntax-byte>` expressed in hexadecimal notation: :math:`\hex{0F}`.
+
+* Nonterminal symbols are written in typewriter font: :math:`\B{valtype}, \B{instr}`.
+
+* :math:`B^n` is a sequence of :math:`n\geq 0` iterations  of :math:`B`.
+
+* :math:`B^\ast` is a possibly empty sequence of iterations of :math:`B`.
+  (This is a shorthand for :math:`A^n` used where :math:`n` is not relevant.)
+
+* :math:`B^?` is an optional occurrence of :math:`B`.
+  (This is a shorthand for :math:`A^n` where :math:`n \leq 1`.)
+
+* :math:`x{:}B` denotes the same language as the nonterminal :math:`B`, but also binds the variable :math:`x` to the attribute synthesized for :math:`B`.
+
+* Productions are written :math:`\B{name} ::= B \Rightarrow A`, where :math:`A` is the attribute that is synthesized for :math:`\B{name}`, usually from attribute variables bound in :math:`B`.
+
+* Some productions are augmented by side conditions in parentheses, which restrict the applicability of the production. They provide a shorthand for a combinatorial expansion of the production into many separate cases.
+
+.. note::
+   For example, the :ref:`binary grammar <binary-valtype>` for :ref:`value types <syntax-valtype>` is given as follows:
+
+   .. math::
+     \begin{array}{llcll@{\qquad\qquad}l}
+     \production{value types} & \Bvaltype &::=&
+       \hex{7F} &\Rightarrow& \I32 \\ &&|&
+       \hex{7E} &\Rightarrow& \I64 \\ &&|&
+       \hex{7D} &\Rightarrow& \F32 \\ &&|&
+       \hex{7C} &\Rightarrow& \F64 \\
+     \end{array}
+
+   Consequently, the byte :math:`\hex{7F}` encodes the type |I32|,
+   :math:`\hex{7E}` encodes the type |I64|, and so forth.
+   No other byte value is allowed as the encoding of a value type.
+
+   The :ref:`binary grammar <binary-limits>` for :ref:`limits <syntax-limits>` is defined as follows:   
+
+   .. math::
+      \begin{array}{llclll}
+      \production{limits} & \Blimits &::=&
+        \hex{00}~~n{:}\Bu32 &\Rightarrow& \{ \MIN~n, \MAX~\epsilon \} \\ &&|&
+        \hex{01}~~n{:}\Bu32~~m{:}\Bu32 &\Rightarrow& \{ \MIN~n, \MAX~m \} \\
+      \end{array}
+
+   That is, a limits pair is encoded as either the byte :math:`\hex{00}` followed by the encoding of a |U32| value,
+   or the byte :math:`\hex{01}` followed by two such encodings. 
+   The variables :math:`n` and :math:`m` name the attributes of the respective |Bu32| nonterminals, which in this case are the actual :ref:`unsigned integers <syntax-uint>` they decode into.
+   The attribute of the complete production then is the abstract syntax for the limit, expressed in terms of the former values.
+
+
+.. _binary-notation:
+
+Auxiliary Notation
+~~~~~~~~~~~~~~~~~~
+
+When dealing with binary encodings the following notation is also used:
+
+* :math:`\epsilon` denotes the empty byte sequence.
+
+* :math:`||B||` is the length of the byte sequence generated from the production :math:`B` in a derivation.
diff --git a/document/binary/index.rst b/document/binary/index.rst
index ce1879dde..89a61d9c2 100644
--- a/document/binary/index.rst
+++ b/document/binary/index.rst
@@ -9,5 +9,5 @@ Binary Format
    conventions
    values
    types
-   modules
    instructions
+   modules
diff --git a/document/binary/instructions.rst b/document/binary/instructions.rst
new file mode 100644
index 000000000..945b391e8
--- /dev/null
+++ b/document/binary/instructions.rst
@@ -0,0 +1,385 @@
+.. _binary-instr:
+.. index:: instruction, ! opcode
+
+Instructions
+------------
+
+:ref:`Instructions <syntax-instr>` are encoded by *opcodes*.
+Each opcode is represented by a single byte,
+and is followed by the instruction's immediate arguments, where present.
+The only exception are :ref:`structured control instructions <binary-instr-control>`, which consist of several opcodes bracketing their nested instruction sequences.
+
+.. note::
+   Gaps in the byte code ranges encoding instructions are reserved for future extensions.
+
+
+.. _binary-instr-control:
+.. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, polymorphism
+   pair: binary format; instruction
+   single: abstract syntax; instruction
+
+Control Instructions
+~~~~~~~~~~~~~~~~~~~~
+
+:ref:`Control instructions <syntax-instr-control>` have varying encodings. For structured instructions, the nested instruction sequences are terminated with explicit opcodes for |END| and |ELSE|.
+
+.. _valid-nop:
+.. _valid-unreachable:
+.. _valid-block:
+.. _valid-loop:
+.. _valid-if:
+.. _valid-br:
+.. _valid-br_if:
+.. _valid-br_table:
+.. _valid-return:
+.. _valid-call:
+.. _valid-call_indirect:
+
+.. math::
+   \begin{array}{llclll}
+   \production{instructions} & \Binstr &::=&
+     \hex{00} &\Rightarrow& \UNREACHABLE \\ &&|&
+     \hex{01} &\Rightarrow& \NOP \\ &&|&
+     \hex{02}~~\X{rt}{:}\Bblocktype~~(\X{in}{:}\Binstr)^\ast~~\hex{0B}
+       &\Rightarrow& \BLOCK~\X{rt}~\X{in}^\ast~\END \\ &&|&
+     \hex{03}~~\X{rt}{:}\Bblocktype~~(\X{in}{:}\Binstr)^\ast~~\hex{0B}
+       &\Rightarrow& \LOOP~\X{rt}~\X{in}^\ast~\END \\ &&|&
+     \hex{04}~~\X{rt}{:}\Bblocktype~~(\X{in}{:}\Binstr)^\ast~~\hex{0B}
+       &\Rightarrow& \IF~\X{rt}~\X{in}^\ast~\ELSE~\epsilon~\END \\ &&|&
+     \hex{04}~~\X{rt}{:}\Bblocktype~~(\X{in}_1{:}\Binstr)^\ast~~
+       \hex{05}~~(\X{in}_2{:}\Binstr)^\ast~~\hex{0B}
+       &\Rightarrow& \IF~\X{rt}~\X{in}_1^\ast~\ELSE~\X{in}_2^\ast~\END \\ &&|&
+     \hex{0C}~~l{:}\Blabelidx &\Rightarrow& \BR~l \\ &&|&
+     \hex{0D}~~l{:}\Blabelidx &\Rightarrow& \BRIF~l \\ &&|&
+     \hex{0E}~~l^\ast{:}\Bvec(\Blabelidx)~~l_N{:}\Blabelidx &\Rightarrow&
+       \BRTABLE~l^\ast~l_N \\ &&|&
+     \hex{0F} &\Rightarrow& \RETURN \\ &&|&
+     \hex{10}~~x{:}\Bfuncidx &\Rightarrow& \CALL~x \\ &&|&
+     \hex{11}~~x{:}\Btypeidx &\Rightarrow& \CALLINDIRECT~x \\
+   \end{array}
+
+.. note::
+   The |ELSE| opcode :math:`\hex{05}` in the encoding of an |IF| instruction can be omitted if the following instruction sequence is empty.
+
+
+.. _binary-instr-parametric:
+.. index:: value type, polymorphism
+   pair: binary format; instruction
+   single: abstract syntax; instruction
+
+Parametric Instructions
+~~~~~~~~~~~~~~~~~~~~~~~
+
+:ref:`Parametric instructions <syntax-instr-parametric>` are represented by single byte codes.
+
+.. _binary-drop:
+.. _binary-select:
+
+.. math::
+   \begin{array}{llclll}
+   \production{instructions} & \Binstr &::=& \dots \\ &&|&
+     \hex{1A} &\Rightarrow& \DROP \\ &&|&
+     \hex{1B} &\Rightarrow& \SELECT \\
+   \end{array}
+
+
+.. _binary-instr-variable:
+.. index:: variable instructions, local index, global index
+   pair: binary format; instruction
+   single: abstract syntax; instruction
+
+Variable Instructions
+~~~~~~~~~~~~~~~~~~~~~
+
+:ref:`Variable instructions <syntax-instr-variable>` are represented by byte codes followed by the encoding of the respective :ref:`index <syntax-indices>`.
+
+.. _binary-get_local:
+.. _binary-set_local:
+.. _binary-tee_local:
+.. _binary-get_global:
+.. _binary-set_global:
+
+.. math::
+   \begin{array}{llclll}
+   \production{instructions} & \Binstr &::=& \dots \\ &&|&
+     \hex{20}~~x{:}\Blocalidx &\Rightarrow& \GETLOCAL~x \\ &&|&
+     \hex{21}~~x{:}\Blocalidx &\Rightarrow& \SETLOCAL~x \\ &&|&
+     \hex{22}~~x{:}\Blocalidx &\Rightarrow& \TEELOCAL~x \\ &&|&
+     \hex{23}~~x{:}\Bglobalidx &\Rightarrow& \GETGLOBAL~x \\ &&|&
+     \hex{24}~~x{:}\Bglobalidx &\Rightarrow& \SETGLOBAL~x \\
+   \end{array}
+
+
+.. _binary-instr-memory:
+.. _binary-memarg:
+.. index:: memory instruction, memory index
+   pair: validation; instruction
+   single: abstract syntax; instruction
+
+Memory Instructions
+~~~~~~~~~~~~~~~~~~~
+
+Each variant of :ref:`memory instruction <syntax-instr-memory>` is encoded with a different byte code. Loads and stores are followed by the encoding of their |memarg| immediate.
+
+.. _binary-memarg:
+.. _binary-load:
+.. _binary-loadn:
+.. _binary-store:
+.. _binary-storen:
+.. _binary-current_memory:
+.. _binary-grow_memory:
+
+.. math::
+   \begin{array}{llclll}
+   \production{memory arguments} & \Bmemarg &::=&
+     a{:}\Bu32~~o{:}\Bu32 &\Rightarrow& \{ \ALIGN~a,~\OFFSET~o \} \\
+   \production{instructions} & \Binstr &::=& \dots \\ &&|&
+     \hex{28}~~m{:}\Bmemarg &\Rightarrow& \I32.\LOAD~m \\ &&|&
+     \hex{29}~~m{:}\Bmemarg &\Rightarrow& \I64.\LOAD~m \\ &&|&
+     \hex{2A}~~m{:}\Bmemarg &\Rightarrow& \F32.\LOAD~m \\ &&|&
+     \hex{2B}~~m{:}\Bmemarg &\Rightarrow& \F64.\LOAD~m \\ &&|&
+     \hex{2C}~~m{:}\Bmemarg &\Rightarrow& \I32.\LOAD\K{8\_s}~m \\ &&|&
+     \hex{2D}~~m{:}\Bmemarg &\Rightarrow& \I32.\LOAD\K{8\_u}~m \\ &&|&
+     \hex{2E}~~m{:}\Bmemarg &\Rightarrow& \I32.\LOAD\K{16\_s}~m \\ &&|&
+     \hex{2F}~~m{:}\Bmemarg &\Rightarrow& \I32.\LOAD\K{16\_u}~m \\ &&|&
+     \hex{30}~~m{:}\Bmemarg &\Rightarrow& \I64.\LOAD\K{8\_s}~m \\ &&|&
+     \hex{31}~~m{:}\Bmemarg &\Rightarrow& \I64.\LOAD\K{8\_u}~m \\ &&|&
+     \hex{32}~~m{:}\Bmemarg &\Rightarrow& \I64.\LOAD\K{16\_s}~m \\ &&|&
+     \hex{33}~~m{:}\Bmemarg &\Rightarrow& \I64.\LOAD\K{16\_u}~m \\ &&|&
+     \hex{34}~~m{:}\Bmemarg &\Rightarrow& \I64.\LOAD\K{32\_s}~m \\ &&|&
+     \hex{35}~~m{:}\Bmemarg &\Rightarrow& \I64.\LOAD\K{32\_u}~m \\ &&|&
+     \hex{36}~~m{:}\Bmemarg &\Rightarrow& \I32.\STORE~m \\ &&|&
+     \hex{37}~~m{:}\Bmemarg &\Rightarrow& \I64.\STORE~m \\ &&|&
+     \hex{38}~~m{:}\Bmemarg &\Rightarrow& \F32.\STORE~m \\ &&|&
+     \hex{39}~~m{:}\Bmemarg &\Rightarrow& \F64.\STORE~m \\ &&|&
+     \hex{3A}~~m{:}\Bmemarg &\Rightarrow& \I32.\STORE\K{8}~m \\ &&|&
+     \hex{3B}~~m{:}\Bmemarg &\Rightarrow& \I32.\STORE\K{16}~m \\ &&|&
+     \hex{3C}~~m{:}\Bmemarg &\Rightarrow& \I64.\STORE\K{8}~m \\ &&|&
+     \hex{3D}~~m{:}\Bmemarg &\Rightarrow& \I64.\STORE\K{16}~m \\ &&|&
+     \hex{3E}~~m{:}\Bmemarg &\Rightarrow& \I64.\STORE\K{32}~m \\ &&|&
+     \hex{3F}~~\hex{00} &\Rightarrow& \CURRENTMEMORY \\ &&|&
+     \hex{40}~~\hex{00} &\Rightarrow& \GROWMEMORY \\
+   \end{array}
+
+.. note::
+   In future versions of WebAssembly, the additional zero bytes occurring in the encoding of the |CURRENTMEMORY| and |GROWMEMORY| instructions may be used to index additional memories.
+
+
+.. _binary-instr-numeric:
+.. index:: numeric instruction
+   pair: binary format; instruction
+   single: abstract syntax; instruction
+
+Numeric Instructions
+~~~~~~~~~~~~~~~~~~~~
+
+All variants of :ref:`numeric instructions <syntax-instr-numeric>` are represented by separate byte codes.
+
+The |CONST| instructions are followed by the respective literal.
+
+.. _binary-const:
+
+.. math::
+   \begin{array}{llclll}
+   \production{instructions} & \Binstr &::=& \dots \\&&|&
+     \hex{41}~~n{:}\Bi32 &\Rightarrow& \I32.\CONST~n \\ &&|&
+     \hex{42}~~n{:}\Bi64 &\Rightarrow& \I64.\CONST~n \\ &&|&
+     \hex{43}~~z{:}\Bf32 &\Rightarrow& \F32.\CONST~z \\ &&|&
+     \hex{44}~~z{:}\Bf64 &\Rightarrow& \F64.\CONST~z \\
+   \end{array}
+
+All other numeric instructions are plain opcodes without any immediates.
+
+.. _binary-testop:
+.. _binary-relop:
+
+.. math::
+   \begin{array}{llclll}
+   \production{instructions} & \Binstr &::=& \dots && \phantom{thisshouldbeenough} \\&&|&
+     \hex{45} &\Rightarrow& \I32.\EQZ \\ &&|&
+     \hex{46} &\Rightarrow& \I32.\EQ \\ &&|&
+     \hex{47} &\Rightarrow& \I32.\NE \\ &&|&
+     \hex{48} &\Rightarrow& \I32.\LT\K{\_s} \\ &&|&
+     \hex{49} &\Rightarrow& \I32.\LT\K{\_u} \\ &&|&
+     \hex{4A} &\Rightarrow& \I32.\GT\K{\_s} \\ &&|&
+     \hex{4B} &\Rightarrow& \I32.\GT\K{\_u} \\ &&|&
+     \hex{4C} &\Rightarrow& \I32.\LE\K{\_s} \\ &&|&
+     \hex{4D} &\Rightarrow& \I32.\LE\K{\_u} \\ &&|&
+     \hex{4E} &\Rightarrow& \I32.\GE\K{\_s} \\ &&|&
+     \hex{4F} &\Rightarrow& \I32.\GE\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \hex{50} &\Rightarrow& \I64.\EQZ \\ &&|&
+     \hex{51} &\Rightarrow& \I64.\EQ \\ &&|&
+     \hex{52} &\Rightarrow& \I64.\NE \\ &&|&
+     \hex{53} &\Rightarrow& \I64.\LT\K{\_s} \\ &&|&
+     \hex{54} &\Rightarrow& \I64.\LT\K{\_u} \\ &&|&
+     \hex{55} &\Rightarrow& \I64.\GT\K{\_s} \\ &&|&
+     \hex{56} &\Rightarrow& \I64.\GT\K{\_u} \\ &&|&
+     \hex{57} &\Rightarrow& \I64.\LE\K{\_s} \\ &&|&
+     \hex{58} &\Rightarrow& \I64.\LE\K{\_u} \\ &&|&
+     \hex{59} &\Rightarrow& \I64.\GE\K{\_s} \\ &&|&
+     \hex{5A} &\Rightarrow& \I64.\GE\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \hex{5B} &\Rightarrow& \F32.\EQ \\ &&|&
+     \hex{5C} &\Rightarrow& \F32.\NE \\ &&|&
+     \hex{5D} &\Rightarrow& \F32.\LT \\ &&|&
+     \hex{5E} &\Rightarrow& \F32.\GT \\ &&|&
+     \hex{5F} &\Rightarrow& \F32.\LE \\ &&|&
+     \hex{60} &\Rightarrow& \F32.\GE \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \hex{61} &\Rightarrow& \F64.\EQ \\ &&|&
+     \hex{62} &\Rightarrow& \F64.\NE \\ &&|&
+     \hex{63} &\Rightarrow& \F64.\LT \\ &&|&
+     \hex{64} &\Rightarrow& \F64.\GT \\ &&|&
+     \hex{65} &\Rightarrow& \F64.\LE \\ &&|&
+     \hex{66} &\Rightarrow& \F64.\GE \\
+   \end{array}
+
+.. _binary-unop:
+.. _binary-binop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \hex{67} &\Rightarrow& \I32.\CLZ \\ &&|&
+     \hex{68} &\Rightarrow& \I32.\CTZ \\ &&|&
+     \hex{69} &\Rightarrow& \I32.\POPCNT \\ &&|&
+     \hex{6A} &\Rightarrow& \I32.\ADD \\ &&|&
+     \hex{6B} &\Rightarrow& \I32.\SUB \\ &&|&
+     \hex{6C} &\Rightarrow& \I32.\MUL \\ &&|&
+     \hex{6D} &\Rightarrow& \I32.\DIV\K{\_s} \\ &&|&
+     \hex{6E} &\Rightarrow& \I32.\DIV\K{\_u} \\ &&|&
+     \hex{6F} &\Rightarrow& \I32.\REM\K{\_s} \\ &&|&
+     \hex{70} &\Rightarrow& \I32.\REM\K{\_u} \\ &&|&
+     \hex{71} &\Rightarrow& \I32.\AND \\ &&|&
+     \hex{72} &\Rightarrow& \I32.\OR \\ &&|&
+     \hex{73} &\Rightarrow& \I32.\XOR \\ &&|&
+     \hex{74} &\Rightarrow& \I32.\SHL \\ &&|&
+     \hex{75} &\Rightarrow& \I32.\SHR\K{\_s} \\ &&|&
+     \hex{76} &\Rightarrow& \I32.\SHR\K{\_u} \\ &&|&
+     \hex{77} &\Rightarrow& \I32.\ROTL \\ &&|&
+     \hex{78} &\Rightarrow& \I32.\ROTR \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \hex{79} &\Rightarrow& \I64.\CLZ \\ &&|&
+     \hex{7A} &\Rightarrow& \I64.\CTZ \\ &&|&
+     \hex{7B} &\Rightarrow& \I64.\POPCNT \\ &&|&
+     \hex{7C} &\Rightarrow& \I64.\ADD \\ &&|&
+     \hex{7D} &\Rightarrow& \I64.\SUB \\ &&|&
+     \hex{7E} &\Rightarrow& \I64.\MUL \\ &&|&
+     \hex{7F} &\Rightarrow& \I64.\DIV\K{\_s} \\ &&|&
+     \hex{80} &\Rightarrow& \I64.\DIV\K{\_u} \\ &&|&
+     \hex{81} &\Rightarrow& \I64.\REM\K{\_s} \\ &&|&
+     \hex{82} &\Rightarrow& \I64.\REM\K{\_u} \\ &&|&
+     \hex{83} &\Rightarrow& \I64.\AND \\ &&|&
+     \hex{84} &\Rightarrow& \I64.\OR \\ &&|&
+     \hex{85} &\Rightarrow& \I64.\XOR \\ &&|&
+     \hex{86} &\Rightarrow& \I64.\SHL \\ &&|&
+     \hex{87} &\Rightarrow& \I64.\SHR\K{\_s} \\ &&|&
+     \hex{88} &\Rightarrow& \I64.\SHR\K{\_u} \\ &&|&
+     \hex{89} &\Rightarrow& \I64.\ROTL \\ &&|&
+     \hex{8A} &\Rightarrow& \I64.\ROTR \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \hex{8B} &\Rightarrow& \F32.\ABS \\ &&|&
+     \hex{8C} &\Rightarrow& \F32.\NEG \\ &&|&
+     \hex{8D} &\Rightarrow& \F32.\CEIL \\ &&|&
+     \hex{8E} &\Rightarrow& \F32.\FLOOR \\ &&|&
+     \hex{8F} &\Rightarrow& \F32.\TRUNC \\ &&|&
+     \hex{90} &\Rightarrow& \F32.\NEAREST \\ &&|&
+     \hex{91} &\Rightarrow& \F32.\SQRT \\ &&|&
+     \hex{92} &\Rightarrow& \F32.\ADD \\ &&|&
+     \hex{93} &\Rightarrow& \F32.\SUB \\ &&|&
+     \hex{94} &\Rightarrow& \F32.\MUL \\ &&|&
+     \hex{95} &\Rightarrow& \F32.\DIV \\ &&|&
+     \hex{96} &\Rightarrow& \F32.\FMIN \\ &&|&
+     \hex{97} &\Rightarrow& \F32.\FMAX \\ &&|&
+     \hex{98} &\Rightarrow& \F32.\COPYSIGN \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \hex{99} &\Rightarrow& \F64.\ABS \\ &&|&
+     \hex{9A} &\Rightarrow& \F64.\NEG \\ &&|&
+     \hex{9B} &\Rightarrow& \F64.\CEIL \\ &&|&
+     \hex{9C} &\Rightarrow& \F64.\FLOOR \\ &&|&
+     \hex{9D} &\Rightarrow& \F64.\TRUNC \\ &&|&
+     \hex{9E} &\Rightarrow& \F64.\NEAREST \\ &&|&
+     \hex{9F} &\Rightarrow& \F64.\SQRT \\ &&|&
+     \hex{A0} &\Rightarrow& \F64.\ADD \\ &&|&
+     \hex{A1} &\Rightarrow& \F64.\SUB \\ &&|&
+     \hex{A2} &\Rightarrow& \F64.\MUL \\ &&|&
+     \hex{A3} &\Rightarrow& \F64.\DIV \\ &&|&
+     \hex{A4} &\Rightarrow& \F64.\FMIN \\ &&|&
+     \hex{A5} &\Rightarrow& \F64.\FMAX \\ &&|&
+     \hex{A6} &\Rightarrow& \F64.\COPYSIGN \\
+   \end{array}
+
+.. _binary-cvtop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \hex{A7} &\Rightarrow& \I32.\WRAP\K{/}\I64 \\ &&|&
+     \hex{A8} &\Rightarrow& \I32.\TRUNC\K{\_s/}\F32 \\ &&|&
+     \hex{A9} &\Rightarrow& \I32.\TRUNC\K{\_u/}\F32 \\ &&|&
+     \hex{AA} &\Rightarrow& \I32.\TRUNC\K{\_s/}\F64 \\ &&|&
+     \hex{AB} &\Rightarrow& \I32.\TRUNC\K{\_u/}\F64 \\ &&|&
+     \hex{AC} &\Rightarrow& \I64.\EXTEND\K{\_s/}\I32 \\ &&|&
+     \hex{AD} &\Rightarrow& \I64.\EXTEND\K{\_u/}\I32 \\ &&|&
+     \hex{AE} &\Rightarrow& \I64.\TRUNC\K{\_s/}\F32 \\ &&|&
+     \hex{AF} &\Rightarrow& \I64.\TRUNC\K{\_u/}\F32 \\ &&|&
+     \hex{B0} &\Rightarrow& \I64.\TRUNC\K{\_s/}\F64 \\ &&|&
+     \hex{B1} &\Rightarrow& \I64.\TRUNC\K{\_u/}\F64 \\ &&|&
+     \hex{B2} &\Rightarrow& \F32.\CONVERT\K{\_s/}\I32 \\ &&|&
+     \hex{B3} &\Rightarrow& \F32.\CONVERT\K{\_u/}\I32 \\ &&|&
+     \hex{B4} &\Rightarrow& \F32.\CONVERT\K{\_s/}\I64 \\ &&|&
+     \hex{B5} &\Rightarrow& \F32.\CONVERT\K{\_u/}\I64 \\ &&|&
+     \hex{B6} &\Rightarrow& \F32.\DEMOTE\K{/}\F64 \\ &&|&
+     \hex{B7} &\Rightarrow& \F64.\CONVERT\K{\_s/}\I32 \\ &&|&
+     \hex{B8} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I32 \\ &&|&
+     \hex{B9} &\Rightarrow& \F64.\CONVERT\K{\_s/}\I64 \\ &&|&
+     \hex{BA} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I64 \\ &&|&
+     \hex{BB} &\Rightarrow& \F64.\PROMOTE\K{/}\F32 \\ &&|&
+     \hex{BC} &\Rightarrow& \I32.\REINTERPRET\K{/}\F32 \\ &&|&
+     \hex{BD} &\Rightarrow& \I64.\REINTERPRET\K{/}\F64 \\ &&|&
+     \hex{BE} &\Rightarrow& \F32.\REINTERPRET\K{/}\I32 \\ &&|&
+     \hex{BF} &\Rightarrow& \F64.\REINTERPRET\K{/}\I64 \\
+   \end{array}
+
+
+.. _binary-expr:
+.. index:: expression
+   pair: binary format; expression
+   single: abstract syntax; expression
+   single: expression; constant
+
+Expressions
+~~~~~~~~~~~
+
+:ref:`Expressions <syntax-expr>` are encoded by their instruction sequence terminated with an explicit :math:`\hex{0B}` opcode for |END|.
+
+.. math::
+   \begin{array}{llclll}
+   \production{instructions} & \Bexpr &::=&
+     (\X{in}{:}\Binstr)^\ast~~\hex{0B} &\Rightarrow& \X{in}^\ast~\END \\
+   \end{array}
diff --git a/document/binary/modules.rst b/document/binary/modules.rst
new file mode 100644
index 000000000..f520e7b88
--- /dev/null
+++ b/document/binary/modules.rst
@@ -0,0 +1,492 @@
+Modules
+-------
+
+The binary encoding of modules is organized into *sections*.
+Most sections correspond to one component of a :ref:`module <syntax-module>` record,
+except that :ref:`function definitions <syntax-func>` are split into two sections, separating their type declarations in the :ref:`function section <binary-funcsec>` from their bodies in the :ref:`code section <binary-codesec>`.
+
+.. note::
+   This separation enables *parallel* and *streaming* compilation of the functions in a module.
+
+
+.. _binary-index:
+.. _binary-typeidx:
+.. _binary-funcidx:
+.. _binary-tableidx:
+.. _binary-memidx:
+.. _binary-globalidx:
+.. _binary-localidx:
+.. _binary-labelidx:
+.. index:: index, index space, type index, function index, table index, memory index, global index, local index, label index
+   pair: binary format; type index
+   pair: binary format; function index
+   pair: binary format; table index
+   pair: binary format; memory index
+   pair: binary format; global index
+   pair: binary format; local index
+   pair: binary format; label index
+   single: abstract syntax; type index
+   single: abstract syntax; function index
+   single: abstract syntax; table index
+   single: abstract syntax; memory index
+   single: abstract syntax; global index
+   single: abstract syntax; local index
+   single: abstract syntax; label index
+
+Indices
+~~~~~~~
+
+All :ref:`indices <syntax-index>` are encoded with their respective |U32| value.
+
+.. math::
+   \begin{array}{llclll}
+   \production{type indices} & \Btypeidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{function indices} & \Bfuncidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{table indices} & \Btableidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{memory indices} & \Bmemidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{global indices} & \Bglobalidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{local indices} & \Blocalidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{label indices} & \Blabelidx &::=& l{:}\Bu32 &\Rightarrow& l \\
+   \end{array}
+
+
+.. _binary-section:
+.. index:: ! section
+   pair: binary format; section
+
+Sections
+~~~~~~~~
+
+Each section consists of
+
+* a one-byte section *id*,
+* the |U32| *size* of the contents in bytes,
+* the actual *contents*, whose structure is depended on the section id.
+
+Every section is optional; an omitted section is equivalent to the section being present with empty contents.
+
+The following parameterized grammar rule defines the generic structure of a section with id :math:`N` and contents described by the grammar :math:`\B{B}`.
+
+.. math::
+   \begin{array}{llclll@{\qquad}l}
+   \production{sections} & \Bsection_N(\B{B}) &::=&
+     N{:}\Bbyte~~\X{size}{:}\Bu32~~\X{cont}{:}\B{B}
+       &\Rightarrow& \X{cont} & (\X{size} = ||\B{B}||) \\ &&|&
+     \epsilon &\Rightarrow& \epsilon
+   \end{array}
+
+For most sections, the contents :math:`\B{B}` encodes a :ref:`vector <binary-vec>`.
+In these cases, the empty result :math:`\epsilon` is interpreted as the empty vector.
+
+.. note::
+   Other than for unknown :ref:`custom sections <binary-customsec>`,
+   the :math:`\X{size}` is not required for decoding, but can be used to skip sections when navigating through a binary.
+   The module is malformed if the size does not match the length of the binary contents :math:`\B{B}`.
+
+
+.. _binary-customsec:
+.. index:: ! custom section
+   pair: binary format; custom section
+   single: section; custom
+
+Custom Section
+~~~~~~~~~~~~~~
+
+*Custom sections* have the id 0.
+They are intended to be used for debugging information or third-party extensions, and are ignored by the WebAssembly semantics.
+Their contents consist of a :ref:`name <syntax-name>` further identifying the custom section, followed by an uninterpreted sequence of bytes for custom use.
+
+.. math::
+   \begin{array}{llclll}
+   \production{custom sections} & \Bcustomsec &::=&
+     \Bsection_0(\Bcustom) \\
+   \production{custom data} & \Bcustom &::=&
+     \Bname~~\Bbyte^\ast \\
+   \end{array}
+
+.. note::
+   If an implementation interprets the contents of a custom section, then errors in that contents, or the placement of the section, must not invalidate the module.
+
+
+.. _binary-typesec:
+.. _binary-type:
+.. index:: ! type section, type definition
+   pair: binary format; type section
+   single: abstract syntax; type definition
+   pair: section; type
+
+Type Section
+~~~~~~~~~~~~
+
+The *type section* has the id 1.
+It decodes into a vector of :ref:`function types <syntax-functype>` that represent the |TYPES| component of a :ref:`module <syntax-module>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{type sections} & \Btypesec &::=&
+     \X{ft}^\ast{:\,}\Bsection_1(\Bfunctype^\ast) &\Rightarrow& \X{ft}^\ast \\
+   \end{array}
+
+
+.. _binary-importsec:
+.. _binary-import:
+.. index:: ! import section, import, name, function type, table type, memory type, global type
+   pair: binary format; import
+   single: abstract syntax; import
+   pair: section; import
+
+Import Section
+~~~~~~~~~~~~~~
+
+The *import section* has the id 2.
+It decodes into a vector of :ref:`imports <syntax-import>` that represent the |IMPORTS| component of a :ref:`module <syntax-module>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{import sections} & \Bimportsec &::=&
+     \X{im}^\ast{:}\Bsection_2(\Bimport^\ast) &\Rightarrow& \X{im}^\ast \\
+   \production{imports} & \Bimport &::=&
+     \X{mod}{:}\Bname~~\X{nm}{:}\Bname~~d{:}\Bimportdesc
+       &\Rightarrow& \{ \MODULE~\X{mod}, \NAME~\X{nm}, \DESC~d \} \\
+   \production{import descriptions} & \Bimportdesc &::=&
+     \hex{00}~~x{:}\Btypeidx &\Rightarrow& \FUNC~x \\ &&|&
+     \hex{01}~~\X{tt}{:}\Btabletype &\Rightarrow& \TABLE~\X{tt} \\ &&|&
+     \hex{02}~~\X{mt}{:}\Bmemtype &\Rightarrow& \MEM~\X{mt} \\ &&|&
+     \hex{03}~~\X{gt}{:}\Bglobaltype &\Rightarrow& \GLOBAL~\X{gt} \\
+   \end{array}
+
+
+.. _binary-funcsec:
+.. _binary-func:
+.. index:: ! function section, function, type index, function type
+   pair: binary format; function
+   single: abstract syntax; function
+   pair: section; function
+
+Function Section
+~~~~~~~~~~~~~~~~
+
+The *function section* has the id 3.
+It decodes into a vector of :ref:`type indices <syntax-typeidx>` that represent the |TYPE| fields of the :ref:`functions <syntax-func>` in the |FUNCS| component of a :ref:`module <syntax-module>`.
+The |LOCALS| and |BODY| fields of the respective functions are encoded separately in the :ref:`code section <binary-codesec>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{function sections} & \Bfuncsec &::=&
+     x^\ast{:}\Bsection_3(\Btypeidx^\ast) &\Rightarrow& x^\ast \\
+   \end{array}
+
+
+.. _binary-tablesec:
+.. _binary-table:
+.. index:: ! table section, table, table type
+   pair: binary format; table
+   single: abstract syntax; table
+   pair: section; table
+
+Table Section
+~~~~~~~~~~~~~
+
+The *table section* has the id 4.
+It decodes into a vector of :ref:`tables <syntax-table>` that represent the |TABLES| component of a :ref:`module <syntax-module>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{table sections} & \Btablesec &::=&
+     \X{tab}^\ast{:}\Bsection_4(\Btable^\ast) &\Rightarrow& \X{tab}^\ast \\
+   \production{tables} & \Btable &::=&
+     \X{tt}{:}\Btabletype &\Rightarrow& \{ \TYPE~\X{tt} \} \\
+   \end{array}
+
+
+.. _binary-memsec:
+.. _binary-mem:
+.. index:: ! memory section, memory, memory type
+   pair: binary format; memory
+   single: abstract syntax; memory
+   pair: section; memory
+
+Memory Section
+~~~~~~~~~~~~~~
+
+The *memory section* has the id 5.
+It decodes into a vector of :ref:`memories <syntax-mem>` that represent the |MEMS| component of a :ref:`module <syntax-module>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{memory sections} & \Bmemsec &::=&
+     \X{mem}^\ast{:}\Bsection_5(\Bmem^\ast) &\Rightarrow& \X{mem}^\ast \\
+   \production{memories} & \Bmem &::=&
+     \X{mt}{:}\Bmemtype &\Rightarrow& \{ \TYPE~\X{mt} \} \\
+   \end{array}
+
+
+.. _binary-globalsec:
+.. _binary-global:
+.. index:: ! global section, global, global type, expression
+   pair: binary format; global
+   single: abstract syntax; global
+   pair: section; global
+
+Global Section
+~~~~~~~~~~~~~~
+
+The *global section* has the id 6.
+It decodes into a vector of :ref:`globals <syntax-global>` that represent the |GLOBALS| component of a :ref:`module <syntax-module>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{global sections} & \Bglobalsec &::=&
+     \X{glob}^\ast{:}\Bsection_6(\Bglobal^\ast) &\Rightarrow& \X{glob}^\ast \\
+   \production{globals} & \Bglobal &::=&
+     \X{gt}{:}\Bglobaltype~~e{:}\Bexpr
+       &\Rightarrow& \{ \TYPE~\X{gt}, \INIT~e \} \\
+   \end{array}
+
+
+.. _binary-exportsec:
+.. _binary-export:
+.. index:: ! export section, export, name, index, function index, table index, memory index, global index
+   pair: binary format; export
+   single: abstract syntax; export
+   pair: section; export
+
+Export Section
+~~~~~~~~~~~~~~
+
+The *export section* has the id 7.
+It decodes into a vector of :ref:`exports <syntax-export>` that represent the |EXPORTS| component of a :ref:`module <syntax-module>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{export sections} & \Bexportsec &::=&
+     \X{ex}^\ast{:}\Bsection_7(\Bexport^\ast) &\Rightarrow& \X{ex}^\ast \\
+   \production{exports} & \Bexport &::=&
+     \X{nm}{:}\Bname~~d{:}\Bexportdesc
+       &\Rightarrow& \{ \NAME~\X{nm}, \DESC~d \} \\
+   \production{export descriptions} & \Bexportdesc &::=&
+     \hex{00}~~x{:}\Bfuncidx &\Rightarrow& \FUNC~x \\ &&|&
+     \hex{01}~~x{:}\Btableidx &\Rightarrow& \TABLE~x \\ &&|&
+     \hex{02}~~x{:}\Bmemidx &\Rightarrow& \MEM~x \\ &&|&
+     \hex{03}~~x{:}\Bglobalidx &\Rightarrow& \GLOBAL~x \\
+   \end{array}
+
+
+.. _binary-startsec:
+.. _binary-start:
+.. index:: ! start section, start function, function index
+   pair: binary format; start function
+   single: abstract syntax; start function
+   single: section; start
+   single: start function; section
+
+Start Section
+~~~~~~~~~~~~~
+
+The *start section* has the id 8.
+It decodes into an optional :ref:`start function <syntax-start>` that represents the |START| component of a :ref:`module <syntax-module>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{start sections} & \Bstartsec &::=&
+     \X{st}^?{:}\Bsection_8(\Bstart) &\Rightarrow& \X{st}^? \\
+   \production{start functions} & \Bstart &::=&
+     x{:}\Bfuncidx &\Rightarrow& \{ \FUNC~x \} \\
+   \end{array}
+
+
+.. _binary-elemsec:
+.. _binary-elem:
+.. index:: ! element section, element, table index, expression, function index
+   pair: binary format; element
+   single: abstract syntax; element
+   pair: section; element
+   single: table; element
+   single: element; segment
+
+Element Section
+~~~~~~~~~~~~~~~
+
+The *element section* has the id 9.
+It decodes into a vector of :ref:`element segments <syntax-elem>` that represent the |ELEM| component of a :ref:`module <syntax-module>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{element sections} & \Belemsec &::=&
+     \X{seg}^\ast{:}\Bsection_9(\Belem^\ast) &\Rightarrow& \X{seg} \\
+   \production{element segments} & \Belem &::=&
+     x{:}\Btableidx~~e{:}\Bexpr~~y^\ast{:}\Bvec(\Bfuncidx)
+       &\Rightarrow& \{ \TABLE~x, \OFFSET~e, \INIT~y^\ast \} \\
+   \end{array}
+
+
+.. _binary-codesec:
+.. _binary-local:
+.. index:: ! code section, function, local, type index, function type
+   pair: binary format; function
+   single: abstract syntax; function
+   pair: section; code
+
+Code Section
+~~~~~~~~~~~~
+
+The *code section* has the id 10.
+It decodes into a vector of *code* entries that are pairs of :ref:`value type <syntax-valtype>` vectors and :ref:`expressions <syntax-expr>`.
+They represent the |LOCALS| and |BODY| field of the :ref:`functions <syntax-func>` in the |FUNCS| component of a :ref:`module <syntax-module>`.
+The |TYPE| fields of the respective functions are encoded separately in the :ref:`function section <binary-funcsec>`.
+
+The encoding of each code entry consists of
+
+* the |U32| *size* of the function code in bytes,
+* the actual *function code*, which in turn consists of
+
+  * the declaration of *locals*,
+  * the function *body* as an :ref:`expression <binary-expr>`.
+
+Local declarations are compressed into a vector whose entries consist of
+
+* a |U32| *count*,
+* a :ref:`value type <binary-valtype>`,
+
+denoting *count* locals of the same value type.
+
+.. math::
+   \begin{array}{llclll@{\qquad}l}
+   \production{code sections} & \Bcodesec &::=&
+     \X{code}^\ast{:}\Bsection_{10}(\Bcode^\ast)
+       &\Rightarrow& \X{code}^\ast \\
+   \production{code} & \Bcode &::=&
+     \X{size}{:}\Bu32~~\X{code}{:}\Bfunc
+       &\Rightarrow& \X{code} & (\X{size} = ||\Bfunc||) \\
+   \production{functions} & \Bfunc &::=&
+     (t^\ast)^\ast{:}\Bvec(\Blocals)~~e{:}\Bexpr
+       &\Rightarrow& \F{concat}((t^\ast)^\ast), e^\ast
+         & (|\F{concat}((t^\ast)^\ast)| < 2^{32}) \\
+   \production{locals} & \Blocals &::=&
+     n{:}\Bu32~~t{:}\Bvaltype &\Rightarrow& t^n \\
+   \end{array}
+
+.. math (commented out)
+   \begin{array}{llclll}
+   \production{code sections} & \Bcodesec_{\typeidx^n} &::=&
+     \f^\ast{:}\Bsection_{10}(\Bcode_{\typeidx}^n)
+       &\Rightarrow& \f^\ast \\
+   \production{code} & \Bcode_{\typeidx} &::=&
+     \X{size}{:}\Bu32~~f{:}\Bfunc_{\typeidx}
+       &\Rightarrow& f \qquad\qquad (\X{size} = |\Bfunc|) \\
+   \production{functions} & \Bfunc_{\typeidx} &::=&
+     (t^\ast)^\ast{:}\Bvec(\Blocals)~~e{:}\Bexpr &\Rightarrow&
+       \{ \TYPE~\typeidx, \LOCALS~\F{concat}((t^\ast)^\ast), \BODY~e^\ast \} \\
+   \production{locals} & \Blocals &::=&
+     n{:}\Bu32~~t{:}\Bvaltype &\Rightarrow& t^n \\
+   \end{array}
+
+Here, :math:`\X{code}` ranges over pairs :math:`(\valtype^\ast, \expr)`.
+The meta function :math:`\F{concat}((t^\ast)^\ast)` denotes the sequence of types formed by concatenating all sequences :math:`t_i^\ast` in :math:`(t^\ast)^\ast`.
+Any code for which the length of the resulting sequence is out of bounds of the maximum size of a :ref:`vector <syntax-vec>` is malformed.
+
+.. note::
+   The :math:`\X{size}` is not needed for decoding, but like with :ref:`sections <binary-section>`, can be used to skip functions when navigating through a binary.
+   The module is malformed if a size does not match the length of the respective function code.
+
+
+.. _binary-datasec:
+.. _binary-data:
+.. index:: ! data section, data, memory, memory index, expression, byte
+   pair: binary format; data
+   single: abstract syntax; data
+   pair: section; data
+   single: memory; data
+   single: data; segment
+
+Data Section
+~~~~~~~~~~~~
+
+The *data section* has the id 11.
+It decodes into a vector of :ref:`data segments <syntax-data>` that represent the |DATA| component of a :ref:`module <syntax-module>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{data sections} & \Bdatasec &::=&
+     \X{seg}^\ast{:}\Bsection_{11}(\Bdata^\ast) &\Rightarrow& \X{seg} \\
+   \production{data segments} & \Bdata &::=&
+     x{:}\Bmemidx~~e{:}\Bexpr~~b^\ast{:}\Bvec(\Bbyte)
+       &\Rightarrow& \{ \MEM~x, \OFFSET~e, \INIT~b^\ast \} \\
+   \end{array}
+
+
+.. _binary-module:
+.. _binary-magic:
+.. _binary-version:
+.. index:: module, section, type definition, function type, function, table, memory, global, element, data, start function, import, export, context, version
+   pair: binary format; module
+   single: abstract syntax; module
+
+Modules
+~~~~~~~
+
+The encoding of a :ref:`module <syntax-module>` starts with a preamble containing a 4-byte magic number and a version field.
+The current version of the WebAssembly binary format is 1.
+
+The preamble is followed by a sequence of :ref:`sections <binary-section>`.
+:ref:`Custom sections <binary-customsec>` may be inserted at any place in this sequence,
+while other sections must occur at most once and in the prescribed order.
+All sections can be empty.
+The lengths of vectors produced by the (possibly empty) :ref:`function <binary-funcsec>` and :ref:`code <binary-codesec>` section must match up.
+
+.. math::
+   \begin{array}{llcllll}
+   \production{magic} & \Bmagic &::=&
+     \hex{00}~\hex{61}~\hex{73}~\hex{6D} \\
+   \production{version} & \Bversion &::=&
+     \hex{01}~\hex{00}~\hex{00}~\hex{00} \\
+   \production{modules} & \Bmodule &::=&
+     \Bmagic \\ &&&
+     \Bversion \\ &&&
+     \Bcustomsec^\ast \\ &&&
+     \functype^\ast{:\,}\Btypesec \\ &&&
+     \Bcustomsec^\ast \\ &&&
+     \import^\ast{:\,}\Bimportsec \\ &&&
+     \Bcustomsec^\ast \\ &&&
+     \typeidx^n{:\,}\Bfuncsec \\ &&&
+     \Bcustomsec^\ast \\ &&&
+     \table^\ast{:\,}\Btablesec \\ &&&
+     \Bcustomsec^\ast \\ &&&
+     \mem^\ast{:\,}\Bmemsec \\ &&&
+     \Bcustomsec^\ast \\ &&&
+     \global^\ast{:\,}\Bglobalsec \\ &&&
+     \Bcustomsec^\ast \\ &&&
+     \export^\ast{:\,}\Bexportsec \\ &&&
+     \Bcustomsec^\ast \\ &&&
+     \start^?{:\,}\Bstartsec \\ &&&
+     \Bcustomsec^\ast \\ &&&
+     \elem^\ast{:\,}\Belemsec \\ &&&
+     \Bcustomsec^\ast \\ &&&
+     \X{code}^n{:\,}\Bcodesec \\ &&&
+     \Bcustomsec^\ast \\ &&&
+     \data^\ast{:\,}\Bdatasec \\ &&&
+     \Bcustomsec^\ast
+     &\Rightarrow& \{~
+       \begin{array}[t]{@{}l@{}}
+       \TYPES~\functype^\ast, \\
+       \FUNCS~\func^n, \\
+       \TABLES~\table^\ast, \\
+       \MEMS~\mem^\ast, \\
+       \GLOBALS~\global^\ast, \\
+       \ELEM~\elem^\ast, \\
+       \DATA~\data^\ast, \\
+       \START~\start^?, \\
+       \IMPORTS~\import^\ast, \\
+       \EXPORTS~\export^\ast ~\} \\
+      \end{array} \\
+   \end{array}
+
+where for each :math:`(t_i^\ast, e_i)` in :math:`\X{code}^n`,
+:math:`\func^n[i] = \{ \TYPE~\typeidx^n[i], \LOCALS~t_i^\ast, \BODY~e_i \}`.
+
+.. note::
+   The version of the WebAssembly binary format may increase in the future
+   if backward-incompatible changes are made to the format.
+   However, such changes are expected to occur very infrequently, if ever.
+   The binary format is intended to be forward-compatible,
+   such that future extensions can be made without incrementing its version.
diff --git a/document/binary/types.rst b/document/binary/types.rst
new file mode 100644
index 000000000..33e5188b5
--- /dev/null
+++ b/document/binary/types.rst
@@ -0,0 +1,149 @@
+.. _binary-type:
+.. index:: type
+   pair: binary format; type
+   single: abstract syntax; type
+
+Types
+-----
+
+.. _binary-valtype:
+.. index:: value type
+   pair: binary format; value type
+   single: abstract syntax; value type
+
+Value Types
+~~~~~~~~~~~
+
+:ref:`Value types <syntax-valtype>` are encoded by a single byte.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{value types} & \Bvaltype &::=&
+     \hex{7F} &\Rightarrow& \I32 \\ &&|&
+     \hex{7E} &\Rightarrow& \I64 \\ &&|&
+     \hex{7D} &\Rightarrow& \F32 \\ &&|&
+     \hex{7C} &\Rightarrow& \F64 \\
+   \end{array}
+
+.. note::
+   In future versions of WebAssembly, value types may include types denoted by :ref:`type indices <syntax-typeidx>`.
+   Thus, the binary format for types corresponds to the encodings of small negative :math:`\xref{binary/values}{binary-sint}{\sX{}}` values, so that they can coexist with (positive) type indices.
+
+
+.. _binary-resulttype:
+.. _binary-blocktype:
+.. index:: result type, value type
+   pair: binary format; result type
+   single: abstract syntax; result type
+
+Result Types
+~~~~~~~~~~~~
+
+The only :ref:`result types <syntax-resulttype>` occurring in the binary format are the types of blocks. These are encoded in special compressed form, by either the byte :math:`\hex{40}` indicating the empty type or as a single :ref:`value type <binary-valtype>`.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{result types} & \Bblocktype &::=&
+     \hex{40} &\Rightarrow& [] \\ &&|&
+     t{:}\Bvaltype &\Rightarrow& [t] \\
+   \end{array}
+
+.. note::
+   In future versions of WebAssembly, this scheme may be extended to support multiple results or more general block types.
+
+
+.. _binary-functype:
+.. index:: function type, value type, result type
+   pair: binary format; function type
+   single: abstract syntax; function type
+
+Function Types
+~~~~~~~~~~~~~~
+
+:ref:`Function types <syntax-functype>` are encoded by the byte :math:`\hex{60}` followed by the respective :ref:`vectors <binary-vec>` of parameter and result types.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{function types} & \Bfunctype &::=&
+     \hex{60}~~t_1^\ast{:\,}\Bvec(\Bvaltype)~~t_2^\ast{:\,}\Bvec(\Bvaltype)
+       &\Rightarrow& [t_1^\ast] \to [t_2^\ast] \\
+   \end{array}
+
+
+.. _binary-limits:
+.. index:: limits
+   pair: binary format; limits
+   single: abstract syntax; limits
+
+Limits
+~~~~~~
+
+:ref:`Limits <syntax-limits>` are encoded with a preceding flag indicating whether a maximum is present.
+
+.. math::
+   \begin{array}{llclll}
+   \production{limits} & \Blimits &::=&
+     \hex{00}~~n{:}\Bu32 &\Rightarrow& \{ \MIN~n, \MAX~\epsilon \} \\ &&|&
+     \hex{01}~~n{:}\Bu32~~m{:}\Bu32 &\Rightarrow& \{ \MIN~n, \MAX~m \} \\
+   \end{array}
+
+
+.. _binary-memtype:
+.. index:: memory type, limits, page size
+   single: binary format; memory type
+   pair: abstract syntax; memory type
+
+Memory Types
+~~~~~~~~~~~~
+
+:ref:`Memory types <syntax-memtype>` are encoded with their :ref:`limits <binary-limits>`.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{memory types} & \Bmemtype &::=&
+     \X{lim}{:}\Blimits &\Rightarrow& \X{lim} \\
+   \end{array}
+
+
+.. _syntax-tabletype:
+.. _syntax-elemtype:
+.. index:: table type, element type, limits
+   pair: binary format; table type
+   pair: binary format; element type
+   single: abstract syntax; table type
+   single: abstract syntax; element type
+
+Table Types
+~~~~~~~~~~~
+
+:ref:`Table types <syntax-tabletype>` are encoded with their :ref:`limits <binary-limits>` and a constant byte indicating their :ref:`element type <syntax-elemtype>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{table types} & \Btabletype &::=&
+     \X{et}{:}\Belemtype~~\X{lim}{:}\Blimits &\Rightarrow& \X{lim}~\X{et} \\
+   \production{element types} & \Belemtype &::=&
+     \hex{70} &\Rightarrow& \ANYFUNC \\
+   \end{array}
+
+
+.. _binary-globaltype:
+.. index:: global type, mutability, value type
+   pair: binary format; global type
+   pair: binary format; mutability
+   single: abstract syntax; global type
+   single: abstract syntax; mutability
+
+Global Types
+~~~~~~~~~~~~
+
+:ref:`Global types <syntax-globaltype>` are encoded by their :ref:`value type <binary-valtype>` and a flag for their :ref:`mutability <syntax-mut>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{global types} & \Bglobaltype &::=&
+     t{:}\Bvaltype~~m{:}\Bmut &\Rightarrow& m~t \\
+   \production{mutability} & \Bmut &::=&
+     \hex{00} &\Rightarrow& \CONST \\ &&|&
+     \hex{01} &\Rightarrow& \MUT \\
+   \end{array}
diff --git a/document/binary/values.rst b/document/binary/values.rst
new file mode 100644
index 000000000..b2abed9ff
--- /dev/null
+++ b/document/binary/values.rst
@@ -0,0 +1,166 @@
+.. _binary-value:
+.. index:: value
+   binary: binary format; value
+   single: abstract syntax; value
+
+Values
+------
+
+
+.. _binary-byte:
+.. index:: byte
+   pair: binary encoding; byte
+   single: abstract syntax; byte
+
+Bytes
+~~~~~
+
+:ref:`Bytes <syntax-int>` encode themselves.
+
+.. math::
+   \begin{array}{llcll@{\qquad}l}
+   \production{bytes} & \Bbyte &::=&
+     \hex{00} &\Rightarrow& \hex{00} \\ &&|&&
+     \dots \\ &&|&
+     \hex{FF} &\Rightarrow& \hex{FF} \\
+   \end{array}
+
+
+.. _binary-int:
+.. _binary-sint:
+.. _binary-uint:
+.. index:: integer, unsigned integer, signed integer, uninterpreted integer
+   pair: binary format; integer
+   pair: binary format; unsigned integer
+   pair: binary format; signed integer
+   pair: binary format; uninterpreted integer
+   single: abstract syntax; integer
+   single: abstract syntax; unsigned integer
+   single: abstract syntax; signed integer
+   single: abstract syntax; uninterpreted integer
+
+Integers
+~~~~~~~~
+
+All :ref:`integers <syntax-int>` are encoded using the `LEB128 <https://en.wikipedia.org/wiki/LEB128>`_ variable-length integer encoding, in either unsigned or signed variant.
+
+:ref:`Unsigned integers <syntax-uint>` are encoded in `unsigned LEB128 <https://en.wikipedia.org/wiki/LEB128#Unsigned_LEB128>`_ format.
+As an additional constraint, the total number of bytes encoding a value of type :math:`\uX{N}` must not exceed :math:`\F{ceil}(N/7)` bytes.
+
+.. math::
+   \begin{array}{llclll@{\qquad}l}
+   \production{unsigned integers} & \BuX{N} &::=&
+     n{:}\Bbyte &\Rightarrow& n & (n < 2^7 \wedge n < 2^N) \\ &&|&
+     n{:}\Bbyte~~m{:}\BuX{N-7} &\Rightarrow&
+       2^7\cdot m + (n-2^7) & (n \geq 2^7 \wedge N > 7) \\
+   \end{array}
+
+:ref:`Signed integers <syntax-sint>` are encoded in `signed LEB128 <https://en.wikipedia.org/wiki/LEB128#Signed_LEB128>`_ format, which uses a 2's complement representation.
+As an additional constraint, the total number of bytes encoding a value of type :math:`\sX{N}` must not exceed :math:`\F{ceil}(N/7)` bytes.
+
+.. math::
+   \begin{array}{llclll@{\qquad}l}
+   \production{signed integers} & \BsX{N} &::=&
+     n{:}\Bbyte &\Rightarrow& n & (n < 2^6 \wedge n < 2^{N-1}) \\ &&|&
+     n{:}\Bbyte &\Rightarrow& n-2^7 & (2^6 \leq n < 2^7 \wedge n \geq 2^7-2^{N-1}) \\ &&|&
+     n{:}\Bbyte~~m{:}\BsX{N-7} &\Rightarrow&
+       2^7\cdot m + (n-2^7) & (n \geq 2^7 \wedge N > 7) \\
+   \end{array}
+
+:ref:`Uninterpreted integers <syntax-int>` are always encoded as signed integers.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{uninterpreted integers} & \BiX{N} &::=&
+     n{:}\BsX{N} &\Rightarrow& n
+   \end{array}
+
+.. note::
+   While the side conditions :math:`N > 7` in the productions for *non-terminating* bytes restrict the length of the :math:`\uX{}` and :math:`\sX{}` encodings,
+   "trailing zeros" are still allowed within these bounds.
+   For example, :math:`\hex{03}` and :math:`\hex{83}~\hex{00}` are both well-formed encodings for the value :math:`3` as a |u8|.
+   Similarly, either of :math:`\hex{7e}` and :math:`\hex{FE}~\hex{7F}` and :math:`\hex{FE}~\hex{FF}~\hex{7F}` are well-formed encodings of the value :math:`-2` as a |s16|.
+
+   The side conditions on the value :math:`n` of *terminating* bytes further enforce that
+   any unused bits in these bytes must be :math:`0` for positive values and :math:`1` for negative ones.
+   For example, :math:`\hex{83}~\hex{10}` is malformed as a |u8| encoding.
+   Similarly, both :math:`\hex{83}~\hex{3E}` and :math:`\hex{FF}~\hex{7B}` are malformed as |s8| encodings.
+
+
+.. _binary-float:
+.. index:: floating-point number
+   pair: binary format; floating-point number
+   single: abstract syntax; floating-point number
+
+Floating-Point
+~~~~~~~~~~~~~~
+
+:ref:`Floating point <syntax-float>` values are encoded directly by their IEEE bit pattern in `little endian <https://en.wikipedia.org/wiki/Endianness#Little-endian>`_ byte order:
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{floating-point numbers} & \BfX{N} &::=&
+     b^\ast{:\,}\Bbyte^{N/8} &\Rightarrow& \F{reverse}(b^\ast) \\
+   \end{array}
+
+Here, :math:`\F{reverse}(b^\ast)` denotes the byte sequence :math:`b^\ast` in reversed order.
+
+
+.. _binary-vec:
+.. index:: vector
+   pair: binary format; vector
+   single: abstract syntax; vector
+
+Vectors
+~~~~~~~
+
+:ref:`Vectors <syntax-vec>` are encoded with their length followed by the encoding of their element sequence.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{vectors} & \Bvec(\B{B}) &::=&
+     n{:}\Bu32~~(x{:}\B{B})^n &\Rightarrow& x^n \\
+   \end{array}
+
+
+.. _binary-name:
+.. index:: name, byte
+   pair: binary format; name
+   single: abstract syntax; name
+
+Names
+~~~~~
+
+:ref:`Names <syntax-name>` are encoded like a :ref:`vector <binary-vector>` of bytes containing the `UTF-8 <http://www.unicode.org/versions/latest/>`_ encoding of the name's code point sequence.
+
+.. math::
+   \begin{array}{llclll@{\qquad}l}
+   \production{names} & \Bname &::=&
+     n{:}\Bu32~~(\X{uc}{:}\Bcodepoint)^\ast &\Rightarrow& \X{uc}^\ast
+       & (|\Bcodepoint^\ast| = n) \\
+   \production{code points} & \Bcodepoint &::=&
+     \X{uv}{:}\Bcodeval_N &\Rightarrow& \X{uv}
+       & (\X{uv} \geq N \wedge (\X{uv} < \unicode{D800} \vee \unicode{E000} \leq \X{uv} < \unicode{110000})) \\
+   \production{code values} & \Bcodeval_N &::=&
+     b_1{:}\Bbyte &\Rightarrow&
+       b_1
+       & (b_1 < \hex{80} \wedge N = \unicode{00}) \\ &&|&
+     b_1{:}\Bbyte~~b_2{:}\Bcodecont &\Rightarrow&
+       2^6\cdot(b_1-\hex{c0}) + b_2
+       & (\hex{c0} \leq b_1 < \hex{e0} \wedge N = \unicode{80}) \\ &&|&
+     b_1{:}\Bbyte~~b_2{:}\Bcodecont~~b_3{:}\Bcodecont &\Rightarrow&
+       2^{12}\cdot(b_1-\hex{e0}) + 2^6\cdot b_2 + b_3
+       & (\hex{e0} \leq b_1 < \hex{f0} \wedge N = \unicode{800}) \\ &&|&
+     b_1{:}\Bbyte~~b_2{:}\Bcodecont~~b_3{:}\Bcodecont~~b_4{:}\Bcodecont
+       &\Rightarrow&
+       2^{18}\cdot(b_1-\hex{f0}) + 2^{12}\cdot b_2 + 2^6\cdot b_3 + b_4
+       & (\hex{f0} \leq b_1 < \hex{f8} \wedge N = \unicode{10000}) \\
+   \production{code continuation} & \Bcodecont &::=&
+     b{:}\Bbyte &\Rightarrow& b - \hex{80} & (b \geq \hex{80}) \\
+   \end{array}
+
+.. note::
+   The :ref:`size <binary-notation>`, :math:`||\Bcodepoint^\ast||` denotes the number of bytes in the encoding of the sequence, not the number of code points.
+
+   The index :math:`N` to |Bcodeval| is the minimum value that a given byte sequence may decode into.
+   The respective side conditions on it exclude encodings using more than the minimal number of bytes to represent a code point.
diff --git a/document/math.def b/document/math.def
index d8e23dba9..d79f1fea3 100644
--- a/document/math.def
+++ b/document/math.def
@@ -9,10 +9,12 @@
 .. X - (multi-letter) variables / non-terminals
 .. F - functions
 .. K - keywords / terminals
+.. B - binary grammar non-terminals
 
 .. |X| mathdef:: \mathit
 .. |F| mathdef:: \mathrm
 .. |K| mathdef:: \mathsf
+.. |B| mathdef:: \mathtt
 
 
 .. Auxiliary definitions for grammars
@@ -20,16 +22,15 @@
 .. |production| mathdef:: \void
 
 
-.. Values, terminals and auxiliary
+.. Values, terminals
 
-.. |hex#1| mathdef:: \F{0x#1}
-.. |byte| mathdef:: \F{byte}
-.. |bytes| mathdef:: \F{bytes}
+.. |hex#1| mathdef:: \mathtt{0x#1}
+.. |unicode#1| mathdef:: \mathrm{U{+}#1}
 
 
 .. Values, non-terminals
 
-.. |by| mathdef:: \xref{syntax/values}{syntax-byte}{\X{byte}}
+.. |byte| mathdef:: \xref{syntax/values}{syntax-byte}{\X{byte}}
 
 .. |uX#1| mathdef:: {\X{uint}_{#1}}
 .. |sX#1| mathdef:: {\X{sint}_{#1}}
@@ -44,6 +45,8 @@
 .. |u64| mathdef:: \xref{syntax/values}{syntax-int}{\uX{64}}
 
 .. |sN| mathdef:: \xref{syntax/values}{syntax-int}{\sX{N}}
+.. |s8| mathdef:: \xref{syntax/values}{syntax-int}{\sX{8}}
+.. |s16| mathdef:: \xref{syntax/values}{syntax-int}{\sX{16}}
 .. |s32| mathdef:: \xref{syntax/values}{syntax-int}{\sX{32}}
 .. |s64| mathdef:: \xref{syntax/values}{syntax-int}{\sX{64}}
 
@@ -57,6 +60,42 @@
 
 .. |vec| mathdef:: \xref{syntax/values}{syntax-vec}{\X{vec}}
 .. |name| mathdef:: \xref{syntax/values}{syntax-name}{\X{name}}
+.. |codepoint| mathdef:: \xref{syntax/values}{syntax-name}{\X{codepoint}}
+
+
+.. Values, binary non-terminals
+
+.. |Bbyte| mathdef:: \xref{binary/values}{binary-byte}{\B{byte}}
+
+.. |BuX#1| mathdef:: {\B{uint}_{#1}}
+.. |BsX#1| mathdef:: {\B{sint}_{#1}}
+.. |BiX#1| mathdef:: {\B{int}_{#1}}
+.. |BfX#1| mathdef:: {\B{float}_{#1}}
+
+.. |BuN| mathdef:: \xref{binary/values}{binary-int}{\BuX{N}}
+.. |Bu1| mathdef:: \xref{binary/values}{binary-int}{\BuX{1}}
+.. |Bu8| mathdef:: \xref{binary/values}{binary-int}{\BuX{8}}
+.. |Bu16| mathdef:: \xref{binary/values}{binary-int}{\BuX{16}}
+.. |Bu32| mathdef:: \xref{binary/values}{binary-int}{\BuX{32}}
+.. |Bu64| mathdef:: \xref{binary/values}{binary-int}{\BuX{64}}
+
+.. |BsN| mathdef:: \xref{binary/values}{binary-int}{\BsX{N}}
+.. |Bs32| mathdef:: \xref{binary/values}{binary-int}{\BsX{32}}
+.. |Bs64| mathdef:: \xref{binary/values}{binary-int}{\BsX{64}}
+
+.. |BiN| mathdef:: \xref{binary/values}{binary-int}{\BiX{N}}
+.. |Bi32| mathdef:: \xref{binary/values}{binary-int}{\BiX{32}}
+.. |Bi64| mathdef:: \xref{binary/values}{binary-int}{\BiX{64}}
+
+.. |BfN| mathdef:: \xref{binary/values}{binary-float}{\BfX{N}}
+.. |Bf32| mathdef:: \xref{binary/values}{binary-float}{\BfX{32}}
+.. |Bf64| mathdef:: \xref{binary/values}{binary-float}{\BfX{64}}
+
+.. |Bvec| mathdef:: \xref{binary/values}{binary-vec}{\B{vec}}
+.. |Bname| mathdef:: \xref{binary/values}{binary-name}{\B{name}}
+.. |Bcodepoint| mathdef:: \xref{binary/values}{binary-name}{\B{codepoint}}
+.. |Bcodeval| mathdef:: \xref{binary/values}{binary-name}{\B{codeval}}
+.. |Bcodecont| mathdef:: \xref{binary/values}{binary-name}{\B{cont}}
 
 
 .. Types, terminals
@@ -87,6 +126,21 @@
 .. |mut| mathdef:: \xref{syntax/types}{syntax-mut}{\X{mut}}
 
 
+.. Types, binary non-terminals
+
+.. |Bvaltype| mathdef:: \xref{binary/types}{binary-valtype}{\B{valtype}}
+.. |Bresulttype| mathdef:: \xref{binary/types}{binary-resulttype}{\B{resulttype}}
+.. |Bblocktype| mathdef:: \xref{binary/types}{binary-blocktype}{\B{blocktype}}
+.. |Bfunctype| mathdef:: \xref{binary/types}{binary-functype}{\B{functype}}
+.. |Bglobaltype| mathdef:: \xref{binary/types}{binary-globaltype}{\B{globaltype}}
+.. |Btabletype| mathdef:: \xref{binary/types}{binary-tabletype}{\B{tabletype}}
+.. |Belemtype| mathdef:: \xref{binary/types}{binary-elemtype}{\B{elemtype}}
+.. |Bmemtype| mathdef:: \xref{binary/types}{binary-memtype}{\B{memtype}}
+.. |Bexterntype| mathdef:: \xref{binary/types}{binary-externtype}{\B{externtype}}
+.. |Blimits| mathdef:: \xref{binary/types}{binary-limits}{\B{limits}}
+.. |Bmut| mathdef:: \xref{binary/types}{binary-mut}{\B{mut}}
+
+
 .. Indices
 
 .. |typeidx| mathdef:: \xref{syntax/modules}{syntax-typeidx}{\X{typeidx}}
@@ -97,6 +151,14 @@
 .. |localidx| mathdef:: \xref{syntax/modules}{syntax-localidx}{\X{localidx}}
 .. |labelidx| mathdef:: \xref{syntax/modules}{syntax-labelidx}{\X{labelidx}}
 
+.. |Btypeidx| mathdef:: \xref{binary/modules}{binary-typeidx}{\B{typeidx}}
+.. |Bfuncidx| mathdef:: \xref{binary/modules}{binary-funcidx}{\B{funcidx}}
+.. |Btableidx| mathdef:: \xref{binary/modules}{binary-tableidx}{\B{tableidx}}
+.. |Bmemidx| mathdef:: \xref{binary/modules}{binary-memidx}{\B{memidx}}
+.. |Bglobalidx| mathdef:: \xref{binary/modules}{binary-globalidx}{\B{globalidx}}
+.. |Blocalidx| mathdef:: \xref{binary/modules}{binary-localidx}{\B{localidx}}
+.. |Blabelidx| mathdef:: \xref{binary/modules}{binary-labelidx}{\B{labelidx}}
+
 
 .. Modules, terminals
 
@@ -146,9 +208,45 @@
 .. |export| mathdef:: \xref{syntax/modules}{syntax-export}{\X{export}}
 .. |importdesc| mathdef:: \xref{syntax/modules}{syntax-importdesc}{\X{importdesc}}
 .. |exportdesc| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\X{exportdesc}}
-.. |elem| mathdef:: \xref{syntax/modules}{syntax-elemseg}{\X{elem}}
-.. |data| mathdef:: \xref{syntax/modules}{syntax-dataseg}{\X{data}}
-.. |start| mathdef:: \xref{syntax/modules}{syntax-dataseg}{\X{start}}
+.. |elem| mathdef:: \xref{syntax/modules}{syntax-elem}{\X{elem}}
+.. |data| mathdef:: \xref{syntax/modules}{syntax-data}{\X{data}}
+.. |start| mathdef:: \xref{syntax/modules}{syntax-start}{\X{start}}
+
+
+.. Modules, binary non-terminals
+
+.. |Bmagic| mathdef:: \xref{binary/modules}{binary-magic}{\B{magic}}
+.. |Bversion| mathdef:: \xref{binary/modules}{binary-version}{\B{version}}
+.. |Bmodule| mathdef:: \xref{binary/modules}{binary-module}{\B{module}}
+.. |Bsection| mathdef:: \xref{binary/modules}{binary-module}{\B{section}}
+.. |Bcustomsec| mathdef:: \xref{binary/modules}{binary-customsec}{\B{customsec}}
+.. |Btypesec| mathdef:: \xref{binary/modules}{binary-typesec}{\B{typesec}}
+.. |Bfuncsec| mathdef:: \xref{binary/modules}{binary-funcsec}{\B{funcsec}}
+.. |Bcodesec| mathdef:: \xref{binary/modules}{binary-codesec}{\B{codesec}}
+.. |Btablesec| mathdef:: \xref{binary/modules}{binary-tablesec}{\B{tablesec}}
+.. |Bmemsec| mathdef:: \xref{binary/modules}{binary-memsec}{\B{memsec}}
+.. |Bglobalsec| mathdef:: \xref{binary/modules}{binary-globalsec}{\B{globalsec}}
+.. |Bimportsec| mathdef:: \xref{binary/modules}{binary-importsec}{\B{importsec}}
+.. |Bexportsec| mathdef:: \xref{binary/modules}{binary-exportsec}{\B{exportsec}}
+.. |Belemsec| mathdef:: \xref{binary/modules}{binary-elemsec}{\B{elemsec}}
+.. |Bdatasec| mathdef:: \xref{binary/modules}{binary-datasec}{\B{datasec}}
+.. |Bstartsec| mathdef:: \xref{binary/modules}{binary-startseg}{\B{startsec}}
+.. |Bcustom| mathdef:: \xref{binary/modules}{binary-customsec}{\B{custom}}
+.. |Btype| mathdef:: \xref{binary/modules}{binary-type}{\B{type}}
+.. |Bfunc| mathdef:: \xref{binary/modules}{binary-func}{\B{func}}
+.. |Btable| mathdef:: \xref{binary/modules}{binary-table}{\B{table}}
+.. |Bmem| mathdef:: \xref{binary/modules}{binary-mem}{\B{mem}}
+.. |Bglobal| mathdef:: \xref{binary/modules}{binary-global}{\B{global}}
+.. |Bimport| mathdef:: \xref{binary/modules}{binary-import}{\B{import}}
+.. |Bexport| mathdef:: \xref{binary/modules}{binary-export}{\B{export}}
+.. |Bimportdesc| mathdef:: \xref{binary/modules}{binary-importdesc}{\B{importdesc}}
+.. |Bexportdesc| mathdef:: \xref{binary/modules}{binary-exportdesc}{\B{exportdesc}}
+.. |Belem| mathdef:: \xref{binary/modules}{binary-elem}{\B{elem}}
+.. |Bcode| mathdef:: \xref{binary/modules}{binary-code}{\B{code}}
+.. |Blocal| mathdef:: \xref{binary/modules}{binary-local}{\B{local}}
+.. |Blocals| mathdef:: \xref{binary/modules}{binary-local}{\B{locals}}
+.. |Bdata| mathdef:: \xref{binary/modules}{binary-data}{\B{data}}
+.. |Bstart| mathdef:: \xref{binary/modules}{binary-start}{\B{start}}
 
 
 .. Modules, meta functions
@@ -247,3 +345,11 @@
 
 .. |instr| mathdef:: \xref{syntax/instructions}{syntax-instr}{\X{instr}}
 .. |expr| mathdef:: \xref{syntax/instructions}{syntax-expr}{\X{expr}}
+
+
+.. Instructions, binary non-terminals
+
+.. |Bmemarg| mathdef:: \xref{binary/instructions}{binary-memarg}{\B{memarg}}
+
+.. |Binstr| mathdef:: \xref{binary/instructions}{binary-instr}{\B{instr}}
+.. |Bexpr| mathdef:: \xref{binary/instructions}{binary-expr}{\B{expr}}
diff --git a/document/syntax/modules.rst b/document/syntax/modules.rst
index 743c4d439..2b5036bdd 100644
--- a/document/syntax/modules.rst
+++ b/document/syntax/modules.rst
@@ -1,5 +1,5 @@
 .. _syntax-module:
-.. index:: ! modules, type definition, function type, function, table, memory, global, element, data, start function, import, export
+.. index:: ! module, type definition, function type, function, table, memory, global, element, data, start function, import, export
    pair: abstract syntax; module
 
 Modules
@@ -89,7 +89,6 @@ Conventions
 .. _syntax-type:
 .. index:: ! type definition, type index
    pair: abstract syntax; type definition
-   single: type; definition
 
 Types
 ~~~~~
@@ -250,13 +249,13 @@ The |OFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <sy
 Data Segments
 ~~~~~~~~~~~~~
 
-The initial contents of a :ref:`memory <syntax-memory>` are zero bytes.
+The initial contents of a :ref:`memory <syntax-mem>` are zero bytes.
 The |DATA| component of a module defines a vector of *data segments* that initialize a range of memory at a given offset with a static vector of bytes.
 
 .. math::
    \begin{array}{llll}
    \production{data segments} & \data &::=&
-     \{ \MEM~\memidx, \OFFSET~\expr, \INIT~\vec(\by) \} \\
+     \{ \MEM~\memidx, \OFFSET~\expr, \INIT~\vec(\byte) \} \\
    \end{array}
 
 The |OFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <syntax-expr>`.
@@ -273,11 +272,11 @@ The |OFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <sy
 Start Function
 ~~~~~~~~~~~~~~
 
-The |START| component of a module optionally declares the :ref:`function index <syntax-idx>` of a *start function* that is automatically invoked when the module is :ref:`instantiated <instantiation>`, after tables and memories have been initialized.
+The |START| component of a module optionally declares the :ref:`function index <syntax-funcidx>` of a *start function* that is automatically invoked when the module is :ref:`instantiated <instantiation>`, after tables and memories have been initialized.
 
 .. math::
    \begin{array}{llll}
-   \production{start function} & \start &::=&
+   \production{start functions} & \start &::=&
      \{ \FUNC~\funcidx \} \\
    \end{array}
 
@@ -342,7 +341,7 @@ Each import is identified by a two-level :ref:`name <syntax-name>` space, consis
 Importable definitions are :ref:`functions <syntax-func>`, :ref:`tables <syntax-table>`, :ref:`memories <syntax-mem>`, and :ref:`globals <syntax-global>`.
 Each import is specified by a descriptor with a respective type that a definition provided during instantiation is required to match.
 
-Every import defines an index in the respective :ref:`index space <syntax-indices>`.
+Every import defines an index in the respective :ref:`index space <syntax-index>`.
 In each index space, the indices of imports go before the first index of any definition contained in the module itself.
 
 .. note::
diff --git a/document/syntax/types.rst b/document/syntax/types.rst
index a35fb4c99..262da63e2 100644
--- a/document/syntax/types.rst
+++ b/document/syntax/types.rst
@@ -156,6 +156,7 @@ A table of that type thus contains references to functions of heterogeneous type
 
 
 .. _syntax-globaltype:
+.. _syntax-mut:
 .. index:: ! global type, ! mutability, value type
    pair: abstract syntax; global type
    pair: abstract syntax; mutability
diff --git a/document/syntax/values.rst b/document/syntax/values.rst
index 1dc03f8b8..609304338 100644
--- a/document/syntax/values.rst
+++ b/document/syntax/values.rst
@@ -18,7 +18,7 @@ In the abstract syntax they are represented as hexadecimal literals.
 
 .. math::
    \begin{array}{llll}
-   \production{bytes} & \by &::=&
+   \production{bytes} & \byte &::=&
      \hex{00} ~|~ \dots ~|~ \hex{FF} \\
    \end{array}
 
@@ -28,7 +28,7 @@ Conventions
 
 * The meta variable :math:`b` range over bytes.
 
-* The meta function :math:`\byte(n)` denotes the byte representing the natural number :math:`n < 256`.
+* Bytes are sometimes interpreted as natural numbers :math:`n < 256`.
 
 
 .. _syntax-int:
@@ -69,7 +69,7 @@ and when interpreted as signed, positive values :math:`n \geq 2^{N-1}` convert t
 Conventions
 ...........
 
-* The meta variables :math:`m, n` range over unsigned integers.
+* The meta variables :math:`m, n, i` range over integers.
 
 * Numbers may be denoted by simple arithmetics, as in the grammar above.
 
@@ -86,7 +86,7 @@ Floating-Point
 .. math::
    \begin{array}{llll}
    \production{floating-point numbers} & \fN &::=&
-     \by^{N/8} \\
+     \byte^{N/8} \\
    \end{array}
 
 The two possible sizes :math:`N` are 32 and 64.
@@ -118,13 +118,25 @@ A vector can have at most :math:`2^{32}-1` elements.
 Names
 ~~~~~
 
-*Names* are vectors of bytes interpreted as character strings.
+*Names* are sequences of *scalar* `Unicode <http://www.unicode.org/versions/latest/>`_ *code points*.
 
 .. math::
    \begin{array}{llll}
    \production{names} & \name &::=&
-     \vec(\by) \\
+     \codepoint^\ast \\
+   \production{code points} & \codepoint &::=&
+     \unicode{0000} ~|~ \dots ~|~ \unicode{D7FF} ~|~
+     \unicode{E000} ~|~ \dots ~|~ \unicode{10FFFF} \\
    \end{array}
 
 .. todo::
-   Unicode?
+   The definition of a name as an arbitrary sequence of scalar code points is too general.
+   So would be the definition of a vector.
+   Only names whose UTF-8 encoding is within the bounds of the maximum vector lengths must be included.
+   How specify this?
+
+
+Convention
+..........
+
+* Code points are sometimes used interchangeably with natural numbers :math:`n < 1114112`.
diff --git a/document/validation/modules.rst b/document/validation/modules.rst
index faad5cd44..a1e26da4a 100644
--- a/document/validation/modules.rst
+++ b/document/validation/modules.rst
@@ -9,6 +9,9 @@ Auxiliary Rules
 ~~~~~~~~~~~~~~~
 
 .. _valid-limits:
+.. index:: limits
+   pair: validation; limits
+   single: abstract syntax; limits
 
 Limits :math:`\{ \MIN~n, \MAX~m^? \}`
 .....................................
@@ -28,6 +31,7 @@ Limits :math:`\{ \MIN~n, \MAX~m^? \}`
 .. _valid-func:
 .. index:: function, local, function index, local index, type index, function type, value type, expression, import
    pair: abstract syntax; function
+   single: abstract syntax; function
 
 Functions
 ~~~~~~~~~
@@ -262,7 +266,7 @@ Start function declarations :math:`\start` are not classified by any type.
 
 .. _valid-export:
 .. index:: export, name, index, function index, table index, memory index, global index
-   validation: abstract syntax; export
+   pair: validation; export
    single: abstract syntax; export
 
 Exports
@@ -444,7 +448,7 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 
 
 .. _valid-module:
-.. index:: modules, type definition, function type, function, table, memory, global, element, data, start function, import, export, context
+.. index:: module, type definition, function type, function, table, memory, global, element, data, start function, import, export, context
    pair: validation; module
    single: abstract syntax; module
 

From 5bf1ca2aadd6e5419f6ef350f1e7473fac4f2c00 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 27 Apr 2017 11:15:27 +0200
Subject: [PATCH 013/329] [spec] Fix binary section grammar

---
 document/binary/modules.rst | 35 ++++++++++-------------------------
 1 file changed, 10 insertions(+), 25 deletions(-)

diff --git a/document/binary/modules.rst b/document/binary/modules.rst
index f520e7b88..4431f1784 100644
--- a/document/binary/modules.rst
+++ b/document/binary/modules.rst
@@ -124,7 +124,7 @@ It decodes into a vector of :ref:`function types <syntax-functype>` that represe
 .. math::
    \begin{array}{llclll}
    \production{type sections} & \Btypesec &::=&
-     \X{ft}^\ast{:\,}\Bsection_1(\Bfunctype^\ast) &\Rightarrow& \X{ft}^\ast \\
+     \X{ft}^\ast{:\,}\Bsection_1(\Bvec(\Bfunctype)) &\Rightarrow& \X{ft}^\ast \\
    \end{array}
 
 
@@ -144,7 +144,7 @@ It decodes into a vector of :ref:`imports <syntax-import>` that represent the |I
 .. math::
    \begin{array}{llclll}
    \production{import sections} & \Bimportsec &::=&
-     \X{im}^\ast{:}\Bsection_2(\Bimport^\ast) &\Rightarrow& \X{im}^\ast \\
+     \X{im}^\ast{:}\Bsection_2(\Bvec(\Bimport)) &\Rightarrow& \X{im}^\ast \\
    \production{imports} & \Bimport &::=&
      \X{mod}{:}\Bname~~\X{nm}{:}\Bname~~d{:}\Bimportdesc
        &\Rightarrow& \{ \MODULE~\X{mod}, \NAME~\X{nm}, \DESC~d \} \\
@@ -173,7 +173,7 @@ The |LOCALS| and |BODY| fields of the respective functions are encoded separatel
 .. math::
    \begin{array}{llclll}
    \production{function sections} & \Bfuncsec &::=&
-     x^\ast{:}\Bsection_3(\Btypeidx^\ast) &\Rightarrow& x^\ast \\
+     x^\ast{:}\Bsection_3(\Bvec(\Btypeidx)) &\Rightarrow& x^\ast \\
    \end{array}
 
 
@@ -193,7 +193,7 @@ It decodes into a vector of :ref:`tables <syntax-table>` that represent the |TAB
 .. math::
    \begin{array}{llclll}
    \production{table sections} & \Btablesec &::=&
-     \X{tab}^\ast{:}\Bsection_4(\Btable^\ast) &\Rightarrow& \X{tab}^\ast \\
+     \X{tab}^\ast{:}\Bsection_4(\Bvec(\Btable)) &\Rightarrow& \X{tab}^\ast \\
    \production{tables} & \Btable &::=&
      \X{tt}{:}\Btabletype &\Rightarrow& \{ \TYPE~\X{tt} \} \\
    \end{array}
@@ -215,7 +215,7 @@ It decodes into a vector of :ref:`memories <syntax-mem>` that represent the |MEM
 .. math::
    \begin{array}{llclll}
    \production{memory sections} & \Bmemsec &::=&
-     \X{mem}^\ast{:}\Bsection_5(\Bmem^\ast) &\Rightarrow& \X{mem}^\ast \\
+     \X{mem}^\ast{:}\Bsection_5(\Bvec(\Bmem)) &\Rightarrow& \X{mem}^\ast \\
    \production{memories} & \Bmem &::=&
      \X{mt}{:}\Bmemtype &\Rightarrow& \{ \TYPE~\X{mt} \} \\
    \end{array}
@@ -237,7 +237,7 @@ It decodes into a vector of :ref:`globals <syntax-global>` that represent the |G
 .. math::
    \begin{array}{llclll}
    \production{global sections} & \Bglobalsec &::=&
-     \X{glob}^\ast{:}\Bsection_6(\Bglobal^\ast) &\Rightarrow& \X{glob}^\ast \\
+     \X{glob}^\ast{:}\Bsection_6(\Bvec(\Bglobal)) &\Rightarrow& \X{glob}^\ast \\
    \production{globals} & \Bglobal &::=&
      \X{gt}{:}\Bglobaltype~~e{:}\Bexpr
        &\Rightarrow& \{ \TYPE~\X{gt}, \INIT~e \} \\
@@ -260,7 +260,7 @@ It decodes into a vector of :ref:`exports <syntax-export>` that represent the |E
 .. math::
    \begin{array}{llclll}
    \production{export sections} & \Bexportsec &::=&
-     \X{ex}^\ast{:}\Bsection_7(\Bexport^\ast) &\Rightarrow& \X{ex}^\ast \\
+     \X{ex}^\ast{:}\Bsection_7(\Bvec(\Bexport)) &\Rightarrow& \X{ex}^\ast \\
    \production{exports} & \Bexport &::=&
      \X{nm}{:}\Bname~~d{:}\Bexportdesc
        &\Rightarrow& \{ \NAME~\X{nm}, \DESC~d \} \\
@@ -313,7 +313,7 @@ It decodes into a vector of :ref:`element segments <syntax-elem>` that represent
 .. math::
    \begin{array}{llclll}
    \production{element sections} & \Belemsec &::=&
-     \X{seg}^\ast{:}\Bsection_9(\Belem^\ast) &\Rightarrow& \X{seg} \\
+     \X{seg}^\ast{:}\Bsection_9(\Bvec(\Belem)) &\Rightarrow& \X{seg} \\
    \production{element segments} & \Belem &::=&
      x{:}\Btableidx~~e{:}\Bexpr~~y^\ast{:}\Bvec(\Bfuncidx)
        &\Rightarrow& \{ \TABLE~x, \OFFSET~e, \INIT~y^\ast \} \\
@@ -353,7 +353,7 @@ denoting *count* locals of the same value type.
 .. math::
    \begin{array}{llclll@{\qquad}l}
    \production{code sections} & \Bcodesec &::=&
-     \X{code}^\ast{:}\Bsection_{10}(\Bcode^\ast)
+     \X{code}^\ast{:}\Bsection_{10}(\Bvec(\Bcode))
        &\Rightarrow& \X{code}^\ast \\
    \production{code} & \Bcode &::=&
      \X{size}{:}\Bu32~~\X{code}{:}\Bfunc
@@ -366,21 +366,6 @@ denoting *count* locals of the same value type.
      n{:}\Bu32~~t{:}\Bvaltype &\Rightarrow& t^n \\
    \end{array}
 
-.. math (commented out)
-   \begin{array}{llclll}
-   \production{code sections} & \Bcodesec_{\typeidx^n} &::=&
-     \f^\ast{:}\Bsection_{10}(\Bcode_{\typeidx}^n)
-       &\Rightarrow& \f^\ast \\
-   \production{code} & \Bcode_{\typeidx} &::=&
-     \X{size}{:}\Bu32~~f{:}\Bfunc_{\typeidx}
-       &\Rightarrow& f \qquad\qquad (\X{size} = |\Bfunc|) \\
-   \production{functions} & \Bfunc_{\typeidx} &::=&
-     (t^\ast)^\ast{:}\Bvec(\Blocals)~~e{:}\Bexpr &\Rightarrow&
-       \{ \TYPE~\typeidx, \LOCALS~\F{concat}((t^\ast)^\ast), \BODY~e^\ast \} \\
-   \production{locals} & \Blocals &::=&
-     n{:}\Bu32~~t{:}\Bvaltype &\Rightarrow& t^n \\
-   \end{array}
-
 Here, :math:`\X{code}` ranges over pairs :math:`(\valtype^\ast, \expr)`.
 The meta function :math:`\F{concat}((t^\ast)^\ast)` denotes the sequence of types formed by concatenating all sequences :math:`t_i^\ast` in :math:`(t^\ast)^\ast`.
 Any code for which the length of the resulting sequence is out of bounds of the maximum size of a :ref:`vector <syntax-vec>` is malformed.
@@ -408,7 +393,7 @@ It decodes into a vector of :ref:`data segments <syntax-data>` that represent th
 .. math::
    \begin{array}{llclll}
    \production{data sections} & \Bdatasec &::=&
-     \X{seg}^\ast{:}\Bsection_{11}(\Bdata^\ast) &\Rightarrow& \X{seg} \\
+     \X{seg}^\ast{:}\Bsection_{11}(\Bvec(\Bdata)) &\Rightarrow& \X{seg} \\
    \production{data segments} & \Bdata &::=&
      x{:}\Bmemidx~~e{:}\Bexpr~~b^\ast{:}\Bvec(\Bbyte)
        &\Rightarrow& \{ \MEM~x, \OFFSET~e, \INIT~b^\ast \} \\

From 2fa62739e6dc81797bbbac3eb9028b368b55bf42 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Fri, 5 May 2017 15:03:24 +0200
Subject: [PATCH 014/329] Represent all names in UTF-8 (#454)

---
 interpreter/host/import.ml          |  5 +--
 interpreter/host/import.mli         |  4 +--
 interpreter/host/import/env.ml      |  2 +-
 interpreter/host/import/spectest.ml |  2 +-
 interpreter/host/js.ml              | 23 +++++++------
 interpreter/host/main.ml            |  4 +--
 interpreter/host/run.ml             | 22 +++++++-----
 interpreter/spec/ast.ml             |  7 ++--
 interpreter/spec/decode.ml          | 13 +++++---
 interpreter/spec/encode.ml          |  7 ++--
 interpreter/spec/instance.ml        |  2 +-
 interpreter/spec/utf8.ml            | 42 +++++++++++++++++++++++
 interpreter/spec/utf8.mli           |  4 +++
 interpreter/spec/valid.ml           |  2 +-
 interpreter/text/arrange.ml         | 15 +++++----
 interpreter/text/parser.mly         | 20 +++++++----
 interpreter/text/script.ml          |  6 ++--
 interpreter/util/lib.ml             | 52 +++++++++++++++++------------
 interpreter/util/lib.mli            |  2 ++
 interpreter/winmake.bat             |  6 ++--
 20 files changed, 162 insertions(+), 78 deletions(-)
 create mode 100644 interpreter/spec/utf8.ml
 create mode 100644 interpreter/spec/utf8.mli

diff --git a/interpreter/host/import.ml b/interpreter/host/import.ml
index 31595b67d..0e658dc00 100644
--- a/interpreter/host/import.ml
+++ b/interpreter/host/import.ml
@@ -4,7 +4,7 @@ open Ast
 module Unknown = Error.Make ()
 exception Unknown = Unknown.Error  (* indicates unknown import name *)
 
-module Registry = Map.Make(String)
+module Registry = Instance.ExportMap
 let registry = ref Registry.empty
 
 let register name lookup = registry := Registry.add name lookup !registry
@@ -14,6 +14,7 @@ let lookup (m : module_) (im : import) : Instance.extern =
   let t = import_type m im in
   try Registry.find module_name !registry item_name t with Not_found ->
     Unknown.error im.at
-      ("unknown import \"" ^ module_name ^ "." ^ item_name ^ "\"")
+      ("unknown import \"" ^ String.escaped (Utf8.encode module_name) ^
+        "\".\"" ^ String.escaped (Utf8.encode item_name) ^ "\"")
 
 let link m = List.map (lookup m) m.it.imports
diff --git a/interpreter/host/import.mli b/interpreter/host/import.mli
index 9310553df..7d29b5920 100644
--- a/interpreter/host/import.mli
+++ b/interpreter/host/import.mli
@@ -3,6 +3,6 @@ exception Unknown of Source.region * string
 val link : Ast.module_ -> Instance.extern list (* raises Unknown *)
 
 val register :
-  string ->
-  (string -> Types.external_type -> Instance.extern (* raise Not_found *)) ->
+  Ast.name ->
+  (Ast.name -> Types.external_type -> Instance.extern (* raise Not_found *)) ->
   unit
diff --git a/interpreter/host/import/env.ml b/interpreter/host/import/env.ml
index 9414fd179..07dab62f7 100644
--- a/interpreter/host/import/env.ml
+++ b/interpreter/host/import/env.ml
@@ -40,7 +40,7 @@ let exit vs =
 
 
 let lookup name t =
-  match name, t with
+  match Utf8.encode name, t with
   | "abort", ExternalFuncType t -> ExternalFunc (HostFunc (t, abort))
   | "exit", ExternalFuncType t -> ExternalFunc (HostFunc (t, exit))
   | _ -> raise Not_found
diff --git a/interpreter/host/import/spectest.ml b/interpreter/host/import/spectest.ml
index de9537517..a5e076254 100644
--- a/interpreter/host/import/spectest.ml
+++ b/interpreter/host/import/spectest.ml
@@ -28,7 +28,7 @@ let print (FuncType (_, out)) vs =
 
 
 let lookup name t =
-  match name, t with
+  match Utf8.encode name, t with
   | "print", ExternalFuncType t -> ExternalFunc (HostFunc (t, print t))
   | "print", _ ->
     let t = FuncType ([], []) in ExternalFunc (HostFunc (t, print t))
diff --git a/interpreter/host/js.ml b/interpreter/host/js.ml
index fff314c25..1d66dc18d 100644
--- a/interpreter/host/js.ml
+++ b/interpreter/host/js.ml
@@ -139,14 +139,15 @@ let harness =
 (* Context *)
 
 module Map = Map.Make(String)
+module ExportMap = Instance.ExportMap
 
-type exports = external_type Map.t
+type exports = external_type ExportMap.t
 type modules = {mutable env : exports Map.t; mutable current : int}
 
 let exports m : exports =
   List.fold_left
-    (fun map exp -> Map.add exp.it.name (export_type m exp) map)
-    Map.empty m.it.exports
+    (fun map exp -> ExportMap.add exp.it.name (export_type m exp) map)
+    ExportMap.empty m.it.exports
 
 let modules () : modules = {env = Map.empty; current = 0}
 
@@ -167,8 +168,9 @@ let lookup (mods : modules) x_opt name at =
       raise (Eval.Crash (at, 
         if x_opt = None then "no module defined within script"
         else "unknown module " ^ of_var_opt mods x_opt ^ " within script"))
-  in try Map.find name exports with Not_found ->
-    raise (Eval.Crash (at, "unknown export \"" ^ name ^ "\" within module"))
+  in try ExportMap.find name exports with Not_found ->
+    raise (Eval.Crash (at, "unknown export \"" ^
+      String.escaped (Utf8.encode name) ^ "\" within module"))
 
 
 (* Wrappers *)
@@ -245,7 +247,7 @@ let wrap module_name item_name wrap_action wrap_assertion at =
   let types = FuncType ([], []) :: itypes in
   let imports = [{module_name; item_name; idesc} @@ at] in
   let edesc = FuncExport item @@ at in
-  let exports = [{name = "run"; edesc} @@ at] in
+  let exports = [{name = Utf8.decode "run"; edesc} @@ at] in
   let body =
     [ Block ([], action @ assertion @ [Return @@ at]) @@ at;
       Unreachable @@ at ]
@@ -286,6 +288,7 @@ let of_string_with add_char s =
 
 let of_bytes = of_string_with add_hex_char
 let of_string = of_string_with add_char
+let of_name n = of_string (Utf8.encode n)
 
 let of_float z =
   match string_of_float z with
@@ -311,14 +314,14 @@ let of_definition def =
 
 let of_wrapper mods x_opt name wrap_action wrap_assertion at =
   let x = of_var_opt mods x_opt in
-  let bs = wrap x name wrap_action wrap_assertion at in
+  let bs = wrap (Utf8.decode x) name wrap_action wrap_assertion at in
   "call(instance(" ^ of_bytes bs ^ ", " ^
     "exports(" ^ of_string x ^ ", " ^ x ^ ")), " ^ " \"run\", [])"
 
 let of_action mods act =
   match act.it with
   | Invoke (x_opt, name, lits) ->
-    "call(" ^ of_var_opt mods x_opt ^ ", " ^ of_string name ^ ", " ^
+    "call(" ^ of_var_opt mods x_opt ^ ", " ^ of_name name ^ ", " ^
       "[" ^ String.concat ", " (List.map of_literal lits) ^ "])",
     (match lookup mods x_opt name act.at with
     | ExternalFuncType ft when not (is_js_func_type ft) ->
@@ -327,7 +330,7 @@ let of_action mods act =
     | _ -> None
     )
   | Get (x_opt, name) ->
-    "get(" ^ of_var_opt mods x_opt ^ ", " ^ of_string name ^ ")",
+    "get(" ^ of_var_opt mods x_opt ^ ", " ^ of_name name ^ ")",
     (match lookup mods x_opt name act.at with
     | ExternalGlobalType gt when not (is_js_global_type gt) ->
       let GlobalType (t, _) = gt in
@@ -383,7 +386,7 @@ let of_command mods cmd =
     (if x_opt = None then "" else
     "let " ^ of_var_opt mods x_opt ^ " = " ^ current_var mods ^ ";\n")
   | Register (name, x_opt) ->
-    "register(" ^ of_string name ^ ", " ^ of_var_opt mods x_opt ^ ")\n"
+    "register(" ^ of_name name ^ ", " ^ of_var_opt mods x_opt ^ ")\n"
   | Action act ->
     of_assertion' mods act "run" [] None ^ "\n"
   | Assertion ass ->
diff --git a/interpreter/host/main.ml b/interpreter/host/main.ml
index 5e62cab15..ab09cbd22 100644
--- a/interpreter/host/main.ml
+++ b/interpreter/host/main.ml
@@ -2,8 +2,8 @@ let name = "wasm"
 let version = "0.7"
 
 let configure () =
-  Import.register "spectest" Spectest.lookup;
-  Import.register "env" Env.lookup
+  Import.register (Utf8.decode "spectest") Spectest.lookup;
+  Import.register (Utf8.decode "env") Env.lookup
 
 let banner () =
   print_endline
diff --git a/interpreter/host/run.ml b/interpreter/host/run.ml
index 3e041c9a5..1f7a9c22c 100644
--- a/interpreter/host/run.ml
+++ b/interpreter/host/run.ml
@@ -188,6 +188,8 @@ let input_stdin run =
 
 (* Printing *)
 
+let string_of_name n = String.escaped (Utf8.encode n)
+
 let print_import m im =
   let open Types in
   let category, annotation =
@@ -198,7 +200,8 @@ let print_import m im =
     | ExternalGlobalType t -> "global", string_of_global_type t
   in
   Printf.printf "  import %s %S %S : %s\n"
-    category im.it.Ast.module_name im.it.Ast.item_name annotation
+    category (string_of_name im.it.Ast.module_name)
+      (string_of_name im.it.Ast.item_name) annotation
 
 let print_export m ex =
   let open Types in
@@ -210,7 +213,7 @@ let print_export m ex =
     | ExternalGlobalType t -> "global", string_of_global_type t
   in
   Printf.printf "  export %s %S : %s\n"
-    category (String.escaped ex.it.Ast.name) annotation
+    category (string_of_name ex.it.Ast.name) annotation
 
 let print_module x_opt m =
   Printf.printf "module%s :\n"
@@ -272,7 +275,7 @@ let run_definition def =
 let run_action act =
   match act.it with
   | Invoke (x_opt, name, vs) ->
-    trace ("Invoking function \"" ^ name ^ "\"...");
+    trace ("Invoking function \"" ^ string_of_name name ^ "\"...");
     let inst = lookup_instance x_opt act.at in
     (match Instance.export inst name with
     | Some (Instance.ExternalFunc f) ->
@@ -282,7 +285,7 @@ let run_action act =
     )
 
  | Get (x_opt, name) ->
-    trace ("Getting global \"" ^ name ^ "\"...");
+    trace ("Getting global \"" ^ string_of_name name ^ "\"...");
     let inst = lookup_instance x_opt act.at in
     (match Instance.export inst name with
     | Some (Instance.ExternalGlobal v) -> [v]
@@ -298,7 +301,10 @@ let assert_result at correct got print_expect expect =
   end
 
 let assert_message at name msg re =
-  if String.sub msg 0 (String.length re) <> re then begin
+  if
+    String.length msg < String.length re ||
+    String.sub msg 0 (String.length re) <> re
+  then begin
     print_endline ("Result: \"" ^ msg ^ "\"");
     print_endline ("Expect: \"" ^ re ^ "\"");
     Assert.error at ("wrong " ^ name ^ " error")
@@ -419,10 +425,10 @@ let rec run_command cmd =
   | Register (name, x_opt) ->
     quote := cmd :: !quote;
     if not !Flags.dry then begin
-      trace ("Registering module \"" ^ name ^ "\"...");
+      trace ("Registering module \"" ^ string_of_name name ^ "\"...");
       let inst = lookup_instance x_opt cmd.at in
-      registry := Map.add name inst !registry;
-      Import.register name (lookup_registry name)
+      registry := Map.add (Utf8.encode name) inst !registry;
+      Import.register name (lookup_registry (Utf8.encode name))
     end
 
   | Action act ->
diff --git a/interpreter/spec/ast.ml b/interpreter/spec/ast.ml
index 94822eb7a..3604bbc1e 100644
--- a/interpreter/spec/ast.ml
+++ b/interpreter/spec/ast.ml
@@ -65,6 +65,7 @@ type storeop = Memory.mem_size memop
 
 type var = int32 Source.phrase
 type literal = Values.value Source.phrase
+type name = int list
 
 type instr = instr' Source.phrase
 and instr' =
@@ -156,7 +157,7 @@ and export_desc' =
 type export = export' Source.phrase
 and export' =
 {
-  name : string;
+  name : name;
   edesc : export_desc;
 }
 
@@ -170,8 +171,8 @@ and import_desc' =
 type import = import' Source.phrase
 and import' =
 {
-  module_name : string;
-  item_name : string;
+  module_name : name;
+  item_name : name;
   idesc : import_desc;
 }
 
diff --git a/interpreter/spec/decode.ml b/interpreter/spec/decode.ml
index 2cca12456..3c4dfd490 100644
--- a/interpreter/spec/decode.ml
+++ b/interpreter/spec/decode.ml
@@ -114,6 +114,11 @@ let rec list f n s = if n = 0 then [] else let x = f s in x :: list f (n - 1) s
 let opt f b s = if b then Some (f s) else None
 let vec f s = let n = len32 s in list f n s
 
+let name s =
+  let pos = pos s in
+  try Utf8.decode (string s) with Utf8.Utf8 ->
+    error s pos "invalid UTF-8 encoding"
+
 let sized f s =
   let size = len32 s in
   let start = pos s in
@@ -491,8 +496,8 @@ let import_desc s =
   | _ -> error s (pos s - 1) "invalid import kind"
 
 let import s =
-  let module_name = string s in
-  let item_name = string s in
+  let module_name = name s in
+  let item_name = name s in
   let idesc = at import_desc s in
   {module_name; item_name; idesc}
 
@@ -548,7 +553,7 @@ let export_desc s =
   | _ -> error s (pos s - 1) "invalid export kind"
 
 let export s =
-  let name = string s in
+  let name = name s in
   let edesc = at export_desc s in
   {name; edesc}
 
@@ -607,7 +612,7 @@ let data_section s =
 
 let custom size s =
   let start = pos s in
-  let _id = string s in
+  let _id = name s in
   skip (size - (pos s - start)) s;
   true
 
diff --git a/interpreter/spec/encode.ml b/interpreter/spec/encode.ml
index c93e71edd..ca706b18b 100644
--- a/interpreter/spec/encode.ml
+++ b/interpreter/spec/encode.ml
@@ -71,6 +71,7 @@ let encode m =
 
     let bool b = vu1 (if b then 1 else 0)
     let string bs = len (String.length bs); put_string s bs
+    let name n = string (Utf8.encode n)
     let list f xs = List.iter f xs
     let opt f xo = Lib.Option.app f xo
     let vec f xs = len (List.length xs); list f xs
@@ -390,7 +391,7 @@ let encode m =
 
     let import im =
       let {module_name; item_name; idesc} = im.it in
-      string module_name; string item_name; import_desc idesc
+      name module_name; name item_name; import_desc idesc
 
     let import_section ims =
       section 2 (vec import) ims (ims <> [])
@@ -434,8 +435,8 @@ let encode m =
       | GlobalExport x -> u8 3; var x
 
     let export ex =
-      let {name; edesc} = ex.it in
-      string name; export_desc edesc
+      let {name = n; edesc} = ex.it in
+      name n; export_desc edesc
 
     let export_section exs =
       section 7 (vec export) exs (exs <> [])
diff --git a/interpreter/spec/instance.ml b/interpreter/spec/instance.ml
index 8c468bc9d..bcc019530 100644
--- a/interpreter/spec/instance.ml
+++ b/interpreter/spec/instance.ml
@@ -1,6 +1,6 @@
 open Values
 
-module ExportMap = Map.Make(String)
+module ExportMap = Map.Make(struct type t = Ast.name let compare = compare end)
 
 type global = value ref
 
diff --git a/interpreter/spec/utf8.ml b/interpreter/spec/utf8.ml
new file mode 100644
index 000000000..5cf17997e
--- /dev/null
+++ b/interpreter/spec/utf8.ml
@@ -0,0 +1,42 @@
+exception Utf8
+
+let con n = 0x80 lor (n land 0x3f)
+
+let rec encode ns = Lib.String.implode (List.map Char.chr (encode' ns))
+and encode' = function
+  | [] -> []
+  | n::ns when n < 0 ->
+    raise Utf8
+  | n::ns when n < 0x80 ->
+    n :: encode' ns
+  | n::ns when n < 0x800 ->
+    0xc0 lor (n lsr 6) :: con n :: encode' ns
+  | n::ns when n < 0x10000 ->
+    0xe0 lor (n lsr 12) :: con (n lsr 6) :: con n :: encode' ns
+  | n::ns when n < 0x110000 ->
+    0xf0 lor (n lsr 18) :: con (n lsr 12) :: con (n lsr 6) :: con n
+    :: encode' ns
+  | _ ->
+    raise Utf8
+
+let con b = if b land 0xc0 = 0x80 then b land 0x3f else raise Utf8
+let code min n =
+  if n < min || (0xd800 <= n && n < 0xe000) || n >= 0x110000 then raise Utf8
+  else n
+
+let rec decode s = decode' (List.map Char.code (Lib.String.explode s))
+and decode' = function
+  | [] -> []
+  | b1::bs when b1 < 0x80 ->
+    code 0x0 b1 :: decode' bs
+  | b1::bs when b1 < 0xc0 ->
+    raise Utf8
+  | b1::b2::bs when b1 < 0xe0 ->
+    code 0x80 ((b1 land 0x1f) lsl 6 + con b2) :: decode' bs
+  | b1::b2::b3::bs when b1 < 0xf0 ->
+    code 0x800 ((b1 land 0x0f) lsl 12 + con b2 lsl 6 + con b3) :: decode' bs
+  | b1::b2::b3::b4::bs when b1 < 0xf8 ->
+    code 0x10000 ((b1 land 0x07) lsl 18 + con b2 lsl 12 + con b3 lsl 6 + con b4)
+    :: decode' bs
+  | _ ->
+    raise Utf8
diff --git a/interpreter/spec/utf8.mli b/interpreter/spec/utf8.mli
new file mode 100644
index 000000000..589d87ec5
--- /dev/null
+++ b/interpreter/spec/utf8.mli
@@ -0,0 +1,4 @@
+exception Utf8
+
+val decode : string -> int list (* raise UTf8 *)
+val encode : int list -> string (* raise Utf8 *)
diff --git a/interpreter/spec/valid.ml b/interpreter/spec/valid.ml
index 77ce2c01f..e596c92ea 100644
--- a/interpreter/spec/valid.ml
+++ b/interpreter/spec/valid.ml
@@ -409,7 +409,7 @@ let check_import (im : import) (c : context) : context =
       "mutable globals cannot be imported (yet)";
     {c with globals = t :: c.globals}
 
-module NameSet = Set.Make(String)
+module NameSet = Set.Make(struct type t = Ast.name let compare = compare end)
 
 let check_export (c : context) (set : NameSet.t) (ex : export) : NameSet.t =
   let {name; edesc} = ex.it in
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 18bc51f48..3eb2a0661 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -29,6 +29,7 @@ let string_with add_char s =
 
 let bytes = string_with add_hex_char
 let string = string_with add_char
+let name n = string (Utf8.encode n)
 
 let list_of_opt = function None -> [] | Some x -> [x]
 
@@ -307,7 +308,7 @@ let import_desc i d =
 let import i im =
   let {module_name; item_name; idesc} = im.it in
   Node ("import",
-    [atom string module_name; atom string item_name; import_desc i idesc]
+    [atom name module_name; atom name item_name; import_desc i idesc]
   )
 
 let export_desc d =
@@ -318,8 +319,8 @@ let export_desc d =
   | GlobalExport x -> Node ("global", [atom var x])
 
 let export ex =
-  let {name; edesc} = ex.it in
-  Node ("export", [atom string name; export_desc edesc])
+  let {name = n; edesc} = ex.it in
+  Node ("export", [atom name n; export_desc edesc])
 
 let global off i g =
   let {gtype; value} = g.it in
@@ -392,8 +393,8 @@ let definition mode x_opt def =
       | Encoded (_, bs) -> bs
     in binary_module_with_var_opt x_opt bs
 
-let access x_opt name =
-  String.concat " " [var_opt x_opt; string name]
+let access x_opt n =
+  String.concat " " [var_opt x_opt; name n]
 
 let action act =
   match act.it with
@@ -426,8 +427,8 @@ let assertion mode ass =
 let command mode cmd =
   match cmd.it with
   | Module (x_opt, def) -> definition mode x_opt def
-  | Register (name, x_opt) ->
-    Node ("register " ^ string name ^ var_opt x_opt, [])
+  | Register (n, x_opt) ->
+    Node ("register " ^ name n ^ var_opt x_opt, [])
   | Action act -> action act
   | Assertion ass -> assertion mode ass
   | Meta _ -> assert false
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index e784a59c4..31db274eb 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -48,6 +48,9 @@ let nat s at =
 let nat32 s at =
   try I32.of_string_u s with Failure _ -> error at "i32 constant out of range"
 
+let name s at =
+  try Utf8.decode s with Utf8.Utf8 -> error at "invalid UTF-8 encoding"
+
 
 (* Symbolic variables *)
 
@@ -196,6 +199,9 @@ let inline_type (c : context) ty at =
 
 /* Auxiliaries */
 
+name :
+  | TEXT { name $1 (at ()) }
+
 text_list :
   | /* empty */ { "" }
   | text_list TEXT { $1 ^ $2 }
@@ -537,7 +543,7 @@ import_desc :
     { fun c -> ignore ($3 c anon_global bind_global); GlobalImport $4 }
 
 import :
-  | LPAR IMPORT TEXT TEXT import_desc RPAR
+  | LPAR IMPORT name name import_desc RPAR
     { let at = at () and at5 = ati 5 in
       fun c -> {module_name = $3; item_name = $4; idesc = $5 c @@ at5} @@ at }
   | LPAR FUNC bind_var_opt inline_import type_use RPAR  /* Sugar */
@@ -567,7 +573,7 @@ import :
         idesc = GlobalImport $5 @@ at } @@ at }
 
 inline_import :
-  | LPAR IMPORT TEXT TEXT RPAR { $3, $4 }
+  | LPAR IMPORT name name RPAR { $3, $4 }
 
 export_desc :
   | LPAR FUNC var RPAR { fun c -> FuncExport ($3 c func) }
@@ -576,7 +582,7 @@ export_desc :
   | LPAR GLOBAL var RPAR { fun c -> GlobalExport ($3 c global) }
 
 export :
-  | LPAR EXPORT TEXT export_desc RPAR
+  | LPAR EXPORT name export_desc RPAR
     { let at = at () and at4 = ati 4 in
       fun c -> {name = $3; edesc = $4 c @@ at4} @@ at }
 
@@ -585,7 +591,7 @@ inline_export_opt :
   | inline_export { $1 }
 
 inline_export :
-  | LPAR EXPORT TEXT RPAR
+  | LPAR EXPORT name RPAR
     { let at = at () in fun d c -> [{name = $3; edesc = d @@ at} @@ at] }
 
 
@@ -658,9 +664,9 @@ script_var_opt :
   | VAR { Some ($1 @@ at ()) }  /* Sugar */
 
 action :
-  | LPAR INVOKE script_var_opt TEXT const_list RPAR
+  | LPAR INVOKE script_var_opt name const_list RPAR
     { Invoke ($3, $4, $5) @@ at () }
-  | LPAR GET script_var_opt TEXT RPAR
+  | LPAR GET script_var_opt name RPAR
     { Get ($3, $4) @@ at() }
 
 assertion :
@@ -682,7 +688,7 @@ cmd :
   | action { Action $1 @@ at () }
   | assertion { Assertion $1 @@ at () }
   | module_ { Module (fst $1, snd $1) @@ at () }
-  | LPAR REGISTER TEXT script_var_opt RPAR { Register ($3, $4) @@ at () }
+  | LPAR REGISTER name script_var_opt RPAR { Register ($3, $4) @@ at () }
   | meta { Meta $1 @@ at () }
 
 cmd_list :
diff --git a/interpreter/text/script.ml b/interpreter/text/script.ml
index faa87e76f..11032f1f6 100644
--- a/interpreter/text/script.ml
+++ b/interpreter/text/script.ml
@@ -7,8 +7,8 @@ and definition' =
 
 type action = action' Source.phrase
 and action' =
-  | Invoke of var option * string * Ast.literal list
-  | Get of var option * string
+  | Invoke of var option * Ast.name * Ast.literal list
+  | Get of var option * Ast.name
 
 type assertion = assertion' Source.phrase
 and assertion' =
@@ -25,7 +25,7 @@ and assertion' =
 type command = command' Source.phrase
 and command' =
   | Module of var option * definition
-  | Register of string * var option
+  | Register of Ast.name * var option
   | Action of action
   | Assertion of assertion
   | Meta of meta
diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index 284329ecd..514077495 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -4,6 +4,37 @@ struct
     if n = 0 then () else (f x; repeat (n - 1) f x)
 end
 
+module Int =
+struct
+  let log2 n =
+    if n <= 0 then failwith "log2";
+    let rec loop acc n = if n = 1 then acc else loop (acc + 1) (n lsr 1) in
+    loop 0 n
+
+  let is_power_of_two n =
+    if n < 0 then failwith "is_power_of_two";
+    n <> 0 && n land (n - 1) = 0
+end
+
+module String =
+struct
+  let implode cs =
+    let buf = Buffer.create (List.length cs) in
+    List.iter (Buffer.add_char buf) cs;
+    Buffer.contents buf
+
+  let explode s =
+    let cs = ref [] in
+    for i = String.length s - 1 downto 0 do cs := s.[i] :: !cs done;
+    !cs
+
+  let breakup s n =
+    let rec loop i =
+      let len = min n (String.length s - i) in
+      if len = 0 then [] else String.sub s i len :: loop (i + len)
+    in loop 0
+end
+
 module List =
 struct
   let rec make n x =
@@ -128,24 +159,3 @@ struct
     | Some x -> f x
     | None -> ()
 end
-
-module Int =
-struct
-  let log2 n =
-    if n <= 0 then failwith "log2";
-    let rec loop acc n = if n = 1 then acc else loop (acc + 1) (n lsr 1) in
-    loop 0 n
-
-  let is_power_of_two n =
-    if n < 0 then failwith "is_power_of_two";
-    n <> 0 && n land (n - 1) = 0
-end
-
-module String =
-struct
-  let breakup s n =
-    let rec loop i =
-      let len = min n (String.length s - i) in
-      if len = 0 then [] else String.sub s i len :: loop (i + len)
-    in loop 0
-end
diff --git a/interpreter/util/lib.mli b/interpreter/util/lib.mli
index 293070c03..5704e067c 100644
--- a/interpreter/util/lib.mli
+++ b/interpreter/util/lib.mli
@@ -64,5 +64,7 @@ end
 
 module String :
 sig
+  val implode : char list -> string
+  val explode : string -> char list
   val breakup : string -> int -> string list
 end
diff --git a/interpreter/winmake.bat b/interpreter/winmake.bat
index e86d11985..40489fd45 100644
--- a/interpreter/winmake.bat
+++ b/interpreter/winmake.bat
@@ -17,6 +17,7 @@ ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I h
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/table.cmi spec/table.mli
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/instance.cmo spec/instance.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/eval.cmi spec/eval.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/utf8.cmi spec/utf8.mli
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/encode.cmi spec/encode.mli
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host/import -I util -I spec -I host -I text -o host/import/env.cmo host/import/env.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host -I util -I spec -I text -I host/import -o host/flags.cmo host/flags.ml
@@ -38,16 +39,17 @@ ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -I spec -I text -I host/import -o host/import.d.cmo host/import.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -I spec -I text -I host/import -o host/run.d.cmo host/run.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host/import -I util -I spec -I host -I text -o host/import/spectest.d.cmo host/import/spectest.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/utf8.d.cmo spec/utf8.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/ast.d.cmo spec/ast.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I spec -I host -I text -I host/import -o util/error.d.cmo util/error.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/f32.d.cmo spec/f32.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/f64.d.cmo spec/f64.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/i32.d.cmo spec/i32.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I spec -I host -I text -I host/import -o util/lib.d.cmo util/lib.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/memory.d.cmo spec/memory.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I spec -I host -I text -I host/import -o util/source.d.cmo util/source.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/types.d.cmo spec/types.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/values.d.cmo spec/values.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/i32.d.cmo spec/i32.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/i64.d.cmo spec/i64.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/float.d.cmo spec/float.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/int.d.cmo spec/int.ml
@@ -83,4 +85,4 @@ ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I spec -I host -I host/import -o text/parser.d.cmo text/parser.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I spec -I host -I host/import -o text/arrange.d.cmo text/arrange.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I spec -I host -I text -I host/import -o util/sexpr.d.cmo util/sexpr.ml
-ocamlc.opt str.cma bigarray.cma -g host/flags.d.cmo spec/float.d.cmo spec/f32.d.cmo spec/f64.d.cmo spec/numeric_error.d.cmo spec/int.d.cmo spec/i32.d.cmo spec/i64.d.cmo spec/types.d.cmo spec/values.d.cmo util/lib.d.cmo spec/memory.d.cmo util/source.d.cmo spec/ast.d.cmo spec/table.d.cmo spec/instance.d.cmo util/error.d.cmo host/import.d.cmo spec/i32_convert.d.cmo spec/f32_convert.d.cmo spec/i64_convert.d.cmo spec/f64_convert.d.cmo spec/eval_numeric.d.cmo spec/eval.d.cmo host/import/env.d.cmo host/import/spectest.d.cmo spec/encode.d.cmo spec/operators.d.cmo spec/decode.d.cmo text/script.d.cmo host/js.d.cmo spec/valid.d.cmo text/parser.d.cmo text/lexer.d.cmo text/parse.d.cmo util/sexpr.d.cmo text/arrange.d.cmo text/print.d.cmo host/run.d.cmo host/main.d.cmo -o %NAME%.exe
+ocamlc.opt bigarray.cma -g host/flags.d.cmo spec/float.d.cmo spec/f32.d.cmo spec/f64.d.cmo spec/numeric_error.d.cmo spec/int.d.cmo spec/i32.d.cmo spec/i64.d.cmo spec/types.d.cmo spec/values.d.cmo util/lib.d.cmo spec/memory.d.cmo util/source.d.cmo spec/ast.d.cmo spec/table.d.cmo spec/instance.d.cmo spec/utf8.d.cmo util/error.d.cmo host/import.d.cmo spec/i32_convert.d.cmo spec/f32_convert.d.cmo spec/i64_convert.d.cmo spec/f64_convert.d.cmo spec/eval_numeric.d.cmo spec/eval.d.cmo host/import/env.d.cmo host/import/spectest.d.cmo spec/encode.d.cmo spec/operators.d.cmo spec/decode.d.cmo text/script.d.cmo host/js.d.cmo spec/valid.d.cmo text/parser.d.cmo text/lexer.d.cmo text/parse.d.cmo util/sexpr.d.cmo text/arrange.d.cmo text/print.d.cmo host/run.d.cmo host/main.d.cmo -o %NAME%.exe

From 232f5a6c8ab50fdaa5703db3cc814d68fc69d55a Mon Sep 17 00:00:00 2001
From: Dan Gohman <sunfish@mozilla.com>
Date: Fri, 5 May 2017 09:25:48 -0700
Subject: [PATCH 015/329] Utf8 tests (#469)

* Test UTF-8 identifier validation.

* Fix custom section lengths.

Fix an error in the custom section lengths, so that the modules are
valid except for the particular aspect being tested.

* Avoid invalid UTF-8 byte sequences in comments.
---
 test/core/names.wast                  |    4 +
 test/core/utf8-custom-section-id.wast | 1792 +++++++++++++++++
 test/core/utf8-import-field.wast      | 2672 +++++++++++++++++++++++++
 test/core/utf8-import-module.wast     | 2672 +++++++++++++++++++++++++
 4 files changed, 7140 insertions(+)
 create mode 100644 test/core/utf8-custom-section-id.wast
 create mode 100644 test/core/utf8-import-field.wast
 create mode 100644 test/core/utf8-import-module.wast

diff --git a/test/core/names.wast b/test/core/names.wast
index 07b4deb58..907d82fb5 100644
--- a/test/core/names.wast
+++ b/test/core/names.wast
@@ -46,6 +46,9 @@
   ;; Test that we can use some libc hidden names without conflict.
   (func (export "_malloc") (result f32) (f32.const 0x1.93p+2))
   (func (export "__malloc") (result f32) (f32.const 0x1.94p+2))
+
+  ;; Test that UTF-8 BOM characters can appear in identifiers.
+  (func (export "") (result f32) (f32.const 0x2.04p+2))
 )
 
 (assert_return (invoke "") (f32.const 0x1.91p+2))
@@ -60,6 +63,7 @@
 (assert_return (invoke "NaN") (f32.const 0x2.01p+2))
 (assert_return (invoke "Infinity") (f32.const 0x2.02p+2))
 (assert_return (invoke "if") (f32.const 0x2.03p+2))
+(assert_return (invoke "") (f32.const 0x2.04p+2))
 
 (module
   ;; Test that we can use indices instead of names to reference imports,
diff --git a/test/core/utf8-custom-section-id.wast b/test/core/utf8-custom-section-id.wast
new file mode 100644
index 000000000..040c3ea37
--- /dev/null
+++ b/test/core/utf8-custom-section-id.wast
@@ -0,0 +1,1792 @@
+;;;;;; Invalid UTF-8 custom section names
+
+;;;; Continuation bytes not preceded by prefixes
+
+;; encoding starts with (first) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\80"                       ;; "\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0x8f) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\8f"                       ;; "\8f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0x90) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\90"                       ;; "\90"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0x9f) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\9f"                       ;; "\9f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0xa0) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\a0"                       ;; "\a0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (last) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\bf"                       ;; "\bf"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 2-byte sequences
+
+;; 2-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\c2\80\80"                 ;; "\c2\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\c2"                       ;; "\c2"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\2e"                    ;; "\c2."
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 2-byte sequence contents
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c0\80"                    ;; "\c0\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c0\bf"                    ;; "\c0\bf"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c1\80"                    ;; "\c1\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c1\bf"                    ;; "\c1\bf"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a contination byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\00"                    ;; "\c2\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\7f"                    ;; "\c2\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\c0"                    ;; "\c2\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\c2\fd"                    ;; "\c2\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\00"                    ;; "\df\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\7f"                    ;; "\df\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\c0"                    ;; "\df\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\df\fd"                    ;; "\df\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 3-byte sequences
+
+;; 3-byte sequence contains 4 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\e1\80\80\80"              ;; "\e1\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\e1\80"                    ;; "\e1\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\2e"                 ;; "\e1\80."
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\e1"                       ;; "\e1"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\e1\2e"                    ;; "\e1."
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\00\a0"                 ;; "\e0\00\a0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\7f\a0"                 ;; "\e0\7f\a0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\80\80"                 ;; "\e0\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\80\a0"                 ;; "\e0\80\a0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\9f\a0"                 ;; "\e0\9f\a0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\9f\bf"                 ;; "\e0\9f\bf"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\c0\a0"                 ;; "\e0\c0\a0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\fd\a0"                 ;; "\e0\fd\a0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\00\80"                 ;; "\e1\00\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\7f\80"                 ;; "\e1\7f\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\c0\80"                 ;; "\e1\c0\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\fd\80"                 ;; "\e1\fd\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\00\80"                 ;; "\ec\00\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\7f\80"                 ;; "\ec\7f\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\c0\80"                 ;; "\ec\c0\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\fd\80"                 ;; "\ec\fd\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\00\80"                 ;; "\ed\00\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\7f\80"                 ;; "\ed\7f\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\a0\80"                 ;; "\ed\a0\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\a0\bf"                 ;; "\ed\a0\bf"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\bf\80"                 ;; "\ed\bf\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\bf\bf"                 ;; "\ed\bf\bf"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\c0\80"                 ;; "\ed\c0\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\fd\80"                 ;; "\ed\fd\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\00\80"                 ;; "\ee\00\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\7f\80"                 ;; "\ee\7f\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\c0\80"                 ;; "\ee\c0\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\fd\80"                 ;; "\ee\fd\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\00\80"                 ;; "\ef\00\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\7f\80"                 ;; "\ef\7f\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\c0\80"                 ;; "\ef\c0\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\fd\80"                 ;; "\ef\fd\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents (third byte)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\00"                 ;; "\e0\a0\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\7f"                 ;; "\e0\a0\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\c0"                 ;; "\e0\a0\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e0\a0\fd"                 ;; "\e0\a0\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\00"                 ;; "\e1\80\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\7f"                 ;; "\e1\80\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\c0"                 ;; "\e1\80\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\e1\80\fd"                 ;; "\e1\80\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\00"                 ;; "\ec\80\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\7f"                 ;; "\ec\80\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\c0"                 ;; "\ec\80\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ec\80\fd"                 ;; "\ec\80\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\00"                 ;; "\ed\80\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\7f"                 ;; "\ed\80\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\c0"                 ;; "\ed\80\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ed\80\fd"                 ;; "\ed\80\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\00"                 ;; "\ee\80\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\7f"                 ;; "\ee\80\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\c0"                 ;; "\ee\80\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ee\80\fd"                 ;; "\ee\80\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\00"                 ;; "\ef\80\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\7f"                 ;; "\ef\80\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\c0"                 ;; "\ef\80\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\ef\80\fd"                 ;; "\ef\80\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequences
+
+;; 4-byte sequence contains 5 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\f1\80\80\80\80"           ;; "\f1\80\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f1\80\80"                 ;; "\f1\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\23"              ;; "\f1\80\80#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f1\80"                    ;; "\f1\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f1\80\23"                 ;; "\f1\80#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\f1"                       ;; "\f1"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f1\23"                    ;; "\f1#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\00\90\90"              ;; "\f0\00\90\90"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\7f\90\90"              ;; "\f0\7f\90\90"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\80\80\80"              ;; "\f0\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\80\90\90"              ;; "\f0\80\90\90"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\8f\90\90"              ;; "\f0\8f\90\90"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\8f\bf\bf"              ;; "\f0\8f\bf\bf"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\c0\90\90"              ;; "\f0\c0\90\90"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\fd\90\90"              ;; "\f0\fd\90\90"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\00\80\80"              ;; "\f1\00\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\7f\80\80"              ;; "\f1\7f\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\c0\80\80"              ;; "\f1\c0\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\fd\80\80"              ;; "\f1\fd\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\00\80\80"              ;; "\f3\00\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\7f\80\80"              ;; "\f3\7f\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\c0\80\80"              ;; "\f3\c0\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\fd\80\80"              ;; "\f3\fd\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\00\80\80"              ;; "\f4\00\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\7f\80\80"              ;; "\f4\7f\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (first) invalid code point
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\90\80\80"              ;; "\f4\90\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; invalid code point
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\bf\80\80"              ;; "\f4\bf\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\c0\80\80"              ;; "\f4\c0\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\fd\80\80"              ;; "\f4\fd\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (first) invalid 4-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f5\80\80\80"              ;; "\f5\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 4-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f7\80\80\80"              ;; "\f7\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 4-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f7\bf\bf\bf"              ;; "\f7\bf\bf\bf"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (third byte)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\00\90"              ;; "\f0\90\00\90"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\7f\90"              ;; "\f0\90\7f\90"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\c0\90"              ;; "\f0\90\c0\90"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\fd\90"              ;; "\f0\90\fd\90"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\00\80"              ;; "\f1\80\00\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\7f\80"              ;; "\f1\80\7f\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\c0\80"              ;; "\f1\80\c0\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\fd\80"              ;; "\f1\80\fd\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\00\80"              ;; "\f3\80\00\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\7f\80"              ;; "\f3\80\7f\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\c0\80"              ;; "\f3\80\c0\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\fd\80"              ;; "\f3\80\fd\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\00\80"              ;; "\f4\80\00\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\7f\80"              ;; "\f4\80\7f\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\c0\80"              ;; "\f4\80\c0\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\fd\80"              ;; "\f4\80\fd\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (fourth byte)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\00"              ;; "\f0\90\90\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\7f"              ;; "\f0\90\90\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\c0"              ;; "\f0\90\90\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f0\90\90\fd"              ;; "\f0\90\90\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\00"              ;; "\f1\80\80\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\7f"              ;; "\f1\80\80\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\c0"              ;; "\f1\80\80\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f1\80\80\fd"              ;; "\f1\80\80\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\00"              ;; "\f3\80\80\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\7f"              ;; "\f3\80\80\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\c0"              ;; "\f3\80\80\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f3\80\80\fd"              ;; "\f3\80\80\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\00"              ;; "\f4\80\80\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\7f"              ;; "\f4\80\80\7f"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\c0"              ;; "\f4\80\80\c0"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f4\80\80\fd"              ;; "\f4\80\80\fd"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 5-byte sequences
+
+;; 5-byte sequence contains 6 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\f8\80\80\80\80\80"        ;; "\f8\80\80\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f8\80\80\80"              ;; "\f8\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\f8\80\80\80\23"           ;; "\f8\80\80\80#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f8\80\80"                 ;; "\f8\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\f8\80\80\23"              ;; "\f8\80\80#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f8\80"                    ;; "\f8\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\f8\80\23"                 ;; "\f8\80#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\f8"                       ;; "\f8"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\f8\23"                    ;; "\f8#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 5-byte sequence contents
+
+;; (first) invalid 5-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\f8\80\80\80\80"           ;; "\f8\80\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 5-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\fb\bf\bf\bf\bf"           ;; "\fb\bf\bf\bf\bf"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 6-byte sequences
+
+;; 6-byte sequence contains 7 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\08"                       ;; custom section
+    "\07\fc\80\80\80\80\80\80"     ;; "\fc\80\80\80\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\fc\80\80\80\80"           ;; "\fc\80\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\fc\80\80\80\80\23"        ;; "\fc\80\80\80\80#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\fc\80\80\80"              ;; "\fc\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\06"                       ;; custom section
+    "\05\fc\80\80\80\23"           ;; "\fc\80\80\80#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\fc\80\80"                 ;; "\fc\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\fc\80\80\23"              ;; "\fc\80\80#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\fc\80"                    ;; "\fc\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\04"                       ;; custom section
+    "\03\fc\80\23"                 ;; "\fc\80#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\fc"                       ;; "\fc"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\fc\23"                    ;; "\fc#"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 6-byte sequence contents
+
+;; (first) invalid 6-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\fc\80\80\80\80\80"        ;; "\fc\80\80\80\80\80"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 6-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\07"                       ;; custom section
+    "\06\fd\bf\bf\bf\bf\bf"        ;; "\fd\bf\bf\bf\bf\bf"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; Miscellaneous invalid bytes
+
+;; invalid byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\fe"                       ;; "\fe"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; invalid byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\02"                       ;; custom section
+    "\01\ff"                       ;; "\ff"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-16BE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\fe\ff"                    ;; "\fe\ff"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-32BE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\00\00\fe\ff"              ;; "\00\00\fe\ff"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-16LE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\03"                       ;; custom section
+    "\02\ff\fe"                    ;; "\ff\fe"
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-32LE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00\05"                       ;; custom section
+    "\04\ff\fe\00\00"              ;; "\ff\fe\00\00"
+  )
+  "invalid UTF-8 encoding"
+)
+
diff --git a/test/core/utf8-import-field.wast b/test/core/utf8-import-field.wast
new file mode 100644
index 000000000..256eb8a48
--- /dev/null
+++ b/test/core/utf8-import-field.wast
@@ -0,0 +1,2672 @@
+;;;;;; Invalid UTF-8 import field names
+
+;;;; Continuation bytes not preceded by prefixes
+
+;; encoding starts with (first) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\80"                       ;; "\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0x8f) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\8f"                       ;; "\8f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0x90) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\90"                       ;; "\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0x9f) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\9f"                       ;; "\9f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0xa0) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\a0"                       ;; "\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (last) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\bf"                       ;; "\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 2-byte sequences
+
+;; 2-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\c2\80\80"                 ;; "\c2\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\c2"                       ;; "\c2"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\2e"                    ;; "\c2."
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 2-byte sequence contents
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c0\80"                    ;; "\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c0\bf"                    ;; "\c0\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c1\80"                    ;; "\c1\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c1\bf"                    ;; "\c1\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a contination byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\00"                    ;; "\c2\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\7f"                    ;; "\c2\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\c0"                    ;; "\c2\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\c2\fd"                    ;; "\c2\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\00"                    ;; "\df\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\7f"                    ;; "\df\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\c0"                    ;; "\df\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\df\fd"                    ;; "\df\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 3-byte sequences
+
+;; 3-byte sequence contains 4 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\e1\80\80\80"              ;; "\e1\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\e1\80"                    ;; "\e1\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\2e"                 ;; "\e1\80."
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\e1"                       ;; "\e1"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\e1\2e"                    ;; "\e1."
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\00\a0"                 ;; "\e0\00\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\7f\a0"                 ;; "\e0\7f\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\80\80"                 ;; "\e0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\80\a0"                 ;; "\e0\80\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\9f\a0"                 ;; "\e0\9f\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\9f\bf"                 ;; "\e0\9f\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\c0\a0"                 ;; "\e0\c0\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\fd\a0"                 ;; "\e0\fd\a0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\00\80"                 ;; "\e1\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\7f\80"                 ;; "\e1\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\c0\80"                 ;; "\e1\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\fd\80"                 ;; "\e1\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\00\80"                 ;; "\ec\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\7f\80"                 ;; "\ec\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\c0\80"                 ;; "\ec\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\fd\80"                 ;; "\ec\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\00\80"                 ;; "\ed\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\7f\80"                 ;; "\ed\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\a0\80"                 ;; "\ed\a0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\a0\bf"                 ;; "\ed\a0\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\bf\80"                 ;; "\ed\bf\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\bf\bf"                 ;; "\ed\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\c0\80"                 ;; "\ed\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\fd\80"                 ;; "\ed\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\00\80"                 ;; "\ee\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\7f\80"                 ;; "\ee\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\c0\80"                 ;; "\ee\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\fd\80"                 ;; "\ee\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\00\80"                 ;; "\ef\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\7f\80"                 ;; "\ef\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\c0\80"                 ;; "\ef\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\fd\80"                 ;; "\ef\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents (third byte)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\00"                 ;; "\e0\a0\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\7f"                 ;; "\e0\a0\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\c0"                 ;; "\e0\a0\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e0\a0\fd"                 ;; "\e0\a0\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\00"                 ;; "\e1\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\7f"                 ;; "\e1\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\c0"                 ;; "\e1\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\e1\80\fd"                 ;; "\e1\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\00"                 ;; "\ec\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\7f"                 ;; "\ec\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\c0"                 ;; "\ec\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ec\80\fd"                 ;; "\ec\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\00"                 ;; "\ed\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\7f"                 ;; "\ed\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\c0"                 ;; "\ed\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ed\80\fd"                 ;; "\ed\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\00"                 ;; "\ee\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\7f"                 ;; "\ee\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\c0"                 ;; "\ee\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ee\80\fd"                 ;; "\ee\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\00"                 ;; "\ef\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\7f"                 ;; "\ef\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\c0"                 ;; "\ef\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\ef\80\fd"                 ;; "\ef\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequences
+
+;; 4-byte sequence contains 5 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\f1\80\80\80\80"           ;; "\f1\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f1\80\80"                 ;; "\f1\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\23"              ;; "\f1\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f1\80"                    ;; "\f1\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f1\80\23"                 ;; "\f1\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\f1"                       ;; "\f1"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f1\23"                    ;; "\f1#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\00\90\90"              ;; "\f0\00\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\7f\90\90"              ;; "\f0\7f\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\80\80\80"              ;; "\f0\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\80\90\90"              ;; "\f0\80\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\8f\90\90"              ;; "\f0\8f\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\8f\bf\bf"              ;; "\f0\8f\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\c0\90\90"              ;; "\f0\c0\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\fd\90\90"              ;; "\f0\fd\90\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\00\80\80"              ;; "\f1\00\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\7f\80\80"              ;; "\f1\7f\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\c0\80\80"              ;; "\f1\c0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\fd\80\80"              ;; "\f1\fd\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\00\80\80"              ;; "\f3\00\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\7f\80\80"              ;; "\f3\7f\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\c0\80\80"              ;; "\f3\c0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\fd\80\80"              ;; "\f3\fd\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\00\80\80"              ;; "\f4\00\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\7f\80\80"              ;; "\f4\7f\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (first) invalid code point
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\90\80\80"              ;; "\f4\90\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; invalid code point
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\bf\80\80"              ;; "\f4\bf\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\c0\80\80"              ;; "\f4\c0\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\fd\80\80"              ;; "\f4\fd\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (first) invalid 4-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f5\80\80\80"              ;; "\f5\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 4-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f7\80\80\80"              ;; "\f7\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 4-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f7\bf\bf\bf"              ;; "\f7\bf\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (third byte)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\00\90"              ;; "\f0\90\00\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\7f\90"              ;; "\f0\90\7f\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\c0\90"              ;; "\f0\90\c0\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\fd\90"              ;; "\f0\90\fd\90"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\00\80"              ;; "\f1\80\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\7f\80"              ;; "\f1\80\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\c0\80"              ;; "\f1\80\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\fd\80"              ;; "\f1\80\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\00\80"              ;; "\f3\80\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\7f\80"              ;; "\f3\80\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\c0\80"              ;; "\f3\80\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\fd\80"              ;; "\f3\80\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\00\80"              ;; "\f4\80\00\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\7f\80"              ;; "\f4\80\7f\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\c0\80"              ;; "\f4\80\c0\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\fd\80"              ;; "\f4\80\fd\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (fourth byte)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\00"              ;; "\f0\90\90\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\7f"              ;; "\f0\90\90\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\c0"              ;; "\f0\90\90\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f0\90\90\fd"              ;; "\f0\90\90\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\00"              ;; "\f1\80\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\7f"              ;; "\f1\80\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\c0"              ;; "\f1\80\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f1\80\80\fd"              ;; "\f1\80\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\00"              ;; "\f3\80\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\7f"              ;; "\f3\80\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\c0"              ;; "\f3\80\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f3\80\80\fd"              ;; "\f3\80\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\00"              ;; "\f4\80\80\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\7f"              ;; "\f4\80\80\7f"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\c0"              ;; "\f4\80\80\c0"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f4\80\80\fd"              ;; "\f4\80\80\fd"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 5-byte sequences
+
+;; 5-byte sequence contains 6 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\f8\80\80\80\80\80"        ;; "\f8\80\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f8\80\80\80"              ;; "\f8\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\f8\80\80\80\23"           ;; "\f8\80\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f8\80\80"                 ;; "\f8\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\f8\80\80\23"              ;; "\f8\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f8\80"                    ;; "\f8\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\f8\80\23"                 ;; "\f8\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\f8"                       ;; "\f8"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\f8\23"                    ;; "\f8#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 5-byte sequence contents
+
+;; (first) invalid 5-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\f8\80\80\80\80"           ;; "\f8\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 5-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\fb\bf\bf\bf\bf"           ;; "\fb\bf\bf\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 6-byte sequences
+
+;; 6-byte sequence contains 7 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\11"                       ;; import section
+    "\01"                          ;; length 1
+    "\07\fc\80\80\80\80\80\80"     ;; "\fc\80\80\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\fc\80\80\80\80"           ;; "\fc\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\fc\80\80\80\80\23"        ;; "\fc\80\80\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\fc\80\80\80"              ;; "\fc\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\05\fc\80\80\80\23"           ;; "\fc\80\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\fc\80\80"                 ;; "\fc\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\fc\80\80\23"              ;; "\fc\80\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\fc\80"                    ;; "\fc\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\03\fc\80\23"                 ;; "\fc\80#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\fc"                       ;; "\fc"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\fc\23"                    ;; "\fc#"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 6-byte sequence contents
+
+;; (first) invalid 6-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\fc\80\80\80\80\80"        ;; "\fc\80\80\80\80\80"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 6-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\06\fd\bf\bf\bf\bf\bf"        ;; "\fd\bf\bf\bf\bf\bf"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; Miscellaneous invalid bytes
+
+;; invalid byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\fe"                       ;; "\fe"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; invalid byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\01\ff"                       ;; "\ff"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-16BE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\fe\ff"                    ;; "\fe\ff"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-32BE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\00\00\fe\ff"              ;; "\00\00\fe\ff"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-16LE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\02\ff\fe"                    ;; "\ff\fe"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-32LE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\ff\fe\00\00"              ;; "\ff\fe\00\00"
+    "\04\74\65\73\74"              ;; "test"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
diff --git a/test/core/utf8-import-module.wast b/test/core/utf8-import-module.wast
new file mode 100644
index 000000000..900f6bfb8
--- /dev/null
+++ b/test/core/utf8-import-module.wast
@@ -0,0 +1,2672 @@
+;;;;;; Invalid UTF-8 import module names
+
+;;;; Continuation bytes not preceded by prefixes
+
+;; encoding starts with (first) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\80"                       ;; "\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0x8f) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\8f"                       ;; "\8f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0x90) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\90"                       ;; "\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0x9f) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\9f"                       ;; "\9f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (0xa0) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\a0"                       ;; "\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; encoding starts with (last) continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\bf"                       ;; "\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 2-byte sequences
+
+;; 2-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\c2\80\80"                 ;; "\c2\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\c2"                       ;; "\c2"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 2-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\2e"                    ;; "\c2."
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 2-byte sequence contents
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c0\80"                    ;; "\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c0\bf"                    ;; "\c0\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c1\80"                    ;; "\c1\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xc1 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c1\bf"                    ;; "\c1\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a contination byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\00"                    ;; "\c2\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\7f"                    ;; "\c2\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\c0"                    ;; "\c2\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (first) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\c2\fd"                    ;; "\c2\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\00"                    ;; "\df\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\7f"                    ;; "\df\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\c0"                    ;; "\df\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte after (last) 2-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\df\fd"                    ;; "\df\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 3-byte sequences
+
+;; 3-byte sequence contains 4 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\e1\80\80\80"              ;; "\e1\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\e1\80"                    ;; "\e1\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\2e"                 ;; "\e1\80."
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\e1"                       ;; "\e1"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 3-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\e1\2e"                    ;; "\e1."
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\00\a0"                 ;; "\e0\00\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\7f\a0"                 ;; "\e0\7f\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\80\80"                 ;; "\e0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\80\a0"                 ;; "\e0\80\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\9f\a0"                 ;; "\e0\9f\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xe0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\9f\bf"                 ;; "\e0\9f\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\c0\a0"                 ;; "\e0\c0\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\fd\a0"                 ;; "\e0\fd\a0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\00\80"                 ;; "\e1\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\7f\80"                 ;; "\e1\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\c0\80"                 ;; "\e1\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\fd\80"                 ;; "\e1\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\00\80"                 ;; "\ec\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\7f\80"                 ;; "\ec\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\c0\80"                 ;; "\ec\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\fd\80"                 ;; "\ec\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\00\80"                 ;; "\ed\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\7f\80"                 ;; "\ed\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\a0\80"                 ;; "\ed\a0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\a0\bf"                 ;; "\ed\a0\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\bf\80"                 ;; "\ed\bf\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; byte sequence reserved for UTF-16 surrogate half
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\bf\bf"                 ;; "\ed\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\c0\80"                 ;; "\ed\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\fd\80"                 ;; "\ed\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\00\80"                 ;; "\ee\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\7f\80"                 ;; "\ee\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\c0\80"                 ;; "\ee\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\fd\80"                 ;; "\ee\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\00\80"                 ;; "\ef\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\7f\80"                 ;; "\ef\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\c0\80"                 ;; "\ef\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\fd\80"                 ;; "\ef\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 3-byte sequence contents (third byte)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\00"                 ;; "\e0\a0\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\7f"                 ;; "\e0\a0\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\c0"                 ;; "\e0\a0\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xe0) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e0\a0\fd"                 ;; "\e0\a0\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\00"                 ;; "\e1\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\7f"                 ;; "\e1\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\c0"                 ;; "\e1\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\e1\80\fd"                 ;; "\e1\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\00"                 ;; "\ec\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\7f"                 ;; "\ec\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\c0"                 ;; "\ec\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ec\80\fd"                 ;; "\ec\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\00"                 ;; "\ed\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\7f"                 ;; "\ed\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\c0"                 ;; "\ed\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xed) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ed\80\fd"                 ;; "\ed\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\00"                 ;; "\ee\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\7f"                 ;; "\ee\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\c0"                 ;; "\ee\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ee\80\fd"                 ;; "\ee\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\00"                 ;; "\ef\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\7f"                 ;; "\ef\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\c0"                 ;; "\ef\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 3-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\ef\80\fd"                 ;; "\ef\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequences
+
+;; 4-byte sequence contains 5 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\f1\80\80\80\80"           ;; "\f1\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f1\80\80"                 ;; "\f1\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\23"              ;; "\f1\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f1\80"                    ;; "\f1\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f1\80\23"                 ;; "\f1\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\f1"                       ;; "\f1"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 4-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f1\23"                    ;; "\f1#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\00\90\90"              ;; "\f0\00\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\7f\90\90"              ;; "\f0\7f\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\80\80\80"              ;; "\f0\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\80\90\90"              ;; "\f0\80\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\8f\90\90"              ;; "\f0\8f\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; overlong encoding after 0xf0 prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\8f\bf\bf"              ;; "\f0\8f\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\c0\90\90"              ;; "\f0\c0\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\fd\90\90"              ;; "\f0\fd\90\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\00\80\80"              ;; "\f1\00\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\7f\80\80"              ;; "\f1\7f\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\c0\80\80"              ;; "\f1\c0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\fd\80\80"              ;; "\f1\fd\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\00\80\80"              ;; "\f3\00\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\7f\80\80"              ;; "\f3\7f\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\c0\80\80"              ;; "\f3\c0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\fd\80\80"              ;; "\f3\fd\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\00\80\80"              ;; "\f4\00\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\7f\80\80"              ;; "\f4\7f\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (first) invalid code point
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\90\80\80"              ;; "\f4\90\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; invalid code point
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\bf\80\80"              ;; "\f4\bf\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\c0\80\80"              ;; "\f4\c0\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; first byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\fd\80\80"              ;; "\f4\fd\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (first) invalid 4-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f5\80\80\80"              ;; "\f5\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 4-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f7\80\80\80"              ;; "\f7\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 4-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f7\bf\bf\bf"              ;; "\f7\bf\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (third byte)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\00\90"              ;; "\f0\90\00\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\7f\90"              ;; "\f0\90\7f\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\c0\90"              ;; "\f0\90\c0\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\fd\90"              ;; "\f0\90\fd\90"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\00\80"              ;; "\f1\80\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\7f\80"              ;; "\f1\80\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\c0\80"              ;; "\f1\80\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\fd\80"              ;; "\f1\80\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\00\80"              ;; "\f3\80\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\7f\80"              ;; "\f3\80\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\c0\80"              ;; "\f3\80\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\fd\80"              ;; "\f3\80\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\00\80"              ;; "\f4\80\00\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\7f\80"              ;; "\f4\80\7f\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\c0\80"              ;; "\f4\80\c0\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; second byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\fd\80"              ;; "\f4\80\fd\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 4-byte sequence contents (fourth byte)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\00"              ;; "\f0\90\90\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\7f"              ;; "\f0\90\90\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\c0"              ;; "\f0\90\90\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf0) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f0\90\90\fd"              ;; "\f0\90\90\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\00"              ;; "\f1\80\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\7f"              ;; "\f1\80\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\c0"              ;; "\f1\80\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (first normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f1\80\80\fd"              ;; "\f1\80\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\00"              ;; "\f3\80\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\7f"              ;; "\f3\80\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\c0"              ;; "\f3\80\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (last normal) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f3\80\80\fd"              ;; "\f3\80\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\00"              ;; "\f4\80\80\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\7f"              ;; "\f4\80\80\7f"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\c0"              ;; "\f4\80\80\c0"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; third byte after (0xf4) 4-byte prefix not a continuation byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f4\80\80\fd"              ;; "\f4\80\80\fd"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 5-byte sequences
+
+;; 5-byte sequence contains 6 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\f8\80\80\80\80\80"        ;; "\f8\80\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f8\80\80\80"              ;; "\f8\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 4 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\f8\80\80\80\23"           ;; "\f8\80\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f8\80\80"                 ;; "\f8\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\f8\80\80\23"              ;; "\f8\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f8\80"                    ;; "\f8\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\f8\80\23"                 ;; "\f8\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\f8"                       ;; "\f8"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 5-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\f8\23"                    ;; "\f8#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 5-byte sequence contents
+
+;; (first) invalid 5-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\f8\80\80\80\80"           ;; "\f8\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 5-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\fb\bf\bf\bf\bf"           ;; "\fb\bf\bf\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 6-byte sequences
+
+;; 6-byte sequence contains 7 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\11"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\07\fc\80\80\80\80\80\80"     ;; "\fc\80\80\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\fc\80\80\80\80"           ;; "\fc\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 5 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\fc\80\80\80\80\23"        ;; "\fc\80\80\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\fc\80\80\80"              ;; "\fc\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 4 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0f"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\05\fc\80\80\80\23"           ;; "\fc\80\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\fc\80\80"                 ;; "\fc\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 3 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\fc\80\80\23"              ;; "\fc\80\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\fc\80"                    ;; "\fc\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 2 bytes
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0d"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\03\fc\80\23"                 ;; "\fc\80#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte at end of string
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\fc"                       ;; "\fc"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; 6-byte sequence contains 1 byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\fc\23"                    ;; "\fc#"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; 6-byte sequence contents
+
+;; (first) invalid 6-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\fc\80\80\80\80\80"        ;; "\fc\80\80\80\80\80"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; (last) invalid 6-byte prefix
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\10"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\06\fd\bf\bf\bf\bf\bf"        ;; "\fd\bf\bf\bf\bf\bf"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;;;; Miscellaneous invalid bytes
+
+;; invalid byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\fe"                       ;; "\fe"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; invalid byte
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0b"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\01\ff"                       ;; "\ff"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-16BE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\fe\ff"                    ;; "\fe\ff"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-32BE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\00\00\fe\ff"              ;; "\00\00\fe\ff"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-16LE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0c"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\02\ff\fe"                    ;; "\ff\fe"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+
+;; UTF-32LE BOM
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\02\0e"                       ;; import section
+    "\01"                          ;; length 1
+    "\04\74\65\73\74"              ;; "test"
+    "\04\ff\fe\00\00"              ;; "\ff\fe\00\00"
+    "\03"                          ;; GlobalImport
+    "\7f"                          ;; i32
+    "\00"                          ;; immutable
+  )
+  "invalid UTF-8 encoding"
+)
+

From 27da124848f3ebf899cf26ded3332a1dd0e37ed9 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Mon, 15 May 2017 12:55:29 +0200
Subject: [PATCH 016/329] Update paper

---
 papers/pldi2017.pdf | Bin 2486556 -> 2501487 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git a/papers/pldi2017.pdf b/papers/pldi2017.pdf
index ee581fc6a38b4ebac01994062cbb90b1ddd3047d..05d59de972abb7165fb09d012818323a1c3205ca 100644
GIT binary patch
delta 129406
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

delta 114728
zcmZVlV{oQV)b<O<wr$(CZBA@VcttarBxh{fb~3S(iEZ1N*mmaqKlgs_+HckVwyJye
z>Z<<I-N)}(*URbP+52hW@f1*;ygb}V1?zM`Gr?NoX3MRS3A^)=mNgm1?y1nKfWt&=
ziU!k=0>wG_K;N|5K0A#ZeO0Y0DOp(dp*QcE!qRfXTpK}5H~ZIF-JPze(B1Wmi0}Q$
z?X!9p0tR^yo#CJMZ_oi)`sp<oqFC}ozqc=Rue-_|)k$}q{~&*kp2vm;w4U?bO~w)e
zpJR_aAHKdE)-$`ug@P1VsGPZaohU+@m*eM;@4TYm$nXwK4Rnce13XB<q*7JCBc;Ha
z(2!Nne7`ptIhP>(!6hKica8ljsrR&5_lWm~z0lcqTgZ%?%_!cUG5>?SKlm$$^u4M%
zx{Gn!fTl{yGJ<q>nIl>nDH|?C!|7lL@G)Ul$EQOtM+z54^|e1cHLicQ{!LMP(ha6O
zfRHh2j=#Vj#Dy7wst8pNR}{VSQecNd&88>Q{Vdu1tKK!=j?t(#XtdLM(88EqtqQMP
z7QvrN6kDA}S7A`ROYHOKwVD+D&9jhG$7P(ymFMUCIjvKciwqxJMDS~GAe*N<Am|i&
z>yXBjLT1M$M!Gl8!)%Psl<Qq8?C^xca=<I9mgUr6vStkqM@ux%3~KwH=8TH`JGKn{
zrzZ2ZVK#!O4kP?`IWG^^sE=~xu@S$y<k5>PhkNPj#8=-wDLzfNrLFN!{Ca~^MA3}K
zn*BdR2`!&31Ug+YetafW6xhAc01QRs7P81nGiJ(B_@XnWKX4^l1G(dd`|g?ZmMgN@
zYkTIa!Q(XD^B`-)M8t<8O@xXeP*?e?kzCSURvnyhvyhIOy{W0?U=pMj{FHugbv0EQ
z9F#xn@PMm4D|Y43%7jsXaE*~_ij^7}2dc{N_2xjZ4!m1<_Sr03_YBboFcO*JnCw@Q
zZB$jtL}zQ-gDvy3K*M#Yx`Nx61~KPIe`7tfV_u}hv>5u(%9nT`g4n*z=3IWu@lpgK
zZ-Aehk5TUAhoqTGGj2WpzCysjwB^<PxC{lSQa^#Hb7k=GT57^>!MK*w!B=(-SboA>
zXE|85Lp;Y3^9nH8$c_yGwkRB>l)=Kh%B~{~y-pOV6r5wk5(AX{<FCi)$-k7~P#{?L
zsPZ>BhM!&&j_tze&!)+EX$F}cYjOu%Zp`u!HqIMfB%++~%HDkg{sviCG}vx#b0HNX
z05X>gzt;?r1gp)wt*UpAHay_40@4fxzSO;_*a~b$ode|4_~9f05$~W;W+ch#vG<mf
zns(`D=&hfPyeOLYY0hZ=oCl^vJNTwvFqRGp<k}1UN+Eu~1-Ko{&SSI0Y+}&je_Gph
zhH68jzR=!4w15VH`R}I#ba<5}$BwR`AI1J@oL%2EC6mR<iKkDZ8Vs<K0zFZ?G*-fl
zNo`wHiNvZ6oG9pkaAqdpy!2purj)7m=((FOM{VEMdSGW9j~8yaA*##H)%rVwrq}Xm
zTRm+OZU<A&hBeGUnrQE#raB4%Ot^~Mi@AWfV4coP>nlnSyTvy>hDnI)N@zDRG+FC#
z`!^hNQmz-t1rE>(&*<gMGGDOfm@j9wySo<$!+@vVFD+vrpJx>7Hnh8q9b$KMe0~wu
zK9ngn*tvJ|ilB+wW=|~F^muy}B0G_=@>Q~-nGyHZ@J_ttP-<SGi}3WaMsQ$0_BT<*
z8s`NIiMc9@kOggez_Y~&B>@UzL_HTF%gEY97O$_pINX_26Rd`Dxy^`N>P^EcY8n#X
zvJQRON>4j*((rZ`H;sZ7C``T<?7Zbb_%~3qqiF8e6<hcVuh~6GYaiu%#B)?A<M%C!
z>NYTNe(gCAORchrb7~2>y3;x~I+QNW4We(zh_eo2S}w?kFnd{(W#GlWHzk+16DamI
zTc^8F;XiFrX<((5qzId9p365r7f&E6=SkO;)tIJ%wmvxrUfwcrr@c0JcJgAZptKE~
z$L(w}-`z^yRqWV^*gNm<cq!k%GaY!k<F6pIVtJE#Z@8jX&h)1SRY2^3t>ENtU1r3D
zQx(PZPUjm_xG&Q=@Hc?Xe~90CjMZ^REn{Ufz8H1otMMZSp=GIqG2vCJuuW>QBMAnv
z?_@*)d)l0IBKAQ^Uc4l9e^T}slx6JETaJ|QxW+ol5PkZlUBTm(5;FoPA!<NT&X74Q
zh-ju;0^g_3+&Gv!3~+ncdC?(Y^%Cok<s@B9vEOk6v?=x%9dD2zG9)3Z3UEhZT62cB
z&;6eJ{t{c{VWO%MuODXBe?t?$xsDURaw`Z1{{Fls0`IeIQVJPQG`p$tB$g=`@Ak62
zbx<)`TP{<ujE9-gyW^xsP|lY!k0?}&kc<7*^^YK(h@Lm;gRLnyW&Ilu?&R;CVkKky
zQTMhyRz&bFNu06Y20vtGWB-JTR@QxT(sGW5$9JaUCCKl|?ioerpFZ<*26IrPg1l|B
zfwxLWkOlK5QSQtwc1vv155H&|%h$f8Hom>I?rl%$LrbIwyyP#<IUa6kOfSV{6Sexu
zM;jr<g)7`zdQ3Am(C&%{62_*da0L!q(fliVKZ0T;zDc^<3F+&fy_S{%=GzXp<J|`|
zRL-1m$EIJVLbM}Otm$(`d4_R+T5>8vfrZILB2#~@z%!mU3x8_doso~qBDBi2Xa1it
zze)ual+De!)4wAuj<w3gZedB&z0?=~L%PoDs$D&njGBTOl)!@9TU>Wxm~A56I>VY^
z8OE`k(asLgB{dZ0GL%wb%hCp`gfR+_)U4gXM*HQde0`*%K_(MDwkExw?xIjl1el2F
zP*y`xkYDF=(^9>4Fr&!o?)b~K^BMHdV=I~R78!(+*SLI6*>d&>nDs)@ujtksyT|@O
z#6_3f6mq@%b?YZ{dicCAV^tlDDuEYTFUR3k+b9I}FeaZitu7t46(3)O-f&-+y_H<T
zDQP(0vOdN^tMvmcsGcbV8<YKz8|Y1DHayQABfqL(qa+{sP&H%U%XE#02wDpJ#fXnu
zjKk91do`2|e}g3_{k7}FIh}!HTkbr#!vIglFJjiD901xkvGwDaD9@LMNI}Ba=CIZx
zl)-iQ&EoZibX-RU?LCvSyFDLBK3M2$bjl(MYUT@o%a!FKDxg4+c(d3_2Br#j^$;lM
z6VRpG@p{#+dd>bQl9A)EazU0ggkg<`yjrm@j<VtZ;9!LRuo$o?&GxEl`S>Iu+E8cv
zSp3^zqJrEG!eBAn(@m$)tdK(frZhGdO560Nb%76+QKT2Xgb*48Zci&PP!kx6^9Z`S
zf;c3*@$;2m=E2iI5$k)C1$-N#FJm1SNMkoG;z9#2!I<&wW`c+Pi|kL_s7d9x(}EOQ
zOgYGCC^GIJaBq$u(l&IJCn$5c$ebQ%13R~~>0`RCD~EFU^9%1VUEYn#x0Bez%XkW{
zCmZ#pq1S;oOp9z|J(=Tm<`zzrJ{5-<J-M9J;KZ2b%bJOO#8W~&;Ao>kpJ?@(Nt@Ud
zZ>YoHfD6K()Xk{rs|ACU>0l@1dI*C#38a+1Y5vU+8#SPCn%o}pUCKC?BDjKYA1!td
zZC7<mSFq-k)gCfa-Kz>LH}WbHqpsltSXObeM8Io4{UmAlsjyggT8VE7-xsO1DVBK~
z74aG>PP6J+!_TM>Fr}(Eb=qq{kE@7PjrGFRNQLzZp$?MQemhoL-5J2!3V;;wu!tI2
zEBzR>CUTT$O<x6p!p3exPA#agZTH?+GR{pm8|Rn!X%6%rcsA3qli@fw+3g6MF45D6
zP2HNalL~4t`K%~N%Q`dgHv1O@sRmy!Ef&&#;kGK-e!g)43K~^d<}rMKX@j{G=mM1*
zZGTuHCT0aJ@e9d^<e3FCeawbb)#^vO97JFt??HYal*(pF!XI7SXFm|29paTVN`cRa
zu^ay|-1+nK;hoY4=~lN-p+e7+!GQiW3Tu9%%R87@BUpd;tJT`$@x&RocBFAig1&)F
zzk&>#{U*8s7?8km>&dWQl2jkx45AUmM8N2So%>5mAy>Eu9jX5%)?u0I&m<JiG`b<3
z-A=Jm%^*#|U!`CaJ|aPUMnY9quNL8rH)Tgxj1*ee!pS@sxr-n95hzu3`ItTQq9aOI
zw9WnLOQ#~X*YIM7MXNzop!j{biy2fahBbK|IWL?AC@BhEWmvv-bD4dT>cfZ2h;6W+
zqe}C!odb=SX@-C3ICr>E;oEY5%)Wa5#z1XgeT$|(ht@==Cd1zY%or@w;qXN#wMN-6
z#K}fp;t{UA<mYk~KfEx@DH4iN8wum9qxASYU6YdKfBw76H5B`S%3(#Pb;HI`QY?FH
zP%e}X5Zr6alEW^c5AnW>@ETfo1r3WuY6;IeL3M{~(yq2Z8mOJR;fSnrZ<+h}JO8#|
zqNYrEjm%x-JoLN1d1@m8kcz?*Aw{QdGYE~=>(wS$Q+D{Qx~<Os9&_7z_q3N>q(;uF
z%0B+xye$<N(}DtN(JoqWv64eg4+2n?)?p9;#LbOVl-}ggZB%r5CJ7{yL*d$Bz{e==
z@Nrj`{@}(`V{V}4kR=?eRp3$|1jqypW<r?dD~M#Z@{(D!Su)J=jpvvNQNW}bxp<Ey
zx!+E?Gu!+w!7>&37sOx$Ihaw^Gc?P7;Tw}%Ee@O+I0$3#(x`{ft7hMA4VrfI4g?Oc
zBnQ)HB(tzdf8PtPIY~zng$E12kF;cax_u~dpPVilBC<34XJWDsnS1Sel&PN1@JUZS
z?*$FlM`;|3r8=yC#mUVkU=j&V%^=B<`D$OCiAsDQT}8d8NJn&DlQur^<=&1QC(^tC
zm4Rp+O$st|XveknpFI*Usyi6n?!W?E&Uw;thup))3Q1jrhtg`2hxrh@$Ki&1b{X}{
zPxnS|=Uq>VjiHUM<}X1N9+`RNO2!D~<DsOmmPyZM>u}x-7~~feDKe%=>vp{$rv^Rz
zHBAArCBCl;g<ep`E-NZSTeqW0r<%ZR*$@og%>_Fyz034N8EflD<{<x^b+y`wKrfz6
zV8zMSRrdDFgSY6JNK@GU<EB3jcdFmHliW%enZaiCk7-f;!94yUeHe|b2rdsDZoHvS
zA+#Jztmr#>@<eYUk<_n}^EXuQP679%6twT)oJrv5G<ZB@Tx4uy8f2_8+`MGm|2O2|
zB}?k-!A#OX$AREsOCv!A$ARYNBxC1Db43MbNE)R^MpUwLvT?U1<KpM#_<z302Kq^x
zd?3G-+VWPb5l{85IN2C;OGWm^R7qlES=$GH3UwpATY|uBo$FdJW7GOdeFA<WKRYmZ
zv=GWTR?fM;D_7i$uS;#RLsisT<DQ8?qti6~<V%v+POh~>voo99tAcIcr|qqjin0s$
z=fk~$b1%DY0{lZit-ox@$R9vSPn5>B-Ht8Ozb-^gRbH=mI=HUNTJ9Bs`$rZeAv<MS
zZdc`2>rD5ln1TB(5hg`d*Za%!R^VS}Ryna!k*wjQ6KhWos-)<cn{i0J*E^qF*Xd8T
z6#GmYhhbw;rBd#H{U*J}9`lvk&m+QW%`;6v`B=8@bY63%K!(aa*d{O}{0VY-&01HY
z)msojpuDyljB#HLx1*F3s;D{oCJKsc*bGI@n4MW*Q{^}rElISqye<7@DUjXo_np{>
zOMZ9j;Pucr1T)y`Xe!Ch^j@hXPwLFoiGT*#Tj<H6szaf}1$wohE#Bg${a$yeLY8kV
z20Pj<j5abW3Ng-$_!!6ySuglEOz0mguUj_#!QL4_>wybB(RYAbbv^)IO6=YFnKVje
zx4R~P9#DnbDJ~I*d4EA^+@&VSl11o~#j*1?`GQLks5tsbl}PQ=rKs7qCQob{n`WL!
z)ms{YnFK5JMHSHnY-9I6!#b^sd!$wwiJC#z{292UgntU0NCb4I5V=#7w7AE=Ic9J_
z-+jlmaqm5lzKSebt(rpb5j|7)k`QS83Dv+Z0qJC$DVv=P^WaiSM)Ct#ZJKe}{Cz(7
zeY-7vU=;TIqpkX2<oqv1Z?Nx41lRrjzZN;@6IJG0iIfbnj0HC$#$ZoHD(d|ts0(HO
z*v!XZBgJIKV?F_;Rgd|5s7`$J9L{I$P$&n|=9sI#cm$@MV-N25RRO)LchcNX%T62=
z3Yv*F=P{JzHvGN0kMkK2KCu%1OSH2TLb)ms@;c2Lg0>0hkOWX|Q#;@KM%4L=^3)M&
zB5dBRQ?~|t)n&Cr<$C(=SBE+XWJOQaIUPBQ`RbS5@)Cj9y{GhJlkDNhD5-53mfGMP
zIu$DExI(lfp@8+w+z_@WGUMN$;6Hs3btJS6a2Urvij{KcI0R)}kC4z8qp`=~AlmV$
z$*NPr-{rcm9;8~=<4iJ4RX;ZuDdIko(h37eap(;KD99T_5xdC(hZ|wI5!7#Y69mq@
zYl4>_++6@@V>QKwNUdK#ySXs+ij||-@#pGY(g=E9V9d=~C&@gC{e$w9gmbRiry_|N
z^3z6^`q*53HK?%Upo};ka5bG-$`^1_q?2W?JoAS$1(G3Ebt^Fm-7VB=lwo*SS<t$5
zIIe=SQJJKCD`hy93=r!-g>(p>vjS~%l|1_G8F~Pi;iRGT2;}O_vEwYIh$;b+{B#$#
z9D=+IDH{7kQoRVX*5=HzB%JR{nbRLQPzg8*dsTAy1byT|DOm9Gjg0X0pHxggyJu1R
zQepkeMPi5Hj|lmyJkzU{gk0h4P&^eX18ceUCW|@?8ktiF5q3ixu$)gy;Pw?XM8_zM
z$7%r>Y<nR4E7TtO5zBBc%N}{?>)q`I`m|uALlcIc1y1on`QOW=h2BUBI(@?*?l|Ia
z=`oz2I+k=K{5z54OcVs96~(s+V!s%r7%BT)Nx_)&I=59fInP45sONi^@oYuizLR)o
z#6Fzk42&r}%ae`5GcLeu^Do;=7Hiyqqd)-2RV#&&QdO}8+BAUB)BS-wL2$d6Sc_j5
z#9a1pyM%%33~!q$Ot)@E1fQfWWrnr6!m8!~4ZJn;0;7jlOm&ga!*;)X0e9@(=zF%*
zvl8-cX??>c*VFwNBsM-!Od0|cgjTaq(kHi|Y{80vF&e3Tvz*C7W`~wbPR|<=H47Z*
z<)drlkYaLZLa9)TA66&o_$h}QHX-BGi6V;cB%q9eJsFW=Jgkcs@oE11^&0qN5|pC@
z?&}#C$5>i#{#{9#O=g(*CsCsi+PCHk-z}X9xoqOf*tfW~XdjLFpk};TgRr_fQs(Db
zX0e|aGj);Ov!)ZuBQfI28>Mn_IoJSC9cP6>o0@e1nx(sa$|nPo>#U0?Xymukulb4}
zJK7-xYBKfqP<PjEf~(4d4>L*PkXcd?qV*KneaQO`H7t5_pm)-<-w!ttrpUZMx%E5g
zFHLzEISANyg=PHo8f|@RH`T}nj4FTCa41Z3qU-Z5%Uky;8pn+OX(emg=<x#r)HHX)
zV48I@q1{8|#0EkfT@>e(jZ>q1O&`F+10E2<_W0P;4vtiB>4ypqvhY6iZxrPt$d^RC
zu&Wy(M-{pSI{u^(AtQadglYIV)>cG4`22u@BozHRI`}1l=`ZRxpOVQ;o~(r<4K~an
z?Yb}xTSZHgFiW<&ca$#^U*8Up|5Rq#qN+DK$HwXki~)nto}wxVW>oT`0HP1D;TeBc
zBkk)d#P1imakfg}5YpC_>)#~$A<pkoIuSFFCn8+C>G|xb=scHJFt_IPG30D9vS`zI
zX8(DKF)2NWqVQT)r@MnI&XDG!AdD5(c?vE*M4*5V7W>EA<IfM*_3sTx8OukKf)_t<
zOZG{4-73yPLx7SVNU69=_}IKb>NS6nK_i*hHi|2hu6zAjAS7vclH+*jEq~t`N?MOb
z%()&8u~I`Mod3&yZ%l(Ciji#VCIw-8CZ@7EtC+oYm$Pq3jEc6o#*Q{sXuwjRgG6zM
zCxYI!bFb2PLSzW3vU(5TC9<D<6SAw5!>)~iT_oW8WzpVePdHMgoQmd-_bbNx3jf=n
z&xjgJ4)!~eU7&-y?_&moL-H`n?eO*pwqtVKPfcykT47|gO6Aa97o4iGUryDBXd5x$
zxPg2m26Zx=AP-`O7s4cCwozuG2e<F?ap<LSkiDX}xHagCQbeyn@R6(3y?E%ug)t0-
zia9QdRREQR6>V&K0A18TE4*KCWll~w)i;W2wLeG!WFghw4X3=fxH*#$h_B<{<>4Be
zvvQF(I@+i(gQ!jLjkLHMrO82I6!&G|8@(5?gF_E$LKN0PQHK*lj_dD_V;1i6dfT9=
zKteSJmhhFiFD?v#PbSlrwmPXV<ZgsWp)VN!COMNXIQ~#YviI0`pzGT`-mH%BO0whU
z4m0Y%Y@c>q`;ihS)Q*~0#$I^e2|h$`)5i_GnF!~=SjO@J{Q{Xm99DL4V6ngD5spzo
z2tl=kC{=DXWhjuGwqxU0wAqqVd<ZtU<9XUl{lDVy)VwF49^c#9GHbQO(PJKQkpare
z;=jA20w;lm=f<nu#4vzRhc2d3`AC^Qlrk2XN9>-^QtT!nKW7}(RCOun(llZBNQi4=
z&-Un=&J14#PJB9MJCdbG?2Ii_Ty|_ZQcYJluF_Qs1OCl{%ao`^{E}8O!MRC4_9vT?
zqFRt63y&Fa2foH;yk>~-NRsh%H%PUqI13FE|9v3Oox`p1)X;Ag%B8P#m$LmA)Sy(K
zl`V1ah*)R}pKG{6y>q+u`<^9J!(NjwKIyjTu6kOO9VIL!^YXOg*b`oO7kP2h1t1nP
zAe0J?GaT;@?n}IRMAH7_1k!c$FQ89rBXtBm6*2?d_UAPf%Yc?YUh$!a(s&|3lo$WR
zr$*uCv1hlJr4(ysQUt}2{LpARnIb-$Mxh8!aP-Et+-2Y*jN(y)8m9LYG}?L83YzKO
z|5g{}Z@`NobpO5wHyc%FRG@PR#1OcmvV=?PjevZ&flpd}r((vcp#U4}7n@M11EN-3
z=wJaY2@UG3n;U<2p>4IReZAK++G@T92N26JQ)igKPS#9Jo{>~scNSkLta}F!U6o_8
zcRXGumA#zNOia|^0|rQ4k-~%6E6L(0R0N1K?sXK~-`xE>A5SqfRG5EmRCEzxmsiB9
zRK+I=&iz|PMYo<<8l%dQtXjk9*m8=7;}l5S#3I;i=v~C6CM;0zc%XPjnnH>Ue1K{a
zNDCfvr7&`eP5LS1NUOAx(ch-zd?cMe!S7rm2cuKktuteo!<?aBomd#su#7EMNH{l=
zNugX~XbaDSl)O8-7CRr}F>!856V16CICAL5O3JkI-J&XE7dYM5kP>!s%9#gJQUTLz
zaaGlCCa|ue@dM2$923&r=$tcBlsmrjDR>;VSgl2~(ioj|?*Ac&R$ty2nI?|4wH_p*
z9zzB4cK?29q$rO;v~m{0VP=`Ra49D$|0wERT{#p9>um(89R5wKq(mtFeEnDQqC>xI
zM8#=5nrx?$Jqos2x3<wrvWn#sTmbZ0uZ!FO=6COBp4om0q6QBwWj>9k+8u?NN0T!D
zbrq@(Ige%-W2C*qRTr+F4<B<hN$WdTx$}O@N~t&+UI_6W9;1U!Y>b?S>AfbQoRXjG
zax(%ec$?C{Q5^5vpk;*SDAmT?MT?bVPW82r;^B0F62qQGi+_iwpU>C+A7GL*rv>$g
zT9Bf?2tV<rZllp1#dk;~BI0X=-4mt)hhmdrepe5iQlTwp@pKcQ0Vl8@RYB?MT^vJ!
z3f~O#ZLX?%BX2mvSSc8-FbJKMDzt$vRggLh<OyefH<pl4Z%uUy3i_NeAC3SoBM7&8
zN>d7m<DO1S6!5}fglO?Q0gQ$}pH)1sr{S0JM*f`_3FkS4zjbY_c#CNTF{?K=c{|)|
z;^T$5>Jf+qdS7?{&TLNwgWxH+=4yvwd(=U3_eg0lqx~?fjmCZ^n$f7MELJ?BN3sST
zsk3H?PezU^xoFl89tCv%6Gde=+&&&8FKZ(dwsR6rY8C&B;wh;m4@B^6*5|7`VW3L>
zJfZhNqe<Hyi22)cP&edf)M5BM?Z@oZq~II?3>H-Mx|LiW*9@a=#E}|20Q@a*bF2{f
zHH}%19AB|qX<ei-ILEB+u^5YI&2Wzc$Z{NNXG$u_f1;vxTv@{0X)b=&k&}(DQ+Id;
z-CDNhkb7+sZu;E{0S-w+xGD9Pz{@aAC|R`obAU-I{)fYnO$8r6YB}VuX{_f)%g7$j
zE|AM9Df~gnUTOmpYZDnd&L7!7M#4cC_)9*t4=|9ueTQixeF9$)Bod+=*k-yCB#?XI
zL?)wpG{kTv<Pq8sYv1!bM<n}Nq}>y-t%kleuvrfp1`;D>0xpBatK1=1VVGeRh`6QG
zheia6_I$qM63TCa;5%&3eo=)#7MlX=T;?WAVL<(mz0UR4Kd&%x?qE2)yhxAk2pYsF
zg`X-5Tj|6^I`39jR&&SPJq>)0tD|(9|F~BqTgXky@Ik^HbTp%UDbg}9LyeeO1%#~j
z26def%Ph?Q0?-_q{!AR^M<z~wBagS@Uh(?z-Arfx;=L_jXkOlUm70iYC{ZI+&DA>O
z{6!*GKtqRHdVl*b^*QfPcpK<Q%d91yB4ImM;+e;cH)C)829P)>v<P1^0h@(xRekDm
zB9NaZVi3DTfs5sNLTyyGAqW=NAp*-Rmn6Oh!NMa+3B;w%>P0R%vziDFA>HV(mQ-Ft
zd0U_<e0wwI7N!PkyepB3k$2~(4C*&}{EcLkQ)owZFwz&61=1PZc9rS8zHh7zOX~Uu
zL5oG|eT#M+8BUrEhfCmDU@lYpZ9D%qeU*Rl{Wn&b5YnhK1kX)xPHqt;^NIvwj(fG0
z3cIQ&3IGathxP`Wkc5cv0)OO-yVHmlc~_~SkEe9qrA21xTEx&Suu)A3VZd<ajQr$4
zHzax8ulR!P@h7-t?Y$`L@zk18&!>|7L!}C8*dHGT14KBt^hm1OTxy5w6mtpkw>?i4
z9fY=iSmrZ}{+!|;kD%61%uXa)HPp}laF9`$1SV9^vV8ilb)z^N9@-D~LN(p}%2Gy{
z=GEpOJ8lFpa4sPq&lVScSyy)&I*_ocvt&d{%%~OC=j)*^wz4;c+YX$@i#_>c`@8gh
z(q%j=^$NT3aO{e)<4I8#h!wO=p6LXdB_A87(-l5LLyHdeV&r?rA&eZCnOsj&Hd45U
z07{9B4N6=|LJ|fj-%jp49p){539g~!>k-cqEWAq&&bo(v^%rKC9JvNCWy<=2<#US&
z=I+5z+W6t6c7EC~3JU3bk;3%uU$wJuTm(bo!#2t2<hSv$B$(PZl^)>FPvqZ-uzs+`
zvG5)l3kx=#ICwCZM0LO>+PH@2V&%T30pDhKpDESn?nv%vO@E)k_N(^9!(v*J2sfi>
zz$hyT2)Uga7uAEK&=p2L9P*vKPft^xn07`><jE}vDrGtd#?aoruqA22T6g-0;2g0;
zz*+naV3>V_>~r*^h&3|Jt|pvLhHlQ;aUJW)wZtn)J{euldVSqnBCVAuhv{^|1;Y5L
zamVN5k{ooKYefKfPwt04nh!n(FIBDvXb*$8a;G4p#`lLa(N`d0cUE(EAsfXvgYhY-
zyzOX_Xc(GYRwI!DCgu`%Z|cUBfh`l{#$wryD;>Zpf>X5%2G%Nr<(Q!9!9$!lLmj<p
zaOnpzG6o!9SZSA#wh>Jf>@6w-<F{0m{K`=tuW|U3Cl4_XiY<VAjY1`zQIElpS@eNL
zwAAK3)jI7I=ES)x-EB`&Q+$)rA*$|oAGg?gIf4Kc$>t!;+Hv9?vxpy4(*ry!;(t}a
zh@l?%WG|=u)fRm2c^fr#EA2@Gzv#u0rO9eTZp5hmL7~;a1hVdxnH`a!Kg;fddQ^;M
z`?$-#P>WQKCDXv4DKWvhlTblqSnNFiN7zGP)v$7N_5fK}xskDRrHP|}Q$w(GrmbSo
z5G4_zBhd1&k+HM=f5kxV|38WFe>6b$H8LJ>_N2WiOeh{6Zm$0$|0TK5paSG#U{qd=
zDVbW{iMi{_+V&j{sGRp=@=Zg;5n4%FUY$K6#}J8N&}$$ALE#i!Oeiu#l<7~R+1sfB
zWuN;z=l!+&ot>W7E7+WEOLeE{j-LQfw4_W>H9B}Y^*%K<6J=sf40NS<t6#((UTU2E
zm=h%#M>!k1ti1+4u3#;)fjmNNJ2O*<H&^FhwqAjBm}|3ps=%A>RU$%Jl$v^GtZ$_h
zh%~3oH<2!GB;tz%Pg=Ha&=swy+dIDCQ=|)RwLTe_^{<~{IO1c88pr%k7-;m0#emNO
zy?>sJ`_k?35Te>wQthxGl3;HXe(W!ey`}eZN3SI=Rl)83;IX~Wz#dJ5Tm;zWRor7o
zZRXq0@(jEqd71L9umT!RR|sy@d*5>X$u#^63RTS@;Y7NCXR7giA3d9FC^CyeB+mwS
zfiF#45%Bxd+8k$?K|T$PT!I!m8a$DUOzrwkxN8mJM6rKpq50E)6>ppXq9>{x;XVxQ
z3&*n^2}3#!hI_JA05<gxR(){Vhc*2kd~}>Q$@wsb%9#oixFW{|fjl*n!uq3~m#<jB
zLBWR?99rP)Hoi54i~y{RKy=f#FMLwGLIXd1iOs0X769K^YnOQ(%D2gaS#NuT&bsV@
zR<2Jlr11jv3Z>*5zYQy%S#>Vi#6l`DD@U17so1Ap-7$*?&_oWoNk$VdTQv)E$|afz
zjkDIzB9l%tf7n4%DuBaf8w#24KtLiRLrSHXM7w$DZ$eZyS*^ehD@Y}0L=|lL+6KYV
zT1aNk4zy`|z#M`pgXwpp<Kt#2<DC|x;|A@uAsi?smPe_20h=MXg^f`&7Mi|;B+lF2
z!2KR_EYS`SPM9E$Ti_I}mB6t!<^AvI*yJD!nd|EZrYwB^H0@bOk9ckrUU%o~>D0eE
znls{RFqOnIcw}lby6w;7*^a$74&T#`4G_@b1m8tBF~q&hoFMg}{ok2##08K0ZnB)M
zSj_43fCsLR{+%}y$s?7O-Pigf7!|+eiHqYR(31^_J8XbS9ND^n;lT5?erUg>+lWmh
z$|$(G3i~*`abolqznO#e(>bb*j6p>wb^8mJ?#NO611w|9##0qoNGwd2O#Z~$aY~~}
z-pkqjtUrPqg|Pfu)kgKe8|ihCv*ue4nnb0{fRLto*P&?pxS?)>PLb}Pd~x_yl_U-S
zgjxY~l@WrI9hvs}G{yu^YeTI3$+lZOY-eYYturDu?O-Tjch8jm))RYf&xWBSAxV8?
zuk=jbbcQ7r!lA3rjg+7dCe&l^c3SCWCFUkh$<sYvX@vv^w%CPHEsOONj#)6_uVvS8
z117PZ1;hl5x5@%t79p(IDhAxUkotr(6~sS4k4u=4GD^$ASjMEx7PD%?qu&VsL5SuE
z#K0P~k1(xA%bB<Lc0l*LD=3*pgM4HOvpci&ORq)zmoCOnBZo3A50e(y<vMY=6!H5N
z|HtpvS@_}0vhwkr6+g#RI`Z8#N^u!cM*LgRg}3xke28!8U5Q$>w;nGOd|HkJ5ecw?
z>$zt&m?vAqyc0|VB3S-qNB!#7A%<{=Z~h`a?Tr><`R(1MENO~aJbZB9$~26flv6rE
z#QkCwMO^HvS=sVP!7Mf~1F?S;&kgEdnEgZY7vOX9US_BCNxkuJbc6mN`6Ikl{h=l}
z*?S+EaKovWGwyXF0DX_u=xhBHgE2A#ex3DSTIp_V<B7JTIv~oqe7nEy`E8^dTB=l}
zWeqS%=?Cf)4Y_61gR)88%1bcYb;zeN@IBgva%t{T$_MFs6@OaH3vozvX+?mJ6_p4M
z*`QELf*%rwH?qUHO#Zamw5CE<NnGz>w}i%KNxd1I)23cussu(SoI3n6hGPH+bkf>Z
zpIODN<jdN_yk~y7jDM|$GWlf~?{lY9APhO-_RB-!)O3)jpe($Mlm>`!FxR*`5KwvW
z$c}nzHW%66|IknL&nZ8ebhz4ZPuEYMw!)ysBXc?ZC_vJSirDAmp@F<AFb>Jjx5<~V
zkB7m$jGzQ_gHx1FF4isTV`=LFh|plTcD`S*%Cffn*!xoQ6SlmZ@Q1HVrZ{*<5Y%Fb
zX_^lpjs#BN1!z2X;j~dkt7{rW#b731Zk}uwAR&I;8?Kl%x0m=gm$}6m;;Dl_Av{19
znSEp9HkJ;b6;-sOD`^Bqd3>XWCFjA2*upHNl5AJ7vf^V9mVH^u^y*>($&Wb?LN}*b
zB!gK#wX^_sYR;!@Nf;H%`CeloHW<fwp-9?4-VJZocRDs>6PzNE8zoAO(wLqDv>Kvb
zEHlIt<%KdvGiG)1t>FF)(i}5mcRcA+_wF@~eKseI6JzO5Ib<U(%;zH2wuNbZbjT8W
z&E7N&dSZC$x%xY+-J6^M6se>!CK8Jw5xBRlU9l?p$8>LIn(k_l0@R5{?N&b{n$y;z
zq{L7*<zZ5zJ+b>v`9*~XlQe>+73clGSL_fr(&Q_jyGA6>=3^O;#>!&emFPH#bI@BC
zN#NdNEY$&&+~=dfDWz&HZi`=Eph@q0o_;-{(|y`S@P=O+wMi_1#VOi#ZR+)L12D;T
z=9(Ya$Q-tdPEGRkb4e<ZfoW35B(2ElDaUpthtAjEQCHI%s`Xd;yUcMm(uTQGSxJmv
za78^;%i>tB6hnk)*r=OKstPxpRm-+~5Z%1=o<)B#&@OzY4?lHD&OBrO8s0Zdd#)c?
zIvmJo!$U$~0ce1~szf@hZot%ixJ}WgaB|l<#z-spm&T#F`ejf!eSFKKogeS_!()!b
zJ}S8+_4EGj0)IH$ih$~?9aLVUiGEqSnFc(}%Bi*BGh6{{)mf@eIOT4BywrT*Tyd->
zTsLx6^bjIn8_pGJs;T65W2iZ(R+b*}Oum|N{lbFt%4#5}X8rG=SPpw>2J8J2A4pgy
z(HJGz0ivH{&PJUo$zS!AJ~IDmTgN6rs*i)l&DG>;fTnG{yCgengS7iH?r8)`-TLb6
zFW1V=v%vas8Vify4w15=hj;hV*KE_LK8gSM@?SjE9G0VkZn|nDP7qr{!_IrJz4)Gn
zX7ML3eG-sALz4%kWpptyE5@N9b%j*C%Iab**LB9}+Bh-t*MT5OmIiG1PUmFkm^J`u
z-WCBZt?vU0p6`i*E-eprIwy=Q`H$(6N5Lc-_{ZctRj+2|l&jZMW--j;miz;fNjit?
z7l!SHzVwitWEK<*w-wkH>?1T%VhFsRFk>$y<UT;0`cVZ#1YHk2D?&t}gBw`$tZ%CG
zfE@T$AI9&K=B#P5I_BW3QExy_zsG!<mU}^w!E(O8lnG5E+7qnXFipi`q&t}jIr{y|
zNn$U5kK#NT{|=WK%<`+~wVoX2{MvBDVI5z3HqyP)?Uem8sy};c(R=<_7G4%U{)lb$
z0SB7RZR9j6`#?}+L&fW}vw&4FGV_1(A=O4VtcTI}hj^^sx{6I)AL-@+-Nutv>XjYd
z%Us1NVNt}W(|&xCYresV?Aagvrq1}YjvA+wB-chWnl)M8V^H)KY&DM;U-~9m+)OHe
z*UU8`aK<|*s&J}6hSsL~^hdNYog~P6y+A*h_(RiIXRn@58I|YK*3~4+($GPjIUxaz
zi#I`tr?4^pZRkLCp?nL<H#OTZJh7GBASg2AcOLWMw{4tr=3TQ?Z~voA-vGF*jG;;-
zCYXVk`XoCFi&VNpnkKUN2hH`1`t4-qnYqOh<|ZNBi?L-go9n^=N66>~{oyy@1t=#6
zcRDXTf*{fxD7o3^rfyW8|98=!0B(2e?lO9%R#WvpQt4NhbQ?s!*I8-v6;g$Rh48GS
z3=u{5PfhFhAzbqxW@EivmufwLr1nn6&}SqQz30Zdpss;<1H>=?1RAItnA8#G9R1hw
z+r?!!f{#*!37ZuY>6XXQz%#6L8*txT<$Y>z7Cn0_tX(#Ant*&@`Ce^r-+9}cJ*siz
zkLX9VepJBx1UHBDqD0I`rDi;T%J3g%!+GpL!fbM*^x>JS<IEo3z~|YY&hE~Vok)SQ
z)<N_Dftu_rth2f;B)zsSP&*q~+b7B@cR+SPQ&>b!xIJlmp9VjZkEaO|a4XOJ!gQ<J
zF7mBmk{bf}G#E76K8P@-mMp7{EXe!D71qF9nzw}+BL3-zL3A*=9HO@ua12j^qVit9
zzH5V2XZ<*;Dir{B9g-ATR(<kWxk(lRtHKcX*S+E~cH|;<G^kE%^%c?YLyt^%uU7w~
z$*D>*?h#{o=}GoU>;@MaxXVargRRjaw~-f{-0M!_qph149Dt6%t?C>>f#cb4@xsIl
zdkQp=frvmqOe=7Ecd7oCToDmL40k6ckoVssS=uHLdUC2jW%<7k{F&-Tq!=XfV03-#
z>za>~Y!NK{_r?8g$0tJwC22Un>P(9;2DoK2V_O59(fgB6Db>DlAYh*fGk5C89i}z$
z`@kFsqK3`^9Iebcw7$WiR6^|r<HqBWPiu!kz@4vRC(y;ZThLYU-vT-dY||wa!hW&A
z1bx_VedKA)Ru`VS|2B9Wz>I{_E4)o+6>CaIOIusj(7tcn9SN6Q4W^5yA5@v8BXvrE
z)iHs?dyw33*IL&CQt8)Dh4jDziAOA9RdvCz$#_|H!{X8IR?nd2S%^-|{}c(BTl6&>
zz3%BzIG6HT_O9Bp57unkMsokG@`{ITyM9^AjNL(e7s4W=^RI1@^mQy4#Q!15ESg=?
zYv4vILFP=s{F5REYmV6Kk1joILrGGANN}l|(W8+Zug(uEfFdg>2M7cSMN6Mr+RJXP
zND4lsCK3)ueI@0OVyIjOB^oB{<S61G?|MfiyN_IJ|Jf$az&9Jgky6;u9>kOD?<L2J
zX|y=D^E@-GQ%GexD@E<Y1Yh*DodKJx@seI~O;{q3Hv|I|tTc3X_0xzo>5|oTD1Mu+
zIf0MmwdDT<v~Rxt5I<@1e?)Q;9BWiFDjGkdv`s)k+KrKdFE0wiId=-{;0;@!_9j^}
z{|h~&?dKy)r6n746C-%h&~>`fqu~4j;_8hh){XHWM}|Z=;|ofRmMv#q?u{3OAZq#@
z`pwTV&Lc+F2fmXA*<GVQ+%0xh?H7_~$mGk*jVZ7M=>7IExv1n;z&0>4=~da`Z<Uc~
z@|S0MtA4DWQW~_S3{Ns2s3fa1#pWFnzxS{^zQJ7D&2~-tvHY#z%iolYn4(S&vtn%N
z-sTIQ)0c_8P^_TtI`)Ueo|>2T2t$|oVpfOB<OEM>>P+Jd)&7E73?*%DH?vxdhV9PM
z(q6a}(0@&0phYi^o)_X9=oARM9rlvDOeQ6RjHb;5wVS^?&ns%4k_+kGOA||(!Jw<o
z1#-1Tfz>HPnkR&xJ|Mx&FCRAOk+06~-68J0d=a$1yEj4N;ZQwizV9KpcpNK;4Jf1H
zkak(_@n})<OvJw^PUaU$(VO_o(Lo3>!1jRw*a&}Oy&89}B1ew!{!#^V-S*bzixDuh
zC;c$juWy2YK&S#aKz1UxZBX_&t5sexVmQ6Tri;%IJlhEpXI5Sfc;gYCr8-+nL3$a=
zF7r0erO)bB%iENF8!QHirmGU`esfJl57F%e5eTt8m!8n)sU#*Ps>1Dvi=};*CF0=$
zT;9Rr+$g*uyjVhTR&OO<{fk|);2O{=YP-HB)f56^U<eEHy@-VN*I_MtrtSioZ!na|
zkkrJY&sGK;Nh%o;Q)T~xzu~>wfWGIA+@R>hHNrbFwIK(Li^!HY`s5j?IOxA=kHn;W
z4z-*}Oz5!}A4D^s@->&IGIubOj<;I_Xe5FVoIFnW>YDpOYIBKoK42naM)PBZ14nsD
z7b|1W_BU0WYcBP8lYLoK9Q{W^iZk^B&)COeS4Z@!>_);RH&N&GD#Wc^(TUXRBE_7_
zq<;qD_6GaC!TXMk#_0%ar0YzBrgq62$`r!IC0Dtb=ZbbEzsqm#xTY;xn6QWg5?omY
z6VIZ5uG?Y`QM9IpXihwyj)Mwix~5qe<M#ImLCaR?jeQWP={{>sf2$SEoAV=nn>j4u
zGU+X#C{(+syYk?q7bvf&2A#Ur3BI2(kX~g><#9erWCn|v7F%MJjOV_+Z%`RE4UyYk
zQK@rmLI0~*OR}KJtB)MC3>s4g{x<N}IQHyEud|lT`pxuTqoo_Ugf=s-+|5mf@mGEB
z28{P5ro;9;AHpzOA0gExFYO{t!r&yw@%L$+(<!3!LfUc#g$g1e(Eh_1a*f~Gi~oxo
zU!A^>S?<|Li3$;3mEtJ$NF~P!2XiLdVL9_C_w+&)r|x1blV(`ofJz+$NO;7Xt?s^5
zw)vXixChS4M5E_+X}sS%S{aCAZ)hQ9_D(vlMTKl&I*c(EK(JH@Ua8$2xWB8dL3X_!
zcOh18wCLD}1S3AkFXaD2tR|YETRsechV_(=DlM0LEo1S7O613LU}(>*z%bA;H3}(3
znWEQriovGKCct1IwIaj<t__|x7A6GWzo%YC=7<`)`m8>gT_0ON%n^xcp&Dl|9ZZHT
zfEV(Pcyo3H1uDvl@|*7PPf(S_^?}5YQ@(zf5r@gJ<Mz$i!kq9aQ<Tg%h9Z3VC~{z>
zJ8Pn9KTp*kV&E|@35?3$EdS%Xk$sC~ttxF=&Tv{+oxsd}mX&@5<Rgn_U{3FwF-bKT
zELf><=ssXoC(_H2rwl^E*}&V^>rDtZBE+y<vwbZlHVU`u3g=UU0&@a#*f_hzB+p#1
z%;YLeRyq8X0~WzRA8OwnD{i+oTAkaI?S~wTVZOC8cQ-C8_?}V5gEqE8e4v*%&<K~U
z#nGq}cYaGa;>g?rZqglS5iQC+F>Rm|VV<|DVVbHCgCLSzS)Ltru633n{3F?hoyuVC
z%hOEjdPpheb#arw<q)aD_YjPhRKEiPL<yG`D!2J+qFqzF;hBeSEla%NtTfhIt@9;h
zENAj58MUK&cuw&8-!v)YAIUs|Hb|R1_1wd71}M{f|0&V|L<wdLhZXGWMeD?@f#h!D
zN2fPYnKmF~1s|L5ISx(J43BantuHyy-jr3rL#>Ms$c>uz(rt2fe}*)e)X;Yh_|2L5
zqYDx>kQHh$Kfq9CVqG;77#QQ~?_nM+d*3aV94GQqx7$;Z*G%ys=$HyM(C`x=^{~Ut
z>$IS@vRnxO{KG-lsN1(_n=XsksZqoJdWV3#oRsO$7*0tmwgRu@AJIl^tFf(T8qa>x
zC&g(PjXg8I1#>3mILaB3mZHttUdscCQIq!tQDFU&B}FyC<PN5|!>>HZ#NK1+zqWgl
zRA0Io!WI$i3aPTnbo37Jk_1O5;9n-q;j7>zuN^o6P6T1sY;*0)%CEU)9&u4L<H~fA
zh#-tbKb)`$Up^CQzPzHNH8zWqyp!p(!5^&rzWo__a%_PcrA43yI#D8Zbwf{{1_*6o
zwR5r1o42&c1N;vjI98$&Y-2CnpIRw$`X@yn6@)dW`%M?<gfjo2TJ~|@^oEE^3=k}_
zEyE-Mli(OiD<;K;U;P|!dg{?QgcEn7juYO04TZo^b<%Q1)|(KgdNH1)XUy<28dktD
zapk*8a=|@DxWzT;L+_GTW%B5Xr?bW9(>!bz;8ctTygO<Zh_78sY-jyYe3!%$@mZ6S
z8zyqQ1=FXlP#AbIl@Lw;immfu(be2vQ}Gi3X346$d|AD?9PSVb8Em@xSV##Y>n2*^
zoOu2j86t#i955flbJ4Lkh*HZ*COTL@3-0Q3Z=67%6TooWWPI2>(v?tEx}d0Dih&MZ
z)o>^%cWL0?{O)h!S(L<~f7=M;{$N#Z6`B<-5k3Wazst}W-7)_*`Y1S83vpNnFO?bs
z*K&tLR!Hzf0a(~*=s!7(1PFA$>hV58dz+EAGM}iYUk&SiyuDFrP+NE9Xx=A5mF88w
zzT9rkQ4ia9AE4cTmHB5?l+weyUEtnMy5sR&$L<D%uv%>}@%!{xOe;)PvlU6!*J+2d
zynHO`e4@eV%zeC%3b)5;WI@Ca$66}@wWL*nh!%J9XDq@&TPmcV2!Nir|1MYzl&DW7
z=o9M{T#DXzp-1t;9zTDFKv{BZGuS!nRko6X^ROzeGL)C0oZuGg3eJy5yoBF4sCyWP
zV^iX7$-qU}$_p}fL@Jy!4;}x;IR14eVCsDD>*-Y$pvs@OQ3zayJGxy+>&pW+d=sq_
zz}Eb6%QzEE8h+J1(jJr0VO_L|UzH*4@pO`5jhOA3;e+Go=X1ag5X8tlPOm@k$LA!v
zi8$cXyz8gLzzyN`i{>97ooD~M31Tj8R5Dt^3hUJYO>epm?Aj0Rb(k?VAd*Nz09xU4
z-3ORC_mh7?=XwPSJT~QNlAS<0gM2rw!=5EAU9<zoeLg0S(OaNlcKVf>(YO-~oDDY;
zJmqJ6z=2+s@z-e1)Bt^yn;D3(R$z<)<fcZ)vHguT*<;6oFS|s_U1UE#e~xl7M$8qr
zcOMY~Ra481h-vzSkZ$smAj=6y6AC5oxq84HZY9)XHo}@v9boVx+yL&|HkbwZvJ!XJ
zE*<yEN0GOAnIg+`RKXDlN4ht;!+iON5ZOCSsTFp(1PQgxwfrG|k{3`}tJ7)B9Q;5^
zzKM&Cp1VaG2u&o_M&lt0WG3t5M`euNl2WAIG(+#{Xw8)lO^)HO@PSiAryAyi>)xmG
za<UJW#$W7^{mA%8mIO9gNecD6gt|+HellF2N(eUKVwho4h5RiZgbFr_f%(Lf7!(-q
z#^4c%#wH2R2XFj9bT_b|EHkjEVCsmB)?zPi^EW*DP_@nJl9=vz8Zk0qw)y8+El9%l
z>Xf@G<T54BE~Ly;pRvOS#fhxJhw9th`hH$$YHEuEWr#3q&PGnIb)=rE&uhYQ=A_c3
z=Kb$oX_(?u#h3Pg|MQC!o_gjrtzL&3D`^ZJF-f=p8;hO){{y9X{|8E8vUC2=jED%C
zm6N5jxjh0qZxT8>4)FgP)OmQwIQ|z^@o<xIu>W6d#mi2{!SR3N|1qrp?>HA3$Nv=l
z&*#p;N5=8Lp7;NfIsVu5&ih~dKb-9U<os8Y_kY*&lKr>jKYoVxe@ycKFAV#CjPbZo
z|82>i<S#A`&XJVhh6%~f!TCRi_}_+#UVnK!x1VcgSxVfrxWI2R^qYMhMy9DUic>7v
zbD^u?QckQBxP6+czaHCJ{h4t7UJb5=_d>(@_xk!g@2Bo}E*SYdA9U*F?uc~1AB8b>
zGZt|ytZf}E7-eoAGQ@DWJ?rg!dOTZfkXAnV)hgG&*ZwM5tRcuen_a*C0-WPSfqTi!
z+U=<*xe;n4rP}V})@fhiR-B2$E5kn=_4XsVip|0;OJtV|=R?avE~Pq<j7c&Pu8?^@
zlxHuUYEuH5Q@wtb6jIH!50vfbTVTiv+)HYY6cNj&yE(ge{j$4Sa`HYJe{gtx{5Zo*
zlEcj~iO8v&>AWW0`TWd*0PKCruC&YwDMB5ilSYf*u73DEuk;LgadUn7;L4UVT^X03
zzfSj>LMN|xqF#UHpdQ%sX#Z6=v?ov~v3`HeQss2TDy#U{RD)7&a;Tp9N=YDjz9Nrq
zRr2~zuSZ22YU>~CgmcHA>^hdh)#4ReA(a82?96V$0M|Q9UUJ^UQ^2WCdn(z_bbMk~
zDOFxsm-ks<>%Z3Zj2{G<qT~hkHi9yn5%_+8mo1jqAH}-BzIT2LarBpWAxXNPz7J*!
zONpk1HFq;ka1+3=C%xD?w!YCi-Q>pPFkRxw+bU<BnY!iYdi+U3d!kX?#`S}ylYxvk
zA`*0%@d>xVt)0_la}5NH0i8(CY{;Wv7goDU2)P<C>A6*hhgR2>W3gSKxU2DgsUl1U
zKH&;ka*oBx(@ax0@7f)|4#yWZ=h{VFQh4IV>jvt0pEglzpY=O1zip77QfaQa{a_J9
z!M1J*XB5qOF8JN`FtF(UUsE*(;ZL){$fJ7+2I3e&Tq-@o{~ulN9OFs!ZvD1x+qP}n
zwr%^{w(V)#w(Xuarfu8ZbLV$*&%Nh8$@^cWl1eJs$=+3Keb#zd>;MFg+Y=*I_P*Q6
znBF;+_O1{JHKMG7&%@Xm7`Gpk0Yk{&DB~Y&h%1HGIo9v1UY5nGBc+r-t5{<<0z<z^
zaqtvp2fzwKVF~_%UNr=ndUt6upV`-xbSp<j1QcjiKB$hzRXn|=?fApl!zW8zk|EeK
zYV2f2#8ZFs-5Ga>)d2UUe27V*)n*dxEE|!#%sO63?cS>6jdu%jrf7(h07w(H?nMQR
zwdqk9MFBWfteV+LhN+kXUOUw$p2^x(#uWylySH3dcT>M%Mh68pjD-#(*fAvcP_5z5
zQ&>O`wYl6E>e>#!Rz1v|)sCim53oG#<}zN`OBxTTqQ2oA<89o~Fn3}ni4FF#8gR*p
zLSn&57&}irjfgVg<*6U+0Y;1fJPd>WJh@S8v=HHpjlTN$`7azBGGR_Fa@(N8RgAC>
zRF(_5lKf9+6niRA141RtA>4*HI@z^PXUAoR9!hO941IVRQf6ixBrP%qEZfk26#e8y
zp`kZDWKbgbG)`4t4qGX^2{XLfvwJj*{4@AX8=7-p3H6V-GYKjQ0AFq-%q#Z0_ee-b
z9=2y<IeFN08uF7vWGSN6;QFRjP`Z+lua(EMt!5rB6Jjk}?olFd-9yR06efRK(B$uY
z*L(Z*_Y5Ed7W34yQGFE<1CW9T$vc&zVv<QKD)639^az808RgJ=F!_on_khu7u>$@P
z5Zu_ZQ5_22FgFt?fLCzb?yI6NvLZ>)aaB&i3A#5e42Y4WfQRZ)L9__amY8*ZfcKg@
zjFa+tH<@M<^)jKzMr9Nnd<o1qx^Fx~=o&<bIP4jEgiIZ8_NX>c9+GRh$#<`E{@bG}
zF%$&ezGaTj&Sc0jy<gpS6z#(7Ifls!eUz5Yp24uH9XZMfpiC@ajE=@tbs^TgL>*!)
zy)t#2dC<Ldpz>3_UXqgonoeGlCg~)jtbg9aYP%?~QHY!0m7Ff@6NQ6n%PRK}&Y~K&
zgJF-sdc6jWFH`Ik5K1}4B@<Vc)Dog<h%(YMgDKpD(l&B;l1T<EBx*pRxj<t|dyAF6
zP9dD4s)>3C`0I~wq3<}C(L!BAWmb)zDY(w1y-+HWB(P72%i>%hfie6uP~7wgEPhSt
zl3sg4(?rVA%&pu_2aJ|{+zoK(OJmO5Em+uu;m5f0zXFd0g_RtIpw5RTO*g7O@vvb4
zJCX&S5bxv-G3T1Mq%eRIH->(7OwG@Gy0Yb+&@ws(Twp>Ba=@HZ3E*qtB3c^_x{wJy
zb_5)y56+QZ%2|Ca!=di0+TFt-<E*;6&<?#MVqc!trH>N+y1qZ0AiR^!9V5hYbu~pm
zLw7zjT$nKM7g)l@hDtc+yb`^uGZLMfySL#)e9<w*jQ3RpSu)r!eGKSXHw_^rs4paW
z6TE^19Pk}!qBx)_p3F!_eFMRA0m7l?S1i}_knCdW?>BvKMIA=z6IiaXSBc?@T{eM>
zo7}A+E6j#LBn0LL7JR<9Uexh3<v=%MpEE#dqa<O0?xj^j&E(6Iq+{aBoIH3XdNj9j
zl=w94b0O<e@NMQUNT*qmX>Nd>;J<JfLdJan7ju3r*}1D=LE4mEs5L8TLlZ!(W(HyE
zL8awDf1A_N3#7e1WCcy$K=y_xbH@y7!|Bm7JxpifbV2Z*$bu?nqm9a!QIIc0%eZLV
zIt`Q@xbi{fe}ZwxgYsAUgx*Ulp+Ao`<N2gv`UIy~OVn7=(Z&0$R!B{h1R%WeO*2gZ
zC-q;*>NF3bbqOyhZxtv7IXeESQL4<a&LjjpN?^O;L~1ytjR_xY5)o(tZ5C@)b<U6^
z1n>N7N`(ipHT{7M3b<*O3A`rgqwg5jAiIqRgX_>uH1|8uJupf&auJ|O9k8o3LHEuh
z&yo=k9L`3e>-nJ9s9k-E6{LdD7vqe8q)3ekY;dzf#DuhhJ6Jh=dJ(7siaCx<P|1=G
zjLLPAlm<`<wFv^@AW6N}fmPSox~z^-SK`-zoM&~2n!LXZw;>QS^{FUvG_IEY!-Pap
zI0}NhMp5l=V&l33!V(!m!gW%>1H)JpkL@J>f3V}UQ8&(lwz~2s8AaVIA=m;_Ze-Mf
zGn>U^bAXXv_5Y~pW485J19NR{B{>?V+{%#v>QRR2Q}panAh;zEvYEWbQ1<<3nCn0^
zBi$08Qix!s6h{%jdR_GBWcE!=l&Wys4)3rVzJ;rWp|&$a-_n#YQu{B3F^xxBOcIzo
z@3HQuMt>i`?>Zek63I*M#gk#|#?%9mLAjf9@n}Hq1<2R_(dD6_z(2!l7&!$3C1DH#
zoHps%lXy<m%Jp1URch-AMAz)Z;^_<xNWSRp6Zo4Xg?xZ4HlApNNBDeulj1s@ExC<*
z)NQm_=%z!@T%{Ql!O?^MdJxvC2|sjY1!l{H<k*+Gx`M-KK8^+}zi-`1%S46Lx@Lp0
zES)b=kdMKONph<7{A-->U1=-u_;fT6a2C>wm|OCY?D-rC@Y<5-&Hr4Ss^(9z!9C*k
z1TAd-dQpLnQkZFw)1Z7jJ;dWGu*;&D#$Pg1@Dlz`cDa)#*Cg&_8`Q#~3bJQH_~O8f
zRfQov`{2QYydVWHPU)^m9TGDyYQLYr>jDxY>rOSIla>r~(R6&<;NO*tLBCS~h#dNh
z_H^ozjzO0Fxxwz6u%`9e>H{g%I%UJ44D!{6^KubC0qUw)pC0|#+Hz&JcW|TEXQ1b_
znd`bQ-LRysG7xc9L;LgRb1-|3`fZFhfHxSWii@CAp!(Vsw|YVjt@?;TRxY(m@x7h$
z=fqSHu{iD9r4tyU72oOGOCDl01wl~&7(GQ^F&EJ1ivD{W>a+)BxiZ8BLE-*x85R{g
zT!IS(9C_yFhs85*dIjpBf+W3w(yQt*u<^H0&$L+Q%TMUEB$IVhLD@2s4T#R4*!~yz
zAjARz`0uRq88j^%VD(}!)9#2pmPrduB@%1R_~y68s4=gx`@`Xt*)R-9PUfa>f&x)h
zeR)9Iw%5Wp6ou>8WIy|Qc>t7%J~9E!$wzl}k}Xl5zMym`VfZ@<I#wfg2bPXNvi4q1
z;cakoc;gaeYNFfgrC*;D^fB(Q6(9zXV$K>Cp^;diCSoa(zQJ;@bP+S7F!4lFz%P_#
zMg+!Z6Z2Od<?dHhL1>zn;mCGrM7gTB!Fa&H`O}oT$*x$ZmgN@bOxE3by9UCCw-ElW
zi1ng*$q04jXhZ=wIXIyu#zS&_d*YA`2#nv)x|jqE6?_;S6Y`khTt<El>(3d=VbCm=
zKw)%?+kwg9gv=UAti3Db701IYs~R_@`p#iX+z3;PL|I)v)Fuk7A+y5UzxJiEsW5;=
zE0>zo12a=iVuN#njMNaEmRMnI#~T3?H2{><+$+fOh&mLF7BJu68YjvKqfvah+-`!*
zW^nK?m8x-H+`OL0h1I>RL4xa-hlrxX?&p~pg|M7l@myA}ia+W+gXc8%+vc_L;}M1c
zz=Z%mMf+Pj#A0&;O-Y;8`e7zAD-qBg8~eKqWC@nn)nV_m|BKBf3RrniQ}z9(lbiom
zoPxPMtnz?{Hy?CL5mgZUc^}AjIpf4(pnjT{)tUkac^a-O$s>`+t(m=>qs3zF=8-h%
z3JU@izq*bmjJv6}YiWiv>+S;Rb2qp2K$Wc#Bpcj2G*hmY&(TVR`0hMHiU^QC3T(Fp
zk&xf?pmZLhj1i$+ug2a6Eh}{1W9E<3Lt1eSzJN!_xWoC`QheO2WCLyM72I#&UqZXk
z*i~aD?J$O$=!Xi9%<RL<-XN3^q6!*U0ug}Z`j4Su{XE-8Ep*Jf19d_KH}A`2$6A<%
z9uOY9@1T{AX5oQn<4_xj#{v-Y$t0_5ff(!|s{{e9U!^P_*vBJ<Z%D!C526b{i9y3f
zmjuaqIgVyFugIr%PZEuZeMh~D70E8z#cxkXlqcTQ6%XrN<$E=IK!0fl8Ks0oSf<Bl
zY<TuO3NKEw>}2@9>22eJ2GCr~TdhsUezmv<upw|haOLJjgQ^iqj{{=LW9`$#XysAP
zS-RhWj^3NWuv;+4Ba0yuuAXR9(~_378`p%35CgDFx*Nmjbdk`xAr?Nefm`kypti^s
zu`1vx{N~2Pomtsh{r^dnG??SXbn13oa72Og99Hhum~3xuKt2NTdLG&)=QrE21eB&R
zhtyQTJ^A_N_d&L37=U0*FPgHbou#PpV%?bCWp-!HL51*rTZFEG!PF%Famu@N%akzH
zf?bjwf<n9oU{%xOc&o{sfUSm_RPS_Ntm{q^OLYWAXcW#?vTk#fKQj|%d!WN}wNHI&
zXoUyFyA#Tocev9+%!p|95YZVyCJMhKenY?jgV*?Ql8ANyTLbPJ$zBH^ha+BnO)`xv
zpgv47wjDMP$uL%jQ0QZYsWiTak~1+VY(}VM!cFdnhPAZsohGos`VK&i$o3C3>>?Uz
zUYYes9~sPFI9M&Gf=sF#i7oxu;eLFMge6jqH2<<~I7y|rp+&$5g{R~8lj+)a$u*gr
zTViVY=g-G->I2e`or{`-DLkrJP6dH2nj;{oJ1?`ZSxy!aNF(fyHPwzRKsPVW{{?@h
zH(nxf?yHtd*Lm0eP#K%iIm`I>fT#$K<WgmsUW7P-_AEFYf~#8Gw^q6nGbQp`mf!ao
zMG^JwW5C|}pSJ2JnT}rC)Wo>{y6po`3;q0Hc7rV(@B)x^_S^X~GRj^_OK|l(s5<<1
zeel(53xRX0O`3qzBmtJW4zN;S%|a-sgbWB@!i^zgkxeG3P`&B_wa1pil_}yfB;Vae
zNS8P_nK7&QL7B6ZnPNO;EnMy<OD;Fcm&r#HKCCo(4??*a8{EChqT2mYOBm)YqHveX
zactRC*9TBFii@8oBbs&d<W6SNK|g+rr?SDHpEP`#!7fb22D*LGtb@_ZGOD9p;%@PR
zh#1#R!UT`{YE&bu5^Tf_ww%VZ%Qv=3$zcUO*G$*%mI<D-(4<!z?-LFPTuy6!-5*|L
zqqAGxao`2YRKXX@eTf%(>LJ_9!lkMY%GAY5A^<YMv8TqP<kc7`gPj5$k3sn&tT(3-
zIjklC*OZrP%Ix3>xg^T(nvE^d567OQvC7Uc;X)N?mcOX*CB6GbSuJO#lgJQa3xExq
zqGZX%g201$Ri0=B*w?VB&v6EmEYnoXzzCt*f-}o5EVB6SJ!7PANI6g*!Z{+QNa_T_
z0f4T=vLu55MqD%lbV-?AD8>XBxQ&<M&)JA66(yCNp5CZpMX&F41}3KYz(U3qqK8=d
zdO3ut<{~;afK3~I$b0fV&teog&w=vruU{Y(obP{a)Z&4UvogGD*{<d#wD-|t&Y<GD
zWfa?1m9Xf4AcCjkRa=tzz~FDb&0QA3YXE@$P*QGC;RsIYVQKQ|Tcw?ak<o{o6IdXh
zSK36b-=kwXozlszhOmbJHeMBopvvFJ8F~dg8)pah5WImdfA6nu#Ias&Uu9|O><+A5
z78jS~&8go^`NJD900=)G+#3c+M%x3Fv>mag1F|lFUXS~=PF(78r~T&3Zhnh*KY+N^
z&sGqF!NDI^Z~M6_vI4lx3!oYd50;o?N`hUU_UN4#%(}M}9h?(Prx7bEDzfcLZrFo#
z|3qNUB&5);H{YeMQ%Y+Ax`p{Ky3x*LuV+&cyTcm&zpxr?P;W;y{v>oSG+6XN6MpHx
zq&}}uKPp?NIp$NILGC11zWEj>k5V+WPyyo=d7t2wgJ4p=S^1<6Ua89o%aF0u>d8@A
zyu3v&58yvz+C@0y@>9dL*xNT#js0M*zXOA04{MJF9~8|HU`0#9J_q5r2=L8Gfvo)l
ztOHu**S9BNt81jQEOBX40&&09ypbG?mQk707-pDPi3P*!IucyxlR~e&14aK*;mL*|
zlkYEcX*=&LJE+w$rep3kjsM+J0zpL`Lk|7*)~nAmw60vmceBzs)i2$*c+YXT2LSrj
zUCImdPr!6_b1^rz|IgKbq)gTfXD(o3G}ix8DgP&t&&u>);%7z#A_c*JaD1fyjpJt!
zBLbsJa{jj(`G1O$%xpyerBVL7%SFWc-%=;@f3(T}SH|RGB4Yh-*^`+mLkkgDG{xHm
zKBMoL7y^ulgNZHU-inMG(8@RIaww7h`T;X*T>-@$r`OPFg3va;q8gtcnNKDEI`{%i
zMvSaZCInhgy<#ZnC`$xfDs$8LNpcddXVCZEtLF0Pm9qVHE>F_GyVL)Ep`X2*S~Vl*
z;riDpr7K6Td@A$d<j3jp&;sl8GT`fVi|r3wyKeQfh3Cb~ubrJAfZtzG|LjVZc5r{4
zs-gu>4RfC3gg<OH21J_D#tv<R757??GtadOoPhe5Vl_es`7ZB@&U`zB=YMJ1rkJ|p
z-Sfl73rF`x@0#OF|1}5a_Z)i&-I=Rd4cp@fKEBnpc3sn}GV6CwLwNR#F36wSH=y?e
zpa%D9U_UlwA<(rgz?Go*oDGZl)DYtJ$Ale^a^*c~cEki(7|kB6ph+q{Vhp?mkKPJR
ziXyJx*~dH(PL3l&(qyfwg}}`C<-5x`>g%%;Kj$@Rh|*~mja*|Wu_5M9<?C8wA+Ga#
znGe=wevBV?-Fj}dZb#v_GKJo-PzKGfd8iD$4eIzT&kxmP07d!95`BR<{qzGT11zy}
z6<gzy`k!o&IdySI8uc)S?+N3Yu@Aj=Qo7<@7$}+YXmkvJhcVK?=`5<Ef$NONKQQ@j
z8S581=#vle#tL1g<%V5{CIVWm{p^z`OPDtsgLSCQeU@5aH`r8`BQb@eXHyM_%Yzz~
zEuroW#o#r-049yJQUejF3Z#?1Rp#Ys^_vH(3G@&=26Dz(m!VHn{NVx>^HI5!b|5Q~
zHqQU#HICsu$T)!n_H4nOYFd<{nmIooa|i(n4hRdc!}3LRN*9(m-Vg*9FeO_{vk{zs
zhxJ?<4YVuR6phRD(C7Svyn=e11N%49-w_t0Luj`E&+6TRtDviFb3(PVXSkcw?x}4-
z09_;7zZIW1@xrNPQ@}e6LTcV0+QCp*jw*c+MI_4F9x0u2rFWmaL~1}R9l;h&S$1|c
z9_2g=emq(0M@qi}k4bMVCw9*$&2A`Mb0Ye986k4BjgL?o9k5)gJf5R+vL8DI*a8iQ
z!CJ@wv*|)xz_)@xk+sB&2Xu0OTzah$hb}5QyO*78BY1DjFapVo@bH|foEX>1d<Vw#
z<;hMU4+Ky)g!c<se<^2hvpCS1<=pT%bVpp*btgX!_Zi7*eWQb$yLYXI96%JHpqalt
zzhOhSKkmvyanZf(DW8Jb{rj7N3zSWPhYCCa=;d`Z-6F7OjG3~#REqRH(*B&|Y~!}J
zb~IDg5tU=NnYNb(qbQ_<Wgzl0Nt9Mnf$j!-1mXUKno#ZfSrKg6^t?O|xR2OVndSVo
z7X(G3@NOdG5#r(MlB~D|kYle1-lI(<f84OCW04FU{fo1Y5}j{=Ag+2$lp<)YxI8Wc
z2H_FcG^B8G$ID~(e3Iy1AkfMv%?QJ+(e{y)m{bJ!1Un2PW(;xFv!gx}ScV{~GS#UU
zXfCv}GBTpj%aGte*DVX;C%IeYjzlENT^69=frjr205R8)XKNOKw*Wac>?Useai2fP
z%E<fv72<zbrR!Lb=wf*BUi_Oy$(o`7TX_8Orr@RYKQ{^LpJ$Q{2gzD!vY(1HMOQYq
zk#@nXrOx)4K#lMc{%ftDA1nqz%lQt?Zm#3B$r|+4tk%=cE%a%+&R)yyi5RkGekn!_
z`hmgg?GfyWq(<+bHh?4M78Fi{uIT}C6z+9exwGh^%<j-mJJYX&DLVH!L~LvT$X}8#
zz5S5zG?1^Wbt@nti=kxuvUi-@jvh#Kr;?aCxFm*_*4A+-D_BUwy5YryJc~!B2Pn;g
z8NC7ULdkF$=-*~yv-4y-YSbYs1@1cVJn1;@{8FrjDbLx!9ECmsIHm3atWPzivN!68
z3sbsB$Ey&Mp)8GR(=L_AzujyAsR6}kU&%?Ib3x^uf_FpH8Q4HndVz?*kVtPnz_H*+
zneL3ss#vA+eH=fL6~bxmL`H#ljaI!EuxKK$ck3;+6{8AA2xvA8k@-RV4{=IqqD$u>
z4JIE!`IAWcf1qHAVcS;65$KiZ^b6R2w-(!b76o8hMXmew75NN;hAZ>|F1v@(=Y!Jx
zJ^R#5NxN2kw0ZcP!IiFqu;HH>HP<gkVjHqB(P+Ww+LdezB!E`1pV%;JeveJ~R*I+B
zrK8tI&1qmY9{&r_@Mv2FbGX+SU*ywz5!OiWA*m6S^yYk4#?WConBw~Oa_MJ-XJ3Pm
z6hd@y5I0M#T*T*yw;f6WkPek|+bddrB#3i=1SlZGQPz`y=LARep%sqB-*c|yl{y|K
zadQ8?qM{%+QVeRhp0&LJuhY*w0hh#)u4$f(@aRUmQA>v=LapV}JG-M?_Hn(p>BB?J
zP9~gNvotp<FM8V8488J=E=i%Zpgz{^95rY2G_7@$=!{6Xw<RP1ge9BBJofpA%Px?o
z@{Fh_Y@#C%O25zhVE2TMq#6v&iPm%Oc=-zV2(+XlWTunpRW$8~j6=xqSG7ckNtI~P
z*iIogC#4Vt2MW($=!)CgSF&2DlxwahB=s-Uvjql9a0%z}T`jIzQvQUYhrZkJpf^%K
zwnR7dykB7Xs5}XP>%f|-Dn}auv77nq;vP|p)tP2zUREUr!$t9A3>PiO{1PjxYsIw?
zAQ?PkHK4n|k$4!eHV6B@E)%PYk8IdLTC>@~eDwBhLR@S&5b$=(S%_*96ralIQMgi4
zT>Gt#^guZ6(;3tIc1p6LqCHfM1ouZTyiPsjyT)Am@Jj~(tqD*8XG70`Fxl>2`z7MY
zAMdaUh`E)Lx#U9aU!y3s5-3tiW|^QW(eOO7l2y<@8WF>xeNE&;jt<;Ud0NGs4L;Cl
zz3ZcfP#(b%<Wk{}$6|ApGG;^^AUB}0B2V;-wG%YM1AU5T5~@CmhvKMFHN#b!Rnlgh
z<=M383gWK-J$`4{nCj&ju=v^^k%G6ZN>G^u_ZY1KOz3A<^j<47c`nQIi8@WaFGh}7
z5s)r-=q##I&gj56ybItN7YDqt@MSbM{GLanL<SJt4C!w_<VRrL0$l2aL1NqIijqjH
z$o?g8r)Q;Gr@G5SQoquU>l}^n0~tPI&Z}yUwz5P(5aksKDFm$GQIlVfhvrCy$&fFO
z@DY4iLP>}*G?$70&b|(p$J5Rvc>h|dhK0qO2tP7#TJ>)QkPDyt3RAaAx4xIYc2aM)
zP_6rR3tYw16b_maOSVS&ntz`tA`Hk|6j&_hSKdT|leMy(N3_TgLIEcetEx!3?{pZ}
zU){C<#VI^fq-*mdLjbvMUdGhslQ_X1z8{40kqZ0)dI_lL;Z-lRf6(bv3<DO6FAS(a
z5_T4dso=kL<$Jf5hn{J{HM;d-Wsgjq%^+a1o8pKlZ{y+gWx2DS`Pbob39?M6X$D7S
zK8m*&2`StbusqbcsGk_#iw1GWkGTz7H2?uPATubYyd?;1vKhZ#&%MkX9tQHT8HgVU
zpC-BKsU?J5054fN2u2MWI9e59E<3Sde;*Y<`l{#W-HP6@wv0($o|+6(HF7(Tf)$N>
z0Eqx=EG*jd8l6qY&@ynHxLEMdA-_BCG?u9E*f+0>>^+U|>9yv*Mb4pI#_Le<!ZHPj
z4#0-8<_DwSZ4NYXt6v|slC-A+Uxq&eS>0Y<EFk%y3)oEoNfal9%UD(2A>*^9)Xidv
zzeM+gaKLkt77{H}5UvA{)KQPd-8wNp$(f3Sv`ysRj`)uV?%GG(pOZ0E0lysNDWaWh
zjBW28IDx38){347h3=iV;3xQd`tt!)7EECbJ`G7qKo+3foH!WSiVC)w80VhKLW~El
zqFbO2qX6RzDSM^x62VdX(NUfJaxJ_G>zjI6V3jDvoxzW2^6@n>q7;_a59}A^9>uBI
zTrLePP@&v3@A77CsX%A%b-&CyxtTcSbf!)WwsPdlpP$yQ0=%3Zy?Gj|9Ss5Ny6?xm
z`{^+4a5D11o5!oMza5&wcE;wi$_Hwuj>+*ZA})Mz4qqKDD33Gh2WhIy3wOm6bmm;;
zQ|KD3a&*!z{W^QKo{DBBbK<=YMs{{r3W%C;57@6FrWuSpQmW_}e_@Xf<iS=_sxbDe
zN%DYm+-!sR8o&_Xu>A^BVbTQ*oH2$Y!cz?&H{TgM@d7<=o3p7G{TfHi(1d<vjo?7-
zlZg`?>&DbLx-jx??}?V)JF%r(dvDIsFOXCy2ndrhBnAs?r+IiXY%2XLXb%A<u>0=A
zixVjLKInF3M?F@Z4tIvgv*}nqYWamzh!^pqa`+nop7WkacjG4lwdxK)6}Y&}>*+sh
zL1aY%(VC-kCBcmT`H^8e+y%Ex)euv>b`aO?`TW*dw*}tFI046`NvTjOBxDN%O63bP
zT#}vo5BZH7<W7`65m>3Fn_$xZXXY+X3TG2@0#8~Br>Taux&DM%r547+!52KuRboG)
zVV_)&G*~qvWdbkd6}kh6HZO@3O7ySuq*sJL#2mjTvARXGfWaw0L<Or#5v!85m6EdD
zx3E#RhMKyOU2CV@*=}X`yml4xVGz?T?EEJ5T1Jh7kt@~iKHIlIQkVX422!8qdG;>(
zjDcTTAF658<js^pwK=GRcp+U`y>#NB#)8&HHXCXfoa_}vMil`vwDIcjte^%Be=!!n
z)_d77$8hgGT6YtYQnC~nWv<Psel49cC-rg(Rr2x8OL_$Vq+$uX7kmM&8m)J*6YBoy
zYm{BP#fgK{ULfCBZfr<05FtIRobqkXHV#uVnt9Pb&NBqim+0CZ4VvbC#s6mVm7>sP
zVgp`EMZA;C$!rBgtA``t!BL?Rfx+mW;IAFc6}Mn#Bq>PGVNv~k*07CD;W!c>#BfWK
zMvejkFb~_^?Y8|sx#no;z&R>j?~0LV0_iRnsF8<M%Jh)O)#>;nI<t?+nVxa(2%QZi
zn8&u#J)y>s%4>)q#+5d+le~7S!!pa{sAAsSe-_qKPbUW;^p|#(6(-^-=)gOIK{>mX
z`jWvvgAY9AN>jL|EljmTmtpQwGHR?hp{BBIMeipKJA*UYMf!khL3gA<%O=>Y^W_L{
zG=3qlYJMURI(1*~yDH2B;fm3dglGFDZ?R@N-gk8>ohPh9TL}Uo%9Js;b*|>PF%c~V
zHcGmaz@h@MFyf^13kHT6xRGd6d{3>uzRgw@#oJ1!^R;V)gG;3&y>GAI48q^k(htV$
zH_gCw3)_q9OfUbcT4o50doDB2vg3?7FN~L^Wss30O=CM<jyNd{+^FhSWySlpTsa0$
zV0o0Yd<%V>R`8G>meqnU4v^Un3El?QTp$h1w;}-W#hu%l>9+dm<PmhAeeg4pgp$d<
z6*mhOTkgmAGW|+ueLeWv%ZoTK`)Ih$nVv9Qs4O&m`bAPm_or_|^#=Rht%M)wV45??
zD>bd8Y8@{`k{{D=pwH1}Dri8Mjy*di^u$%>v^ZbzFE$n{RKeeq6MUZ0BvsT!^U_zF
zx>qE?irZNTd74GgUpQJ=npv^5@ZG)(+pK~IS<Nrjx4RP@Oe^3^tY|Ps0sIrMA@C{v
zeJGt#9_ikO)zb`cefwU>Al1U#JP5aKxg%8lAGJ7_T~`aTfun9ufX<G2F6bWAYA5XS
z@FtFYY|>U#(Ijr<2{^e8-$(kH289#uB?u27Y${lxRxH+Asp13{&nc8FNMzbu05eE|
zh-U;ewz>P=$AThMMuBm2?)`!tKc3*ZxeeP3EJ7&)xGkslL3%J<VWbN9`xaw{Z(!Tg
z)d5fL3IAlQmZHC(9-dp&bjO+xN^3Uj-s5K#V}s-r^(pn{ZiIXedzOpcEqdGt_8|>`
z=zfP>F>>TpGIeSyIYx>G`RfBGAw}gRAHz8iygt_yPeVjw{ZDQ9JHFz*d7iXQ#sTna
zfLSICR<B&XuB#RG44_n^OC^r4%9NtM6|A^N5eFu6mOl$y={^fi$*gRh(+`&o(b)Hm
zz7Er!Jmz+Xr~N(PTObUzosQDMn0*Go<x~@?QYiX_YfG>!WxKXIEj{2;UyMn1zXgmR
zW3A9$cbvTxJTa{jFH9apY?sF5$RNj_=12ZZP>Aruuk>F<`ohcmx)O<4wqn2^OHOen
z(5gIEv8!BS5b?(62C^iN%ai*2eYh6pIVi>fvdVV7v416-(tvb(;niZ}5WWcj>#)*o
zY8V+t%)QEPXlB|4G{pKL`j63F3o})JdN+*cL>*WROtM*X&#?txWVzf~DXr_|$BOEg
zFe-)jyh4CNP!yz}Yu;=)5dB{LQuKoB5bQ58*;ye`k7`Zk;l|4#Vnw~C%Z&I0=sDwu
zACg;JV^@Lh+q6fsya7ZR-y|r&{kP@PV+?->wMA2sl{58?;l~i`iLeWCBp5O;86n8s
z_B$5sB_1S!Q$eXhGMO`eXyOcBxZ(DcM!Nom6x9W3nYw}_gz2q^oInyDhNvtbqm=&8
z?p_##`Zp?CB|%_02cqI2X!ofjTDjk0pt$r=_CqE)Hw`K{@aIcShnWwc(|pS8gzSJR
z!8@B1167X+u)4sVDzKCdzb<V<>5;rSyL`eLg=tv3KwBojIvR;OE9h|lE@%+`Si!h&
zcHZj-IVc17-5;8!jnS6_w+t>PcsAirG6{NBID;jA-!5RN_{9QdJCxdliL9&<O>*#?
zseQGA#FY~RpYg`CccKZ9tPrWH&3SGLl4bQ`%+Y_Ll`NF5NR~)1O>`)SinU;<J43$L
zmWbE1ofEWymaVADl&(pgno#bbnP-wf_^$`@;h>tOI(egcIIG_^xUi&)z{X>PkZUU=
zvxnj2Ymaq(ic%&ac&b-%?-zT5eO20==Jxu$VT0-1iIwSxrdSU^KY(*tw(wel00Rsr
zS_~yGMZF5;c|l<>1UT<z$(Izpxb)S@)m{8{rH5kwckC{uGV1%`P+iup5o<4B=<0Xl
zj^Y(2?+{-G7NmC%c$aw3U`M#IXcOGy2se?58LbvhUB+}})+X<JT>tw_tBf2Hd*mWw
zq?0<@c^tLtz{vr?le;Y$uWs|V+FW}5l44ynUjgA?9k52vya%>LjEg;^sU`%3BVwkL
z)eVvYfj*>*&Zj?Tgz^|i=cR5V`FVoc)N}J4I*~A^kLBCTGs*4e-5AFMy3#JAgmN$2
z#pGX3X?`0{o)ytkH&)qR@#un=qJ+7b8`-TcRzliyJG?CbMrvK>JVMd@zNp4SA#aj`
zQJOUY^CZ4N#y5y;RAXGMt*^dCi>rb$4CK^}2LP<uxd>5AEo80evrsNb^lfR(-(sM)
zyIeaYi}NR*yDa@RxT3(VZI%4E*)X?;0Q}Osf&L$PDujnv@NC+yEZ#~fPec8q!|$I>
zL}df#+xIB|@-P@aMM^RxVb0gFN!HryEtM2(@~F6Vn4!0_>~I+D96`DLSJs$80r@Q>
z%Rt0_jR3;Z-(M38YTR+~pKb*nS960L$W3M}eaH2<oef0n>=16zyEvzRU>mqhTV+qi
z`O*@@P-U0N3$+iDmBgKPD)-!9-@KKdmLF~$DBLOlx!D-5Z)C?81o)zPN1D#b#(q5|
zTGy8tq>Lc|6s*Z^dWw%<zgY(>(k_8ji_+H=pk{RG75zqd#*%owS)SKfwYElSsr`z{
z5X~DOqH{BYcU`O609E1iyI;rOcepe0w;>6BMGSj0-MUX+FYL#(rt`8>zc?h!E92M6
z-qJz=C8|-O7Dr>4OoepUVlf%g=`M--qczeEoLOy>KZgc7ca_4TZ$$hRQAUvBE8cYe
zp{D%B>f87BoCL)?0>*I+Ns<8!i@@U}C;YyH9g#nx41(<)Uvw;!Za#L;W=@zZAQNfA
zm5T!7g%hB1pV6mXhcAI`jTA(~E~4j^z9?7#@gEfx&W88LR&YJs%Z%pFer`ORZO1#1
zH8g=SB`t3JjCuAxSctNjmBO1-PDiEsuX?u-u*mc3O{$EJJ;A0KH0Y1O;*xH1N;5xt
zjJgC7SGd>0&GDx{EPfmUsOY^_rs};$n)od>{<F(aGNAwhF;)7s`#zq-zerM97;OB?
zc$tB-{4=eMV$N1{Mh-naBLj*WFkuJ60_ALQQuR#<?O6GYz%peekOjuk5Cc4Nsvb0X
z{xlSe@0vHXDK$&hKZu!x`+5JvcgVPfqQFTZazR98{V#{$|L`1AlE^7h{x@yS%JCoC
z8u9<9t^dn&_%Hi`m5qbwzYT@|=}-JmbK!sc4=DvPXtu2X{nY<3D*kV<_CGqC?Z4sf
z{~N6RkIw%8SZ!t^w*Th8|AS}$S4TN8Tgsp?`adMQV3Q_g!4(W3>2mu8(}Rr)A)_y8
z=wfH5Wb2ZFYg}vhdk0b)kzdGofn)*xrEvdhjW?mHPl**zg*FU*KjXZsi-(r>R!**^
zOIN&Fus?G9F~^g!&j-J}TJI=IM&lNtdc8&kJ4UR2=UQ{O{yHvpjWFi%*o>1?m-PAL
z$BNeB`<o(W_2mU%zP0&yeI5ikjq%F{Ueu$%-Iw#i;N8}_xafJFlg0qk(No_0oP$%a
z?~`_*DNQAl?YKVuRQ8YCThs6Nj|I){x|-_r?$d)H+;)uJ?+bSl%DZVQ%->S$Ngh0_
z_T$wS<*5x+lV3%nkX@#W&ec|QoG&jCR4Qo^Q1Ky3j-^w8(D(=LyERL+yY$JmzpkXE
zdYI)q2N4HWy|x!^^wqriH}UDX<waeWF}!QtwVyVIY=~blqF}?~yDM8rH*?~eH_=Oz
zy$#jXxFLH3{5lb;+m`LsIs5?JF8$eg+jZ}rbHz4vP!iOnavoDL3z12$QgILfbl@_*
zEXCW-hr2GIbWb0$3gv!QLqfUb$8&4rL{G!q7hxMCp9zCP`D>F`EOmyoBdx8cx<jAv
z&09Q`%ZpCOp~W5GdDRhTId)oFiOemS;oEM%KNbWQvy}o*+)0~_n^k*DcV%8==U;(q
zH}GdAvip<12SRb|BWmr+<_oCpX8K0!6~BKGBhV61QiuNsV$RSG6gNM{#!~$35+JBU
z25Qg3rQO`$pA^sJbhJwFjv^ZhE%|Z`9K^j|HVRC%8&CPsW+^hLu<?L;R@8JetG@_R
z3qfS{`3ISbRDLy5JFU!?Yraju4!1ymn)SMo&+R(Ae7cHM*(E~v@T!jt4Ec8>;Bx@>
zuW=5*XIRvaUaljMXtn}ANOWD(0zQ{T7bb*xnjo{p*$82X<%y9UXjJw@?sqWN`dxO>
zX7?C0)wNwUgBLO25;;&00nOT_wU1U3#p=6-(sfVS0NhMRZNZf`k?J1$b?8xQjm^2m
zJ`oKznIyjYp5AU|5=1ibq(fcPfP;wabf_0Fl$>Ai=a~xr&&4D;o_*u#BPftJ-aPO-
zEUCZ98$1a*BWnV300_C_Dm)%GV^{>PZ6|ck#+4M?5Dp&)LVATa(k*y!i@OQu-E(iR
zR>$`gbPYFVVx(zhJV|547fHa6o({wxSjmVvm_9Cpjd$B}hoUemnJ@*H@Pn-bT`%^3
zEvdWvi!l+Z`d3?lVzMkrL1peAr!p4%2oWDgq0-Z!HH1xO-zO{8np<ofeA^yj<1t(A
z@t6f*{l>$$irB!Ec%*x3i$Gbq^b5s%os<mEFv<S-7#Qkt-IPQZ3?7;Uk&C3Bcv$Wf
zV{`xFxcY}GZh;@snyhzBQ&`~;wAAGQIb(2Tv{+U|p^#9`g&v|h4VlBvJ!_-a9Yk)H
zpg}?Z*IoLAIFQuOi9@=kAou;g<V+-x+ik+>lw)ypnLE|@go0#??GRx#Jf2PU>}Rxb
zL_XbT%dLWv0R?!QLZ{esIC{U@YFh#$J`l_n)In0On?+l=0SPH)r>QzJHIWp6I5aZ!
z(}Y%Fd94(`im&D`MklvrrWUh>gt;DQtr&-DYOpL;o}hEvuOrYDZA;Jbs;>b}_;1yB
z0!w^eAaOg#%Y^vcrRP_fA1bd4T%sU;PH6kLD|}3*uHbgiNCtW;L#5!5qvb|89m$R%
z4Nvp1ma$9v`ZoG(L~~y;B&Q<4byTd@T5$=CUp8EA{i0U9kuje18)>JmhW*;pj?yS{
z`qA=5H!L<<@`$c}A@qd4P=f9p<e&z!#ZqMpDR}9U*DMUY?m!l<!!x?jh6`??8eAzv
zss7Hyb5Ks0Z+#6EhfP-oOn{m}38PRJ9`G>}p7CK=M{Rhzs?yDw12HFHssN0#@kJW@
z$1t58IS|U{b!FUiv3<m2&4h1WJekZOw!cR@t~mZ-q$Y@$&11oC-CQ(IjSq#nc{L<Q
zY}09I`<lPMsA)JOXhJ&F*pw#6Exhg6T9E>u!KDni)^vx_(`tNaA}4yc0}Y<2Oc33m
z>G9{QWgk|=Cjy+s*ijAuN(<iGs0E8{n?Tg$eNVo8^ES7UZ=2{2{9Pdi7Lewfps(Q9
zXiE?|e{YT^%H^@<Wt*UZhi^m)gdBea7moGC-|Ce5cIY-km@0#XyF<`TjC&OX2@AoT
z*O{nHA;*>rU$}srQ_g76>wCWs{!y?fQ)gx&W}(3oCq~h{a`Oc^_#`Y|Avgi56*=9w
z$k)gpj8ehoDJ@^w!u&hg_x_clO)+p>Qj3z6Fy65!WI@cAEk(tTbS4&j*I2z+A_MO<
z@Y^HPCEk@9_&)CXqs+x3j!iXSLaff@FE`OiB&K-^d!^K@Q!@)#^F;F?0P|}yqY!ps
zPa1(x^k3Vj08<-)KtPjoFa~W*@0zt=ROw6v*vBmw*8YgGQ>=guc|5u;S>iosBO~rl
zm<T!#vI;}}!avg)M=sfJKj-0@W<F<uN`amwMh22}kh(+ZYb25lX91YUE<)y(-%(8G
z-SX7*4`e~yzK>+^)}3y92k3pD2n0DfP{SRo@h1{)?ej7K>dO&mHfBJAJ;rXiz1Ci9
zy9pb_G@?u(;YZ=zZM5|~h^EN)`uq;g{|*z5*xvLm#}LuE=rW`{YU1HdIflTnpY2&+
zHFtlx@m0hrlPW&kufe9(y?b^}Fir)Vg?$n-q6`)W8!f<+Yh};%Kuf6hkZEJ-ZX18n
z6j2<zZpatFjT0swAwk~OPcMY9;NJioYf2U%kFZ*!Dr>cR2=>{StuW2N<rWSqsffpJ
zZ11q(ajAoVl{peIy^u$z;B`)6QI8ysQSf(K9?k<!5&nmRx5+Cg`}VWZ^peVaEnG*g
zW<jX?bkJk&Aqe=?3FXEcEKm3DFUPiNn*8t{Oo%AJG_S~$Xhx2CAR#IPfeJA=VN6&Q
zblf<2d|zMx-+~e&VtpF)F4A^4WPwZI!K~}m8s6wLA#Ebq-89sP!Uw$BSL)v~cZAJ0
zJ>UL27r(C+-QJ@^unH^W-8B)BrJ6!6PQLfDKye5!Z2B8sHt{=z<NqQC%<1}OfPmrd
zv_b(wiS7@Hdi;@;qeeyv{(3NMts>*{{Qb!>g7nz);~%?=DL7)^kV1&xe+1zm(u3m$
zS#aOyolK2ugHvLX#>NxXyfEW!4+ejkGZ>0JD8{w-ZxdA-M_heOVSiDB12!VO597V+
zeF7u7lzGygoGo!0Poxf9x<s#d1#2OqK8FJ|1Ys?BAFTAsWz@?dr$<pqf{Ka}ZEz>X
zaEb26X)P#_nSg?_;@IJ^$md~~QQmEQhf8LbKcPH1cLUA&EthxbDIBBVr_6xHqc|N<
zi`jiQ#xltSP*eO2yP_MAL&`9ptq7nrfcR`GBsRw06(&+}BVPM2qW2F18yKiA0X+k-
zUZSWw6pWM$QYV;=La?ZlxpLNt<kt*E+LXyu%+sxN%M)l>8(x1OWe|ADbWh28qLb4R
z$qLR$1@3ox>~VUP^${%`T@IafzG>xuvMRPZbq_ubBTe(Ao&HXlT>KPvL&YofY(fn?
zCv7?UQx3jqapDLkA>f5Fnf9mpVekf!Mx?)3m#5tqID+-aFVLD9G<##e<JPf&mM)e&
z8a*k5NpqLF%(oWQHOdQEuX~3cde}CtC~%E|IV~@@X{t??88Pjvmy_GuLUGj!5#$WT
z^ww?o^V0jcFO7LXiiIe$N5G)aE?b~P#;5e4d~#G`pX~!x^jrKYy02A{a&Hf?$rTH8
z4SCt@vPz9HZaJJbZ&Ezr=KEO)iPl)j(SLUAD*R5fNCHC1$gDH+1C<)Ys(moZ;3?F<
zUgXYdc55y@5ItjZny>&t<fto?VDywl2>EGMRGxKq6n6@Q0O8a9qecMnevKa}ikM!7
z-$Ep^A)wh?deSTo)_*r!xzh_U#6ee`#^`MEx<ko3o36d-VYBD`)!Z19<KHKzX-IQW
z28jiPUx9Qr+a{PG%yk)u0H><?xhrD(11)sMMOT~ZX&)rkGh1B3nrQTLqqYmO;T)j|
zy2OA9AxegTe!ArpPOpG9Aa~`CW-6R<2G`*=p_XKwR2t&rGS@3@0eb-OLy`qi-UM$`
zu2k}Yin^*RWEPQS57$3X(jo`m;xvE|Y4XM+n|+vMP)6Fbi|sV}_@q%YAxSTeiV}xY
zSV1jBA$R%M6EmI>uqYBEODd{ud7XbF8P-a+NWEW!Tpl`8G`98-pftXb1_yW0jAm9+
z4-Y0L(F_p*&PZ4yMYRPiU7ED<NY;m;=0;zqiNUB9=$3{(J(Y#I8W{LLZEPy~Q0+F>
zIlbSq5oMwK(s60unbL_5?v$t$9Uu4VDzsTn4Chj;Rww7Fraq-=j?>K`QDl<U=He89
z;k2pBx#VpcXX4J)96fgMhtL#TUD`M~#OOwgRO{7kIAx#iHSz)`2M1}8sJff*)hKJd
zRPS?L`K@E}`ook2<WDA*L`Qmsy7W(|t?6<le)S(yXtt5*r6;TOWh8e2cXLaJMnMEE
zZJ)W>zkc5!e=Kk#t%eFHjvDbZPJ0eukspX+>Xc5Q7P_guwN+E^T4r3_z(b$q`G<pk
z+r-1=NoU-X71IJ#5eBH!_HbChSUDyOc+(JIw*!^2ON$kiS$#x;#bEIhXhVoE$nwN0
z?mx{?h{3+WLy+vggBEko#g*{=bxN|9SGY<p*N*jXZAsA(y>+ZRw*=Jm?~}G_77LiQ
z0Fmfw=GT6@d?sAP^9HPA=1geEO=|p30~^}i?4u4;%AtTp;(&#Ko{rqD!2x3T!*;$q
zl)2%7fl9l7v2-(H8Sb~(bq4-kyN+FMMA$7l){<;5t(H(fV!PRY1ARMNIVO@vq2+Mn
z!;CTuYqn8opBwJWHZ$z5mgp8UU)Z^pk5rYH#OaTaS_cjos#t~*_CfQ--zZ*uTQqAp
zEg;9<g{cA81z;Y5`OX{y7$baez;L?Pm^7n<6X{M{tqE(FJtcSD!kTz^ak?Vm2P*P-
z0k-}{P!MT}xC9Jd1BN&VdA>0E!nArxSs_d1&uk$<zdfXkM@XhIsAHKKm|n$8luSA9
z(@iS|+`?%$2O9UfC*XF$`34&|VI6o7M!(dze(?ZaO{NtC81ut3K_rElGc9cRq6I@i
z4%Ha%rc?2FAf$R5-z1${3o${~HNLR0wlNu#0g~v^b!UssF}U`Y&oTM5<ts@OX>iQL
zOrThCA@QV`9iHR!!f4Pp^B{zsl-gEuAcRlum{s$6xapr%3~UnA{_0w1p>k-SUfx$M
zCkp^0TYOzJIb(>Jbf;$`dh>uyr+WI%NYZFZVWcbOEHMFVfAA4x0qN4dj-u{%H8-F<
z)&+U*LZFOzN#n50#rOdy6PhgBR~l(^A8T9z&WBJ`X=x59fxIKRVx|*s!Yyz`;+RLE
zi1m69>qe=^!Lr@Fi#E&F(-s|!S=PAw3Sxlgpc_qQk4;14dpMF#@*q@V%oAuMHgQIk
zqX@AnSz-bc{MoL68$n-|!JKMR?2ISw^7OwkuVV*KGGs+oNrr<~<Qh{*0(71e$uWM|
zZLtz@QhCQ|GLVct%1&$DFSzaRDaX<DWd|KlGuC!lABv{?5^JhLNSgt=SLXS+LEHdg
z=67KW;Vc%i^9g*1EuU=xC3|)l<UE`VrJ;0LrVF)ZFL`Ebt(`QqR&>4r7Id6P`2_;&
z&J9&?j5dr`1JU=3IhXgU{iB1z@+!jXI3&(v6WvX8OPpUQzjvB<JB&^6)|@ZYNRRD@
z!-h+%w^Tw}0#C?fLi8~(nIWOs>^K1y&{pilbQZo)1g7!`+<aV5U|Xh1oagx&B_YY;
zvzKy>LA!y-yV1jWTytdG4`floHPF55PD2T5TZyjS&FI+czJ!Mx__Bmn2R6?I%{tx{
zgw1q6SElqloP9f!To@ozcUeqWq=Bx7wc@NXdLPh~?bL>TBvT<#?WL-9#y<d_*E~iA
zIf_QYGq@x*tKBZ}K=c~4Z6^$G6sGd0hfG%r@v+X+ru{P03Cb$IL%(2_GmB}$;J4i@
zAyc;72j!!?Z!<lTglf<x<YRl2-{LjY^1o1RvvDc+&`##ro%EO&ktnJCfi^A8M1KUs
zgvYC{i0LlzS4I&Pg3-nrVd(&0X}0ls<uIZt20Z01bSS+VZrFP^%O=-}Ojv+b6R}j4
zn#CgvIfgJa60dD1<dm=xhDtNynZS2q%0NuzIxcjYj3qLSGaV*t_HZCuB%w4$Vsi7G
z^FYtiNhKzpR}b`fuI@V=dTY4s2h;#Z4v`PX9{fZ*ZyFpJqWy$cDn0<{;avL&^AAb3
zG#Bt3I;3DCe_i2v8MmMLK9ZkZ{jhgu<ha|cD@cPO77ExDVU)RJ(A4^~-1uj%KWn@g
z!(sVB@Y@RTL#?^-yzT?yG1m`8qt3CYAcoEC9a*u|1hd>dvzs9+8uZRaGeX-t0na6g
zr7j)QOtKgCD8(!L5)^=8s9{0?k&gc-*x0L?KX_-GfLU-4AfF`n8$?G6?jE#}wlZUz
zn*wEUW}4j`<ZB*HvJUuc{Ch%AUw$>ttm(}mH_i+sls-ro0ON>tiQNliYI!LL_L6Gk
zlhFS4#9S0bjqyQ~*#HwZ({LB%dIo+x>oMe_=PG~8+TfLPY68#<VDJ&O0+)+TdP1(*
zpxDxb!KUYnK2?Ui_{;Pa#r#*1pg)!Gr}FGu<zZkq?WB6X9G(dk)Nm$Dtsipmo;LTu
zQ$9N3P?+(Kh!B_#-6i%K&{&h4DHpfW9EP3=*B6VRw}NCcXaSU}u=;ISGGTa*)i0Rr
zM?mrbPV%$C#tmo&Z<nDhRG&FX`#iH{yPCj^c_8L%-)HznK+4A>A4ueS#e5-(mBV9%
zD_HrmQ#^K9uR+tW0~vF9!itgeZzMC<q%$yb)96KlmCH@2&Ob&b0+3PfxzVoGegF74
zf)iM!`h)ZjkRFo5I|L(kse*#$Fr*4LU!Lasff0=<@&d~Hfko<GRf!m%*ilaU5NoiF
z{${@xNgntXf=;6G`F&sFM~PzbV7O#ieNaDrlCf(9e%amyk9dv!n`9wuZd6`X4geGP
zg~OvIeCBKB%IetS`F%NE>BzZ%kwK>zpxYF6%4JXh3?xILwNThp`juiri@c$gDwdTv
z@jWFbX#>!qB|N{!^iMiqvnUxyN>7cFN~Uyib9J*2N$9`wn~Bm~A^}RNHOyE!dS!a6
z=eYR;IPP$KE6-UNS$5cq!NzKsR2{@5st&5~@0}${1q+sm=do*<ZhmJxko(a#PMJ@J
z)=d%HiOe)bo1Q*s?BO62Hs_F1Qt&42L-+#7JpiO1P{hm#B2XfN=7Upk7)|}P@;Odp
zCjZt)1s6~U`txeDryG50QKqlwhXYNrlSzY>(EZZYXv+H0MEH0ge>0>DW-e!&>)%Ud
zg$ADD0<Kc{MMl`*B-BOi^u1CqA&M&M#^5uEg2VWj!uBLZtx88STq>tC-j^!fsZz$7
zrYJrtP+j5Blv_hwm#9SZf{qfzMu7ni4~Y<E)G#v+bU=uOPnv!zXuxjr<$akIfZQ8!
z)Lrm*#)~upC~jmz9Tg`_>e`AS<t7Rn&<x-hO)E_?2f#U4xconiy+dH8ZM&r%+qP}n
zwr$%^D#??iV%xSVtk||~+ji=&@9o~Z-~IQb=l9?m-GgJD>sag?c1mswQ)r=-hmWlQ
zIBP2OnYVA}3mmiH@w5U}IB!~n{whiHWMD1%_urQ@s_Yu)ey6f9o%^Mx$`qO+HtfOf
zxbNx_z=>E%qg;Yy@U@k{Bp>ZiciEwj6UQqA!n(8J*db8)Xh08ntQgS89%&y^&?8fO
zDBcX|Ek0fTP5Gzc{-OLxDF58}{~PkNr3oPbQ=t4`QWdtOKy6IWzm)$UvJdzlW|RLj
z1n}>^!N1u3zaanr@T~mHq4MwY!M|dIe@6xX(zrlK{Nr)?PgnrVn&yNEOq-Nl0H2iY
z3I)Q(^1rGHSNvlxxZJ6p0PqtEaZcq`OieYpK`}XZu^By!^%fh#-*tBFRCA&#E>k-%
zpox=Uy=fUzEYdQ~3My?xyGI+Ge6wR^&^e!1_*4GhBVnF`UzL-CC}mCAzOR0T^z|Zg
zaPEW30&h-&Z&&AeYI9E(ZJB+Hm+uE*J%1jnmgjZ=Oyd#1VLad_RyN3KbV$gZC$BU*
z0e@thBqFTfPl8vnJ`L!Z=(dBcY&>9(<1VH=Vxo=b#I%}w!Z#vFrm^rbs0*7ipiC+@
z{7BG8)1*n#Gvtaw1WBE&3)SIYkB>1xWszYlIc;@_4nkjhxS-7t8zI41rlCCVGBHNM
zl$5Licn!hP1T0xX&(<9@$Bh+8(Nt5EsuB^+?R#v1@2P_=yDcZ($noS294EyAr)GoO
zN3XCz(4O|py=x4pb2w$SIGKgaBmw%=mUJ;46R|Jr87R3#EK5aDReE4*DFYCkN_*jb
z<}hT4!w7|UPcvL#JuAe+53{1=n~mKBC_ZQaqPG{^@D+5D9JhH=1*o2l7-%w+15G3I
z0fKoO8WSiVf>{R3tIn#cA#^fO8VLu)HO2zjp!7<i6bgD@G!QTvFc*P!c*l^-*KZni
zB;L<#Eq*bqg*N`m6{F5`5E74GhT5`CgRL2+K^2l+QPlvHaP)+RZJ3325l{;oCq4$y
z9>3fq{8&QL3m5f28-7m{Cs|kbSwn^I<{ndvOL_ihIHXiSrt<c0mH?6@!&qX#1G^^B
zo$92gzQgPT)_tR^GYSbxpDj*e2l=$uW|GdLZ^(F>tJt~BYX#F(+4km7kn~#4s;sF^
zz*8gTOf|{UJuMMjcAp5{<Zy5QhwUtQ^?Tpmh`<S}G)}g!a6CoeH9PM>nBNdbeeZmy
zV;V$RuAj1|qHT_C-XW1thwBjFgswMN0UT;fVXkU5#XT6CDIBdcp1x6_&_c#~wNCqy
z*XDxsk54EM{AQ&HCK7w(n6pvw2ZHTgusqFNPzeaU4+Jp-9_6^U8E~W)lcFiy84?*b
zC&9e^aVXimN}D*FvquAd`2ys-PZ@C*4JocWy_+m3IH+vjz;j?wT|z2AhmPMpNCkwv
zwZd++REhD6bN|-5zmG){NjVxXpUmt$5W}jjfT8u=<aXz?(DTpR-qxS4hd{`jI%rM2
z)hxw;p@@*U_8(p^8<IS2VSnB{cZGl<{a|GYDfo<%6flwiogaBLpz(kGa9-zn!N1r(
z;UxXV-WXI=K*_n*tj@Xcl;^{OP|%8Gpo`m~9w9}<u}820##qq6E~E-_Nm%h@00`Dg
zwiR_>3oK`WMWB|5iC>9tJ8NGHTNd5En`xXC!1zW3?7c!I=ZTyn;l|Avt!{|mu<Rv)
zguKuB+f}=D6ev2wg^2O%NTA!5r8KV?&Lq>r7ewn5cGB&L2{D9CM_v%^Kuj>{2*ePe
z_;k>wEF)Gvv2pW7=3QY^@dIZ007f6Jh6G}f(vdIs4jG9mEaMom&kYaYm{?d@VOU@Y
zbCbBFfq-2ji9&J6!nIB+Hr~s+<P&r(h!KQ6O)&>6^vTo-dGm6VJ4kluAcP<Fb(%l!
zGn_nG5NUWT$aR<fH<?3K!|J#Mu4~gzV2|}IeDkQxCAm~1nlebks7-pO0TNNmT!#ve
zZA!b9y(jSfD#*(H+8bNc^+Y(}zY`14m`Hy4<V%@HDsuq^D|3s|1td*?dI9r#8wo7P
ziKhu&ax^+9^5%#U_1d#GfQ`-dZy&60g<7Qv&Nc>VV*YxEe>e-L$v+`Bd`3pc(FjXs
z6y+cd;5BoF>Wh3mAX-Bc1HgRCtR1f+4!4fM?6-o-3sw8+A1mOevv`3Y$EKz8K3QCg
zWQt(*_l+<xd1n6*X+Ut*bo5|wrR;s!5p_xY0aS`|i>N9dynKbH%)N>CJ4xO)y%fGY
zKDKyAl?SD%PK$>{$IA%=n;&kBMDjvM1)<kPEyixHCqIu|)uan93h+$<QidF8pdU+l
zZtJ+WEB1wiHQOKy55mBtTGQKizlE5MGPRYk<_TRcnYf2-SKqk2_?{S(PT>v$;o5|i
zEjFYitXPmgNENn-mn5DEf{)`dfHfaL>ms#90*u+sDV{A+C*nEsxxazLreUo#j{;t1
zD_O3w6%sm2G^=5$1c(fz2#yhQYl@@-R^pL``@AzS#<7P|X{H!B<`;nk-)^wSq0<>Z
z3c|`rn_#VQv}vYirvUFSo{)XfvP87z;majRGpt9nD41uBXMIpeOlJ)vq7UH^)&X@a
z%-mzL$>9{zYXD=%_6dQ5Fm5Ri-llhJ_z@g*AiR&g)cs4e5)kFAwrq6VOkq2*U#)&1
z9@S4N&wXNl%iI4b-g`2%o2TREa6;d3AULis<MDo%l@4*tg<QD8#+Jk8X?53X9XzN5
zjlYWVGoK#a7)h3q$AHH>0_vfUB-=H0h+NdOetAYc3#qvXUOWrM;s~ozWV3oVucUGj
z@`v@iXxb^_7r^8xjA4%O{qbG26$QL-dJjFwbGtQfV(M=~vEduTz91h`fJA#P>w0YN
zS2AVS)dyYLt7}54V#mN`{Sf9mB3D#rny%tbBZ{WKkGz(^M>0vgzu|i>g^)mPg8Qa|
zzRtC~;mn?ShKi(0LsVruRBI8{94^A_j*Jal7koo!0nmh1Qxl2E(;s}8CC?2b*!RZk
zN4q@>kh|&_!J>?e1Wt_f&pXNJ+j;4x9AlBPcrR)Kkv@H+iM2p&ti9)Z=hL-!YTWxd
zl*@W0K+)&}slJz(RoI<P*4{`iQN^a82*cX6NBgB=vy$5OjT$(Kd~UYGPg7c1y$L+@
zyT+*;%24_9kgny#bA5B1Xsv<mxe~^l**_ArE^%RA4U4MgH!;QG&f?Nmqh<^*duEuK
z^}OQ<ERNF|9qLA8#gmV+d3F5hs&$i%P52i3j>B`y{$Ld|#wZ$XtQjrx=7`nYOcFwh
zE`|^N>XJ=pAER)EiwB>`R|yN{!GK|H5+Fq!cqeHng$O`tUJ4=%%=|?jc&c&3s<Z5{
zdgmVkdKQkK3q}W$2%Qhi8d2&mal<A3TB2xeWz-^OnQT8a$0E|KKG37BAi|y&+sM|t
z&E8G{FQmJQ)ycX%I^ffszEw~YLN*+$y^I}NUc3Xm2vm?8-0LXg=Sa5ri)>KG7T(L3
zUE$BZs~h0CQr?sqlOeQINrg3eF)@guPIyEmBckfuX3JL$$*6Zku4`mti`)#ZWf$9e
z>OdKx<T`uZwe5vic2-!FGfiGOVRsV=9?P6qaUs%kIGni>F%wJ?v1`^T`Ko-DnT_0k
zFXEcz<TwW2avK450}#dbbVM*)Ky0HVxjC(K)dX0^CT>_G_2$JfZ(B@}l1_CTD>-Cq
z1Z9!->|SEACg7Ht_V&SSJ-5><^t1UMY>aH9Mt1$dz|2W*;;=KwcV>U;;KzO@M!G<8
z>S*_NzQ&T5P*n0BtLBz?xIdi+qwAvg1EGdbJ-UGwg)Bls^l!-p@hdj9Jci#bRidZ1
zISw#8%AHBS+?bk$urKs{`Lcop5i86Sr}OLU!d7FZAigbXib0suK%@nO+bEMOf3rS_
ziEqB~C}BIRwKHO(?M#DsO!CTKC`+CZ^RFChxJ}RPk}J2+SpNgVFB@9I)J0#|{}?I1
zELt5ExgSiK-R*H6c>6Kq<jkB*hLJxcl?#w9qk>|qm~?JAuV@M#^5m1cLVb`1E4z|!
ztZ8@~gn+&p)4Y5K`V-G}=`1~s3!<f<JwjoTv~w?k@pb4TbfS~<7MXhzg(8#dv{UBj
zvtItZn%Swnvo=YQi-6Z=tld=AQx2)<N}%bX85W?LtQfo>tg^P{v8U#7$GCup^bQDe
z#)t$CRkL(WvE2+Iff$fIiOwr5ZB>**wxGcD*`}<m@2xF_2bwlrd`8iKpDuO|N6>{P
zH>8;B$le)f+D*1LigwCj|8c(iJG%gCi8{A^QD~EFXBbiLVs`gr$DuBtHFg)W7qWgn
z_*W-qcUEMa2gR$!NH#gk)|GalB@=+k3oBBZ&S_M=Q@X#3u^TgK`Gf*7qBpgYtWtD(
zxI@(rr>PU+86redoB2l`#ZdrwR;Tfqq?%B&%K=O{vlz$=)O4@uo+NZQI3x}eQGn96
z_$m6|ixnzj4)l1<@?uKWgAuDUHbf;J0V_wji1j>}o|WE}Nigt~{`BToPFjEyxcm+n
zb_{&o_!rM`QfORZ;8O=A)_kcDsBD=K{M5sU(|iL`ezIbrJ9$dM+w=1zrtg5oq6{pq
zd<N@a97{}PBe)x!W%Fn|@p|i?jZFZN*~?6!%51Dmn?-$qI``gmsKRU!8!T+jf`1i{
zSf1eajHdg9ypQPwWL`UK?Fb+M==@bUjAsnwk*Ntgu0s6VDM98*pw>$#JGpG(gHkS3
zS76Kf-hyt@_O%y|t4AA7&+C1dU2&&8Ia8z@YxoL0<2hY}Y5Bz^jWqQ7sOn*z0KL;5
zMEyG#ZR6&#S^w#1nK_K+$G*+!?BF$ajJ=JT%<Z*0&;IVynX+oRBt3u%k6L1`s17~l
z{^)E@c)HK{Mb7QLm{2NN;UIvOk`}USEGeff)9kAaZ@Hj$^7rG7a%gf63K&^Q_|^+0
zOxwGEZG6R*ulC%9*!9mvALE<Zm7?^37A9fGD&-OLx8)0}?>V{%H(#=R-F`d_S#$K@
z&zOYV%&F0>ZhHGn9u1If$E1zSAYjNOgDgBiL=0IZq@vkQU3Y>9TououH^*gPG^%^`
z<7R~J6o(=$of^=<S!O*J;Rk`bUtp|I>LNt5r+_P{9=!)^^F|BkRJ$s`aJ{sFRq$N=
z%EIYjMgHsRz>4Oh5n#Abc=Aq{*91;pvc>h9+h3;ocdHv8@=rx(OT4*fHq;O*!!9L&
zx90m82-`^XOC$MCqep<Uo1L%b9;(7g0OTk2m5{_er#$wYdd1R}jm8Kwcn_Lt-Or3d
z!MWK#4&&dhV8d|J9KVzaej{9_q~9_XO5>0G%(faE(D+tXWwTry3t%iZKL?@X2|#wE
zBt@&ZMJ@04uq4UE1db-gmb@;p(EJkv*gz~>fAe9@a=&Hw+Vt0%$MU@jOS;vZTB)ay
z`>7SD%mH>$&JpMpAtktR?^W$;8xB_Xys4GPQZb;K3koX>$qjTH^Np;jKy1T4lH!TC
zsx{rOQSBdSRo^+J44zxW?F|UKq}xkwa(GqjjcUgEJZXG!fFfu(>&4ZmNZ7dr@W?<n
zV|haRn*S`SSarsa@2v#!<?2Z>av%cWmjeOYR46W#B@iY*S!X{qt(HG0m~{FGIvc5q
zLo~SE$9w1UD>7Cidj*<iWg+hzXU%NLYh})v%MUnZ+5I@41BX_3PS*=-3G(lQuVJT)
zGA0Y}gpwKK++LIAz`<MO*b>kMbb3a9nRvU#ofx@4lyEKu%HlnVoHoL=F`&5UM+PpB
zSA|f0qzeapBt6V2YhIOJVi0cAZY9WbRKS3IA52xhnZCF0HwUbNUI+SkIuhY{B*sNR
z{Jc@?;$LxR>;A;v<CjfdZ#1=!7=X|0j-h!oRQg%qR+Fn1=z}v3Wc`o~sLYH@%qkVk
zRFSRyNhxFhfIhK&7jF)U7C_8pk;v#u)A}(v>-3WZKRieM+=>+7SE=!(RJlx4iGj_O
z8<00Wu$E6Q`=@8Yn~PBl+jR$Y^#YNj^_}^*^K+<FaZFDkFJ6A^)7erzDCH6+qWQvs
ze<x2fqdIODi9H=}Q$2VqAf@LJvR!lhV3C;=g=@xf=$sbY{^yeVj*&ZhIRWgWtVe?4
zjwNjgydRqCj>rCM+@bC7>4=w@tbyafILJkx#%hXQ(*S8EqI+JbD+7`5&?qLF!`06i
zs<EAN=X=gdGJq;-^^kkrorItV5@vRol>uNMfA-eqH(W&Za#me8KxWllo^tZxrd68v
z*LLlkyei7|)B1T%ATgr{{%iM;nhxfA-8Ni5Ied^cD^vyPF?`Ut{`qIKi|g6tlo_5m
z%jc}>$d26b9mN3Jj1CvqeDu1|hKT$Rjv`~0qJozI+2^@}^c8bXA;ove-(7o3SD^#2
zO~`#Nx2#$Ska!ohnA0Qj&5o%>D=w?7Lnz>-q(AK0E|vgMNilg0fInC#!-^n)K`3aN
zWJ8O1(NgMpC*Tf(?aVSe*@Z~3%2>8vQF}CWX{MZEUS@&1DoZ#WZrO&Kbq#FG?<Gg^
zIG#Eh?H@f%m=1rPT58U2u1qHDZlhoUid96=J51PW1T+$X!h;F=e9i5idxo#*HR2Gc
zE$C+P_cw#Yjw=950IH=v)%3e0(#ax3<|wEy`j!GFte=vLtfr9T#=1?sVt%-dE@M~;
z;=6?SK!*JTayqo?NW$}La!YvxcqH+)9g2sy!HL}ObcP*ui)>kmv)l!j3}ffX`qGIv
zs-bA(woiUaTSmK9pX|?j?-6+FjV1;r+#yIA4!^ah19a+V0QxA~Xx?hi@_>Gfw>Ytn
zCB+awmHUbA0&O=2T)LVf9OQ@}?(rX<KaaoLEuL*Oq_HTQ679Z~?zx^nM+T-$nDrek
z466jSr>^s^IUbG<o(1zT8i_z|P7hH(r*_Wsj5XoS?yl1I#8vY$ZsX$4>4!a0W3@Zs
zK$Moi8nam*NRmDy77n3=R(gQCOl-*i#UB5+*@TVb@75?W>Ob1#|G^*G|06b`K>6pS
z7v}#+o!Qv`AEnO!12Fze@XY!DB6a?kF6G}+=l`aiD2x*S29^Kenn^;)_*8$FP+9-m
z49!l&_Fr}t4kEVyI%WPx7@hW?HB_v>Ph=wct9K#d<AY(8Gk36bvm)YTVgFwy=p{bw
zq=V*+n+IAR#VUm+tNnfB8x0!gp^7zmy^cGzd!v)U#MP}wsbUe8>$A`IFN6RvDyc1g
z50wr@FkmF0z#D=1ZNAN7PJmb1`pJzz=f{2)Nf&hzOVZj@*avQrql+<0!O>LM*3?VY
z)%UX_;rBz7V{rReB8w)t2MvlbAQCsn%CvO_(YmtL@Y-G0aru@6<~qp*GU-R-8Q5?_
z#NTb~whsM^PA&e+4*8}Lm$vsajZF0>!KI)2;kVs04aHQj>EYeq)D3E{DI^`r(iAle
z?l}}N8W0!qQB@c8>anoX1K@E>7KRT#Sst1@FpckM+BJbO3l2?FZ!~I!fRua8kE~Ig
zak3On+gjD7YcKS$_t~czMn+S5xXxq<7!ZH*6Jvqg+7YtjlBH8I5Tw_MK>7sp=5-H0
zL&TAqE%qx=jiajigVMYD<H&D~>U_m6d|bYxJg2_q3U0g(f4tY9`dwR^eq9HpQxAM_
zbf*^j6m8m{lLZ?&&uqz|fM2_oD>vr^Q8r6kuIlc5%j$+r8$5fFh;i-<uFk#!%b=Ku
zWyXhyh)b=0zpp&r*|IY*5yJ9eI<9T(+C8M|Xhxu0fBm{k%X=-c4nx-L^D{bJUPjbY
zg%^F8-G?x;N6&g8@W9oym{)Jw=#zyrj8?e!g$@jfQ;Kl=^~bnp1z^x9g-Xh@axgLq
z$1>Kq>0T#0S^}xc6Zp(d*ZKQ4=np}b44JmhrWZaSIv@}DHtRMI37FGJ6EszJopC)b
zFz;o{e`l@+(Qw`HMS6!vF$pc-i++KO_Rz)sn?o9S=<-~lPl9S?FPHa}j*L7cohN(U
z-b}m>si^e8ClJk27VwUd4XeD~v~p85nt3mlykJO-9E<M+qnq0kd)VDc)>nKG!j8>}
zKf5+6L?XKgLh%4TNDbiciD0lOG_BQ#i{DuNrpljL$QX*Sp)r}5(@c9n3iJ<HBvH;3
zZjL8^@%5?x;DL}AqKvvsnROec{}~a8P|RZK<zfXVW#KkG2*8K^QI1@dU>Lu<@7i$_
zs%p5=Jpdg+?FX(;NW0NilmG7f1=8xLU4Dd!Mof09rZ+Irqz0n(6{O!8o==bfLxiY3
z^Sh7&f<*|b!Hz^(*DP=p%Ot)iiH#PMjZ~{s+Tt{-Pc#85u6-c2O0GH+Ij>?Q9@0U`
zBN`sPN2hR&2+$JwMRTdEF+OyUkr*-eU?Bz>*tH_t&`Ly55)ow!JE|!pP%NTNAuTIg
zEeS%LLK7t6+nn>OT*p^tBKM}X;o?o2DJmpnR)kdBKlbROn|JW<DG~7a<cZ1hhS>4j
zj4%?|X?`sJr|_ReII`j5q4O7XY3d3}0awvSHJJe1H$a<;TU{&Nm{R03&%W^PAl*Y>
zkP$%fBY{>L?q_>uiJ$>>xGWjdJ0ZJ$qlLC2(3x@@)SRbXrQZW0+I6ywCfy5xGMGqT
z6s<E&2^cVMCl5U6guw2ObL}+3Pyleqx1L-V$;X)7k2(|?Ba_s+@3(iET&#Sm+-?*g
znbN<DqX3Xo*eQ-m(-ao!MHLIZY@bYPL#QYse}vvl#`H&%3Yr`xs9-+>jji3FHomcs
zI#Fq0E|j&8K&FoH?3M2~4p!O?xD#A$)5v?ndMz{L`4zSvnkVRZ>qXgn=R1lwuT<~U
z#8zrUjJU3%4lfoT3uD3=K)c)`-|)$w$BpD5Z9p@O1;`rpj|D+adcxOc9J*U6Ee1H8
zdBlE@k{p6KaWddnHyQR+Y`TJ7S}Ym;UH3{Lc#HKkQMqUo=}g7h*=W(Oo)%X46UYJ}
z<fyY5f2o+E*G)nda`Ee^i4WLB3F1-%dpQaEC?qJ;Vmj)kN5z48h=kk>wt$;4l5~30
zH-L<`G%T3~k+pdS<N`R_%yZBIz1l48;H(@{AFInc1@cK@K2OjfUT+{N?2w4r*deWl
z{tq8vPgpsy{A1q*wG6AT)EvQVMrbQ)C}o2@SV8Pwk)ZJS+HQ9X$Uzv`Ypt2WSv%2w
z9?KN0*OdIc_=;M3&S`Mz>^=&OqJ@qKaDYk#xSt|Br3Ek76JKe}Kx%QO`<-2Bu(P{f
zLBkdDanmI1O}PlY2xVpT=o2tMO1ZU_0Hj}OA*599;j&CY8WKuw2O=@19DpUA={XN*
z%Y`{39Z^uIlW)u&x|}??J<=-_nGu!}eo(jAw748LL6L|+5E_1jd}36(7&8_69MG`1
zmbKy?UWGsvI++7BKlr8~+j}AnJN<ZtqxQZ8U{@vq?oG7Wl|#9*NDb(stOiO*LMvfE
zWz{GZXPZmZMo`oEOuzJfWr@}&Bpns`*)RAINqp})NW%X^2nT)8%u31I#}4Vv>70UM
zqk@n6&}BVDCS#iK1iH8$D*#9`2Y~1Y5j|uf10B|x-<mXby&CwtdreR>loRC;_U!IA
zEGv~8SvE8;EGkI8@ip=}tf)0wZJD1it#e0}XT((oc(WTlY6j_fYJ}2ri&`O2%{-g_
zSKD?@bE6FYWMblTCF?|`6o#fmb#+4GBeoa6MlnDnA{ooef8noU9cy4%8c-wR+#)<L
zvxr0U?V}q&^ZV_JX%TW$v+_3saB^5nnY&y_y%0T2sHs=1JD`_YeC#1ANC=l;pkV!G
zWk8GYtt;<4#pmUzJ2ULVz#PzVKq6{xcHb@@8k}_0hQ1Mj*|*Wmi&u3u%J^k{E)G=e
zqL(D690sOdyS65w@mCSP40wu_eHlD;F>^585pMzV4{8FCYKr=afeKu)Yok_6K+F4L
z-SRE-*Y;~gfv7p~;`uv5Vpm;_1oD0onGZK%enLJt(F|-yc83NXR|2Eq^C*O5%_B?+
z1w-m+4NVD!ZI4JrQw!av*SST@Fk5((l5=^XO$j}Wf<UZ4R3K{b0zgBM>0kN`uP%P@
z@fOg-VgKMznqyH~w+JBiS8UzL^Glz%TR{#4itXb090Z9rCoIT_ZQC;ow!O3MCH^dQ
zNd@0HgTproMzvZ?w1co?%6Q7DEnK$vYUm@6%L0yMt?FL6nm1dpIp?xfKBBGW<u32x
zNsonhIK^trx8k?|t8~%6t72_7S`tTq@+oI}$DzIFe2SIa@YE&H(tS|g;Yxv=W@eO@
zL_m0~<kbcNOMYjaIoho6dW<ammGY`@K`*NX1SZ1jeUp!O5&C{phO-rz;74Nd0gGQY
zI)2N=n=5F9O1crLg5-N#vH`Ckj5gH||C}BmM_<u>aIZQw1Gt`z))QIgSRMc2uaiZH
zatd+f^T|?V#~vp?i%DEiT%NBcxok+64N;5+(rX49x5S!8>o7>Z?VJz`3F~33H5dYY
zadY%dc7+_(yK*#dBA0SCkE4B9U;<pP7btS4)r3f;skD&?#0nx(s@kA=7T@?c06u_f
zOd=Fqbv`)e26Tg6!1r9@EqklLxNpstHB|h3C{QFNZCuZN?{<*1&_wYV3F72!spy{%
z2akrI)&z`%XiI3}#>YH>CnHl8T(=VPFlgrop?vg|pH|{j*`Np+0h^)DoNmTy{GON(
z@q*wgq<8uBfSf0Z=i)o2RskN&zRBIFe@Amq1TM=i0ZbuM#qXJr+w_60-m*t5s&PiZ
zX~|DwTKD(HXk>S3cL<BVpa-Bh(}1N_>+uHxRXE3)h4vQn8wF|5q625_rKpnEAMwGz
zaW^^Lf;QXR)a(^SMa7X(4P-Vs_mo1<)fMvNbC^vo4U$a1xoM-&yO^|WIPK5Zov|bS
zL_yIE1pFqSr>dozW8|R*HIxX(2ZdQ#1V(tm!WJ)N;eL2K?u&#0+7jX&5OlOW)5Q+E
zQ>xUWD#9+`uW#^cr#GIsW@z9cx{HvqT=_$`5OOY;fJL6>Use*KJR_pd>J`PpM@R3t
z^7!Oo)`pT9r$E6{2iL@Oi}wPLU#~XFR9p-i3eddRiuqDP&`HcJ9`<Vz?z2}PNu?7;
z$l=~BI2T0l;3#Bc%1OZroOJ?CAkmYUxLIP!mzqZ5mW0b7<Ag<a7vUB|wYGp~0n0*R
z8<kGnEP`bp@{9h0oc+bE1!3h7qw$m9o+Vn*lK71dNbyQrXvohH-$s|r4+Iut!22yk
z0Wfd=is6KQg_ck6Okzgc@H>(yEe|KR*h!&*-<4Ea&A6`1cmL<jW{DPl`}XtdlIhZ=
zDHxENK(B)7>^2oFyJ{E6s8Hj9jDQqX?;m^x1=&Fcx5QZ^c0M|iUuJPczXjPx<q6)v
z^UJq43>1~k$19+bbx0eFm9~W&h^*5QRsgLrdBavv>bd3G3SXv!#VO?8dr^jj2ipup
zbjZq?Ua0R3$gQM}mJu35{kn}<ZQ0+Izrx0_CbCkvIu*`teonar6uNR%!e94V=WD9?
zUJ)A~)HxCmL}(dh!3zc-lot`BFsTdZh6#vsOp;+sZEYL;zKcgK5U(@mmr>+<fd#<i
zGvsr1Y@J8Mo<uNUOeTxpV5usX2c`>sGY7y<@y};|w8s%*hpS6O4*g-|(^#u^|HLJk
z=@r#QfMI#*b|B2YvWJeX(0fHqWhQQHOA;ZL=e8vbwuIJfe;9c$>&CwDIxP?SrE}Y@
zs4Q>oT#nfk&xRPc6lI7a8=V78{SBz~*~jguF@W(4vjN+GROgH3q8(owBfT$wv|V(2
z@4yLlXT9|hDG<OLvAnpi<I$6A&?~~Aj3Pl}>fy&f?_QHoH{9iEw3=4<5ZO%~&rNpl
z@;>cYK#rPMQD#<EhO4phd=}?<r==)q<6U$3)dW*>6>Y3U&oBeCn46yNv;+VXIGo2;
zfYfZBCbEPqYhNg{*iq}+qHXXFWW#g^L$@;+ikHP4a<b_#olGN2#GCb}50tRb)C+DW
z!YsIWFb5-=MN^}*GY_QY34eW4S5tlg5i-q9L;>sM#<`)ijA!k}l_}`aog%2)TWE7F
zmQo3!h+xwnM19w7JT|yU90YI!<iC}e!l5?lNY3Zzfn2&248<i_B1A~`o)YIqLGG=s
zR1E|pSgXwI@EUK^BTuPRz!N}wELPOagrX@@_QF{(=;<Pp;plCnrC3510HMqXSy&aS
zEOwciy`|n8vDtm42EE5D6waYj65_GL`Q&zmC0Q0IA@fdUNWoqC&497@J@9&Qe^d{-
zpDqXF{=UzEZURWo1VN*T{<cHqV42k9g6d}+LPuO}r#;maLY0ODAf#`s7y@93f|@Ts
zqhE1gwBW*=jW6tACe*;H3n4)*)(o?nO1#mZE4_8V&!opoWh@vO5af<gR*a&Z3?g&d
zZwvv{`JAuf(vpusgn(SY+{ME_V>kFK1`(+U?$yaH4w<#NGr_<;$s<Nuzze1n!W(5j
z8-xt~qUo&k+@_PX!)WrmAnZylsjnm1tqjFHqHNxQ(IhvI7+Jg#Xv8k8cgQX+NK6aT
z=N|x;Xz<C7X}EH~!3BWdM9w<*x^2-C-1<0!!^vwHQADZY0kCRP%|?r%Rn1}b$6_F!
zkN{qt5>sJ|hkZDzW4LC^h&Sm=qqM3VIAalrjn%g5?^V*!iRGoqDM#@|(X>g|{;X*^
zB34qPxVczcs|B4>??Z3Stg8WGb!vAumQnz`m6@nh!hsdc9u#Qwy|vCPVVvJpH1X=B
zu!Di*R0MikCO}Py7b&YV?co`HI^0K@S|jU(`8<6w9WJda80T0V7se`w<Z)LA6?Ae7
z|E_E`C$q4=<LG^Cm8VV~S-0mxs)IJ<2?Y8CTt?Wd4u?#KB2{8MRb61O!uOS?+EA_d
z&a^jF^l4ImEiqQz41cJ<cOr1Ols{MEBjh0?+q++BEor_H4ZtRaSCl|u_U+CFKTNt4
z9tDl~`Pavl$^plp=om~*g8H_>e(3N2^6_^H>Kg%D!iQAI608q9I6c~g`*G^|_WGlz
zgp=1Qc!w<VNlYJ62uX&;>e8|M$BSSBpQAnv3~X;fu>sNx5k`X?49~Fkdc@Ehj9^Vy
z3{Kl`weCr@4Zu&jv17QhT+`kGdL|etVyJ?iUJR@ha)~HIH`x0YN8n)+OSDz&xM<N1
zZOxdAdR@*duC;Pft)NsY350`qP?$0g7OIU?j|OJd!F}+Svfvmw`l4^2=PbGy6%uCG
z(u0+x50r9;-R?=YkJ>UhR0LM1TvMva<NR<+x|zf^T!7n>Gnm#4FrIUdLciJT*XWG3
zCPe8nx~Ajv)^id0=|}8-?|lTOaE0^NSpIc&(;|Mj#Nx}eWCm}C?(}qdDL?lJ<f0Z&
zG<obA-1~;Oaf063ZSc`em3@~h;nLjbPk4$J!Nd=-qNK7$#c`1^kT0?RBgD9Dhg^o#
zF#AOiMS$(@;xg^waOB^6s8*tm2G^(K391I}6|Vz4Yv#Dn!D<$7j8$wA=}>XTC+6HN
zi_cf$-#=Hr3as^qGn}z4XGM7ZM^Z4*bJjMEzLg$kf2TZAU|6e|!75-<6mS=v_3K?e
zQ^njMzrXX725c2E99KXft4{gnby(+iZ}TZ)3I5%NJ`fz5g*t(i0k%HuhrUnKg_9Ra
zcDm+KA7v6x&Xnr>iE$w~K=YiJFv%n)ngh!G#}(g-hZ=LmX!GuILQlki`qm5cstuz}
zO0C|>*zN+SNP_vL6j<6))73%|-4*yGLgl=v=F(0<&PfZ-H5;h!nJ;80&sDH7!@ZMJ
zjs=jw`@yQJf}Aa9{xw3f5HX4gXDKQGjB6|ARx*lhR?uK;Puqdv5^rw_`9o2Jluf{x
zOX5k60NCq`cFR<FAX-nf9#Lzq=~Q5_l8NX>j;GX%8fcyOdJ6PN4jlGm*g+z?FhA07
zDzJCiG@EzGlo`FNV@Pf?-loSEL3yfpO%uTXb{$e*KbIkHR9#`GMjPfWgc{}@&OJ%G
z=d+FWO*VWbWW!v`=gHO?N%R|3Q|YOtP>X-@^eqQO*S$T!vs;WD;jcw+VA6%NCH)Uh
ziff1ggjuMvzT8{>J1K~SKB0Xwraj+Q>AZ<%M{-p`21rQLL;BjI&bi&Dc)43Sa2tSK
z2VTOt_4)TKb#n59>n9ghK$iWE9oH>G5&aNlk}Op)3W%B<N`D4B$Z}0hJBO@bcpAGr
zR=o34tb)x+$=e$zlRMwU^kGrN8YxUKaotblbL_8H0U;vmBKBhEKyDwHqPjg+z15qx
zgx@Dok$(!d+0m>Nr&V#86}v?+CpiHE&)HaWJR>C3(_$`m4vfqkWk-tD*NXz|$#XM!
zh!*r|m_oiW)PEHIOa-eS*E?aDMx@Yb>~WZh$j{R^?-HA#jl_NtDhRRZ?Z3ZOKQOVV
zPG{M&Hty`W+7HG3>JhR#acrxvC#@^PCBKMdjxD4v*qgIR_F~Hd1^N0(rH2Ecxml0%
zJwuK_z!*P8Yo8EsoT2?}K;1mU=J+_W4M?(@4UwAXW<Bq@ATSN(5-dtaV-MLigrNu^
zA1d546@4)f>Wa~!F-Ib4I<Y6Jgv;??X*-RK$4e86JxRXdhI7nVFHTg+hW%3JX3rZK
z+4L%ita8gR)7c6Tg3Os>N7n=>qY3BlhpIFOKG6z`X85){MHGFRWZ{dwD(GZ2|7D!@
zw#cow>=jvITK9C-O6M(RGX^m3lc=u#-tty?n5A4V@N}q$7PKJ~76T8cV=Oq4{TR`(
z)`ytgQZTE3`c$fdcgl!3sgi;_4;rG*STr6zlToNyj)gbrY3Tm~qDepl)vJ|jj-69c
zSTf<pbW{V@mAOT^;cKvKyFDGoFLGh*(Hii;tm14{2uj+a?hAoX=9RJ{RVFuydZE6X
zx<C!5XqeRMA&@F0FsuP^!_`3dYrHy21&-C@guLq1BJbNbtgre)GS2J%;oMwt6tA_U
ztB?=v*#tr{oKvQ9U<$x<&E~86W{2)%;YP_2*jsK`8V2cs^>t8T>TN^1+Ke^<ji`O>
z(oW{DgE$1YI{Vbgy0OUQGEi+<6P_Gkc&-kHp7ghSqLv_2&qHV)gn|Pd+pCtKRkV65
zp>_S>%WlFqiC%j{O^y(vlj0)Z@eY1UPHl-hoLZPYb+^5u+8)5xn)dqiwp<V+0X-dT
zX~-fITbM;6kPK2)8iey|1XL1Ieon;7Igo)9Ii!6o1NGW^3swpj93ie<alHnfb+%K+
zq{+I)s&V(Nw?jk&NsT9Z6o^e75+%0s36q3eI<{gLc>o=V>s-Rvh(k}KKJ5#5i0ZI3
zTDg?>J4(cT=MTVE(0C~A?|Z)lGw-(Oa*s5Y!r)$(mLx_n14j-Q@HHVBWT}zGIT#AK
z8S<mRSP!=E;XWR<Rv<@5^@&j%TN7ZoJJ&6)6H^vklX~ZGhUt8pZ{d-&v9ThKy>wsX
zrV_eQgD=-71~wrwZRG70cEi!r!sMJLn?!~`$}d(g&;EemHu%dSri|%V)b?6diMI!`
zEc5t_<Uin1s#xXcQmTP#M6mOZIYYj^dfl&RdCImbGMe?>8he7I5^2NgSV5GaG?WaK
zG~wLko7la^oAg_m5a8pV$lYy2%Yrj>-FjkC3Ywg4pX|#cyD{ctK?^~V+#3nor(9>K
zKNQoS;W_`-uhOjS>)CU1B7meY=jgc`>5;V~ExEF|IjvaAwXzb4H>lC6$Qzt^9E?Ya
z#G>dn*;_)O<y>yZsdpc-m3#Z;Qguoz`25KH;^c-ux<rxFn0hZAF(VB<Fc{zLIWE0X
zNXO(GCBr8k{CoO^AJcRLUD8V=m<OTpvV4IZ62Jk6C_8t%ch+Z{n?o^j>X(fnAUlz}
z04`>7-o5#8WQuqkWB3m(C+R1(wk?yISo?w`>DJHgob%S+V?jFcs~1==TrNSAf=lW_
z0B~k$L3DIp(Iqt;2$fa2To1&J@j0KMCypGDvp;JiA|A0@PAo5&h%73(m5wax2caHL
zYa(DGDaDJG(6EMFn|<9m<B{U1AGSOw<38sKHzf}y;jl5}o4EN#VqZR~PFtw+&c7_L
z{zfA8P|!jk|9Hc-3RXczA>>C)Q$CQNdp8$7j9_~)ZM-r~e|}4zH60UAQ9%RAk3B&k
zhps9`YE`L}r0I%C7oN&75FLY#OdTkoj0^xQ`&}_La=1GiNkLVP^CwM1l<nddOiC9x
zF6(IqMh_H6zY+_*;i|m$duZB#b@g<T?CW{3kQ_;I)@8P;Vy*>7AAfO7X;FSqEP+s7
z^`8hvkf?aq&sysWz$HyG_-H4t8Nz_C9cnK}Bw><I5Q6n|f#|&c4~DN`O6|?*XFI?G
zuWpvV%~mwOKAb51C)P831gfe{`F($Naf7jja0k0FZRcg#O>9?_xF~p;0XcJmuZ%ac
zc06+lrY7AKwhp5Kv^VwZ&G}XaQRZ}-t%9d6gNbXC04$LlV<-_pQEH6a^sb*XHV4;4
zgmB$k>xD;cCcZc?l*RTUY{^S7Zy_MuXiMbNZ=!^n9$Qqzt$R|&|9H~Hwg8NZi=AO#
z{6gxHV7X!4omQhJ$XwOloQ9yhK^=eR6a6Px95u{uASI=IDp?Hl`g1>|dR9Zp$Q-Cf
z$ZO2d=jhG8w3Is3ky#_zA@uJUVoOe#gpZa-B_IPl7@>qYXc)MDwP1NZr!he21r_F3
z03jF^2>SDUZ*-%7!M-0GmiassS(pG3Vp<SG<uFZDkO|3|*4irNH$w);>5zZ@nZlJr
z-GG`0T5Ld~$@^o01M~9iIE67&bs90bP$Mm~Xjw5BrH(W6QQ|xE+<KgATE%G3tl=md
z7GCT49}tN;9=HEWX+i%EP^1N5|6P{oeuPE)C#_WZcSg(3{7*&;%#=n1OM&;F`3dlU
zdK&+!WAOgByNUh(D53uUnd$!?nfO;j<ezjj$vFy@;$IQ$zf;wJC8_^toBlIzf&6c&
z6z6|p*MDqIn14U`zw%WM7S4ZqAzWR0+DV%dF8(LAr+zMq>7WG&dKRyND%H!IPwynA
zFTxtZb5@UV#SZx)KS|G5cx!3!^jVAPuey_v`p^Njf}QW@8)O^k$_eLgFMGdblggzM
z^-B|}*gFtMwmd%^vzqzx1h-1YzMr;U2)|#KTGs9{B_t(89T%H3|HJR>p3h$h4Za>_
zgylO`dCk?5%Y%5P-Rr9uYP&xKw($$@<2txl#JhhKmZs%IxaEqTb^iEsF8CM6Bhr`_
z@$o5WnszRxT~C+${fUrl%}g3AQlsS@ykO&79@y$y9`pCDZewEWk*eVRRjG2G*|D`n
zt1hNtsTEEK7s->f+eZK#m-MGk5N3+Pdf=*_HpTZWNvfY6xFX5FKNh$>34Xu;P<x>Y
znT2<Vu-e0yWIz4zRbV0FSC;rS^IBFzagJddcCW^}Co}c>^7aj~V=-QEEL~>P#vKvE
zax^m`X+U(!?$ppgW#9np{+`BLvgo62Ob`;;U_!d{ekOO1f?0N<Df{k$bv^+cs@P=C
z2>YWtP}A)~)1k7m^q0hrf)6byU}2uh#|VsN^=?7^9ZvxMg#@;E%qHH{4|-Bhc!E!V
zQqS`38#G6ZPWnbEXuBSgh7;69CN)7$xWAqt6OzaL7UY5cgFu0IG`*1xD|6yWPqHEO
zb86{ydryI4()sm}AOd{X{_<5i8f4}@xDYX|&PFI>UsDL@CQ!19aAH6^$$F3w7$qrU
zkQutH>gJ{=d_>?!(!d}cuwByaU@$<s$P3&e`Ps;VFJzkEXnqk93h_cTs*~a#G&GCi
zB4ns!{OX&nslo7d_)>(NuaKK*c#<TTFW;s_DS>HGP~Kg)&5#A8HxyJ*(1ei6OB9!{
zN%9aFw@moXDp6`=xabODnkjcDZzO(og=nJ7=9^;QAY!A=$s%CLa3cMnd>>%!i~vCa
zztV1FG}@CNEhKU?eQ_-?1)O1>AwErrD)2b6q1c8ko;?eV{N`LE2~3%G9gZJGCVdb?
zCMBFW%H#J_^^Z5)7#u7`^b^h@{bP1ngIaljXj$($)ij5t(Ug*N@-z)vyx9sN<n`Mo
zToIbJ$}N~HG;D+v21>P1C@KKTYwDLSuooutOe8F=5SFMY3&9Xj0|NhB{U$at^-7Jk
zBnF{;hmG%5M_4yn;NX2Gxh5$~X|1zvnhN7!ycY!0BbNCKz;AHI1lr$QfOT90qJSnz
z)}IbD3#!vd&%g3WGR?wmigD#y;PDP46>g>3=|l=Mq8E;6DeXdPlv;B?vSmIQ17v$=
zMd2A_uG3;a>GQS1ahQi}0tSDr-!7ea0oE9T10_A_g=t!(7%egeX{A`%rtdiiw-B$d
zHZ28|byk8B*Em=%K(<JFTD8ZcLcI@&0VYXugc3xsCCO<-3n2L$+O~%JjksU)5KGr>
z{_RS~4q-N}{-%wONO#|J=^JkqdYAJ__bT{%Qo#)9T9b|<JR<?VTia5OvF@RS!j-oE
zf**EO9^&@2T14?HNB-IBUfD73KCm4gTSXc~Yb-8r1_{p?l#+hiDX2BhMFsKjlNxA8
z^N5Yh$Gdz6R7kT<4AjIh@0_51Ac6M%y)&f5j>^Qe?`+oYTZ<da_@DqIE?nOaWM}Nk
zXiDJtuaGk_s@DjUp+0W#I*z^Nt34@fR0W{jXT<JaS9Ue(8Ju(=&unCqoR%p~+Z7({
z0##@&L@NEBh&Ns6n`%|tRtpN!XN{J-SVz*P;|k0g?OcQWv$SoXvSnbDCEjt(v0f=)
z1-46v>Uka+w$vq5^-9A0bdo883y~WClA;fZsN42Ld)DrOB(lXo8#&o%7}6a-dksLc
zU^uGnkFKS3?1bcKj$8eD+3hPVK#`|APuE%eHeQx`SOxB<QB~6Dn2yatT8{XBQcqxW
z_p=w<q0%MUMns3W`L7Nc({M8Nk5gK}^*)36YQ$TL1jiii?nV^&u6Y05GQRTtfHzOM
zH!lxl2$0yL9o#)$*t@UJ7Y6qQY&9Utvr!(ifhiFrAaO^sp?tQanT>#zgTOIHlS{+H
z<BIpfJ?aOGqwS}w6|Eea?uWVL!|?Vr#+1>zHQLGB_>T^jZ`ggUfWeGcCx1*FM6D9(
z=d3tMNb?Bxs=GSp8GprRc#EOXHYhjBp?MX;bdgz@Kyi97O9JxpAArovZEk=XXSXJN
zz^H6oX_o>qs9u(oZcoC1mWE&`8j78T$+t#U8+RTJwMNv4L#GKw3D5Ac#R2;zFJCHQ
zmZ=jrlJeUEQ1dQp74UM%bhi<EqV`J{9SMM(HUUYW4#Fm_b@fjh=}{3G8yak<NIw;U
zELkKY;+P%7Ao$qa563OXB}M=pAup_br@8n66Oo#*_!=Ky?Cb?9c=)^NAp5pT-RqQ1
zqG4i4l%U(B9you`DHYc8G^Pvi3JEefNn@z(B|V4{@xl;^JSHrZ<@@!ep_k0OOe|tg
zo!v1CJ`+u3KrthRF7B&}iBf21NyS4;X(2()NvX}?g>rL18%9DwN*zEQM`#j`=x29-
zc6VE^$}P5Y+HKfgRNkv@qs#i=zYpU_jT}lz$T|ci-zjL$DVol>47IV-0GdiNa?)5%
z!lWw$ZfrT({&`^K+5oWFS7rptxoj(|@&K{nebcpfVd1aAsG;oe-;&I-n49NKJc|>`
zWfb2pYj#fzTwITSj=%t5kc_)|o=810i67?PLPl{+?<4VE^~%{L4+7gB5HjN{oMlWp
zGV>|!GNuRY{Z4bHSGV(5K1dm9q9n2+M@PL*C{lcTiEM%1_H%8zl|NJ`j|-?HPcSI!
z6EeKBmLX!F*$<lo&FM6_L68AQhIh1|$k@y(vIvxDKbSPkxzGT1G%lE)R2IrmVwO;r
zKzfT3?sx%1OgQ%Y=(xs6Fw!Vh!-bew6w}WGi_s|OK{R`d!rMCjJULCqw99mG(7evH
zMRaR}eV9{t4v+4FZVagkDy&2VjUirYb$Ft##VP`lN1_z!C>15#ABnb;k*E3UtwZ7Y
zF0Rj`tC&tEc;o=r@K$(|Ad)dlya83Lt!kxH*D>C#W<0G)uHPapFZMFhiDKO8YBV9B
znV*$|gg`V2AfTcpMv^5ClOv%hybdQ2S`-D(RrFOG#^)!WgzG=3*zb$W`7O@f=)La(
z+~OyR1mLxNNCdf3WzNF9(E%$`E1IuTF`c50H(9c?eKCM-5jA4iZsHWp@I^{dtSa(*
z11URTs%$J5MFx`C-<TVyp;PA^uf|$nvD4|3zk-ZIz`)Y9ejZ6iF5^y$<V%avVlIWZ
z1|6g+IT<Ke^`8Jo7_d7)>{8nPK19dT>T=a22pO&s%!fCX#0?!>6OMEQg%oItYuKBa
zHbT%_oudbA1RgfSR^@*y9DP9Icu0H(xK3uHh@*@SX^$2?3nacz<H?Nj;R>Hcihx6U
zB~ze(+}B?xbP^b=PfnJyKq43^k)vwxS5Ai16$tA-f8h-j@ep*oRO%ibI^=>8zU>Gy
z&T{n^!5)C~Nzi7eS?$sU#f5b3HTNHFqG^ahCW--S5NAaBG1up=Pu8ncs01vj&4%V#
zA2`{0`pjlDOF?RTO*#*~QW9qNb~l7iypxMPP^o7eK#pWje7%Gybl(mvf9t*GC(PWt
z&FGhsyn5Lf8)tvIVNKf{sgYnf2fgCqe?vNJEM@-*d{m#!@~5Rkxx46LGKEn5W(oC&
z^neA30K<xeT`^E`FTg~O_>{kgqL}W+#6hQWi65&awFQFR6R%H_e-iJFhuE$}sSfiP
z?#f3eS!6)fitBwtfU<+maA{v&;8!Dz(~}vDE9#~H!uQIU0!wps`rvm{$dvP5O|i}e
ziH~)c_a@T%%T>Pu3{y+#u34Ixly2n%5I6uCHMJSTNVLU2pstPS?(4NL#}X=%m9(|O
zUaRX`6B_ZI?{eaWXxn_{eE^l>N-aSsnE2iujPV;LrXkSre5AhGtT;#rD#CB6oxHCe
zW`02)Xx*~?eS^?&<1bSaUu$)1f97uLc(MYT<m<<cx#jt7C8Ea6Iu*FG<W|wgt}g+?
z%1q1}s3?-_i?LgS(vhz|<s+18BXlb6YUyrSNpfZDhlM3|y^{R<n1o?{m=>!jtjq?i
zA;_`D1F<bkm?hyM?yE!qf8so5{bgs7BGP*Tu+Pm<rlJW3^sGs;nWrf2{>F>PDBk79
z58thv$VEJ)k?Vk&{tOQBc9;<|ltRE@Vz~$vHw=)ytTeMx?bJ9vV6hFapJX1F@z}R`
zRcwDMTpxopan-n~yq#_2K$~X8TSh2fZbb<s7#y#=4nrN|7S^)vXU*7+h%;&(_=9h~
z8*w9BgdJa)XuA+6)>@(3BfDqE^|H5(m3|i&1-`ijH<?Ee_(*8P?V63^oDu--kGAfL
z0N<XST;xTE-37PBp1llYY=T6oKW3!p=FcXypJN_zo_H!5*8rl=%jrCzWW&HJk%$`V
z+bG=24}^o5F`o&@(qzBCnqsLUGlV>YuQCy9a_CjNGnNdjj<4OV5tw{6olP@wy)!7S
zqkb2q!hrxq7egL8aIiFT=pjJeT1D@Bj3om9vv671@&r@ljQSV{G!HBT{<-UF;-asm
zc^{kx_o9qzBDJ3J(Biiw_dr_#xz<SA?PWsC%WO11`3g?bObu6c7N{hysX$EimIPvp
zG@YwlQfH)P8es^&>Lyw@g%m86`hw;HxEo^7#|lEhK&v{2jOA$H6d|CaH1S?_z}ta2
zYn1yq@9(7!vY`2N3(GC{N#W5Q3(R*W^>q+jQ}vCgHz<Oy3c_^cFJ{HC6@|9mW|sX}
zhP4xU!NLRTDX2{<eojhk{9dxl3k}?}2rx%f@y~CC)9SebCla}*K}J8nz<MS<W$c_F
zV+X?a&Anx8)!L4A=v;uqBf+n^2-LhNeFoJAefuSO%L>S6Hv&e;dMUgvE97o*1z^<<
z2}tl%YIrdJuh|v$m4tO>4`QxR*p*2sFC!3Ry@Ot&W~-4>05RMy68EtO>FS`Rrn)NQ
z+ct?cG6)K54RMho4C7Im(=^v#h0bj8$ztLIxm7inQiVOo2ru9_I2{<I2iF{p=n|_}
z@vO2P-)zQuH$)x(|Hs=qg?I9;?YgmT+qSKaZ9D1MPJVI6w$X9Yv2EM7Z6~Ye{Jy!?
z|66<S(|t7Rr0S}ps%yOWc<#shAt9PoE<N>Q`NZbF?o8;pH1I}c_2PSWa?RQT792+Z
z+NQh^FY3f#w-FSV9V9xGzewD1e{o~XCX>>D&#S8qZD}jAo!OZMr3V_zu6DQfIoi}Z
z(=$@;kMJZTy;?b>uzJ89A>bvtzAt-W^iiGV@MP5~Wp=zNFNXWs3fUoIGdcq+R@d_Y
zMc)7g56<3p7=G}pL$Zr*f$sBHE&8|71s_{&_9qQznx3^vj!;KS*Z>e3u4CQ{C}9y>
ziZx64xPVN=tCuJp4YK8xHeO0D0rRkF>+cmb(v<xg1kvr^!0#_wO@N4OiHoNsVY7s{
z_*OQQhhBs!&ar0Cy;W7SXZ1Gap?mwFIiW01aTeavx#I^{7z&AukL<m-aE@k2-?8MJ
z67}EC1AioQ*h7#l(851?xtBOV-OJYZG-ZyJ_72(bPgOU0;QdcxmD*Ci?S1Gm6<>IV
z63?xyzH3j1!)s7FNdPWDIs9EY09+S*Mz)%9eeI_tqzi6&^ylEwA5N=Qj*(XRp};vU
z69CMdH=7;mA^a++>-q8UTpMrWQGPAZa*<Z%M`g#q+tiUj7<K}zw`kSc#<^+tJo{fN
z1TQc^E7S#h8LWDbJ-XU~kWwU=jJ0BZkfp6jRh1aZ<NJv7OaPWK89Xte;dkf2vmSS*
z(>LkSSZ;FQNyCx?)W9ALIOFT5p0~zzli5gC&6Xd+D#VUGP<_~dy@0)O^Rdqa9j?k+
zB-x9ESZ3-;3*Ua+i0wSBm{qYYC~D9rTLSWWrLWjsZ|(Zw4<y;}S!X{IX<q`AypyR_
zcSB5jRGlN_YJf9Z7038FWDUl2k@z0CT79~97xbn*>3#W&Z1obI{ScuD>4KJ5W^_)K
zT)8;S6{eTJ=`Pw)9I|qksIU)T{T&bsG<^t6Ek?D!_HRS#0jgUHo7Lqo&s2BU1MS3a
zztaR3dEs<~_IMi%kIX_|%BE+dEhXoSHR3Ei4%|`s2SBS4fv>z2ciXz+4{WD>y!13l
zKqB@S^|3%K&={FOrIE>+_OI<9HJ#v9Dh2Og#e?E3OXpqJS$I9}cRD7R$N7mED3}N$
z4ax=K7wT7;b~tG}@H#Le2_3-jDsMBz8|r=9Sg9yR+I~1GpV_zzNH6+75S3=swsSI{
zp6)LDN&vyRo2Kr&(E?qZBA$%{+!yEu`pcWey$SnLs!zGEJo+y&+3EaD_S`F@&Cgt`
zApuxFl6IA{S6_x`+_`5y&p}Fu<a#K3SLxQt#ze(Qv4pzXxp5LoPg&6=EngdxSC#2A
z;{s7rqg%8=-W?~F$Pzw6j3?OQ09(R8eKb8Q6#%<6e&+@2L`~`7H8pP;Vl8DogwA>R
zr0Tk}DXCuTqqXrX8q=rXlJCuSN!qC$_;8Lt#Sv0u`qQ^PzPmA<B)h2W^;JOI=toSC
zEA(W-(7?*4y10Zt;Gf0g6rkJHQ9}>7sU-J<SSPi}J@%zdLO<68NvW4fq{v+1H68D`
z=m67pl$gw)h{sooIoUfloLcr@a~KrD4ZUa_0vkjf&;r=_n#0Q*LUq_1leQtPIOw=G
zWHpkRp2dVY?P;aWtD-c1)ZV4gJka!MyO9zJhebXqh{q?xOE!ASu8)O1tgg;@aZf_$
zqld4`odrc|-fgw$?L>Bc%SO^)oDdP$<N#tmgyAUicOl0#wA`MN4_}la$=&Hht?~mG
z;?`usme1e<!Yoq;pi#XkucM0zu59BjT8j-~rgkzY`Y-hHz3xA3qy~8y^bdjUau!~W
z$w1pFD2dc``j5&5I~600HcZlyqV69JUvkvw$1xiL=}*u;!jM_h1M_1M)o~Hmp8&ld
ztqH|hslYJfRSw?_!mFOxJ|Yo%M0*Ye2?G@?EZ8lQF_=R0v60{U#O$%kC(OUJEtyU@
zbvyifds;8fKR{h@K?-AZf71^g^;J01eFq(KB=?S5^N6(d3@H2Q3xVyn{rwT85Hgf0
zVP?v)Q>5q?8Ml^IF#PZnNL324kODZ#YuGRw$YLJ|=5@61#1+wxPfVC;%zU$^|5<k4
ze{kiV(yAsmEWgwGQ3fUf<SG>v{J_Jf<B5<Kt}3+<Oj7S~Gbk0?fYS9Y<#no?7GiIz
z*~r~EZTCaXU^tUj7_(XG<!R^eEAn{tdWR)F^!F*96L3R<&b>aS(v>cLNGwzBB>Zeh
zljIPX4%7RXU(vqWargJl836eF4W;5gQ|ABEa?H;DHw#3B_V2On{~R>4{lABS*xCLS
z24ea@1Ll8vhyE4H`F{?W|1&g3WBo_V@n6f)zXM4B>OuaS;Q6-<>F@Rb7%TtFQS`6D
zG$PUeo^1bnF8yD{0qlvpk*HuC9BiD4`D-+Q@q~Sjgy%1qOF8uUz*~qDy<a94#(cZs
zEB&Fo#)t&dG17zO<~p%B{2QD1kD1VlWWoVtWJ-%>)qe}o!2`m5EJ)&iC;m%2bO>+z
z`MuxHY2aHjF_0i@&F%TjWfX;CyD-2cl{P|gO+X<i|1E*8XS4MF5mR<r@`)f&-<}KD
z`h2XoZm|1Mrzxlk4&RLZQjJlZT!lBH;Ej2CJGcM9BF8b|qSVFz#rFmr%1$WC#=hv^
z@1+zIKMC1uHWU-|bjY?Lk2V@L%Qb)mN(xrnpiPcmtA^Y=VY-C%a*dqFHd`L}_OrD$
zmyy)aQ9Kv}T~h(MhAtnw8(#DM^^*k<D?5mdTr9HG1{T5TuPjzp3BAx9{}XI9i65~*
zt!r(=k$2NCW|9&r*%+;64yh=1THEf*9B6S*vL8t&2}<jBTR=oa7|f>&8anmf8;Cyh
zXgtgX*mO|{ZIy~82|cy%kC#z(vWT?^IFFI6sjBJP(R;rezGyJW>Xbe>jRzrsrYpL%
zTg8pO5v-CoNNGckJuv}=_P`V(BZl_$M^`(m)7xvSrXX-470;(%=ej*&q;IX(wL=0Y
z!0-7e*Ise%G*}KT<kyOgaVdrJ&8YF?(Qxj`0dUvHIanHBePXQLiB*9RB`Cv*DfjE{
zBmmM`Qlu*TBno6hYa5SA7ugOV#{G+xKZ<?ncWJ;i`$Q2C1G*+M1up2U*sQd{XCdBf
z))<P;xNO;78qn2fR80{)@IC}Z%qWMgtqB2W0Rl}G^VPW%k}ZgQQe1x3Pa|z$)Eb!@
z7isz|&^Q<9TDCfp3Bz9bc@?UiihVSUwDGbnh$@g>Zh13*Q+3GSFfH5w(vf%KqQG!E
zBf~2ZYBq{E$X;4onI72HOA~2q%@#L)3}os>vC*~rFxh;l{l+mviaH!Q5B0JrK;%R(
zR;32`I5c+v@E%r}H3&Q$Bsqn*rQ+mY@8k*+vW<9fnu(}v$Y;OTJ)X)~)`>7oO(nQQ
z4blSa6U~P+IGbz=FoPxl@vEX$AN%V%5&=X~5sya=?8#7sD>ebRX5!S<1xY$EbXUs7
zKfdV~+@dPAsiMYt0WnKhM$rAHfIQTV@ozawu?!+GKV?aOksB2hN$`A#i3|}Cc!@3r
zbT#Kr7NwOfYJ@JQQ~~9{O=-N)vRN-I50{-J)15bFU?Ufdx1tZg0AqFlZG3W?xsr}q
z54jcG95UVvsqD5G5s3C}B3B6^5<wwkNEnB|=`%Hp7DS;cU5YjKZAt|{lt%<L09Qt>
zhN2<|Rg`SDys;9asw<qyucn;j2(&lBgH{(|$tEK_v6~Xc0B6v^l3Uov4druwB%}98
z*mC|Lt-FwH{qz?gZ53o$yEgJ<)r(367(@WhGW9#GVhl%^umGxDbhkb%8KMG)uqfk}
zEpm;Fz8w71-Za6#-3v_G4?4gr3Z(FyuCH1qPdPP_Op#u_2hW~v9k~q?gAe2ng?7*z
zB<uRV-VI!6od9Mm_9cj8l@N7M8UAvo<bE~KGNnjRz$qi(l>;LK2Fb-MJg<oa(*cnM
ziD^I>LU%b42nbQK0x3IRJf)}QrW7cfUjqC0c9?MC239i8hF;zuc`;(<4@q^>UOv7c
zN9>PkRON2@Sh@`(?%R<eX2uKU`#H9d?G6r=m57W|utRc{2OJX!s;!dc@=^V2{q>_k
zuUz}wYp{NRk2js8eb`|$lT)`g{hahGFfLS7bO`y<0}C8FS-n;+aph5gn3OX?KUfk1
z)=|yY(f#22(32riHqthZx7{8?TXLWdc$JH{zamfiF2c|1zg{4OD<Ymmr)5wy)^QS2
z9C44hwhUBiPXmG444QxztFRW=6SPS`AW~{_eKJD8pY{3%<p9GNGCEG+ps}ChIjV;2
zi=}(FHPMuDRJH6G1|<3TKZvxEQ+^xvP%cNoW09ql8_a1rq%z(Q3Un!1m$lJB{v8KU
z&EApqVicbWwJwP%sN)74^P%p9>|Y5|oWiLXc}h_k`oHm{#$8O7b-|ywmW0;v)1YSg
zno+_5Hk=b_%JgQ^DA+25EsZ_pryLznvjjIM)1t1POazJ%w7jheH6;$rPTTaON~)E>
zu}VZZQ&-|yW`m{DFP09Gc`2ZqY4Rm{Gbha#zFdPlMSam%N6eK2Mkgq6R&uR3&nNN}
ztUc^i5s~Rf;vk9=r5uZz{xl5mt6xL$=zZV;WF%k<9;Ng&b?B@qPWxJ2gm0xTg@BSN
zkO(Jm_U|4=H&E_T@wvoOpw-bNBaN*qIs@g|AG8}3Q+|gmM3X&;!JeAZn~LI_db`B6
zk@a&Ubm=g&PhQw7K|(`__FT%&3bT-^mkPux^}VSTAV|A=NTa*B;P%g{?w||;Kxr%i
zL%^PW1*~BC(J0jtu<2;@rUufm>12PGb_{6)qYc!$AZ<yqWpkHEF;!Ujdr2_`cEc;A
zFh6Vvh5oQMj4$`PE;6lG4^vz29tvmT_CQ6R{Q`F#8KZm;d*E~+FKXyS;Rhb|x&n_V
zy79P5<QH8dr(oxAR2K7M-cdLS&@jNN<nH0P-i0QJHhJ&RuW)zlF$&33HzzLC@`CVT
zVcw-7VpwpbgJNI@g(=bO?E8~n9?22AHC^GXr%l;2I!G*r?(<pFywKUqBJB1j;tnNy
zUh$~sbGVB)Xq%d1<|qu0i*!yvW|ak3FfDmYHIWF24WL#MX-udgt42%b6F7i#>2t5W
z(|uhSWcndxs%N`%N`3nN^F(cNHV9@}pVsK08skp#-A#qaw#9h4uwsMHy>_I_fhq?J
zq??%>4vTSh3*}1<dL3OXW1=RRxT+}RvUfRG?&T`e3h=fRG39fDUuq7Wg9PbTw%8EU
z`)gc-ctZLEy8b;<Evi|sOuK+RBU;{Dq>MY)WY2j~rgSdZOFc!{lX0QwQWvck099~d
zcFemd*)wVMda5+i&mrOBkdw*Jq{N~T7q6=lnc@&&EdtSk5N4qfy5RPE8%6?%ac$k%
zK3)P6E2tjAg2qe_<9zD))Uj?)_@xggTjwu`y=Xdtus`IXd(eu8E@c47N4Y}jqWc}X
zaVYj$>G@sLP4cN~kSrNyB@jHCA#e9T#24zmeY%r_^zp-zhh9ck0>*G{L1Wv#>zF$(
zG2%{7Alpq>@UsG|Mz50>Wq%^-&6@drqgs6y!qozqc7P4c-Z~cdb*cN}uBsT0#?3Y~
zW*%GnREHgjE+Nzrgct#wT-BReHPjN+%>7)NnQlt?gO5PB9u+VIDSmKJ@&oBmaaGWd
z38W}h{XBb+&__NeU=kL(s9ULbrAIg#=Y-gu;4K(i2Eo668je}(a=}ZM@C3JO3Zku-
z%hSXm27ph!kp-+%Lor@uHR98_wQn3mZ%`Z690$0;vp4Y2daVOmcB=k*3?sJST9!GR
zIYei5M#eG%=okN#h^3V255wLQ_%;=1Nt+vj!x4@z@EszTvW5j4(Fwq$x`%x1!u1dV
z&)7}pxN?5hhQ_AgVVC5%UBi>N{Gh1>^ZN9uVA$7z^46=Bg4wq!_-WtPkwqKsJYD7*
z-5Y%iOErkBiAewuH%vE(a%~?=n|w8!7-_?<Sw5`v<}{hNdr}L(pbcHoh#BbmV-mI(
z?u9A4s`!jNIIQ0B&KKKb8-3ow2J(Iv)uvKh9RrxYv<PfGUm3sgIkI(wv}s??iY{_$
z_vEM)g!XWA4a0X1WKPJ)7w~4%2lw2vT*nk<lX2o>*}ajTS$-azX0Q8-@gnF8e23!W
z2n2$%?q#(bwe3Nv>QbLbTi$hVcs1Z%eARyKresd+`MwlETP<8H>T@ck3opYSeM8(y
za*nQCEKK}3!~(FEp*s){1%#TC@KRP?wWY&oyR+K5Zacl%a5dWL@Z<FT#EO56$08_O
z?tN+zzVjuh3L1RNchHC#AGz1=bU}-5s<au||79stJal_;JObCWdcat#C0#*;?A-r=
zamk4~o!M;uldUWw+rxrmshoY{6|6C9y7mo1HY$jmc?jSddXj7qU)vRfB!XHPk~tQ}
z(%Ss4F)WeSfi#QR<WvW`1e+9Mb~(f<`fFe3tT><UkG*<Bgo|kY&Q#DCyB}&{wGG;b
z^j5q5<c)*5IYnt%WfJ4^ja_TH;DB1f)Ij6LM5WWKP+6n(yAL=gt3xf*Dkf2BVx}4h
zXQU=#k_zCsnc4Dcy4=pV4v{an@tp}mUdnJ&Vk2rOrvR^ik1h9-Zk}Rljs0u0A=_-t
z1|^mvje|GhC#x^k&x|Hg2@pfucAlN4?5`QV8x1=GFi4m_R+S4-@P*Q?9!(SG?q)>o
zl~n7Y)^&TI%(S#DNq2pL5XREIeyvcenYaQq&<H@vbMs*^H(6t|q~BD_6EYjdfQjl$
z(W2w~@5m=yUX~!sDnM!q3Tb`7m#rVeh6!#J<M3Y1=Fz!k4!RN$s?2Cl>Ws!AE%yql
zVFHj#tRKdYZlG`acJY$i`INf0T=#(PG{s4j2#tO{kFeBnvMXcFqb2Xq<_v4qE3Y*k
zG9N&c1v4`-4~RE(QD=o0zBfE=<8IZn^ZO50n-6i}k(=KpfN#q|sQS(-q8R7eA>yuc
z(G2Yt?JjZA7JUjc?Vr9=!al|<o*`ymEW<{Or61i$SurFPN;v*{ZhszrkBkNXY8ft|
z63jo*)O&cDjJx+LMdw8ghJSFFx77T}%%=iaT(5@bt##sWnmZFbv6>e2S!Y0JK-@O}
ztSsiMNJmp=Wz+z-Rn`VIXVg?#I%rh+hTTV`(^X%sO8!*C*JL1FwHHoro<1>U_>xyd
zR7axl-j;F7q7~<lGP=NB9rk-ebhnb{8>IBwK3U?@AoX*-%WdFGY2a~wI`eplwzmU#
zW4B*Y8H;~}*nc;Aa?#!E(S6&6NvyH@EEi&R+wY?9aY>7J;t=KmTU>W^8Tr~LnXZ`W
z{yn#WoNv<uc*oS-qZaqwC*a&ydVjdEYWStiDXB-L*l#gripA2kcetGwl7%-P&?-JS
z@8MyW+{jvz5ppO7wVwGt%q9hZMLGv;g@jr}Q}f>ISq5}Mi6$t-KU&xglUPxbUixK(
z)}3ch&JKB8MyIrCKS!0%I&P-fVSd11R<>_$t*)eY>PHCbLtfFkCH^F+_KxrdeH*}q
zQq|dkkJ1(7F&SE+`o4>rVccx0<F!0f;<;;sSRf+p*n+>>jgnb%okXy12Py&Rr2oEO
z^<Q3<A1kz*P+p)KzX=&`YewWD$Cg<r^pcFNt9`Jf8r`%{M~n!i^=bCvoL!4<k&<2Y
z>}f`Yy(96(FrmC*Vttmk-p){s*{nGvmrr>{yUER>yXMEX3WMHiA1aXB(kAz=#ov|X
zvil*`|KN0;DJ$gXwY{b-M{x@%!rTiXyO^+R{VAum)CH0smWPhJGQTr>P8Co?ZTq`*
zY)~LTc0zX~2VQ&EU?g3{X7|b9-OX}*RG+n0!A-AUU-*hYfq&7uNh*g{ZRhb|{v`v3
zDHP8`Cd}_Fz<r6bY`Ba`rdOZxR2eiP9nDI+(m0><>g2v+bQ!$!!j==D+IFCg3Sa&~
zlIoLpDBixH-Uf<Ay%DfEY`Oh<ZB+;Mg+;%YREAu_x2zTzmf%_!mcJ)cJE9^h&id@u
zM@9^}Q~y^X?^LHjcT{%7we+pINP=3#(B+az>E6@b`kIWVlK&GW!pQ7e2V%TcpV@4>
zxs&qXFz5iEZJM*lo>v4APvk&#aFv$M&nwhw40+3Z)~RUqW5zc8RMFRF@NT8-vj>L8
zSy<KNeQb}{c%@E3xkAc}h8iTc`){-^@a0c7^RDpeK%TG|ECwtS+igmq%$9dnLVFC~
zuyAvUL*xGE0{Q@_+h?qwd=1-qdk7*OJc-$4rVMW`dSD69jw33d{61Vwr79x48hPC%
z6{^xeww8ExWn9WmeAzelKs{K`J*!v|GsoiRHOAV7aam^|ieZ(p4=|3wDl$orGj(l5
zAFV42xdit(H!8#fQjTfdfK%d@!yz5KSHYZzN)SR9=NoeyV}*77GCr9Q7+sy40DD0t
zjwKDr!J*hWL>Dz6dIxt&Ew}s3FW)WkG`B#fIXYxhjQmVL`K9E=leaKb|K2unbP@d_
zNU%r&rJ%QO*0n{>wZE0l^j*`EuLdVT1q$7jk+o>kp5&Is*zox3!Eo0QKG^xCwF>Xc
ztyy%ePNoNk>-q(4I3U4|uW`f8Rwt7tuyvY)8W^a~Z=o2l?`=xykF6@8N^aA=0l@$e
zdj(6dFHAvu{!6@v#who*hIqk6(*>9aA~w4;8I8F)VRi}J<^nA@pD<FStz=eh!5(&x
znis@^j{BpDRn5bX)786lL14j5SSBPTTxDJ%R={wHY}XL<D)bAG+gIE!0&%8Keq-Z;
z(i(78vi1P#$2+)<IIr0t)UI^7v>>`d__?16mC<pJt#SG5#&L&psVJiw6H0|0DK!-e
ziu}Ka8X26X-~V{<*j%S&A9b~;#6^Ig8%XQh{fz+SrEr`JHxFCQaJt-q1%1u=-N4C2
zu#Gk3J*I0*y=+DW1hIS?Ico}5-fuG8S)NHN9XbN4?>D{uRU~;n3BgFZzo$1D3^o}B
z`{m;0o^x}@tKD<my?a{PGphw{uCV+&XuH>^ml5wTYsbN?`J&DIkJmIWy?`?DhufB3
zhW8qeFORsluOjhslV?w36F$Xu=FFqj+UyMv@KxpwZl)a{zCL{b9b=!>O|Sh%wTv9r
zfNnrvqp0kDZ|piegGR6O-M+^Q(MR{IF(8c*KVxUU;P$|l+pzTklY8s)pi3L?%oE7M
z8<Jc%RdG-3-W4w8wP}U;Wlf%tQwMN6j<0c(wATv=UKF%FuE4(~>>eIIv1to%O%;3z
zBU`s2bhH0FHa7TV8Nl7RUkQwS{iK7KVE`B~#&t($+Yx*M^28A`{HyOFJB*5-U*BKx
zOXdw=z_5RzS$}U&#$Y0E>@Ws^9-sTxuDmK?B}}+Gav@YmTYXeIFbn$7qzvL^p*=hL
zY96i|?+WtSN2=8_BDpUHZrV2;#tI&dA69BZzwOBTIRYqEXnfj4S<L2-xtUJ(Y5-aG
z*Frc*ooKz(ZeQodj~x#mGO<2T?#IvMD7RNf%oMyU^U}*#C8^>sr*>ay*Mh?f5f#jg
z!=PIhhw-j4l-FiZA5Jk)?s!lrKAIiFv_KUdpbdeIZ0WMC1)XNEohG7q&AL1^0-L)%
zPBDWZzgZZ6TycI~Ie`kgPy7;G9|nxPx}@0$+`ZOf2na#a$uC_F&Y-)ZHFe+;!k|l=
z5p2KB=2hH?Z~^z=zIwT@@JRS)=0xt;)jo|=T?M3nTmaDx#vl^UPyva6IB_7#YxJQK
z5H$S&>%l}&yV*|E_hNgC&jZI0L<Ky*cYY&EuD#e>4>@+{T%UWAjPP=y69eR+<G2M7
z?ffBJD~1rS;=ksYOBWohVQG*Z6cNgXFy6DfHKzpa5xfDPao55{{)RuuQ4Wwxfc36a
zb!%_56U>+{x3=9YhH;Cg?%Z=Z2fbo10tf}V7~_Z?kwC(mF@Q{%83CsaL|c=Dg^GDE
z3@{fgO#5(B^<E5o{rm7cTY$!I<Ew95e%K(~urU<K%A?5V8kD{6@2eVdei*#e?#FG+
z!->{qndE$dFGxsGQ-l@t50JhXvjMDG^!DeN<)}(etUvr3eIcxH%(g)1^Nr--o6LYM
z{4sHHEraFi-4ER3H3fsXtPXlYPsHF{#u(I{VhGpEZC>~q)1iEXZvgLAUt}_GXW;Tu
zHHf`&+VyO7?$xYv5b}6@mq-6RrwA95|2aGhj%?G!vEX}!F+7+-@<WgiXw>A~y004>
z2@!Rq@im;2uYLXIF`~ii*yjiF7!?7tC52Pc)0h<<$N8^<g}9ehM?8K1G|wyh3|`fI
z!@j0cs*Msg0e9&l7r+-AJU^3NI6dd1--><KC9ui+m3-P9A|H9_k<bhc^6T(N?c3^)
z=WVXz-pw1j1BOnXe(%QmV3S>e55GhHTrF;Q$?!=p;IwhzBJKREBty>|r5Awf%H?fD
zYTDLu%uR!;(^Y|s<?R};mK~oqXh&ne+4aYx4}KB6kUtiLJK)W-+=1BnSum4hwpwNz
z#E$p5U6+;ei{PcD{VpZwpsKsmyIc7F$x&|-3Ai95cD>B!{M*|iAhXOwt)qVO+mkBm
zYd|4K!=wL)Gb|OrH+I8$<sG{`U*Q!e>7njLL+X<QFO2ig>BH{5SC`XPl$+Nj!bU78
z$HG>B@-XVH0ieJFvElUs;C_Pzq+oH`4MBSN(q7(=xcL;dzz8j_O>CXQ3Zy4JT!4oG
zlCl3Lkc<mY_g5u`Ri*jz3o21(?j$jmwm9!4)w!lGwgn+08BVUsf@sgai+78U1%K<q
z!NX%rV+&%2REcVCb+x_F9!vnkw$^XZRx7DW>{X5XHy{OQIucuiK#Q;GH*-^?*Lspe
zfx;9ixQZmn`G7}y1vu)w2L!oRHv0Py(};;G4mu)p5Q1#%jVZTL?SP-^lk&>aa+<^+
z6J$gCi!Dy)103x56d&?2p<rN;4XkR+YoEs`jTO?_-U9v4S}nHE=89l&J_|{`IGz%8
z%f2=#$$%;-YXR1cc5)9TD_XlWPQ(%g#f?riryXcl+x{tqj;Zq&lXLrkTRO$q*Syj9
z2oJ)6$6f>Ote)@B_h`U2hgW`7DaX8e27IMLmGR7?Kq%K1E#u_k=dt?2LBRXUgpg|J
zby}fS1dHPD7`ZcdS?~vo;?cQCvnXIH5B5dAdxd@24jn|&rX|=*P_bT@EMuC|GutKk
zf;5Pd=@u~>BlHdcZ^w2=elkzxFDIYE`0`9VW%I5C14kU$?_+oSFGQz8O74H)uEh8r
zv_$@VbTsyVOX2=Uq=NJRgLHBJ|De757aRKzG5aSSV<Y-+k6mK<BjSHGg8W~k?4R82
zpTfNVlHL6)qXELfl=%I~km`W|3<vw)t~(AU4z9nrj0$k5x9NPq;RM+3Hoi+zT8y9&
z0wG&IbgI&GBUvVQt1Ca~JuWXarwVTub&5IAT>5-mCftGK+JP%tw0m-5B!Ti5DxBTy
zzJlPs({QH+Jla=(j6SxXYZ!c%7N}j2YyYY^Ur&ArDRFIx5IYf<uKv?pVXzE%O5Scz
z%huDCJ_J;As;!!1id21D=8NloxP8uR2wL&uh{G~2LCXrqcC+#?l>VB@xiMSbpUkvx
ziG>+zkW?uDGfwXwHc%>h@>B4P=fG^9M=~Hhu;u)o-#zYD+EWVc=LM3d@`>8cpx<28
z5+WXGh(1xl;$i9jGD1Q_Nr1I^8%L+3(r-S&vt@u9kEC*r@@NTh*$B+Akg^AhCxg^d
z4t}D`aoRNt5Ho6*rk?cny%E6tknHIV-Yr~mPn?B^lH@j(lEf+?>|~mj<cyj`nM*Q)
zpIAU%EXgd45B;e<5MxAGb*GFgD-GNF&&s@%{jV=$bpmaCF%tYcqt)`2#Gs^3$C-S~
z(<T6zmS_zad?Yf$*RAn}4$p3sDhFshKPz1XU;ciqdHe~FjT-|*0LnRaP$e@RL}Rl&
zf_Oh2;b^`IG%vGZP14~l^7yor>8WWm5@~G;v7uGv@-@CJsz1Py@9<-Qh1x(+=6I_;
z<+MzJ?)Nd5I+rEn>6{XaS^AkqUJ2bf`7L0m)t^kZ3o54bZTD@_z#xC(offzvNgpjD
zSsn;GS=Tl~qx<Wqx@qQRe(V`!rw7!PUOgYN6oY8mt-`(fYuv-J=@`w+5v9_Fu2YjD
z+YWVImkQb@5`vT|O;`tSn2GzL76Z1YsCNTQpXz``_l#Enm}Zeq6@kS(e#*;FJ{~}F
zg1HMSBRgKYA8rfz8rDZ1h2`o4B2=N}uU}wuf3{1ZlTG%1>f>;_Ub>%+N-kmPh7k^Z
zWjG<`C6yIdpDww+8uj~7^`~Nr%<d}@EG0h(5Fa!TuZwQq^#-#t&=>)p4pJmL5>3c1
zSbmijU2vDH*K8MIZm-49{(9SNHdz2L>=MmWpinl8JTwD$lWihCuA3+@BJZZbPAcE3
z+hqGot4u!%%S?87sbQCC=cH~7(;s)76zwEhMm)adB4r<Q-eO!DAi4u-p)7pL++Ojo
z;k$2n9>S$P`l~Fps_kqS$g?bQoTs^;z=6aqFWt9o<~Bw`#fsx9H<>+W2UdWE%R@Ng
zpC5nsoLn&j1EWn4`zJ4HC3k2F-L6s`X(0#X*f3B@Cn`(~J>()f{0}-TyWW&y<C=WG
z3PVtZD{Bs+@v>W5nO7nlpyR-_J)k|8oh9dDA5F<-|E`R;Pl|TB0!(PJ(fO=o&YlTx
zzbQRAJl&fsvQ`ULB0<=hl>r!X#8}HO;@Pv5hg{AjHF;gJ=5I^X`_Q4A)6Ox+^%~ds
z4>e7A^Q-}p)cnpj0^<GQK}<q@tG^FPq%MeDNy3%xPQjR6JwcQ`0}$|L)6yb`B1F$u
z;Nu7z0#OR2m>CIX40i1vvIP(f1e5(PSenHkeh^U{Dn+;lg!09c%mCufKswgnX4&<D
zDAeTVJMO3^+l7?yW;f1Q;EV#HGQ_~*&3)Ex&rU7z-pe~RM~h;X+aqO=A;&xih)fg^
zrcRfqY@ZXAB80`Jh~y}G2NIL40>9^+fSf32k->fx%HJP-aC^?wSBz)PkBV<mUPziM
zG|v#`oEQ`B-@n#@VFDnH$Sw%X?c}*o`eOOY4#Qorq1fP1dJMZL_ihHCYaG2Tf;zG`
zQ%VBcw2d2bNWqUwSe2R1JUA3s86jZRF+GLUL9A5`41ZflAu^ucX|__Xi?4!?e*>&!
zOBIHLud~)E`kePlF~FnzI@sJX00|qbA4CSczE!hrZduQ(4}h-dCX-$&zm&s_k$~<t
zFiz^65&xVKArLxcrG~gW9&1F`)29(rqTB?G93AZjB*(qhL{87MgG(LC;_^{T3-ssv
zy=4@G9RuA0vJOkASOF05UdLOMsDSByq8w=IJFerspA(6&`~kh#I>=FY6gP(hUQaKc
zE^g0CZeI%lK>)tPzu%7({xu87)f9SGeXymo`oKn?C4#j+94qKMJbGkx@__77=u}&*
z^A)qqW`xaJbGC3q@A@lSnrGm^1${0a5tlmUkkQ1Api$&V1??h~OY%EYb6KP5lLh2R
zY?>JUOPTYkq|<ek{@GIlypGy*jS_G72-UNa<1fmIA^=_8O<R9d(Lxs%k|xCfP(!ai
zK;0fGZ$I`C^2b4v#ZO0k#K3UyZWpm}y1f$%kq_v=gRJ47N)P;oVka)fJ-B$;TbFaV
zPCa#-6SzjOA89-DH9k&VJCvgy0gO&g@84VQ+>BC*{UF%$xLvR|Bst(CL|m@gc_=H<
zn9UJnb%1~q@g)?_nrM<b(XKiCOyfD16PNRW4<+T7q|%pLlqT!-Htwy#xSWfD^+$y2
zr>SDtq;=5Rw6e|~1v*4B+Gd8daK6)uqL;VRkoTXuZs}6+cwn^HB51e(&*A$f3J^Ab
zvT^bZsPPC<R}tj*+M$RRq6x0V`V18_SNUY`d_X`A;F#xUulw2qr6+J7iopj72@bC?
zA)(jcaSfA`VLs^T2Joj=DKAVhSZ3de3lq6Uq5L=6>-GIQOZe~Lhd?HMuqfe!Q<avL
z*hkNWTj&vO<eH~ZuD|+6L$^EVxJR3U+al*j*zLd%$`E~5n#r9RIP^cNU<ny`C71_X
zfq)dlSW4oCIikGq6gmT9%Mge{IGLchz~Xo2Zr%k<68+5U9g*ouRvdn;yY^ze0-qNv
z2JkJn-09v>Ni161`|^XaC&%1W_r#n>qf~a?jw-A97Wz9Ddu^W=5t=xTe4aq2eSJa>
zE*gC9$L&|(icjR|R1&1Td&_0umZaI&bHF=X7(LE#0h;9ukioY%a-Z%czdX(IrSDM4
zyG`@4vTNirP$tfN8o}3yyQj9`-Q|1#69a8so$bpP@&3LM>nu5x=*nRiXW6cj)@~r7
zS18&qy|s)YTpE9iRR)u;p4<kTRyPBU_e#6_N>3AJhyxK4!W%YiT<>?8X`s?5A3*Qi
zIV6AAH)j;}vY>&k6?8UZBh#U~YFEJ>`{&`^wCZ;*LszJNsdqXeqv5A@>=(=nEUb{_
zcM$}`QU}3?HkhG(Tc<G_O|XdLicT1<$(<P28Ay@C85T5QO1jt!I{`gcu||Hsm{zEg
zCab6R$zo|Da*jtO($)^P?<E$fCV;6U*T|*>O5%4O1PRgEZg4fL#S`C0i2Sy#UENP4
zGr3R$b+Thh87yCk&n>Q1);k!TVH+TY(TTYW{Kvi?ecd%JE9*WP**noZYuXuBPI7@}
z>NnUGG;5-jWavzNUQ>g(TwBt3^7j>XF534};(XDkk|dq?bHaKk0|O0(eZXu1e16%)
ziBJ*J@iTOmZ<&Ep?$lh~AT^2pb5p0w1!-6t!AUx+@vY#VgoHtl#E>1%gC`Ej4LwOD
zRH~zD4$OiK)-Wk9EBFssCq{8NBd8uyBfkf5;VwK;KUc`o?W_<l2Zct$oPal`a11Lc
zu4?jl%)wi$h12<h2>nnRMu17x!_U%Ray91O`=+sQd(Lxs?G~BwN4-!G`KF{$MTXgj
zsYmS`QO3WUdI{bZ5#EUO)pubX`cIxpw>kf;`Y1qmPK=$#21SenMvS$($@Oki>iVEf
zGWfYz@odKKCU4X)3@36L8R(uD{N;44UQ9|<veK&&H?juuIqY_pAb{llmR3EW&H?Zl
z#-9+mryydCKk)^Xh4orddQ`XPTPF8k-ZSbU^6`FMdN3|&t>RhDFKw03FB`ArlygaJ
z9j<?!w)4=pSva#qFVwM9EHv9v9xGD~I;Xl$QJ!4q<>)3ait9g>{enz{IXxD1k;0t{
zib_DuEdNt4w_f5?R}3(T9Qx2GV8Rr&_<@48S*sZUAoAHZ06^9|K@1vvhyC>*$2TDi
z?X{u3VAsj441Dpld#<x-Io1aOgOD$K_G@SwuA+Iao9k3UEulN*n}E9uzt!HvEf*(o
zY;Yg0<BDRZ)X$A>$Tb$hrAmqzM@fPZVA0OuPFNCK)U<ihtpgqq?N&{m3d#0vI2c=D
z5BDbe`&eBiS?y5NIo@3oTTe>s8_LEYjMT`otYHoN?d#;cgj)O8_G(&>t$w3fr-3Uv
zj`NjB8x!lECyB$ZJL11?`ko&E^L;oFf4FMfN6YeKjh2pOudcKgHt3I~X7Wr&39<hw
zI3Wivo|24;f&#3nbb;3e8m{CCfk48k;M&Q&&h<Q9uv{stu7jq6_LES}IORKzqaCeR
zT2rk@=%HYO%bBwzq$&@eyMRjfBoMha*wOwmM-S-Z=pLN4H&ROK2ofN?bF$8%hz_J}
zIK(ubObH+u=V))3YGU|PH~|)*e|%}paN+(dREFBXjunuo1s7<URX)%Z;}dHS;7h`l
zU*E$&t-+2^1%=79I^OuehYQ9_3@1u370F0m);%~dAH6hJo-f;zu5tE-Kr7FDZ-5Z+
z+IaD8oNUQa8B`20h~cJYet7rt1(lY9^=GlICIqGpcxAt&U)VeFkb9joeQ%(c|D}h!
z5)`A{u?@HuI-LkQwUyxs5EszMPU!Vcaob4l0$Pt%m8@~Cq>RPnA-f*2VE1R>WM|Fq
zovkIIy}o1FXE~0@XQdd8{ID<f%H1-%;xAJs<CI@YlV;#7b#1w3#tQynXSs%kRNCRp
z?f61#9#jEY4gkJOECLVb6zC|6@a@{?`>suw7XdI5Y-N)sMxd$>$P*FUMyZpJ$%t^*
zk_QoqSgzTV?HTFmaDc5-O6a*s;I|bjJ-1wyAJW#whpw?FTknQLJm(2c0mt{m8)eqx
z-)#guY@(t{Vzu=1IE-ufz_PC6QBdMht$!AfWBKSe49hJ;IiaV{`>da0j-v8w835h2
zKLUWO+)ono#Ql?~wE=X!V6nOdMkEi^EO8FXCN?GNipNWAoODi_<u7A)Fe%Di{tH3n
zOFltSZb%D0BhN!m+ZKP1me2*`to%KSR2Lw3R2mGeY|c@K;tb@-F2L3X=VCFMHv<ZO
z%BEUVfokc$%F^E9X(Kmm6>H5BYXY+W<N)ACgrX<r3^px1Htk@T`|+ofxoXg8`G^hn
zSh#dq$K|Ppol{T*nqey@b4=7RaWVK};mS?a4N@YP>Ez_dNgr*M1CrJsG&oy$7-S_R
zqA9B_+2?Z}aT^-j8T;=Jz$U()s5j!X93UzMzNN>y6v9ts(t1x@18OrOd6(G*iU}Ah
zm;J-YpMd$U*EOocn#E1X71&qIOHR6k-}8loOjFUH?PvmRKeKx>2n#qz70(~NHBq<o
zX~;s&*k;S0hrb#PQ9dWXs=C@(Cp3I-THiOBsi-q6!3zp_faq!U^@*83rwww%8J+xj
zsX2;Ng0(kOTekkUz}BV1>v@S!D+4g~dpbCke%XdrLa~vdVkz3$V@oID&&Z?iuiXHQ
zLL~6as6DAb@+I!xDfGp<!BCnlqy!+ggkWH8H=&a}e=$m!(AHasUnVVy@w%YaN?@(0
zXBD~p4A??3Bcr0#6*TeeFJM%5ei}}Nj<9eO+(it^hL=yJ@1}gK$-~-ipCkZd!px^I
z5-`Y%p1d!r=*98KeJp+N-5XDbF;u*8uy`exV(D82PR-vziu=s2zm(!R-UG<**b7D)
z@mJuQu$aJqm(e&v#ae5<)~1&pn{H+eq#@ZNVTZM>uyfM?#Eh*S=x}?09IQNRI#=l8
zgZNoFzpzKNLt#zG0+J{M$GQiAp9}+Mf?SN5L;`0;!t!TJv>j{Kvqvh63L!({_sHak
z!H)4u^dNWLc_j&^A84k77sleq3$dP&2%rXnJ_ON$rfTr)9WscpEVX@FrTAfvBCg0>
z3bY{$-gk&A^kL74{{q{8T~{@{sA2B8n15vMq*w74q;=%G<VeXWjJp6(E~P$wEG{No
zoN!JwJB-Tgo2nwt^wrU)S@=rQf8dUD&*a%|*4?fMzbzbPy%qm<gYX((g;+}B3~}so
zEMnkih~hC_zY0ktCS@7*<SN6~c{D<HxPMBmU_dwSEDHo1&|mSTeMPlWee)JHgc^a2
z<#`Z<;b-@G3eySp4G#inVnHHbyoBtu;;lkntVs#3La|=lzEcaAuGj~hBNP<q<L~Bd
z>ee0Sv(R9n6a)_t8?Hg3rT_WiZNQ2JX(X8k=8E9P!vW<HAOdYtn;sB|9TAZS<E<h`
zp@mh6`GHWzB#06muzXYvIrcaMZ}7Kxc}&j_XuR1~ttBjASY#V8Ws#)2=wEKb)Qdre
zbfx$Qyh7>gRy*+aR1Jz2sq3a~G86HL`nLv4=SrZxK#{*ZTDo$`B;kGFqhTJGNdL>z
z)<7LO*OOeokzfID=H&85*gQBNKF3^U-_w3rsP7D)riKMZX?+ku|6F^=1{PEUX~Bpj
zY@u0mUsp7qIo$>ztt68{5Xku5Ybr1eiZcS<L&(Uqxw#nn79@|}mS7w{jMU>7d^4Js
zw}I{CWWVoX8Z!_=kDhy=)LJLVGf<O@U?V=0XFTUB%Hy|+zF%5^x0K+f<-#X@nKzpd
z-DZ4_aW4kOj5iG1i0`1e%<g2*lNXPJ5h()-tXx@$OJGK7A2cu)denEwwEJrAQ1*Tw
zyX^?0Bv^Yx_;%_wG%yBWpW>qmYX&NT(r@LoI*sx-+CCKi)ycBG<P>we5N*llFN!bt
z{7`!?dr;pKIZo7TldpX1>#cN`A<fUoB&zY9Ux879v^~#w9O9#1!+raXkIAQYe`68>
zP=!Yxt)GK8<HsG)Ndq41rDiG?Kdt9-@ja{;Lh-;*M7-urHSO;JnSuNsrDmaRM;zbr
z#1*~5+pankLBWLZRQD0cc+rGWW+`r9RuZfb6s$4R@ZMNt!L+8rM-O~q{Zd;*>J*LO
z`k#~UHlkfrs>)XQG`%MWnGM(HPIxuz=BXeIobv5Uyyz6Jg<hj(DkeUOnJ)97RkWet
z@N315p0x}O`jAV2+ZWQfW><LCq4VKu1i+K{Om@pU1@&FRZb_-$68r)VAdQ+y;?MMO
z4?#|hOD`<)=ZMC^k>eXi^?NzuyxiZF>Qfgd3V-vli$4H6mm)ql=sG{v)5rd4kgCM~
zLsh=LKoM1=_AS2Jjba;la`)R0%dglG(F;<fmfwbH<r%R2=Q%EDATk-tL;C)M_k5WO
zdda%Ro(@X?)i|jZ@zv0VS#BN?^b$+M{imn9<f|l7-U_mWn-&o2kdqNu#Rm~qE5i=N
zjD#D(ot}3(Z>R4Px`493-k94F(B9a>;nBu!4d)MJbV7rk%7K1!U3k&odV&H@J$oFs
z^S9ig<0b$m3q*=$^SOp2|9~n|RX8Ric~UqV;j(EIvLCm^4H&0{o{kP}u^u%O95kE}
zhUC_7W?dYkxK0)M4pi>k)}G7poNN}D5LREuf^EO1itU~#kRh*l$tPH*{GM>bU#A2H
zHXI5^Pt!z!CSsN-EY>bdIe5nw5uabDu<b7E>wW-&6+_@QEW>V(-g5B0>DED@XNO6b
zRm8$Wk{Cl-+;ip*Hcc5XeIRGLj_Vzyuo-{G#1x_YwK-M>a(A*Du*xdnp6mnFR2-eu
z<JyKE&Rclj+uWkl@`xxLHua{M!<$4h(r@0hn;;m(u)1jKp@ZjIhCi-f|G_y14!b_>
zZPNglXEm)k=gSz#>AT<bW@hE=<LM+SX5>kR3cLFujm4KCz@KW4c(>#|Blr2^pCfe-
z_h1~GZ=0D(ocS|Qyd3a??J$sFcgQm-77h@!*Ejos|AKqb%+PPeK6~ycx*$Tc-^?+N
z_d9vM_Bd4Zr227dygB0#VbUK@=djlGjz9*mwYZ<iPko`7#&h*Ns^}X#%bq0b7WXUo
z+Yk_n7}2Q&TllCa&L%>COR?|=f03dc^b_97SWP~jJBjPnYY#2}WI#xgC!h?0ew&T@
z<%g-~%2F6mxzMLQYh8+iOfjTaLFV!+s!dVtQwAzL`Zrj~=g`Fs1=1}@kvhoR5Jdt3
zM!|AKeo4|=B4`2VmV`lwfz&q6=dW`O03@3SIc2Jn4lrt}BNs3+8VAe2_`yGc1_#r>
zfd=&d?(s>?dqDfEih>3FpVZDj3cdfU&-=e21UoAc^S>YXmo{+zqr!)Ui-_evpyHo(
zKL4f-|9vmZ-@ML$nt1*Pk@$~S3hD1d{{cMyz9#`9FgezL?)kq}RjE3Nz{0@niSf>;
zpd2hr|Hc+oysHTt90}KN5q|4uD-03O$oFK_Hq{-w4pEEeo^g*oB(rK+M@keUKU2H>
z?m?<W${K6$mBCPmpvdl~=$@}Uj<-G^hLVrphdJ#5Q3>r6qsD?=-ac)SeeDC0SzImN
zbk_pc<-*(7K?B>#(i+1U>%CVS?jdt;0YCK7L=^z9o!3`iuGiwcW?QY#qyY<?TFHF1
zRx+;YH}eR5)mBrDYuf<N4{VOcXFf_<lrJAp=eztf?G16H>o!WiuYCbm_p=*$>qWdX
zSkQ`;Tu(jc!qM;5#|^#*{HsIp3jGuu9=|WxT~9r&Zi6Gxtijkmy{(ju(zTL5_AUHb
zrV9YW;aCt$%;X_@UcM)fa<=9Mnj5-#T5$vXq$XbtclfG{t0}!jgp73$FCP%GM`=Xs
z6Nj^g4l$@~$Kx4F!%w=1rR`UKaI%)(D@0DGQ>K9PYrm98u@0X={v61h-)km|V|ab+
zJ$`3xCRKmmHo`4~m{6YIh5+M%z~ijMSq)H5kZOu{ZHxO_WSx7>-=ac>(K5|6awKOo
z+(aFmDQASs88U6qR;{LYY_0+IR(rOn@{DO03G9)JF<<~V5?v-$-*nlEy{1_D+##zc
z%nEuJPE$MwXn+C;jXH4}WrNr&wwltf_*CT{8?9oQnEfMPUq+$}tf$oEen;t%nE?cE
z;L-x*G-4VPuwSJP54*hA`UA(F%0LZ&O`YyGJ;pVQiVp;dT?~eX8L=_SF9ueFdtIq%
zp^N&Jnjs%ydfcnxE3o`HoNltuRg0xdZU*nP_JGF?G$FbxUx3@k^;d|!e3&i&6AFun
z%Gq-dUPgVLc}rLQw})`Nj7ENfy#(O1S1;VS!ACVe7DD)rFty@v3_S?T@uzH;WBL<Q
zrT`q_{e5N=xY-|S%hjQaAagb}(o++WKZ4BTT$A|91Vz7Xf0hE1qHWYdyHUG0JCxbU
z>TBb81p%`I0#sc;ND8%j5cnRa$FD4+Yu=w3;#-j*{Moitq78(lWBZ5DgDU`m&#RXs
zY)`=675;dR4+5ru<U;i@Z5hrRXI%sh*e(9xcCmxK8cqhgzNkhYzSOr*$h@h=2J3fw
zznP-A1`Poz3!aB5pF6$iw}W2yG6==SxA?MpR7*Z&j*Do{PMIXQ=RjwA_d07TiV9@F
z_(Rlwi5-??sfh*8pZ?DuIp6?O&AUz@HM~P{BG2(u$fFge%|i>KwX9M+FNilWxPqVF
zE08(Ykb5aJ4va$6_%$G5fjHMNz>SL49gC&K=ZsC)m^H7p+zKpYNX#R)68qR_B+t0<
z0=?)Vq)}jao#K2!cX=G45PiHhxcYmX{+r?8+h17iu=fz0*xX7O5nq7zXFkM6z$l*t
zW923BwqrliR^jV4(7sWVPFXq743pLmCXb7_79{B<7@<E^=s*b#y;@|(VMd2Kv}_sH
zA~Mv>Lt~xIth^LVzEC-mqmoQg9q&}4vid+CXG1x{+!0<$v^N6lrnm0thNaW>lIp>s
zQ@AT(E(ooEU;?H&J&XWQmyD5NIzey;Z@|Ypo1|z|W+&}yR*>+Xw{Y9hLP97N`_5k2
z-iGQ=VpS{or!!!mU&`>55D2ODbMrVXtjCZrH##DsY)~Xr6s>@Z-JW-%F~eb#aUXcn
z5k)94Uwt09wFLC&#KlU*=-s6LkbJ%NX6Nd)pbh95w7_#}`Eq~<MSK9i7^Q%g;r?YK
zk!rCK>HN*iiiN6S#pQ(0`wz8ke+lwTPB76<4I-|`N`E9b#k*{OE}xTO5U~mq58U18
zu}7%#Rj>RT4x}}QGhx&?Nr=SRv>gZ?sCf&sP$`o3m($&l1!lK|6Tj<0=9AoK`^Jg-
zNJB;^M=KUN@lZhi{BKE!ml=~m3wf~S)3b~E;-lIit4Ni^=V^_K)fY&+0{cNVk%Y6I
z&fXPuD6{nlJmN_L6se1Dni=tk0dP3_Lx04K7Tnp&J`SkibqVxLN*%C7e$uP{`LHXL
zCheYTn>b)6NEyn06V)$O{H?R=xaw=?Dy!OQ)FuPbn^u58*r!!|b516gVJ%L8x7irw
zo`NnfTzIX*%1gW}2Zp3lY!Qh9I2dRy213fJDcgjhnym+xL0Qj<+Y7w<C{We~Xs~)+
zOELxr;VNigB#Z&%=xNFBUP7&VTHJ9-Jk~cgPEV_>B7E!dip>n2eX<^Mp(m=p5J?F<
zII3V8W-GvVs__VeQDGh&M3YOkk~(jA4ot_o+zBg8v-VZ3;T=mC)6j?Ip(f}KDz{!P
zv@^E*wjS>t1`W<ru(rDk4h&DxB{oR*YNDVNuhLI~Q9WdZk9iH}VtY71lWzrx7H$G#
zlE02`M{7(avEbmT7V@dZ;oZxYDV?VxiGBjv2LYh<(q;J*3}|}F3-ZT}F&=?8TOvmA
zF096^aR#tW6w+~l=<JgEdz3GxpbiTDgE=b_&(8m1>#f4-YT7Mr7B0bE0t<Kd;O_43
z?(Qty-QC>+!66~IySr;}hhRVNyL)$k-TywgPwJ{U*Qz>t=BQEQA($~Lq~;lSC-S<)
z^(nWEj0lDYu1HhpjJPA{EYTTbCz7HXqcO(@MSVNsGgMrVv1HR>g=yO}LAK6NWr$(o
z6y7tTq@6ZDHk(km0VUJrOAOF&ZieQ&qlzf2==P8Hn}%J`#Y*3A9bx+Gn7((o{zcbt
zgpYNAlVfz8C1V%9eY^`aXviatb7%4W^_yC_@3eM0BoKuSP#lp7g+Cbjg#_I_nuOG>
zy)nkfkSMO$i@y*~h~Q(J!f?(!1I0d=t;78{jx00<yp+x{4Tv2dnw#1PJEX?~-~L*@
zU}nF-b!f0op{KP>s@hR3VQ_A!l?D>!{3_=0>xgWI2%wdX13#*+$mD|7iJ9%B^EQt;
zh)<j<i^!D)((mt`eLPFiK7-U!s8M>olgV42J|tpK`xlQ(Hi3K19Ktp&#8*=x@;xAS
zCt;uX`oXbv8)zO?T3qwDpv;xo#*i>_ayZi>c_$LgHK#O-lZ=y;;1{>`kVco_S|Z=j
z5EyTw-MoTvv<aAvzhTTZ&SX(^%vH>L1rYpR$Rih#zXg!Nq)^?=$oybK!TdCkDVdj8
zQYJ<87k(IT(l(a3p{K{4^rMf!AnFB-^~q82D(L#z=7Mf-G30vRg<z-9dvCw&c)70_
zMz3a2Vc_9i*VTACu0D#iQp%DJhd5|fmliE33v;>0<_6k{Q_w@Mehmpah}N-TcRZ*t
zRM#43b8z+~^o+BlC&=7SKJD7wMME~*M=8<B@7cq{H~S5X+k;TuhhES)q@e`UF3bWK
z=I31)$py+LGYq=Uef{~sg+in3>ipcp@jIY$hU>NK8aRyG?E4lWj%`FM?Ln#LLPH@v
zfWWR41Y0b4Je~L`?zfk%0`pZF>ElW#8KS~#oiO4@gqRYk+&k|H)Jh=J1LWkX$x`sZ
zietJRrV^HIv=-@+=z-C(lrEgkA2<*BL3govf-I0HSX>>+#Mw?*uj_IJ;3XM5h8YUY
z_%870uaR#gS$&Sl_#&_a3Vn{+kq~Pn`+X5#<U?9=znosjps8<O?1T*#6*=;NV=<>t
zw_D_S7{-08!`>V)+V-^S&(_f`W2Q2ulnF}t64ej4cg5gntWZ{t)kx~dqG|U#BQ(*h
z4fhL(KlD(!L217vn<P?C6m^Yi=TFxOVw*1G##c<{edov_pYG9Rq7EWdnf8!zUqO!y
zyRU>CDP=Vnj-~3{oLs7D0R0tY$ko@gX9FD1v)kK|3VBH1*YiO9?Re6zNIEImW#eCZ
zFz(N0TlYZC)CetYwCt`K-%3w)u%0%Ea#<7*jX7)(vi2Ldvp>cGuj6k$#|aW*6yw1#
z26@4+mhL=Xo>J{FEhnteMW%AS67y+Adj1H~?+HcV7X2)Zk7=rWhU26}5%r5W<9D2<
z`$EnJ|FFE=5~H>QmQ6vCjjT&6^pW$iOZXSOq;FMOdDb>ievTGZg@hN-Q+23%*5~mA
zinJH)(ltVo1G~Z6kj$~M{i;^|m)Z<E;IV3$d<Z);qz>P&d;z@!H=Kj~2(^QHTj4X#
zOc0_Oo?nYP`w@$SN%u=MtY<E%4erVb2L$#7iXBA^UQ#)a@*o(W)^+G!LVmdQHuNk)
zVH9iPwojuC;TbrHmHjeW1<D&;E&3T8^z`h0R;&nK$mnWhn>L-Fj6A2P@>KzXQ)-}B
z<;;crGGm+qi7&9vzwa2Re-%S`Q$()D93bhQhdQN-(@=<P@>@A(Bf9KW9J!+`0dwYY
zJ9dnQW58^d2kN=R3Md^?B;vQ^NW1?T)13PNIa`*Rkibr#o3;Lnu0L{;Ekgwvw5G?@
z*Q-_-PCp!%NG7`>F)S;z#2l+)Ty*$wCzK;SJOFpP&Wx-a^t8~#l*(7b((qUGPlDg&
z+DhIs97(*!t6bt+z;Q2oakojL#EFm()2v%if7?RE!d321I@&by<ziXW?Wi!pr}ru5
z@{lG-5-Y?`IlE<i)_DSsE0U3U5Kt0c6QzyL&?^C>m8`dXVLpYU^=2WNyDgu*Iv71b
zAiostWP~Z_o9eHo?`QUqi(Wnix1`1XFMP^#y8h_6$mH8{q#?l!%YW}hHs^VtR^op%
z)f1TIIgyde!JAtAcpFo~z-H0kC^_aL*Irv1`#~0Vx}&UNU?nkaGW5{<6*RNToYBdC
z;sG7Z0zqFrK`?+wvb;*OCZ?9Wut!hwYW(-9B-H5`c?)^b2q|%g$pQ&y&X|ea^{E!$
zX=$JqM!&7=z8fJ8)hQm69gLeiAV6f{@GW$$9=?pl6F%A$c`W0hHE41WRZPQiXU<KA
zi&pst_b8V>j9tJ0gPfWI7DV~}Mh#@EQ2(AoK~QAdK|dI{LMUN8A)Xouo~&tjrjTeb
zIim72Gsnty;wOWH!L`fTmb8QvZ~<Gp$G!fSMxLNVs1WxnxUkQy6_H5zvmA7*bPlUF
zp)SAb=dJBxPf~0Z7+Ho*<y}MVAt<6}zEPh@TmSBy;uc9UB+ak}Mi4h48xJqKyZ<&4
z6oiOkk}|McP?<>5ws2@c>FFmL{gZa$*l~~aBGA42k`RNETo8L-VgK4f#k<$c*d1F7
zsotN_Zc{M}?;8v^ZI{@yTKJBDVP${p4W@}0nli6LU<#9KQoFq2Htxu(PSg*nbS}5_
z^fa@8d_Bjqbt!8nFAzlJy~UVbzy~Yis73h=OiASFLh$(YPuIqg<3kD}PiDh46B$(C
zSc8eD(Pmw#fA964XCtsw0D&7nn@M{`9fn3Omu<~*YVsztAMU5smU4A_n*$5}DB7}+
z4uA4s9FN{cquV`Q?lgy&khfXfo$Bg-_(~B_<qLKnM3Q^yJxImFO@0Z&eSOjTGv^jz
zh+vo$&M*r-%NIb$K+AxbJ`4ym81MbdfG@;l#iFEh&nbVwue0P*Zu71%CY*^b5Bukx
z0=;(uQXq@rIG<zGBZ+Gz;m{h2Y{Ios*xLr666`Lv8GTy>4~sUPlcEr+UhIsvIo%J;
zk5x@tj!ZTc0nwgBslIl<*vo2JO~_EHBIlYxO+hg{yyyE!{+OUhL+F>}%YN+Bx!md)
zziS@TP3YT{sfV6%qc6b*yH>DS`Mg6$=gJF8J_S_{M*wz&<A}3}YWx+=4AJg;6<apy
z*PSuRujFQ7@g^kQu%BkxG}0)(8aIQ8$m?N{IL)ORK*o|TpyMZQ%zMqc<-P*#r&u0n
zsXYJFC?{I~n^+$C+~cg$zHHi89eZvhX7JPSmS*s)q_TG4yz4#YOp^)+N0>Pd;}g!z
z^Gpb&QKc)b%x!jycn}2{CT;*{1U)&$7YV{&re?hf>7p&NV`1>vGT1Ds5f|!DTL`ki
z$cZ#T5Il>oiN_Mf(}-ToiTY3jKKo<OF0%*>oKiEr9qyxlN-1=n5P)(_UJ*5ir<V3%
z7cGXVl{{-hPAu9=aiZ~VeL4ks)t3Y>CV5pZi7JyJJm;Z5#g38!&B(Zsi|r#9a)?~w
z_apciyF3lM0G%~Il;|1#x%gA8${o1vcS`3`kg?Asm-B9><B?0<KAI*)GR^ZVo`+_s
zD~n5;p0tINAw|;?f+!HDeC)}%Gx7k*_8PURJBMs|(I^R7mkGo84Xlma@ZIm1+ShES
z$adddq7=_YL-05}vhRtA(~BWUEFVrVFe{PJt%;=G1TgSzVd%l$r8KlEtth?zEn)_}
zAP4_Lc{Sy2Li05y2XlB%!{e!j-fzkw2Ne6ES2;$yNr~;zTx@YzUOv%}%z+IN-z2?7
zlT<PezY)%G=xN}ID^m!fM;Von*mm`^H$xj@$bTuH$X!Vw09Tk`@f)pWYX?qy^vt^k
zBZA{v6nr6D{~AP*;>fvx^CZpy&U^HEE$KuE<%B0-WctT3Vz@(k0%<AmkThXtLMW9W
z@~(J!I4~qKQhV@cxf8>j)G|l9DER`#_BH|iP(xL-g)J_(^C1kk+4qvy1p><45m?hB
zCa7Si{h_L*;Gf*JgX{@ybXF)t(afU_innYwY@zS|K(`E2k*kFXeY%#B0+g%Je9*5y
zn&s=oe57t%)lg*0a{Ctdwwyi<YuQFOQNJ<=wpuuom%dEW{cX)6@lV=h5fj7;dVi5u
zA-n6jz0+@9DvqVlv}1s3&YG-?_S2|C_qsmUtHpxk#<A%6S#-MDmTKujTdk(PBpe-(
zOQ?0NkS25ma@*oa1b3)=F~jDU<N`%g{eUyKH35V*J}T(RQFE(Q9s|x@>|u>4rIyWj
z^inC*>L)#4GLw7h>62D6&5{N2Mrii<FdsFG=|^g2^~*^;`1wOg$>%7&F8U)y9Q>Zt
z3++c=qCNnp4Ews<w;z;l?4|y(xH9N+qv>Dq#(iD9g}Mp2+LgNCts_2$a6pR0Wc+*y
ze3rS^(7PWqD4NYcX6nR=0m?E*5~dl{oPM{g#1#xd$z_Ex9T6wG5o~GL&PMNeW6~C-
z{@eU|x-3>O7vk)U#~frR_`bRQ<l0;$6qm@~v$>1$QPgM_{ivsY0-1O=)SY=3A)^hy
z;Z+@}uZKUZPNl7zELGo$B|+Z<Xug)O^DxvzCEqWu!q)|kXVB%b^1c#7E6>xIq-GAt
zq-M%}@Zgy-BwD0pR3&GfS1-TP_f*MEd>~3UGnfl6TM*GQErQIks`b&%P(P-^-pi&D
z4?o~#-<7S}>HMB|t|#&xu8cQ$E*Zc!dv36iIrhO@u_v;p4Awi*pg~6YNC_Vs2y%9Y
z(ubm``p$ljClg!cA4A2JxlEWD1M4VlYin3TWK1*nT*}yGj&J;usfH}^(aHNpvb~}2
z9k?04n~jY#WX!;mQNB<iE@ypY30)p-feJC`$}D6f0k!QlaKhcXod;ss&iS3cY#CkF
z**IoRpW{^{t^PD{*n?6^@;Timd^TeJ3Lj|IUCWbxYRyklLC%70QE$L&(f;v8mlcZf
z`i!ALoJ-31xMcx(fLAg?pfl9p7J2H*yBJv}KEk``%+h0O7phXlyJU(w2})`I(!}1~
zDG@_i2@^qy3nPZIF>5VcP3KRKy4L-(WXG<9e=Z7_jzWMxuS^K-mM1XM<W+V#6ekeA
z@3$ng8Rp>UF-G`-FshRT{;w<!VEZ@HisN5d`Tx?zS^sCFKL_hSMt`;c5XYH-pE*;X
zs`~$}SO2Fz{h#jp|IDxYPd)sfG_3Rj3V<;7KQH@#n$EMa{hM1w1<J)+OImBW-!Ldl
zmu;WJ`~v<{KHqjpDz`GbX|p5O=}k~+852KBRdN*n=+wu)fC|p09CsoD2Iet1__Mnd
zU(Ma0PK&?0_<g_i2dde$N=wx{=rr!%SEi;^)5x8KQV|lWe6fXiL5=Ympo{#sul{4B
zZbiEx;xAW9-&+En{XwOv><51mSI;yC(`Xj4w%zZMykEL(G{?OgveG@K@<7?<)yk=v
zBkCTHO{=_0rJ=L#_r!l&ytt4!olx7e-O^H&s_gkU{g88S#LCGan1XRD#sqYA<R)UJ
ziWNAW{_uPY0TGM(<z#i4+|8dg2vrro>of73T$^n9`=4}pKZ4-PL-cOxPPx>j@@{qU
zYqm7{6!s=ow}D?lA8sng!*=>H#cK|$Q!!_MjSQM6zT1x-RARplIHPJj>V(ft4n4oF
z$uhQlDK~V+JW5--ey5NtHqVGt^J$cCB=J6dc)P;g;qB<8Mm+mVu{cv_<Ims0EZDbf
zt#&wwejOe+Gy*~+G?|l);R18IG$P%jPfyepB^2n!^{YEEOdfVamOH|!tBwowyGLh8
zn6`2yC?!;Y`knuJSW#<>v@^2M$zCg%uRzbEH)JNAGWgvl+Ye&jU3dL%$evd2Pi{2`
z4d-DfARl(8s_v_;NS5mPJWRQtqhKN+UZe+njH^S$p9NIPZ-<{?(kOt!4JObwgXsG}
zx`f3fktVjq&e$$18gLm2J6*eKUwDM0-RD_hoiSYIr0S*v9U?`4rOwU*PbK7I%~9*H
z(ej0$3Wl=wX?OmD$;qLENb?%b3+u@XU%R)E=qV|)Wc$9)gP${iM*|UdBvfQRtPGsQ
zP42M(=MhwQVqMv_U)o)B3)y~uN1SyChYo&SkE8kcc1&Tw%2n48hT4A`Vc8Lxz7K8c
zQI$N?dLf{lT?cmqc9}E6Xh6c&3ym$f#2AOY#K=h_;|zM?SU7G|YWP_cN~65BFJg#N
zd{c9U*l`MgSEFe7{$XMmpjqu}e>HaxR+)A5fdfh)&SY8n3DdTsCvg41*~?-l_JiPf
zq$I;VPq6=nyMb2*J-Mo;{>b$g(O<rVt^QtC3jQNp(Gw=WXyKK)O@%wY^gtPK+PrR7
zV8DxijwgId6dR8dJlJ>tS4xNl#Y?;dDVvorXkxuV>@z2V2wJ&|Ow^M=v0XuxCnp!2
zx=fI}4<~zb)8*64_BYN1vVg_#J;!4yL*WS^Brc_)wm2Y_a?=hgzdGTd>JOF!S;TgN
zJD6T_Ijc=1EYr-j<CR3DOl##pY5tQgl9u-4(1~LXjy}UJ#mo%-W8Rwo$6*{m6-889
ztGB)2)|d@qr=7CMY(!X@l+g48lPEot<`A^;DpCHen^_&x>*fH#%6PWhpiA-FNAG9z
zqjp^hf{q1TN$A@bMzbn3zRTcJprV<hY-@-X{E4UrJW8kaviF0Wk)w+f0#TxrrsZG(
zbr|8Yo+)3-V?lg%9qywp89q#x8~XwebRgp5+uJIwf#@^33bEDS79!pF_1<r@jnN=#
zX)aJ#PUsQ|*!Z`AKOoG5wV0R_@Anoz31wI#MN0cl^6D?ra@ZIrY`*%V6WJARpIK=^
zFPl<daqS=@Tc|UfVBKcr25LGhjn_I0uqaQYT7W2bJsaMn&PG5qSHamIcQR(h%ag=X
z)jPNCwa-j<R8EBLWHzJInnsf&43Hp5X;CeOy6vbT?bG9lcR}Z$67o-M3VM$(B6Fiv
z!}aEcE=H|`-HDky%%J|h8o{Jyq!2B%wPQ>~WmFM8Ru{Nvt_`lliDkPv1)i`?>?d|#
z$Ouml%NBdjH4kG$aP)@j`m~wJia4}^bG>lqs(|FxcI)V~(YPRb=@p9Ft27WkJNgpv
zyfT@MEK(W=CD~Fn=npL3mzSt#&Ftfbp6C+#d>kN>Frm3wh35Da{qWDAC>s-en#VT|
zu7d_Q%Q>=d@huacyTqbw8);vY%w-NKb}!<;Zrpr&;A`Vvyb;C8MCP0D1I%|iUz6fS
z4w=8A`>zO2$USAW!O>07e<cG6-%#pVkgz0|E<=5`O*oPIVU4c*SYMw!0R<yK*Z-vf
z450`7EK6pn>?Do%5*Y$zugB}-qM>JkM3r~OQ>v<43_zbs&bvk1aRH|({hj7v|Ej6(
zF~z37$6VvdfTtsV+3xU^a00yljAma#L8ZTY^#nzQgwcOhf7DjBc98}2j!Q3?az9ik
z9-6)EDI{r5Wi!bcXBQ$3OY*pj&GtTA8`%oR+IHUHPRvpDg5?u@&MJ@jBnrcD^;Ika
znth2MLb5}r&MPJDY?DARbOgte&Iw`B<)t9}pj-?vIY)B0TmTU|J=l{6g#Za~sQ5!M
zgGfpXxN-`={$a4j^fCv!54|Zjw=FBjRL+zz5xY&v+@dQU2o`zWMnYm&r%lTHGeAF4
zbQy{`o#~^2jQH1Ud3zw<0SD-SqtkT~lw{foTWk9f!(fvnPBa@2Yg+MLbc^hmzD1Xy
zogjzD2=tXFSl1S5D2>4VkAgKO7|`C4z6b=5juHk1Cz9f$yWIl<1FI%nc1(y9TsAjU
z#K>ZUU_oNwI)z;l&sa+fd$V~}#^s$9xxbxZwx4^z55u#1E9(Rn?CN`T4#qbY;H8S#
zz$T$FsJL-8$(@_UtuvU=!wndvsMqr&RX{HGO=KcC3ck++Q}w3rv03d*y)C<9(l8*D
zu#_~)gC+UD+INDS9$iTywr(yuTfVoD+%p`R(i{JDChIYg1JBZ8)~|q@?iC!^jgv>n
zQl}r?or>AuT4EM;X02)3na|`jR)>MIVSj~p7*McmhI&c7Mkr$vBQ5B6W#DoR*zykm
z2;U~JN|4rhA7`B$PxK^P-l*fOg)aR$m*FrtwBx7c*wO)M#G*wGbP-ct_qG&I(-RUu
zVNm<eTCV5f;MSj=15jWmja?erS&$$Yyi3Nm>C}9O1;Q-ZhAa}(3h3hyBhkRZi;-~!
z123R8Z2^Tlv<S@1sJki*$FS+ltKa<$wk8rC@sFg3aIzSuMP5HhZx1VnegAfX-}>{N
z&IQ#4-`;|X5Q?R94J3~3w8XWTg!8*I$IVB^%1DPGvm2w+ERniN54AZ`N+o4Dx~dCt
zM-ryBfBGzQDL67<4F3B2y-mb-&EKZ}tCUqNi*{WPdJDC!H||`klhiEc@ASFlwzk6?
z^imeJ!<KCvj2x7!@KNJT-bLaywQ9P+H-^=Xjb#i_9ru8p5eEjD?eDbG(YdjHDAvXi
zGCDrzzzuJ(SGjXY#(SWybr~QD9nY2qDb^UDgc%GiN2Je$w`I<g-*`DgsCWzmBh*mr
zYze&0$@mu5krZD|3=a)=J|BvZP0yQx{nS^pE}KxPDIAd|MvIK<^)w0{C6WvX=CyNd
znA!%~R-_gJu+>6PW(9s2&NY(8ij?ux4CLfi?9Mz3U*-6q^@;jbRPKkkR6DoDTf7Lp
zF?=Jy0bf6Rba>{Wg{6y#XeKuh=<Y|0+KAVs2o-%pc>hrc)onegqT3vDdJ|IW=@q{G
z*(r!=xwts_OE4322XXLidsGLXa!lAQ2A>t^X=OyXgbUXoYS_Y@khjsc902c?!EA9B
ztG14idmRkCfa-}F4pB?bRZB;HG+-E3!$6XmkP@S2_^74COdWhze?p-Fw+N4l$TFEl
zvman2WPQ+I2G}OeKEhd;J5}~9t|?l7X1%aQH9yrSm=~)$Bj!Y#M9`0sd9SlKaT9>7
zGKre`m%uTBh+)*8s*T3-uCfg)$<gHl_0o5xGL@lfC^-1_;R%ZDZMrzBYB3)|UsRaN
z9r7P4=pyJHVa!L&u#=*tooRqJ5F-;Ydk*eM>hM?^r)7u2_kyg(TZ&hg${;e_5&Re~
z^2#G`!NXTAG`z9p09OjOIQFe$hc-|Yqc>iTFkM#lLYwuKmhC7io>YblN-$*kx)>1-
zb76hVpr^-cbA61uIg;j!)FgJbuRD2rocQ=G%Um9a^;b%E=0k)1*Lji^TMmmKBWCeq
z8UQA@%rb@F@bwh@4QyDF!iHrLHR#R?Y^7^(UhpGdFb8~5U+`J-V@1*EJ})AqjczgR
z<`v<jnC}=um9BFk5hHZ>o?dVNfu39(`byT0pkZ{HJM=TBJo8fX3Vv_EhT0CvI%J(I
zgn(MHBLmTkD1g4m!KpFFVXDs^Ysj|#@1I^`WpzAV$-O0e_9vv9UNB^_wTgofI(0`Z
zG$2nhlFV7Fce%)vuwUJe#>hxe8#j^uM9ap3_oizOpTEI6OTDb-k{>7GBaDJAGvAG(
zE_T9Eqg2<o42kX78@bwj_rXR{uHPf6B?QX|rLEwU_}`j(P+ok77y*~;d&t@67{n!L
zP^?B8mTw5N+2*RSPQF)Fg+ZESrn}=7k%1nE0}w4IgJI+B0bAG=SoZCpnJy#whmH1R
z)gN*Q%LY+&!$v7^li>DZgKMg~d@j$KbnX1hvMlB+K{uKD-h5;17)c4FWpvLoU%-3o
z#qOr+GWl6AWGRH6MV_zIh&k5MHo#{xXMMB{W>lQ44m@$cdD&=|;i71ETxyCx=7N!M
zfnWYPq<=nF)$?8Hq-3rFVfR8J*cub>yI}uJ6z^3|*39Y9{Ng$m5hakXr&-t3D5OX>
zQ|K^E3RaKGxi|fg+#l9`m<e80KObEV%_H^aPxRgGdO(h;H3VVrY@=f3z-y}XsOf{(
z2TvH<OuO`$Z?oldd3VXSX!dKXY*vokUr!UsTu4@CnqdFvLAk3PkYrusErDAPG=(pR
zts#k4<m~PZ8BN#SV|l>@VC)UAF!=*C1w;`xjZ0-eY)xo?;xlc*iv*{*NG_TDE&hkK
ztJelX{5X12f~|&<B@myJ^&6HJKUlq8Rd`q5I4}*%>Dn!^B1hd1^=tV!QZALh{9~fD
zr%`h9R={>Dq_8O|s5r()HbR<m)=EL^7Kga%1%NSCc-gY67SL5p=?yu%d-U|ncpn)}
zx1;5=tB4H(d{`(|JS!0}!UgL~z(|a=LKWvj1DYkV0;X}x6l&wVe#PMf((&d9SLmoI
zfx4N(P`{gM3B~{>G7w8+OP7|uzpzN8G>qvx5wZSP;jvUh5O?}e)K)}!Xj`Wqla0sa
z&-svz1<c>mffKya<CI96o+TX;b-G=ICacWcH#X<d=y&=X#TGbG;`Liu(OcT0-`@kK
zI3&bp*|#A#ir_j&L#$u$))B;!FOE!D9l3C;Xx?Kwt$l6?N*li+uyu9m^gH-@vdcT0
zA>5X7*%PGGfaE3!h7L6C;w~d^Ug^~FDH~?_qkqDZA5JR|MYkm@iP0s#Ed3@}pLWd1
z*YD)-5Xu|B5efT6N<R@Fe#}h=dS7)NGQeq~X^}R$5DXJs>x4l(Wi<;S<4n^(4l3@E
zBbyqJrb%V+9Urf;k)I7rG*zYODZhNbp)KC*c543e4q9s<mH3`~h5O~;=S+g|1-ou@
zCm<1KEs@}76Xhn!nw{gO<hXAIZT#lwi>O}<8`p6lwX!Iv*+x1xaZK6UCyYq>1v@U}
zX(+liYRxkqv%$2F_^PTlA-A4TltXcrDKDQTf0LN`VHaGNQAyVRbZY?Y%3DA=FTvK{
zhE!261$4n(x;<fxMK?l<ZzFQ!#r#9E?urJ32c6LuX9t5!{;l!Ho%Egb)%zJP4i8IZ
zjPu!`3fG$}qTy!~!oPZ9dcXVMQ#Pr^E)2naPlO@zGOBZeXUzNw4{7|U2m&Z)L1z5O
z!X1_=C9hk$!PrKWaKF3hui}U8Mx_VJx>+}N&p_dcxt_N5x?CK0Q+6&NlRr?@j)@F=
z<r6MmCFd-DqWHZ*!c-Cc^&eYs4x@40f1L!AKjtL_y=%(pFYcPO6kd8WA-_gW#Zke0
zQPASCe_>L6QG!Z##8&c@mZR{TCcg@{faUoe&DYFEp+Z6bE7sICM?fJD-;cWO0|qC@
z()1t6h&&nSjEuqgUw%nOWiuBCH)j(w7a#{$dg3FH0{eeCEG3*B+#G?QuE>A<mi+v{
z^lowhUiupszyZLTZpRH!2C$`fa|18|?5&I3fI_s-QBPUG!RM&H9Dp9co*p9y-~@2A
z_R9gR0qJ^j0JK&?1%Ma;>fa#rbdVeXC!N)p1S9=C6NuV6qzK4`2XLmJaRKDh8+8C|
z;GA6PCprLP0CPHmE<g&LlRI2p7w`%AClH@NeggFg^d~T%z<vVv3H&DrpM3cQ@e`y^
zkUv5B1oacNPtZTX_yqG4tWU5%!TALD6TDCGKOy+!>nDVt5Vfl70@Jzv`A?TAK+xx(
zNq0;IdIOkRPg8-U0JQ(!q<<nfK9w(cuFr<0>A*vp|Jq7^{{KDx&%}Qw@bbbl{;!M*
zu75M+)0vG)h+CC1fOY`ff1dh(C;jV2{bv$Z>*s!5P+|V_)IXD0**O3A+u72udV!dq
zI|khclm!2bzW5aSnEy}Y#((rl{m<a}{}lTE74bgPGzhu=XPNJFDU6y5#@1#gu0UR1
zAfuEWGw{<~`>%K?Wyb>K;QTkOKK*1Fh?tz?0t?Q{md<nuqygzjdF+WNb-idDb4=U7
zhx%o5r<yIvKCjpbr0c&FECL{jS#*GcCY5;i-}57$NB{}o2klI(r0DH~H)5u<ohw_O
zoF8ww<tLBGTYgU%l$>3chfW0Ryu4feGje~1>@z|*kvp>`C|w*beWz}7wyHaDsy5E`
zP<$qdTCL8SHb7(NbA1Z)BHqcJUT9?NfgUarTM|+MmqbXIZV5h<4d*cX?q$`|6Zup;
z?tW|cRIO8zA8ix7<*WW@FMrx<4TR{vouB6GpS_6-yl+Ln;FSzfEnnH1`fkO}V(h)V
zL#sSAQkq7IV=LWBJR0!b#LpzRytp$R2sL8P=AMitnuChAGNDhfwL`6%w>!IN_e>b4
zD6jW!?NH`weig8(iO9qUO>?UcwfKm2G3HeZ-Ihsc1GzCaklOVYvi*X6S2*6LF$dkn
zUj~D>YGeJ|)1}U)3&WiDU&ZmI(O;}r8(>O7=iz@W5lAl~kKjw!x8lD#KpYYE9ZT6*
zNocgZzk`}<*1{f`zK9$#!{#UOV6+Av`Tn{$kvJW{o*%t%?y-kDiVmFX#zk7aA(YZ%
zdudpvZ5Sje>GMv7yOZssa(PfwaTA-M8yKkj>q6$fe;~%~WYT#VMOrlq5vzR9ApLum
z;G1c5V9PPvoegO&BSVC8xpm%J9mZy15^e%k)+lI{%jNqWy;S6-t5_vsoR}9=EXOw;
zYRRo}N5MMVcpaBkj><Aaelz)al0+u?m%s}08x*)vR}<EZ;ux$sXw`#g|NCPf{C)6j
zxHrm)`}2m~DRqyMW1l$@r;^A<zXLYRx_9@}YFU?w;(Xf#gkO}{wfxu8Ye@T12p>8G
z3T~iM#0IbV3j|u!^CO~GxJb*Pq52NoKFzB|v&h?q;@Z*)Ldm#mufaJ({)6>8<3PI%
z&LFxnKJZKh$@uV!+iS&zmVh|mx607e2GDzE+8Ou9Q|KeTM~gYtnqFwHBbdT|nu)i}
z60`xo|KDqW>-Xbwg<;gWyefO9@v0?^X$Vktz!LftgFM=-p~%A5>RjSjq^Q)2ylB@u
zv7xF+8|c5|{$jV^;2HHaIQj~0hTaOlYPs_96;Go-@Mhu}$RJK+V^QCTm7Y|zJNnPR
z-uE5lE8XKH5E_`Un(t5{<|+t)-d`Yo#1mhl9?7#=t403V-3_RXnC*UkbwOTbMP>kH
zHlY5RwCy!p%~BKZ^=GC%Bx`ls_+jhMI*~^m>B8hQgQF|6n&oAs!EOc>wTxmNs+YOu
zW{Vej^tak3<}JpSx{>zCliXv}qamN?JQ8x|6(9VvXyU`r9ART-Lp-lB(`VY=i}78%
z+>1H8tUGvJX30>mY8kh|b*gD$B0wBe-e7Vb=WTogy$>G3T4(rI(Y2Mo`lLrMdkmXY
z2S>cn5lc=A!wZtHcfWzC)|;|%d0rbijie30Gnr~UPql$55-3i#QhW?v%Y3AqV}$fD
z{&e=nt1TNM1FuZ7si|U2<4-t6IT2MUpjL{?TR?O@;tV~<79fp!_`6C~3r`rNB%PCo
z;ClQSNBnXO$C2RLu!OIe<v#82?W<O>jQp8^xmh~_hK`v>CBfH4=UhOnOVty)xYL0<
z?sOo$=XhX}AW&$$6f~=md$Zn*7!iuj&8@*8nz3RD(L0W%{6gY9x(x*%6~XJaZ`wEc
z%|H#TB)1;U!^r%e>?oixA-@oWh-vDKi~IIa5@J!}9HYgO&u>1&?mneH*vd1E$2O7c
zGiKN|7Yv?E(r(4m#tX-%AxA1X;7dabK`3!J#)P2haVd@}O5<Do=kMf$q?!0p(Fkik
ze#?}{=Le)5pz>flvWG{yJ|JhUt}aO|jSFBPk<k%h;cah&(=egCT@(uPB+_;JY*2en
z`dOeGlfC<XQ|`gWp#d7e94!ay2P`tOR~5z6M?WqnmPz0zM&I3-wnHcDnbB3GO~+&8
z8E<x7{ZVqEpS3f?$BHq>869S(%Mu)Z8>SH%J;~EguN!=r!Ib+Rv=cs=ZzA-RaKFeF
zkryUw?}Yb`@79-`I)MvPmk5b0%wN=etWl~R4Q1_wP6DSGwX?csOsn9>?@x3=89H5t
zy+9=ZQ+`ThcXL&L(NP9pR;)U!YS3uzX|$=8NMNktO6UKGbG`ZI%u@K~Hr#Jb@d$^=
z0To=wglx_}ikXjJG8L3AGh;b#4xqSh50YZ2M;@V0!Dr9od4vL;=!y(UwCQr6$Z(mq
z3qCN7=WH#nxC_1X+znjNHVQC9rf?<i#5me>bN_YE)6Fo@R--+FGFo=7iAFku2)+nc
zk5-DqjQ*b0huoiT{DW?>buoq|gm1VUqOp;gwxv69RqU!ITBOh~=2Ua)FSzlDaMHH{
zQSlt~qU8#qK|d={bzyUDB27nQE-Yk;>VsP_uL5KLUCBsQO}7IYM8>R997&B6bRcEY
zF(l2>7t+w)S84_X?0}v&App3Y;&V_<2P^*ktu4t$4c9Lgd}!6CEv7o5Ge%u&270#=
zj_u_EPmJ-gpjB%T2(Mk<z@Oe23gPgqw6!q|FZovmVX2QG)cR!JZgAJ(m=jZHQU0at
zNYG)DQleS<+BwbP(natj!8Zk?TlP@g1oi{^=zB1g)1QfYdPpL7^p{){H9xj838}9g
z*POV-DP%+R-{50c9S!iJwpXjCMg8F29sSem-ehnT)c7h@(>S>x*3BRGO9LIX*X~o*
z8TI5`Hw%nG2J9MiTEsPc&mb0B8Y6Z6viILZpH}9U79zy{ewiMkc}FXNVzAs1g>9+&
zP(H!pgxHyaD^yT`q?%~c#?7*p&oT$kMB$bPf&EGbN<zu8?3T5bI=VbqOe4BG<u=7t
zZX`O=+D|KkV`UAy$N^`i<NW&`v$o-s9Ta@$k1s)>t2}=a47JyDnBHGG%yJ5wX92z6
zJiXED5!q8lDlI9bJB=;$ikJ+ii-0V!3(8JZO|}YIn4aVLYHyLQgJO;{zZz;Q5r+^U
z1VWLC>Q!i+B~reZ%>^KLPH1j|ill{|L@{TISu}g|je~d+4*DailyJ!j)t!=q;>dD+
z!6s!u{qzkD{1mR{4rE>3rPRm6P=Rb?EvgIkO8t1)zcOjlMuA10eN_<7EG-`-)pH-%
z>Bjt{g=h$3YCoV-z?WUvnMmdi@6lEUtJ;MjnryTcO-C>Ivy)K^UDJYt<|V^>pR<hh
z(7&KjLM{$<{EgSS`Q?2MyH|}=LV*m^_@^iZgk}%{7Q?;K9D7)G3;bD=Jj@Y**YJ%D
zm3Lv)e=JR{FMmw2;tHoUt$9%~WrLx`LCwo@Jb%w;r`=$1t&<BWcWBs0I4(13E+~0e
ziPX^p73>g;u2<r-0ZtTppNkMKA^2p7-hJK$laCmeb?S<u8WlDbp`1ya82vRI#p9VG
z$T>6z*gAJy(d$~&#H)qxp42k7e0lim++^RE4o}(0c8L?q^OEk^el!t9O{G_1+6EDN
z8zQTP1E+MyuZJ&1m_%K|oHNnFDlzETgoZl3WV0l4g`lOV(?^vGx?r5ENdmD>MM<Nt
z7)t8c+ut=gqygWoJ#>8xbJzaJ)<~Eaw56$((v}Oy=1ux7g`hAOt4?<mb{YLq*%wrD
z*274Z8D49w>rALAy@G&t*??=?B(^Q<&<6)XeR409{T@yRA%N|)?YabyQut7neOrn(
zY0g{>zaZTYiLd&AMy;C}ZTQX=;8b*{i5Z(999zxOFg*$`B{2FhM%a%>YyNi^L=xrG
zgp%@|b!j}<bDu-f@Xyz%J-BQ5twGvX(=Mpu*M{9{s=2Xdg46|8Y1nN6<R^RHKx2vN
z?OW^VV>Rx@@aeKeEAywJaic<@t49?|Bo$OrA^t(!sI-vQo_zA{t^ZZHVCOq#UILY-
z;2QKf(R4%Suw_De&+n`xL&5`F&{8{D@v)aP&26<izN=zD1pSuH*!?pwFX4Ha)O5_f
z#$#BX*q@$5(yH$2wBW+rM&9iTY=wuqDOvsHO?>eCU)nh(*L_Y8Q%W0rD5ZQjr12ix
z*rMgdzw%AP<|j4IuBIn7gEeH|GYg+PVofovrFv(dorm}wy2uWDTSY=6K%5frVbaVj
zY8iy81cj7K$CsM<g{*i)$^j0=z+Him7W||E6{sy>J)z)m*^6p6T0pN#S`h|u)an^U
zE1)d(bUQ$3Kp#~dN#t@(eQ#<1?{G|aj#fpV3Su<Av)E_3+v=$F?$!hVZ&PLjDlqV3
zyPvkUjH?8t{F42?DLSMKvZ_}7H3t-c!j>uI3^lA+?6}{A^!2F?*fBh^(UTjIKgzpJ
zj=&PAgWdnZ+$tW&^5{#9z29|<6PE5aA9#}B=K{7~w}}o;h&1GXA9eInMK`Gbox7Y8
zhs`Ug*^l+NVEYv(c*rGL?b^*joabH1B^So-K@lRAmjJkWbvm^Zh@(L{MZ8gvNeRPl
z^6~emxH5}Kd<z?OTuK_>acA8z%)RfT?GGFzO!?mB9bvTK?VH`~DkmnP`V=k_#$SuG
z_FQ}54|L2^gc!`Or{5BYGD6z-h6q_GLmo-o^fN`nm6Dp&R|9Ys?l6DK=K#w8@S@#e
z)3FBpo%6=A=t6Gf0ZqkgcYXa5d`%T`=bmQiFqvyJ5s>1ujqpY|(9&QP8t+AK)8{gO
zn7k6tRFg?c%*8$ePO(yIyN10FuX+}t;PE%mvugL-16qUxg63XKaWsq_XH`#Frwm5)
zFe7pi6MMc|T?bu$Z#b~Z@<-S$DZh*M!%D-^>pn#qHl9}j0L1<)yQL%L`1J=I*qijz
zAtoa}*yYLz?{c*sjo()re_0Vit}%-6P(je$9-^~<T|D(Ll$4;dF0qGB0R~mxDj-ml
zm*(~@TEZ;a>n)06rAX|Lxs~vF*{$vgc?n0N-CTi?cXFE-p83tg#00B#$`f-|h(mbf
zI@O571y(HCGU)LESND&1=GW1%nXt|u$K)-jmbRoQE4);(K!A}fYp`*`vwzkkN7Hez
z)j(u`H~^-*mH0+bFhO$}=rOY3?J^bMAuMN*C;-ojW%ifE(mOhZ*+p)Wb7m-PIcvNz
ztnL|Aji*VwQX%{YT+kJ1`34PVW(&wp+SxcnsW*hk62t^@l-EeGeA1PqSBA5o46Ns5
z$Y~DD>gb1#r&2j{7vD%C`x&EZhJYNQ6?eWXMUt8F)`f|mxN<C(RvDute(uY!k$Asm
zsTYsIFrReOu;S*M+57`t0OMYxZ<TDs5?NESkIVpEwl2esN5hy?G8-)ogEQo&EEzT{
z5saL(3bghxUwjeu!pX5#WbWHbOJWg8Pd*Qhd3c13kCJCa_cIJO$+BZl607wjkQd9?
z<rh|t#4y&IMZ@jfQ8?ibBu7l17gqBlya!WJZnnQkRn;ipmpZxT39EOeFYe5+nAs}F
z!os!KtvvmL!ZeHgBecli4@|f^O((-vu+Z-t`9ZI{M$2&ycYDDP-_BR<-;^`EtV7vD
zLi<+2VbyA(X$`|7hC)Xs)eFwP2tq(ET`s=y*~t%LrxT-fM$+k$vTVcL&`j<R(b*$-
z&l?T+PEfx6v@VYb_Zss{fCm^=dka1p;l{%BQdiHt<~^L%V8z>)BWxZe4mqpc=lwD&
zy9NbKBbxXH<*ZST=RcwQ!xZYh8Y<3KjDB3wvy!?Sb1<taE6y({I2bxsU9VRDS@2<9
z=45uvyK*igc)9n$4l*Hwcly@6Q4sUKqw<5zKJs#K#T0O=9u#W3QtfSKmUv{YWvkPe
zwQ`KZiiQrb$kN|9Q}n)AE$(pA7fimJS^%BCg}?lMldD&`@D;t$)oK=p@|T)Hgl(71
zRb$qjorb>NHzXrFa2an{vhgrzmt)z(WSU4muM%0f!|ot&eSx`;Q8BK=3TN7LoNMSV
zJrh0vu}+_IU}QDKRyH~FC4f!tJ8IUOB0+9|pZb^LnM#WsZK*A7roQsOpEvw<RR(#b
ztR+`z($tpJG}!KU;xcz}Y}GJF$>_J+F%fjEF}ac1KDDq4qc-GE<r*#4(_#N|9+$(*
z7g&0E9YeNxqp(L&kQ}clIZYN5M=@9}=J$f;Lakn>wK7V@32=?lj>_tz`(9vAYlC#*
zS|2ST7Gh{i=256u2D^Dv2)C=U`4`0V*QO!m5>?9*-%qRuES!_6cMJXs$+)8I50)Dq
z>VXH-{i`UyLA$=m0*`wz;%)7qs%40JzRs#eIz-X1MUm6P8QOux&%d3f;*9Q%WKA$b
zM)8l$F_&dK^S;l!@nH$&+xksca`kakZhO4#F`>)Z$h_Q2@r9(G4Z6|aFq%P1<*(=P
zH_P|thLieO{6==I6aXX9m191qs12qp3~Cb@{-4<QZm>ntC?8BGXN{Xu7B5ym6Byqu
z{f^K%vr5x+d)BBZ9F+I00*TtZE)2kkBA<SKP1$G54%Obo2`#F0f&3BDd2=PJq~f&o
zqbC_2(HRJh_Jauy0p}+_iKa3r&C~mbrKyALrR$T+RDTyaIKzZ*HRzX>IGX&|Y-_p4
zr>>*HM2GYy#tyrlFZD~)U%=bl<ihee;w){}lFIBm6r(w?zT69=H++7wFp#?RO&g?g
za-cP{q`@;(tRWqLA3_lD#4mQXQ$y#xHDCuzr<4dWIM8gICpwm_<NKQda#R}vEquei
zJ}HbndNtizoe2X`^SI!h5#?8z`y&|rspNUtf&6urC28;rUG@<F!n-3;=@-m4cgAcE
z*kSPru|X5oJOU*Gf!8iT+gIB%f815$-eBlsTS!D{*K-LPymR+Wb?7lfCWS}A+$Av0
zZn~L(!Gf{psS!>_(uA)I#LAaJ!f{TKA0X7wQ4h|Dd(^vn(wG`WUY&7~c5iBK7;N%~
zo<aU60$X;6QcYlVJb84lOmGj}<_?;(97n{`oM~^`LysvLGJVuxXd@nfgd=@xDo>dt
zsfk51DCCig>HO|ZgDjEK!7|Q-wBc=d%&T)*YM-tsNZ*`vQkF*^bSZvq$EruC%MIIb
zo5-IL`#LSpp7r5)bc*0NnIi(}8z?4j1G|%ZWX%72#lA!M_J(=ILf7DrO4|BgzhZt7
zv|-)zmI$LKZhf371%2oBtYw^*tDZZM0{0^KCi$cs#yUzt+A;1s6RsSdyFD&!MAp2?
z_VY>jvB-Ar{rg@YzQ+g5bmesOe`GZOw^YoL4q65hqyMXl|EGVGi~V0Y9__z1WZ-{4
z!2XY{%k)3Wy8o|~`(MJWIOk_a(e(e5kxUQH&Gb*q05~gC`n4q)b$a;<Pz3-=e^~)i
z1A1D?SAhTwfvs1B1_y~i_{7}pN4r4I&{2r_sT25}X5$~1a0E?eHu6`$?c>%-PwprL
zet#T%07OG@BmZM{=_vg`jPyD@3g~}N8@T^}rwv^Hb=vU%U*5l}HSYhoJZ?51cRJGw
zkSl%o5%?u}LI?(ug^80ro%tVyS;l3L3#sez`&I1;jSi|*Vv4g%d9tndIT`!I<h<-7
z0ftsXb0T><VdmufUntno27>k~MhZB7QE;LF<OhlDM1hXC{mzH6KXU`IEXC8&O-SO^
zM~QH}0;;5aspSWj&4hjyYOAUT$XnQQ$(Y&Ks#O80Q}c%>8MH09v{;nOARkgE<vJCI
z*T+9=1F?q^<t_%^h0|AdJ~uZP4^I4@<$RB3do6biCEyCf^=r(9&9kppsZ%@Q2F|GO
zD8eqda*i*SqiV;`^<JZX3UKoHzXw7&^WYCy0gMeq-z)*@VfsLfroeJvF`h1&dk@gc
zW91jp2dK%!!YRVWCTVB`P-T1h{Z3+a1Kjc&f31~{Zq3HKH35}++-H{$%s&j9=aRpf
zxZ|Vc@YlFsKO5Jx_my7BT6SD^H^<D_Hp^YZPGWh`mLnJQ8HD)x@v2+tDM*rPTwhd<
zE@sciVms*#jkMIxm7OfUT5xB-7QMTc3-DF^)|t<bSvJw<V8qoH0|gVBlhtHb$z`=f
zx!?`G_^I{kS<a_SL-W%<T48dUO#b*$Pb;Ke-q~jPqlB<u&qH870HR+r;9+f)5a=7k
z*5bk<l{P)SionyDBYQ16_~&pc)2Ulu+mmHhLUHhIHQySnfxD+(XRQ&}lK+W)KTBxh
zBa{#Yu4R3Y+%;J82S`h(2+iR=O2FzqtF$5;v_8(-jJPW;nzJ!}d7*(F%^jKS+&XpB
zghxAYmI>&jg{A{;7p+%ZT+7=;9_8VS<te=_1&wzHQb5{Df}I3GbC?I5FxzfF#WU;w
z@UCn<$RjfoI#1l&VRG4}_1S9!oGr({yiFM!YHjHG#WD3?fdH)17onHPPV&ra3v$}E
zd%5^JjQx{-@KM#yf=WkHTdTbjI|vHrmA(pj+N=akhxsN9B=hY|s2Ob8ikDmR&X`No
zVy3kj**eSIiWNF8dhG4lBpD({)!Ci3R80=kRnkAUhE^@K7Md0f4118)S%S+8kbK?`
zFyNpYn6y<?K)SodJ^pezKNXjDYVB?CIvLF?MvXYJRuRT~f|1&~Cul{1+=hS|go)EQ
zF<wKS>cL(Mm2fT()yq+iP`gHo0Ti~hu)@Lu;seS4$<;{02f3E9ckDS2=o~#r{eohX
zjP5$H8O-G-at7{>pKU4L!r`45P-ERQeaLZyu#7Q5AQfBD;N>SolbYEx^DpiF513S4
z-o(_Uz++#Rv9uBQ^jc;#2~R}TIa)mWvXgSo=?FjWxSRzRQ%Jb>#8eCRX0er=f&Q+V
z(=+O!<e=`3EcWLq3i`#9tdeVVG5{0M8t!|^v!mz^xbDD}d><!DAaRi@k2EYmC*Uac
zboHw?sBKPzLpQ~1qbC6AWaFm2hN(@;9m)y1NDRS~tcPV}mPE=bVCiyKGpmkOQ`goy
ztGI%C#qAWU-%SL7Zp(wA=1Im!I>D@O_`<(gvLUw-v`0WuQjhZ)RcL=m*^LU=CXea<
z{Bl(d&+aDbM}$U}<UvuTS6KmWM9uqD^t5|{)MYDL?<~D{%)9otR}~@%C9CZxdTZMm
zt7)oR<)se;CTn=+eTK&2TwXM^AmqB4N<_Q6)Sc8(<ZkqollU#hKumz4&NuQ{Y%S%~
zro(0gZ7L6;>M|wWxumvqSluU@+i|ZqmlZ6Va93A_UKrW^v{E}|yjr_evd7`EHwJnT
zo{ZZ*?yI%$S>TE@0t%P;3V5L9u?&NlTxT=i!1&^K<^WVwixfGB<-F2Vu4kL3Sx*|Y
zAxX9;IwqUU*3OhcWkm$Rk0-WLUciFL(9PvgZ#}N59gHcgX_dktzYDu7`h}Quo~gDo
z+*)dHn4%Oa2Bg8B+(y&dI--M01hg245l)*ZaP^R^O*#hrFyuG1@3aJ+X{;$ob;W#5
zG5^XIvga!#r&V6LR<5xqX9AxES>09?w2R7a%dbWq94+@~ddIZJO+`{HKzHyns&WYL
z@oAmspyjb)weEq@b62bt476*N+m`3506AAq^+;f|uW4a`LS<3%K1M_%R0=GJT^y5$
z$+9|b8s$2`J<}f0+x5m&)8V%J-Kp8%$ElZ5-m_T_q4kZ^<4=)Yi@YgZfzC5nRX5l#
zXevlsXZ7D0bKnnGXiL{JyoED<*aN#&6Fh|o#v8WX_N%<{cJ%8rJBp6WbEcPpfs^f{
z#PMwDO?DijA~sxam9KE?2(G3e2qgChvxWWyfpbKXMJz=IfR6Uu*_5J6IoC7UXa!k*
zn4&mhIBCH)&9{)^&ePLV5BoUuq4y5oH6fa*)vu+mao}`wCAB{e&qK_4)mLnCej*Oy
zoe1Tfsy$}$^)o&j-C77Z8~;o?mG)q7{bjJSTA=ZZ%Qy}P$cJI4vF$tuvaR$;PCo$H
zrPX<qB7XrZKp`t^Ii~n<T_Ya*^B9AVxM<pA#g=GM92xNAjS);IOckGN^uA8M$`-lg
zIElh875d!QUhnX6pozMCh}X_)X|8B4ijGSq@qT*i`)I-hO6m-;60T(>*u2C+#x!&s
zw6p56rZECUELpp!d?Y_QNMklGSmfpE&H%V15&){0CPx`1kUU<Y3rim3?0&5)>lsQh
zAHWh=&OCqgO3OJo39^~WDE>&NtN(V=;7mwJnC=p@7bViQixnB}8X|0n!SU5;=Mc%T
zcg2Kh=P6GzRYw~1y?|gAU8zk4Y67K9BbtBt%%%w&7kAfY8*&+pM-6fQfe>a<VqTbN
z{G$uQ9^Us#v7p;xLhLi6b@O_uTHyo6qxN3?KWdc!RZwxW{(FPwv$*)j>F^(h2yT{t
zD=?^kE3kCk6(CM>tQNwjNn!gD$o*-1z<c^Ut^ag5L_7ma0iVMRFF<iT?teO2{Btm`
z!_Lagz^eD(hx6Rr=?O1DoKMR@<qI$e@OemYM?_4~YWoJ10svUjTi$^M0M=HG4`3$%
zz}AWmAhrbm{0UzOVmENO|Bt7yjH(-2x5eGvVdGkgySo>6FYfLHcW7yW4Ta)boFc{D
z-QC^Y?Q!pU=l)CP_$+ITBr7X(ee-{Qu>WsJ@C6cxr~wBKqz(!8g9afrxWI$*AfZ0<
zHsB$GMm`Ss8g`ICU!fpBgXK^`6(32C(Lq5C-e@4#k0cErC)1E0S=uo{VNf4gBym7L
zpgu033?H-z3B|?(jwA#<Lb35Sgb;xMC@40*253@{4HUQ(AB5Q8K@Q^iD7&GY0u%-H
z5saG(R1SssUmAiw7!x1F*+4-HLjI^9tSUf_(;!L*5@7-Vz@fzhzk_J-8cH=lkdWB_
z8Ric{$^RdIHg@j+m``hhkf}e0BKVM+8I0@;s>5ObUuMDokWc>4miIrl2fiQ~5I9f+
z!~!<R0F{GFH9_<ZY`;N4#Nc%w5Hoo7A1Djl=?kK3$ZG^`GlD;7e1J7OpffPiZxCHk
z|1O9VoQw3|!mbG^aUj9|jUVQph$&aez~MU|fqD5UE5KR1AA!*XC?{yZeT0-OU}RIu
zaWEV)C4B>w8Rae&7=@pb8H^o4*$>|5r=)9ujHDF*D8b|dbjqd71TUL@fSh@h_RQe@
za7yNek#S07Nbpj`2l_TaNzDir&;1Ch^8BH+fs#kb&|vdI=|~IC8vg)csHi5va}yun
z8x<8Q1DNXh!=Fcq3KbG8_VVFxr%d&Q8N5JA^%2^aY8O05MMa0n&B60uVhKA14;L2?
zIGBnC2ZopXW2*l#OJ)H6!E-JL5c5=UbCnj8+Ky*?o-X-mk48~QhV-oY&1;n=E#(!r
z&NADA^$N5~44YY=3S0d|#sfs&-}%n{T$Qh$11rWo4A<>w>Fh_E;QX)Z5s0JMp%S*R
zci`oraOzMLVS^zkzNC^P;81=w=LpL+`QGj#&TSq=j1?24@D>W>9Kb>5Oe|1gASum=
zcR(JUeGbb0Ec)eR`9%>60R{mw7z@D0bo>z{LxEn*A{tAcoe(7PJ<L7^0pE$IxD^`d
zbpKoif-V)Af*u6wd)6nVI7e{_4H0t=!b8}FaFO<d2{nO$h9N)_^LZbJ*_VLF8In>H
z?U<haNxl=eBl8bf9Cp5h63n584-$q!bh!>%fC>ypnSkSycnj-O8G!rj9z^+$ML==#
zC6j^&0Rpun+XR6mTFWJJS$qY;`Wyn9ODQM;8RiXN_nH-obwkA!BIG6Ho$X%c84RL-
zX<$b{k>+g<+F1MYPpAV8DHOsziR)3-h~5YS!SOj3Ap`_qS_gcGM?ivJ%tmalM1!Iq
zK86%MKzQ$oglQHt{307jjdRB&9c*klVWSnY%t)E>8{~}h<6{1mOl+0H#C@$5_6=tq
zG2tTY`7NL(w9DZ%Fx>R`jM4-qvZ+a8hU|4S8`Sk~c87r@3PTTKWc(1W`3FT|WC9;-
zjE2%`NYM_2x0|}7ytREozz-tjM~M=dK?`}KxRDAGq<~0D7wB2P&k6yu5MW^;>%V+P
zGJ&p+>_U9EBSn=sdE?JJK8L%7N`;&}r9*&t^L^bPgjzMNN8lZKZogTl!TX}kGdJts
zb4|DNj)04UVFY0;3_^s+3ZuuMpr@xt!obFce0T?z#{l*VubXyNLyVj8(>GI9RL4jN
z*%w?Gem?+y>#~T0_dO03e`B4j7V{u50)qE_`E5@WlY-!t_TgO+rd{*x-S-`w{BHOB
zejcB+YFf4KI@XTxPR=(#h;;qdEqeb~07-~g58)=P;~i`Z^=Ow}M^XR9YyUm@PmbsT
zVImN@ocEleaserF(P_+!Q-X3EvT!7>Y7*J*dw6b^9ng{O9Q6qb@wLutLQiz#ePALF
z-c$S>kGkn=yA;OF*VpArERwjYSFR9o%3O%=>BIx+7^{#6KM^{#F@#F%F)G(t&@eV4
zslHg_LhwriL8M*r7uu$<llM3fou>{fq9y<xg0IX{P9WynfaDv)b7?k!93DQ&&chS7
z|K4GZ6FmmPISi{P?G~|*hJvvdb$o{in}Aqi-vRuQ-h<yAv=I<6f^x7ST|8tOhSuqc
z+#|YH6W<GRAiW5XjzW~j*HdAZIEGeH6C`uMGeE{GQ>=*>56?~R<LcP~&U?UHD=<re
z!HSUT9Eb;*g5>5;Iv1!*rLsTRz!%e8vqbpYdWoDS#O(c|YhDbSRl#CNvvaBbXl;OF
zwXr5@P*;TiEOeNS^_qvTbNKL&4?Rl3n@2cR+e?lUozn>@t{y?}*`?ZQ@^~jw&KD(r
z&T_$$gn{<2_NJLomwu%%zL6JY1CS|u0+j*TyZ?3M(7o9Eab?VKL`U6nPIIQJgl}<L
zz|oTMEW%cLdp@;#q6i=9)P-}sWqvf%5)F8H;I_(sPrGmlmUgPM)`Wo_H6-`gTS?pz
zBO1ylxuvCsYYrJ`G}G0iL{>_4gL!68sav@Eb{G;|pD$*559jC5yRpm<37iwH9%E4c
zooW;s?!VC@UW{0Wi8|+^lM%R>6ExQ}DXs72B_HE0!;9FxHB)DUaz5tA2W*w7<mFiv
zx!CZDwlAQ>!&yXBR+?)Q#^teaYGi*#M571#mQegbHg_ki=Ft7;n+lhmZIL&j**#_H
zY2ZQLI6e&A)sX95rZT_=0!^zg^#T9rt`ItXJ4E?#Gamj?*)=%PmB=aWya+Y2HT<Ce
zqqPm4I~>CV;xXm_BEpKV-%zeDbrhY^vjU?KQvKPc4fF^vG0GB$;sB*S==_*%!;Xbi
z6v`f<jhvi&ZX_GYsZbOR4+)J&m*6NgwX8r<YS>;re~sGDKG}CF3y31Dt5H>6M~8Yu
zb4T(YiBZ<N@LbyJce*n^$l81IsciPqPsHSMb_kAtdh4J5TRt7p-O_*Mp{imsSz@Rj
ze5}Q~&gL#i=q;Z$DO5eb+?iOvTd;KTO7a}lWvL_O`kkf>L2ELVV(QO>OA!0gfIUS1
zV&GET`P}tb#pMlgB9OfpJ`);mf<Jr;cParU->pFU2H_>kx7S4zHeXsBvOwcs9i1Bo
zO^%rry$*s?;tWF=?RsP*IUz#iF{vR!)_`rcEUO-6+woY}G)NfpI}}l?otr`~Mt=%o
zt%?y(>IJ+HkXQq-yvwMb=Jd%XHT^KEnk`JX<nQSvOJRA2fSXSFK{-hdpJ1D=k>-&8
zCV81(^Ww)^;w%lNdP5k0Y}&#;)Lzs%y&^q%o0e8>UY0O=!29b;wP^%5f0NX{#olx1
zV->Qg098d5RvoEHfLa>7?GN)K0faU)jj_5%Jp-<@aco2?t(IB{9DJ5L=dH*|zlBi>
zai5dE^Ihvx;EZGT(YWL5Vdu)QDl@!hO7K&17R%6YD(-<b3571sA&-c{O!m^%1V5qI
zr~bKCj({s-rkUDk4a@oFO2W`H*NppN)s=I3`a&n-)`81geG!4_Yj{K_MsQcv6u(MO
zYZcSs1ya$M!9TQD1wxv3Y91rVeZ$y1Ju&6oUJ~(`fX6tVke=K94-3B|wX}RSH`@Z4
zl&{|1aB~Wb{G+;zZCr&Gswzk4+ujFEg`>Ep`v*d<6#1aEl)qb}r1?aHpi}2230x<0
z_~jqk%`<g9%$3788RNP1^_s+Lw=P>S#t4zVud-j`2$9w}2)L&-OaETa5-<@<O+{dn
z#{JT20QS$3PkdVB2zZ8_9@+XA$_5L6vNoib5D_K1?r+w7>Q}!7Q^f|8$#Jwmm)$a>
zNz>@n6nQk)lrnr;`D<!MMonH^fbRjD_;$>g&)^!qG)S2u(`7Rmk?yhOS&j*z=hV72
zFo8!}QRTZOpS^Ii&%ph|Ipi~LZrAzXlQ1iTGN63Y_8_gS^Fzc{hd<z->PC86W8ru1
z8jj=lRzDMAe1@<6Io?~XEn4PW54KOq8L+9Uf(3ZWOnXC^^4E_k(lfKrbfh*%ujxpQ
zx>TaBhgfm<d7s1?Jky^3V(&dGI%2W;Ycv0awOnb9Jy$Y!Tb|yFs>c{cFH<^kNvG?_
z+X1$!YQy4bzasnTED#6x)Nv_PFk5zywozbQBJSDlcD_iiGHN<ULMpUrba^f%H`7Fj
zaptrPxD*zLa6Xy^!~3&MJCn9Ea^!fn{HF20%8lz1hww^boml6wbv2Rw<i!7*E=3qw
z-u1W%1%=2h7@ehJUIqAd$wD{x3AvNk-2{*bWO{c^Lhi7Btomapi(6BzYtvH2#!avU
z%Q#%ayPEQQlcsA$q+V>dTaBG$K=Nnck)+R!PV&YP;G<2KXbn--Gqq|p=hjH!{ZrO!
za*Nh?@=f|r@tNF{=X^&*KS^E~b|TNC`X9L2uTJ<3OEMDVbC3)PoX;VA*gs^RO!0tZ
z^1lxL8aNiZ3*s*n<gtQj4R+HqQrj{yHy#bTB0P1nZzta4Tr-y%hi@yMi7YY}=a%@S
z#tKxE`XCg@ra*}0`J%VPYeRPzH-#C=F{;g3l?v-;Bu=@W{$`c^?M^B>)a|I|>(pen
z#b1A<&h@!clvRk_8rjD#4BUK#nL_}j*6Ami<(R7)CrmXRo7ULo`n{i}-Oy`neXWJt
zyrYDbzj;|D2$Rroe=H3JmIWwAD|Hgu5)rL=ZRR^nnJl$d3f?>Gcea0eja6SYV_l1R
z6W;F{`ByMOLQIIE{&wU$&R2#?<rsH^JTlIQ!}jV~c>)=~X31ossnd4vhSUxug~6g1
z3PcJ*Mu+>v1(e96ZWNsxkDJrjp`HX{6!TkUFG-Dtn;Vvh*HG?x;2yVoTa(*Y7e_r|
z<DO%ZZ|v^saU$#utJ8V*7hF9!%sM;P5{&yBMyoQEhed~5FHEMb-0FG`|6KyV<#cTg
ztG<~~Z&l-Er~W-Qa?*3?0mTE~I@AoeTgH<t&wqYyPdSijAb=;kNDS16Wjt->?3)l~
zdsy?Q6!}M_8%?fx@0n~_p&Lk5x2pt?G^Z<2==<9#!j#}7oMf8O1YtgYuL6J!PNKnC
z#`QAu=4X*yGjGwr-NEW+RSK%<QMn<DsDdKga|}6V@{PC1G4wi<e9i#uqtS1kJ#YsX
z-rR4vM`F;=96o!Jy}Z~b_towEZr%E<G$l8+Y2aly$AU<nQLofZ-@7XsEUY1Frv^yF
zC?kdh`@N@0t^_SV#Oc`!cU3Q08*gWH4YRc;X9eMV-Tdg6uClzl)y_4lvtOVZm1w2Y
z>FUIfZ}NBUv3YiZ@9zc>rxS1u5Y{uZJ80w#GIg9u8h#ACTGb~SBV(#e2e9A_Tj)4d
zB_aBsq|xR6Gp5vID|8_-U%R$>M_40gAu1OqiKV--^FCSx;=Beo@oMua5I3{pqkV<v
z{^~2_+mMhtKi%!m7I0h|5?IGAgq)s{i6~TinCYj@GPTmu2T%Z~5eoM{@9KS~f`VV!
z3!`}6w<lnjpGqdR4U9#m@d@_M&2h4pk!*Kxc{Md!VqIPcbX0>>;NhRXfJ<A<bSzxs
z9px8blhY0YOs^5s+lt<rEY4g&4r1Rv%a0N-%s>7h_j?L-Z`U1q6_1#Zxldk;q;CGF
z!Q`f$lsWs!%9{jeI#gUv=<MBSKprfrI-wSCEIqs<Q^@pi97L(Nl5_p`$&P)&G@(!Z
zPM-R2=nv8YZvuaY<)B0ugAbYe!Mj#2q7{M8Z(P2g@#Bg4{P(glT7FvTY)}S~XM9_)
zNN2NGp*bH_G?*dL2dS<L3BH*<BIx-#X!%n|`#<=X=oUu;kH@PPc?0Kxiv)-FF743-
zk*7;aM7<~fj^Lh+4U`_`-s6VF-!l&}CoiW@dsn3`<@{Mp{g2wK)4G%fI?T^0$$Rv>
zpQV?^tHou*3|#0XnV;<==pR3~Hf=7F2<cM1<3sMM@i*n9V48^W%Zpgmal!q}3SYw(
z-w{=qmdYgtZlG$|j!#_uv&o{1!KEdJ3g~Y(9<@{=xby}!g))x?3c-^PoI$s;;w9P1
zjFYOrKF^8ceW`w3na3_#iqVjK$d!HU2y7}n>vRhrIgLLNdYp<8C?&0^?EfY$o2JzS
zrX%Ov=>05>N2^SN&^A@qe4m+p73MXUEuwPc-bxw?yoKwVM(a-X^N`JDMJ*BA0zK+k
zp0K`##Z_-3dB{vlg!}j7PK3>`pXy4Id~I6PeK<LA4b;<<aVP^SkK#!=Zdqv05))hl
z4T4!zR@$rsF13^!A0HQ($<3VIA`L3Jn}1#ZUHQgpLB`SUp&aT@nnE0^nwa|XHH}?M
zW3|m6`1H0G?MsWepL1`KP%pqnkLy%aT$`8G?!AG5U0`TDgAa@Ct2B2)U1^CqC{^wu
zN3>x5<>Il(=1H(6n46jmpNGRVqBUvxilN&Cs~=YfE!6#V4cBk_`+9eB^;?$}{_nV-
zwa;8$foCJ&>--S8KOscqd+^?FyyqZtOQHZoAjR3V{-}p}($1K7d4qm#Osho1pm*>)
zsPlxC^whJqxE)#qGmtqi^PEcH-C9Ie@0tBYD-ty$6|^>=ywsPZ9${gW;U`e<W<66f
zqyK<ajpr6!4THcRtz~!)Quf|yoO88NC6JsE1IsqrJ$Gp{q`Cep=9%O0&a~wEnUR$Y
zOnG|@2jeBXoo)9V?ey4Qnl${vdPcCH&v<YBRi=cwOl^4Py|WW}aeZy|N%3>*5k7-&
z7DrySgO&mVtbwv4S4K-VkD|+|MkY>weN$Q@oyu9rx!OT%|FiB!+2ss)Rpw|@QTvl)
z)%9f)p~lH7ujZ@c*l;DuipG4!w@?%(p!1t5`l01kMgr`G#c)`L%|BO}zEfrWKljsG
z^GKgs&)q7t_5ZRwq)aC!e{3#d+e3g@Ok^@*De}}u!WB&BaIB7$XNt5e9)$HHMSb#a
z1(&Vs8Y`?9yy9GeWIX$|lnF+pEI|g!>B==65+b3UedW8A^6Luej|KGF@{@PFfGynE
z_jCn#rT7iQ{$oK4SG}4FdS~7rkjeFxT`tvy)|qQZUEzkk9tnOw&3luij5;(0x)-m6
znu|B<Q?!^&B@79wkAvX-%x^Ekw}uL<xTW*<u)qE;%Bg5}!osa-^=R2s<Kan(JonMm
zZBsq@tGCOMr(l@E9bX-VkQsBw08A@K5ri{Wg>ambklQNAfD3e4EzZN}F89!iN{Ecj
zNJgG!7lV^-QFiC79ufUD2cNWAwUjgo?P1i3=9V<z1JZ>g;BQ%!=>A&EdLtTFF@oDv
zv;#N+dqt*W*SLM5$FkjuGxqcvcYWFMjUaLAv&R>owwS(*3JJp?&sJRypnj=pR$1da
z<y#^sdHgDgv=gth`|xJwU+ISa9QwrikbKDBBa+kkQgYq$*IPtqIf)BAs8NN`f%)3-
zj1weLIs`8dw$1(EuL8IIWTgUzMZrX|v~7HP)5Bdg<XBt7wFxY3a=#{IS847|<WcB`
zJA7Jb!?6oHk`yrvuTm+40b?&sC3)^|i&dYII)G+Gxw=RX$FJ3wjGVf@S1u!?r^jCt
zpUzS#8Yozj;u_pNVD5cCL>slNf@oae|70nzm2;E#O?odHXLx$J4!_)(eR7I2;vjJ2
z;WXw6H$(}i>=pFVzD%5|0;-(Z3CHPYcgA|J3Y3qYe~9V%ev|1R048VC%tU|NgMF>j
zMQhk&i!lMzFP6yo*GX1#5>EUmvfb>0hHMP2#4osy7Cs^~$T^PHPdOQnzxR`i$7BNE
z7gi`{&SbL@9#w-cmt=KGRcL%v)h#sdaYJ<!e`B&!AJ5t^2Hnr?IU6Honi^%~4kX8<
zzy88>Bu^U<m<t=Q0$ff4xe!qe*&ZNm$Tf#}_Ilj1PBHeiw{3mwE1db&^5n(mwIO<p
z`;j+{@Bgy&F+bgYUQb&=o=;QAjd!Kp{O0#qdlV(QUiQ<M5<2H~;_}Vvg*f4Rd7Eb^
zV+`L9M+Sg)D$m)iykmbuS9y?6R=oVg$GeBW_vZ+F9Fgi>BCufbx*RTKp`VZA>cSV1
zToOcxHo=Fy92AjNml^S16w+|qfA)>iRV`QUMP(th;<<<Bq0&lWsovgN2&Y3ZSl&>u
zMpA;ZSM}s`^mIQ<6Fau^vpUoVXI^fROykIavLZNfjKDjnM^$!mvFt!SJRw!F>gS+W
zQEo^L+DKymEI^V|iB1qx;wsDFM@E#~@|N97UlCp9VIUbufk_*i1R82lk$L6{!0Nr^
z9ZgXSk&!FAll6nf7n$Z(UTIk0;vH+;Z4{**Jq@n>+UP)@sfM>W<vY>y%S?LXS7Fxr
zXCF!fdgb=7>{g7ohr;;kDN-xM=Wa7J$vOfRW`lv|SwJqvwV-1eV06E6SdtV{U=*UP
z8*|a{$uWGn%OmIPf}44+5VsEU$L}m3E&hMsiI4BY6bZ{#ndU%m{#Z%APytfudLG}i
z4Hg@DLL~&$xlkJj2Jc9?tC-DV91@xkD%xvLHFQo9gfd!4l*l(aX_qA??~~?J<M(Hz
zCyV#jlYqkk+!`C2l5l1KB#p~6;<FJUJ(4<IkFZdtaz|!I$fS-2Eftt>$y?%plqNf{
zQ1A@qf*hdz^h~4@u9_H+E24i*I!qPg_o^d*B$7o&J%+W1ik7CTY}d!TV=BzmDxurY
z6^ViAmTS-`*Eo(BRrJd~p;P~mYtJjDOxpJpA1K)q)|jI(UXRM?CS3KRZ(O~Sbl)=K
zjo>)H$`6Ii8vH4MNUdXjbkF<C_ESWG0#Axy9Z%MLu*vR^$uclMB~ufzX=bYy_N06V
zfn~hK=0P+j-tg$4(_IA*R)?NI0i-emKHg!vslWyNn>`)w&Rg8pfa8TPO7K`iW%Ha@
z1aPTf@PorYU0Z%uvIKXUs{*$gM$j%(V7<3ghltyI{7L>Cemg&R&!$sOjU!n*g08b@
z%q+rrcW>98#B&QGr3$qGCv6g;U7Eqpekzdi8@WAL5qUPk@_9qoAhsI=!4f5Qh=WS6
z{~;M^<@0$eRZ`@9Tz+%85mxduwo_?yC4lOnt2Si3bYb5*8C{hcs_7T7g>frrgdgyt
zmsob32$zROHkvNmY_IIcr-IyUwmp(a_V;&3&?>Lku9GnVi`;Iw5F;YoynBsM;h#g|
za7P~u%qRbKPJ5#_VW^CE@A<tqpF5Vn_T=Z6JA_*HQ6{^&({TeF`T>tZc4KeOe89S-
z4T%$WT18$lYTCKntp1v7)-zB~P#)O-{t6ba{4+zb!1H>L(-0D`Ll~E~%9L}9AXCA7
z^=e8aoaG>VXBPR~m%t}IPQPcB64!x@b{}dgB5#={wMpLb<bAYu2TtLrR6BPW{d)Dt
zeMnt9b1)K!PdUwcT0(d0+uRyE4&W5be*=z6OhgiE=K>v^S5wkQuX0FI9NgT`sAkpD
zbM}PHD{dh7M+cN^WA#gZ;;H^5sW3nfYkdxP)`Kha;w7?hzHIy!5Ax2k)9;W1E?j-u
znlpAYzk~{yMqp9v?))fnYJ=0g+DQ$?dv|nD7}V`6Vo9fOov$sD;ex9Y0DKZ&_k$#f
z^vDI#iBM{Gv+E$Z1Cdb4-A<by*-Z7dkMT9+1-x61G0bxqTy0ovVPNMC+e|zzvM-Co
z2O0G8d~yaY(?FfY=uYZ7vduS&dd6W#23bn9LK}0JkCQ{_j>0Z5MOvvf#^ubTqw(t0
zC#SOKF{^T1tzcas@bS(Xh}1TM5iYCGCHYDFoyza_6RlhF0#w*e<viX$)eM_%YB5z-
z!_tV-D2Ub<5DGWe!#IldLi?`97Jvxn*yIuT=L@T;2C94)qHym_1^fArI{yxr?|&WC
zxo5b?W=26JY!;`7P-Hy$vMMG<dbLk-?iIhpwA~1&vEJEeDGzrdfKHy)EZfd^>AK-Z
zM5M$g1{WV0`+vD^Gz==NUR5P-YjBKzlddI;s=_X%bQEJ8O3SYl@d*?MhSU;Wmd~TQ
zf>jO2p^bw>=U(`<Ru2s8y>f+!E5jQ~XB#heBu+|<uL<r*WWZkJNd{)MGARAco!YYV
zT=#13?CaKag+pBQz@vRhQ+3Ls>r<Uki_J#gZM2@aSh7HM)P-ekjs7B&r4!?pf05J*
z%Bbx>0vy(;0#!_O<c-d3otP(z6N$}HD-Uj5&M_EB0{$_+o2!};K4^l;7n*96Hn5TX
zy%!pV3q$|lE@b=*VRg?bWm!kPM4ysXV3V2{T3SbO7`Nn4VDIdK3$MhZyD4}!;-F-n
zYf!ro<(piRfTnji>pc(e;y6b%^*3d0MDcH&Lg&sY%E9s@T_ueqT<;Bk2~?uA)f63C
z7#e>#_D!YyDjo%VVa3)~phZwk%84ZmN@^1^i?M1El9LssP#(<~u}<_P@x^)b2@FT`
zwuk7kmfFov04V}eS>K(0oy|BG>x(hKh3AwgtLr?=H;|*t4K3<*CHd&3M<+H4|8`}4
z61(7@O5iWoIC_xBu}~({noHS?gBLArXOJTl&6~3|-{=>JNdpjy$}H`%a+P5LyxAXo
zrl&g3(HYo5tM8bF7^6|80bX~A*Eb!u<&BrQ4+|*>KxuarIWn>;-k<h*X49OEKMY&+
zpYtm#Stou?P=B=Lh}}oKl{i0(a(UZL_qF`d<<YD3=Lbw=0F8j^eZ$bVrgaP6Pmu7B
z^+gD+v$uCQ<FeTHLf4C2b)I_+6yqsKRg$q%BgWhx!j>NrT<D|UDGE64M7fc|0~s~2
zYn+e|f`DJjFZq_jX^I=wt@!3@jmk^vgtu4xf1Vz~I|<PBKz_fso~JpnD^F%Im`EQi
zN_*22p-=N-&0s?FClY7mim&N>E_kT9wfm5fBS5yJQ(zd-QT-?)jOwwJUi7DYCYUF_
z{BTyI=PxZ;gQM~h_BUxGOMcC%mJ_^5zOWY7v;gBENn|#s_FkbVo!sg<oxfU)afJ0C
zN!F5J^D5i=*<IHGmDwk0wev@u^tW+Fk*6=yl|nTw9hvit!b*%Yotq7ol9!IXzbsPM
zTAibnD6Xyy+O%fYHVDSzI<nBLg)f`m{Qqqv)ir<jUEfmI8d?yCS13p6A)uQD4b6nx
z4geE4hriw_xkf+HfXg#aDIUuql}ry%>?H1EQ+85+fmyWvF;)A$s<qxX>~@HZaF!ce
zk18WvG7cIE&2ME)l=YUiLvRHi;YY*v#F-Mco;I6fNBhR8J(xf`OguSmhZ`>bhK@*O
zD^JE1U{f>~<oS`Y^gGN(d?9eAotWshEfmO#<2Yo*elBr-;f*d!)|OVu;5gnb=h&;R
zlq#dntYkIwmo-S(VvPTNa}P^UXs*bJgL34Gs2_<#GQu&PRIoGzeMb8mLqc$9oVu4r
zSGaWlK!ZU@Fw4YfW)}BFRC1IIRZnGYBU{~aXm9CIxw>O>nf(Y6IQv(??&%bNF%7H*
z3E&Z4ny%k6kvo=5CetR@=5rz2ap{o%{ImJn!`_b35Ejc|{0~BRIRB|98hToK!N+%X
z;zOW|M%3olH0LK|&pOZT2F<*9dm)*pC|yEgD-;dM<^f*;9s?lsQ};*$xs^+S67z3+
z*x|mK<<ZXLS0ax-Gm39$<T+Xn3bH`K1HwNp+K9K|X2$XFjrwp-7A3=7_ehyhdQ}E>
zFFNk~`J^@YPyr&!cptM@gWaj8uB?VkTP}Qje46*f>(9bdt({hzs$zt~e$cIr7f~aD
z!StQFX*MtxWxO1k`Zm^9Go?!FK8>2?`3@}on|Jpgt26e)mE9jw(Ky3KE-=8V7^{Tg
zKwSWz@)$QJCYWDnbZh6bq)7LT9JL50SMD3CK+LG2d?vm~$FHAGf}4IPJIr%P6e6+1
z=r2bFstLWCgw#N4q)>VJc^#+j!Jhf@?VlJb^?);3$YcxYMPCtpt9K-G_W@SM*7v8J
zeT_^(TM?!*mH2TeGi7qA^B$n^SH?8IB>yz&n(jO3#%~fL)WHgMttiy@oQG&gv8X7}
zv%_XzTlTFnjQcoC2vQJ_l0)?QjJS)y|Hp7)^qr8W$4CN1p;my&_|KBP9ar3~B>B$r
z(h<#hH?o<23hptK^3LZ1d#9&B1npkMDl1K#TD1lJQLvt{vNk66k}oj0V-B90<j~Ko
zui{BZQA^Bm4XmnVQ#F{CKGjbq`(t37LxX_D<KhxPm^x3@J;yE?b$K^P@Vv8Mh%6rb
z!IbQKfNf+|X7y1&C$EXWoIP8wdBQsOtq!CYqkfwGI?DKSVT&%Iw}?P~a*{s=!E4jy
zG?|!8lI+n^c=3Bjzz@Jl?nACdos+wVJ~M##NB0|-HfAJ4)FjvPpv&oLc%Pl%;aW^k
zgx++V^U?_9Ctb|5zu#?9{Y~<o)9M5E7m6)I{d+l*G7|cSyo$PmQC~AiAdAy#Qi2~I
zo4Y`p^^)j6`j*FaKiKQU0m#ki7pp{X=+`zgp#LL1fsyX1kibYvR4j1v@>*XMCBX@q
zRLfxJEGka0q%sv<gGdV%Cn>nemx=|Py-3v$9`>W6Z}_%E6;1-y&-?(z?y1_qd0A8p
z4fGFGk)&XW<`4eKGA{K$FhR?QdlMct7Zuojk&3y2n4g*o5^TNnfm#SqD>H*}?mzrD
ztf)J|@Ap)U4a3&dhos;NTxu5ZW(0LU_y-;}LqkO*^$r90jPC<%ucqz-3kguuH5AuS
zFLHxxt*DtB$`7d}A;G!UA1J{w^&~gAF5&~lrKI721V=<t(}SI<XwaZO8W9Ik(cnX~
z@v;4^?w|w8z0AEWS8E&=T&Ajj@{oGiFV~OqaPxci*YnpqEKB#-m!mnhIjslW`P{Yc
zkMr&K>y7{7vW)-pD^E+vE)i>xX%c~8nFvbC!6Cz%!1|C6vSx2CVk{x1ey*mTWQvnr
z)Z7h`4w|Wht`AB<o^c0))0w@Y4wKs%$`xuRs1E`#&BhE$#O&zk?1WT6!l<cpbNgVe
zyFvMDt7_zB=jOhFcPm*SBpLw9tjvVHLT-qf@knw}CVc_B?D%QAUSL@j5dnrb4HA-e
zPfIlDdqzt{SQ)`ab7~oqD2g?-`vbH1+Tz5}3Ic_LBTTIej2eWZJt>6NyADL0y+hpS
zJ0mcfc=uDG1JeY;xfYrz4QPTij1Tez#AYA_vP0_{^S1XnI#w`Ej!aCpZ+zgC>ml5T
zshF&`+p!*M(-+=;fBzkNx{r3Oa`IDgZEkXKa-ef%4Do_c(@5ur+=oAnkoOgLdGZAt
zZsC{z8D~A0>sx7ld$r0hm6^egl|IZ37<a(qi75qyVPbz~ZDp}>NBI16WUTY$oHK)T
z)Isq*8Ir35(%N>z#2(h&{U!f#=k3`2O_OdzMAON{%4+wnq2YAB`Hc$RjZP*z8Igq<
zdfQ5os%U(naF4sn9k`7Ri;rdr3VtK^G`DI7%tV6F0P>0ZcHf9C4n$~kePSk_Ab@QG
zCPjH}?vR6e;~7w~Sb7&qe8;DLGsb)Xq}JZk{=HXB0>07jMd#P;>aqO#x`RYI0C$JT
z9?FK>1i=D?uobE((Zzg~OFi5Rm(xi68@UR!of}ib`_TQmS1IIsVr_PL@@2dE`v!g$
z+p9)oL~wY@A-ScSjH;V<c6Cc5@H3IHqo?EOdgHCWbb$bxv~0v7C=2R6pgv3a=H@+u
zAw7*)cj=`7W>|zGJN~jA|Dt4Z{cw7aUOt8iN&OZ7=iT|}RTk-H{)r_#%*(p0Eqi_6
zd-X%C{FjM2+zqkrhcqNqY$}eR&`{it&Y_dr_vj}c^zQaKb~t6Uy$T2xz*o=L7p`Of
zHEX_Ii~n7k%FO($-HSFd10Uf60pPg`5WI!NXONNz_rCdI_~X5e->$!+!!$v~n}G2h
z;{OHe<>wdiYnof4CLr70dU6Dz!!6;?GVJd^X)Sp^=7-t4BptSE!A{MoxVAO?W64-(
zJ(W{CL-#V*N%W$DWOcm&TA~<yT@&XAmllfeUJu=4G1OFMDFr|67w~{Mbq_V~8~Sl^
zJdlmsH&p7`_(Y9`)gG|k2X3XPe5xdFxaBM2rJdgO&_mRId%4Qv0XGk#Ya;BNyb~U%
zi+>{(k_k~IhAe^(e|w83ZR`}DJ8N6rpgmrNj&5EWb>MrRz&x}7M@z_x^qc3&``E)8
zK-g_UW#vH-&M_k5ye=BPqt7HZ=IopgAq&Tq>(sPW{-=#Bmd2Hkzr*_0PiX2qrpVJg
zKQ-Bgity+m0obgXA+#g*6Tu0?(zxF-@D|lW>_R$jyv3uLy;_RCJ98YB4&!|HxmOC-
zChd{L_?<ss`ZddeOPdO@-OfMb-}a!-EOEb4*E-f@Hq$=*MqWsx@!gvvdt5=1Acvde
zO>q5+(sqG6R^D2s&Q<0o>e`K=A9|QQI4;TJQm#6^R#u9@Kzq1f&*w9%xjWdgqZb5v
zG!l|kFZ#(<NTgKWj+=9^s`POu<#e!8p_09Yh?gDbd_67)VxF~pgne{)Mt64Y<wCwv
z%i+XR6H?`r8o<-==r3OP89fCCG#?G{VL$I-)XIQZgC|)pXY1_-{J$d2Kah#@UX{l4
z#DuM9yx_)I8X;igbh8L6D^c^o&|w@#tkHRqd8x@@0v)(8aJkn`oPMe@3VL?ZuU~p5
z9DkROKyj-9$i4yZ4*ossSTM*m>Bdvs-fxDC<@hJD9eU5OTV>;IS+9HC?j>KL)f|7w
zoehHh8hK=o@h6@>C=`x~GEr_f+6aCpYoS)rI<z*U+r}*$D&z#OSnR!|aL^VKE25`4
z!(cdZ=Vv1uyXm0$+bJ-E!TR4ItZ%igdJiN;ZL`Y&rb{A2xe0bUJHm3s@86<^sE3FO
zmJX2+5#rmep2HZ?4UfC>f8h$7YMmrYzG^OQr|D0tz{ID)P4?oPUvuP8%cLOLHhrID
z(5X_r_B5!0qSWPLvT4ArQc57h&~nLH;B@tdRYdf9B}9xROVA9Tav3Ew$+Ht8ek73G
zo+vZ`n*76^xG3VCqc9XA*Y#Q}R=Bg#+AGqp7>Wx!OkXYkY1Jz#NZt)o<o7bUDAg6q
z-^gw$<DiSXeQQ!q3*x&#>tAp3YOzM<^<J~CW*aS0Kz&VXmKQdeS)2S;V)RX%xQ2Bt
zP#{uUsSNz<r3Th$K`q*CL+9|)%6@JbJ}*QMICz6I5=kZ!^Mk<bhv_sMvLF0Ku!dJ@
zjoQo}LE404Y06qvH!;>Uq>u*pv~8pMU152_vem`LAT&@&O+5YC+k<Ad7{UL~E9%V)
zJytr4bbSt!ub|^UHVdF>gHdRJzabQeZ!?kmKIZHV-%Cy2J~&Y~u%r>yxL!0W@k((F
z)KPxy!UTR*^6nn(3iN0d9k?0^i9cq!U7Bt|RwQuzSh_nYR8(SM@tyTn=6+h_?Zy3k
zz7w$bQnq;Pz2E!lsg_H1fj+C2XvbBO>NB%9q~u%5;CeOrM)GM;wNQ~;h<1kIpg`1;
z>{x+@s}aO|mZlqZz;gD*f`;`NhD3@MSQdpWmZlxcN9tHuarz_CaooCxm}^CMndFgC
zBpqCdUws`6$HaEsSNzW}OUr`6Ghe?CI$7`)LwmkqB)K844So@8mi`7tdN%XaJTb%E
zxRQz{PYJ3XCSVF>Q|^m-d7v9nj&Vy1<Py3wJzbI`!v1RIKhK5Gv{-ggRKjvv;K@u>
zo?=$!ik|ZNp0dwQo;{Sk%cw<phNUt~#v5`K&(UAgvDb(Zni|EZsMnAB75zYv4go_)
z4LcY#-M%)l{9ULPyD!zF4h0Hz(g*J^hg89_lJ{LaQl@vLs^p9tp?mx3+V~2}#_?TJ
zT)TwO8&T%1zQO_nIc@erJQQIP&~)ncUY%b=HAp(X7iN9wfLIprX}e=TPusv*w7*|p
zC1jyVRcU9@%1qf3pPah(F9Q?Io;7!KhCrJ{Zl&A}9s6J+JvOyNr~E4_`rjlx@`6eu
zPHp`__<EOLJ~CqO&7b;Qm)YU-76g$Mma(ToYzPee6_E6V!TLXLG<j0HfiG4)DvMlB
zw%3TRZP3bb_erCUpC$;UI1337y|386?fPLf@WfXTqSvh629Zibs@dvJd63nuQ5>Q8
zYv`G0Y{~X9W?X1TK<sMeo@vSadz<dD0O(xq1#PPOp(ZZ+qx&%sBbtM*L1~yA`LYLg
zcR8Pitc2}`-8AJM<`kJZfkSr{T?4S6X$!7LY@A>PyTt8j8A*AKu^{KTI~w%I22!%B
ziSV%#HkBrgF|poz|IhaI1dR$uKnskamh!>zwvCxa0(E{RJS>C~n;;kJb7SUxO7rf_
zZ(1c6steD?qpDZmFb<fK-;&cKnJPf8Z(ZsEJ>M;bR_{081lVH$(C!808joQV8Zi3_
zjH7*@!oXQ-QDbzaxEQa^7r9%>gr(OUC+~j>v0_Em;x6GXnxOr3sy<|*5?@?}s@L=*
z1aBcbOWHR)s_SdqbX%So&h+9<mgc6T{LQX{SIUX*j^E|A<9Ev@&Qpr2{whLkCI4u%
zI*8Jal!Al5oM?f20857NdyEZz^xtQ9-{%`Myx-HV`skY*!t`ph1(rKM&h<n5tj7{c
zge2ee#}v6}y#uVD<X!LSI<K`C0zIqgav&}B!<Odxcxn48#L;w{=y|xm$TnQN;y7RD
zVf7>A=eUp*qc3pATJN!EJChR_W$8Z{r6H3nTAFs>A_dZM0d`I)&sohv3%SFcvzIjW
z&cqDg;pyh{vb1Jred_Q<m^iA;49`vzA@LwPn+>eK*6WcWcl;TyAc=RMi90fZS$Qo(
z3K!{<h^$;o;!C+Ah8=4j`kfG0epu1YXyGWHKo0IuPo(PIS6he=&>^a$lX(#0qYNe2
zy$`bseaUEd1$NKNO~-7F95AaRQf)asWV$4_`4J5JBt#SL6~sa&yigc>&%xM*->>W-
z=)J;?&hm*|%`Fpt2EZPpzUjF9iTKv8mhJKbm7kD&WQc#kF8=HH(~rJ<6Hy%^;<IJg
znstQ6Q+wCmSQXxTZw%sI4F+W-(n?kiuvP>D@l+0YDS&3H!RGKkSQQ1lGyC&6W}}cN
zL$}ZwCe6<1l5%mhNu>#5O2eNG9r%5rsa0J9*%Y;F!PChyZ$dVb1B<aIJ2Vm!>?Pb?
ztr1Kui33mzh1*f@D<g*qBYNzF%zL!nTGRdRsH!&X4E8E5B`nlAG4p4^eU=5(f_|rX
zOg?-|3;<d@CQ7tFcra7t_Xe?3>ZPQ@tWsG%3*<#v!JCrcbg%T!k0+=2LV<CfS^t!V
zK>APk&{58Rad-Mig0ie2hmZ(*3#~dTmXVsDyoPI5Am7{XbFoF2LJ=Rj;v24Opa);q
zWS&iCphiq4QycG7pSuv$H%hEdk^%KNq;(`c6u|0+kp7Mjq?hvabu`NcjpBPJgd@&O
zPJmR!elb?W9#?%~x7d2=@oB-f$8-HQTjX)cB1@LL>lre1`ayJis_klZm7{t~qp)@M
z71xv+Sw_EK_VZcJ+u6DHdy+NogT`j82D-J0?8ZUo_#!eDXzbF8HNVcsK-n4*dK~4v
z8@QrSCkYW`!DEwI-TQ1qI0{>LD^?PVz$d`jwDc^EFxT*CCc(*g|D`ofnjF%D$XkRi
z!1RF1Z5a*jqKor7x~<_(#)w{;tUt&UTT|t12x}(HjpI)^%{G)*w9GVFJ@KWf)CQ)M
zcjB?Y^i0=xJ%d2hbAn&ZSYd{g<U<6((147lAFGs|L)X6%Y|&2+U-B5n*OUCZbFX<<
zimx%cc{VRLAK}$N$Qc#gN=|k7zl;zlv5`B!F+Uoc(qqhb|HacN`Nb$hy<&YqT4}$k
zVXcGfwB{FE{c!%*emvP{Dc3-WNPzI|kME@nQkPsp_O4!WK+aydW0m8|Zl|xoK_=i+
zpVw4cay14bo?{5jX`!Xnr&rT>T8<m2Db9<5m(VtW$<6x|j3-q}A-y%rp&Wz-^~Jq1
ztO`|4{{~T6-3B~70)qg)gZN`ljN1L(VMCE(1fHGS`oteT?-q;3@ghtoM8R7l<;rh;
zQh13_b|w%;V$NkzTuzO!TNzTVMh3VZ02>4#L{3)oy`y|}+g&Iry(`;?mHILjzlb5g
zU?l13!2?}YS8!BlbeQ4`>q*a>PR<xnY8+sAzA3Ru4$Te`*S=JzfKU$VRKQGVRz+*8
zf03j%59Qw(nmN;*qR^nB@;;w}knVoz{Mj(uBjL-I?BcO;8SE6oNNnY9U=6hArvfxo
ze5pG54hPoT+avvSrcyQ`)BVO`jaC8yKE<am2=(~~x~h4|)LmApSTT(1b^E=!!hny9
zid2o-KPL+n%H)0b&IVsm%u3cdQsp{^!2@;JFI@@XsT@z4iJ-vCd=>>4!C#M>YApTZ
zdZ-BKzvxkj(MCseA~3U$>;aov7%?2g9Bz$gN~xi|UnAHwUx%t0r^w<1lb2wi<wuSe
z6Pk*mkYYw69J|pa##gdzX7Of)p7ILql|X;@VQ<nUznDdL>E(Dz6Y33jHYj{EuUMxw
zX_D~t(y84E=i^Y!TP<69dF=IdIc+<%<*hCuS-OC!4(-VhD2u=<cLX@e+MRl)Bm#60
zW?P@{5E^~39O0OKnIgKND@>fR+B>r}7^md}U(t@b#EJmPImd#)XDPaAn)90+FGXHX
zeFxlJ-OQdW&Bu6~3Lw)g6R$*bqB&q^a0H+{%zg9>5PdueFcZ+-Qt3x>y-6zgauv-X
zU+u2j8+;#*!B>{)1Q=y3cMS9Am`X7e%I;Ds6I7*Qk%y^%L8!ijZs!Q0J1o5Q(6=#R
zbl`U>rAiEhB&AW<)`XnfYiRF3L#9`?!tILwrR4fLO79K{kHfkAIj{u+JZ<umb+MK(
z4iBl}D>r1gPIBp)4ip!)F(12|IwJEbKDzBwz#oyMsOFb-0)VPnyUPv_C=)|J_$e)e
zdr%p~Kx?z;lq^C{&M6UfHlnkEo-F(0!Ba(c&G13UnJGAEqo6eYv)U|fHinmWR()u-
zoVD-M5X_5DANGsvXJN!r6u}XaHBz$kS~^7{{<UIRqprJF-e-A}kv!rCDa|&qB7%3=
zRRUSGeALtfDIgrotV(%1s9t}Mz978$?F3!gQ`4+QbXir67QSLDcFUX17W>Dk1Hrwa
z%oq6lSp_Fb8Fe0te@{+18`+XDj7QGr_$b{JPj<&B`VsNvu~qRfHVpl1igLLun9=Sp
zi?55S&843+xvnVVh5BddGOPH9WR#+z5^@e1v9^rro&eZy2S)9SC==<vJ2qPw8s;zg
znv|brg+5ptx8sC`?YLBKmaK=o+LWAG{$nmZfrcqDv;l_wFjr7`zXPIQX8yIYebYcN
zl}^mij;)v1jB9@u{Y4a<jUsXev)Z{!pT_+;lA>PJ)Rmqcx6m<E0MFiSlz8tujB%!d
z+2@ehe^vlhgo;G_x&<lanKs2y(0F<kyZ)tI&&qx2XT3X1UmG#DI+hrr%zZ>n7S9Lm
z%s7f4+Uc-uxxzZZlc033@<sJqc@{7{v3#ECtZ9L;72E8h$h5Q;TyHKoBtf4n(W{*Q
ziFD8u3S%F}twSR5p<X<D(e!m=MXP1_91)&F{TG0ixl0*Q=6VWofl-`Uf^%Ktn&(cx
zELro4%gZ0Wum;MV3~Pb^_1rtuh~z5dZh~_Lu7kSt$q2@H)bS@&{#)_JN#Q#BMPka<
zE%}nrH(1SSc_I7E&5T!RJt<NXEw?hFsP3TV?+b<AS`vkQOahdVj9$yj0DCIUSBMw_
zzyhFf!?I**6?TwG&r(*%wdHpzbTAWnJG9(C>Lew9h#)8zPw0QEhtegT50JATEepAR
zadn~oq43E<%1KiSKdTM8=i)>00Y9LV=d7A<ng(@`huXB}OM5j3?6wD-1R>&F@?+yv
zZGR`n;do@S#uhsrB93S4s_cZ*!1p*EcSa!RiBR;J;3*YV0^BBTXXYUgA%3lUT6$Ci
zZfZreoI*<K``s8|d5ujAAITg0hI6K>lcw}3ZckD&hYLM9U)l)T#|Xyj7gU=-o${1D
z!Y7Qb*Ug8b4Ji#A@#1{ax`sU|C}%Qjt*LKhm@xsQ7tM%AyS1+|P7RKC>vR>J#WjFF
zmwGWlOP9j;hcI&KegrxYa(^zQ((9)_4D+R7ev;e}PNA{INSX+Sbv(K9`uQoO<^-bk
zPZ@&0RG|aJ1BV<rqkO(ok+b{`yYK<mLW+unoKoNMiVm~~-)}i{!U=W$M6Y5g(q?1+
zxp^NN=If2A3(sV$g}bW->`z1&k(UCBm)((e+0WrwJLAGlfx5cWTCB%@WbqB+RF}k+
zuzE=1c*lRZF9=3OT5*nD1<WIv;rta7c}0Z`Itf*5$_X_Mk4|R(HIJBI!LW*?o6~r}
z^ilA{cjt<&sAcNJ-M<Xhn|3gXR-@;UP+qn$F~0xP;Mu%8`aEC{X{v`&_l^vxY~VXq
zJD~<1kiXJKqE~umWFXd)jq|VD@1$D_n^EvxB4Yk?**vu+3rxFek`*75Ym%l@HV9^o
z_DxXR<n*~rj61Vm^|fuJFpZ|N30Ixt6sV=Z*ctGZ#Km|2e9|K43f-_HS@?%+SrZW0
zDx_FL>*XmLCG=Ox9`9QJjI0H0A6bTci85K#c0s)9ChE4JxY+zEOoj;=DbNC54U!aO
zkDdU8(gYv7w~cMP3(bP&1dvfE%=FiC$v4K<rD)@wr9Xa-8{WtcJP8w0`)4no^dwp%
z035SRrkdGeoA%e&MP$0;mLr(#vc7tvSNNZkZdws%2_xnm#3vOh$WVdiExZy1vI--E
z%%unx1^6Eat70L&*+ro%pGQ~3gB%1He}4sQ{dD`9)@Z>w-ASxv2mXG}Dp3`GPhj?I
zyV>HaUfs_wqHjLbZo~t>cw4Y8)T1{4eT~NE5b1^Y@bHV;mXq&%*|yU9tz%TBFqeX_
zUdbM#9{p-Afc^2FD~Rt0Vi3*?l$>XGM;aSj;E%LDkUE)f@K^NZdt;)+#UHyv+ypjL
zWy|OK^=3p_NSJ4@BP6HrGT?ot+ujs&8WE7gB<*eSZIhVW`;TT^&-c5?sTk5YAP;9m
zO(s+n-_ePa$vPCXn>ez1s~@Qf!ebmt?EZiUYhi>@VU3HCv!HGP!u)r=rqG@kIuI`j
zH)P|+gukDeFxMad)d|P%Jy7+M1HoK~?F(W-5T|c9yMrzB=m<Hf_pe)DhKg$O=?rqP
zZe>yf92x}k?Z5f&iH-2bi)MJi6^i>@cFb2#caM%v<u$)7HuGQ5`82RtSwVj59p*Lh
z78^Ts{B+3-oyHdr%(loo^8Wo3YJ0YgRFK=4oX4rSGZ>k!|8vg{R4sMOS|pN(c@C^u
z#+D-W>zBm~AZ$Hqf_q5}*J{o`JFu(1?8n$X6xG<aO?jDYAUajuql-1R`@SD)F{}AZ
z>Zj!oq%o84E~Y1mPb}?VRYRM}F~O{FbC#`(ZX~29p4)_c$cV2pw`p!CFbYXa5$EeF
zkS-3T&D8^w8Z3FtF;N@`$?5XfUiR{X^n@MP#dk4jcw+@-9GIv>>%}q>jO0h6?n|W-
zRKC#j?Qa%7f==T`Ev0wZM4q4txA^h44ueH@(yZdZ(HxjAxwCqnz`nlCk>`(PbSsLK
zx!G#ndFe1fwvWPK#e)w2582xA9hmIme!Yl{h%uQZ;LLdIC0WZwbQMA+#J#0D%tt2P
zpZT6#8Qm(yQ)g!-*fW1MJ#AK8_n9LmU>~mnxlDPJ!SgHau97)T!3L|~AIVaWKWyv#
zn`I#eyT-Vz4sbIO#N+4ArF7J7ZLw8qU1v*&w9&_a-rrhi19gbJ_FvaqC9h*?$GFcU
z2<4f^i?k7|a9ZJ&tKZE^iu7ZXbHx>ohAnymAgT<nOf-Wh^{2hb|De0?xZM)o7P=qr
zrwWfBu)UfcSr46v<}Q=A>^xv?Od9~pNA6D_P0#i~tT+g>l85pQk_kBl9E0CGTM@=9
z2gm@RH0rkbxAHo!(E`;%V%>(&KjK+*c)ybGRwvpPGVKdZeBZtMQ8j)fOM4jOeT^>a
zkc=KQSUDiIs&e-i#H@#HC7%E-wE4!jl=`qct>>M&-hOhDKuZjV(qI@#D|+;F`isB$
zFQrXHBVz<f`8~`bAvueGJNq+=s3Z35t;u!|5V{BZ{s^}OKW2%Q`2;-|>$Um#{|bBW
zc&h*Re>^LD@4ZhMarVe4BO}R3WM%KYXB{G;BE+%x3?+nY5m_M;AuF>Gm6?2>r{1sE
z=jHg_Zol)Fb3L!ebzP79H6GXVd2^oEggMFAq`2uTn7+{1=q=fw@f?bi1#izQKJ-@J
z;h-p4uZ0+@g2+fiuRz=kq#^9Lc>T`mj^x+}g~t(N%5E$@@V&mtZXp=<xGsx<qtUDL
zP2U02_L@&oGQagrHRW4I6GU!lZNFI!Dyf^S?_gi%w?|Hxe$DgP6&mL{E4$1YevRi|
zaElck)9uH#C{}og9AzjKgCJ$MhB(8g`R7_nO*0S6h1?2@guXt{mHHrO?#D8mRuTC6
zfc5H%klHw{j_H*f9_d(IL2Bp>>v^+`E6v)0wX%be#-5qE-LcFLgFKMx_M$X>vNM*4
z5yNM&BBH*99~_^n^4~g0`gAzES^xU`^&Fd1{0Su&bLYt)LN0TRMsm$iBj(rN1y<Qq
zzx<N%wL&zx&qF()TU;gTRE-(QZS1opGLK=}NFT;hfkak@wr1gLixF3=Twk^IcvcHb
zCX#E{de*BLydt|D-?_wE(IQ`}UUp{wY;ECSJ{@*jm+a^{dZf;aOC(`{?FO08RVh>m
zd}O0!z?*GxXRw;P3>|Cu^XixZlbmT_PU@qx#=+i~Rs}z&Cfw0Any*gGU#jzAx{;)I
zbMj6XojXmHM3<VraVGO)(l+19OA;TSN0<{kKxkM$?bQ#9mr8~CvQkS{B7Qfyi|Z6k
ztuB&d_o$OUm$<*PF%HxWQRzrkTGveV4rbj8j)|jNEo-`iu|>&kCat|RS9ADyBv6v<
z!y^%w+PnHP#bxb_k@Fpv)<Qe;_3!W-J5w9fr!?iwNtJBl$c=|nB#0V1c-~fQgh~!-
zIz5g`A71kqT>SPb{40+p<9x19b|2`w-hRnJBGz`{?2Hi1H)z!2{W){7H*GCexvlc^
zoK|KkGwxE~?gmI)@EH|xh>!1nZ23Z~xgqp!T@0gmkfWz311Chdrd9IEu4Cq?T=UiZ
z@cyf?YH+t^h4S*H&(Fn<P@K#`(wnR1M-a1j_l)<SdRR?1HQtYQy~oK~P)~o5ZuX#Y
z{f9Jm=}cqix%{S)hC8L%#UnVHEw5VX?v#0z(?r6DxAWq4leru0BiYS5mt&vlh@Hj6
zZfmX|P-`rU$fhLjde>)I?UI=xt&<95EcAE%=lONMzz=O7a~0jYBI}p*cm<9_Z46fB
zJJ~rZF6N@PKHWg0I3K$je+gH8r6p~&qN>=1Z3t7*$aLdMH^XHV@_Uw=+*VggP<P^W
zv!CnrM?I}fNSgf_(L>d2aa$tKcvE4^p4@4djE1MXLDS6M@3N=0=J>lW%Zd{dj~o3o
z*dMXo&h^bbLm4&3z52fW#~aRRh6kl<;U9y@vGTzkI&=c>^dRV;!_sHI`*k<m8gguS
zLWFf?yO5vw#p~$vR^a7R^v{~0!<I2rFyG?jic2=}J1RwPQfUQ`LdC_R?~tNLU~5V<
z)4FMH{bt>10%FNyOKvP3U$cbzA+YI)Z5GBBt_rOwO-+M|%tMP*t<&_vEa8PCvIZ7e
zAF_<^cVNWbo=(@EZ6Io{qzScLW4xZ+mspQoZfwHXzHTh1j~$r(q<2$hW$nC>JIj;Q
zib=4_;l~NK%^ArZ%BKO;#4HTaTz1%?yTdi=K@~psbi~+e<oDa<lOjH>UK3xg$>O?K
zxqAOGd?Gc$!NPQ}lWWZ5lDJ3WqAk^gc~Hv5TXyVQZ(5!j+%~AZm+D-!7T<4B_4+^|
z0_%65NT5&l)PPlp2!#D;i0i3jmD^Zh;O(zk;d}Zzsc%vhr6MO9n96%87dht1=>-k4
zh_gT)(wQ&HIX!i*Oh?(PnW8uaY7!CxgNw)#ARi3X*pQY^>>9b`QZI^y>cmFZhwAMc
zT|yWl+$29-TIFRd+VK_+c5>%%G@^Bd-NuqU5TgQyGIg#T{^BQ1_NwT}emf)FnN5S_
z#EkncjWScdu(~Yas3|e^y(yy7zv|<3pUJ_ms~hxQlx}Z#6pqCE8%(Smzx@nAm#Y_=
z34F9kyvX3BYSYoO@HpM)Ch+Uq+E=Zx-!W}cj+aNDOXpuG+l(1F*t9J=>f;O;?4){y
z{g|oosF$P9C$CpyKazPC<%@WE_J!-`q#V0APwy{R)8}V=@+!;XsLb{<8V7#Kl$&~P
zlNI;)v(!|toQ@ncP`9g&<k{6vn_n?3*3G4G>wosJVL+&GdltS&^U>E?<-SkqT-nQl
zZJ(8Ol!pB>+HtsJn~Cow>B~V(=>7hYZftNkE}Xv1*E2FoWfIw{7*HFsKcO^|dI2)n
z>hxRg>IM&`kG6`vWuK4w*LnV?!f3NknMGafKMJ?tR%SLC?*2(p7O!c?f|<yOzZjQW
z`3KZzE`4I?`P~Xjwxc!txIWb{K>uK?FZwyM*kq+M%2)VcpY{4tnY$PL-7-hT*X7u<
zf*CheI>s@X+>6YwzAdx4IUmJK3s-iiW>|z=8}Bkve@<m`UYy4gA=OaNDFgl#`h3h7
z?)r_Ayw96AW<&T|fQ6C6mggGpO@T5a1F-7saPQRXgAt0yxY&Y-VnG|13|Gy$po}||
z_TlY_p(0V?JVS%6ELX$83&Kg($%qfwC~}SO&UY#EQqNGlpR((jFlomQaV&TCW%ooT
zS(RLimWWAA{M?~q-cYM;2oKCEvGM2)yQQ>FdBDjj;4)NpMNg_>BP~l$_}$N$EQyHP
zZ1o({@OQ>b5?6Gy>pXEglAE%H3ngExnCk4`KA880asQ?hC-dSH<1J(4>7JY~!~XbH
zA$KK)PH<eTLZWE!_Za^+jhwjxkJ_CHqpmMaidpZ5#x)jNcp08bvdY|Hn0c3?X1cc;
zIQIzj^kSp{R#1FpvHkOcJx3jAa+!~UIw7KGD8EOv<xJ;;lvIV#u=Hd~hl&8!CsOOS
zpBN%BhspAOcVqo7-}*J@ajC^Q(qaSaF0ZOA<_8Yy;j1Q}axW}cc;F}`y+y8^T!NzS
zzUx_dH%V~BW<8*!o@Z@hJLK(`Y`Nk3JheL%gQqf*bG6hMex}t8@9;-SD#$HPUHNsv
zT_yXbuEN*k8u3TI8$^s|LJcg!#C&aA8Uyq@R<|#`PmcTQH1e6PV&i}osX!(iitXQ*
z#)?iC_{hBUd9hXiCd(qyEIu6r{>9N`$~n~=IGr$WGo7I}KeeQeE+5>ADSZ(|i*-(;
z*-917r|>?z0QLK*I8;&6MI%d+(9^Q==+`Xdl+!IWY{OmA$CvfQjD$(vL5M4VZdd6@
z6fb^K)J%Du$$l8UDPD73mqDi^WD6TE9{-9Z#QUDu^GH_zexH1r*kUSe&AIz&>xxTB
zQh7`bV+r?^u3?_ngtKrKSoX)>3Rxapd9u|*_v-V-gvXf7&p+0lUM}AS(M-};1x_!R
zMv^g`DKEfz?>&azzmvZ{?b@6d#Td^r{g7hLtL>K3xo=8hqY!<wXjEFYipiZUtix$1
zl2ZSL-0ri^ep_~-ydkx+jJn0$pwjNOi#z<WmS1R$CMFf$8v88yDRlA_dWL+;Pk8tY
zZLzBSd*y08W5wLAR9xov>j_~-De&DnKJ$&YVQ~8dsf5ppVXgWH<+wb@tZyP>b!&qM
zS`KE^@hdTVpbs~#7s6xe)7WokpT}AbaK|Np)u`N7r5=p08>n?DOqqRb?xOj6p)rMp
zE^}s%s_P6r@p;E_#s@P^*1=HE8qTD7_q-KTrBAC*RQjJftfegkwrbRT?q#kHW&(G3
zU0rQahyX8$?ez<~#%7u@g})mQud>*En|$jw&kRTHVsU!na*_-r7WXZjlr$9U;zNsT
zl>U}7dD)=aCI7eVJ;8Y7HP^B+>b&ZL;iD*0nfY9!w6tmF05D5S8b4-`y_FAoq5F%i
zD)elh+vUja{Xi}Iq*|*Rx7)!wYp+1#G@T=DB7J_()wXO@UcwkYk~~?}7}A_Ab_-1&
zxpS5~wX@wX>u@Cz?7d8qL0zGZ)fqug_1j<JJNn3I<i@E}O7Uo)zg9U-qtRp6&XTT1
zRj%uDA(h<9Y<ofNi<V`yw;H92Zs|pjk5BI|*_{pSd{D(NxgsR(^@VrH)ZPOgi}YAh
z9qsHa)=GThYE0Yam{nr8)c;+Ls3t6Bxb!rW_BoX+3eS5BX3uzf%{FQ83}TJmC6~Lk
z(uu8rR7PU&PJXT`xbUtMp>%=uko}rQvio^7-HVB*#OdptV-c;p_sL8S{Haf?X+lE2
zxshe!iYc2Yo!~F+TLM1Q`cER&)oGTsY?(dDULVXRB-^vLMG0TEvFY)kSpVQ-BxYz=
z)cfXzjN|(iNZ;`8X!0&rUY{LX(LODGqnC(nO<(J&=*47JkHdx$-Z1wP(6d0wJ;rw}
zZQ#{t%7e0*r-up}+Km36!YGG+sDw4RpBnlY%H&IW$=>_Y6n`dBsZ5Tz@ag*pHs`X}
z_mu;?or4(f%sDczM(1kAcM;Rdy}{({zHdixe!&?Hy^5Lt704jl$$!&}3%j7%EdI!9
z;SF(@Y6D4sqov%f?&c<mV$mmQ<~Nb=HE9$=n!jc6(rqAr2c8qFlAW4LB+tP8Bxye1
zV{tuyP}%fmtBn5U26Lm?g?^eB&-g9Aq|Lm={_<xjPUpV9`LxtM0+{c7U5!oXJ(V~5
zO`c-(G`Ov<glYbe%F5`&dV3YNkmjiV3;o2dF=|P>OB>lg?0C1#K_CPo@%+k_Q|Aq4
zLo{2e1R0-jx1mj>l0d-$tMWk~TErArw9}Xkjk&Z`YO+xUT}zFQ&wHuQ^J3cO{kt5T
zGT!5|i<88!-)fvgB-yidkQnJ27wD(TX4ziQ8eCG+aU2nAgU~q?-h@2G3bPL?6ZdfI
zap}7}u6SQWw=TpnXnW07(%9vVP=2G_!yL|l6h%Hqd)|r5*EF}%xhpiwX8Jy}pBe7+
zb^qS5-+L)fki6LW4x1S7uitAbkn|rmexW+8oD|Xf8DdPIEo7_RSK}8pCO1kb`L4-u
zIAoW_W+TB<cI>30*KZ_t%VB%AhE<;Sx?KLHXgE=4>iR%8k~{G9&EFR&N;J$2?&bzQ
zVbp}r&L5Qcln3WjG2ZY_!t8dOlR>zJFTgAh_JnqnN1IzRnGKe;be@@*q;hQbrN(S<
zU^aeKk2V)A)L8`%1eAE@4DSf$hNlxx`USYZ*I+Ba&W)K6*N^tG9LQsLwPkXSl+`r9
zS2>c!$04tT2GSlePWs%Iy!w7-@m9lPzJJ}Y>e=yi_M-O0j%T&u=Kf|EhNv`BS)(IL
z8O<bobYGr=Ji2|S??8UbIgm2%$GU00fp1{9G0F%tUs|uih8dOVef_h7=U{U|R+d?;
zuJH^+%$!@Qrr}1T&5vYHEbVJo?e2*kqwJkEnh}|{?@F(mG}QfGJ7*Q&(-Idm6qIGA
zjwOQ4(sL!5xSsN$i+q%4Jlj#&?Xx=gbG*<|K=xU2@DXH>Q`h%wHTOnS>;dQQcU%?Z
zgVV%EJ(lw+2_zrRhojEQ5{DoDzS}n^#>Aw}WVt)^sBc43@27$5p*D8(OLCB5u*P0A
z%Uy80#}Gp4(yJb8mz4J`8*z0vu^d0N1b^On@WY>h-6Wma-h*M~{7N%!?#6B$tKN`d
zS6S1`{UXhd{5>%{-$x17x9|1p$FT)0*V>%_B`D6pl6-Muq5!d18ZBP->vG=fIiBL3
zFFh|uCG+dT2A0BvmVVc*Vbxqtk^54h9(De7v6Yk;;q7sRsfF-a|L(v=G`*kv8Cyfr
zZ=p(dx8J^k>r24LkWSdQ=vL=w`7QzFWD=vqhde6h!xaOF558KcTec%sd9(AoR)#6>
zyyr+piSK7ybJh8@T+eS2X1iEC^un|X)NUcqacaF0c5&R^Uey0}WgvF-2Uvs5kynQC
z?&97Hrmushd@tW4Y;XG1U3zpdPg!ryp9uf(Mb3d}ebO!CNAA0CUspTW?mU8X>Ip^j
zSG>Bg<ij8<ZglE&If%CdRqLE7cbhlGDj{C_$~|WdK~Ls~Jj31W>f3C5jZItL5mpYV
ziRO++8MqGir?mZiFXF#Fz*3$mD^ic5Px4zk-xr)@Gr=3{!pi0T!S?+JOb^e2g2~NL
zY5H)mrQ?m5`Y9rc&`N82)5F^(ZxD^wdKS<2Q#>(I$bInOLG#kMSt;56x3q44CJuEd
z&$W25s=H(#sOPP|f4N5+8K?U!=KE?YCZOX*o0%Sb5BpeKr0BGrhL<xoRbDJAXggxF
z&-b}mdbpgV?$qnlyYI0-B9?4U_uHkN&hVMFjaIvQP3zpnf*i7;Yb(;CJx1)XhIKdF
zmd)SAajn=Oo|}?3x3_o|-9l*3m3M-_GCw!Z=F|}FG;BMsyDF2SVCWiW9ATjLDuyia
z_KZ@B)zI8QKw4FK>y$G46m}}P>wDn%FBOl^-ShM3G~jNoAg>6suTnEw@#}3VHzYO=
zH1Er@^D!liYJb*}+JK?=HWl}7)%#=*3(2?lL)Eu+e)O(v%%zq7T7wqFH<2G^H1^#J
z6A>DB_w#)@Qtqa|TC1NRsPS8We9?FZZBqJt#=7Hu-_|_Itd!$SssT1UT1aK~cJt?w
zt%~lL6g?*0>W6S4UI&YEF3SPc^*4&8eLrdJZ&AvfpILC=E?fDmqt;XOY_m|}=`Hev
z)n1;P&K$NDL5_OFz3!%ounPfm(qJ>XCYsN?j_s}vH?dZNqH%3vR)-NV%f{CF-Ps__
zGimudIp;%urivsUHK@8{nUa8)EH7OuU?!jbwHWODOFn2+Gh$WWzlMV&SSXcF5s?qC
zj*@-FUQ{4R`SFRy+ODmloUmd3CzkFzPl{+)Lr96)7UIr)Vct>GmVa>jN1tAu;nbMD
zA;d_w^C^|b>;6p<ndku;=_is;N@75IUu$Y|r<b@%RcK=rZCI1iwXu@XSv?%A(am<x
zQP<%uv6i{ptrVh>2{LLbKKK0uLy~kw-3$GpC5CEo1((OwUG3Q$L%mj2&h9N+9;%&}
zH02I7-Po$p+USP1UX!xVI8@>Krk%kGyiQyewHu>5d<6>2uYB2KSDD3ysOk;#Ew5#J
zf3f+sU=XeLZHbZ}L!wySYUM_)=D@X__V~#rMwX|ycxiL8pFi!F?s_{qEt!h@3JdSj
zZ{}N^gJmlq*}@P9`{~}RZAv7*l7rujNUsjITXWoa%IGUg9yX}M0aD~O)byama(#R+
zD>@7ETRX~=NbFzeUfda|lW%NNesNEAobOtx|Ivdf>mpLPc<C$b@VBRCZ|ZDZmikS$
z`tP2KnI5t{rCU;idgUM=?sA!e&2HL+PI7hW%%edXn_(AehW9<fYZv5q8ndReh!U(v
z_a)Fp4I9%f3)IRtA6n7h%(_K8`SH6%Ofmh}`vtOl7Wt>lqB72Nsh7(zTL@lcz07_l
z=eww9RWO!2B6G~d>LvCC1J3_}q(P0m)R5CXy%d}E!=1V8)63^mcOP@@v*`xNSCw?_
zDbi#I4+75xgWO%*coNsN<k43-3ZP?;8p2D<ZJZF7N&7r+dJbI{L+)IC)->*DlwZG?
z79jMyzq?}cV#`hMp^Xb45nPY9+jfKN&)9mhnUB-9L?#C48tN-xc`bIf(Wm6N$5=S~
z)ml<T!qKlkRwR`=x<(f+51?Xa)iV<_GA#MXO3udIZ7%d7o0U=BCh58H@Po5CjqRo`
zwM8o9+Y~9T1;4$07RvK-i3wzH;A~fE!c3LVe}AX<iSfH0Ijce>!!pV;*la|pIFYpj
zE@x6*83^+pi*mRXg&hf5*A+1<k?Z-6$l1Vk-Du*Nmx|Z^*1R9FAH4hG+-B~xd&;lI
zydp&ntk!BLJ-ouY4nAivQ-1kMmbxc+v_Btr=wclu$H!Rx(tA-{SNiN^aD(~-jVg`Z
zUf>n2<wZ)Jr?wtBx^MUzc2+qtX83+;v-wa76ls^EhwDzZY(Cg%cUzNStDj-t7iY(Y
z%VvJ8mef0+8iSJ2=Q9+Xp2x6^%~#nDuE~A=nq1ZKvQ|?nX#2glY#+Ka-TNt`#$Chk
z+ni!pfBf&anO$+@p+&=!N)j__?E5|st$P_kJeQ>WgMQqbd%$NE?AEk)4{Jxg-&*=@
zQCR*+LwuO-z^m{&HcIcaj@UDb_tx*EhYSl|M9`(RHJ_F)6BsEZI{2czx_nmBClA-j
z&-``I&uq4#_`^11snOt+kAhf3i>QGh)WD>1FadY_x22K{b#rKT8r9hzkCa3nFy)8&
z+EY~3TjE5qRK{OpRNqB0@R<DWpGV|P^-z7Crn)m{SD5O41La&U%+)^6g_74ke8b7-
zB<D8qYht8oDU;>-*4k=7(o{NGz7k7usM$gp#Ixx%WH_TzfT@|(r6oOSLC?Y?<BeEX
zF>8a|YBs{!xiVzPsM0doXSVIWfeqQIU4(-6jBCa77`b8=<0JYEkoF-iCqje;m+)Lf
z^0cPzWi?%8TpSyS3m1+PV8RI-h?e1;$U%a*bpugaTxg}p8D<FZYTW;OWiA8*1tb5w
zGnWhs2E$SKpAXgg+z>4%K5gX5)YD^Bd)8R=vOI|zZEdYjil{Ov)~K@KibdMA1_;wf
zSI#DQVL&-54a*9vEc^gp4R8-YmIeD1?y$e&vrD1;<qF=%{?e??_YmnE-nh>lqA;DE
zAYs#X<d^eCN$sdGqwX&GRDIOx#Dv#Rcy&c>9bXj=8jZbv^x=uhX0E-Ej@j^ODp_zn
z=LJSrjkPgNufmSihuFxUsM77bL?%ygvL7y|bKf&!TQsUwt~nIdqe+=ew2$f!&HfPJ
zI^0p;R<kl1g$}LRy+3)YjcwD@k6+K`v#?XH*^V5ud&#a_j}vGh`NoTi2K}tJWwc%!
zi3c$=3Q|hhb**ab@}I<w6%OUPcM_>x;bbq(DO67*9<LlNHUSSvTi@_GhaKvsIX01A
zk9lM7JXHNHkup$1tLaOnMg)_qMR87E_#Ml|#}W~Fj;fvxEuB^Gb$--24axB-{d#$@
z_jr0xN^anLp%u!!DVHSA^Xautwo_{{=5&azClGDo*sg9{RJwV*C`>)KP2Ml<9GAAl
zM~x*4mBX5M&a7Ot*w}}rzNN3sQ0G58u~rOUnUgy#;JrANW)N4)Zeoh=5EdaC5re8$
zH&S`<Qt*WTh%PTl*%PIr8k*uSE_!F4$ITY8)Y8=J>pL{6DxF*4pB6P~B1I%IuRr%X
z`9NmDXZdl)h|tck(GB%Jlwo>wl5c?B$jD4%S@IjjVI8ZIR_yqE;oU&0T;tM!)G2)j
zqgrFo1N$7^=YBMN<?P#&arYi^k`GCT48(Wz@vo-!%`v6IG6b|kRBciQ8!HjcpRrlV
z3V!-6pA>W$NKU=+S8nHu*C>pBbh~s<Lw58OG|9VFrndr3>mN?hHv2h&iEEtO9icJz
z>!<OPYjwt99d%fb&W=uIjhgoH`AOPC8MV0f0n8c3(^=gG1Hyv^uCC^)%-!C4cFp{Q
zK?ff5BM)<Urle^XiO*#C1__dG$zXB|9Z_aPMMV|D?IePa;*{m*c|5<6z_t~*_PWyr
z6$%6Hr`0}F#a-y-6Yx^>qt71b%FKe4|AxTUY@3$*_HD4NIRE7=xrQb_ElZ0yqWYq(
zn~^%{N0*)EJ*c$yRRimE?<pfNUV1-t*HWWR<DvPoxNC;cz;@lCtD?!sEA%hc(840Z
zJ^QjuD<1i0Mmy+QUBbiml!=F8&w23Vw(y6LQhl(Fn!OL|@xtb)pK}W}9$IJd-L6w+
z*yiGVRn>&07rCryMxsQrG72dQvl-hOSQ+kY=D>X9Pxz7iV@cqbU}XQ2;0I5?jRZ6<
z*!I(>M6+a(;&_g8W#mb$JjNsw-JRkc7%(NXb2nGaqqH%z&~hV|SVw)8%+Am9HGUVR
z&r*rH68VxViSE$e{~hs(9p3Gs7vRnJWt5AZaf26y<&e({rl<pYfK$8eMaj!t1D8<E
zYS*|N!bV7aHBSl13T_V0p4nXS8JO+Je=qUPVC?Oag*V9Qxah7oOzGX}SB|QMqEKKB
zb`zbwbB4kn89e;2pl(0e>7u;QT6ZBfo}#wPNJf}=21DEmDdJ47X=67n$a$6bUF0-G
z9_1`*f_+v_tXZ6g?%1i?e)hB#s?IaBEFl^${&unmw-OS0k;<WanvNm9!_3^~!Nb-U
z;m8;`SMU_cGpkQZ1H1kYc?FvHUc9Zk^^<rweV;a9rf%kzdwug}BJz6dTa%b6>uXB|
z*=Rm1iKqwYz}GcRlv=sNsibaxr}VT?=T1+M(RN{Ly$Zoj(W#`sOXQbrGp(K`e7tP_
zW7!>h9sZVXk<3ey;y0B*rjDmb1Di)yQ7-!WmBK`o_~`Gt7beR&m76}!9++o!Y=*p3
z?G#pAF){4YbBeuj?yVchqs-ajsG8Le7D0E^v039^>2hg}o)KqfJ9T|!{t>-Hd9@_f
zo8cfUER20Ymu49DX7u6dBum~`A)VbO-L3jnyv+>{#iSo+Z+g?SIkK3HW$cIiTv*OI
z$FIcu)?GBa1s60nXE_bq8+d+QFHhv|bsdlFMNXZS{`(v*y;4#PETQ$Rac`OfQ*Lr(
z#k@0PLw7|@xH?+O=2K*<&qkzVmRxBT^F~R^RAZGbQ*9(241ANRw;#XRxRZZ_^87ou
zjZ$(2mJ#z&`;O|=N;?ZQ<Fyu?CP~5|3hb$pY(kl*cb9B=;EZ>kzVxP#JDaV7P_grj
zgM;e)#p1IysLqL-0^n~^LNq;n!>Q)Yw@hsu{Vs*(K2yLY6?jAID_nkB%RQrH*YNM2
zeprb;Tk5Ty$WW&G`&N-k2%{oxGsy-I4&wH{;11DGSHs`CQsJ9$Dr#%8+Xr74282?k
zq3k)AuJ!bhq|1qfF(#)P^NVi2bw8qQll}QBXwlXDmG2|w*Kh3|bF}gv(mJJ2{fM?o
zWTLGY^aj5Ji5ZgE^ySh3V|&t=T%lMhVqT0CcAKPXNM9pu+ePc8xQqom1}Abw@Xh18
zSKxClesKwDVNm7Wxx6u7UCo=RzaK9Derei$7?&fmhh&J+c$m%ig!yBTcc6HLZ2Q&V
zUyn$PT<ViIY-R)lN=ZC|##D%unp%bmkyo|lUT8;BvshWQ6-V}=?mtvbd9M8U&D@&m
zauha4#O02`EAWo<PaN5b($$<z7l@<VgfF)dH|On55(bK(wqlzFEw#MwFQ^%vB^gA+
zlBW*+>Y1{oCEAMno9Uc&%@@^{z!Gxhlqx!x`zJY<Lx72&?z(o$p6bkFhFTKD^qKEl
z9{4G=OLx!rXm+MI!k%y(@tHUJL1oU3Hm72re9b4KkRIKUkRYzIDd%`^xG3?;Ca6(4
z9IPKQRKU1F$^1ytqK6+wR*$vutS$cJI8JNjVsk_PE?9K0js00Xx`Vv2ui2wz(f#Vr
zBhGQ6%zM-no)sw!ZQ5hA(<7u|yr6K^iLMT5(w?$%=$SK+wek*Gzh7f>x6-@cCZ(uh
z!*LlF%y-5k6)8cXRyVzT6_A%d@W*qG->a$;QMq`@Qv7PO=j$8Z&#7287_A2jE?%ML
zuv*aEH{hve(tjvvPu$x{N^!;p7bWcu{2y3@9=ZI|t$TR|zHzDx?c23imUmTt+N?ij
z9~k&<nYYZuHgejj(nIUn-g1w69Gkw=0yTG?2BU$40I7?eyz$uvn&wiXbu-qIZWs;8
zE$+Xq7=E0?X``!Z*RC1i6xe~03pGWeyL2|vHV$_7-qJQM))rp&xW;19Y23F};1}RM
zuSHAbam#|D(zUsyAa^31s<0>%F$94Fod!XOP_<^KK?X!5z&czdIp_?|o&p5J(NKT{
zh!D7Q6d(y;_Cy&qND-Gt0pcTuqHqlW4R?bA#DL480yxDeL3}s~3J?>nmjXnOlcWJr
zGlL<227mnDlnFR6D}fpW!PQcN_;K|VAV%C0C5Vd(gZYOqLE|D<5*<hYr$PmAs8IqO
zaugss+&Be@26vAh#FW5l$n=L{1kW&vXK<na%Rr0s2EGzu@G7q2tf>G~P_!UgTqZS$
zmI#Tv!vYw;P7UJ4ZBc=kaeOo&PTT@u@81OwTo4Vgfe>n7RVfY7)}m=Z$~a0|fSra0
zprL6&?6@cRt6*vn6!(}GU{1kbaHR)S;LRh3KylNwAak53EkM?x17zf}1Li3)0_Z%W
z13-gga07GzXq*fHXv}!f<miD-T%`NE32yx45<0-hUV4xa?k%4Bn;ygsz|X}1Quybs
z0u~H_U=w=a;sXW{C$MCn4y1(hWd!W`3gGjHird349%KY*;{q7~8k7m(1mmtS0oGA4
z0+*VYKwQAm>%c8Hj*A(vA(0Uz!9+Me1P1@>ts*>!023f+j2Xm@drbqNjQ)EG$pYvt
z#b2^z0Zc{VbZG&R9e665`R@WQ912)~yR<IA{Ks*+tbnvGW`G1Zj-CcdC2inf?QQQR
zfI;9gSV1nh>ny-EZZ;4%GkydLFgNCstCgFzgR7kY1PE4jHjv_f?mxtEb1Z<KKHyG-
z1@ga1f5-Uu*#PYRFG)mk?yLa6KRbwv`S1L{<Khe0K^{0tHh|?U2Z)me@^?<kah@Uu
zkPt9?j}({531UV5Z~mT!gSD4{@gI=_5Cq<E0SJCzjjjOfPZkKk{#Yjf|FbDm+%7YS
z?_VLx$ArNDC>22b6^8gL4DnYO@~<%DA77dNXMhU|3e4JJ#hXNlfKy3pTX@>IdIKgL
zlZ^b6XaeZJ3ebPQVg6^4rm!ey0+%P%9~r_Bz%hUK1o?Aa0P#nX0P2rbe>CG7^+maH
z)m(tPei?}J;pVwO7bxLSFa!!kL7_MaZV=ahzFy@9r4plIxK(ZtHwO%Z-vRz3;3`1%
z=MOLpjlke|c|gKgGz10((E871;8*DoBnmM5I1RXu1YjYc!C=6?2xwpgp*$1@j)&nm
z9|VpsMOXqN8cw(v4MyUfdz=pnh5|_ahX(wKfuc{+ASl44$NAup|E$IS1q6bG!U1m|
zV}u|fu#*B|c&q=z2L)h30MHW9FfjOW#Q+}$g(BobV<BMpaqj@|gCY3&O9V<VP(nTw
z1_?dM2S%Ob!$5#YIxY`|!RN{!{QnILC=>}fZXp;9g(ASm7lXkN<R9N17l=l}kMrR-
zf<l}`3yM$lf7br-KNyMu!;ZrRC`Mxl0uyfx5Dovg7!ZPo6^uN-7Vi=mK8OEN@;^S{
zp~x{B7*L8OjD9>33OQ~ypawvTFc#nt2#Syo4gsSG;|K-}FglJZ9vRGERDu2f4}QGW
zC^Vt(&`=;h39N>r3H=E?<Uyms$JYWh2>gUG2m}z-|B?3xe*^*nJ`N$U7z05N3PeJY
z$m8h=1|y*e0w06H2n70s(MaH#)CqYQFcw4T6C@O<7XPsj??e;=c49FK0XexA13y6n
zvgt$|q0tz8#Ropvf8oc2bpkFlz(R-&3UQ(m0&BsT<H!I$hC&H40t`kYAb-*h5c}8d
zc>K`_82+fifBsEHGy)DjE)dU$#?KNv&Ic67<1`>(5KzMU0np$CDB$_f2<-6)28cij
zIIb8^1Mokl7>eI9{<Qp$F@I<T<rWG7Y$0$Ro(7bzziYAoL_Z)9hClC)2?Pv04i^|$
zjE4WGe&fqGKm)>qU@dTnokRu+MiU@|1*#DkC?O{lBMAx;o)1Hi?*I*QqRs;}6hW5Y
z`Ot(XC7y<aVF?riL^L7%NGOc(fC0`cB=UHc07{@}D4{!%Kz;jfzT?qC!qES282h&+
z0Eln|ln@0ZP-%|mEWn3=5gtSU4Rs<2k;oG#B?JjD63D{>tp@m{g+PuS&j>&<`h-8>
zC=?vuQ5}mJBpOY4^g@sr*vZXd5J0;BJ%9cULKFZGK_Ed;VDyRTM*;0IAzDEBAnXkw
zD4+}wW(f)k^j!ZKjs4S+K_O^39N$tO+X>JM!3c931H+sUh=D^1{SNd;Cz=f?7ziT*
zc~GGL024+l6apN+1i=LbaQXkBAx_X>a14~dbx@!n5u6b~X@o)00MdW({|A162q!pt
zf%XFiIUx`M^qquCfQ-Q31OFF6D3B3I0(U}@81#Rt?VtV+=%In?O1Kyelq7;^1w4la
z|LeQIu7hHLuIVHVL+DNz-X#R6!oXM<m@trlP6I(`3_v41^Pw;(P)7-32B0Ab>jDgh
z$ND%j01e1RfQHBaANXN#ppp_qD?mFDn1G8>aDwOuXc)p&gdtET@*SX||C@?<{ZJTC
z%LtkcfQAC5q7zsRwAutmG!%wHqX|zo7#fKH6Ydy|L=l#B7zTv}j%flVK$}ijtASPz
z=md`Q0k;t+3lb1<gvh{wN)09`%W$AJ{taqi|Np=bhl2r+5-33e2OFVcK-@pa=f7)#
zY{%an|2O)9oxxxPC;&A0v0$YH;Kvh@NL;@-hzE;?0kdP>-0*j^KtAA~2&lW-x&hw+
z!~T3z7BH5DC<0N7yo6E&D_v4iP*B0BTtX@$6wyEvbP0}DR+bm||7S53ke8?O^0x5w
X_V={0rNSG5g2BkCL`5%YsZjkt5A#38


From 27b2ad5a14612d815aeebef58079706bd22724bc Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 16 May 2017 09:45:02 +0200
Subject: [PATCH 017/329] [spec] Execution: conventions, runtime, instructions
 (#467)

---
 document/binary/instructions.rst     |   32 +-
 document/binary/modules.rst          |   73 +-
 document/binary/types.rst            |   18 +-
 document/binary/values.rst           |   26 +-
 document/execution/conventions.rst   |  131 ++++
 document/execution/index.rst         |    4 +-
 document/execution/instructions.rst  | 1062 ++++++++++++++++++++++++++
 document/execution/modules.rst       |    5 +
 document/execution/numerics.rst      |   54 ++
 document/execution/runtime.rst       |  539 +++++++++++++
 document/index.rst                   |    2 -
 document/instantiation/index.rst     |    8 -
 document/math.def                    |  161 ++--
 document/syntax/conventions.rst      |   37 +-
 document/syntax/instructions.rst     |  188 +++--
 document/syntax/modules.rst          |   52 +-
 document/syntax/types.rst            |   52 +-
 document/syntax/values.rst           |   25 +-
 document/validation/conventions.rst  |   48 +-
 document/validation/instructions.rst |   94 +--
 document/validation/modules.rst      |   26 +-
 21 files changed, 2256 insertions(+), 381 deletions(-)
 create mode 100644 document/execution/conventions.rst
 create mode 100644 document/execution/instructions.rst
 create mode 100644 document/execution/modules.rst
 create mode 100644 document/execution/numerics.rst
 create mode 100644 document/execution/runtime.rst
 delete mode 100644 document/instantiation/index.rst

diff --git a/document/binary/instructions.rst b/document/binary/instructions.rst
index 945b391e8..fb64b6634 100644
--- a/document/binary/instructions.rst
+++ b/document/binary/instructions.rst
@@ -37,7 +37,7 @@ Control Instructions
 
 .. math::
    \begin{array}{llclll}
-   \production{instructions} & \Binstr &::=&
+   \production{instruction} & \Binstr &::=&
      \hex{00} &\Rightarrow& \UNREACHABLE \\ &&|&
      \hex{01} &\Rightarrow& \NOP \\ &&|&
      \hex{02}~~\X{rt}{:}\Bblocktype~~(\X{in}{:}\Binstr)^\ast~~\hex{0B}
@@ -77,7 +77,7 @@ Parametric Instructions
 
 .. math::
    \begin{array}{llclll}
-   \production{instructions} & \Binstr &::=& \dots \\ &&|&
+   \production{instruction} & \Binstr &::=& \dots \\ &&|&
      \hex{1A} &\Rightarrow& \DROP \\ &&|&
      \hex{1B} &\Rightarrow& \SELECT \\
    \end{array}
@@ -101,7 +101,7 @@ Variable Instructions
 
 .. math::
    \begin{array}{llclll}
-   \production{instructions} & \Binstr &::=& \dots \\ &&|&
+   \production{instruction} & \Binstr &::=& \dots \\ &&|&
      \hex{20}~~x{:}\Blocalidx &\Rightarrow& \GETLOCAL~x \\ &&|&
      \hex{21}~~x{:}\Blocalidx &\Rightarrow& \SETLOCAL~x \\ &&|&
      \hex{22}~~x{:}\Blocalidx &\Rightarrow& \TEELOCAL~x \\ &&|&
@@ -131,9 +131,9 @@ Each variant of :ref:`memory instruction <syntax-instr-memory>` is encoded with
 
 .. math::
    \begin{array}{llclll}
-   \production{memory arguments} & \Bmemarg &::=&
+   \production{memory argument} & \Bmemarg &::=&
      a{:}\Bu32~~o{:}\Bu32 &\Rightarrow& \{ \ALIGN~a,~\OFFSET~o \} \\
-   \production{instructions} & \Binstr &::=& \dots \\ &&|&
+   \production{instruction} & \Binstr &::=& \dots \\ &&|&
      \hex{28}~~m{:}\Bmemarg &\Rightarrow& \I32.\LOAD~m \\ &&|&
      \hex{29}~~m{:}\Bmemarg &\Rightarrow& \I64.\LOAD~m \\ &&|&
      \hex{2A}~~m{:}\Bmemarg &\Rightarrow& \F32.\LOAD~m \\ &&|&
@@ -181,7 +181,7 @@ The |CONST| instructions are followed by the respective literal.
 
 .. math::
    \begin{array}{llclll}
-   \production{instructions} & \Binstr &::=& \dots \\&&|&
+   \production{instruction} & \Binstr &::=& \dots \\&&|&
      \hex{41}~~n{:}\Bi32 &\Rightarrow& \I32.\CONST~n \\ &&|&
      \hex{42}~~n{:}\Bi64 &\Rightarrow& \I64.\CONST~n \\ &&|&
      \hex{43}~~z{:}\Bf32 &\Rightarrow& \F32.\CONST~z \\ &&|&
@@ -195,7 +195,7 @@ All other numeric instructions are plain opcodes without any immediates.
 
 .. math::
    \begin{array}{llclll}
-   \production{instructions} & \Binstr &::=& \dots && \phantom{thisshouldbeenough} \\&&|&
+   \production{instruction} & \Binstr &::=& \dots && \phantom{thisshouldbeenough} \\&&|&
      \hex{45} &\Rightarrow& \I32.\EQZ \\ &&|&
      \hex{46} &\Rightarrow& \I32.\EQ \\ &&|&
      \hex{47} &\Rightarrow& \I32.\NE \\ &&|&
@@ -211,7 +211,7 @@ All other numeric instructions are plain opcodes without any immediates.
 
 .. math::
    \begin{array}{llclll}
-   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
      \hex{50} &\Rightarrow& \I64.\EQZ \\ &&|&
      \hex{51} &\Rightarrow& \I64.\EQ \\ &&|&
      \hex{52} &\Rightarrow& \I64.\NE \\ &&|&
@@ -227,7 +227,7 @@ All other numeric instructions are plain opcodes without any immediates.
 
 .. math::
    \begin{array}{llclll}
-   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
      \hex{5B} &\Rightarrow& \F32.\EQ \\ &&|&
      \hex{5C} &\Rightarrow& \F32.\NE \\ &&|&
      \hex{5D} &\Rightarrow& \F32.\LT \\ &&|&
@@ -238,7 +238,7 @@ All other numeric instructions are plain opcodes without any immediates.
 
 .. math::
    \begin{array}{llclll}
-   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
      \hex{61} &\Rightarrow& \F64.\EQ \\ &&|&
      \hex{62} &\Rightarrow& \F64.\NE \\ &&|&
      \hex{63} &\Rightarrow& \F64.\LT \\ &&|&
@@ -252,7 +252,7 @@ All other numeric instructions are plain opcodes without any immediates.
 
 .. math::
    \begin{array}{llclll}
-   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
      \hex{67} &\Rightarrow& \I32.\CLZ \\ &&|&
      \hex{68} &\Rightarrow& \I32.\CTZ \\ &&|&
      \hex{69} &\Rightarrow& \I32.\POPCNT \\ &&|&
@@ -275,7 +275,7 @@ All other numeric instructions are plain opcodes without any immediates.
 
 .. math::
    \begin{array}{llclll}
-   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
      \hex{79} &\Rightarrow& \I64.\CLZ \\ &&|&
      \hex{7A} &\Rightarrow& \I64.\CTZ \\ &&|&
      \hex{7B} &\Rightarrow& \I64.\POPCNT \\ &&|&
@@ -298,7 +298,7 @@ All other numeric instructions are plain opcodes without any immediates.
 
 .. math::
    \begin{array}{llclll}
-   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
      \hex{8B} &\Rightarrow& \F32.\ABS \\ &&|&
      \hex{8C} &\Rightarrow& \F32.\NEG \\ &&|&
      \hex{8D} &\Rightarrow& \F32.\CEIL \\ &&|&
@@ -317,7 +317,7 @@ All other numeric instructions are plain opcodes without any immediates.
 
 .. math::
    \begin{array}{llclll}
-   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
      \hex{99} &\Rightarrow& \F64.\ABS \\ &&|&
      \hex{9A} &\Rightarrow& \F64.\NEG \\ &&|&
      \hex{9B} &\Rightarrow& \F64.\CEIL \\ &&|&
@@ -338,7 +338,7 @@ All other numeric instructions are plain opcodes without any immediates.
 
 .. math::
    \begin{array}{llclll}
-   \phantom{\production{instructions}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+   \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
      \hex{A7} &\Rightarrow& \I32.\WRAP\K{/}\I64 \\ &&|&
      \hex{A8} &\Rightarrow& \I32.\TRUNC\K{\_s/}\F32 \\ &&|&
      \hex{A9} &\Rightarrow& \I32.\TRUNC\K{\_u/}\F32 \\ &&|&
@@ -380,6 +380,6 @@ Expressions
 
 .. math::
    \begin{array}{llclll}
-   \production{instructions} & \Bexpr &::=&
+   \production{expression} & \Bexpr &::=&
      (\X{in}{:}\Binstr)^\ast~~\hex{0B} &\Rightarrow& \X{in}^\ast~\END \\
    \end{array}
diff --git a/document/binary/modules.rst b/document/binary/modules.rst
index 4431f1784..bd20c8be7 100644
--- a/document/binary/modules.rst
+++ b/document/binary/modules.rst
@@ -40,13 +40,13 @@ All :ref:`indices <syntax-index>` are encoded with their respective |U32| value.
 
 .. math::
    \begin{array}{llclll}
-   \production{type indices} & \Btypeidx &::=& x{:}\Bu32 &\Rightarrow& x \\
-   \production{function indices} & \Bfuncidx &::=& x{:}\Bu32 &\Rightarrow& x \\
-   \production{table indices} & \Btableidx &::=& x{:}\Bu32 &\Rightarrow& x \\
-   \production{memory indices} & \Bmemidx &::=& x{:}\Bu32 &\Rightarrow& x \\
-   \production{global indices} & \Bglobalidx &::=& x{:}\Bu32 &\Rightarrow& x \\
-   \production{local indices} & \Blocalidx &::=& x{:}\Bu32 &\Rightarrow& x \\
-   \production{label indices} & \Blabelidx &::=& l{:}\Bu32 &\Rightarrow& l \\
+   \production{type index} & \Btypeidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{function index} & \Bfuncidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{table index} & \Btableidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{memory index} & \Bmemidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{global index} & \Bglobalidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{local index} & \Blocalidx &::=& x{:}\Bu32 &\Rightarrow& x \\
+   \production{label index} & \Blabelidx &::=& l{:}\Bu32 &\Rightarrow& l \\
    \end{array}
 
 
@@ -69,7 +69,7 @@ The following parameterized grammar rule defines the generic structure of a sect
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
-   \production{sections} & \Bsection_N(\B{B}) &::=&
+   \production{section} & \Bsection_N(\B{B}) &::=&
      N{:}\Bbyte~~\X{size}{:}\Bu32~~\X{cont}{:}\B{B}
        &\Rightarrow& \X{cont} & (\X{size} = ||\B{B}||) \\ &&|&
      \epsilon &\Rightarrow& \epsilon
@@ -98,7 +98,7 @@ Their contents consist of a :ref:`name <syntax-name>` further identifying the cu
 
 .. math::
    \begin{array}{llclll}
-   \production{custom sections} & \Bcustomsec &::=&
+   \production{custom section} & \Bcustomsec &::=&
      \Bsection_0(\Bcustom) \\
    \production{custom data} & \Bcustom &::=&
      \Bname~~\Bbyte^\ast \\
@@ -123,7 +123,7 @@ It decodes into a vector of :ref:`function types <syntax-functype>` that represe
 
 .. math::
    \begin{array}{llclll}
-   \production{type sections} & \Btypesec &::=&
+   \production{type section} & \Btypesec &::=&
      \X{ft}^\ast{:\,}\Bsection_1(\Bvec(\Bfunctype)) &\Rightarrow& \X{ft}^\ast \\
    \end{array}
 
@@ -143,12 +143,12 @@ It decodes into a vector of :ref:`imports <syntax-import>` that represent the |I
 
 .. math::
    \begin{array}{llclll}
-   \production{import sections} & \Bimportsec &::=&
+   \production{import section} & \Bimportsec &::=&
      \X{im}^\ast{:}\Bsection_2(\Bvec(\Bimport)) &\Rightarrow& \X{im}^\ast \\
-   \production{imports} & \Bimport &::=&
+   \production{import} & \Bimport &::=&
      \X{mod}{:}\Bname~~\X{nm}{:}\Bname~~d{:}\Bimportdesc
        &\Rightarrow& \{ \MODULE~\X{mod}, \NAME~\X{nm}, \DESC~d \} \\
-   \production{import descriptions} & \Bimportdesc &::=&
+   \production{import description} & \Bimportdesc &::=&
      \hex{00}~~x{:}\Btypeidx &\Rightarrow& \FUNC~x \\ &&|&
      \hex{01}~~\X{tt}{:}\Btabletype &\Rightarrow& \TABLE~\X{tt} \\ &&|&
      \hex{02}~~\X{mt}{:}\Bmemtype &\Rightarrow& \MEM~\X{mt} \\ &&|&
@@ -172,7 +172,7 @@ The |LOCALS| and |BODY| fields of the respective functions are encoded separatel
 
 .. math::
    \begin{array}{llclll}
-   \production{function sections} & \Bfuncsec &::=&
+   \production{function section} & \Bfuncsec &::=&
      x^\ast{:}\Bsection_3(\Bvec(\Btypeidx)) &\Rightarrow& x^\ast \\
    \end{array}
 
@@ -192,9 +192,9 @@ It decodes into a vector of :ref:`tables <syntax-table>` that represent the |TAB
 
 .. math::
    \begin{array}{llclll}
-   \production{table sections} & \Btablesec &::=&
+   \production{table section} & \Btablesec &::=&
      \X{tab}^\ast{:}\Bsection_4(\Bvec(\Btable)) &\Rightarrow& \X{tab}^\ast \\
-   \production{tables} & \Btable &::=&
+   \production{table} & \Btable &::=&
      \X{tt}{:}\Btabletype &\Rightarrow& \{ \TYPE~\X{tt} \} \\
    \end{array}
 
@@ -214,9 +214,9 @@ It decodes into a vector of :ref:`memories <syntax-mem>` that represent the |MEM
 
 .. math::
    \begin{array}{llclll}
-   \production{memory sections} & \Bmemsec &::=&
+   \production{memory section} & \Bmemsec &::=&
      \X{mem}^\ast{:}\Bsection_5(\Bvec(\Bmem)) &\Rightarrow& \X{mem}^\ast \\
-   \production{memories} & \Bmem &::=&
+   \production{memory} & \Bmem &::=&
      \X{mt}{:}\Bmemtype &\Rightarrow& \{ \TYPE~\X{mt} \} \\
    \end{array}
 
@@ -236,9 +236,9 @@ It decodes into a vector of :ref:`globals <syntax-global>` that represent the |G
 
 .. math::
    \begin{array}{llclll}
-   \production{global sections} & \Bglobalsec &::=&
+   \production{global section} & \Bglobalsec &::=&
      \X{glob}^\ast{:}\Bsection_6(\Bvec(\Bglobal)) &\Rightarrow& \X{glob}^\ast \\
-   \production{globals} & \Bglobal &::=&
+   \production{global} & \Bglobal &::=&
      \X{gt}{:}\Bglobaltype~~e{:}\Bexpr
        &\Rightarrow& \{ \TYPE~\X{gt}, \INIT~e \} \\
    \end{array}
@@ -259,12 +259,12 @@ It decodes into a vector of :ref:`exports <syntax-export>` that represent the |E
 
 .. math::
    \begin{array}{llclll}
-   \production{export sections} & \Bexportsec &::=&
+   \production{export section} & \Bexportsec &::=&
      \X{ex}^\ast{:}\Bsection_7(\Bvec(\Bexport)) &\Rightarrow& \X{ex}^\ast \\
-   \production{exports} & \Bexport &::=&
+   \production{export} & \Bexport &::=&
      \X{nm}{:}\Bname~~d{:}\Bexportdesc
        &\Rightarrow& \{ \NAME~\X{nm}, \DESC~d \} \\
-   \production{export descriptions} & \Bexportdesc &::=&
+   \production{export description} & \Bexportdesc &::=&
      \hex{00}~~x{:}\Bfuncidx &\Rightarrow& \FUNC~x \\ &&|&
      \hex{01}~~x{:}\Btableidx &\Rightarrow& \TABLE~x \\ &&|&
      \hex{02}~~x{:}\Bmemidx &\Rightarrow& \MEM~x \\ &&|&
@@ -288,9 +288,9 @@ It decodes into an optional :ref:`start function <syntax-start>` that represents
 
 .. math::
    \begin{array}{llclll}
-   \production{start sections} & \Bstartsec &::=&
+   \production{start section} & \Bstartsec &::=&
      \X{st}^?{:}\Bsection_8(\Bstart) &\Rightarrow& \X{st}^? \\
-   \production{start functions} & \Bstart &::=&
+   \production{start function} & \Bstart &::=&
      x{:}\Bfuncidx &\Rightarrow& \{ \FUNC~x \} \\
    \end{array}
 
@@ -312,9 +312,9 @@ It decodes into a vector of :ref:`element segments <syntax-elem>` that represent
 
 .. math::
    \begin{array}{llclll}
-   \production{element sections} & \Belemsec &::=&
+   \production{element section} & \Belemsec &::=&
      \X{seg}^\ast{:}\Bsection_9(\Bvec(\Belem)) &\Rightarrow& \X{seg} \\
-   \production{element segments} & \Belem &::=&
+   \production{element segment} & \Belem &::=&
      x{:}\Btableidx~~e{:}\Bexpr~~y^\ast{:}\Bvec(\Bfuncidx)
        &\Rightarrow& \{ \TABLE~x, \OFFSET~e, \INIT~y^\ast \} \\
    \end{array}
@@ -352,13 +352,13 @@ denoting *count* locals of the same value type.
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
-   \production{code sections} & \Bcodesec &::=&
+   \production{code section} & \Bcodesec &::=&
      \X{code}^\ast{:}\Bsection_{10}(\Bvec(\Bcode))
        &\Rightarrow& \X{code}^\ast \\
    \production{code} & \Bcode &::=&
      \X{size}{:}\Bu32~~\X{code}{:}\Bfunc
        &\Rightarrow& \X{code} & (\X{size} = ||\Bfunc||) \\
-   \production{functions} & \Bfunc &::=&
+   \production{function} & \Bfunc &::=&
      (t^\ast)^\ast{:}\Bvec(\Blocals)~~e{:}\Bexpr
        &\Rightarrow& \F{concat}((t^\ast)^\ast), e^\ast
          & (|\F{concat}((t^\ast)^\ast)| < 2^{32}) \\
@@ -392,9 +392,9 @@ It decodes into a vector of :ref:`data segments <syntax-data>` that represent th
 
 .. math::
    \begin{array}{llclll}
-   \production{data sections} & \Bdatasec &::=&
+   \production{data section} & \Bdatasec &::=&
      \X{seg}^\ast{:}\Bsection_{11}(\Bvec(\Bdata)) &\Rightarrow& \X{seg} \\
-   \production{data segments} & \Bdata &::=&
+   \production{data segment} & \Bdata &::=&
      x{:}\Bmemidx~~e{:}\Bexpr~~b^\ast{:}\Bvec(\Bbyte)
        &\Rightarrow& \{ \MEM~x, \OFFSET~e, \INIT~b^\ast \} \\
    \end{array}
@@ -425,7 +425,7 @@ The lengths of vectors produced by the (possibly empty) :ref:`function <binary-f
      \hex{00}~\hex{61}~\hex{73}~\hex{6D} \\
    \production{version} & \Bversion &::=&
      \hex{01}~\hex{00}~\hex{00}~\hex{00} \\
-   \production{modules} & \Bmodule &::=&
+   \production{module} & \Bmodule &::=&
      \Bmagic \\ &&&
      \Bversion \\ &&&
      \Bcustomsec^\ast \\ &&&
@@ -451,7 +451,7 @@ The lengths of vectors produced by the (possibly empty) :ref:`function <binary-f
      \Bcustomsec^\ast \\ &&&
      \data^\ast{:\,}\Bdatasec \\ &&&
      \Bcustomsec^\ast
-     &\Rightarrow& \{~
+     \quad\Rightarrow\quad \{~
        \begin{array}[t]{@{}l@{}}
        \TYPES~\functype^\ast, \\
        \FUNCS~\func^n, \\
@@ -464,11 +464,12 @@ The lengths of vectors produced by the (possibly empty) :ref:`function <binary-f
        \IMPORTS~\import^\ast, \\
        \EXPORTS~\export^\ast ~\} \\
       \end{array} \\
+   &&& (\begin{array}[t]{@{}l@{}}
+        \mbox{where for each $t_i^\ast, e_i$ in $\X{code}^n$,} \\
+        \func^n[i] = \{ \TYPE~\typeidx^n[i], \LOCALS~t_i^\ast, \BODY~e_i \} ) \\
+        \end{array}
    \end{array}
 
-where for each :math:`(t_i^\ast, e_i)` in :math:`\X{code}^n`,
-:math:`\func^n[i] = \{ \TYPE~\typeidx^n[i], \LOCALS~t_i^\ast, \BODY~e_i \}`.
-
 .. note::
    The version of the WebAssembly binary format may increase in the future
    if backward-incompatible changes are made to the format.
diff --git a/document/binary/types.rst b/document/binary/types.rst
index 33e5188b5..fde083402 100644
--- a/document/binary/types.rst
+++ b/document/binary/types.rst
@@ -18,7 +18,7 @@ Value Types
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{value types} & \Bvaltype &::=&
+   \production{value type} & \Bvaltype &::=&
      \hex{7F} &\Rightarrow& \I32 \\ &&|&
      \hex{7E} &\Rightarrow& \I64 \\ &&|&
      \hex{7D} &\Rightarrow& \F32 \\ &&|&
@@ -43,7 +43,7 @@ The only :ref:`result types <syntax-resulttype>` occurring in the binary format
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{result types} & \Bblocktype &::=&
+   \production{result type} & \Bblocktype &::=&
      \hex{40} &\Rightarrow& [] \\ &&|&
      t{:}\Bvaltype &\Rightarrow& [t] \\
    \end{array}
@@ -64,7 +64,7 @@ Function Types
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{function types} & \Bfunctype &::=&
+   \production{function type} & \Bfunctype &::=&
      \hex{60}~~t_1^\ast{:\,}\Bvec(\Bvaltype)~~t_2^\ast{:\,}\Bvec(\Bvaltype)
        &\Rightarrow& [t_1^\ast] \to [t_2^\ast] \\
    \end{array}
@@ -100,7 +100,7 @@ Memory Types
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{memory types} & \Bmemtype &::=&
+   \production{memory type} & \Bmemtype &::=&
      \X{lim}{:}\Blimits &\Rightarrow& \X{lim} \\
    \end{array}
 
@@ -120,9 +120,9 @@ Table Types
 
 .. math::
    \begin{array}{llclll}
-   \production{table types} & \Btabletype &::=&
+   \production{table type} & \Btabletype &::=&
      \X{et}{:}\Belemtype~~\X{lim}{:}\Blimits &\Rightarrow& \X{lim}~\X{et} \\
-   \production{element types} & \Belemtype &::=&
+   \production{element type} & \Belemtype &::=&
      \hex{70} &\Rightarrow& \ANYFUNC \\
    \end{array}
 
@@ -141,9 +141,9 @@ Global Types
 
 .. math::
    \begin{array}{llclll}
-   \production{global types} & \Bglobaltype &::=&
+   \production{global type} & \Bglobaltype &::=&
      t{:}\Bvaltype~~m{:}\Bmut &\Rightarrow& m~t \\
    \production{mutability} & \Bmut &::=&
-     \hex{00} &\Rightarrow& \CONST \\ &&|&
-     \hex{01} &\Rightarrow& \MUT \\
+     \hex{00} &\Rightarrow& \MCONST \\ &&|&
+     \hex{01} &\Rightarrow& \MVAR \\
    \end{array}
diff --git a/document/binary/values.rst b/document/binary/values.rst
index b2abed9ff..8a4366501 100644
--- a/document/binary/values.rst
+++ b/document/binary/values.rst
@@ -19,7 +19,7 @@ Bytes
 
 .. math::
    \begin{array}{llcll@{\qquad}l}
-   \production{bytes} & \Bbyte &::=&
+   \production{byte} & \Bbyte &::=&
      \hex{00} &\Rightarrow& \hex{00} \\ &&|&&
      \dots \\ &&|&
      \hex{FF} &\Rightarrow& \hex{FF} \\
@@ -49,9 +49,9 @@ As an additional constraint, the total number of bytes encoding a value of type
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
-   \production{unsigned integers} & \BuX{N} &::=&
+   \production{unsigned integer} & \BuX{N} &::=&
      n{:}\Bbyte &\Rightarrow& n & (n < 2^7 \wedge n < 2^N) \\ &&|&
-     n{:}\Bbyte~~m{:}\BuX{N-7} &\Rightarrow&
+     n{:}\Bbyte~~m{:}\BuX{(N\B{-7})} &\Rightarrow&
        2^7\cdot m + (n-2^7) & (n \geq 2^7 \wedge N > 7) \\
    \end{array}
 
@@ -60,19 +60,19 @@ As an additional constraint, the total number of bytes encoding a value of type
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
-   \production{signed integers} & \BsX{N} &::=&
+   \production{signed integer} & \BsX{N} &::=&
      n{:}\Bbyte &\Rightarrow& n & (n < 2^6 \wedge n < 2^{N-1}) \\ &&|&
      n{:}\Bbyte &\Rightarrow& n-2^7 & (2^6 \leq n < 2^7 \wedge n \geq 2^7-2^{N-1}) \\ &&|&
-     n{:}\Bbyte~~m{:}\BsX{N-7} &\Rightarrow&
+     n{:}\Bbyte~~m{:}\BsX{(N\B{-7})} &\Rightarrow&
        2^7\cdot m + (n-2^7) & (n \geq 2^7 \wedge N > 7) \\
    \end{array}
 
-:ref:`Uninterpreted integers <syntax-int>` are always encoded as signed integers.
+:ref:`Uninterpreted integers <syntax-int>` are encoded as signed integers.
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{uninterpreted integers} & \BiX{N} &::=&
-     n{:}\BsX{N} &\Rightarrow& n
+   \production{uninterpreted integer} & \BiX{N} &::=&
+     n{:}\BsX{N} &\Rightarrow& i & (n = \signed_{\iX{N}}(i))
    \end{array}
 
 .. note::
@@ -99,7 +99,7 @@ Floating-Point
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{floating-point numbers} & \BfX{N} &::=&
+   \production{floating-point number} & \BfX{N} &::=&
      b^\ast{:\,}\Bbyte^{N/8} &\Rightarrow& \F{reverse}(b^\ast) \\
    \end{array}
 
@@ -118,7 +118,7 @@ Vectors
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{vectors} & \Bvec(\B{B}) &::=&
+   \production{vector} & \Bvec(\B{B}) &::=&
      n{:}\Bu32~~(x{:}\B{B})^n &\Rightarrow& x^n \\
    \end{array}
 
@@ -135,13 +135,13 @@ Names
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
-   \production{names} & \Bname &::=&
+   \production{name} & \Bname &::=&
      n{:}\Bu32~~(\X{uc}{:}\Bcodepoint)^\ast &\Rightarrow& \X{uc}^\ast
        & (|\Bcodepoint^\ast| = n) \\
-   \production{code points} & \Bcodepoint &::=&
+   \production{code point} & \Bcodepoint &::=&
      \X{uv}{:}\Bcodeval_N &\Rightarrow& \X{uv}
        & (\X{uv} \geq N \wedge (\X{uv} < \unicode{D800} \vee \unicode{E000} \leq \X{uv} < \unicode{110000})) \\
-   \production{code values} & \Bcodeval_N &::=&
+   \production{code value} & \Bcodeval_N &::=&
      b_1{:}\Bbyte &\Rightarrow&
        b_1
        & (b_1 < \hex{80} \wedge N = \unicode{00}) \\ &&|&
diff --git a/document/execution/conventions.rst b/document/execution/conventions.rst
new file mode 100644
index 000000000..81d1c9f27
--- /dev/null
+++ b/document/execution/conventions.rst
@@ -0,0 +1,131 @@
+.. index:: ! execution, stack, store
+
+Conventions
+-----------
+
+WebAssembly code is *executed* when :ref:`instantiating <instantiation>` a module or :ref:`invoking <exec-invocation>` an :ref:`exported <syntax-export>` function on the resulting module :ref:`instance <syntax-moduleinst>`.
+
+Execution behavior is defined in terms of an *abstract machine* that models the *program state*.
+It includes a *stack*, which records operand values and control constructs, and an abstract *store* containing global state.
+
+For each instruction, there is a rule that specifies the effect of its execution on the program state.
+Furthermore, there are rules describing the instantiation of a module.
+As with :ref:`validation <validation>`, all rules are given in two *equivalent* forms:
+
+1. In *prose*, describing the execution in intuitive form.
+2. In *formal notation*, describing the rule in mathematical form.
+
+.. note::
+   As with validation, the prose and formal rules are equivalent,
+   so that understanding of the formal notation is *not* required to read this specification.
+   The formalism offers a more concise description in notation that is used widely in programming languages semantics and is readily amenable to mathematical proof.
+
+:ref:`Store <store>`, :ref:`stack <stack>`, and other *runtime structure*, such as :ref:`module instances <syntax-moduleinst>`, are made precise in terms of additional auxiliary :ref:`syntax <syntax-runtime>`.
+
+
+.. _exec-notation-textual:
+
+Prose Notation
+~~~~~~~~~~~~~~
+
+Execution is specified by stylised, step-wise rules for each :ref:`instruction <syntax-instr>` of the :ref:`abstract syntax <syntax>`.
+The following conventions are adopted in stating these rules.
+
+* The execution rules implicitly assume a given :ref:`store <store>` :math:`S`.
+
+* The execution rules also assume the presence of an implicit :ref:`stack <stack>`
+  that is modified by *pushing* or *popping*
+  :ref:`values <syntax-value>`, :ref:`labels <syntax-label>`, and :ref:`frames <syntax-frame>`.
+
+* Certain rules require the stack to contain at least one frame,
+  which is referred to as the *current* frame.
+
+* Both the store and the current frame are mutated by *replacing* some of its components.
+  Such replacement is assumed to apply globally.
+
+* The execution of an instruction may *trap*,
+  in which case the entire computation is aborted and no further modifications to the store are performed by it. (Other computations can still be initiated afterwards.)
+
+* The execution of an instruction may also end in a *jump* to a designated target,
+  which defines the next instruction to execute.
+
+* Execution can *enter* and *exit* :ref:`instruction sequences <syntax-instr-seq>` in a block-like fashion.
+
+* :ref:`Instruction sequences <syntax-instr-seq>` are implicitly executed in order, unless a trap or jump occurs.
+
+* In various places the rules contain *assertions* expressing crucial invariants about the program state, with indications why these are known to hold.
+
+
+.. _exec-notation:
+.. index:: ! reduction rules, ! configuration
+
+Formal Notation
+~~~~~~~~~~~~~~~
+
+.. note::
+   This section gives a brief explanation of the notation for specifying execution formally.
+   For the interested reader, a more thorough introduction can be found in respective text books. [#tapl]_
+
+The formal execution rules use a standard approach for specifying operational semantics, rendering them into *reduction rules*.
+Every rule has the following general form:
+
+.. math::
+   \X{configuration} \quad\stepto\quad \X{configuration}
+
+A *configuration* is a syntactic description of a program state.
+Each rule specifies one *step* of execution.
+As long as there is at most one reduction rule applicable to a given configuration, reduction -- and thereby execution -- is *deterministic*.
+WebAssembly has only very few exceptions to this, which are noted explicitly in this specification.
+
+For WebAssembly, a configuration is a tuple :math:`(S; F; \instr^\ast)` consisting of the current :ref:`store <store>` :math:`S`, the :ref:`call frame <frame>` :math:`F` of the current function, and the sequence of :ref:`instructions <syntax-instr>` that is to be executed.
+
+To avoid unnecessary clutter, the store :math:`S` and the frame :math:`F` are omitted from reduction rules that do not touch them.
+
+There is no separate representation of the :ref:`stack <stack>`.
+Instead, it is conveniently represented as part of the configuration's instruction sequence.
+In particular, :ref:`values <syntax-val>` are defined to coincide with |CONST| instructions,
+and a sequence of |CONST| instructions can be interpreted as an operand "stack".
+
+.. note::
+   For example, the :ref:`reduction rule <exec-binop>` for the :math:`\I32.\ADD` instruction could be given as follows:
+
+   .. math::
+      (\I32.\CONST~n_1)~(\I32.\CONST~n_2)~\I32.\ADD \quad\stepto\quad (\I32.\CONST~(n_1 + n_2) \mod 2^{32})
+
+   Per this rule, two |CONST| instructions and the |ADD| instruction itself are removed from the instruction stream and replaced with one new |CONST| instruction.
+   This can be interpreted as popping two value off the stack and pushing the result.
+
+   When no result is produced, an instruction reduces to the empty sequence:
+
+   .. math::
+      \NOP \quad\stepto\quad \epsilon
+
+:ref:`Labels <label>` and :ref:`frames <frame>` are similarly :ref:`defined to be part <syntax-instr-admin>` of an instruction sequence.
+
+The order of reduction is determined by the definition of an approporiate :ref:`evaluation context <syntax-ctxt-eval>`.
+
+Reduction *terminates* when no more reduction rules are applicable.
+:ref:`Soundness <soundness>` of the WebAssembly :ref:`type system <type-system>` guarantees that this is only the case when the original instruction sequence has either been reduced to a sequence of |CONST| instructions, which can be interpreted as the :ref:`values <syntax-val>` of the resulting operand stack,
+or if a trap occurred.
+
+.. note::
+   For example, the following instruction sequence,
+
+   .. math::
+      (\F64.\CONST~x_1)~(\F64.\CONST~x_2)~\F64.\NEG~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL
+
+   terminates after three steps:
+
+   .. math::
+      \begin{array}{ll}
+      & (\F64.\CONST~x_1)~(\F64.\CONST~x_2)~\F64.\NEG~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL \\
+      \stepto & (\F64.\CONST~x_1)~(\F64.\CONST~x_4)~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL \\
+      \stepto & (\F64.\CONST~x_1)~(\F64.\CONST~x_5)~\F64.\MUL \\
+      \stepto & (\F64.\CONST~x_6) \\
+      \end{array}
+
+   where :math:`x_4 = -x_2` and :math:`x_5 = -x_2 + x_3` and :math:`x_6 = x_1 \cdot (-x_2 + x_3)`.
+
+
+.. [#tapl]
+   For example: Benjamin Pierce. `Types and Programming Languages <https://www.cis.upenn.edu/~bcpierce/tapl/>`_. The MIT Press 2002
diff --git a/document/execution/index.rst b/document/execution/index.rst
index 628dbdc85..caa7046cf 100644
--- a/document/execution/index.rst
+++ b/document/execution/index.rst
@@ -5,5 +5,7 @@ Execution
    :maxdepth: 2
 
    conventions
-   invocation
+   runtime
+   numerics
    instructions
+   modules
diff --git a/document/execution/instructions.rst b/document/execution/instructions.rst
new file mode 100644
index 000000000..ceb257a93
--- /dev/null
+++ b/document/execution/instructions.rst
@@ -0,0 +1,1062 @@
+.. _exec-instr:
+.. index:: instruction, function type, store
+
+Instructions
+------------
+
+
+.. _exec-instr-numeric:
+.. index:: numeric instruction
+   pair: execution; instruction
+   single: abstract syntax; instruction
+
+Numeric Instructions
+~~~~~~~~~~~~~~~~~~~~
+
+
+.. _exec-const:
+
+:math:`t\K{.}\CONST~c`
+......................
+
+1. Push the value :math:`t.\CONST~c` to the stack.
+
+.. note::
+   No formal reduction rule is required for this instruction, since |CONST| instructions coincide with :ref:`values <syntax-val>`.
+
+
+.. _exec-unop:
+
+:math:`t\K{.}\unop`
+...................
+
+1. Assert: due to :ref:`validation <valid-unop>`, a value of :ref:`value type <syntax-valtype>` :math:`t` is on the top of the stack.
+
+2. Pop the value :math:`t.\CONST~c_1` from the stack.
+
+3. If :math:`\unop_t(c_1)` is defined, then:
+
+   a. Let :math:`c` be the result of computing :math:`\unop_t(c_1)`.
+
+   b. Push the value :math:`t.\CONST~c` to the stack.
+
+4. Else:
+
+   a. Trap.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (t\K{.}\CONST~c_1)~t\K{.}\unop &\stepto& (t\K{.}\CONST~c)
+     & (\mbox{if}~\unop_t(c_1) = c) \\
+   (t\K{.}\CONST~c_1)~t\K{.}\unop &\stepto& \TRAP
+     & (\mbox{otherwise})
+   \end{array}
+
+
+.. _exec-binop:
+
+:math:`t\K{.}\binop`
+....................
+
+1. Assert: due to :ref:`validation <valid-binop>`, two values of :ref:`value type <syntax-valtype>` :math:`t` are on the top of the stack.
+
+2. Pop the value :math:`t.\CONST~c_2` from the stack.
+
+3. Pop the value :math:`t.\CONST~c_1` from the stack.
+
+4. If :math:`\binop_t(c_1, c_2)` is defined, then:
+
+   a. Let :math:`c` be the result of computing :math:`\binop_t(c_1, c_2)`.
+
+   b. Push the value :math:`t.\CONST~c` to the stack.
+
+5. Else:
+
+   a. Trap.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\binop &\stepto& (t\K{.}\CONST~c)
+     & (\mbox{if}~\binop_t(c_1,c_2) = c) \\
+   (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\binop &\stepto& \TRAP
+     & (\mbox{otherwise})
+   \end{array}
+
+
+.. _exec-testop:
+
+:math:`t\K{.}\testop`
+.....................
+
+1. Assert: due to :ref:`validation <valid-testop>`, a value of :ref:`value type <syntax-valtype>` :math:`t` is on the top of the stack.
+
+2. Pop the value :math:`t.\CONST~c_1` from the stack.
+
+3. Let :math:`c` be the result of computing :math:`\testop_t(c_1)`.
+
+4. Push the value :math:`\I32.\CONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (t\K{.}\CONST~c_1)~t\K{.}\testop &\stepto& (t\K{.}\CONST~c)
+     & (\mbox{if}~\testop_t(c_1) = c) \\
+   \end{array}
+
+
+.. _exec-relop:
+
+:math:`t\K{.}\relop`
+....................
+
+1. Assert: due to :ref:`validation <valid-relop>`, two values of :ref:`value type <syntax-valtype>` :math:`t` are on the top of the stack.
+
+2. Pop the value :math:`t.\CONST~c_2` from the stack.
+
+3. Pop the value :math:`t.\CONST~c_1` from the stack.
+
+4. Let :math:`c` be the result of computing :math:`\relop_t(c_1, c_2)`.
+
+5. Push the value :math:`\I32.\CONST~c` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\relop &\stepto& (t\K{.}\CONST~c)
+     & (\mbox{if}~\relop_t(c_1,c_2) = c) \\
+   \end{array}
+
+
+.. _exec-cvtop:
+
+:math:`t_2\K{.}\cvtop/t_1`
+..........................
+
+1. Assert: due to :ref:`validation <valid-cvtop>`, a value of :ref:`value type <syntax-valtype>` :math:`t_1` is on the top of the stack.
+
+2. Pop the value :math:`t_1.\CONST~c_1` from the stack.
+
+3. If :math:`\cvtop_{t_1,t_2}(c_1)` is defined:
+
+   a. Let :math:`c_2` be the result of computing :math:`\cvtop_{t_1,t_2}(c_1)`.
+
+   b. Push the value :math:`t_2.\CONST~c_2` to the stack.
+
+4. Else:
+
+   a. Trap.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (t\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& (t_2\K{.}\CONST~c_2)
+     & (\mbox{if}~\cvtop_{t_1,t_2}(c_1) = c_2) \\
+   (t\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& \TRAP
+     & (\mbox{otherwise})
+   \end{array}
+
+
+.. _exec-instr-parametric:
+.. index:: parametric instructions
+   pair: execution; instruction
+   single: abstract syntax; instruction
+
+Parametric Instructions
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. _exec-drop:
+
+:math:`\DROP`
+.............
+
+1. Assert: due to :ref:`validation <valid-drop>`, a value is on the top of the stack.
+
+2. Pop the value :math:`\val` from the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \val~~\DROP &\stepto& \epsilon
+   \end{array}
+
+
+.. _exec-select:
+
+:math:`\SELECT`
+...............
+
+1. Assert: due to :ref:`validation <valid-select>`, a value :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+2. Pop the value :math:`\I32.\CONST~c` from the stack.
+
+3. Assert: due to :ref:`validation <valid-select>`, two more values (of the same :ref:`value type <syntax-valtype>`) are on the top of the stack.
+
+4. Pop the value :math:`\val_2` from the stack.
+
+5. Pop the value :math:`\val_1` from the stack.
+
+6. If :math:`c` is not :math:`0`, then:
+
+   a. Push the value :math:`\val_1` back to the stack.
+
+7. Else:
+
+   a. Push the value :math:`\val_2` back to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \val_1~\val_2~(\I32\K{.}\CONST~c)~\SELECT &\stepto& \val_1
+     & (\mbox{if}~c \neq 0) \\
+   \val_1~\val_2~(\I32\K{.}\CONST~c)~\SELECT &\stepto& \val_2
+     & (\mbox{if}~c = 0) \\
+   \end{array}
+
+
+.. _exec-instr-variable:
+.. index:: variable instructions, local index, global index, address, global address, global instance, store, frame
+   pair: execution; instruction
+   single: abstract syntax; instruction
+
+Variable Instructions
+~~~~~~~~~~~~~~~~~~~~~
+
+.. _exec-get_local:
+
+:math:`\GETLOCAL~x`
+...................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-get_local>`, :math:`F.\LOCALS[x]` exists.
+
+3. Let :math:`\val` be the value :math:`F.\LOCALS[x]`.
+
+4. Push the value :math:`\val` to the stack.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   F; (\GETLOCAL~x) &\stepto& F; \val
+     & (\mbox{if}~F.\LOCALS[x] = \val) \\
+   \end{array}
+
+
+.. _exec-set_local:
+
+:math:`\SETLOCAL~x`
+...................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-set_local>`, :math:`F.\LOCALS[x]` exists.
+
+3. Assert: due to :ref:`validation <valid-set_local>`, a value is on the top of the stack.
+
+4. Pop the value :math:`\val` from the stack.
+
+5. Replace :math:`F.\LOCALS[x]` with the value :math:`\val`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   F; \val~(\SETLOCAL~x) &\stepto& F'; \epsilon
+     & (\mbox{if}~F' = F \with \LOCALS[x] = \val) \\
+   \end{array}
+
+
+.. _exec-tee_local:
+
+:math:`\TEELOCAL~x`
+...................
+
+1. Assert: due to :ref:`validation <valid-tee_local>`, a value is on the top of the stack.
+
+2. Pop the value :math:`\val` from the stack.
+
+3. Push the value :math:`\val` to the stack.
+
+4. Push the value :math:`\val` to the stack.
+
+5. :ref:`Execute <exec-set_local>` the instruction :math:`(\SETLOCAL~x)`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   F; \val~(\TEELOCAL~x) &\stepto& F'; \val~\val~(\SETLOCAL~x)
+   \end{array}
+
+
+.. _exec-get_global:
+
+:math:`\GETGLOBAL~x`
+....................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-get_global>`, :math:`F.\MODULE.\GLOBALS[x]` exists.
+
+3. Let :math:`a` be the :ref:`global address <syntax-globaladdr>` :math:`F.\MODULE.\GLOBALS[x]`.
+
+4. Assert: due to :ref:`validation <valid-get_global>`, :math:`S.\GLOBALS[a]` exists.
+
+5. Let :math:`\X{glob}` be the :ref:`global instance <syntax-globalinst>` :math:`S.\GLOBALS[a]`.
+
+6. Let :math:`\val` be the value :math:`\X{glob}.\VALUE`.
+
+7. Push the value :math:`\val` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\GETGLOBAL~x) &\stepto& S; F; \val
+   \end{array}
+   \\ \qquad
+     (\mbox{if}~S.\GLOBALS[F.\MODULE.\GLOBALS[x]].\VALUE = \val) \\
+   \end{array}
+
+
+.. _exec-set_global:
+
+:math:`\SETGLOBAL~x`
+....................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-set_global>`, :math:`F.\MODULE.\GLOBALS[x]` exists.
+
+3. Let :math:`a` be the :ref:`global address <syntax-globaladdr>` :math:`F.\MODULE.\GLOBALS[x]`.
+
+4. Assert: due to :ref:`validation <valid-set_global>`, :math:`S.\GLOBALS[a]` exists.
+
+5. Let :math:`\X{glob}` be the :ref:`global instance <syntax-globalinst>` :math:`S.\GLOBALS[a]`.
+
+6. Assert: due to :ref:`validation <valid-set_global>`, a value is on the top of the stack.
+
+7. Pop the value :math:`\val` from the stack.
+
+8. Replace :math:`\X{glob}.\VALUE` with the value :math:`\val`.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; \val~(\SETGLOBAL~x) &\stepto& S'; F; \epsilon
+   \end{array}
+   \\ \qquad
+   (\mbox{if}~S' = S \with \GLOBALS[F.\MODULE.\GLOBALS[x]].\VALUE = \val) \\
+   \end{array}
+
+
+.. _exec-instr-memory:
+.. _exec-memarg:
+.. index:: memory instruction, memory index, store, frame, address, memory address, memory instance, store, frame, value type, width
+   pair: execution; instruction
+   single: abstract syntax; instruction
+
+Memory Instructions
+~~~~~~~~~~~~~~~~~~~
+
+.. _exec-load:
+.. _exec-loadn:
+
+:math:`t\K{.}\LOAD~\memarg` and :math:`t\K{.}\LOAD{N}\K{\_}\sx~\memarg`
+.......................................................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-loadn>`, :math:`F.\MODULE.\MEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\MODULE.\MEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-loadn>`, :math:`S.\MEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\MEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-loadn>`, a value :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+7. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+8. Let :math:`\X{ea}` be :math:`i + \memarg.\OFFSET`.
+
+9. If :math:`N` is not part of the instruction, then:
+
+   a. Let :math:`N` be the :ref:`width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
+
+10. If :math:`\X{ea} + N` is larger than the length of :math:`\X{mem}.\DATA`, then:
+
+    a. Trap.
+
+11. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\DATA[\X{ea}:N]`.
+
+12. If :math:`N` and :math:`\sx` are part of the instruction, then:
+
+    a. Let :math:`n` be the integer for which :math:`\bytes_N(n) = b^\ast`.
+
+    b. Let :math:`c` be the result of computing :math:`\extend_{\sx,N}(n)`.
+
+13. Else:
+
+    a. Let :math:`c` be the constant for which :math:`\bytes_t(c) = b^\ast`.
+
+14. Push the value :math:`t.\CONST~c` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(t.\LOAD~\memarg) &\stepto& S; F; (t.\CONST~c)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + |t| \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
+     \wedge & \bytes_t(c) = S.\MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:|t|])
+     \end{array} \\
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(t.\LOAD{N}\K{\_}\sx~\memarg) &\stepto&
+     S; F; (t.\CONST~\extend_{\sx,N}(n))
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + N \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
+     \wedge & \bytes_N(n) = S.\MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:N])
+     \end{array} \\
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(t.\LOAD({N}\K{\_}\sx)^?~\memarg) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\mbox{otherwise}) \\
+   \end{array}
+
+.. note::
+   The alignment :math:`\memarg.\ALIGN` does not affect the semantics.
+   Unaligned access is supported for all types, and succeeds regardless of the annotation.
+   The only purpose of the annotation is to provide optimizatons hints.
+
+
+.. _exec-store:
+.. _exec-storen:
+
+:math:`t\K{.}\STORE~\memarg` and :math:`t\K{.}\STORE{N}~\memarg`
+................................................................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-storen>`, :math:`F.\MODULE.\MEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\MODULE.\MEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-storen>`, :math:`S.\MEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\MEMS[a]`.
+
+6. Assert: due to :ref:`validation <valid-storen>`, a value :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+7. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+8. Let :math:`\X{ea}` be :math:`i + \memarg.\OFFSET`.
+
+9. If :math:`N` is not part of the instruction, then:
+
+   a. Let :math:`N` be the :ref:`width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
+
+10. If :math:`\X{ea} + N` is larger than the length of :math:`\X{mem}.\DATA`, then:
+
+    a. Trap.
+
+11. Assert: due to :ref:`validation <valid-storen>`, a value of :ref:`value type <syntax-valtype>` :math:`t` is on the top of the stack.
+
+12. Pop the value :math:`t.\CONST~c` from the stack.
+
+13. If :math:`N` is part of the instruction, then:
+
+    a. Let :math:`n` be the result of computing :math:`\wrap_N(c)`.
+
+    b. Let :math:`b^\ast` be the byte sequence :math:`\bytes_N(n)`.
+
+14. Else:
+
+    a. Let :math:`b^\ast` be the byte sequence :math:`\bytes_t(c)`.
+
+15. Replace the bytes :math:`\X{mem}.\DATA[\X{ea}:N]` with :math:`b^\ast`.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(t.\STORE~\memarg) &\stepto& S'; F; \epsilon
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + |t| \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
+     \wedge & S' = S \with \MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:|t|] = \bytes_t(c)
+     \end{array} \\
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(t.\STORE{N}~\memarg) &\stepto& S'; F; \epsilon
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
+     \wedge & \X{ea} + N \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
+     \wedge & S' = S \with \MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:N] = \bytes_N(\wrap_N(c))
+     \end{array} \\
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~k)~(t.\STORE{N}^?~\memarg) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\mbox{otherwise}) \\
+   \end{array}
+
+
+.. _exec-current_memory:
+
+:math:`\CURRENTMEMORY`
+......................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-current_memory>`, :math:`F.\MODULE.\MEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\MODULE.\MEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-current_memory>`, :math:`S.\MEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\MEMS[a]`.
+
+6. Let :math:`\X{sz}` be the length of :math:`\X{mem}.\DATA` divided by the :ref:`page size <page-size>`.
+
+7. Push the value :math:`\I32.\CONST~\X{sz}` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; \CURRENTMEMORY &\stepto& S; F; (\I32.\CONST~\X{sz})
+   \end{array}
+   \\ \qquad
+     (\mbox{if}~|S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| = \X{sz}\cdot64\,\F{Ki}) \\
+   \end{array}
+
+
+.. _exec-grow_memory:
+
+:math:`\GROWMEMORY`
+...................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-grow_memory>`, :math:`F.\MODULE.\MEMS[0]` exists.
+
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\MODULE.\MEMS[0]`.
+
+4. Assert: due to :ref:`validation <valid-grow_memory>`, :math:`S.\MEMS[a]` exists.
+
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\MEMS[a]`.
+
+6. Let :math:`\X{sz}` be the length of :math:`S.\MEMS[a]` divided by the :ref:`page size <page-size>`.
+
+7. Assert: due to :ref:`validation <valid-grow_memory>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+8. Pop the value :math:`\I32.\CONST~n` from the stack.
+
+9. If :math:`\X{mem}.\MAX` is not empty and :math:`\X{sz} + n` is larger than :math:`\X{mem}.\MAX`, then:
+
+  a. Push the value :math:`\I32.\CONST~(-1)` to the stack.
+
+10. Else, either:
+
+    a. Let :math:`\X{len}` be :math:`n` multiplied with the :ref:`page size <page-size>`.
+
+    b. Append :math:`\X{len}` bytes with value :math:`\hex{00}` to :math:`S.\MEMS[a]`.
+
+    c. Push the value :math:`\I32.\CONST~\X{sz}` to the stack.
+
+11. Or:
+
+    a. Push the value :math:`\I32.\CONST~(-1)` to the stack.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~n)~\GROWMEMORY &\stepto& S'; F; (\I32.\CONST~\X{sz})
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\mbox{if} & F.\MODULE.\MEMS[0] = a \\
+     \wedge & |S.\MEMS[a].\DATA| = \X{sz}\cdot64\,\F{Ki} \\
+     \wedge & (\X{sz} + n \leq S.\MEMS[a].\MAX \vee S.\MEMS[a].\MAX = \epsilon) \\
+     \wedge & S' = S \with \MEMS[a].\DATA = S.\MEMS[a].\DATA~(\hex{00})^{n\cdot64\,\F{Ki}}) \\
+     \end{array} \\
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~n)~\GROWMEMORY &\stepto& S; F; (\I32.\CONST~{-1})
+   \end{array}
+   \end{array}
+
+.. note::
+   The |GROWMEMORY| instruction is non-deterministic.
+   It may either succeed, returning the old memory size :math:`\X{sz}`,
+   or fail, returning :math:`{-1}`.
+   Failure *must* occur if the referenced memory instance has a maximum size defined that would be exceeded.
+   However, failure *can* occur in other cases as well.
+   In practice, the choice depends on the resources available to the :ref:`embedder <embedder>`.
+
+
+.. _exec-instr-control:
+.. _exec-label:
+.. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, address, table address, table instance, store, frame
+   pair: execution; instruction
+   single: abstract syntax; instruction
+
+Control Instructions
+~~~~~~~~~~~~~~~~~~~~
+
+.. _exec-nop:
+
+:math:`\NOP`
+............
+
+1. Do nothing.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \NOP &\stepto& \epsilon
+   \end{array}
+
+
+.. _exec-unreachable:
+
+:math:`\UNREACHABLE`
+....................
+
+1. Trap.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \UNREACHABLE &\stepto& \TRAP
+   \end{array}
+
+
+.. _exec-block:
+
+:math:`\BLOCK~[t^?]~\instr^\ast~\END`
+.....................................
+
+1. Let :math:`n` be the arity :math:`|t^?|` of the :ref:`result type <syntax-resulttype>` :math:`t^?`.
+
+2. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is the end of the block.
+
+3. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr^\ast` with label :math:`L`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \BLOCK~[t^n]~\instr^\ast~\END &\stepto&
+     \LABEL_n\{\epsilon\}~\instr^\ast~\END
+   \end{array}
+
+
+.. _exec-loop:
+
+:math:`\LOOP~[t^?]~\instr^\ast~\END`
+....................................
+
+1. Let :math:`L` be the label whose arity is :math:`0` and whose continuation is the start of the loop.
+
+2. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr^\ast` with label :math:`L`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \LOOP~[t^?]~\instr^\ast~\END &\stepto&
+     \LABEL_0\{\LOOP~[t^?]~\instr^\ast~\END\}~\instr^\ast~\END
+   \end{array}
+
+
+.. _exec-if:
+
+:math:`\IF~[t^?]~\instr_1^\ast~\ELSE~\instr_2^\ast~\END`
+........................................................
+
+1. Assert: due to :ref:`validation <valid-if>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+2. Pop the value :math:`\I32.\CONST~c` from the stack.
+
+3. Let :math:`n` be the arity :math:`|t^?|` of the :ref:`result type <syntax-resulttype>` :math:`t^?`.
+
+4. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is the end of the |IF| instruction.
+
+5. If :math:`c` is not :math:`0`, then:
+
+   a. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr_1^\ast` with label :math:`L`.
+
+6. Else:
+
+   a. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr_2^\ast` with label :math:`L`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\I32.\CONST~c)~\IF~[t^n]~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
+     \LABEL_n\{\epsilon\}~\instr_1^\ast~\END
+     & (\mbox{if}~c \neq 0) \\
+   (\I32.\CONST~c)~\IF~[t^n]~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
+     \LABEL_n\{\epsilon\}~\instr_2^\ast~\END
+     & (\mbox{if}~c = 0) \\
+   \end{array}
+
+
+.. _exec-br:
+
+:math:`\BR~l`
+.............
+
+1. Assert: due to :ref:`validation <valid-br>`, the stack contains at least :math:`l+1` labels.
+
+2. Let :math:`L` be the :math:`l`-th label appearing on the stack, starting from the top and counting from zero.
+
+3. Let :math:`n` be the arity of :math:`L`.
+
+4. Assert: due to :ref:`validation <valid-br>`, there are at least :math:`n` values on the top of the stack.
+
+5. Pop the values :math:`\val^n` from the stack.
+
+6. Repeat :math:`l+1` times:
+
+   a. While the top of the stack is a value, do:
+
+      i. Pop the value from the stack.
+
+   b. Assert: due to :ref:`validation <valid-br>`, the top of the stack now is a label.
+
+   c. Pop the label from the stack.
+
+7. Push the values :math:`\val^n` to the stack.
+
+8. Jump to the continuation of :math:`L`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \LABEL_n\{\instr^\ast\}~\XB^l[\val^n~(\BR~l)]~\END &\stepto& \val^n~\instr^\ast
+   \end{array}
+
+
+.. _exec-br_if:
+
+:math:`\BRIF~l`
+...............
+
+1. Assert: due to :ref:`validation <valid-br_if>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+2. Pop the value :math:`\I32.\CONST~c` from the stack.
+
+3. If :math:`c` is not :math:`0`, then:
+
+   a. :ref:`Execute <exec-br>` the instruction :math:`(\BR~l)`.
+
+4. Else:
+
+   a. Do nothing.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\I32.\CONST~c)~(\BRIF~l) &\stepto& (\BR~l)
+     & (\mbox{if}~c \neq 0) \\
+   (\I32.\CONST~c)~(\BRIF~l) &\stepto& \epsilon
+     & (\mbox{if}~c = 0) \\
+   \end{array}
+
+
+.. _exec-br_table:
+
+:math:`\BRTABLE~l^\ast~l_N`
+...........................
+
+1. Assert: due to :ref:`validation <valid-if>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+2. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+3. If :math:`i` is smaller than the length of :math:`l^\ast`, then:
+
+   a. Let :math:`l_i` be the label :math:`l^\ast[i]`.
+
+   b. :ref:`Execute <exec-br>` the instruction :math:`(\BR~l_i)`.
+
+4. Else:
+
+   a. :ref:`Execute <exec-br>` the instruction :math:`(\BR~l_N)`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   (\I32.\CONST~i)~(\BRTABLE~l^\ast~l_N) &\stepto& (\BR~l_i)
+     & (\mbox{if}~l^\ast[i] = l_i) \\
+   (\I32.\CONST~i)~(\BRTABLE~l^\ast~l_N) &\stepto& (\BR~l_N)
+     & (\mbox{if}~|l^\ast| \leq i) \\
+   \end{array}
+
+
+.. _exec-return:
+
+:math:`\RETURN`
+...............
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Let :math:`n` be the arity of :math:`F`.
+
+3. Assert: due to :ref:`validation <valid-br>`, there are at least :math:`n` values on the top of the stack.
+
+4. Pop the results :math:`\val^n` from the stack.
+
+5. Assert: due to :ref:`validation <valid-return>`, the stack contains at least one :ref:`frame <syntax-frame>`.
+
+6. While the top of the stack is not a frame, do:
+
+   a. Pop the top element from the stack.
+
+7. Assert: the top of the stack is the frame :math:`F`.
+
+8. Pop the frame from the stack.
+
+9. Push :math:`\val^n` to the stack.
+
+10. Jump to the instruction after the original call.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \FRAME_n\{F\}~\XB^k[\val^n~\RETURN]~\END &\stepto& \val^n
+   \end{array}
+
+
+.. _exec-call:
+
+:math:`\CALL~x`
+...............
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-call>`, :math:`F.\MODULE.\FUNCS[x]` exists.
+
+3. Let :math:`a` be the :ref:`function address <syntax-funcaddr>` :math:`F.\MODULE.\FUNCS[x]`.
+
+4. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   F; (\CALL~x) &\stepto& F; (\INVOKE~a)
+     & (\mbox{if}~F.\MODULE.\FUNCS[x] = a)
+   \end{array}
+
+
+.. _exec-call_indirect:
+
+:math:`\CALLINDIRECT~x`
+.......................
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`F.\MODULE.\TABLES[0]` exists.
+
+3. Let :math:`\X{ta}` be the :ref:`table address <syntax-tableaddr>` :math:`F.\MODULE.\TABLES[0]`.
+
+4. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`S.\TABLES[\X{ta}]` exists.
+
+5. Let :math:`\X{tab}` be the :ref:`table instance <syntax-tableinst>` :math:`S.\TABLES[\X{ta}]`.
+
+6. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`F.\MODULE.\TYPES[x]` exists.
+
+7. Let :math:`\X{ft}_{\F{expect}}` be the :ref:`function type <syntax-functype>` :math:`F.\MODULE.\TYPES[x]`.
+
+8. Assert: due to :ref:`validation <valid-call_indirect>`, a value with :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+
+9. Pop the value :math:`\I32.\CONST~i` from the stack.
+
+10. If :math:`i` is not smaller than the length of :math:`\X{tab}.\ELEM`, then:
+
+    a. Trap.
+
+11. If :math:`\X{tab}.\ELEM[i]` is uninitialized, then:
+
+    a. Trap.
+
+12. Let :math:`a` be the :ref:`function address <syntax-funcaddr>` :math:`\X{tab}.\ELEM[i]`.
+
+13. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`S.\FUNCS[a]` exists.
+
+14. Let :math:`\X{f}` be the :ref:`function instance <syntax-funcinst>` :math:`S.\FUNCS[a]`.
+
+15. Assert: due to :ref:`validation <valid-func>`, :math:`\X{f}.\MODULE.\TYPES[\X{f}.\CODE.\TYPE]` exists.
+
+16. Let :math:`\X{ft}_{\F{actual}}` be the :ref:`function type <syntax-functype>` :math:`\X{f}.\MODULE.\TYPES[\X{f}.\CODE.\TYPE]`.
+
+15. If :math:`\X{ft}_{\F{actual}}` and :math:`\X{ft}_{\F{expect}}` differ, then:
+
+    a. Trap.
+
+17. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\CALLINDIRECT~x) &\stepto& S; F; (\INVOKE~a)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\mbox{if} & S.\TABLES[F.\MODULE.\TABLES[0]].\ELEM[i] = a \\
+     \wedge & S.\FUNCS[a] = f \\
+     \wedge & F.\MODULE.\TYPES[x] = f.\MODULE.\TYPES[f.\CODE.\TYPE])
+     \end{array} \\
+   \begin{array}{lcl@{\qquad}l}
+   S; F; (\I32.\CONST~i)~(\CALLINDIRECT~x) &\stepto& S; F; \TRAP
+   \end{array}
+   \\ \qquad
+     (\mbox{otherwise})
+   \end{array}
+
+
+.. _exec-instr-seq:
+.. index:: instruction, instruction sequence
+
+Instruction Sequences
+~~~~~~~~~~~~~~~~~~~~~
+
+The following auxiliary rules define the semantics of executing an :ref:`instruction sequence <syntax-instr-seq>`
+that is part of a :ref:`structured control instruction <exec-instr-control>`.
+
+
+.. _exec-instr-seq-enter:
+
+Entering :math:`\instr^\ast` with label :math:`L`
+.................................................
+
+1. Push :math:`L` to the stack.
+
+2. :ref:`Jump <exec-jump>` to the start of the instruction sequence :math:`\instr^\ast`.
+
+.. note::
+   No formal reduction rule is needed for entering an instruction sequence,
+   because the label :math:`L` is embedded in the :ref:`administrative instruction <syntax-instr-admin>` that structured control instructions reduce to directly.
+
+
+.. _exec-instr-seq-exit:
+
+Exiting :math:`\instr^\ast` with label :math:`L`
+................................................
+
+When the end of a labelled instruction sequence is reached without a jump or trap aborting it, then the following steps are performed.
+
+1. Let :math:`n` be the arity of :math:`L`.
+
+2. Assert: due to :ref:`validation <valid-instr-seq>`, there are :math:`n` values on the top of the stack.
+
+3. Pop the results :math:`\val^n` from the stack.
+
+4. Assert: due to :ref:`validation <valid-instr-seq>`, the label :math:`L` is now on the top of the stack.
+
+5. Pop the label from the stack.
+
+6. Push :math:`\val^n` back to the stack.
+
+7. Jump to the position after the |END| of the :ref:`structured control instruction <syntax-instr-control>` associated with the label :math:`L`.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \LABEL_n\{\instr^\ast\}~\val^n~\END &\stepto& \val^n
+   \end{array}
+
+.. note::
+   This semantics also applies to the instruction sequence contained in a |LOOP| instruction.
+   Therefor, execution of a loop falls off the end, unless a backwards branch is performed explicitly.
+
+
+.. index:: ! invocation, function, function instance, label, frame
+
+Function Calls
+~~~~~~~~~~~~~~
+
+The following auxiliary rules define the semantics of invoking a :ref:`function instance <syntax-funcinst>`
+through one of the :ref:`call instructions <exec-instr-control>`
+and returning from it.
+
+
+.. _exec-invoke:
+
+Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
+.................................................................
+
+1. Assert: due to :ref:`validation <valid-call>`, :math:`S.\FUNCS[a]` exists.
+
+2. Let :math:`f` be the :ref:`function instance <sytnax-funcinst>`, :math:`S.\FUNCS[a]`.
+
+3. Assert: due to :ref:`validation <valid-func>`, :math:`f.\MODULE.\TYPES[f.\CODE.\TYPE]` exists.
+
+4. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`f.\MODULE.\TYPES[f.\CODE.\TYPE]`.
+
+5. Let :math:`t^\ast` be the list of :ref:`value types <syntax-valtype>` :math:`f.\CODE.\LOCALS`.
+
+6. Let :math:`\instr^\ast~\END` be the :ref:`expression <syntax-expr>` :math:`f.\CODE.\BODY`.
+
+7. Assert: due to :ref:`validation <valid-call>`, :math:`n` values are on the top of the stack.
+
+8. Pop the values :math:`\val^n` from the stack.
+
+9. Let :math:`\val_0^\ast` be the list of zero values of types :math:`t^\ast`.
+
+10. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \MODULE~f.\MODULE, \LOCALS~\val^n~\val_0^\ast \}`.
+
+11. Push the activation of :math:`F` with arity :math:`m` to the stack.
+
+12. :ref:`Execute <exec-block>` the instruction :math:`\BLOCK~[t_2^m]~\instr^\ast~\END`.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   \val^n~(\INVOKE~a) &\stepto& \FRAME_m\{F\}~\BLOCK~[t_2^m]~\instr^\ast~\END~\END
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\mbox{if} & S.\FUNCS[a] = f \\
+     \wedge & f.\CODE = \{ \TYPE~x, \LOCALS~t^k, \BODY~\instr^\ast~\END \} \\
+     \wedge & f.\MODULE.\TYPES[x] = [t_1^n] \to [t_2^m] \\
+     \wedge & F = \{ \MODULE~f.\MODULE, ~\LOCALS~\val^n~(t.\CONST~0)^k \})
+     \end{array} \\
+   \end{array}
+
+
+.. _exec-invoke-exit:
+
+Returning from a function
+.........................
+
+When the end of a funtion is reached without a jump (|RETURN|) or trap aborting it, then the following steps are performed.
+
+1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
+
+2. Let :math:`n` be the arity of the activation of :math:`F`.
+
+3. Assert: due to :ref:`validation <valid-instr-seq>`, there are :math:`n` values on the top of the stack.
+
+4. Pop the results :math:`\val^n` from the stack.
+
+5. Assert: due to :ref:`validation <valid-func>`, the frame :math:`F` is now on the top of the stack.
+
+6. Pop the frame from the stack.
+
+7. Push :math:`\val^n` back to the stack.
+
+8. Jump to the instruction after the original call.
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \FRAME_n\{F\}~\val^n~\END &\stepto& \val^n
+   \end{array}
+
+
+.. _exec-expr:
+.. index:: expression
+   pair: execution; expression
+   single: abstract syntax; expression
+   single: expression; constant
+
+Expressions
+~~~~~~~~~~~
+
+:math:`\instr^\ast~\END`
+........................
+
+.. todo::
+   Define
+
+.. math::
+   \frac{
+     S; F; \instr^\ast \stepto^\ast S; F; v
+   }{
+     S; F; \instr^\ast~\END \stepto^\ast S; F; v
+   }
diff --git a/document/execution/modules.rst b/document/execution/modules.rst
new file mode 100644
index 000000000..46e76ef07
--- /dev/null
+++ b/document/execution/modules.rst
@@ -0,0 +1,5 @@
+Modules
+-------
+
+.. todo::
+   Work in progress
diff --git a/document/execution/numerics.rst b/document/execution/numerics.rst
new file mode 100644
index 000000000..59ad0e0c6
--- /dev/null
+++ b/document/execution/numerics.rst
@@ -0,0 +1,54 @@
+.. _exec-numeric:
+
+Numerics
+--------
+
+.. todo::
+   Describe
+
+
+.. _aux-bytes:
+.. _aux-signed:
+.. _aux-extend:
+.. _aux-wrap:
+
+Auxiliary Operations
+~~~~~~~~~~~~~~~~~~~~
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \bytes_N(i) &=& \epsilon & (N = 0 \wedge i = 0) \\
+   \bytes_N(i) &=& b~\bytes_{N-8}(j) & (N \geq 8 \wedge i = 2^8\cdot j + b) \\
+   ~ \\
+   \bytes_{\K{i}N}(i) &=& \bytes_N(i) \\
+   \bytes_{\K{f}N}(b^N) &=& \F{reverse}(b^N) \\
+   \end{array}
+
+Note that |bytes| is a bijection, hence the function is invertible.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \signed_N(i) &=& i & (0 \leq i < 2^{N-1}) \\
+   \signed_N(i) &=& i - 2^N & (2^{N-1} \leq i < 2^N) \\
+   \signed_N(-i) &=& -i & (0 < i \geq 2^{N-1}) \\
+   ~ \\
+   \extend_{\B{U},N}(i) &=& i \\
+   \extend_{\B{S},N}(i) &=& \signed_N(i) \\
+   \wrap_N(i) &=& i \mod 2^N \\
+   \end{array}
+
+.. Note::
+   The index :math:`N` of the |extend| function is the size extending *from*,
+   where as the index of the |wrap| function is the size wrapping *to*.
+
+
+Integer Operations
+~~~~~~~~~~~~~~~~~~
+
+
+Floating-Point Operations
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+
+Conversions
+~~~~~~~~~~~
diff --git a/document/execution/runtime.rst b/document/execution/runtime.rst
new file mode 100644
index 000000000..028865b42
--- /dev/null
+++ b/document/execution/runtime.rst
@@ -0,0 +1,539 @@
+.. _syntax-runtime:
+.. index:: ! runtime
+
+Runtime Structure
+-----------------
+
+
+.. _syntax-val:
+.. index:: ! value, constant
+   pair: abstract syntax; value
+
+Values
+~~~~~~
+
+WebAssembly computations manipulate *values* of the four basic :ref:`value types <syntax-valtype>`: :ref:`integers <syntax-int>` and :ref:`floating-point data <syntax-float>` of 32 or 64 bit width each, respectively.
+
+In most places of the semantics, values of different types can occur.
+In order to avoid ambiguities, values are therefore represented with an abstract syntax that makes their type explicit.
+It is convenient to reuse the same notation as for the |CONST| :ref:`instructions <syntax-const>` producing them:
+
+.. math::
+   \begin{array}{llll}
+   \production{(value)} & \val &::=&
+     \I32.\CONST~\i32 ~|~
+     \I64.\CONST~\i64 ~|~
+     \F32.\CONST~\f32 ~|~
+     \F64.\CONST~\f64
+   \end{array}
+
+
+.. _store:
+.. _syntax-store:
+.. index:: ! store, function instance, table instance, memory instance, global instance, module
+   pair: abstract syntax; store
+
+Store
+~~~~~
+
+The *store* represents all global state that can be manipulated by WebAssembly programs.
+It consists of the runtime representation of all *instances* of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tableinst>`, :ref:`memories <syntax-meminst>`, and :ref:`globals <syntax-globalinst>` that have been *allocated* during the life time of the abstract machine. [#gc]_
+
+Syntactically, the store is defined as a :ref:`record <syntax-record>` listing the existing instances of each category:
+
+.. math::
+   \begin{array}{llll}
+   \production{(store)} & \store &::=& \{~
+     \begin{array}[t]{l@{~}ll}
+     \FUNCS & \funcinst^\ast, \\
+     \TABLES & \tableinst^\ast, \\
+     \MEMS & \meminst^\ast, \\
+     \GLOBALS & \globalinst^\ast ~\} \\
+     \end{array}
+   \end{array}
+
+.. [#gc]
+   In practice, implementations may apply techniques like garbage collection to remove objects from the store that are no longer referenced.
+   However, such techniques are not semantically observable,
+   and hence outside the scope of this specification.
+
+
+Convention
+..........
+
+* The meta variable :math:`S` ranges over stores where clear from context.
+
+
+.. _syntax-addr:
+.. _syntax-funcaddr:
+.. _syntax-tableaddr:
+.. _syntax-memaddr:
+.. _syntax-globaladdr:
+.. index:: ! address, store, function instance, table instance, memory instance, global instance
+   pair: abstract syntax; function address
+   pair: abstract syntax; table address
+   pair: abstract syntax; memory address
+   pair: abstract syntax; global address
+   pair: function; address
+   pair: table; address
+   pair: memory; address
+   pair: global; address
+
+Addresses
+~~~~~~~~~
+
+:ref:`Function instances <syntax-funcinst>`, :ref:`table instances <syntax-tableinst>`, :ref:`memory instances <syntax-meminst>`, and :ref:`global instances <syntax-globalinst>` in the :ref:`store <syntax-store>` are referenced with abstract *addresses*.
+These are simply indices into the respective store component.
+
+.. math::
+   \begin{array}{llll}
+   \production{(address)} & \addr &::=&
+     0 ~|~ 1 ~|~ 2 ~|~ \dots \\
+   \production{(function address)} & \funcaddr &::=&
+     \addr \\
+   \production{(table address)} & \tableaddr &::=&
+     \addr \\
+   \production{(memory address)} & \memaddr &::=&
+     \addr \\
+   \production{(global address)} & \globaladdr &::=&
+     \addr \\
+   \end{array}
+
+.. note::
+   Addresses are *dynamic*, globally unique references to runtime objects,
+   in contrast to :ref:`indices <syntax-index>`,
+   which are *static*, module-local references to their original definitions.
+
+   There is no specific limit on the number of allocations of store objects,
+   hence logical addresses can be arbitrarily large natural numbers.
+
+   A *memory address* |memaddr| denotes the abstract address *of* a memory *instance* in the store,
+   not an offset *inside* a memory instance.
+
+
+.. _syntax-moduleinst:
+.. index:: ! instance, function type, function instance, table instance, memory instance, global instance, export instance, table address, memory address, global address, index
+   pair: abstract syntax; module instance
+   pair: module; instance
+
+Module Instances
+~~~~~~~~~~~~~~~~
+
+A *module instance* is the runtime representation of a :ref:`module <syntax-module>`.
+It is created by :ref:`instantiating <instantiation>` a module,
+and collects runtime representations of all entities that are imported, defined, or exported by the module.
+
+.. math::
+   \begin{array}{llll}
+   \production{(module instance)} & \moduleinst &::=& \{
+     \begin{array}[t]{l@{~}ll}
+     \TYPES & \functype^\ast, \\
+     \FUNCS & \funcaddr^\ast, \\
+     \TABLES & \tableaddr^\ast, \\
+     \MEMS & \memaddr^\ast, \\
+     \GLOBALS & \globaladdr^\ast \\
+     \EXPORTS & \exportinst^\ast ~\} \\
+     \end{array}
+   \end{array}
+
+Each component references runtime instances corresponding to respective declarations from the original module -- whether imported or defined -- in the order of their static :ref:`indices <syntax-index>`.
+:ref:`Function instances <syntax-funcinst>`, :ref:`table instances <syntax-tableinst>`, :ref:`memory instances <syntax-meminst>`, and :ref:`global instances <syntax-globalinst>` are referenced with an indirection through their respective :ref:`addresses <syntax-addr>` in the :ref:`store <syntax-store>`.
+
+It is an invariant of the semantics that all :ref:`export instances <syntax-exportinst>` in a given module instance have different :ref:`names <syntax-name>`.
+
+
+.. _syntax-funcinst:
+.. index:: ! function instance, module instance, function, closure
+   pair: abstract syntax; function instance
+   pair: function; instance
+
+Function Instances
+~~~~~~~~~~~~~~~~~~
+
+A *function instance* is the runtime representation of a :ref:`function <syntax-func>`.
+It effectively is a *closure* of the original function over the runtime :ref:`module instance <syntax-moduleinst>` of its own :ref:`module <syntax-module>`.
+The module instance is used to resolve references to other non-local definitions during execution of the function.
+
+.. math::
+   \begin{array}{llll}
+   \production{(function instance)} & \funcinst &::=&
+     \{ \MODULE~\moduleinst, \CODE~\func \} \\
+   \end{array}
+
+Function instances are immutable, and their identity is not observable by WebAssembly code.
+However, the :ref:`embedder <embedder>` might provide implicit or explicit means for distinguishing them.
+
+.. todo:: Host functions?
+
+
+.. _syntax-tableinst:
+.. _syntax-funcelem:
+.. index:: ! table instance, table, function address
+   pair: abstract syntax; table instance
+   pair: table; instance
+
+Table Instances
+~~~~~~~~~~~~~~~
+
+A *table instance* is the runtime representation of a :ref:`table <syntax-table>`.
+It holds a vector of *function elements* and an optional maximum size, if one was specified at the definition site of the table.
+
+Each function element is either empty, representing an uninitialized table entry, or a :ref:`function address <syntax-funcaddr>`.
+Function elements can be mutated through the execution of an :ref:`element segment <syntax-elem>` or by external means provided by the :ref:`embedder <embedder>`.
+
+.. math::
+   \begin{array}{llll}
+   \production{(table instance)} & \tableinst &::=&
+     \{ \ELEM~\vec(\funcelem), \MAX~\u32^? \} \\
+   \production{(function element)} & \funcelem &::=&
+     \funcaddr^? \\
+   \end{array}
+
+It is an invariant of the semantics that the length of the element vector never exceeds the maximum size, if present.
+
+.. note::
+   Other table elements may be added in future versions of WebAssembly.
+
+
+.. _syntax-meminst:
+.. _page-size:
+.. index:: ! memory instance, memory, byte, ! page size, memory type
+   pair: abstract syntax; memory instance
+   pair: memory; instance
+
+Memory Instances
+~~~~~~~~~~~~~~~~
+
+A *memory instance* is the runtime representation of a linear :ref:`memory <syntax-mem>`.
+It holds a vector of bytes and an optional maximum size, if one was specified at the definition site of the memory.
+
+.. math::
+   \begin{array}{llll}
+   \production{(memory instance)} & \meminst &::=&
+     \{ \DATA~\vec(\byte), \MAX~\u32^? \} \\
+   \end{array}
+
+The length of the vector always is a multiple of the WebAssembly *page size*, which is defined to be the constant :math:`65536` -- abbreviated :math:`64\,\F{Ki}`.
+Like in a :ref:`memory type <syntax-memtype>`, the maximum size in a memory instance is given in units of this page size.
+
+The bytes can be mutated through :ref:`memory instructions <syntax-instr-memory>`, the execution of a :ref:`data segment <syntax-data>`, or by external means provided by the :ref:`embedder <embedder>`.
+
+It is an invariant of the semantics that the length of the byte vector, divided by page size, never exceeds the maximum size, if present.
+
+
+.. _syntax-globalinst:
+.. index:: ! global instance, value
+   pair: abstract syntax; global instance
+   pair: global; instance
+
+Global Instances
+~~~~~~~~~~~~~~~~
+
+A *global instance* is the runtime representation of a :ref:`global <syntax-global>` variable.
+It holds an individual :ref:`value <syntax-val>` and a flag indicating whether it is mutable.
+
+.. math::
+   \begin{array}{llll}
+   \production{(global instance)} & \globalinst &::=&
+     \{ \VALUE~\val, \MUT~\mut \} \\
+   \end{array}
+
+The value of mutable globals can be mutated through specific instructions or by external means provided by the :ref:`embedder <embedder>`.
+
+
+.. _syntax-exportinst:
+.. index:: ! export instance, name, external value
+   pair: abstract syntax; export instance
+   pair: export; instance
+
+Export Instances
+~~~~~~~~~~~~~~~~
+
+An *export instance* is the runtime representation of an :ref:`export <syntax-export>`.
+It defines the export's :ref:`name <syntax-name>` and the :ref:`external value <syntax-externval>` being exported.
+
+.. math::
+   \begin{array}{llll}
+   \production{(export instance)} & \exportinst &::=&
+     \{ \NAME~\name, \VALUE~\externval \} \\
+   \end{array}
+
+
+.. _syntax-externval:
+.. index:: ! external value, function address, table address, memory address, global address
+   pair: abstract syntax; external value
+   pair: external; value
+
+External Values
+~~~~~~~~~~~~~~~
+
+An *external value* is the runtime representation of an entity that can be imported or exported.
+It is an :ref:`address <syntax-addr>` denoting either a :ref:`function instance <syntax-funcinst>`, :ref:`table instance <syntax-tableinst>`, :ref:`memory instance <syntax-meminst>`, or :ref:`global instances <syntax-globalinst>` in the shared :ref:`store <syntax-store>`.
+
+.. math::
+   \begin{array}{llll}
+   \production{(external value)} & \externval &::=&
+     \FUNC~\funcaddr ~|~
+     \TABLE~\tableaddr ~|~
+     \MEM~\memaddr ~|~
+     \GLOBAL~\globaladdr \\
+   \end{array}
+
+
+Conventions
+...........
+
+The following auxiliary notation is defined for sequences of external values.
+It filters out entries of a specific kind in an order-preserving fashion:
+
+.. math::
+   \begin{array}{lcl}
+   \funcs(\externval^\ast) &=& [\funcaddr ~|~ (\FUNC~\funcaddr) \in \externval^\ast] \\
+   \tables(\externval^\ast) &=& [\tableaddr ~|~ (\TABLE~\tableaddr) \in \externval^\ast] \\
+   \mems(\externval^\ast) &=& [\memaddr ~|~ (\MEM~\memaddr) \in \externval^\ast] \\
+   \globals(\externval^\ast) &=& [\globaladdr ~|~ (\GLOBAL~\globaladdr) \in \externval^\ast] \\
+   \end{array}
+
+
+.. _syntax-externtype:
+.. index:: ! external type, function type, table type, memory type, global type
+   pair: abstract syntax; external type
+   pair: external; type
+
+External Types
+~~~~~~~~~~~~~~
+
+*External types* classify :ref:`external values <syntax-externval>`, and thereby imports and exports, with their respective types.
+
+.. math::
+   \begin{array}{llll}
+   \production{external types} & \externtype &::=&
+     \FUNC~\functype ~|~
+     \TABLE~\tabletype ~|~
+     \MEM~\memtype ~|~
+     \GLOBAL~\globaltype \\
+   \end{array}
+
+
+Conventions
+...........
+
+The following auxiliary notation is defined for sequences of external types.
+It filters out entries of a specific kind in an order-preserving fashion:
+
+.. math::
+   \begin{array}{lcl}
+   \funcs(\externtype^\ast) &=& [\functype ~|~ (\FUNC~\functype) \in \externtype^\ast] \\
+   \tables(\externtype^\ast) &=& [\tabletype ~|~ (\TABLE~\tabletype) \in \externtype^\ast] \\
+   \mems(\externtype^\ast) &=& [\memtype ~|~ (\MEM~\memtype) \in \externtype^\ast] \\
+   \globals(\externtype^\ast) &=& [\globaltype ~|~ (\GLOBAL~\globaltype) \in \externtype^\ast] \\
+   \end{array}
+
+
+.. _stack:
+.. _frame:
+.. _label:
+.. _syntax-frame:
+.. _syntax-label:
+.. index:: ! stack, ! frame, ! label
+   pair: abstract syntax; frame
+   pair: abstract syntax; label
+
+Stack
+~~~~~
+
+Besides the :ref:`store <store>`, most :ref:`instructions <syntax-instr>` interact with an implicit *stack*.
+The stack contains three kinds of entries:
+
+* *Values*: the *operands* (arguments and results) of instructions.
+
+* *Labels*: active (entered) :ref:`structured control instructions <syntax-instr-control>` that can be targeted by branches.
+
+* *Activations*: the *call frames* of active :ref:`function <syntax-func>` calls.
+
+These entries can occur on the stack in any order during the execution of a program.
+Stack entries are described by abstract syntax as follows.
+
+.. note::
+   It is possible to model the WebAssebmly semantics using separate stacks for operands, control constructs, and calls.
+   However, because the stacks are interdependent, additional book keeping about associated stack heights would be required.
+   For the purpose of this specification, an interleaved representation is simpler.
+
+
+Values
+......
+
+Values are represented by :ref:`themselves <syntax-val>`.
+
+Labels
+......
+
+Labels carry an argument arity :math:`n` and their associated branch *target*, which is expressed syntactically as an :ref:`instruction <syntax-instr>` sequence:
+
+.. math::
+   \begin{array}{llll}
+   \production{(label)} & \label &::=&
+     \LABEL_n\{\instr^\ast\} \\
+   \end{array}
+
+Intuitively, :math:`\instr^\ast` is the *continuation* to execute when the branch is taken, in place of the original control construct.
+
+.. note::
+   For example, a loop label has the form
+
+   .. math::
+      \LABEL_n\{\LOOP~[t^?]~\dots~\END\}
+
+   When performing a branch to this label, this executes the loop, effectively restarting it from the beginning.
+   Conversely, a simple block label has the form
+
+   .. math::
+      \LABEL_n\{\epsilon\}
+
+   When branching, the empty continuation ends the targeted block, such that execution can proceed with consecutive instructions.
+
+Frames
+......
+
+Activation frames carry the return arity of the respective function,
+hold the values of its :ref:`locals <syntax-local>` (including arguments) in the order corresponding to their static :ref:`local indices <syntax-localidx>`,
+and a reference to the function's own :ref:`module instance <syntax-moduleinst>`:
+
+.. math::
+   \begin{array}{llll}
+   \production{(activation)} & \X{activation} &::=&
+     \FRAME_n\{\frame\} \\
+   \production{(frame)} & \frame &::=&
+     \{ \LOCALS~\val^\ast, \MODULE~\moduleinst\} \\
+   \end{array}
+
+The values of the locals are mutated by respective :ref:`variable instructions <syntax-instr-var>`.
+
+
+Conventions
+...........
+
+* The meta variable :math:`L` ranges over labels where clear from context.
+
+* The meta variable :math:`F` ranges over frames where clear from context.
+
+.. note::
+   In the current version of WebAssembly, the arities of labels and activations cannot be larger than :math:`1`.
+   This may be generalized in future versions.
+
+
+.. _syntax-instr-admin:
+.. index:: ! administrative instructions, function, function instance, function address, label, frame, instruction, trap
+   pair:: abstract syntax; administrative instruction
+
+Administrative Instructions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+.. note::
+   This section is only relevant for the :ref:`formal notation <exec-notation>`.
+
+In order to express the reduction of :ref:`traps <trap>`, calls, and :ref:`control instructions <syntax-instr-control>`, the syntax of instructions is extended to include the following *administrative instructions*:
+
+.. math::
+   \begin{array}{llll}
+   \production{(administrative instruction)} & \instr &::=&
+     \dots ~|~ \\&&&
+     \TRAP ~|~ \\&&&
+     \INVOKE~\funcaddr ~|~ \\&&&
+     \LABEL_n\{\instr^\ast\}~\instr^\ast~\END ~|~ \\&&&
+     \FRAME_n\{\frame\}~\instr^\ast~\END ~|~ \\
+   \end{array}
+
+The |TRAP| instruction represents the occurrence of a trap.
+Traps are bubbled up through nested instruction sequences, ultimately reducing the entire program to a single |TRAP| instruction, signalling termination.
+
+The |INVOKE| instruction represents the imminent invocation of a :ref:`function instance <syntax-funcinst>`, identified by its :ref:`address <syntax-funcaddr>`.
+It unifies the handling of different forms of calls.
+
+The |LABEL| and |FRAME| instructions model :ref:`labels <syntax-label>` and :ref:`frames <syntax-frame>` :ref:`"on the stack" <exec-notation>`.
+Moreover, the administrative syntax maintains the nesting structure of the original :ref:`structured control instruction <syntax-instr-control>` or :ref:`function body <syntax-func>` and their :ref:`instruction sequences <syntax-instr-seq>`.
+That way, the end of the inner instruction sequence is tracked when part of an outer sequence.
+
+.. note::
+   For example, the :ref:`reduction rule <exec-block>` for |BLOCK| is:
+
+   .. math::
+      \BLOCK~[t^n]~\instr^\ast~\END \quad\stepto\quad
+      \LABEL_n\{\epsilon\}~\instr^\ast~\END
+
+   This replaces the block with a label instruction,
+   which can be interpreted as "pushing" the label on the stack.
+   When |END| is reached, i.e., the inner instruction sequence has been reduced to the empty sequence -- or a sequence of |CONST| instructions, the representation of non-empty local operand stack -- then the |LABEL| instruction is eliminated courtesy of its own :ref:`reduction rule <exec-label>`:
+
+   .. math::
+      \LABEL_n\{\instr^\ast\}~\val^\ast~\END \quad\stepto\quad \val^\ast
+
+   This can be interpreted as removing the label from the stack and only leaving the locally accumulated operand values.
+
+.. commented out
+   Both rules can be seen in concert in the following example:
+
+   .. math::
+      \begin{array}{@{}ll}
+      & (\F32.\CONST~1)~\BLOCK~[]~(\F32.\CONST~2)~\F32.\NEG~\END~\F32.\ADD \\
+      \stepto & (\F32.\CONST~1)~\LABEL_0\{\}~(\F32.\CONST~2)~\F32.\NEG~\END~\F32.\ADD \\
+      \stepto & (\F32.\CONST~1)~\LABEL_0\{\}~(\F32.\CONST~{-}2)~\END~\F32.\ADD \\
+      \stepto & (\F32.\CONST~1)~(\F32.\CONST~{-}2)~\F32.\ADD \\
+      \stepto & (\F32.\CONST~{-}1) \\
+      \end{array}
+
+
+.. _syntax-ctxt-label:
+.. index:: ! evaluation context
+
+Block Contexts
+..............
+
+To express :ref:`branches <syntax-instr-control>`, the following syntax of *block contexts* is defined, indexed by the count :math:`k` of labels surrounding the hole:
+
+.. math::
+   \begin{array}{llll}
+   \production{(block contexts)} & \XB^0 &::=&
+     \val^\ast~[\_]~\instr^\ast \\
+   \production{(block contexts)} & \XB^{k+1} &::=&
+     \val^\ast~\LABEL_n\{\instr^\ast\}~\XB^k~\END~\instr^\ast \\
+   \end{array}
+
+This definition allows to index active labels surrounding a :ref:`branch <syntax-br>` or :ref:`return <syntax-return>` instruction.
+
+.. note::
+   For example, the :ref:`reduction <exec-br>` of a simple branch can be defined as follows:
+
+   .. math::
+      \LABEL_0\{\instr^\ast\}~\XB^l[\BR~l]~\END \quad\stepto\quad \instr^\ast
+
+   Here, the hole :math:`[\_]` of the context is instantiated with a branch instruction.
+   When a branch occurs,
+   this rule replaces the targeted label and associated instruction sequence with the label's continuation.
+   The right label is identified through the :ref:`label index <syntax-labelidx>` :math:`l`, which corresponds to the number of surrounding |LABEL| instructions that must be hopped over -- which is exactly the count encoded in the index of a block context.
+
+
+.. _syntax-ctxt-eval:
+.. index:: ! evaluation context
+
+Evaluation Contexts
+...................
+
+Finally, the following definition of *evaluation context* and associated structural rules enable reduction inside instruction sequences and administrative forms as well as the propagation of traps:
+
+.. math::
+   \begin{array}{llll}
+   \production{(evaluation contexts)} & E &::=&
+     [\_] ~|~
+     \val^\ast~E~\instr^\ast ~|~
+     \LABEL_n\{\instr^\ast\}~E~\END ~|~
+     \FRAME_n\{\frame\}~E~\END \\
+   \end{array}
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   S; F; E[\instr^\ast] &\stepto& S'; F'; E[{\instr'}^\ast]
+     & (\mbox{if}~S; F; \instr^\ast \stepto S'; F'; {\instr'}^\ast) \\
+   S; F; E[\TRAP] &\stepto& S; F; \TRAP
+     & (\mbox{if}~E \neq [\_]) \\
+   \end{array}
diff --git a/document/index.rst b/document/index.rst
index 6060619a7..417975647 100644
--- a/document/index.rst
+++ b/document/index.rst
@@ -11,9 +11,7 @@ WebAssembly Specification
    introduction/index
    syntax/index
    validation/index
-   instantiation/index
    execution/index
-   instructions/index
    binary/index
    appendix-properties/index
    appendix-algorithm/index
diff --git a/document/instantiation/index.rst b/document/instantiation/index.rst
deleted file mode 100644
index 2fdfe1ac1..000000000
--- a/document/instantiation/index.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-Instantiation
-=============
-
-.. toctree::
-   :maxdepth: 2
-
-   conventions
-   instantiation
diff --git a/document/math.def b/document/math.def
index d79f1fea3..6d970bc71 100644
--- a/document/math.def
+++ b/document/math.def
@@ -20,6 +20,7 @@
 .. Auxiliary definitions for grammars
 
 .. |production| mathdef:: \void
+.. |with| mathdef:: ~\xref{syntax/conventions}{syntax-record}{\mbox{with}}~
 
 
 .. Values, terminals
@@ -32,31 +33,31 @@
 
 .. |byte| mathdef:: \xref{syntax/values}{syntax-byte}{\X{byte}}
 
-.. |uX#1| mathdef:: {\X{uint}_{#1}}
-.. |sX#1| mathdef:: {\X{sint}_{#1}}
-.. |iX#1| mathdef:: {\X{int}_{#1}}
-.. |fX#1| mathdef:: {\X{float}_{#1}}
+.. |uX#1| mathdef:: {\X{u}#1}
+.. |sX#1| mathdef:: {\X{s}#1}
+.. |iX#1| mathdef:: {\X{i}#1}
+.. |fX#1| mathdef:: {\X{f}#1}
 
 .. |uN| mathdef:: \xref{syntax/values}{syntax-int}{\uX{N}}
-.. |u1| mathdef:: \xref{syntax/values}{syntax-int}{\uX{1}}
-.. |u8| mathdef:: \xref{syntax/values}{syntax-int}{\uX{8}}
-.. |u16| mathdef:: \xref{syntax/values}{syntax-int}{\uX{16}}
-.. |u32| mathdef:: \xref{syntax/values}{syntax-int}{\uX{32}}
-.. |u64| mathdef:: \xref{syntax/values}{syntax-int}{\uX{64}}
+.. |u1| mathdef:: \xref{syntax/values}{syntax-int}{\uX{\X{1}}}
+.. |u8| mathdef:: \xref{syntax/values}{syntax-int}{\uX{\X{8}}}
+.. |u16| mathdef:: \xref{syntax/values}{syntax-int}{\uX{\X{16}}}
+.. |u32| mathdef:: \xref{syntax/values}{syntax-int}{\uX{\X{32}}}
+.. |u64| mathdef:: \xref{syntax/values}{syntax-int}{\uX{\X{64}}}
 
 .. |sN| mathdef:: \xref{syntax/values}{syntax-int}{\sX{N}}
-.. |s8| mathdef:: \xref{syntax/values}{syntax-int}{\sX{8}}
-.. |s16| mathdef:: \xref{syntax/values}{syntax-int}{\sX{16}}
-.. |s32| mathdef:: \xref{syntax/values}{syntax-int}{\sX{32}}
-.. |s64| mathdef:: \xref{syntax/values}{syntax-int}{\sX{64}}
+.. |s8| mathdef:: \xref{syntax/values}{syntax-int}{\sX{\X{8}}}
+.. |s16| mathdef:: \xref{syntax/values}{syntax-int}{\sX{\X{16}}}
+.. |s32| mathdef:: \xref{syntax/values}{syntax-int}{\sX{\X{32}}}
+.. |s64| mathdef:: \xref{syntax/values}{syntax-int}{\sX{\X{64}}}
 
 .. |iN| mathdef:: \xref{syntax/values}{syntax-int}{\iX{N}}
-.. |i32| mathdef:: \xref{syntax/values}{syntax-int}{\iX{32}}
-.. |i64| mathdef:: \xref{syntax/values}{syntax-int}{\iX{64}}
+.. |i32| mathdef:: \xref{syntax/values}{syntax-int}{\iX{\X{32}}}
+.. |i64| mathdef:: \xref{syntax/values}{syntax-int}{\iX{\X{64}}}
 
 .. |fN| mathdef:: \xref{syntax/values}{syntax-float}{\fX{N}}
-.. |f32| mathdef:: \xref{syntax/values}{syntax-float}{\fX{32}}
-.. |f64| mathdef:: \xref{syntax/values}{syntax-float}{\fX{64}}
+.. |f32| mathdef:: \xref{syntax/values}{syntax-float}{\fX{\X{32}}}
+.. |f64| mathdef:: \xref{syntax/values}{syntax-float}{\fX{\X{64}}}
 
 .. |vec| mathdef:: \xref{syntax/values}{syntax-vec}{\X{vec}}
 .. |name| mathdef:: \xref{syntax/values}{syntax-name}{\X{name}}
@@ -67,29 +68,29 @@
 
 .. |Bbyte| mathdef:: \xref{binary/values}{binary-byte}{\B{byte}}
 
-.. |BuX#1| mathdef:: {\B{uint}_{#1}}
-.. |BsX#1| mathdef:: {\B{sint}_{#1}}
-.. |BiX#1| mathdef:: {\B{int}_{#1}}
-.. |BfX#1| mathdef:: {\B{float}_{#1}}
+.. |BuX#1| mathdef:: {\B{u}#1}
+.. |BsX#1| mathdef:: {\B{s}#1}
+.. |BiX#1| mathdef:: {\B{i}#1}
+.. |BfX#1| mathdef:: {\B{f}#1}
 
 .. |BuN| mathdef:: \xref{binary/values}{binary-int}{\BuX{N}}
-.. |Bu1| mathdef:: \xref{binary/values}{binary-int}{\BuX{1}}
-.. |Bu8| mathdef:: \xref{binary/values}{binary-int}{\BuX{8}}
-.. |Bu16| mathdef:: \xref{binary/values}{binary-int}{\BuX{16}}
-.. |Bu32| mathdef:: \xref{binary/values}{binary-int}{\BuX{32}}
-.. |Bu64| mathdef:: \xref{binary/values}{binary-int}{\BuX{64}}
+.. |Bu1| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{1}}}
+.. |Bu8| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{8}}}
+.. |Bu16| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{16}}}
+.. |Bu32| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{32}}}
+.. |Bu64| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{64}}}
 
 .. |BsN| mathdef:: \xref{binary/values}{binary-int}{\BsX{N}}
-.. |Bs32| mathdef:: \xref{binary/values}{binary-int}{\BsX{32}}
-.. |Bs64| mathdef:: \xref{binary/values}{binary-int}{\BsX{64}}
+.. |Bs32| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{32}}}
+.. |Bs64| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{64}}}
 
 .. |BiN| mathdef:: \xref{binary/values}{binary-int}{\BiX{N}}
-.. |Bi32| mathdef:: \xref{binary/values}{binary-int}{\BiX{32}}
-.. |Bi64| mathdef:: \xref{binary/values}{binary-int}{\BiX{64}}
+.. |Bi32| mathdef:: \xref{binary/values}{binary-int}{\BiX{\B{32}}}
+.. |Bi64| mathdef:: \xref{binary/values}{binary-int}{\BiX{\B{64}}}
 
 .. |BfN| mathdef:: \xref{binary/values}{binary-float}{\BfX{N}}
-.. |Bf32| mathdef:: \xref{binary/values}{binary-float}{\BfX{32}}
-.. |Bf64| mathdef:: \xref{binary/values}{binary-float}{\BfX{64}}
+.. |Bf32| mathdef:: \xref{binary/values}{binary-float}{\BfX{\B{32}}}
+.. |Bf64| mathdef:: \xref{binary/values}{binary-float}{\BfX{\B{64}}}
 
 .. |Bvec| mathdef:: \xref{binary/values}{binary-vec}{\B{vec}}
 .. |Bname| mathdef:: \xref{binary/values}{binary-name}{\B{name}}
@@ -100,13 +101,16 @@
 
 .. Types, terminals
 
+.. |I8| mathdef:: \xref{execution/runtime}{syntax-storagetype}{\K{i8}}
+.. |I16| mathdef:: \xref{execution/runtime}{syntax-storagetype}{\K{i16}}
 .. |I32| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i32}}
 .. |I64| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i64}}
 .. |F32| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f32}}
 .. |F64| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f64}}
 
 .. |ANYFUNC| mathdef:: \xref{syntax/types}{syntax-elemtype}{\K{anyfunc}}
-.. |MUT| mathdef:: \xref{syntax/types}{syntax-mut}{\K{mut}}
+.. |MVAR| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}}
+.. |MCONST| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}}
 
 .. |MIN| mathdef:: \K{min}
 .. |MAX| mathdef:: \K{max}
@@ -121,7 +125,6 @@
 .. |tabletype| mathdef:: \xref{syntax/types}{syntax-tabletype}{\X{tabletype}}
 .. |elemtype| mathdef:: \xref{syntax/types}{syntax-elemtype}{\X{elemtype}}
 .. |memtype| mathdef:: \xref{syntax/types}{syntax-memtype}{\X{memtype}}
-.. |externtype| mathdef:: \xref{syntax/types}{syntax-externtype}{\X{externtype}}
 .. |limits| mathdef:: \xref{syntax/types}{syntax-limits}{\X{limits}}
 .. |mut| mathdef:: \xref{syntax/types}{syntax-mut}{\X{mut}}
 
@@ -136,7 +139,6 @@
 .. |Btabletype| mathdef:: \xref{binary/types}{binary-tabletype}{\B{tabletype}}
 .. |Belemtype| mathdef:: \xref{binary/types}{binary-elemtype}{\B{elemtype}}
 .. |Bmemtype| mathdef:: \xref{binary/types}{binary-memtype}{\B{memtype}}
-.. |Bexterntype| mathdef:: \xref{binary/types}{binary-externtype}{\B{externtype}}
 .. |Blimits| mathdef:: \xref{binary/types}{binary-limits}{\B{limits}}
 .. |Bmut| mathdef:: \xref{binary/types}{binary-mut}{\B{mut}}
 
@@ -169,6 +171,7 @@
 .. |GLOBALS| mathdef:: \K{globals}
 .. |LOCALS| mathdef:: \K{locals}
 .. |LABELS| mathdef:: \K{labels}
+.. |LRETURN| mathdef:: \K{return}
 .. |IMPORTS| mathdef:: \K{imports}
 .. |EXPORTS| mathdef:: \K{exports}
 
@@ -178,8 +181,6 @@
 .. |TABLE| mathdef:: \K{table}
 .. |MEM| mathdef:: \K{mem}
 .. |GLOBAL| mathdef:: \K{global}
-.. |LOCAL| mathdef:: \K{local}
-.. |LABEL| mathdef:: \K{label}
 .. |IMPORT| mathdef:: \K{import}
 .. |EXPORT| mathdef:: \K{export}
 .. |CODE| mathdef:: \K{code}
@@ -251,10 +252,10 @@
 
 .. Modules, meta functions
 
-.. |funcs| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{funcs}}
-.. |tables| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{tables}}
-.. |mems| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{mems}}
-.. |globals| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{globals}}
+.. |funcs| mathdef:: \xref{execution/runtime}{syntax-externtype}{\F{funcs}}
+.. |tables| mathdef:: \xref{execution/runtime}{syntax-externtype}{\F{tables}}
+.. |mems| mathdef:: \xref{execution/runtime}{syntax-externtype}{\F{mems}}
+.. |globals| mathdef:: \xref{execution/runtime}{syntax-externtype}{\F{globals}}
 
 
 .. Instructions, terminals
@@ -331,14 +332,35 @@
 .. |DEMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{demote}}
 .. |REINTERPRET| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{reinterpret}}
 
+.. |TRAP| mathdef:: \xref{execution/runtime}{syntax-instr-admin}{\K{trap}}
+.. |LABEL| mathdef:: \xref{execution/runtime}{syntax-instr-admin}{\K{label}}
+.. |FRAME| mathdef:: \xref{execution/runtime}{syntax-instr-admin}{\K{frame}}
+
+.. |INVOKE| mathdef:: \xref{execution/instructions}{syntax-instr-admin}{\K{invoke}}
+.. |INSTANTIATE| mathdef:: \xref{execution/modules}{syntax-instantiate}{\K{instantiate}}
+.. |INITIALIZE| mathdef:: \xref{execution/modules}{syntax-instantiate}{\K{initialize}}
+.. |INITGLOBAL| mathdef:: \xref{execution/modules}{syntax-instantiate}{\K{init\_global}}
+.. |INITTABLE| mathdef:: \xref{execution/modules}{syntax-instantiate}{\K{init\_table}}
+.. |INITMEM| mathdef:: \xref{execution/modules}{syntax-instantiate}{\K{init\_mem}}
+
 
 .. Instructions, non-terminals
 
-.. |unop| mathdef:: \X{unop}
-.. |binop| mathdef:: \X{binop}
-.. |testop| mathdef:: \X{testop}
-.. |relop| mathdef:: \X{relop}
-.. |cvtop| mathdef:: \X{cvtop}
+.. |unop| mathdef:: \xref{syntax/instructions}{syntax-unop}{\X{unop}}
+.. |binop| mathdef:: \xref{syntax/instructions}{syntax-binop}{\X{binop}}
+.. |testop| mathdef:: \xref{syntax/instructions}{syntax-testop}{\X{testop}}
+.. |relop| mathdef:: \xref{syntax/instructions}{syntax-relop}{\X{relop}}
+.. |cvtop| mathdef:: \xref{syntax/instructions}{syntax-cvtop}{\X{cvtop}}
+
+.. |iunop| mathdef:: \xref{syntax/instructions}{syntax-iunop}{\X{iunop}}
+.. |ibinop| mathdef:: \xref{syntax/instructions}{syntax-ibinop}{\X{ibinop}}
+.. |itestop| mathdef:: \xref{syntax/instructions}{syntax-itestop}{\X{itestop}}
+.. |irelop| mathdef:: \xref{syntax/instructions}{syntax-irelop}{\X{irelop}}
+
+.. |funop| mathdef:: \xref{syntax/instructions}{syntax-funop}{\X{funop}}
+.. |fbinop| mathdef:: \xref{syntax/instructions}{syntax-fbinop}{\X{fbinop}}
+.. |ftestop| mathdef:: \xref{syntax/instructions}{syntax-ftestop}{\X{ftestop}}
+.. |frelop| mathdef:: \xref{syntax/instructions}{syntax-frelop}{\X{frelop}}
 
 .. |sx| mathdef:: \xref{syntax/instructions}{syntax-sx}{\X{sx}}
 .. |memarg| mathdef:: \xref{syntax/instructions}{syntax-memarg}{\X{memarg}}
@@ -353,3 +375,50 @@
 
 .. |Binstr| mathdef:: \xref{binary/instructions}{binary-instr}{\B{instr}}
 .. |Bexpr| mathdef:: \xref{binary/instructions}{binary-expr}{\B{expr}}
+
+
+.. Runtime, terminals
+
+.. |MUT| mathdef:: \K{mut}
+
+
+.. Runtime, non-terminals
+
+.. |val| mathdef:: \xref{execution/runtime}{syntax-val}{\X{val}}
+
+.. |addr| mathdef:: \xref{execution/runtime}{syntax-addr}{\X{addr}}
+.. |funcaddr| mathdef:: \xref{execution/runtime}{syntax-funcaddr}{\X{funcaddr}}
+.. |tableaddr| mathdef:: \xref{execution/runtime}{syntax-tableaddr}{\X{tableaddr}}
+.. |memaddr| mathdef:: \xref{execution/runtime}{syntax-memaddr}{\X{memaddr}}
+.. |globaladdr| mathdef:: \xref{execution/runtime}{syntax-globaladdr}{\X{globaladdr}}
+
+.. |moduleinst| mathdef:: \xref{execution/runtime}{syntax-moduleinst}{\X{moduleinst}}
+.. |funcinst| mathdef:: \xref{execution/runtime}{syntax-funcinst}{\X{funcinst}}
+.. |tableinst| mathdef:: \xref{execution/runtime}{syntax-tableinst}{\X{tableinst}}
+.. |funcelem| mathdef:: \xref{execution/runtime}{syntax-funcelem}{\X{funcelem}}
+.. |meminst| mathdef:: \xref{execution/runtime}{syntax-meminst}{\X{meminst}}
+.. |globalinst| mathdef:: \xref{execution/runtime}{syntax-globalinst}{\X{globalinst}}
+.. |exportinst| mathdef:: \xref{execution/runtime}{syntax-exportinst}{\X{exportinst}}
+
+.. |externval| mathdef:: \xref{execution/runtime}{syntax-externval}{\X{externval}}
+.. |externtype| mathdef:: \xref{execution/runtime}{syntax-externtype}{\X{externtype}}
+.. |storagetype| mathdef:: \xref{execution/runtime}{syntax-storagetype}{\X{storagetype}}
+
+.. |store| mathdef:: \xref{execution/runtime}{syntax-store}{\X{store}}
+.. |frame| mathdef:: \xref{execution/runtime}{syntax-frame}{\X{frame}}
+.. |label| mathdef:: \xref{execution/runtime}{syntax-label}{\X{label}}
+
+.. |XB| mathdef:: \xref{execution/runtime}{syntax-ctxt-block}{B}
+
+
+.. Execution, notation
+
+.. |stepto| mathdef:: \hookrightarrow
+.. |mod| mathdef:: \mathbin{\F{mod}}
+
+.. Numerics, meta functions
+
+.. |bytes| mathdef:: \xref{execution/numerics}{aux-bytes}{\F{bytes}}
+.. |signed| mathdef:: \xref{execution/numerics}{aux-signed}{\F{signed}}
+.. |extend| mathdef:: \xref{execution/numerics}{aux-extend}{\F{extend}}
+.. |wrap| mathdef:: \xref{execution/numerics}{aux-wrap}{\F{wrap}}
diff --git a/document/syntax/conventions.rst b/document/syntax/conventions.rst
index 63413f545..3f0c82b3b 100644
--- a/document/syntax/conventions.rst
+++ b/document/syntax/conventions.rst
@@ -30,6 +30,9 @@ The following conventions are adopted in defining grammar rules for abstract syn
 * :math:`A^\ast` is a possibly empty sequence of iterations of :math:`A`.
   (This is a shorthand for :math:`A^n` used where :math:`n` is not relevant.)
 
+* :math:`A^+` is a possibly empty sequence of iterations of :math:`A`.
+  (This is a shorthand for :math:`A^n` where :math:`n \geq 1`.)
+
 * :math:`A^?` is an optional occurrence of :math:`A`.
   (This is a shorthand for :math:`A^n` where :math:`n \leq 1`.)
 
@@ -47,11 +50,39 @@ When dealing with syntactic constructs the following notation is also used:
 
 * :math:`s[i]` denotes the :math:`i`-th element of a sequence :math:`s`, starting from :math:`0`.
 
-Productions of the following form are interpreted as *records* that map a fixed set of fields :math:`\K{field}_i` to values :math:`x_i`, respectively:
+* :math:`s[i:n]` denotes the sub-sequence :math:`s[i]~\dots~s[i+n-1]` of a sequence :math:`s`.
+
+* :math:`s \with [i] = A` denotes the same sequence as :math:`s`,
+  except that the :math:`i`-the element is replaced with :math:`A`.
+
+* :math:`s \with [i:n] = A^n` denotes the same sequence as :math:`s`,
+  except that the sub-sequence :math:`s[i:n]` is replaced with :math:`A^n`.
+
+Moreover, the following conventions are employed:
+
+* The notation :math:`x^n`, where :math:`x` is a non-terminal symbol, is treated as a meta variable ranging over respective sequences of :math:`x` (similarly for :math:`x^\ast`, :math:`x^+`, :math:`x^?`).
+
+* When given a sequence :math:`x^n`,
+  then the occurrences of :math:`x` in a sequence written :math:`(A_1~x~A_2)^n` are assumed to be in point-wise correspondence with :math:`x^n`
+  (similarly for :math:`x^\ast`, :math:`x^+`, :math:`x^?`).
+  This implicitly expresses a form of mapping syntactic constructions over a sequence.
+
+Productions of the following form are interpreted as *records* that map a fixed set of fields :math:`\K{field}_i` to "values" :math:`A_i`, respectively:
 
 .. math::
-   \X{r} ~::=~ \{ \K{field}_1~x_1, \K{field}_2~x_2, \dots \}
+   \X{r} ~::=~ \{ \K{field}_1~A_1, \K{field}_2~A_2, \dots \}
 
 The following notation is adopted for manipulating such records:
 
-* :math:`r.\K{field}` denotes the :math:`\K{field}` component of :math:`r`.
+* :math:`r.\K{field}` denotes the value of the :math:`\K{field}` component of :math:`r`.
+
+* :math:`r \with \K{field} = A` denotes the same record as :math:`r`,
+  except that the value of the :math:`\K{field}` component is replaced with :math:`A`.
+
+The update notation for sequences and records generalizes recursively to nested components accessed by "paths" :math:`\X{pth} ::= ([\dots] \;| \;.\K{field})^+`:
+
+* :math:`s \with [i]\,\X{pth} = A` is short for :math:`s \with [i] = (s[i] \with \X{pth} = A)`.
+
+* :math:`r \with \K{field}\,\X{pth} = A` is short for :math:`r \with \K{field} = (r.\K{field} \with \X{pth} = A)`.
+
+where :math:`r \with .\K{field} = A` is shortened to :math:`r \with \K{field} = A`.
diff --git a/document/syntax/instructions.rst b/document/syntax/instructions.rst
index d1749c07a..07bf174d8 100644
--- a/document/syntax/instructions.rst
+++ b/document/syntax/instructions.rst
@@ -25,6 +25,19 @@ The following sections group instructions into a number of different categories.
 
 .. _syntax-sx:
 .. _syntax-instr-numeric:
+.. _syntax-const:
+.. _syntax-unop:
+.. _syntax-binop:
+.. _syntax-testop:
+.. _syntax-relop:
+.. _syntax-iunop:
+.. _syntax-ibinop:
+.. _syntax-itestop:
+.. _syntax-irelop:
+.. _syntax-funop:
+.. _syntax-fbinop:
+.. _syntax-ftestop:
+.. _syntax-frelop:
 .. index:: ! numeric instruction
    pair: abstract syntax; instruction
 
@@ -40,59 +53,73 @@ These operations closely match respective operations available in hardware.
      \K{32} ~|~ \K{64} \\
    \production{signedness} & \sx &::=&
      \K{u} ~|~ \K{s} \\
-   \production{instructions} & \instr &::=&
-     \K{i}\X{nn}\K{.const}~\xref{syntax/values}{syntax-int}{\iX{\X{nn}}} ~|~
-     \K{f}\X{nn}\K{.const}~\xref{syntax/values}{syntax-float}{\fX{\X{nn}}} ~|~ \\&&&
-     \K{i}\X{nn}\K{.eqz} ~|~ \\&&&
-     \K{i}\X{nn}\K{.eq} ~|~
-     \K{i}\X{nn}\K{.ne} ~|~
-     \K{i}\X{nn}\K{.lt\_}\sx ~|~
-     \K{i}\X{nn}\K{.gt\_}\sx ~|~
-     \K{i}\X{nn}\K{.le\_}\sx ~|~
-     \K{i}\X{nn}\K{.ge\_}\sx ~|~ \\&&&
-     \K{f}\X{nn}\K{.eq} ~|~
-     \K{f}\X{nn}\K{.ne} ~|~
-     \K{f}\X{nn}\K{.lt} ~|~
-     \K{f}\X{nn}\K{.gt} ~|~
-     \K{f}\X{nn}\K{.le} ~|~
-     \K{f}\X{nn}\K{.ge} ~|~ \\&&&
-     \K{i}\X{nn}\K{.clz} ~|~
-     \K{i}\X{nn}\K{.ctz} ~|~
-     \K{i}\X{nn}\K{.popcnt} ~|~ \\&&&
-     \K{i}\X{nn}\K{.add} ~|~
-     \K{i}\X{nn}\K{.sub} ~|~
-     \K{i}\X{nn}\K{.mul} ~|~
-     \K{i}\X{nn}\K{.div\_}\sx ~|~
-     \K{i}\X{nn}\K{.rem\_}\sx ~|~ \\&&&
-     \K{i}\X{nn}\K{.and} ~|~
-     \K{i}\X{nn}\K{.or} ~|~
-     \K{i}\X{nn}\K{.xor} ~|~ \\&&&
-     \K{i}\X{nn}\K{.shl} ~|~
-     \K{i}\X{nn}\K{.shr\_}\sx ~|~
-     \K{i}\X{nn}\K{.rotl} ~|~
-     \K{i}\X{nn}\K{.rotr} ~|~ \\&&&
-     \K{f}\X{nn}\K{.abs} ~|~
-     \K{f}\X{nn}\K{.neg} ~|~
-     \K{f}\X{nn}\K{.sqrt} ~|~ \\&&&
-     \K{f}\X{nn}\K{.ceil} ~|~ 
-     \K{f}\X{nn}\K{.floor} ~|~ 
-     \K{f}\X{nn}\K{.trunc} ~|~ 
-     \K{f}\X{nn}\K{.nearest} ~|~ \\&&&
-     \K{f}\X{nn}\K{.add} ~|~
-     \K{f}\X{nn}\K{.sub} ~|~
-     \K{f}\X{nn}\K{.mul} ~|~
-     \K{f}\X{nn}\K{.div} ~|~ \\&&&
-     \K{f}\X{nn}\K{.min} ~|~
-     \K{f}\X{nn}\K{.max} ~|~
-     \K{f}\X{nn}\K{.copysign} ~|~ \\&&&
-     \K{i32.wrap/i64} ~|~
-     \K{i64.extend\_}\sx/\K{i32} ~|~
-     \K{i}\X{nn}\K{.trunc\_}\sx/\K{f}\X{mm} ~|~ \\&&&
-     \K{f32.demote/f64} ~|~
-     \K{f64.promote/f32} ~|~
-     \K{f}\X{nn}\K{.convert\_}\sx/\K{i}\X{mm} ~|~ \\&&&
-     \K{i}\X{nn}\K{.reinterpret/f}\X{nn} ~|~
-     \K{f}\X{nn}\K{.reinterpret/i}\X{nn} \\
+   \production{instruction} & \instr &::=&
+     \K{i}\X{nn}\K{.}\CONST~\xref{syntax/values}{syntax-int}{\iX{\X{nn}}} ~|~
+     \K{f}\X{nn}\K{.}\CONST~\xref{syntax/values}{syntax-float}{\fX{\X{nn}}} ~|~ \\&&&
+     \K{i}\X{nn}\K{.}\iunop ~|~
+     \K{f}\X{nn}\K{.}\funop ~|~ \\&&&
+     \K{i}\X{nn}\K{.}\ibinop ~|~
+     \K{f}\X{nn}\K{.}\fbinop ~|~ \\&&&
+     \K{i}\X{nn}\K{.}\itestop ~|~ \\&&&
+     \K{i}\X{nn}\K{.}\irelop ~|~
+     \K{f}\X{nn}\K{.}\frelop ~|~ \\&&&
+     \K{i32.}\WRAP\K{/i64} ~|~
+     \K{i64.}\EXTEND\K{\_}\sx/\K{i32} ~|~
+     \K{i}\X{nn}\K{.}\TRUNC\K{\_}\sx/\K{f}\X{mm} ~|~ \\&&&
+     \K{f32.}\TRUNC\K{/f64} ~|~
+     \K{f64.}\PROMOTE\K{/f32} ~|~
+     \K{f}\X{nn}\K{.}\CONVERT\K{\_}\sx/\K{i}\X{mm} ~|~ \\&&&
+     \K{i}\X{nn}\K{.}\REINTERPRET\K{/f}\X{nn} ~|~
+     \K{f}\X{nn}\K{.}\REINTERPRET\K{/i}\X{nn} \\
+   \production{integer unary operator} & \iunop &::=&
+     \K{clz} ~|~
+     \K{ctz} ~|~
+     \K{popcnt} \\
+   \production{integer binary operator} & \ibinop &::=&
+     \K{add} ~|~
+     \K{sub} ~|~
+     \K{mul} ~|~
+     \K{div\_}\sx ~|~
+     \K{rem\_}\sx ~|~ \\&&&
+     \K{and} ~|~
+     \K{or} ~|~
+     \K{xor} ~|~
+     \K{shl} ~|~
+     \K{shr\_}\sx ~|~
+     \K{rotl} ~|~
+     \K{rotr} \\
+   \production{floating-point unary operator} & \funop &::=&
+     \K{abs} ~|~
+     \K{neg} ~|~
+     \K{sqrt} ~|~
+     \K{ceil} ~|~ 
+     \K{floor} ~|~ 
+     \K{trunc} ~|~ 
+     \K{nearest} \\
+   \production{floating-point binary operator} & \fbinop &::=&
+     \K{add} ~|~
+     \K{sub} ~|~
+     \K{mul} ~|~
+     \K{div} ~|~
+     \K{min} ~|~
+     \K{max} ~|~
+     \K{copysign} \\
+   \production{integer test operator} & \itestop &::=&
+     \K{eqz} \\
+   \production{integer relational operator} & \irelop &::=&
+     \K{eq} ~|~
+     \K{ne} ~|~
+     \K{lt\_}\sx ~|~
+     \K{gt\_}\sx ~|~
+     \K{le\_}\sx ~|~
+     \K{ge\_}\sx \\
+   \production{floating-point relational operator} & \frelop &::=&
+     \K{eq} ~|~
+     \K{ne} ~|~
+     \K{lt} ~|~
+     \K{gt} ~|~
+     \K{le} ~|~
+     \K{ge} \\
    \end{array}
 
 Numeric instructions are divided by :ref:`value type <syntax-valtype>`.
@@ -116,6 +143,28 @@ where a signedness annotation |sx| distinguishes whether the operands are to be
 For the other integer instructions, the use of 2's complement for the signed interpretation means that they behave the same regardless of signedness.
 
 
+Conventions
+...........
+
+Occasionally, it is convenient to group operators together according to the following grammar shorthands:
+
+.. math::
+   \begin{array}{llll}
+   \production{unary operator} & \unop &::=& \iunop ~|~ \funop \\
+   \production{binary operator} & \binop &::=& \ibinop ~|~ \fbinop \\
+   \production{test operator} & \testop &::=& \itestop \\
+   \production{relational operator} & \relop &::=& \irelop ~|~ \frelop \\
+   \production{conversion operator} & \cvtop &::=&
+     \WRAP ~|~
+     \EXTEND\K{\_}\sx ~|~
+     \TRUNC\K{\_}\sx ~|~
+     \CONVERT\K{\_}\sx ~|~
+     \DEMOTE ~|~
+     \PROMOTE ~|~
+     \REINTERPRET \\
+   \end{array}
+
+
 .. _syntax-instr-parametric:
 .. index:: ! parametric instruction
    pair: abstract syntax; instruction
@@ -127,7 +176,7 @@ Instructions in this group can operate on operands of any :ref:`value type <synt
 
 .. math::
    \begin{array}{llll}
-   \production{instructions} & \instr &::=&
+   \production{instruction} & \instr &::=&
      \dots ~|~ \\&&&
      \DROP ~|~ \\&&&
      \SELECT
@@ -149,7 +198,7 @@ Variable instructions are concerned with the access to :ref:`local <syntax-local
 
 .. math::
    \begin{array}{llll}
-   \production{instructions} & \instr &::=&
+   \production{instruction} & \instr &::=&
      \dots ~|~ \\&&&
      \GETLOCAL~\localidx ~|~ \\&&&
      \SETLOCAL~\localidx ~|~ \\&&&
@@ -163,6 +212,8 @@ The |TEELOCAL| instruction is like |SETLOCAL| but also returns its argument.
 
 
 .. _syntax-instr-memory:
+.. _syntax-load:
+.. _syntax-store:
 .. _syntax-memarg:
 .. index:: ! memory instruction, memory index
    pair: abstract syntax; instruction
@@ -176,18 +227,18 @@ Instructions in this group are concerned with :ref:`linear memory <sec-memory>`.
    \begin{array}{llll}
    \production{memory immediate} & \memarg &::=&
      \{ \OFFSET~\u32, \ALIGN~\u32 \} \\
-   \production{instructions} & \instr &::=&
+   \production{instruction} & \instr &::=&
      \dots ~|~ \\&&&
-     \K{i}\X{nn}\K{.load}~\memarg ~|~
-     \K{f}\X{nn}\K{.load}~\memarg ~|~ \\&&&
-     \K{i}\X{nn}\K{.store}~\memarg ~|~
-     \K{f}\X{nn}\K{.store}~\memarg ~|~ \\&&&
-     \K{i}\X{nn}\K{.load8\_}\sx~\memarg ~|~
-     \K{i}\X{nn}\K{.load16\_}\sx~\memarg ~|~
-     \K{i64.load32\_}\sx~\memarg ~|~ \\&&&
-     \K{i}\X{nn}\K{.store8}~\memarg ~|~
-     \K{i}\X{nn}\K{.store16}~\memarg ~|~
-     \K{i64.store32}~\memarg ~|~ \\&&&
+     \K{i}\X{nn}\K{.}\LOAD~\memarg ~|~
+     \K{f}\X{nn}\K{.}\LOAD~\memarg ~|~ \\&&&
+     \K{i}\X{nn}\K{.}\STORE~\memarg ~|~
+     \K{f}\X{nn}\K{.}\STORE~\memarg ~|~ \\&&&
+     \K{i}\X{nn}\K{.}\LOAD\K{8\_}\sx~\memarg ~|~
+     \K{i}\X{nn}\K{.}\LOAD\K{16\_}\sx~\memarg ~|~
+     \K{i64.}\LOAD\K{32\_}\sx~\memarg ~|~ \\&&&
+     \K{i}\X{nn}\K{.}\STORE\K{8}~\memarg ~|~
+     \K{i}\X{nn}\K{.}\STORE\K{16}~\memarg ~|~
+     \K{i64.}\STORE\K{32}~\memarg ~|~ \\&&&
      \CURRENTMEMORY ~|~ \\&&&
      \GROWMEMORY \\
    \end{array}
@@ -217,6 +268,7 @@ The precise semantics of memory instructions is :ref:`described <exec-instr-memo
 
 
 .. _syntax-instr-control:
+.. _syntax-isntr-seq:
 .. _syntax-label:
 .. index:: ! control instruction, ! structured control, ! label, ! block, ! branch, ! unwinding, result type, label index, function index, type index, vector
    pair: abstract syntax; instruction
@@ -228,7 +280,7 @@ Instructions in this group affect the flow of control.
 
 .. math::
    \begin{array}{llll}
-   \production{instructions} & \instr &::=&
+   \production{instruction} & \instr &::=&
      \dots ~|~ \\&&&
      \NOP ~|~ \\&&&
      \UNREACHABLE ~|~ \\&&&
@@ -301,7 +353,7 @@ Expressions
 
 .. math::
    \begin{array}{llll}
-   \production{expressions} & \expr &::=&
+   \production{expression} & \expr &::=&
      \instr^\ast~\END \\
    \end{array}
 
diff --git a/document/syntax/modules.rst b/document/syntax/modules.rst
index 2b5036bdd..d879612f9 100644
--- a/document/syntax/modules.rst
+++ b/document/syntax/modules.rst
@@ -13,7 +13,7 @@ and provide initialization logic in the form of :ref:`data <syntax-data>` and :r
 
 .. math::
    \begin{array}{lllll}
-   \production{modules} & \module &::=& \{ &
+   \production{module} & \module &::=& \{ &
      \TYPES~\vec(\functype), \\&&&&
      \FUNCS~\vec(\func), \\&&&&
      \TABLES~\vec(\table), \\&&&&
@@ -61,13 +61,13 @@ Each class of definition has its own *index space*, as distinguished by the foll
 
 .. math::
    \begin{array}{llll}
-   \production{type indices} & \typeidx &::=& \u32 \\
-   \production{function indices} & \funcidx &::=& \u32 \\
-   \production{table indices} & \tableidx &::=& \u32 \\
-   \production{memory indices} & \memidx &::=& \u32 \\
-   \production{global indices} & \globalidx &::=& \u32 \\
-   \production{local indices} & \localidx &::=& \u32 \\
-   \production{label indices} & \labelidx &::=& \u32 \\
+   \production{type index} & \typeidx &::=& \u32 \\
+   \production{function index} & \funcidx &::=& \u32 \\
+   \production{table index} & \tableidx &::=& \u32 \\
+   \production{memory index} & \memidx &::=& \u32 \\
+   \production{global index} & \globalidx &::=& \u32 \\
+   \production{local index} & \localidx &::=& \u32 \\
+   \production{label index} & \labelidx &::=& \u32 \\
    \end{array}
 
 The index space for functions, tables, memories and globals includes respective imports declared in the same module.
@@ -114,7 +114,7 @@ The |FUNCS| component of a module defines a vector of *functions* with the follo
 
 .. math::
    \begin{array}{llll}
-   \production{functions} & \func &::=&
+   \production{function} & \func &::=&
      \{ \TYPE~\typeidx, \LOCALS~\vec(\valtype), \BODY~\expr \} \\
    \end{array}
 
@@ -142,7 +142,7 @@ The |TABLES| component of a module defines a vector of *tables* described by the
 
 .. math::
    \begin{array}{llll}
-   \production{tables} & \table &::=&
+   \production{table} & \table &::=&
      \{ \TYPE~\tabletype \} \\
    \end{array}
 
@@ -172,7 +172,7 @@ The |MEMS| component of a module defines a vector of *linear memories* (or *memo
 
 .. math::
    \begin{array}{llll}
-   \production{memories} & \mem &::=&
+   \production{memory} & \mem &::=&
      \{ \TYPE~\memtype \} \\
    \end{array}
 
@@ -203,7 +203,7 @@ The |GLOBALS| component of a module defines a vector of *global variables* (or *
 
 .. math::
    \begin{array}{llll}
-   \production{globals} & \global &::=&
+   \production{global} & \global &::=&
      \{ \TYPE~\globaltype, \INIT~\expr \} \\
    \end{array}
 
@@ -229,7 +229,7 @@ The |ELEM| component of a module defines a vector of *element segments* that ini
 
 .. math::
    \begin{array}{llll}
-   \production{element segments} & \elem &::=&
+   \production{element segment} & \elem &::=&
      \{ \TABLE~\tableidx, \OFFSET~\expr, \INIT~\vec(\funcidx) \} \\
    \end{array}
 
@@ -254,7 +254,7 @@ The |DATA| component of a module defines a vector of *data segments* that initia
 
 .. math::
    \begin{array}{llll}
-   \production{data segments} & \data &::=&
+   \production{data segment} & \data &::=&
      \{ \MEM~\memidx, \OFFSET~\expr, \INIT~\vec(\byte) \} \\
    \end{array}
 
@@ -276,7 +276,7 @@ The |START| component of a module optionally declares the :ref:`function index <
 
 .. math::
    \begin{array}{llll}
-   \production{start functions} & \start &::=&
+   \production{start function} & \start &::=&
      \{ \FUNC~\funcidx \} \\
    \end{array}
 
@@ -296,9 +296,9 @@ The |EXPORTS| component of a module defines a set of *exports* that become acces
 
 .. math::
    \begin{array}{llll}
-   \production{exports} & \export &::=&
+   \production{export} & \export &::=&
      \{ \NAME~\name, \DESC~\exportdesc \} \\
-   \production{export descriptions} & \exportdesc &::=&
+   \production{export description} & \exportdesc &::=&
      \FUNC~\funcidx ~|~ \\&&&
      \TABLE~\tableidx ~|~ \\&&&
      \MEM~\memidx ~|~ \\&&&
@@ -313,6 +313,20 @@ which are referenced through a respective descriptor.
    In the current version of WebAssembly, only *immutable* globals may be exported.
 
 
+Conventions
+...........
+
+The following auxiliary notation is defined for sequences of exports, filtering out indices of a specific kind in an order-preserving fashion:
+
+* :math:`\funcs(\export^\ast) = [\funcidx ~|~ \FUNC~\funcidx \in (\export.\DESC)^\ast]`
+
+* :math:`\tables(\export^\ast) = [\tableidx ~|~ \TABLE~\tableidx \in (\export.\DESC)^\ast]`
+
+* :math:`\mems(\export^\ast) = [\memidx ~|~ \MEM~\memidx \in (\export.\DESC)^\ast]`
+
+* :math:`\globals(\export^\ast) = [\globalidx ~|~ \GLOBAL~\globalidx \in (\export.\DESC)^\ast]`
+
+
 .. _syntax-import:
 .. index:: ! import, name, function type, table type, memory type, global type, index, index space, type index, function index, table index, memory index, global index, function, table, memory, global, instantiation
    pair: abstract syntax; import
@@ -328,9 +342,9 @@ The |IMPORTS| component of a module defines a set of *imports* that are required
 
 .. math::
    \begin{array}{llll}
-   \production{imports} & \import &::=&
+   \production{import} & \import &::=&
      \{ \MODULE~\name, \NAME~\name, \DESC~\importdesc \} \\
-   \production{import descriptions} & \importdesc &::=&
+   \production{import description} & \importdesc &::=&
      \FUNC~\typeidx ~|~ \\&&&
      \TABLE~\tabletype ~|~ \\&&&
      \MEM~\memtype ~|~ \\&&&
diff --git a/document/syntax/types.rst b/document/syntax/types.rst
index 262da63e2..bb8927d0b 100644
--- a/document/syntax/types.rst
+++ b/document/syntax/types.rst
@@ -18,7 +18,7 @@ Value Types
 
 .. math::
    \begin{array}{llll}
-   \production{value types} & \valtype &::=&
+   \production{value type} & \valtype &::=&
      \I32 ~|~ \I64 ~|~ \F32 ~|~ \F64 \\
    \end{array}
 
@@ -50,7 +50,7 @@ which is a sequence of values.
 
 .. math::
    \begin{array}{llll}
-   \production{result types} & \resulttype &::=&
+   \production{result type} & \resulttype &::=&
      [\valtype^?] \\
    \end{array}
 
@@ -72,7 +72,7 @@ mapping a vector of parameters to a vector of results.
 
 .. math::
    \begin{array}{llll}
-   \production{function types} & \functype &::=&
+   \production{function type} & \functype &::=&
      [\vec(\valtype)] \to [\vec(\valtype)] \\
    \end{array}
 
@@ -115,7 +115,7 @@ Memory Types
 
 .. math::
    \begin{array}{llll}
-   \production{memory types} & \memtype &::=&
+   \production{memory type} & \memtype &::=&
      \limits \\
    \end{array}
 
@@ -139,9 +139,9 @@ Table Types
 
 .. math::
    \begin{array}{llll}
-   \production{table types} & \tabletype &::=&
+   \production{table type} & \tabletype &::=&
      \limits~\elemtype \\
-   \production{element types} & \elemtype &::=&
+   \production{element type} & \elemtype &::=&
      \ANYFUNC \\
    \end{array}
 
@@ -170,43 +170,9 @@ Global Types
 
 .. math::
    \begin{array}{llll}
-   \production{global types} & \globaltype &::=&
+   \production{global type} & \globaltype &::=&
      \mut^?~\valtype \\
    \production{mutability} & \mut &::=&
-     \CONST ~|~
-     \MUT \\
+     \MCONST ~|~
+     \MVAR \\
    \end{array}
-
-
-.. _syntax-externtype:
-.. index:: ! external type, function type, table type, memory type, global type
-   pair: abstract syntax; external type
-   pair: external; type
-
-External Types
-~~~~~~~~~~~~~~
-
-*External types* classify imports and exports and their respective types.
-
-.. math::
-   \begin{array}{llll}
-   \production{external types} & \externtype &::=&
-     \FUNC~\functype ~|~ \\&&&
-     \TABLE~\tabletype ~|~ \\&&&
-     \MEM~\memtype ~|~ \\&&&
-     \GLOBAL~\globaltype \\
-   \end{array}
-
-
-Conventions
-...........
-
-The following auxiliary notation is defined for sequences of external types, filtering out entries of a specific kind in an order-preserving fashion:
-
-* :math:`\funcs(\externtype^\ast) = [\functype ~|~ \FUNC~\functype \in \externtype^\ast]`
-
-* :math:`\tables(\externtype^\ast) = [\tabletype ~|~ \TABLE~\tabletype \in \externtype^\ast]`
-
-* :math:`\mems(\externtype^\ast) = [\memtype ~|~ \MEM~\memtype \in \externtype^\ast]`
-
-* :math:`\globals(\externtype^\ast) = [\globaltype ~|~ \GLOBAL~\globaltype \in \externtype^\ast]`
diff --git a/document/syntax/values.rst b/document/syntax/values.rst
index 609304338..faa1aa201 100644
--- a/document/syntax/values.rst
+++ b/document/syntax/values.rst
@@ -18,7 +18,7 @@ In the abstract syntax they are represented as hexadecimal literals.
 
 .. math::
    \begin{array}{llll}
-   \production{bytes} & \byte &::=&
+   \production{byte} & \byte &::=&
      \hex{00} ~|~ \dots ~|~ \hex{FF} \\
    \end{array}
 
@@ -50,20 +50,17 @@ Different classes of *integers* with different value ranges are distinguished by
 
 .. math::
    \begin{array}{llll}
-   \production{unsigned integers} & \uN &::=&
+   \production{unsigned integer} & \uN &::=&
      0 ~|~ 1 ~|~ \dots ~|~ 2^N{-}1 \\
-   \production{signed integers} & \sN &::=&
+   \production{signed integer} & \sN &::=&
      -2^{N-1} ~|~ \dots ~|~ {-}1 ~|~ 0 ~|~ 1 ~|~ \dots ~|~ 2^{N-1}{-}1 \\
-   \production{uninterpreted integers} & \iN &::=&
-     \uN ~|~ \sN \\
+   \production{uninterpreted integer} & \iN &::=&
+     \uN \\
    \end{array}
 
 The latter class defines *uninterpreted* integers, whose signedness interpretation can vary depending on context.
-In those contexts, a conversion based on 2's complement will be applied for values that are out-of-range for a chosen interpretation.
-That is, semantically, when interpreted as unsigned, negative values :math:`-n` convert to :math:`2^N-n`,
-and when interpreted as signed, positive values :math:`n \geq 2^{N-1}` convert to :math:`n-2^N`.
-
-.. todo:: once there, link to definition of conversion
+In the abstract syntax, they are represented as unsigned.
+However, some operations :ref:`convert <aus-signed>` them to signed based on a 2's complement interpretation.
 
 
 Conventions
@@ -85,7 +82,7 @@ Floating-Point
 
 .. math::
    \begin{array}{llll}
-   \production{floating-point numbers} & \fN &::=&
+   \production{floating-point number} & \fN &::=&
      \byte^{N/8} \\
    \end{array}
 
@@ -105,7 +102,7 @@ A vector can have at most :math:`2^{32}-1` elements.
 
 .. math::
    \begin{array}{lllll}
-   \production{vectors} & \vec(A) &::=&
+   \production{vector} & \vec(A) &::=&
      A^n
      & (n < 2^{32})\\
    \end{array}
@@ -122,9 +119,9 @@ Names
 
 .. math::
    \begin{array}{llll}
-   \production{names} & \name &::=&
+   \production{name} & \name &::=&
      \codepoint^\ast \\
-   \production{code points} & \codepoint &::=&
+   \production{code point} & \codepoint &::=&
      \unicode{0000} ~|~ \dots ~|~ \unicode{D7FF} ~|~
      \unicode{E000} ~|~ \dots ~|~ \unicode{10FFFF} \\
    \end{array}
diff --git a/document/validation/conventions.rst b/document/validation/conventions.rst
index f05c46b2b..34c561d67 100644
--- a/document/validation/conventions.rst
+++ b/document/validation/conventions.rst
@@ -39,10 +39,11 @@ which collects relevant information about the surrounding :ref:`module <syntax-m
 * *Globals*: the list of globals declared in the current module, represented by their global type.
 * *Locals*: the list of locals declared in the current function (including parameters), represented by their value type.
 * *Labels*: the stack of labels accessible from the current position, represented by their result type.
+* *Return*: the return type of the current function, represented as a result type.
 
 In other words, a context contains a sequence of suitable :ref:`types <syntax-types>` for each :ref:`index space <syntax-index>`,
 describing each defined entry in that space.
-Locals and labels are only used for validating :ref:`instructions <syntax-instr>` in :ref:`function bodies <syntax-func>`, and are left empty elsewhere.
+Locals, labels and return type are only used for validating :ref:`instructions <syntax-instr>` in :ref:`function bodies <syntax-func>`, and are left empty elsewhere.
 The label stack is the only part of the context that changes as validation of an instruction sequence proceeds.
 
 It is convenient to define contexts as :ref:`records <syntax-record>` :math:`C` with abstract syntax:
@@ -57,7 +58,8 @@ It is convenient to define contexts as :ref:`records <syntax-record>` :math:`C`
         & \MEMS & \memtype^\ast, \\
         & \GLOBALS & \globaltype^\ast, \\
         & \LOCALS & \valtype^\ast, \\
-        & \LABELS & \resulttype^\ast ~\} \\
+        & \LABELS & \resulttype^\ast, \\
+        & \LRETURN & \resulttype^? ~\} \\
      \end{array}
    \end{array}
 
@@ -79,27 +81,35 @@ In addition to field access :math:`C.\K{field}` the following notation is adopte
    because the :ref:`label index <syntax-labelidx>` space is indexed relatively, that is, in reverse order of addition.
 
 
-Textual Notation
-~~~~~~~~~~~~~~~~
+.. _valid-notation-textual:
+
+Prose Notation
+~~~~~~~~~~~~~~
 
 Validation is specified by stylised rules for each relevant part of the :ref:`abstract syntax <syntax>`.
 The rules not only state constraints defining when a phrase is valid,
 they also classify it with a type.
-A phrase :math:`A` is said to be "valid with type :math:`T`",
-if all constraints expressed by the respective rules are met.
-The form of :math:`T` depends on what :math:`A` is.
+The following conventions are adopted in stating these rules.
 
-.. note::
-   For example, if :math:`A` is a :ref:`function <syntax-func>`,
-   then  :math:`T` is a :ref:`function type <syntax-functype>`;
-   for an :math:`A` that is a :ref:`global <syntax-global>`,
-   :math:`T` is a :ref:`global type <syntax-globaltype>`;
-   and so on.
+* A phrase :math:`A` is said to be "valid with type :math:`T`"
+  if and only if all constraints expressed by the respective rules are met.
+  The form of :math:`T` depends on what :math:`A` is.
+
+  .. note::
+     For example, if :math:`A` is a :ref:`function <syntax-func>`,
+     then  :math:`T` is a :ref:`function type <syntax-functype>`;
+     for an :math:`A` that is a :ref:`global <syntax-global>`,
+     :math:`T` is a :ref:`global type <syntax-globaltype>`;
+     and so on.
+
+* The rules implicitly assume a given :ref:`context <context>` :math:`C`.
+
+* In some places, this context is locally extended to a context :math:`C'` with additional entries.
+  The formulation "Under context :math:`C'`, ... *statement* ..." is adopted to express that the following statement must apply under the assumptions embodied in the extended context.
 
-The rules implicitly assume a given :ref:`context <context>` :math:`C`.
-In some places, this context is locally extended to a context :math:`C'` with additional entries.
-The formulation "Under context :math:`C'`, ... *statement* ..." is adopted to express that the following statement must apply under the assumptions embodied in the extended context.
 
+.. _valid-notation:
+.. index:: ! typing rules
 
 Formal Notation
 ~~~~~~~~~~~~~~~
@@ -129,7 +139,7 @@ The conclusion always is a judgment :math:`C \vdash A : T`,
 and there is one respective rule for each relevant construct :math:`A` of the abstract syntax.
 
 .. note::
-   For example, the typing rule for the :ref:`instruction <syntax-instr-numeric>` :math:`\I32.\ADD` can be given as an axiom:
+   For example, the typing rule for the :math:`\I32.\ADD` instruction can be given as an axiom:
 
    .. math::
       \frac{
@@ -145,7 +155,7 @@ and there is one respective rule for each relevant construct :math:`A` of the ab
 
    .. math::
       \frac{
-        C.\LOCAL[x] = t
+        C.\LOCALS[x] = t
       }{
         C \vdash \GETLOCAL~x : [] \to [t]
       }
@@ -153,7 +163,7 @@ and there is one respective rule for each relevant construct :math:`A` of the ab
    Here, the premise enforces that the immediate :ref:`local index <syntax-localidx>` :math:`x` exists in the context.
    The instruction produces a value of its respective type :math:`t`
    (and does not consume any values).
-   If :math:`C.\LOCAL[x]` does not exist then the premise does not hold,
+   If :math:`C.\LOCALS[x]` does not exist then the premise does not hold,
    and the instruction is ill-typed.
 
    Finally, a :ref:`structured <syntax-instr-control>` instruction requires
diff --git a/document/validation/instructions.rst b/document/validation/instructions.rst
index 918dd03cc..3cd9d04a1 100644
--- a/document/validation/instructions.rst
+++ b/document/validation/instructions.rst
@@ -70,65 +70,9 @@ In both cases, the unconstrained types or type sequences can be chosen arbitrari
 Numeric Instructions
 ~~~~~~~~~~~~~~~~~~~~
 
-In this section, the following grammar shorthands are adopted:
-
-.. math::
-   \begin{array}{llll}
-   \production{unary operators} & \unop &::=&
-     \CLZ ~|~
-     \CTZ ~|~
-     \POPCNT ~|~
-     \ABS ~|~
-     \NEG ~|~
-     \SQRT ~|~
-     \CEIL ~|~
-     \FLOOR ~|~
-     \TRUNC ~|~
-     \NEAREST \\
-   \production{binary operators} & \binop &::=&
-     \ADD ~|~
-     \SUB ~|~
-     \MUL ~|~
-     \DIV ~|~
-     \DIV\K{\_}\sx ~|~
-     \REM\K{\_}\sx ~|~
-     \FMIN ~|~
-     \FMAX ~|~
-     \COPYSIGN ~|~ \\&&&
-     \AND ~|~
-     \OR ~|~
-     \XOR ~|~
-     \SHL ~|~
-     \SHR\K{\_}\sx ~|~
-     \ROTL ~|~
-     \ROTR \\
-   \production{test operators} & \testop &::=&
-     \EQZ \\
-   \production{relational operators} & \relop &::=&
-     \EQ ~|~
-     \NE ~|~
-     \LT ~|~
-     \GT ~|~
-     \LE ~|~
-     \GE ~|~
-     \LT\K{\_}\sx ~|~
-     \GT\K{\_}\sx ~|~
-     \LE\K{\_}\sx ~|~
-     \GE\K{\_}\sx \\
-   \production{conversion operators} & \cvtop &::=&
-     \WRAP ~|~
-     \EXTEND\K{\_}\sx ~|~
-     \TRUNC\K{\_}\sx ~|~
-     \CONVERT\K{\_}\sx ~|~
-     \DEMOTE ~|~
-     \PROMOTE ~|~
-     \REINTERPRET \\
-   \end{array}
-
-
 .. _valid-const:
 
-:math:`t \K{.const}~c`
+:math:`t\K{.}\CONST~c`
 ......................
 
 * The instruction is valid with type :math:`[] \to [t]`.
@@ -136,7 +80,7 @@ In this section, the following grammar shorthands are adopted:
 .. math::
    \frac{
    }{
-     C \vdash t\K{.const}~c : [] \to [t]
+     C \vdash t\K{.}\CONST~c : [] \to [t]
    }
 
 
@@ -321,7 +265,7 @@ Variable Instructions
 
 * The global :math:`C.\GLOBALS[x]` must be defined in the context.
 
-* Let :math:`\mut~t` be the :ref:`value type <syntax-globaltype>` :math:`C.\LOCALS[x]`.
+* Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`C.\GLOBALS[x]`.
 
 * Then the instruction is valid with type :math:`[] \to [t]`.
 
@@ -342,13 +286,13 @@ Variable Instructions
 
 * Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`C.\GLOBALS[x]`.
 
-* The mutability :math:`\mut` must be |MUT|.
+* The mutability :math:`\mut` must be |MVAR|.
 
 * Then the instruction is valid with type :math:`[t] \to []`.
 
 .. math::
    \frac{
-     C.\GLOBALS[x] = \MUT~t
+     C.\GLOBALS[x] = \MVAR~t
    }{
      C \vdash \SETGLOBAL~x : [t] \to []
    }
@@ -365,8 +309,8 @@ Memory Instructions
 
 .. _valid-load:
 
-:math:`t\K{.load}~\memarg`
-..........................
+:math:`t\K{.}\LOAD~\memarg`
+...........................
 
 * The memory :math:`C.\MEMS[0]` must be defined in the context.
 
@@ -386,8 +330,8 @@ Memory Instructions
 
 .. _valid-loadn:
 
-:math:`t\K{.load}N\K{\_}\sx~\memarg`
-....................................
+:math:`t\K{.}\LOAD{N}\K{\_}\sx~\memarg`
+.......................................
 
 * The memory :math:`C.\MEMS[0]` must be defined in the context.
 
@@ -407,8 +351,8 @@ Memory Instructions
 
 .. _valid-store:
 
-:math:`t\K{.store}~\memarg`
-...........................
+:math:`t\K{.}\STORE~\memarg`
+............................
 
 * The memory :math:`C.\MEMS[0]` must be defined in the context.
 
@@ -428,8 +372,8 @@ Memory Instructions
 
 .. _valid-storen:
 
-:math:`t\K{.store}N~\memarg`
-............................
+:math:`t\K{.}\STORE{N}~\memarg`
+...............................
 
 * The memory :math:`C.\MEMS[0]` must be defined in the context.
 
@@ -674,15 +618,15 @@ Control Instructions
 :math:`\RETURN`
 ...............
 
-* The label vector :math:`C.\LABELS` must not be empty in the context.
+* The return type :math:`C.\LRETURN` must not be empty in the context.
 
-* Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` that is the last element of :math:`C.\LABELS`.
+* Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` of :math:`C.\LRETURN`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast~t^?] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
-     C.\LABELS[|C.\LABELS|-1] = [t^?]
+     C.\LRETURN = [t^?]
    }{
      C \vdash \RETURN : [t_1^\ast~t^?] \to [t_2^\ast]
    }
@@ -690,6 +634,10 @@ Control Instructions
 .. note::
    The |RETURN| instruction is :ref:`stack-polymorphic <polymorphism>`.
 
+   :math:`C.\LRETURN` is empty (:math:`\epsilon`) when validating an expression that is not a function body.
+   This differs from it being set to the empty result type (:math:`[]`),
+   which is the case for functions not returning anything.
+
 
 .. _valid-call:
 
@@ -734,7 +682,7 @@ Control Instructions
 
 
 .. _valid-instr-seq:
-.. index:: instruction
+.. index:: instruction, instruction sequence
 
 Instruction Sequences
 ~~~~~~~~~~~~~~~~~~~~~
diff --git a/document/validation/modules.rst b/document/validation/modules.rst
index a1e26da4a..0fcab62e1 100644
--- a/document/validation/modules.rst
+++ b/document/validation/modules.rst
@@ -51,9 +51,11 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`,
   but with:
 
-  * the |LOCALS| set to the sequence of :ref:`value types <syntax-valtype>` :math:`t_1^\ast~t^\ast`, concatenating parameters and locals,
+  * |LOCALS| set to the sequence of :ref:`value types <syntax-valtype>` :math:`t_1^\ast~t^\ast`, concatenating parameters and locals,
 
-  * the |LABELS| set to the singular sequence containing only :ref:`result type <syntax-valtype>` :math:`[t_2^\ast]`.
+  * |LABELS| set to the singular sequence containing only :ref:`result type <syntax-valtype>` :math:`[t_2^\ast]`.
+
+  * |LRETURN| set to the :ref:`result type <syntax-valtype>` :math:`[t_2^\ast]`.
 
 * Under the context :math:`C'`,
   the expression :math:`\expr` must be valid with type :math:`t_2^\ast`.
@@ -64,7 +66,7 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
    \frac{
      C.\TYPES[x] = [t_1^\ast] \to [t_2^?]
      \qquad
-     C,\LOCALS\,t_1^\ast~t^\ast,\LABELS~[t_2^?] \vdash \expr : [t_2^?]
+     C,\LOCALS\,t_1^\ast~t^\ast,\LRETURN~[t_2^?] \vdash \expr : [t_2^?]
    }{
      C \vdash \{ \TYPE~x, \LOCALS~t^\ast, \BODY~\expr \} : [t_1^\ast] \to [t_2^?]
    }
@@ -343,13 +345,13 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
 
 * Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`C.\GLOBALS[x]`.
 
-* The mutability :math:`\mut` must be |CONST|.
+* The mutability :math:`\mut` must be |MCONST|.
 
 * Then the export description is valid.
 
 .. math::
    \frac{
-     C.\GLOBALS[x] = \CONST~t
+     C.\GLOBALS[x] = \MCONST~t
    }{
      C \vdash \GLOBAL~x ~\F{ok}
    }
@@ -436,14 +438,14 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 :math:`\GLOBAL~\mut~t`
 ......................
 
-* The mutability :math:`\mut` must be |CONST|.
+* The mutability :math:`\mut` must be |MCONST|.
 
 * Then the import description is valid with type :math:`\GLOBAL~t`.
 
 .. math::
    \frac{
    }{
-     C \vdash \GLOBAL~\CONST~t : \GLOBAL~\CONST~t
+     C \vdash \GLOBAL~\MCONST~t : \GLOBAL~\MCONST~t
    }
 
 
@@ -482,6 +484,8 @@ Instead, the context :math:`C` for validation of the module's content is constru
 
   * :math:`C.\LABELS` is empty.
 
+  * :math:`C.\LRETURN` is empty.
+
 * Under the context :math:`C`:
 
   * For each :math:`\func_i` in :math:`\module.\FUNCS`,
@@ -530,7 +534,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \quad
      (C \vdash \mem : \X{mt})^\ast
      \quad
-     (C_i \vdash \global : \X{gt})_i^\ast
+     (C' \vdash \global : \X{gt})^\ast
      \\
      (C \vdash \elem ~\F{ok})^\ast
      \quad
@@ -552,13 +556,13 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \\
      C = \{ \TYPES~\functype^\ast, \FUNCS~\X{ift}^\ast~\X{ft}^\ast, \TABLES~\X{itt}^\ast~\X{tt}^\ast, \MEMS~\X{imt}^\ast~\X{mt}^\ast, \GLOBALS~\X{igt}^\ast~\X{gt}^\ast \}
      \\
+     C' = \{ \GLOBALS~\X{igt}^\ast \}
+     \qquad
      |C.\TABLES| \leq 1
      \qquad
      |C.\MEMS| \leq 1
      \qquad
      \name^\ast ~\F{disjoint}
-     \qquad
-     (C_i = \{ \GLOBALS~[\X{igt}^\ast~\X{gt}^{i-1}] \})_i^\ast
      \end{array}
    }{
      \vdash \{
@@ -585,7 +589,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
    All types needed to construct :math:`C` can easily be determined from a simple pre-pass over the module that does not perform any actual validation.
 
    Globals, however, are not recursive.
-   The effect of defining the limited contexts :math:`C_i` for validating the module's globals is that their initialization expressions can only access imported and previously defined globals and nothing else.
+   The effect of defining the limited context :math:`C'` for validating the module's globals is that their initialization expressions can only access imported globals and nothing else.
 
 .. note::
    The restriction on the number of tables and memories may be lifted in future versions of WebAssembly.

From 16cc5bb3593fd28782abd75bccc57a197849677e Mon Sep 17 00:00:00 2001
From: Dan Gohman <sunfish@mozilla.com>
Date: Tue, 16 May 2017 10:42:05 -0700
Subject: [PATCH 018/329] Some binary tests (#473)

* Test more invalid binary headers.

* Add a few more valid custom section name tests.

* Test that a module containing a single trailing NUL is invalid.

* Test that concatenated modules are invalid.
---
 test/core/binary.wast         | 25 +++++++++++++++++++++++++
 test/core/custom_section.wast | 20 ++++++++++++++++++++
 2 files changed, 45 insertions(+)

diff --git a/test/core/binary.wast b/test/core/binary.wast
index 390223965..8b1d59ec1 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -10,10 +10,35 @@
 (assert_malformed (module "msa\00") "magic header not detected")
 (assert_malformed (module "msa\00\01\00\00\00") "magic header not detected")
 (assert_malformed (module "msa\00\00\00\00\01") "magic header not detected")
+(assert_malformed (module "asm\01\00\00\00\00") "magic header not detected")
+(assert_malformed (module "wasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module "\7fasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module "\80asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module "\82asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module "\ffasm\01\00\00\00") "magic header not detected")
+
+;; 8-byte endian-reversed.
+(assert_malformed (module "\00\00\00\01msa\00") "magic header not detected")
+
+;; Middle-endian byte orderings.
+(assert_malformed (module "a\00ms\00\01\00\00") "magic header not detected")
+(assert_malformed (module "sm\00a\00\00\01\00") "magic header not detected")
+
+;; Upper-cased.
+(assert_malformed (module "\00ASM\01\00\00\00") "magic header not detected")
+
+;; EBCDIC-encoded magic.
+(assert_malformed (module "\00\81\a2\94\01\00\00\00") "magic header not detected")
+
+;; Leading UTF-8 BOM.
+(assert_malformed (module "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected")
 
 (assert_malformed (module "\00asm") "unexpected end")
 (assert_malformed (module "\00asm\01") "unexpected end")
 (assert_malformed (module "\00asm\01\00\00") "unexpected end")
+(assert_malformed (module "\00asm\00\00\00\00") "unknown binary version")
 (assert_malformed (module "\00asm\0d\00\00\00") "unknown binary version")
 (assert_malformed (module "\00asm\0e\00\00\00") "unknown binary version")
+(assert_malformed (module "\00asm\00\01\00\00") "unknown binary version")
+(assert_malformed (module "\00asm\00\00\01\00") "unknown binary version")
 (assert_malformed (module "\00asm\00\00\00\01") "unknown binary version")
diff --git a/test/core/custom_section.wast b/test/core/custom_section.wast
index f087a9d2d..551ed97bf 100644
--- a/test/core/custom_section.wast
+++ b/test/core/custom_section.wast
@@ -6,6 +6,9 @@
   "\00\10\00" "" "this is payload"
   "\00\01\00" "" ""
   "\00\24\10" "\00\00custom sectio\00" "this is the payload"
+  "\00\24\10" "\ef\bb\bfa custom sect" "this is the payload"
+  "\00\24\10" "a custom sect\e2\8c\a3" "this is the payload"
+  "\00\1f\16" "module within a module" "\00asm" "\01\00\00\00"
 )
 
 (module
@@ -54,6 +57,14 @@
   "\00\1b\07" "custom2" "this is the payload"  ;; custom section
 )
 
+(assert_malformed
+  (module
+    "\00asm" "\01\00\00\00"
+    "\00"
+  )
+  "unexpected end"
+)
+
 (assert_malformed
   (module
     "\00asm" "\01\00\00\00"
@@ -90,3 +101,12 @@
   )
   "function and code section have inconsistent lengths"
 )
+
+;; Test concatenated modules.
+(assert_malformed
+  (module
+    "\00asm\01\00\00\00"
+    "\00asm\01\00\00\00"
+  )
+  "length out of bounds"
+)

From eba1e22f434d66d950b41084be073c07798a107f Mon Sep 17 00:00:00 2001
From: Dan Gohman <sunfish@mozilla.com>
Date: Tue, 16 May 2017 10:45:56 -0700
Subject: [PATCH 019/329] More tests (#470)

* Test that names are not normalized to NFC/NFD.

* Say "code point" instead of "character".

* Simplify and organize names tests.

Use i32 values instead of f32, and put the invokes in the same order
as the function definitions.

* Test that we can use names beginning with a dash.

* Test that Unicode compatibility normalization is not applied.

* Test that names can contain Unicode control codes.

* Test that the control pictures are distinct from the control codes they depict.

* Test the Unicode Specials in non-escaped form.

* Test names with bare ZWJ and ZWNJ code points.

* Test various bare joiner code points.

* Test various interesting code points.

* Test more interesting code points.

* Test some deprecated code points.

* Test "invisible" operator code points.

* Test that code points outside the BMP are supported.

* Test that WebAssembly implementations cope in the presence of Zalgo.

* Test Hangul filler code points.

* Test variation selectors (which are also ID_Continue code points).

* Test an uncombined combining code point.

* Test that numerous different present and historical representations of the "newline" concept are distinct.

* Test that non-characters are not replaced by the replacement character.

* Test an interrobang with combining diacritical marks above.

* Test that RLM/LRM don't change the logical byte order.

* Test that Unicode font variations are preserved.

* Test that various additional letter variations are preserved.

* Test unmatched "closing" and "opening" code points.

* Test that Unicode fraction normalization is not applied.

* Test a full-width quote.

* Test that different present and historical representations of the "delete" concept are distinct.

* Test that different representations of the "substitute" concept are distinct.

* Test that different present and historical representations of the "paragraph" concept are distinct.
---
 test/core/names.wast | 1061 ++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 1034 insertions(+), 27 deletions(-)

diff --git a/test/core/names.wast b/test/core/names.wast
index 907d82fb5..b749b2329 100644
--- a/test/core/names.wast
+++ b/test/core/names.wast
@@ -18,52 +18,1059 @@
 
 (module
   ;; Test that we can use the empty string as a symbol.
-  (func (export "") (result f32) (f32.const 0x1.91p+2))
+  (func (export "") (result i32) (i32.const 0))
 
   ;; Test that we can use names beginning with a digit.
-  (func (export "0") (result f32) (f32.const 0x1.97p+2))
+  (func (export "0") (result i32) (i32.const 1))
+
+  ;; Test that we can use names beginning with a dash.
+  (func (export "-0") (result i32) (i32.const 2))
 
   ;; Test that we can use names beginning with an underscore.
-  (func (export "_") (result f32) (f32.const 0x1.98p+2))
+  (func (export "_") (result i32) (i32.const 3))
 
   ;; Test that we can use names beginning with a dollar sign.
-  (func (export "$") (result f32) (f32.const 0x1.99p+2))
+  (func (export "$") (result i32) (i32.const 4))
 
   ;; Test that we can use names beginning with an at sign.
-  (func (export "@") (result f32) (f32.const 0x2.00p+2))
+  (func (export "@") (result i32) (i32.const 5))
 
   ;; Test that we can use non-alphanumeric names.
-  (func (export "~!@#$%^&*()_+`-={}|[]\\:\";'<>?,./ ") (result f32) (f32.const 0x1.96p+2))
+  (func (export "~!@#$%^&*()_+`-={}|[]\\:\";'<>?,./ ") (result i32) (i32.const 6))
 
   ;; Test that we can use names that have special meaning in JS.
-  (func (export "NaN") (result f32) (f32.const 0x2.01p+2))
-  (func (export "Infinity") (result f32) (f32.const 0x2.02p+2))
-  (func (export "if") (result f32) (f32.const 0x2.03p+2))
+  (func (export "NaN") (result i32) (i32.const 7))
+  (func (export "Infinity") (result i32) (i32.const 8))
+  (func (export "if") (result i32) (i32.const 9))
 
   ;; Test that we can use common libc names without conflict.
-  (func (export "malloc") (result f32) (f32.const 0x1.92p+2))
+  (func (export "malloc") (result i32) (i32.const 10))
 
   ;; Test that we can use some libc hidden names without conflict.
-  (func (export "_malloc") (result f32) (f32.const 0x1.93p+2))
-  (func (export "__malloc") (result f32) (f32.const 0x1.94p+2))
+  (func (export "_malloc") (result i32) (i32.const 11))
+  (func (export "__malloc") (result i32) (i32.const 12))
+
+  ;; Test that names are case-sensitive.
+  (func (export "a") (result i32) (i32.const 13))
+  (func (export "A") (result i32) (i32.const 14))
+
+  ;; Test that UTF-8 BOM code points can appear in identifiers.
+  (func (export "") (result i32) (i32.const 15))
+
+  ;; Test that Unicode normalization is not applied. These function names
+  ;; contain different codepoints which normalize to the same thing under
+  ;; NFC or NFD.
+  (func (export "Å") (result i32) (i32.const 16))
+  (func (export "Å") (result i32) (i32.const 17))
+  (func (export "Å") (result i32) (i32.const 18))
+
+  ;; Test that Unicode compatibility normalization is not applied. These
+  ;; function names contain different codepoints which normalize to the
+  ;; same thing under NFKC or NFKD.
+  (func (export "ffi") (result i32) (i32.const 19))
+  (func (export "ffi") (result i32) (i32.const 20))
+  (func (export "ffi") (result i32) (i32.const 21))
+
+  ;; Test the C0 control codes.
+  (func (export "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f") (result i32) (i32.const 22))
+  (func (export "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f") (result i32) (i32.const 23))
+  ;; Test miscellaneous control codes.
+  (func (export " \7f") (result i32) (i32.const 24))
+  ;; Test the C1 control codes.
+  (func (export "\c2\80\c2\81\c2\82\c2\83\c2\84\c2\85\c2\86\c2\87\c2\88\c2\89\c2\8a\c2\8b\c2\8c\c2\8d\c2\8e\c2\8f") (result i32) (i32.const 25))
+  (func (export "\c2\90\c2\91\c2\92\c2\93\c2\94\c2\95\c2\96\c2\97\c2\98\c2\99\c2\9a\c2\9b\c2\9c\c2\9d\c2\9e\c2\9f") (result i32) (i32.const 26))
+  ;; Test the Unicode Specials.
+  (func (export "\ef\bf\b0\ef\bf\b1\ef\bf\b2\ef\bf\b3\ef\bf\b4\ef\bf\b5\ef\bf\b6\ef\bf\b7") (result i32) (i32.const 27))
+  (func (export "\ef\bf\b8\ef\bf\b9\ef\bf\ba\ef\bf\bb\ef\bf\bc\ef\bf\bd\ef\bf\be\ef\bf\bf") (result i32) (i32.const 28))
+
+  ;; Test that the control pictures are distinct from the control codes they
+  ;; depict. These correspond to the C0 and miscellaneous control code tests
+  ;; above.
+  (func (export "␀␁␂␃␄␅␆␇␈␉␊␋␌␍␎␏") (result i32) (i32.const 29))
+  (func (export "␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟") (result i32) (i32.const 30))
+  (func (export "␠␡") (result i32) (i32.const 31))
+
+  ;; Test the Unicode Specials in non-escaped form (excluding U+FFFE and
+  ;; U+FFFF, so that generic tools don't detect this file as non-UTF-8).
+  (func (export "￰￱￲￳￴￵￶￷￸�") (result i32) (i32.const 32))
+
+  ;; Test a bare ZWJ code point.
+  (func (export "‍") (result i32) (i32.const 33))
+  ;; Test a bare ZWNJ code point.
+  (func (export "‌") (result i32) (i32.const 34))
+
+  ;; Test various bare joiner code points.
+  (func (export "͏") (result i32) (i32.const 35))
+  (func (export "⁠") (result i32) (i32.const 36))
+  (func (export "⵿") (result i32) (i32.const 37))
+  (func (export "𑁿") (result i32) (i32.const 38))
+  (func (export "᠎") (result i32) (i32.const 39))
+
+  ;; Test various interesting code points: reverse BOM, zero-width space,
+  ;; no-break space, soft hyphen, word joiner, ogham space mark,
+  ;; right-to-left override, left-to-right override.
+  (func (export "￯​ ­⁠ ‮‭") (result i32) (i32.const 40))
+
+  ;; Test more interesting code points: left-to-right mark, right-to-left mark,
+  ;; non-breaking hyphen, line separator, paragraph separator,
+  ;; left-to-right embedding, right-to-left embedding,
+  ;; pop directional formatting, narrow no-break space, left-to-right isolate,
+  ;; right-to-left isolate, first strong isolate, pop directional isolate.
+  (func (export "‎‏‑

‪‫‬ ⁦⁧⁨⁩") (result i32) (i32.const 41))
+
+  ;; Test some deprecated code points: inhibit symmetric swapping,
+  ;; activate symmetric swapping, inhibit arabic form shaping,
+  ;; activate arabic form shaping, national digit shapes, nominal digit shapes.
+  (func (export "") (result i32) (i32.const 42))
+
+  ;; Test "invisible" operator code points.
+  (func (export "⁡⁢⁣⁤") (result i32) (i32.const 43))
+
+  ;; Test that code points outside the BMP are supported.
+  (func (export "𐀀󟿿􏿿") (result i32) (i32.const 44))
+
+  ;; Test that WebAssembly implementations cope in the presence of Zalgo.
+  (func (export "Z̴͇̫̥̪͓͈͔͎̗̞̺̯̱̞̙̱̜̖̠̏͆̆͛͌͘͞ḁ̶̰̳̭͙̲̱̹̝͎̼͗ͨ̎̄̆͗̿̀́͟͡l̶̷͉̩̹̫̝͖̙̲̼͇͚͍̮͎̥̞̈́͊͗ͦ̈́ͫ̇́̚ͅͅg̶͕͔͚̩̓̐̅ͮ̔̐̎̂̏̾͊̍͋͊ͧ́̆ͦ͞o̡͋̔͐ͪͩ͏̢̧̫̙̤̮͖͙͓̺̜̩̼̘̠́") (result i32) (i32.const 45))
+
+  ;; Test Hangul filler code points.
+  (func (export "ᅟᅠㅤﾠ") (result i32) (i32.const 46))
+
+  ;; Test variation selectors (which are also ID_Continue code points).
+  (func (export "︀") (result i32) (i32.const 47))
+  (func (export "︄") (result i32) (i32.const 48))
+  (func (export "󠄀") (result i32) (i32.const 49))
+  (func (export "󠇯") (result i32) (i32.const 50))
+
+  ;; Test an uncombined combining code point.
+  (func (export "̈") (result i32) (i32.const 51))
+
+  ;; Test that numerous different present and historical representations of the
+  ;; "newline" concept are distinct. Tests largely inspired by:
+  ;;   https://en.wikipedia.org/wiki/Newline#Representations
+  ;;   https://en.wikipedia.org/wiki/Newline#Unicode and
+  ;;   https://en.wikipedia.org/wiki/Newline#Reverse_and_partial_line_feeds
+  (func (export "\0a") (result i32) (i32.const 52))
+  (func (export "␤") (result i32) (i32.const 53))
+  (func (export "
") (result i32) (i32.const 54))
+  (func (export "\0d") (result i32) (i32.const 55))
+  (func (export "\0d\0a") (result i32) (i32.const 56))
+  (func (export "\0a\0d") (result i32) (i32.const 57))
+  (func (export "\1e") (result i32) (i32.const 58))
+  (func (export "\0b") (result i32) (i32.const 59))
+  (func (export "\0c") (result i32) (i32.const 60))
+  (func (export "\c2\85") (result i32) (i32.const 61))
+  (func (export "
") (result i32) (i32.const 62))
+  (func (export "…") (result i32) (i32.const 63))
+  (func (export "⏎") (result i32) (i32.const 64))
+  (func (export "\c2\8b") (result i32) (i32.const 65))
+  (func (export "\c2\8c") (result i32) (i32.const 66))
+  (func (export "\c2\8d") (result i32) (i32.const 67))
+  (func (export "↵") (result i32) (i32.const 68))
+  (func (export "↩") (result i32) (i32.const 69))
+  (func (export "⌤") (result i32) (i32.const 70))
+  (func (export "⤶") (result i32) (i32.const 71))
+  (func (export "↲") (result i32) (i32.const 72))
+  (func (export "⮨") (result i32) (i32.const 73))
+  (func (export "⮰") (result i32) (i32.const 74))
+
+  ;; Test that non-characters are not replaced by the replacement character.
+  (func (export "�") (result i32) (i32.const 75))
+  (func (export "\ef\b7\90") (result i32) (i32.const 76))
+  (func (export "\ef\b7\91") (result i32) (i32.const 77))
+  (func (export "\ef\b7\92") (result i32) (i32.const 78))
+  (func (export "\ef\b7\93") (result i32) (i32.const 79))
+  (func (export "\ef\b7\94") (result i32) (i32.const 80))
+  (func (export "\ef\b7\95") (result i32) (i32.const 81))
+  (func (export "\ef\b7\96") (result i32) (i32.const 82))
+  (func (export "\ef\b7\97") (result i32) (i32.const 83))
+  (func (export "\ef\b7\98") (result i32) (i32.const 84))
+  (func (export "\ef\b7\99") (result i32) (i32.const 85))
+  (func (export "\ef\b7\9a") (result i32) (i32.const 86))
+  (func (export "\ef\b7\9b") (result i32) (i32.const 87))
+  (func (export "\ef\b7\9c") (result i32) (i32.const 88))
+  (func (export "\ef\b7\9d") (result i32) (i32.const 89))
+  (func (export "\ef\b7\9e") (result i32) (i32.const 90))
+  (func (export "\ef\b7\9f") (result i32) (i32.const 91))
+  (func (export "\ef\b7\a0") (result i32) (i32.const 92))
+  (func (export "\ef\b7\a1") (result i32) (i32.const 93))
+  (func (export "\ef\b7\a2") (result i32) (i32.const 94))
+  (func (export "\ef\b7\a3") (result i32) (i32.const 95))
+  (func (export "\ef\b7\a4") (result i32) (i32.const 96))
+  (func (export "\ef\b7\a5") (result i32) (i32.const 97))
+  (func (export "\ef\b7\a6") (result i32) (i32.const 98))
+  (func (export "\ef\b7\a7") (result i32) (i32.const 99))
+  (func (export "\ef\b7\a8") (result i32) (i32.const 100))
+  (func (export "\ef\b7\a9") (result i32) (i32.const 101))
+  (func (export "\ef\b7\aa") (result i32) (i32.const 102))
+  (func (export "\ef\b7\ab") (result i32) (i32.const 103))
+  (func (export "\ef\b7\ac") (result i32) (i32.const 104))
+  (func (export "\ef\b7\ad") (result i32) (i32.const 105))
+  (func (export "\ef\b7\ae") (result i32) (i32.const 106))
+  (func (export "\ef\b7\af") (result i32) (i32.const 107))
+  (func (export "\ef\bf\be") (result i32) (i32.const 108))
+  (func (export "\ef\bf\bf") (result i32) (i32.const 109))
+  (func (export "\f0\9f\bf\be") (result i32) (i32.const 110))
+  (func (export "\f0\9f\bf\bf") (result i32) (i32.const 111))
+  (func (export "\f0\af\bf\be") (result i32) (i32.const 112))
+  (func (export "\f0\af\bf\bf") (result i32) (i32.const 113))
+  (func (export "\f0\bf\bf\be") (result i32) (i32.const 114))
+  (func (export "\f0\bf\bf\bf") (result i32) (i32.const 115))
+  (func (export "\f1\8f\bf\be") (result i32) (i32.const 116))
+  (func (export "\f1\8f\bf\bf") (result i32) (i32.const 117))
+  (func (export "\f1\9f\bf\be") (result i32) (i32.const 118))
+  (func (export "\f1\9f\bf\bf") (result i32) (i32.const 119))
+  (func (export "\f1\af\bf\be") (result i32) (i32.const 120))
+  (func (export "\f1\af\bf\bf") (result i32) (i32.const 121))
+  (func (export "\f1\bf\bf\be") (result i32) (i32.const 122))
+  (func (export "\f1\bf\bf\bf") (result i32) (i32.const 123))
+  (func (export "\f2\8f\bf\be") (result i32) (i32.const 124))
+  (func (export "\f2\8f\bf\bf") (result i32) (i32.const 125))
+  (func (export "\f2\9f\bf\be") (result i32) (i32.const 126))
+  (func (export "\f2\9f\bf\bf") (result i32) (i32.const 127))
+  (func (export "\f2\af\bf\be") (result i32) (i32.const 128))
+  (func (export "\f2\af\bf\bf") (result i32) (i32.const 129))
+  (func (export "\f2\bf\bf\be") (result i32) (i32.const 130))
+  (func (export "\f2\bf\bf\bf") (result i32) (i32.const 131))
+  (func (export "\f3\8f\bf\be") (result i32) (i32.const 132))
+  (func (export "\f3\8f\bf\bf") (result i32) (i32.const 133))
+  (func (export "\f3\9f\bf\be") (result i32) (i32.const 134))
+  (func (export "\f3\9f\bf\bf") (result i32) (i32.const 135))
+  (func (export "\f3\af\bf\be") (result i32) (i32.const 136))
+  (func (export "\f3\af\bf\bf") (result i32) (i32.const 137))
+  (func (export "\f3\bf\bf\be") (result i32) (i32.const 138))
+  (func (export "\f3\bf\bf\bf") (result i32) (i32.const 139))
+  (func (export "\f4\8f\bf\be") (result i32) (i32.const 140))
+  (func (export "\f4\8f\bf\bf") (result i32) (i32.const 141))
+
+  ;; Test an interrobang with combining diacritical marks above.
+  ;; https://xkcd.com/1209/
+  (func (export "̈‽̈̉") (result i32) (i32.const 142))
+
+  ;; Test that RLM/LRM don't change the logical byte order.
+  (func (export "abc") (result i32) (i32.const 143))
+  (func (export "‭abc") (result i32) (i32.const 144))
+  (func (export "‮cba") (result i32) (i32.const 145))
+  (func (export "‭abc‮") (result i32) (i32.const 146))
+  (func (export "‮cba‭") (result i32) (i32.const 147))
+
+  ;; Test that Unicode font variations are preserved.
+  (func (export "𝑨") (result i32) (i32.const 148))
+  (func (export "𝐴") (result i32) (i32.const 149))
+  (func (export "𝘈") (result i32) (i32.const 150))
+  (func (export "𝘼") (result i32) (i32.const 151))
+  (func (export "𝐀") (result i32) (i32.const 152))
+  (func (export "𝓐") (result i32) (i32.const 153))
+  (func (export "𝕬") (result i32) (i32.const 154))
+  (func (export "𝗔") (result i32) (i32.const 155))
+  (func (export "𝒜") (result i32) (i32.const 156))
+  (func (export "𝔄") (result i32) (i32.const 157))
+  (func (export "𝔸") (result i32) (i32.const 158))
+  (func (export "𝖠") (result i32) (i32.const 159))
+  (func (export "𝙰") (result i32) (i32.const 160))
+  (func (export "ᴀ") (result i32) (i32.const 161))
+
+  ;; Test that various additional letter variations are preserved.
+  ;; (U+0040, U+0061, U+0041, U+00C5, U+0041 U+030A, U+212B, and the font
+  ;; variations are covered above.)
+  (func (export "ᴬ") (result i32) (i32.const 162))
+  (func (export "Ⓐ") (result i32) (i32.const 163))
+  (func (export "Ａ") (result i32) (i32.const 164))
+  (func (export "🄐") (result i32) (i32.const 165))
+  (func (export "🄰") (result i32) (i32.const 166))
+  (func (export "󠁁") (result i32) (i32.const 167))
+  (func (export "U+0041") (result i32) (i32.const 168))
+  (func (export "A​") (result i32) (i32.const 169))
+  (func (export "А") (result i32) (i32.const 170))
+  (func (export "Ꙗ") (result i32) (i32.const 171))
+  (func (export "ⷼ") (result i32) (i32.const 172))
+  (func (export "ⷶ") (result i32) (i32.const 173))
+  (func (export "Ɐ") (result i32) (i32.const 174))
+  (func (export "🅐") (result i32) (i32.const 175))
+  (func (export "🅰") (result i32) (i32.const 176))
+  (func (export "Ⱝ") (result i32) (i32.const 177))
+  (func (export "𐐂") (result i32) (i32.const 178))
+  (func (export "𐐈") (result i32) (i32.const 179))
+  (func (export "𐒰") (result i32) (i32.const 180))
+  (func (export "À") (result i32) (i32.const 181))
+  (func (export "Á") (result i32) (i32.const 182))
+  (func (export "Â") (result i32) (i32.const 183))
+  (func (export "Ã") (result i32) (i32.const 184))
+  (func (export "Ä") (result i32) (i32.const 185))
+  (func (export "Ā") (result i32) (i32.const 186))
+  (func (export "Ă") (result i32) (i32.const 187))
+  (func (export "Ą") (result i32) (i32.const 188))
+  (func (export "Ǎ") (result i32) (i32.const 189))
+  (func (export "Ǟ") (result i32) (i32.const 190))
+  (func (export "Ǡ") (result i32) (i32.const 191))
+  (func (export "Ǻ") (result i32) (i32.const 192))
+  (func (export "Ȁ") (result i32) (i32.const 193))
+  (func (export "Ȃ") (result i32) (i32.const 194))
+  (func (export "Ȧ") (result i32) (i32.const 195))
+  (func (export "Ⱥ") (result i32) (i32.const 196))
+  (func (export "Ӑ") (result i32) (i32.const 197))
+  (func (export "Ӓ") (result i32) (i32.const 198))
+  (func (export "ߊ") (result i32) (i32.const 199))
+  (func (export "ࠡ") (result i32) (i32.const 200))
+  (func (export "ࠢ") (result i32) (i32.const 201))
+  (func (export "ࠣ") (result i32) (i32.const 202))
+  (func (export "ࠤ") (result i32) (i32.const 203))
+  (func (export "ࠥ") (result i32) (i32.const 204))
+  (func (export "ऄ") (result i32) (i32.const 205))
+  (func (export "अ") (result i32) (i32.const 206))
+  (func (export "ॲ") (result i32) (i32.const 207))
+  (func (export "অ") (result i32) (i32.const 208))
+  (func (export "ਅ") (result i32) (i32.const 209))
+  (func (export "અ") (result i32) (i32.const 210))
+  (func (export "ଅ") (result i32) (i32.const 211))
+  (func (export "அ") (result i32) (i32.const 212))
+  (func (export "అ") (result i32) (i32.const 213))
+  (func (export "ಅ") (result i32) (i32.const 214))
+  (func (export "അ") (result i32) (i32.const 215))
+  (func (export "ะ") (result i32) (i32.const 216))
+  (func (export "ະ") (result i32) (i32.const 217))
+  (func (export "༁") (result i32) (i32.const 218))
+  (func (export "ཨ") (result i32) (i32.const 219))
+  (func (export "ྸ") (result i32) (i32.const 220))
+  (func (export "အ") (result i32) (i32.const 221))
+  (func (export "ဢ") (result i32) (i32.const 222))
+  (func (export "ႜ") (result i32) (i32.const 223))
+  (func (export "ᅡ") (result i32) (i32.const 224))
+  (func (export "አ") (result i32) (i32.const 225))
+  (func (export "ዐ") (result i32) (i32.const 226))
+  (func (export "Ꭰ") (result i32) (i32.const 227))
+  (func (export "ᐊ") (result i32) (i32.const 228))
+  (func (export "ᖳ") (result i32) (i32.const 229))
+  (func (export "ᚨ") (result i32) (i32.const 230))
+  (func (export "ᚪ") (result i32) (i32.const 231))
+  (func (export "ᛆ") (result i32) (i32.const 232))
+  (func (export "ᜀ") (result i32) (i32.const 233))
+  (func (export "ᜠ") (result i32) (i32.const 234))
+  (func (export "ᝀ") (result i32) (i32.const 235))
+  (func (export "ᝠ") (result i32) (i32.const 236))
+  (func (export "ᠠ") (result i32) (i32.const 237))
+  (func (export "ᢇ") (result i32) (i32.const 238))
+  (func (export "ᤠ") (result i32) (i32.const 239))
+  (func (export "ᥣ") (result i32) (i32.const 240))
+  (func (export "ᨕ") (result i32) (i32.const 241))
+  (func (export "ᩋ") (result i32) (i32.const 242))
+  (func (export "ᩡ") (result i32) (i32.const 243))
+  (func (export "ᮃ") (result i32) (i32.const 244))
+  (func (export "ᯀ") (result i32) (i32.const 245))
+  (func (export "ᯁ") (result i32) (i32.const 246))
+  (func (export "ᰣ") (result i32) (i32.const 247))
+  (func (export "Ḁ") (result i32) (i32.const 248))
+  (func (export "Ạ") (result i32) (i32.const 249))
+  (func (export "Ả") (result i32) (i32.const 250))
+  (func (export "Ấ") (result i32) (i32.const 251))
+  (func (export "Ầ") (result i32) (i32.const 252))
+  (func (export "Ẩ") (result i32) (i32.const 253))
+  (func (export "Ẫ") (result i32) (i32.const 254))
+  (func (export "Ậ") (result i32) (i32.const 255))
+  (func (export "Ắ") (result i32) (i32.const 256))
+  (func (export "Ằ") (result i32) (i32.const 257))
+  (func (export "Ẳ") (result i32) (i32.const 258))
+  (func (export "Ẵ") (result i32) (i32.const 259))
+  (func (export "Ặ") (result i32) (i32.const 260))
+  (func (export "あ") (result i32) (i32.const 261))
+  (func (export "ア") (result i32) (i32.const 262))
+  (func (export "ㄚ") (result i32) (i32.const 263))
+  (func (export "ㅏ") (result i32) (i32.const 264))
+  (func (export "㈎") (result i32) (i32.const 265))
+  (func (export "㈏") (result i32) (i32.const 266))
+  (func (export "㈐") (result i32) (i32.const 267))
+  (func (export "㈑") (result i32) (i32.const 268))
+  (func (export "㈒") (result i32) (i32.const 269))
+  (func (export "㈓") (result i32) (i32.const 270))
+  (func (export "㈔") (result i32) (i32.const 271))
+  (func (export "㈕") (result i32) (i32.const 272))
+  (func (export "㈖") (result i32) (i32.const 273))
+  (func (export "㈗") (result i32) (i32.const 274))
+  (func (export "㈘") (result i32) (i32.const 275))
+  (func (export "㈙") (result i32) (i32.const 276))
+  (func (export "㈚") (result i32) (i32.const 277))
+  (func (export "㈛") (result i32) (i32.const 278))
+  (func (export "㉮") (result i32) (i32.const 279))
+  (func (export "㉯") (result i32) (i32.const 280))
+  (func (export "㉰") (result i32) (i32.const 281))
+  (func (export "㉱") (result i32) (i32.const 282))
+  (func (export "㉲") (result i32) (i32.const 283))
+  (func (export "㉳") (result i32) (i32.const 284))
+  (func (export "㉴") (result i32) (i32.const 285))
+  (func (export "㉵") (result i32) (i32.const 286))
+  (func (export "㉶") (result i32) (i32.const 287))
+  (func (export "㉷") (result i32) (i32.const 288))
+  (func (export "㉸") (result i32) (i32.const 289))
+  (func (export "㉹") (result i32) (i32.const 290))
+  (func (export "㉺") (result i32) (i32.const 291))
+  (func (export "㉻") (result i32) (i32.const 292))
+  (func (export "㋐") (result i32) (i32.const 293))
+  (func (export "ꀊ") (result i32) (i32.const 294))
+  (func (export "ꓮ") (result i32) (i32.const 295))
+  (func (export "ꕉ") (result i32) (i32.const 296))
+  (func (export "ꚠ") (result i32) (i32.const 297))
+  (func (export "ꠀ") (result i32) (i32.const 298))
+  (func (export "ꠣ") (result i32) (i32.const 299))
+  (func (export "ꡝ") (result i32) (i32.const 300))
+  (func (export "ꢂ") (result i32) (i32.const 301))
+  (func (export "꣪") (result i32) (i32.const 302))
+  (func (export "ꤢ") (result i32) (i32.const 303))
+  (func (export "ꥆ") (result i32) (i32.const 304))
+  (func (export "ꦄ") (result i32) (i32.const 305))
+  (func (export "ꨀ") (result i32) (i32.const 306))
+  (func (export "ｱ") (result i32) (i32.const 307))
+  (func (export "ￂ") (result i32) (i32.const 308))
+  (func (export "𐀀") (result i32) (i32.const 309))
+  (func (export "𐊀") (result i32) (i32.const 310))
+  (func (export "𐊠") (result i32) (i32.const 311))
+  (func (export "𐌀") (result i32) (i32.const 312))
+  (func (export "𐎠") (result i32) (i32.const 313))
+  (func (export "𐒖") (result i32) (i32.const 314))
+  (func (export "𐔀") (result i32) (i32.const 315))
+  (func (export "𐝀") (result i32) (i32.const 316))
+  (func (export "𐠀") (result i32) (i32.const 317))
+  (func (export "𐤠") (result i32) (i32.const 318))
+  (func (export "𐦀") (result i32) (i32.const 319))
+  (func (export "𐦠") (result i32) (i32.const 320))
+  (func (export "𐨀") (result i32) (i32.const 321))
+  (func (export "𐬀") (result i32) (i32.const 322))
+  (func (export "𐰀") (result i32) (i32.const 323))
+  (func (export "𐰁") (result i32) (i32.const 324))
+  (func (export "𐲀") (result i32) (i32.const 325))
+  (func (export "𑀅") (result i32) (i32.const 326))
+  (func (export "𑂃") (result i32) (i32.const 327))
+  (func (export "𑄧") (result i32) (i32.const 328))
+  (func (export "𑅐") (result i32) (i32.const 329))
+  (func (export "𑆃") (result i32) (i32.const 330))
+  (func (export "𑈀") (result i32) (i32.const 331))
+  (func (export "𑊀") (result i32) (i32.const 332))
+  (func (export "𑊰") (result i32) (i32.const 333))
+  (func (export "𑌅") (result i32) (i32.const 334))
+  (func (export "𑍰") (result i32) (i32.const 335))
+  (func (export "𑐀") (result i32) (i32.const 336))
+  (func (export "𑒁") (result i32) (i32.const 337))
+  (func (export "𑖀") (result i32) (i32.const 338))
+  (func (export "𑘀") (result i32) (i32.const 339))
+  (func (export "𑚀") (result i32) (i32.const 340))
+  (func (export "𑜒") (result i32) (i32.const 341))
+  (func (export "𑜠") (result i32) (i32.const 342))
+  (func (export "𑢡") (result i32) (i32.const 343))
+  (func (export "𑫕") (result i32) (i32.const 344))
+  (func (export "𑰀") (result i32) (i32.const 345))
+  (func (export "𑲏") (result i32) (i32.const 346))
+  (func (export "𑲯") (result i32) (i32.const 347))
+  (func (export "𒀀") (result i32) (i32.const 348))
+  (func (export "𖧕") (result i32) (i32.const 349))
+  (func (export "𖩆") (result i32) (i32.const 350))
+  (func (export "𖫧") (result i32) (i32.const 351))
+  (func (export "𖽔") (result i32) (i32.const 352))
+  (func (export "𛱁") (result i32) (i32.const 353))
+  (func (export "𛱤") (result i32) (i32.const 354))
+  (func (export "𞠣") (result i32) (i32.const 355))
+  (func (export "🇦") (result i32) (i32.const 356))
+  (func (export "Ɑ") (result i32) (i32.const 357))
+  (func (export "Λ") (result i32) (i32.const 358))
+  (func (export "Ɒ") (result i32) (i32.const 359))
+  (func (export "ª") (result i32) (i32.const 360))
+  (func (export "∀") (result i32) (i32.const 361))
+  (func (export "₳") (result i32) (i32.const 362))
+  (func (export "𐤀") (result i32) (i32.const 363))
+  (func (export "Ⲁ") (result i32) (i32.const 364))
+  (func (export "𐌰") (result i32) (i32.const 365))
+  (func (export "Ά") (result i32) (i32.const 366))
+  (func (export "Α") (result i32) (i32.const 367))
+  (func (export "Ἀ") (result i32) (i32.const 368))
+  (func (export "Ἁ") (result i32) (i32.const 369))
+  (func (export "Ἂ") (result i32) (i32.const 370))
+  (func (export "Ἃ") (result i32) (i32.const 371))
+  (func (export "Ἄ") (result i32) (i32.const 372))
+  (func (export "Ἅ") (result i32) (i32.const 373))
+  (func (export "Ἆ") (result i32) (i32.const 374))
+  (func (export "Ἇ") (result i32) (i32.const 375))
+  (func (export "ᾈ") (result i32) (i32.const 376))
+  (func (export "ᾉ") (result i32) (i32.const 377))
+  (func (export "ᾊ") (result i32) (i32.const 378))
+  (func (export "ᾋ") (result i32) (i32.const 379))
+  (func (export "ᾌ") (result i32) (i32.const 380))
+  (func (export "ᾍ") (result i32) (i32.const 381))
+  (func (export "ᾎ") (result i32) (i32.const 382))
+  (func (export "ᾏ") (result i32) (i32.const 383))
+  (func (export "Ᾰ") (result i32) (i32.const 384))
+  (func (export "Ᾱ") (result i32) (i32.const 385))
+  (func (export "Ὰ") (result i32) (i32.const 386))
+  (func (export "Ά") (result i32) (i32.const 387))
+  (func (export "ᾼ") (result i32) (i32.const 388))
+  (func (export "𝚨") (result i32) (i32.const 389))
+  (func (export "𝛢") (result i32) (i32.const 390))
+  (func (export "𝜜") (result i32) (i32.const 391))
+  (func (export "𝝖") (result i32) (i32.const 392))
+  (func (export "𝞐") (result i32) (i32.const 393))
+  (func (export "⍶") (result i32) (i32.const 394))
+  (func (export "⍺") (result i32) (i32.const 395))
+  (func (export "⩜") (result i32) (i32.const 396))
+  (func (export "ᗅ") (result i32) (i32.const 397))
+  (func (export "Ꭺ") (result i32) (i32.const 398))
+
+  ;; Test unmatched "closing" and "opening" code points.
+  (func (export ")˺˼𔗏𝅴𝅶𝅸𝅺⁾₎❩❫⟯﴿︶﹚）｠󠀩❳❵⟧⟩⟫⟭⦈⦊⦖⸣⸥︘︸︺︼︾﹀﹂﹄﹈﹜﹞］｝｣󠁝󠁽»’”›❯") (result i32) (i32.const 399))
+  (func (export "(˹˻𔗎𝅳𝅵𝅷𝅹⁽₍❨❪⟮﴾︵﹙（｟󠀨❲❴⟦⟨⟪⟬⦇⦉⦕⸢⸤︗︷︹︻︽︿﹁﹃﹇﹛﹝［｛｢󠁛󠁻«‘“‹❮") (result i32) (i32.const 400))
+  (func (export "𝪋𝪤") (result i32) (i32.const 401))
+  (func (export "𝪋") (result i32) (i32.const 402))
+
+  ;; Test that Unicode fraction normalization is not applied.
+  (func (export "½") (result i32) (i32.const 403))
+  (func (export "1⁄2") (result i32) (i32.const 404))
+  (func (export "1/2") (result i32) (i32.const 405))
+  (func (export "୳") (result i32) (i32.const 406))
+  (func (export "൴") (result i32) (i32.const 407))
+  (func (export "⳽") (result i32) (i32.const 408))
+  (func (export "꠱") (result i32) (i32.const 409))
+  (func (export "𐅁") (result i32) (i32.const 410))
+  (func (export "𐅵") (result i32) (i32.const 411))
+  (func (export "𐅶") (result i32) (i32.const 412))
+  (func (export "𐦽") (result i32) (i32.const 413))
+  (func (export "𐹻") (result i32) (i32.const 414))
+
+  ;; Test a full-width quote.
+  (func (export "＂") (result i32) (i32.const 415))
+
+  ;; Test that different present and historical representations of the "delete"
+  ;; concept are distinct.
+  (func (export "\7f") (result i32) (i32.const 416))
+  (func (export "\08") (result i32) (i32.const 417))
+  (func (export "⌫") (result i32) (i32.const 418))
+  (func (export "⌦") (result i32) (i32.const 419))
+  (func (export "␈") (result i32) (i32.const 420))
+  (func (export "␡") (result i32) (i32.const 421))
+  (func (export "᷻") (result i32) (i32.const 422))
+  (func (export "\0f") (result i32) (i32.const 423))
+  (func (export "←") (result i32) (i32.const 424))
+  (func (export "⌧") (result i32) (i32.const 425))
+  (func (export "⍒") (result i32) (i32.const 426))
+  (func (export "⍔") (result i32) (i32.const 427))
+  (func (export "⍢") (result i32) (i32.const 428))
+  (func (export "⍫") (result i32) (i32.const 429))
+
+  ;; Test that different representations of the "substitute" concept are
+  ;; distinct. (U+FFFD is covered above.)
+  (func (export "\1a") (result i32) (i32.const 430))
+  (func (export "␦") (result i32) (i32.const 431))
+  (func (export "␚") (result i32) (i32.const 432))
+  (func (export "") (result i32) (i32.const 433))
+  (func (export "?") (result i32) (i32.const 434))
+  (func (export "¿") (result i32) (i32.const 435))
+  (func (export "᥅") (result i32) (i32.const 436))
+  (func (export ";") (result i32) (i32.const 437))
+  (func (export "՞") (result i32) (i32.const 438))
+  (func (export "؟") (result i32) (i32.const 439))
+  (func (export "፧") (result i32) (i32.const 440))
+  (func (export "⁇") (result i32) (i32.const 441))
+  (func (export "⍰") (result i32) (i32.const 442))
+  (func (export "❓") (result i32) (i32.const 443))
+  (func (export "❔") (result i32) (i32.const 444))
+  (func (export "⳺") (result i32) (i32.const 445))
+  (func (export "⳻") (result i32) (i32.const 446))
+  (func (export "⸮") (result i32) (i32.const 447))
+  (func (export "㉄") (result i32) (i32.const 448))
+  (func (export "꘏") (result i32) (i32.const 449))
+  (func (export "꛷") (result i32) (i32.const 450))
+  (func (export "︖") (result i32) (i32.const 451))
+  (func (export "﹖") (result i32) (i32.const 452))
+  (func (export "？") (result i32) (i32.const 453))
+  (func (export "𑅃") (result i32) (i32.const 454))
+  (func (export "𞥟") (result i32) (i32.const 455))
+  (func (export "󠀿") (result i32) (i32.const 456))
+  (func (export "𖡄") (result i32) (i32.const 457))
+  (func (export "⯑") (result i32) (i32.const 458))
 
-  ;; Test that UTF-8 BOM characters can appear in identifiers.
-  (func (export "") (result f32) (f32.const 0x2.04p+2))
+  ;; Test that different present and historical representations of the
+  ;; "paragraph" concept are distinct. (U+2029 is covered above).
+  (func (export "¶") (result i32) (i32.const 459))
+  (func (export "⁋") (result i32) (i32.const 460))
+  (func (export "܀") (result i32) (i32.const 461))
+  (func (export "჻") (result i32) (i32.const 462))
+  (func (export "፨") (result i32) (i32.const 463))
+  (func (export "〷") (result i32) (i32.const 464))
+  (func (export "❡") (result i32) (i32.const 465))
+  (func (export "⸏") (result i32) (i32.const 466))
+  (func (export "⸐") (result i32) (i32.const 467))
+  (func (export "⸑") (result i32) (i32.const 468))
+  (func (export "⸎") (result i32) (i32.const 469))
+  (func (export "\14") (result i32) (i32.const 470)) ;; ¶ in CP437
+  (func (export "☙") (result i32) (i32.const 471))
 )
 
-(assert_return (invoke "") (f32.const 0x1.91p+2))
-(assert_return (invoke "malloc") (f32.const 0x1.92p+2))
-(assert_return (invoke "_malloc") (f32.const 0x1.93p+2))
-(assert_return (invoke "__malloc") (f32.const 0x1.94p+2))
-(assert_return (invoke "~!@#$%^&*()_+`-={}|[]\\:\";'<>?,./ ") (f32.const 0x1.96p+2))
-(assert_return (invoke "0") (f32.const 0x1.97p+2))
-(assert_return (invoke "_") (f32.const 0x1.98p+2))
-(assert_return (invoke "$") (f32.const 0x1.99p+2))
-(assert_return (invoke "@") (f32.const 0x2.00p+2))
-(assert_return (invoke "NaN") (f32.const 0x2.01p+2))
-(assert_return (invoke "Infinity") (f32.const 0x2.02p+2))
-(assert_return (invoke "if") (f32.const 0x2.03p+2))
-(assert_return (invoke "") (f32.const 0x2.04p+2))
+(assert_return (invoke "") (i32.const 0))
+(assert_return (invoke "0") (i32.const 1))
+(assert_return (invoke "-0") (i32.const 2))
+(assert_return (invoke "_") (i32.const 3))
+(assert_return (invoke "$") (i32.const 4))
+(assert_return (invoke "@") (i32.const 5))
+(assert_return (invoke "~!@#$%^&*()_+`-={}|[]\\:\";'<>?,./ ") (i32.const 6))
+(assert_return (invoke "NaN") (i32.const 7))
+(assert_return (invoke "Infinity") (i32.const 8))
+(assert_return (invoke "if") (i32.const 9))
+(assert_return (invoke "malloc") (i32.const 10))
+(assert_return (invoke "_malloc") (i32.const 11))
+(assert_return (invoke "__malloc") (i32.const 12))
+(assert_return (invoke "a") (i32.const 13))
+(assert_return (invoke "A") (i32.const 14))
+(assert_return (invoke "") (i32.const 15))
+(assert_return (invoke "Å") (i32.const 16))
+(assert_return (invoke "Å") (i32.const 17))
+(assert_return (invoke "Å") (i32.const 18))
+(assert_return (invoke "ffi") (i32.const 19))
+(assert_return (invoke "ffi") (i32.const 20))
+(assert_return (invoke "ffi") (i32.const 21))
+(assert_return (invoke "\00\01\02\03\04\05\06\07\08\09\0a\0b\0c\0d\0e\0f") (i32.const 22))
+(assert_return (invoke "\10\11\12\13\14\15\16\17\18\19\1a\1b\1c\1d\1e\1f") (i32.const 23))
+(assert_return (invoke " \7f") (i32.const 24))
+(assert_return (invoke "\c2\80\c2\81\c2\82\c2\83\c2\84\c2\85\c2\86\c2\87\c2\88\c2\89\c2\8a\c2\8b\c2\8c\c2\8d\c2\8e\c2\8f") (i32.const 25))
+(assert_return (invoke "\c2\90\c2\91\c2\92\c2\93\c2\94\c2\95\c2\96\c2\97\c2\98\c2\99\c2\9a\c2\9b\c2\9c\c2\9d\c2\9e\c2\9f") (i32.const 26))
+(assert_return (invoke "\ef\bf\b0\ef\bf\b1\ef\bf\b2\ef\bf\b3\ef\bf\b4\ef\bf\b5\ef\bf\b6\ef\bf\b7") (i32.const 27))
+(assert_return (invoke "\ef\bf\b8\ef\bf\b9\ef\bf\ba\ef\bf\bb\ef\bf\bc\ef\bf\bd\ef\bf\be\ef\bf\bf") (i32.const 28))
+(assert_return (invoke "␀␁␂␃␄␅␆␇␈␉␊␋␌␍␎␏") (i32.const 29))
+(assert_return (invoke "␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟") (i32.const 30))
+(assert_return (invoke "␠␡") (i32.const 31))
+(assert_return (invoke "￰￱￲￳￴￵￶￷￸�") (i32.const 32))
+(assert_return (invoke "‍") (i32.const 33))
+(assert_return (invoke "‌") (i32.const 34))
+(assert_return (invoke "͏") (i32.const 35))
+(assert_return (invoke "⁠") (i32.const 36))
+(assert_return (invoke "⵿") (i32.const 37))
+(assert_return (invoke "𑁿") (i32.const 38))
+(assert_return (invoke "᠎") (i32.const 39))
+(assert_return (invoke "￯​ ­⁠ ‮‭") (i32.const 40))
+(assert_return (invoke "‎‏‑

‪‫‬ ⁦⁧⁨⁩") (i32.const 41))
+(assert_return (invoke "") (i32.const 42))
+(assert_return (invoke "⁡⁢⁣⁤") (i32.const 43))
+(assert_return (invoke "𐀀󟿿􏿿") (i32.const 44))
+(assert_return (invoke "Z̴͇̫̥̪͓͈͔͎̗̞̺̯̱̞̙̱̜̖̠̏͆̆͛͌͘͞ḁ̶̰̳̭͙̲̱̹̝͎̼͗ͨ̎̄̆͗̿̀́͟͡l̶̷͉̩̹̫̝͖̙̲̼͇͚͍̮͎̥̞̈́͊͗ͦ̈́ͫ̇́̚ͅͅg̶͕͔͚̩̓̐̅ͮ̔̐̎̂̏̾͊̍͋͊ͧ́̆ͦ͞o̡͋̔͐ͪͩ͏̢̧̫̙̤̮͖͙͓̺̜̩̼̘̠́") (i32.const 45))
+(assert_return (invoke "ᅟᅠㅤﾠ") (i32.const 46))
+(assert_return (invoke "︀") (i32.const 47))
+(assert_return (invoke "︄") (i32.const 48))
+(assert_return (invoke "󠄀") (i32.const 49))
+(assert_return (invoke "󠇯") (i32.const 50))
+(assert_return (invoke "̈") (i32.const 51))
+(assert_return (invoke "\0a") (i32.const 52))
+(assert_return (invoke "␤") (i32.const 53))
+(assert_return (invoke "
") (i32.const 54))
+(assert_return (invoke "\0d") (i32.const 55))
+(assert_return (invoke "\0d\0a") (i32.const 56))
+(assert_return (invoke "\0a\0d") (i32.const 57))
+(assert_return (invoke "\1e") (i32.const 58))
+(assert_return (invoke "\0b") (i32.const 59))
+(assert_return (invoke "\0c") (i32.const 60))
+(assert_return (invoke "\c2\85") (i32.const 61))
+(assert_return (invoke "
") (i32.const 62))
+(assert_return (invoke "…") (i32.const 63))
+(assert_return (invoke "⏎") (i32.const 64))
+(assert_return (invoke "\c2\8b") (i32.const 65))
+(assert_return (invoke "\c2\8c") (i32.const 66))
+(assert_return (invoke "\c2\8d") (i32.const 67))
+(assert_return (invoke "↵") (i32.const 68))
+(assert_return (invoke "↩") (i32.const 69))
+(assert_return (invoke "⌤") (i32.const 70))
+(assert_return (invoke "⤶") (i32.const 71))
+(assert_return (invoke "↲") (i32.const 72))
+(assert_return (invoke "⮨") (i32.const 73))
+(assert_return (invoke "⮰") (i32.const 74))
+(assert_return (invoke "�") (i32.const 75))
+(assert_return (invoke "\ef\b7\90") (i32.const 76))
+(assert_return (invoke "\ef\b7\91") (i32.const 77))
+(assert_return (invoke "\ef\b7\92") (i32.const 78))
+(assert_return (invoke "\ef\b7\93") (i32.const 79))
+(assert_return (invoke "\ef\b7\94") (i32.const 80))
+(assert_return (invoke "\ef\b7\95") (i32.const 81))
+(assert_return (invoke "\ef\b7\96") (i32.const 82))
+(assert_return (invoke "\ef\b7\97") (i32.const 83))
+(assert_return (invoke "\ef\b7\98") (i32.const 84))
+(assert_return (invoke "\ef\b7\99") (i32.const 85))
+(assert_return (invoke "\ef\b7\9a") (i32.const 86))
+(assert_return (invoke "\ef\b7\9b") (i32.const 87))
+(assert_return (invoke "\ef\b7\9c") (i32.const 88))
+(assert_return (invoke "\ef\b7\9d") (i32.const 89))
+(assert_return (invoke "\ef\b7\9e") (i32.const 90))
+(assert_return (invoke "\ef\b7\9f") (i32.const 91))
+(assert_return (invoke "\ef\b7\a0") (i32.const 92))
+(assert_return (invoke "\ef\b7\a1") (i32.const 93))
+(assert_return (invoke "\ef\b7\a2") (i32.const 94))
+(assert_return (invoke "\ef\b7\a3") (i32.const 95))
+(assert_return (invoke "\ef\b7\a4") (i32.const 96))
+(assert_return (invoke "\ef\b7\a5") (i32.const 97))
+(assert_return (invoke "\ef\b7\a6") (i32.const 98))
+(assert_return (invoke "\ef\b7\a7") (i32.const 99))
+(assert_return (invoke "\ef\b7\a8") (i32.const 100))
+(assert_return (invoke "\ef\b7\a9") (i32.const 101))
+(assert_return (invoke "\ef\b7\aa") (i32.const 102))
+(assert_return (invoke "\ef\b7\ab") (i32.const 103))
+(assert_return (invoke "\ef\b7\ac") (i32.const 104))
+(assert_return (invoke "\ef\b7\ad") (i32.const 105))
+(assert_return (invoke "\ef\b7\ae") (i32.const 106))
+(assert_return (invoke "\ef\b7\af") (i32.const 107))
+(assert_return (invoke "\ef\bf\be") (i32.const 108))
+(assert_return (invoke "\ef\bf\bf") (i32.const 109))
+(assert_return (invoke "\f0\9f\bf\be") (i32.const 110))
+(assert_return (invoke "\f0\9f\bf\bf") (i32.const 111))
+(assert_return (invoke "\f0\af\bf\be") (i32.const 112))
+(assert_return (invoke "\f0\af\bf\bf") (i32.const 113))
+(assert_return (invoke "\f0\bf\bf\be") (i32.const 114))
+(assert_return (invoke "\f0\bf\bf\bf") (i32.const 115))
+(assert_return (invoke "\f1\8f\bf\be") (i32.const 116))
+(assert_return (invoke "\f1\8f\bf\bf") (i32.const 117))
+(assert_return (invoke "\f1\9f\bf\be") (i32.const 118))
+(assert_return (invoke "\f1\9f\bf\bf") (i32.const 119))
+(assert_return (invoke "\f1\af\bf\be") (i32.const 120))
+(assert_return (invoke "\f1\af\bf\bf") (i32.const 121))
+(assert_return (invoke "\f1\bf\bf\be") (i32.const 122))
+(assert_return (invoke "\f1\bf\bf\bf") (i32.const 123))
+(assert_return (invoke "\f2\8f\bf\be") (i32.const 124))
+(assert_return (invoke "\f2\8f\bf\bf") (i32.const 125))
+(assert_return (invoke "\f2\9f\bf\be") (i32.const 126))
+(assert_return (invoke "\f2\9f\bf\bf") (i32.const 127))
+(assert_return (invoke "\f2\af\bf\be") (i32.const 128))
+(assert_return (invoke "\f2\af\bf\bf") (i32.const 129))
+(assert_return (invoke "\f2\bf\bf\be") (i32.const 130))
+(assert_return (invoke "\f2\bf\bf\bf") (i32.const 131))
+(assert_return (invoke "\f3\8f\bf\be") (i32.const 132))
+(assert_return (invoke "\f3\8f\bf\bf") (i32.const 133))
+(assert_return (invoke "\f3\9f\bf\be") (i32.const 134))
+(assert_return (invoke "\f3\9f\bf\bf") (i32.const 135))
+(assert_return (invoke "\f3\af\bf\be") (i32.const 136))
+(assert_return (invoke "\f3\af\bf\bf") (i32.const 137))
+(assert_return (invoke "\f3\bf\bf\be") (i32.const 138))
+(assert_return (invoke "\f3\bf\bf\bf") (i32.const 139))
+(assert_return (invoke "\f4\8f\bf\be") (i32.const 140))
+(assert_return (invoke "\f4\8f\bf\bf") (i32.const 141))
+(assert_return (invoke "̈‽̈̉") (i32.const 142))
+(assert_return (invoke "abc") (i32.const 143))
+(assert_return (invoke "‭abc") (i32.const 144))
+(assert_return (invoke "‮cba") (i32.const 145))
+(assert_return (invoke "‭abc‮") (i32.const 146))
+(assert_return (invoke "‮cba‭") (i32.const 147))
+(assert_return (invoke "𝑨") (i32.const 148))
+(assert_return (invoke "𝐴") (i32.const 149))
+(assert_return (invoke "𝘈") (i32.const 150))
+(assert_return (invoke "𝘼") (i32.const 151))
+(assert_return (invoke "𝐀") (i32.const 152))
+(assert_return (invoke "𝓐") (i32.const 153))
+(assert_return (invoke "𝕬") (i32.const 154))
+(assert_return (invoke "𝗔") (i32.const 155))
+(assert_return (invoke "𝒜") (i32.const 156))
+(assert_return (invoke "𝔄") (i32.const 157))
+(assert_return (invoke "𝔸") (i32.const 158))
+(assert_return (invoke "𝖠") (i32.const 159))
+(assert_return (invoke "𝙰") (i32.const 160))
+(assert_return (invoke "ᴀ") (i32.const 161))
+(assert_return (invoke "ᴬ") (i32.const 162))
+(assert_return (invoke "Ⓐ") (i32.const 163))
+(assert_return (invoke "Ａ") (i32.const 164))
+(assert_return (invoke "🄐") (i32.const 165))
+(assert_return (invoke "🄰") (i32.const 166))
+(assert_return (invoke "󠁁") (i32.const 167))
+(assert_return (invoke "U+0041") (i32.const 168))
+(assert_return (invoke "A​") (i32.const 169))
+(assert_return (invoke "А") (i32.const 170))
+(assert_return (invoke "Ꙗ") (i32.const 171))
+(assert_return (invoke "ⷼ") (i32.const 172))
+(assert_return (invoke "ⷶ") (i32.const 173))
+(assert_return (invoke "Ɐ") (i32.const 174))
+(assert_return (invoke "🅐") (i32.const 175))
+(assert_return (invoke "🅰") (i32.const 176))
+(assert_return (invoke "Ⱝ") (i32.const 177))
+(assert_return (invoke "𐐂") (i32.const 178))
+(assert_return (invoke "𐐈") (i32.const 179))
+(assert_return (invoke "𐒰") (i32.const 180))
+(assert_return (invoke "À") (i32.const 181))
+(assert_return (invoke "Á") (i32.const 182))
+(assert_return (invoke "Â") (i32.const 183))
+(assert_return (invoke "Ã") (i32.const 184))
+(assert_return (invoke "Ä") (i32.const 185))
+(assert_return (invoke "Ā") (i32.const 186))
+(assert_return (invoke "Ă") (i32.const 187))
+(assert_return (invoke "Ą") (i32.const 188))
+(assert_return (invoke "Ǎ") (i32.const 189))
+(assert_return (invoke "Ǟ") (i32.const 190))
+(assert_return (invoke "Ǡ") (i32.const 191))
+(assert_return (invoke "Ǻ") (i32.const 192))
+(assert_return (invoke "Ȁ") (i32.const 193))
+(assert_return (invoke "Ȃ") (i32.const 194))
+(assert_return (invoke "Ȧ") (i32.const 195))
+(assert_return (invoke "Ⱥ") (i32.const 196))
+(assert_return (invoke "Ӑ") (i32.const 197))
+(assert_return (invoke "Ӓ") (i32.const 198))
+(assert_return (invoke "ߊ") (i32.const 199))
+(assert_return (invoke "ࠡ") (i32.const 200))
+(assert_return (invoke "ࠢ") (i32.const 201))
+(assert_return (invoke "ࠣ") (i32.const 202))
+(assert_return (invoke "ࠤ") (i32.const 203))
+(assert_return (invoke "ࠥ") (i32.const 204))
+(assert_return (invoke "ऄ") (i32.const 205))
+(assert_return (invoke "अ") (i32.const 206))
+(assert_return (invoke "ॲ") (i32.const 207))
+(assert_return (invoke "অ") (i32.const 208))
+(assert_return (invoke "ਅ") (i32.const 209))
+(assert_return (invoke "અ") (i32.const 210))
+(assert_return (invoke "ଅ") (i32.const 211))
+(assert_return (invoke "அ") (i32.const 212))
+(assert_return (invoke "అ") (i32.const 213))
+(assert_return (invoke "ಅ") (i32.const 214))
+(assert_return (invoke "അ") (i32.const 215))
+(assert_return (invoke "ะ") (i32.const 216))
+(assert_return (invoke "ະ") (i32.const 217))
+(assert_return (invoke "༁") (i32.const 218))
+(assert_return (invoke "ཨ") (i32.const 219))
+(assert_return (invoke "ྸ") (i32.const 220))
+(assert_return (invoke "အ") (i32.const 221))
+(assert_return (invoke "ဢ") (i32.const 222))
+(assert_return (invoke "ႜ") (i32.const 223))
+(assert_return (invoke "ᅡ") (i32.const 224))
+(assert_return (invoke "አ") (i32.const 225))
+(assert_return (invoke "ዐ") (i32.const 226))
+(assert_return (invoke "Ꭰ") (i32.const 227))
+(assert_return (invoke "ᐊ") (i32.const 228))
+(assert_return (invoke "ᖳ") (i32.const 229))
+(assert_return (invoke "ᚨ") (i32.const 230))
+(assert_return (invoke "ᚪ") (i32.const 231))
+(assert_return (invoke "ᛆ") (i32.const 232))
+(assert_return (invoke "ᜀ") (i32.const 233))
+(assert_return (invoke "ᜠ") (i32.const 234))
+(assert_return (invoke "ᝀ") (i32.const 235))
+(assert_return (invoke "ᝠ") (i32.const 236))
+(assert_return (invoke "ᠠ") (i32.const 237))
+(assert_return (invoke "ᢇ") (i32.const 238))
+(assert_return (invoke "ᤠ") (i32.const 239))
+(assert_return (invoke "ᥣ") (i32.const 240))
+(assert_return (invoke "ᨕ") (i32.const 241))
+(assert_return (invoke "ᩋ") (i32.const 242))
+(assert_return (invoke "ᩡ") (i32.const 243))
+(assert_return (invoke "ᮃ") (i32.const 244))
+(assert_return (invoke "ᯀ") (i32.const 245))
+(assert_return (invoke "ᯁ") (i32.const 246))
+(assert_return (invoke "ᰣ") (i32.const 247))
+(assert_return (invoke "Ḁ") (i32.const 248))
+(assert_return (invoke "Ạ") (i32.const 249))
+(assert_return (invoke "Ả") (i32.const 250))
+(assert_return (invoke "Ấ") (i32.const 251))
+(assert_return (invoke "Ầ") (i32.const 252))
+(assert_return (invoke "Ẩ") (i32.const 253))
+(assert_return (invoke "Ẫ") (i32.const 254))
+(assert_return (invoke "Ậ") (i32.const 255))
+(assert_return (invoke "Ắ") (i32.const 256))
+(assert_return (invoke "Ằ") (i32.const 257))
+(assert_return (invoke "Ẳ") (i32.const 258))
+(assert_return (invoke "Ẵ") (i32.const 259))
+(assert_return (invoke "Ặ") (i32.const 260))
+(assert_return (invoke "あ") (i32.const 261))
+(assert_return (invoke "ア") (i32.const 262))
+(assert_return (invoke "ㄚ") (i32.const 263))
+(assert_return (invoke "ㅏ") (i32.const 264))
+(assert_return (invoke "㈎") (i32.const 265))
+(assert_return (invoke "㈏") (i32.const 266))
+(assert_return (invoke "㈐") (i32.const 267))
+(assert_return (invoke "㈑") (i32.const 268))
+(assert_return (invoke "㈒") (i32.const 269))
+(assert_return (invoke "㈓") (i32.const 270))
+(assert_return (invoke "㈔") (i32.const 271))
+(assert_return (invoke "㈕") (i32.const 272))
+(assert_return (invoke "㈖") (i32.const 273))
+(assert_return (invoke "㈗") (i32.const 274))
+(assert_return (invoke "㈘") (i32.const 275))
+(assert_return (invoke "㈙") (i32.const 276))
+(assert_return (invoke "㈚") (i32.const 277))
+(assert_return (invoke "㈛") (i32.const 278))
+(assert_return (invoke "㉮") (i32.const 279))
+(assert_return (invoke "㉯") (i32.const 280))
+(assert_return (invoke "㉰") (i32.const 281))
+(assert_return (invoke "㉱") (i32.const 282))
+(assert_return (invoke "㉲") (i32.const 283))
+(assert_return (invoke "㉳") (i32.const 284))
+(assert_return (invoke "㉴") (i32.const 285))
+(assert_return (invoke "㉵") (i32.const 286))
+(assert_return (invoke "㉶") (i32.const 287))
+(assert_return (invoke "㉷") (i32.const 288))
+(assert_return (invoke "㉸") (i32.const 289))
+(assert_return (invoke "㉹") (i32.const 290))
+(assert_return (invoke "㉺") (i32.const 291))
+(assert_return (invoke "㉻") (i32.const 292))
+(assert_return (invoke "㋐") (i32.const 293))
+(assert_return (invoke "ꀊ") (i32.const 294))
+(assert_return (invoke "ꓮ") (i32.const 295))
+(assert_return (invoke "ꕉ") (i32.const 296))
+(assert_return (invoke "ꚠ") (i32.const 297))
+(assert_return (invoke "ꠀ") (i32.const 298))
+(assert_return (invoke "ꠣ") (i32.const 299))
+(assert_return (invoke "ꡝ") (i32.const 300))
+(assert_return (invoke "ꢂ") (i32.const 301))
+(assert_return (invoke "꣪") (i32.const 302))
+(assert_return (invoke "ꤢ") (i32.const 303))
+(assert_return (invoke "ꥆ") (i32.const 304))
+(assert_return (invoke "ꦄ") (i32.const 305))
+(assert_return (invoke "ꨀ") (i32.const 306))
+(assert_return (invoke "ｱ") (i32.const 307))
+(assert_return (invoke "ￂ") (i32.const 308))
+(assert_return (invoke "𐀀") (i32.const 309))
+(assert_return (invoke "𐊀") (i32.const 310))
+(assert_return (invoke "𐊠") (i32.const 311))
+(assert_return (invoke "𐌀") (i32.const 312))
+(assert_return (invoke "𐎠") (i32.const 313))
+(assert_return (invoke "𐒖") (i32.const 314))
+(assert_return (invoke "𐔀") (i32.const 315))
+(assert_return (invoke "𐝀") (i32.const 316))
+(assert_return (invoke "𐠀") (i32.const 317))
+(assert_return (invoke "𐤠") (i32.const 318))
+(assert_return (invoke "𐦀") (i32.const 319))
+(assert_return (invoke "𐦠") (i32.const 320))
+(assert_return (invoke "𐨀") (i32.const 321))
+(assert_return (invoke "𐬀") (i32.const 322))
+(assert_return (invoke "𐰀") (i32.const 323))
+(assert_return (invoke "𐰁") (i32.const 324))
+(assert_return (invoke "𐲀") (i32.const 325))
+(assert_return (invoke "𑀅") (i32.const 326))
+(assert_return (invoke "𑂃") (i32.const 327))
+(assert_return (invoke "𑄧") (i32.const 328))
+(assert_return (invoke "𑅐") (i32.const 329))
+(assert_return (invoke "𑆃") (i32.const 330))
+(assert_return (invoke "𑈀") (i32.const 331))
+(assert_return (invoke "𑊀") (i32.const 332))
+(assert_return (invoke "𑊰") (i32.const 333))
+(assert_return (invoke "𑌅") (i32.const 334))
+(assert_return (invoke "𑍰") (i32.const 335))
+(assert_return (invoke "𑐀") (i32.const 336))
+(assert_return (invoke "𑒁") (i32.const 337))
+(assert_return (invoke "𑖀") (i32.const 338))
+(assert_return (invoke "𑘀") (i32.const 339))
+(assert_return (invoke "𑚀") (i32.const 340))
+(assert_return (invoke "𑜒") (i32.const 341))
+(assert_return (invoke "𑜠") (i32.const 342))
+(assert_return (invoke "𑢡") (i32.const 343))
+(assert_return (invoke "𑫕") (i32.const 344))
+(assert_return (invoke "𑰀") (i32.const 345))
+(assert_return (invoke "𑲏") (i32.const 346))
+(assert_return (invoke "𑲯") (i32.const 347))
+(assert_return (invoke "𒀀") (i32.const 348))
+(assert_return (invoke "𖧕") (i32.const 349))
+(assert_return (invoke "𖩆") (i32.const 350))
+(assert_return (invoke "𖫧") (i32.const 351))
+(assert_return (invoke "𖽔") (i32.const 352))
+(assert_return (invoke "𛱁") (i32.const 353))
+(assert_return (invoke "𛱤") (i32.const 354))
+(assert_return (invoke "𞠣") (i32.const 355))
+(assert_return (invoke "🇦") (i32.const 356))
+(assert_return (invoke "Ɑ") (i32.const 357))
+(assert_return (invoke "Λ") (i32.const 358))
+(assert_return (invoke "Ɒ") (i32.const 359))
+(assert_return (invoke "ª") (i32.const 360))
+(assert_return (invoke "∀") (i32.const 361))
+(assert_return (invoke "₳") (i32.const 362))
+(assert_return (invoke "𐤀") (i32.const 363))
+(assert_return (invoke "Ⲁ") (i32.const 364))
+(assert_return (invoke "𐌰") (i32.const 365))
+(assert_return (invoke "Ά") (i32.const 366))
+(assert_return (invoke "Α") (i32.const 367))
+(assert_return (invoke "Ἀ") (i32.const 368))
+(assert_return (invoke "Ἁ") (i32.const 369))
+(assert_return (invoke "Ἂ") (i32.const 370))
+(assert_return (invoke "Ἃ") (i32.const 371))
+(assert_return (invoke "Ἄ") (i32.const 372))
+(assert_return (invoke "Ἅ") (i32.const 373))
+(assert_return (invoke "Ἆ") (i32.const 374))
+(assert_return (invoke "Ἇ") (i32.const 375))
+(assert_return (invoke "ᾈ") (i32.const 376))
+(assert_return (invoke "ᾉ") (i32.const 377))
+(assert_return (invoke "ᾊ") (i32.const 378))
+(assert_return (invoke "ᾋ") (i32.const 379))
+(assert_return (invoke "ᾌ") (i32.const 380))
+(assert_return (invoke "ᾍ") (i32.const 381))
+(assert_return (invoke "ᾎ") (i32.const 382))
+(assert_return (invoke "ᾏ") (i32.const 383))
+(assert_return (invoke "Ᾰ") (i32.const 384))
+(assert_return (invoke "Ᾱ") (i32.const 385))
+(assert_return (invoke "Ὰ") (i32.const 386))
+(assert_return (invoke "Ά") (i32.const 387))
+(assert_return (invoke "ᾼ") (i32.const 388))
+(assert_return (invoke "𝚨") (i32.const 389))
+(assert_return (invoke "𝛢") (i32.const 390))
+(assert_return (invoke "𝜜") (i32.const 391))
+(assert_return (invoke "𝝖") (i32.const 392))
+(assert_return (invoke "𝞐") (i32.const 393))
+(assert_return (invoke "⍶") (i32.const 394))
+(assert_return (invoke "⍺") (i32.const 395))
+(assert_return (invoke "⩜") (i32.const 396))
+(assert_return (invoke "ᗅ") (i32.const 397))
+(assert_return (invoke "Ꭺ") (i32.const 398))
+(assert_return (invoke ")˺˼𔗏𝅴𝅶𝅸𝅺⁾₎❩❫⟯﴿︶﹚）｠󠀩❳❵⟧⟩⟫⟭⦈⦊⦖⸣⸥︘︸︺︼︾﹀﹂﹄﹈﹜﹞］｝｣󠁝󠁽»’”›❯") (i32.const 399))
+(assert_return (invoke "(˹˻𔗎𝅳𝅵𝅷𝅹⁽₍❨❪⟮﴾︵﹙（｟󠀨❲❴⟦⟨⟪⟬⦇⦉⦕⸢⸤︗︷︹︻︽︿﹁﹃﹇﹛﹝［｛｢󠁛󠁻«‘“‹❮") (i32.const 400))
+(assert_return (invoke "𝪋𝪤") (i32.const 401))
+(assert_return (invoke "𝪋") (i32.const 402))
+(assert_return (invoke "½") (i32.const 403))
+(assert_return (invoke "1⁄2") (i32.const 404))
+(assert_return (invoke "1/2") (i32.const 405))
+(assert_return (invoke "୳") (i32.const 406))
+(assert_return (invoke "൴") (i32.const 407))
+(assert_return (invoke "⳽") (i32.const 408))
+(assert_return (invoke "꠱") (i32.const 409))
+(assert_return (invoke "𐅁") (i32.const 410))
+(assert_return (invoke "𐅵") (i32.const 411))
+(assert_return (invoke "𐅶") (i32.const 412))
+(assert_return (invoke "𐦽") (i32.const 413))
+(assert_return (invoke "𐹻") (i32.const 414))
+(assert_return (invoke "＂") (i32.const 415))
+(assert_return (invoke "\7f") (i32.const 416))
+(assert_return (invoke "\08") (i32.const 417))
+(assert_return (invoke "⌫") (i32.const 418))
+(assert_return (invoke "⌦") (i32.const 419))
+(assert_return (invoke "␈") (i32.const 420))
+(assert_return (invoke "␡") (i32.const 421))
+(assert_return (invoke "᷻") (i32.const 422))
+(assert_return (invoke "\0f") (i32.const 423))
+(assert_return (invoke "←") (i32.const 424))
+(assert_return (invoke "⌧") (i32.const 425))
+(assert_return (invoke "⍒") (i32.const 426))
+(assert_return (invoke "⍔") (i32.const 427))
+(assert_return (invoke "⍢") (i32.const 428))
+(assert_return (invoke "⍫") (i32.const 429))
+(assert_return (invoke "\1a") (i32.const 430))
+(assert_return (invoke "␦") (i32.const 431))
+(assert_return (invoke "␚") (i32.const 432))
+(assert_return (invoke "") (i32.const 433))
+(assert_return (invoke "?") (i32.const 434))
+(assert_return (invoke "¿") (i32.const 435))
+(assert_return (invoke "᥅") (i32.const 436))
+(assert_return (invoke ";") (i32.const 437))
+(assert_return (invoke "՞") (i32.const 438))
+(assert_return (invoke "؟") (i32.const 439))
+(assert_return (invoke "፧") (i32.const 440))
+(assert_return (invoke "⁇") (i32.const 441))
+(assert_return (invoke "⍰") (i32.const 442))
+(assert_return (invoke "❓") (i32.const 443))
+(assert_return (invoke "❔") (i32.const 444))
+(assert_return (invoke "⳺") (i32.const 445))
+(assert_return (invoke "⳻") (i32.const 446))
+(assert_return (invoke "⸮") (i32.const 447))
+(assert_return (invoke "㉄") (i32.const 448))
+(assert_return (invoke "꘏") (i32.const 449))
+(assert_return (invoke "꛷") (i32.const 450))
+(assert_return (invoke "︖") (i32.const 451))
+(assert_return (invoke "﹖") (i32.const 452))
+(assert_return (invoke "？") (i32.const 453))
+(assert_return (invoke "𑅃") (i32.const 454))
+(assert_return (invoke "𞥟") (i32.const 455))
+(assert_return (invoke "󠀿") (i32.const 456))
+(assert_return (invoke "𖡄") (i32.const 457))
+(assert_return (invoke "⯑") (i32.const 458))
+(assert_return (invoke "¶") (i32.const 459))
+(assert_return (invoke "⁋") (i32.const 460))
+(assert_return (invoke "܀") (i32.const 461))
+(assert_return (invoke "჻") (i32.const 462))
+(assert_return (invoke "፨") (i32.const 463))
+(assert_return (invoke "〷") (i32.const 464))
+(assert_return (invoke "❡") (i32.const 465))
+(assert_return (invoke "⸏") (i32.const 466))
+(assert_return (invoke "⸐") (i32.const 467))
+(assert_return (invoke "⸑") (i32.const 468))
+(assert_return (invoke "⸎") (i32.const 469))
+(assert_return (invoke "\14") (i32.const 470))
+(assert_return (invoke "☙") (i32.const 471))
 
 (module
   ;; Test that we can use indices instead of names to reference imports,

From c09927151ff6d9b6ca0acf6b48e4825de1416a46 Mon Sep 17 00:00:00 2001
From: Dan Gohman <sunfish@mozilla.com>
Date: Thu, 18 May 2017 07:41:35 -0700
Subject: [PATCH 020/329] Float tests (#479)

* Test that x/2*2 is not folded to x.

* Test that y < 0 ? x : (x + 1) is not folded to x + (y < 0).

* Test that implementations don't do the x+0x1p52-0x1p52 trick outside the range where it's safe.

* Test that floor isn't implemented as XMVectorFloor.
---
 test/core/float_exprs.wast | 28 ++++++++++++++++++++++++++++
 test/core/float_misc.wast  | 12 ++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/test/core/float_exprs.wast b/test/core/float_exprs.wast
index 9069c158c..3fb15b591 100644
--- a/test/core/float_exprs.wast
+++ b/test/core/float_exprs.wast
@@ -602,6 +602,18 @@
 (assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.e75859d2f0765p-278) (f64.const -0x1.5f19b6ab497f9p+283)) (f64.const -0x1.e75859d2f0764p-278))
 (assert_return (invoke "f64.no_fold_div_mul" (f64.const -0x1.515fe9c3b5f5p+620) (f64.const 0x1.36be869c99f7ap+989)) (f64.const -0x1.515fe9c3b5f4fp+620))
 
+;; Test that x/2*2 is not folded to x.
+
+(module
+  (func (export "f32.no_fold_div2_mul2") (param $x f32) (result f32)
+    (f32.mul (f32.div (get_local $x) (f32.const 2.0)) (f32.const 2.0)))
+  (func (export "f64.no_fold_div2_mul2") (param $x f64) (result f64)
+    (f64.mul (f64.div (get_local $x) (f64.const 2.0)) (f64.const 2.0)))
+)
+
+(assert_return (invoke "f32.no_fold_div2_mul2" (f32.const 0x1.fffffep-126)) (f32.const 0x1p-125))
+(assert_return (invoke "f64.no_fold_div2_mul2" (f64.const 0x1.fffffffffffffp-1022)) (f64.const 0x1p-1021))
+
 ;; Test that promote(demote(x)) is not folded to x.
 
 (module
@@ -2476,3 +2488,19 @@
 
 (assert_return (invoke "tau" (i32.const 10)) (f64.const 0x1.921fb54442d14p+2))
 (assert_return (invoke "tau" (i32.const 11)) (f64.const 0x1.921fb54442d18p+2))
+
+;; Test that y < 0 ? x : (x + 1) is not folded to x + (y < 0).
+
+(module
+  (func (export "f32.no_fold_conditional_inc") (param $x f32) (param $y f32) (result f32)
+    (select (get_local $x)
+            (f32.add (get_local $x) (f32.const 1.0))
+            (f32.lt (get_local $y) (f32.const 0.0))))
+  (func (export "f64.no_fold_conditional_inc") (param $x f64) (param $y f64) (result f64)
+    (select (get_local $x)
+            (f64.add (get_local $x) (f64.const 1.0))
+            (f64.lt (get_local $y) (f64.const 0.0))))
+)
+
+(assert_return (invoke "f32.no_fold_conditional_inc" (f32.const -0.0) (f32.const -1.0)) (f32.const -0.0))
+(assert_return (invoke "f64.no_fold_conditional_inc" (f64.const -0.0) (f64.const -1.0)) (f64.const -0.0))
diff --git a/test/core/float_misc.wast b/test/core/float_misc.wast
index 4ad9bd668..1d67fdff5 100644
--- a/test/core/float_misc.wast
+++ b/test/core/float_misc.wast
@@ -620,6 +620,13 @@
 (assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1p+52))
 (assert_return (invoke "f64.ceil" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1.ffffffffffffep+51))
 
+;; Test that implementations don't do the x+0x1p52-0x1p52 trick outside the
+;; range where it's safe.
+(assert_return (invoke "f32.ceil" (f32.const 0x1.fffffep+23)) (f32.const 0x1.fffffep+23))
+(assert_return (invoke "f32.ceil" (f32.const -0x1.fffffep+23)) (f32.const -0x1.fffffep+23))
+(assert_return (invoke "f64.ceil" (f64.const 0x1.fffffffffffffp+52)) (f64.const 0x1.fffffffffffffp+52))
+(assert_return (invoke "f64.ceil" (f64.const -0x1.fffffffffffffp+52)) (f64.const -0x1.fffffffffffffp+52))
+
 ;; Test values close to -1.0.
 (assert_return (invoke "f32.floor" (f32.const -0x1.fffffep-1)) (f32.const -1.0))
 (assert_return (invoke "f32.floor" (f32.const -0x1.000002p+0)) (f32.const -2.0))
@@ -632,6 +639,11 @@
 (assert_return (invoke "f64.floor" (f64.const -0x1.fffffffffffffp+51)) (f64.const -0x1p+52))
 (assert_return (invoke "f64.floor" (f64.const 0x1.fffffffffffffp+51)) (f64.const 0x1.ffffffffffffep+51))
 
+;; Test that floor isn't implemented as XMVectorFloor.
+;; http://dss.stephanierct.com/DevBlog/?p=8#comment-4
+(assert_return (invoke "f32.floor" (f32.const 88607.0)) (f32.const 88607.0))
+(assert_return (invoke "f64.floor" (f64.const 88607.0)) (f64.const 88607.0))
+
 ;; Test the maximum and minimum value for which trunc is not an identity operator.
 (assert_return (invoke "f32.trunc" (f32.const -0x1.fffffep+22)) (f32.const -0x1.fffffcp+22))
 (assert_return (invoke "f32.trunc" (f32.const 0x1.fffffep+22)) (f32.const 0x1.fffffcp+22))

From 913fbf477ecf113f254ab27918a883257fff8bcb Mon Sep 17 00:00:00 2001
From: Luke Wagner <mail@lukewagner.name>
Date: Tue, 23 May 2017 00:31:02 +0200
Subject: [PATCH 021/329] Update tests for Instance exports property (#484)

---
 test/js-api/jsapi.js | 21 +++++++++++++--------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 61dd0a6d0..6fc2fdf31 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -97,6 +97,7 @@ let CompileError;
 let LinkError;
 let RuntimeError;
 let Memory;
+let instanceProto;
 let memoryProto;
 let mem1;
 let Table;
@@ -350,7 +351,7 @@ test(() => {
 }, "'WebAssembly.Instance.prototype' data property");
 
 test(() => {
-    const instanceProto = Instance.prototype;
+    instanceProto = Instance.prototype;
     const instanceProtoDesc = Object.getOwnPropertyDescriptor(Instance, 'prototype');
     assert_equals(instanceProto, instanceProtoDesc.value);
     assert_equals(String(instanceProto), "[object WebAssembly.Instance]");
@@ -366,12 +367,16 @@ test(() => {
 }, "'WebAssembly.Instance' instance objects");
 
 test(() => {
-    const instanceExportsDesc = Object.getOwnPropertyDescriptor(exportingInstance, 'exports');
-    assert_equals(typeof instanceExportsDesc.value, "object");
-    assert_equals(instanceExportsDesc.writable, true);
-    assert_equals(instanceExportsDesc.enumerable, true);
-    assert_equals(instanceExportsDesc.configurable, true);
-}, "'WebAssembly.Instance' 'exports' data property");
+    const exportsDesc = Object.getOwnPropertyDescriptor(instanceProto, 'exports');
+    assert_equals(typeof exportsDesc.get, "function");
+    assert_equals(exportsDesc.set, undefined);
+    assert_equals(exportsDesc.enumerable, false);
+    assert_equals(exportsDesc.configurable, true);
+    const exportsGetter = exportsDesc.get;
+    assertThrows(() => exportsGetter.call(), TypeError);
+    assertThrows(() => exportsGetter.call({}), TypeError);
+    assert_equals(typeof exportsGetter.call(exportingInstance), "object");
+}, "'WebAssembly.Instance.prototype.exports' accessor property");
 
 test(() => {
     exportsObj = exportingInstance.exports;
@@ -385,7 +390,7 @@ test(() => {
     assert_equals(Object.getPrototypeOf(exportsObj), null);
     assertThrows(() => Object.defineProperty(exportsObj, 'g', {}), TypeError);
     assert_equals(Object.keys(exportsObj).join(), "f");
-}, "'WebAssembly.Instance' 'exports' object");
+}, "exports object");
 
 test(() => {
     const f = exportsObj.f;

From 8319a6199a515ac3262eee9a5fbc57948b799c96 Mon Sep 17 00:00:00 2001
From: Benjamin Bouvier <public@benj.me>
Date: Mon, 29 May 2017 14:53:02 +0200
Subject: [PATCH 022/329] Fixes #453: Automatically recompile the spec
 interpreter before generating the tests; (#486)

---
 test/build.py | 33 ++++++++++++++++++++++++++-------
 1 file changed, 26 insertions(+), 7 deletions(-)

diff --git a/test/build.py b/test/build.py
index e2b81c161..2448f2e37 100755
--- a/test/build.py
+++ b/test/build.py
@@ -9,7 +9,8 @@
 import multiprocessing as mp
 
 SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
-WASM_EXEC = os.path.join(SCRIPT_DIR, '..', 'interpreter', 'wasm')
+INTERPRETER_DIR = os.path.join(SCRIPT_DIR, '..', 'interpreter')
+WASM_EXEC = os.path.join(INTERPRETER_DIR, 'wasm')
 
 WAST_TESTS_DIR = os.path.join(SCRIPT_DIR, 'core')
 JS_TESTS_DIR = os.path.join(SCRIPT_DIR, 'js-api')
@@ -35,6 +36,14 @@ def ensure_empty_dir(path):
     ensure_remove_dir(path)
     os.mkdir(path)
 
+def compile_wasm_interpreter():
+    print("Recompiling the wasm interpreter...")
+    result = run('make', '-C', INTERPRETER_DIR)
+    if result.returncode != 0:
+        print("Couldn't recompile wasm spec interpreter")
+        sys.exit(1)
+    print("Done!")
+
 def ensure_wasm_executable(path_to_wasm):
     """
     Ensure we have built the wasm spec interpreter.
@@ -44,7 +53,6 @@ def ensure_wasm_executable(path_to_wasm):
         print('Unable to run the wasm executable')
         sys.exit(1)
 
-
 # JS harness.
 def convert_one_wast_file(inputs):
     wast_file, js_file = inputs
@@ -208,21 +216,32 @@ def process_args():
                         help="Relative path to the output directory for the front page.",
                         type=str)
 
-    return parser.parse_args()
+    parser.add_argument('--dont-recompile',
+                        action="store_const",
+                        dest="compile",
+                        help="Don't recompile the wasm spec interpreter (by default, it is)",
+                        const=False,
+                        default=True)
+
+    return parser.parse_args(), parser
 
 if __name__ == '__main__':
-    args = process_args()
+    args, parser = process_args()
 
     js_dir = args.js_dir
     html_dir = args.html_dir
     front_dir = args.front_dir
 
-    ensure_wasm_executable(WASM_EXEC)
-
     if front_dir is None and js_dir is None and html_dir is None:
-        print('At least one mode must be selected.')
+        print('At least one mode must be selected.\n')
+        parser.print_help()
         sys.exit(1)
 
+    if args.compile:
+        compile_wasm_interpreter()
+
+    ensure_wasm_executable(WASM_EXEC)
+
     if js_dir is not None:
         ensure_empty_dir(js_dir)
         build_js(js_dir)

From c4774b47d326e4114f96232f1389a555639d7348 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 1 Jun 2017 11:58:07 +0200
Subject: [PATCH 023/329] [spec/interpreter] Specify text format and adapt
 interpreter (#471)

This change specifies the text format, based on earlier discussion between @binji, @lukewagner, @sunfishcode, and myself. It also adapts the interpreter to the changes listed below.

The changes relative to the .wast format previously implemented in the interpreter and other tools are the following.

Removals:

- some of the more baroque forms of sugar for `if`
- binary module bodies
- anything script related (assertions, invokes, etc)
- `infinity` as a secondary spelling for float `inf`

Additions:

- \u{...} escapes in strings (see below)
- more than just one inline export (that is, you can write (func $f (export "f1") (export "f2") ...), closing a gap in the syntax), and it combines with import
- the toplevel (module ...) is optional

Changes:

One breaking change makes the syntax forward compatible with some of the future extensions that have been discussed:

- non-empty block signatures must now be written (result i32), in order to generalise cleanly to function signatures

Unicode:

- the lexical syntax is defined in terms of Unicode characters (i.e., code points)
- comments and strings may contain mostly arbitrary Unicode, the rest stays within ASCII
- in strings, a Unicode character denotes its UTF-8 encoding
- in strings, Unicode characters can be given explicitly with \u{...} notation
- .wat files are assumed to be encoded in UTF-8

Misc Remarks:

- formatting characters: currently only the minimum set of formatting characters are allowed as white space (\t, \n, \r); we could include more, e.g. the whole set of ASCII "format effectors" (\b, \v, \f), but you quickly get into a lot of Unicode complexity if you want to go further than that

- Unicode in comments: similarly, in order to avoid getting into Unicode specifics, any legal code point is currently allowed in comments; should we be more restrictive?

- binary module bodies: they would seem pretty unusual for a "text" format, so are not included for now.

- abbreviations: to avoid combinatorial complexity in defining the AST to map on, most syntactic sugar is specified in the form of "abbreviations", simple rewritings into the core syntax

- inline function signatures: I tried to come up with a decent way to describe their rewriting into type indices (and the potential insertion of new type definitions) in terms of rules, but ultimately gave up; it's too cumbersome to express succinctly; so this is the one part that is left partially informal (though hopefully still unambiguous)

- formatting: many of the rules do not currently fit the page width; I left them as is for now, and plan to clean up layout issues once the spec is complete, probably tweaking some layout parameters as well

- tests: lots of stuff we could write tests for, e.g. regarding the Unicode support...
---
 document/.gitignore                          |    1 +
 document/appendix-textual/index.rst          |    8 -
 document/binary/conventions.rst              |    4 +-
 document/binary/instructions.rst             |   34 +-
 document/binary/modules.rst                  |   28 +-
 document/binary/types.rst                    |   16 +-
 document/binary/values.rst                   |   37 +-
 document/execution/instructions.rst          |    4 +-
 document/execution/runtime.rst               |    2 +-
 document/index.rst                           |    2 +-
 document/math.def                            |  180 ++-
 document/syntax/conventions.rst              |    9 +
 document/syntax/instructions.rst             |   19 +-
 document/syntax/modules.rst                  |    1 +
 document/syntax/values.rst                   |   26 +-
 document/text/conventions.rst                |  140 +++
 document/text/index.rst                      |   14 +
 document/text/instructions.rst               |  504 +++++++++
 document/text/lexical.rst                    |  111 ++
 document/text/modules.rst                    |  598 ++++++++++
 document/text/types.rst                      |  143 +++
 document/text/values.rst                     |  259 +++++
 document/validation/conventions.rst          |    2 +-
 document/validation/modules.rst              |    1 +
 interpreter/Makefile                         |   33 +-
 interpreter/README.md                        |   53 +-
 interpreter/host/import.ml                   |    4 +-
 interpreter/host/js.ml                       |   21 +-
 interpreter/host/run.ml                      |   66 +-
 interpreter/spec/ast.ml                      |   14 +
 interpreter/spec/float.ml                    |    1 -
 interpreter/text/arrange.ml                  |   21 +-
 interpreter/text/lexer.mll                   |   86 +-
 interpreter/text/parse.ml                    |    4 +-
 interpreter/text/parse.mli                   |    2 +-
 interpreter/text/parser.mly                  |  349 +++---
 interpreter/util/lib.ml                      |    2 +-
 test/core/block.wast                         |  114 +-
 test/core/br.wast                            |  149 ++-
 test/core/br_if.wast                         |   76 +-
 test/core/br_table.wast                      |  178 +--
 test/core/call.wast                          |   47 +-
 test/core/call_indirect.wast                 |   62 +-
 test/core/comments.wast                      |  Bin 652 -> 701 bytes
 test/core/conversions.wast                   |   60 +-
 test/core/exports.wast                       |    2 +
 test/core/f32.wast                           | 1068 +++++++++---------
 test/core/f32_bitwise.wast                   |  144 +--
 test/core/f32_cmp.wast                       |  912 +++++++--------
 test/core/f64.wast                           | 1068 +++++++++---------
 test/core/f64_bitwise.wast                   |  144 +--
 test/core/f64_cmp.wast                       |  912 +++++++--------
 test/core/fac.wast                           |   28 +-
 test/core/float_exprs.wast                   |  194 ++--
 test/core/float_literals.wast                |   12 +-
 test/core/float_misc.wast                    |   30 +-
 test/core/forward.wast                       |   12 +-
 test/core/func.wast                          |   10 +-
 test/core/if.wast                            |   88 +-
 test/core/imports.wast                       |    6 +
 test/core/inline-module.wast                 |    1 +
 test/core/labels.wast                        |   73 +-
 test/core/left-to-right.wast                 |    6 +-
 test/core/loop.wast                          |  108 +-
 test/core/memory.wast                        |   10 +-
 test/core/nop.wast                           |   40 +-
 test/core/return.wast                        |   30 +-
 test/core/stack.wast                         |    4 +-
 test/core/switch.wast                        |   10 +-
 test/core/token-keyword-separation.fail.wast |    1 +
 test/core/token-number-separation.fail.wast  |    1 +
 test/core/typecheck.wast                     |   24 +-
 test/core/unreachable.wast                   |   46 +-
 test/core/unreached-invalid.wast             |   52 +-
 test/core/unwind.wast                        |   54 +-
 75 files changed, 5443 insertions(+), 3132 deletions(-)
 delete mode 100644 document/appendix-textual/index.rst
 create mode 100644 document/text/conventions.rst
 create mode 100644 document/text/index.rst
 create mode 100644 document/text/instructions.rst
 create mode 100644 document/text/lexical.rst
 create mode 100644 document/text/modules.rst
 create mode 100644 document/text/types.rst
 create mode 100644 document/text/values.rst
 create mode 100644 test/core/inline-module.wast
 create mode 100644 test/core/token-keyword-separation.fail.wast
 create mode 100644 test/core/token-number-separation.fail.wast

diff --git a/document/.gitignore b/document/.gitignore
index 09f98591a..b932ec283 100644
--- a/document/.gitignore
+++ b/document/.gitignore
@@ -1,2 +1,3 @@
 _build
 _static
+document/*.pyc
diff --git a/document/appendix-textual/index.rst b/document/appendix-textual/index.rst
deleted file mode 100644
index e7ea647eb..000000000
--- a/document/appendix-textual/index.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-.. text-format:
-
-Appendix: Text Format
----------------------
-
-.. todo::
-
-   Describe
diff --git a/document/binary/conventions.rst b/document/binary/conventions.rst
index c48bc8484..32f951206 100644
--- a/document/binary/conventions.rst
+++ b/document/binary/conventions.rst
@@ -44,10 +44,10 @@ In order to distinguish symbols of the binary syntax from symbols of the abstrac
 * :math:`B^n` is a sequence of :math:`n\geq 0` iterations  of :math:`B`.
 
 * :math:`B^\ast` is a possibly empty sequence of iterations of :math:`B`.
-  (This is a shorthand for :math:`A^n` used where :math:`n` is not relevant.)
+  (This is a shorthand for :math:`B^n` used where :math:`n` is not relevant.)
 
 * :math:`B^?` is an optional occurrence of :math:`B`.
-  (This is a shorthand for :math:`A^n` where :math:`n \leq 1`.)
+  (This is a shorthand for :math:`B^n` where :math:`n \leq 1`.)
 
 * :math:`x{:}B` denotes the same language as the nonterminal :math:`B`, but also binds the variable :math:`x` to the attribute synthesized for :math:`B`.
 
diff --git a/document/binary/instructions.rst b/document/binary/instructions.rst
index fb64b6634..a1e0fd328 100644
--- a/document/binary/instructions.rst
+++ b/document/binary/instructions.rst
@@ -16,24 +16,23 @@ The only exception are :ref:`structured control instructions <binary-instr-contr
 .. _binary-instr-control:
 .. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, polymorphism
    pair: binary format; instruction
-   single: abstract syntax; instruction
 
 Control Instructions
 ~~~~~~~~~~~~~~~~~~~~
 
 :ref:`Control instructions <syntax-instr-control>` have varying encodings. For structured instructions, the nested instruction sequences are terminated with explicit opcodes for |END| and |ELSE|.
 
-.. _valid-nop:
-.. _valid-unreachable:
-.. _valid-block:
-.. _valid-loop:
-.. _valid-if:
-.. _valid-br:
-.. _valid-br_if:
-.. _valid-br_table:
-.. _valid-return:
-.. _valid-call:
-.. _valid-call_indirect:
+.. _binary-nop:
+.. _binary-unreachable:
+.. _binary-block:
+.. _binary-loop:
+.. _binary-if:
+.. _binary-br:
+.. _binary-br_if:
+.. _binary-br_table:
+.. _binary-return:
+.. _binary-call:
+.. _binary-call_indirect:
 
 .. math::
    \begin{array}{llclll}
@@ -51,8 +50,8 @@ Control Instructions
        &\Rightarrow& \IF~\X{rt}~\X{in}_1^\ast~\ELSE~\X{in}_2^\ast~\END \\ &&|&
      \hex{0C}~~l{:}\Blabelidx &\Rightarrow& \BR~l \\ &&|&
      \hex{0D}~~l{:}\Blabelidx &\Rightarrow& \BRIF~l \\ &&|&
-     \hex{0E}~~l^\ast{:}\Bvec(\Blabelidx)~~l_N{:}\Blabelidx &\Rightarrow&
-       \BRTABLE~l^\ast~l_N \\ &&|&
+     \hex{0E}~~l^\ast{:}\Bvec(\Blabelidx)~~l_N{:}\Blabelidx
+       &\Rightarrow& \BRTABLE~l^\ast~l_N \\ &&|&
      \hex{0F} &\Rightarrow& \RETURN \\ &&|&
      \hex{10}~~x{:}\Bfuncidx &\Rightarrow& \CALL~x \\ &&|&
      \hex{11}~~x{:}\Btypeidx &\Rightarrow& \CALLINDIRECT~x \\
@@ -65,7 +64,6 @@ Control Instructions
 .. _binary-instr-parametric:
 .. index:: value type, polymorphism
    pair: binary format; instruction
-   single: abstract syntax; instruction
 
 Parametric Instructions
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -86,7 +84,6 @@ Parametric Instructions
 .. _binary-instr-variable:
 .. index:: variable instructions, local index, global index
    pair: binary format; instruction
-   single: abstract syntax; instruction
 
 Variable Instructions
 ~~~~~~~~~~~~~~~~~~~~~
@@ -113,8 +110,7 @@ Variable Instructions
 .. _binary-instr-memory:
 .. _binary-memarg:
 .. index:: memory instruction, memory index
-   pair: validation; instruction
-   single: abstract syntax; instruction
+   pair: binary format; instruction
 
 Memory Instructions
 ~~~~~~~~~~~~~~~~~~~
@@ -168,7 +164,6 @@ Each variant of :ref:`memory instruction <syntax-instr-memory>` is encoded with
 .. _binary-instr-numeric:
 .. index:: numeric instruction
    pair: binary format; instruction
-   single: abstract syntax; instruction
 
 Numeric Instructions
 ~~~~~~~~~~~~~~~~~~~~
@@ -370,7 +365,6 @@ All other numeric instructions are plain opcodes without any immediates.
 .. _binary-expr:
 .. index:: expression
    pair: binary format; expression
-   single: abstract syntax; expression
    single: expression; constant
 
 Expressions
diff --git a/document/binary/modules.rst b/document/binary/modules.rst
index bd20c8be7..ebcfcbf2d 100644
--- a/document/binary/modules.rst
+++ b/document/binary/modules.rst
@@ -17,7 +17,7 @@ except that :ref:`function definitions <syntax-func>` are split into two section
 .. _binary-globalidx:
 .. _binary-localidx:
 .. _binary-labelidx:
-.. index:: index, index space, type index, function index, table index, memory index, global index, local index, label index
+.. index:: index, type index, function index, table index, memory index, global index, local index, label index
    pair: binary format; type index
    pair: binary format; function index
    pair: binary format; table index
@@ -25,13 +25,6 @@ except that :ref:`function definitions <syntax-func>` are split into two section
    pair: binary format; global index
    pair: binary format; local index
    pair: binary format; label index
-   single: abstract syntax; type index
-   single: abstract syntax; function index
-   single: abstract syntax; table index
-   single: abstract syntax; memory index
-   single: abstract syntax; global index
-   single: abstract syntax; local index
-   single: abstract syntax; label index
 
 Indices
 ~~~~~~~
@@ -112,7 +105,6 @@ Their contents consist of a :ref:`name <syntax-name>` further identifying the cu
 .. _binary-type:
 .. index:: ! type section, type definition
    pair: binary format; type section
-   single: abstract syntax; type definition
    pair: section; type
 
 Type Section
@@ -132,7 +124,6 @@ It decodes into a vector of :ref:`function types <syntax-functype>` that represe
 .. _binary-import:
 .. index:: ! import section, import, name, function type, table type, memory type, global type
    pair: binary format; import
-   single: abstract syntax; import
    pair: section; import
 
 Import Section
@@ -160,7 +151,6 @@ It decodes into a vector of :ref:`imports <syntax-import>` that represent the |I
 .. _binary-func:
 .. index:: ! function section, function, type index, function type
    pair: binary format; function
-   single: abstract syntax; function
    pair: section; function
 
 Function Section
@@ -181,7 +171,6 @@ The |LOCALS| and |BODY| fields of the respective functions are encoded separatel
 .. _binary-table:
 .. index:: ! table section, table, table type
    pair: binary format; table
-   single: abstract syntax; table
    pair: section; table
 
 Table Section
@@ -203,7 +192,6 @@ It decodes into a vector of :ref:`tables <syntax-table>` that represent the |TAB
 .. _binary-mem:
 .. index:: ! memory section, memory, memory type
    pair: binary format; memory
-   single: abstract syntax; memory
    pair: section; memory
 
 Memory Section
@@ -225,7 +213,6 @@ It decodes into a vector of :ref:`memories <syntax-mem>` that represent the |MEM
 .. _binary-global:
 .. index:: ! global section, global, global type, expression
    pair: binary format; global
-   single: abstract syntax; global
    pair: section; global
 
 Global Section
@@ -248,7 +235,6 @@ It decodes into a vector of :ref:`globals <syntax-global>` that represent the |G
 .. _binary-export:
 .. index:: ! export section, export, name, index, function index, table index, memory index, global index
    pair: binary format; export
-   single: abstract syntax; export
    pair: section; export
 
 Export Section
@@ -276,7 +262,6 @@ It decodes into a vector of :ref:`exports <syntax-export>` that represent the |E
 .. _binary-start:
 .. index:: ! start section, start function, function index
    pair: binary format; start function
-   single: abstract syntax; start function
    single: section; start
    single: start function; section
 
@@ -299,7 +284,6 @@ It decodes into an optional :ref:`start function <syntax-start>` that represents
 .. _binary-elem:
 .. index:: ! element section, element, table index, expression, function index
    pair: binary format; element
-   single: abstract syntax; element
    pair: section; element
    single: table; element
    single: element; segment
@@ -324,7 +308,7 @@ It decodes into a vector of :ref:`element segments <syntax-elem>` that represent
 .. _binary-local:
 .. index:: ! code section, function, local, type index, function type
    pair: binary format; function
-   single: abstract syntax; function
+   pair: binary format; local
    pair: section; code
 
 Code Section
@@ -360,14 +344,14 @@ denoting *count* locals of the same value type.
        &\Rightarrow& \X{code} & (\X{size} = ||\Bfunc||) \\
    \production{function} & \Bfunc &::=&
      (t^\ast)^\ast{:}\Bvec(\Blocals)~~e{:}\Bexpr
-       &\Rightarrow& \F{concat}((t^\ast)^\ast), e^\ast
-         & (|\F{concat}((t^\ast)^\ast)| < 2^{32}) \\
+       &\Rightarrow& \concat((t^\ast)^\ast), e^\ast
+         & (|\concat((t^\ast)^\ast)| < 2^{32}) \\
    \production{locals} & \Blocals &::=&
      n{:}\Bu32~~t{:}\Bvaltype &\Rightarrow& t^n \\
    \end{array}
 
 Here, :math:`\X{code}` ranges over pairs :math:`(\valtype^\ast, \expr)`.
-The meta function :math:`\F{concat}((t^\ast)^\ast)` denotes the sequence of types formed by concatenating all sequences :math:`t_i^\ast` in :math:`(t^\ast)^\ast`.
+The meta function :math:`\F{concat}((t^\ast)^\ast)` concatenates all sequences :math:`t_i^\ast` in :math:`(t^\ast)^\ast`.
 Any code for which the length of the resulting sequence is out of bounds of the maximum size of a :ref:`vector <syntax-vec>` is malformed.
 
 .. note::
@@ -379,7 +363,6 @@ Any code for which the length of the resulting sequence is out of bounds of the
 .. _binary-data:
 .. index:: ! data section, data, memory, memory index, expression, byte
    pair: binary format; data
-   single: abstract syntax; data
    pair: section; data
    single: memory; data
    single: data; segment
@@ -405,7 +388,6 @@ It decodes into a vector of :ref:`data segments <syntax-data>` that represent th
 .. _binary-version:
 .. index:: module, section, type definition, function type, function, table, memory, global, element, data, start function, import, export, context, version
    pair: binary format; module
-   single: abstract syntax; module
 
 Modules
 ~~~~~~~
diff --git a/document/binary/types.rst b/document/binary/types.rst
index fde083402..e4b646ef5 100644
--- a/document/binary/types.rst
+++ b/document/binary/types.rst
@@ -1,7 +1,6 @@
 .. _binary-type:
 .. index:: type
    pair: binary format; type
-   single: abstract syntax; type
 
 Types
 -----
@@ -9,7 +8,6 @@ Types
 .. _binary-valtype:
 .. index:: value type
    pair: binary format; value type
-   single: abstract syntax; value type
 
 Value Types
 ~~~~~~~~~~~
@@ -34,7 +32,6 @@ Value Types
 .. _binary-blocktype:
 .. index:: result type, value type
    pair: binary format; result type
-   single: abstract syntax; result type
 
 Result Types
 ~~~~~~~~~~~~
@@ -55,7 +52,6 @@ The only :ref:`result types <syntax-resulttype>` occurring in the binary format
 .. _binary-functype:
 .. index:: function type, value type, result type
    pair: binary format; function type
-   single: abstract syntax; function type
 
 Function Types
 ~~~~~~~~~~~~~~
@@ -73,7 +69,6 @@ Function Types
 .. _binary-limits:
 .. index:: limits
    pair: binary format; limits
-   single: abstract syntax; limits
 
 Limits
 ~~~~~~
@@ -90,8 +85,7 @@ Limits
 
 .. _binary-memtype:
 .. index:: memory type, limits, page size
-   single: binary format; memory type
-   pair: abstract syntax; memory type
+   pair: binary format; memory type
 
 Memory Types
 ~~~~~~~~~~~~
@@ -105,13 +99,11 @@ Memory Types
    \end{array}
 
 
-.. _syntax-tabletype:
-.. _syntax-elemtype:
+.. _binary-tabletype:
+.. _binary-elemtype:
 .. index:: table type, element type, limits
    pair: binary format; table type
    pair: binary format; element type
-   single: abstract syntax; table type
-   single: abstract syntax; element type
 
 Table Types
 ~~~~~~~~~~~
@@ -131,8 +123,6 @@ Table Types
 .. index:: global type, mutability, value type
    pair: binary format; global type
    pair: binary format; mutability
-   single: abstract syntax; global type
-   single: abstract syntax; mutability
 
 Global Types
 ~~~~~~~~~~~~
diff --git a/document/binary/values.rst b/document/binary/values.rst
index 8a4366501..9f530c0e3 100644
--- a/document/binary/values.rst
+++ b/document/binary/values.rst
@@ -1,7 +1,6 @@
 .. _binary-value:
 .. index:: value
-   binary: binary format; value
-   single: abstract syntax; value
+   pair: binary format; value
 
 Values
 ------
@@ -9,13 +8,12 @@ Values
 
 .. _binary-byte:
 .. index:: byte
-   pair: binary encoding; byte
-   single: abstract syntax; byte
+   pair: binary format; byte
 
 Bytes
 ~~~~~
 
-:ref:`Bytes <syntax-int>` encode themselves.
+:ref:`Bytes <syntax-byte>` encode themselves.
 
 .. math::
    \begin{array}{llcll@{\qquad}l}
@@ -29,15 +27,11 @@ Bytes
 .. _binary-int:
 .. _binary-sint:
 .. _binary-uint:
-.. index:: integer, unsigned integer, signed integer, uninterpreted integer
+.. index:: integer, unsigned integer, signed integer, uninterpreted integer, LEB128
    pair: binary format; integer
    pair: binary format; unsigned integer
    pair: binary format; signed integer
    pair: binary format; uninterpreted integer
-   single: abstract syntax; integer
-   single: abstract syntax; unsigned integer
-   single: abstract syntax; signed integer
-   single: abstract syntax; uninterpreted integer
 
 Integers
 ~~~~~~~~
@@ -45,22 +39,22 @@ Integers
 All :ref:`integers <syntax-int>` are encoded using the `LEB128 <https://en.wikipedia.org/wiki/LEB128>`_ variable-length integer encoding, in either unsigned or signed variant.
 
 :ref:`Unsigned integers <syntax-uint>` are encoded in `unsigned LEB128 <https://en.wikipedia.org/wiki/LEB128#Unsigned_LEB128>`_ format.
-As an additional constraint, the total number of bytes encoding a value of type :math:`\uX{N}` must not exceed :math:`\F{ceil}(N/7)` bytes.
+As an additional constraint, the total number of bytes encoding a value of type :math:`\uN` must not exceed :math:`\F{ceil}(N/7)` bytes.
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
-   \production{unsigned integer} & \BuX{N} &::=&
+   \production{unsigned integer} & \BuN &::=&
      n{:}\Bbyte &\Rightarrow& n & (n < 2^7 \wedge n < 2^N) \\ &&|&
      n{:}\Bbyte~~m{:}\BuX{(N\B{-7})} &\Rightarrow&
        2^7\cdot m + (n-2^7) & (n \geq 2^7 \wedge N > 7) \\
    \end{array}
 
 :ref:`Signed integers <syntax-sint>` are encoded in `signed LEB128 <https://en.wikipedia.org/wiki/LEB128#Signed_LEB128>`_ format, which uses a 2's complement representation.
-As an additional constraint, the total number of bytes encoding a value of type :math:`\sX{N}` must not exceed :math:`\F{ceil}(N/7)` bytes.
+As an additional constraint, the total number of bytes encoding a value of type :math:`\sN` must not exceed :math:`\F{ceil}(N/7)` bytes.
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
-   \production{signed integer} & \BsX{N} &::=&
+   \production{signed integer} & \BsN &::=&
      n{:}\Bbyte &\Rightarrow& n & (n < 2^6 \wedge n < 2^{N-1}) \\ &&|&
      n{:}\Bbyte &\Rightarrow& n-2^7 & (2^6 \leq n < 2^7 \wedge n \geq 2^7-2^{N-1}) \\ &&|&
      n{:}\Bbyte~~m{:}\BsX{(N\B{-7})} &\Rightarrow&
@@ -71,8 +65,8 @@ As an additional constraint, the total number of bytes encoding a value of type
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{uninterpreted integer} & \BiX{N} &::=&
-     n{:}\BsX{N} &\Rightarrow& i & (n = \signed_{\iX{N}}(i))
+   \production{uninterpreted integer} & \BiN &::=&
+     n{:}\BsN &\Rightarrow& i & (n = \signed_{\iN}(i))
    \end{array}
 
 .. note::
@@ -90,16 +84,15 @@ As an additional constraint, the total number of bytes encoding a value of type
 .. _binary-float:
 .. index:: floating-point number
    pair: binary format; floating-point number
-   single: abstract syntax; floating-point number
 
 Floating-Point
 ~~~~~~~~~~~~~~
 
-:ref:`Floating point <syntax-float>` values are encoded directly by their IEEE bit pattern in `little endian <https://en.wikipedia.org/wiki/Endianness#Little-endian>`_ byte order:
+:ref:`Floating point <syntax-float>` values are encoded directly by their `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ bit pattern in `little endian <https://en.wikipedia.org/wiki/Endianness#Little-endian>`_ byte order:
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{floating-point number} & \BfX{N} &::=&
+   \production{floating-point number} & \BfN &::=&
      b^\ast{:\,}\Bbyte^{N/8} &\Rightarrow& \F{reverse}(b^\ast) \\
    \end{array}
 
@@ -109,7 +102,6 @@ Here, :math:`\F{reverse}(b^\ast)` denotes the byte sequence :math:`b^\ast` in re
 .. _binary-vec:
 .. index:: vector
    pair: binary format; vector
-   single: abstract syntax; vector
 
 Vectors
 ~~~~~~~
@@ -124,14 +116,13 @@ Vectors
 
 
 .. _binary-name:
-.. index:: name, byte
+.. index:: name, byte, Unicode, UTF-8
    pair: binary format; name
-   single: abstract syntax; name
 
 Names
 ~~~~~
 
-:ref:`Names <syntax-name>` are encoded like a :ref:`vector <binary-vector>` of bytes containing the `UTF-8 <http://www.unicode.org/versions/latest/>`_ encoding of the name's code point sequence.
+:ref:`Names <syntax-name>` are encoded like a :ref:`vector <binary-vec>` of bytes containing the `Unicode <http://www.unicode.org/versions/latest/>`_ UTF-8 encoding of the name's code point sequence.
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
diff --git a/document/execution/instructions.rst b/document/execution/instructions.rst
index ceb257a93..fc977d44e 100644
--- a/document/execution/instructions.rst
+++ b/document/execution/instructions.rst
@@ -918,7 +918,7 @@ Entering :math:`\instr^\ast` with label :math:`L`
 
 1. Push :math:`L` to the stack.
 
-2. :ref:`Jump <exec-jump>` to the start of the instruction sequence :math:`\instr^\ast`.
+2. Jump to the start of the instruction sequence :math:`\instr^\ast`.
 
 .. note::
    No formal reduction rule is needed for entering an instruction sequence,
@@ -973,7 +973,7 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 
 1. Assert: due to :ref:`validation <valid-call>`, :math:`S.\FUNCS[a]` exists.
 
-2. Let :math:`f` be the :ref:`function instance <sytnax-funcinst>`, :math:`S.\FUNCS[a]`.
+2. Let :math:`f` be the :ref:`function instance <syntax-funcinst>`, :math:`S.\FUNCS[a]`.
 
 3. Assert: due to :ref:`validation <valid-func>`, :math:`f.\MODULE.\TYPES[f.\CODE.\TYPE]` exists.
 
diff --git a/document/execution/runtime.rst b/document/execution/runtime.rst
index 028865b42..a7e6ead04 100644
--- a/document/execution/runtime.rst
+++ b/document/execution/runtime.rst
@@ -407,7 +407,7 @@ and a reference to the function's own :ref:`module instance <syntax-moduleinst>`
      \{ \LOCALS~\val^\ast, \MODULE~\moduleinst\} \\
    \end{array}
 
-The values of the locals are mutated by respective :ref:`variable instructions <syntax-instr-var>`.
+The values of the locals are mutated by respective :ref:`variable instructions <syntax-instr-variable>`.
 
 
 Conventions
diff --git a/document/index.rst b/document/index.rst
index 417975647..6b29eefc1 100644
--- a/document/index.rst
+++ b/document/index.rst
@@ -13,9 +13,9 @@ WebAssembly Specification
    validation/index
    execution/index
    binary/index
+   text/index
    appendix-properties/index
    appendix-algorithm/index
-   appendix-textual/index
    appendix-names/index
 
 .. only:: latex
diff --git a/document/math.def b/document/math.def
index 6d970bc71..bbde450ac 100644
--- a/document/math.def
+++ b/document/math.def
@@ -10,17 +10,55 @@
 .. F - functions
 .. K - keywords / terminals
 .. B - binary grammar non-terminals
+.. T - textual grammar non-terminals
 
 .. |X| mathdef:: \mathit
 .. |F| mathdef:: \mathrm
 .. |K| mathdef:: \mathsf
 .. |B| mathdef:: \mathtt
+.. |T| mathdef:: \mathtt
 
 
 .. Auxiliary definitions for grammars
 
 .. |production| mathdef:: \void
-.. |with| mathdef:: ~\xref{syntax/conventions}{syntax-record}{\mbox{with}}~
+.. |concat| mathdef:: \xref{syntax/conventions}{syntax-concat}{\F{concat}}
+.. |with| mathdef:: \xref{syntax/conventions}{syntax-record}{\mathrel{\mbox{with}}}
+.. |compose| mathdef:: \xref{syntax/conventions}{syntax-record}{\oplus}
+.. |bigcompose| mathdef:: \xref{syntax/conventions}{syntax-record}{\bigoplus}
+
+
+.. Lexical grammar, terminals
+
+.. |textl| mathdef:: \mbox{‘}
+.. |textr| mathdef:: \mbox{’}
+.. |text#1| mathdef:: \textl\mathtt{#1}\textr
+
+.. |Tcommentl| mathdef:: \text{{(}{;}}
+.. |Tcommentr| mathdef:: \text{{;}{)}}
+.. |Tcommentd| mathdef:: \text{{;}{;}}
+
+
+.. Lexical grammar, non-terminals
+
+.. |Tchar| mathdef:: \xref{text/lexical}{text-char}{\T{char}}
+.. |Tspace| mathdef:: \xref{text/lexical}{text-space}{\T{space}}
+.. |Tformat| mathdef:: \xref{text/lexical}{text-format}{\T{format}}
+
+.. |Ttoken| mathdef:: \xref{text/lexical}{text-token}{\T{token}}
+.. |Tkeyword| mathdef:: \xref{text/lexical}{text-keyword}{\T{keyword}}
+.. |Treserved| mathdef:: \xref{text/lexical}{text-reserved}{\T{reserved}}
+
+.. |Tcomment| mathdef:: \xref{text/lexical}{text-comment}{\T{comment}}
+.. |Tlinecomment| mathdef:: \xref{text/lexical}{text-comment}{\T{linecomment}}
+.. |Tblockcomment| mathdef:: \xref{text/lexical}{text-comment}{\T{blockcomment}}
+.. |Tlinechar| mathdef:: \xref{text/lexical}{text-comment}{\T{linechar}}
+.. |Tblockchar| mathdef:: \xref{text/lexical}{text-comment}{\T{blockchar}}
+
+
+.. Lexical grammar, meta functions
+
+.. |utf8| mathdef:: \xref{syntax/values}{syntax-utf8}{\F{utf8}}
 
 
 .. Values, terminals
@@ -99,6 +137,57 @@
 .. |Bcodecont| mathdef:: \xref{binary/values}{binary-name}{\B{cont}}
 
 
+.. Values, textual non-terminals
+
+.. |Tbyte| mathdef:: \xref{text/values}{text-byte}{\T{byte}}
+
+.. |Tsign| mathdef:: \xref{text/values}{text-sign}{\T{sign}}
+.. |Tdigit| mathdef:: \xref{text/values}{text-digit}{\T{digit}}
+.. |Thexdigit| mathdef:: \xref{text/values}{text-hexdigit}{\T{hexdigit}}
+.. |Tnum| mathdef:: \xref{text/values}{text-num}{\T{num}}
+.. |Thexnum| mathdef:: \xref{text/values}{text-hexnum}{\T{hexnum}}
+.. |Tfrac| mathdef:: \xref{text/values}{text-frac}{\T{frac}}
+.. |Thexfrac| mathdef:: \xref{text/values}{text-hexfrac}{\T{hexfrac}}
+.. |Tfloat| mathdef:: \xref{text/values}{text-float}{\T{float}}
+.. |Thexfloat| mathdef:: \xref{text/values}{text-hexfloat}{\T{hexfloat}}
+
+.. |TuX#1| mathdef:: {\T{u}#1}
+.. |TsX#1| mathdef:: {\T{s}#1}
+.. |TiX#1| mathdef:: {\T{i}#1}
+.. |TfX#1| mathdef:: {\T{f}#1}
+
+.. |TuN| mathdef:: \xref{text/values}{text-int}{\TuX{N}}
+.. |Tu1| mathdef:: \xref{text/values}{text-int}{\TuX{\T{1}}}
+.. |Tu8| mathdef:: \xref{text/values}{text-int}{\TuX{\T{8}}}
+.. |Tu16| mathdef:: \xref{text/values}{text-int}{\TuX{\T{16}}}
+.. |Tu32| mathdef:: \xref{text/values}{text-int}{\TuX{\T{32}}}
+.. |Tu64| mathdef:: \xref{text/values}{text-int}{\TuX{\T{64}}}
+
+.. |TsN| mathdef:: \xref{text/values}{text-int}{\TsX{N}}
+.. |Ts32| mathdef:: \xref{text/values}{text-int}{\TsX{\T{32}}}
+.. |Ts64| mathdef:: \xref{text/values}{text-int}{\TsX{\T{64}}}
+
+.. |TiN| mathdef:: \xref{text/values}{text-int}{\TiX{N}}
+.. |Ti32| mathdef:: \xref{text/values}{text-int}{\TiX{\T{32}}}
+.. |Ti64| mathdef:: \xref{text/values}{text-int}{\TiX{\T{64}}}
+
+.. |TfN| mathdef:: \xref{text/values}{text-float}{\TfX{N}}
+.. |Tf32| mathdef:: \xref{text/values}{text-float}{\TfX{\T{32}}}
+.. |Tf64| mathdef:: \xref{text/values}{text-float}{\TfX{\T{64}}}
+
+.. |Tvec| mathdef:: \xref{text/values}{text-vec}{\T{vec}}
+.. |Tstring| mathdef:: \xref{text/values}{text-string}{\T{string}}
+.. |Tstringelem| mathdef:: \xref{text/values}{text-string}{\T{stringelem}}
+.. |Tstringchar| mathdef:: \xref{text/values}{text-string}{\T{stringchar}}
+.. |Tname| mathdef:: \xref{text/values}{text-name}{\T{name}}
+.. |Tcodepoint| mathdef:: \xref{text/values}{text-name}{\T{codepoint}}
+.. |Tcodeval| mathdef:: \xref{text/values}{text-name}{\T{codeval}}
+.. |Tcodecont| mathdef:: \xref{text/values}{text-name}{\T{cont}}
+
+.. |Tid| mathdef:: \xref{text/values}{text-id}{\T{id}}
+.. |Tidchar| mathdef:: \xref{text/values}{text-id}{\T{idchar}}
+
+
 .. Types, terminals
 
 .. |I8| mathdef:: \xref{execution/runtime}{syntax-storagetype}{\K{i8}}
@@ -110,7 +199,7 @@
 
 .. |ANYFUNC| mathdef:: \xref{syntax/types}{syntax-elemtype}{\K{anyfunc}}
 .. |MVAR| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}}
-.. |MCONST| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}}
+.. |MCONST| mathdef:: \xref{syntax/types}{syntax-mut}{\K{const}}
 
 .. |MIN| mathdef:: \K{min}
 .. |MAX| mathdef:: \K{max}
@@ -143,6 +232,22 @@
 .. |Bmut| mathdef:: \xref{binary/types}{binary-mut}{\B{mut}}
 
 
+.. Types, textual non-terminals
+
+.. |Tvaltype| mathdef:: \xref{text/types}{text-valtype}{\T{valtype}}
+.. |Tresulttype| mathdef:: \xref{text/types}{text-resulttype}{\T{resulttype}}
+.. |Tblocktype| mathdef:: \xref{text/types}{text-blocktype}{\T{blocktype}}
+.. |Tfunctype| mathdef:: \xref{text/types}{text-functype}{\T{functype}}
+.. |Tglobaltype| mathdef:: \xref{text/types}{text-globaltype}{\T{globaltype}}
+.. |Ttabletype| mathdef:: \xref{text/types}{text-tabletype}{\T{tabletype}}
+.. |Telemtype| mathdef:: \xref{text/types}{text-elemtype}{\T{elemtype}}
+.. |Tmemtype| mathdef:: \xref{text/types}{text-memtype}{\T{memtype}}
+.. |Texterntype| mathdef:: \xref{text/types}{text-externtype}{\T{externtype}}
+.. |Tlimits| mathdef:: \xref{text/types}{text-limits}{\T{limits}}
+.. |Tparam| mathdef:: \xref{text/types}{text-functype}{\T{param}}
+.. |Tresult| mathdef:: \xref{text/types}{text-functype}{\T{result}}
+
+
 .. Indices
 
 .. |typeidx| mathdef:: \xref{syntax/modules}{syntax-typeidx}{\X{typeidx}}
@@ -161,6 +266,22 @@
 .. |Blocalidx| mathdef:: \xref{binary/modules}{binary-localidx}{\B{localidx}}
 .. |Blabelidx| mathdef:: \xref{binary/modules}{binary-labelidx}{\B{labelidx}}
 
+.. |Ttypeidx| mathdef:: \xref{text/modules}{text-typeidx}{\T{typeidx}}
+.. |Tfuncidx| mathdef:: \xref{text/modules}{text-funcidx}{\T{funcidx}}
+.. |Ttableidx| mathdef:: \xref{text/modules}{text-tableidx}{\T{tableidx}}
+.. |Tmemidx| mathdef:: \xref{text/modules}{text-memidx}{\T{memidx}}
+.. |Tglobalidx| mathdef:: \xref{text/modules}{text-globalidx}{\T{globalidx}}
+.. |Tlocalidx| mathdef:: \xref{text/modules}{text-localidx}{\T{localidx}}
+.. |Tlabelidx| mathdef:: \xref{text/modules}{text-labelidx}{\T{labelidx}}
+
+.. |Ttypebind| mathdef:: \xref{text/modules}{text-typebind}{\T{typebind}}
+.. |Tfuncbind| mathdef:: \xref{text/modules}{text-funcbind}{\T{funcbind}}
+.. |Ttablebind| mathdef:: \xref{text/modules}{text-tablebind}{\T{tablebind}}
+.. |Tmembind| mathdef:: \xref{text/modules}{text-membind}{\T{membind}}
+.. |Tglobalbind| mathdef:: \xref{text/modules}{text-globalbind}{\T{globalbind}}
+.. |Tlocalbind| mathdef:: \xref{text/modules}{text-localbind}{\T{localbind}}
+.. |Tlabelbind| mathdef:: \xref{text/modules}{text-labelbind}{\T{labelbind}}
+
 
 .. Modules, terminals
 
@@ -250,6 +371,30 @@
 .. |Bstart| mathdef:: \xref{binary/modules}{binary-start}{\B{start}}
 
 
+.. Modules, textual non-terminals
+
+.. |Tmodule| mathdef:: \xref{text/modules}{text-module}{\T{module}}
+.. |Tmodulebody| mathdef:: \xref{text/modules}{text-modulebody}{\T{modulebody}}
+.. |Tmodulefield| mathdef:: \xref{text/modules}{text-modulefield}{\T{modulefield}}
+.. |Ttype| mathdef:: \xref{text/modules}{text-type}{\T{type}}
+.. |Ttypeuse| mathdef:: \xref{text/modules}{text-typeuse}{\T{typeuse}}
+.. |Tfunc| mathdef:: \xref{text/modules}{text-func}{\T{func}}
+.. |Ttable| mathdef:: \xref{text/modules}{text-table}{\T{table}}
+.. |Tmem| mathdef:: \xref{text/modules}{text-mem}{\T{mem}}
+.. |Tglobal| mathdef:: \xref{text/modules}{text-global}{\T{global}}
+.. |Timport| mathdef:: \xref{text/modules}{text-import}{\T{import}}
+.. |Texport| mathdef:: \xref{text/modules}{text-export}{\T{export}}
+.. |Timportdesc| mathdef:: \xref{text/modules}{text-importdesc}{\T{importdesc}}
+.. |Texportdesc| mathdef:: \xref{text/modules}{text-exportdesc}{\T{exportdesc}}
+.. |Telem| mathdef:: \xref{text/modules}{text-elem}{\T{elem}}
+.. |Tcode| mathdef:: \xref{text/modules}{text-code}{\T{code}}
+.. |Tlocal| mathdef:: \xref{text/modules}{text-local}{\T{local}}
+.. |Tlocals| mathdef:: \xref{text/modules}{text-local}{\T{locals}}
+.. |Tdata| mathdef:: \xref{text/modules}{text-data}{\T{data}}
+.. |Tdatastring| mathdef:: \xref{text/modules}{text-datastring}{\T{datastring}}
+.. |Tstart| mathdef:: \xref{text/modules}{text-start}{\T{start}}
+
+
 .. Modules, meta functions
 
 .. |funcs| mathdef:: \xref{execution/runtime}{syntax-externtype}{\F{funcs}}
@@ -377,6 +522,31 @@
 .. |Bexpr| mathdef:: \xref{binary/instructions}{binary-expr}{\B{expr}}
 
 
+.. Instructions, textual non-terminals
+
+.. |Tmemarg| mathdef:: \xref{text/instructions}{text-memarg}{\T{memarg}}
+.. |Talign| mathdef:: \xref{text/instructions}{text-memarg}{\T{align}}
+.. |Toffset| mathdef:: \xref{text/instructions}{text-memarg}{\T{offset}}
+
+.. |Tlabel| mathdef:: \xref{text/instructions}{text-label}{\T{label}}
+.. |Tinstr| mathdef:: \xref{text/instructions}{text-instr}{\T{instr}}
+.. |Tplaininstr| mathdef:: \xref{text/instructions}{text-plaininstr}{\T{plaininstr}}
+.. |Tblockinstr| mathdef:: \xref{text/instructions}{text-blockinstr}{\T{blockinstr}}
+.. |Tfoldedinstr| mathdef:: \xref{text/instructions}{text-foldedinstr}{\T{foldedinstr}}
+.. |Texpr| mathdef:: \xref{text/instructions}{text-expr}{\T{expr}}
+
+
+.. Context, textual
+
+.. |TYPEDEFS| mathdef:: \K{typedefs}
+
+
+.. Contexts, meta functions
+
+.. |idfresh| mathdef:: ~\xref{text/values}{text-id-fresh}{\mbox{fresh}}
+.. |idcwellformed| mathdef:: ~\xref{text/conventions}{text-context-wf}{\mbox{well-formed}}
+
+
 .. Runtime, terminals
 
 .. |MUT| mathdef:: \K{mut}
@@ -422,3 +592,9 @@
 .. |signed| mathdef:: \xref{execution/numerics}{aux-signed}{\F{signed}}
 .. |extend| mathdef:: \xref{execution/numerics}{aux-extend}{\F{extend}}
 .. |wrap| mathdef:: \xref{execution/numerics}{aux-wrap}{\F{wrap}}
+
+.. todo...
+
+.. |ieee| mathdef:: \F{ieee}
+.. |ieeeinf| mathdef:: \F{ieeeinf}
+.. |ieeenan| mathdef:: \F{ieeenan}
diff --git a/document/syntax/conventions.rst b/document/syntax/conventions.rst
index 3f0c82b3b..f35dc11d4 100644
--- a/document/syntax/conventions.rst
+++ b/document/syntax/conventions.rst
@@ -58,6 +58,8 @@ When dealing with syntactic constructs the following notation is also used:
 * :math:`s \with [i:n] = A^n` denotes the same sequence as :math:`s`,
   except that the sub-sequence :math:`s[i:n]` is replaced with :math:`A^n`.
 
+* :math:`\concat(s^\ast)` denotes the flat sequence formed by concatenating all sequences :math:`s_i^\ast` in :math:`s^\ast`.
+
 Moreover, the following conventions are employed:
 
 * The notation :math:`x^n`, where :math:`x` is a non-terminal symbol, is treated as a meta variable ranging over respective sequences of :math:`x` (similarly for :math:`x^\ast`, :math:`x^+`, :math:`x^?`).
@@ -79,6 +81,13 @@ The following notation is adopted for manipulating such records:
 * :math:`r \with \K{field} = A` denotes the same record as :math:`r`,
   except that the value of the :math:`\K{field}` component is replaced with :math:`A`.
 
+* :math:`r_1 \compose r_2` denotes the composition of two records with the same fields of sequences by appending each sequence pointwise:
+
+  .. math::
+     \{ \K{field}_1\,A_1^\ast, \K{field}_2\,A_2^\ast, \dots \} \compose \{ \K{field}_1\,B_1^\ast, \K{field}_2\,B_2^\ast, \dots \} = \{ \K{field}_1\,A_1^\ast~B_1^\ast, \K{field}_2\,A_2^\ast~B_2^\ast, \dots \}
+
+* :math:`\bigcompose r^\ast` denotes the composition of a sequence of records, respectively; if the sequence is empty, then all fields of the resulting record are empty.
+
 The update notation for sequences and records generalizes recursively to nested components accessed by "paths" :math:`\X{pth} ::= ([\dots] \;| \;.\K{field})^+`:
 
 * :math:`s \with [i]\,\X{pth} = A` is short for :math:`s \with [i] = (s[i] \with \X{pth} = A)`.
diff --git a/document/syntax/instructions.rst b/document/syntax/instructions.rst
index 07bf174d8..afd5f694f 100644
--- a/document/syntax/instructions.rst
+++ b/document/syntax/instructions.rst
@@ -221,7 +221,7 @@ The |TEELOCAL| instruction is like |SETLOCAL| but also returns its argument.
 Memory Instructions
 ~~~~~~~~~~~~~~~~~~~
 
-Instructions in this group are concerned with :ref:`linear memory <sec-memory>`.
+Instructions in this group are concerned with :ref:`linear memory <syntax-mem>`.
 
 .. math::
    \begin{array}{llll}
@@ -264,11 +264,20 @@ Both instructions operate in units of :ref:`page size <page-size>`.
    all memory instructions implicitly operate on :ref:`memory <syntax-mem>` :ref:`index <syntax-memidx>` :math:`0`.
    This restriction may be lifted in future versions.
 
-The precise semantics of memory instructions is :ref:`described <exec-instr-memory>` in the :ref:`Instruction <sec-instruction>` section.
-
 
 .. _syntax-instr-control:
-.. _syntax-isntr-seq:
+.. _syntax-instr-seq:
+.. _syntax-nop:
+.. _syntax-unreachable:
+.. _syntax-block:
+.. _syntax-loop:
+.. _syntax-if:
+.. _syntax-br:
+.. _syntax-br_if:
+.. _syntax-br_table:
+.. _syntax-return:
+.. _syntax-call:
+.. _syntax-call_indirect:
 .. _syntax-label:
 .. index:: ! control instruction, ! structured control, ! label, ! block, ! branch, ! unwinding, result type, label index, function index, type index, vector
    pair: abstract syntax; instruction
@@ -333,7 +342,7 @@ However, forward branches that target a control instruction with a non-empty res
 The |CALL| instruction invokes another function, consuming the necessary arguments from the stack and returning the result values of the call.
 The |CALLINDIRECT| instruction calls a function indirectly through an operand indexing into a :ref:`table <syntax-table>`.
 Since tables may contain function elements of heterogeneous type |ANYFUNC|,
-the callee is dynamically checked against the :ref:`function type <functype>` indexed by the instruction's immediate, and the call aborted with a :ref:`trap <trap>` if it does not match.
+the callee is dynamically checked against the :ref:`function type <syntax-functype>` indexed by the instruction's immediate, and the call aborted with a :ref:`trap <trap>` if it does not match.
 
 .. note::
    In the current version of WebAssembly,
diff --git a/document/syntax/modules.rst b/document/syntax/modules.rst
index d879612f9..ed3905910 100644
--- a/document/syntax/modules.rst
+++ b/document/syntax/modules.rst
@@ -106,6 +106,7 @@ They are referenced by :ref:`type indices <syntax-typeidx>`.
 .. _syntax-local:
 .. index:: ! function, ! local, function index, local index, type index, value type, expression, import
    pair: abstract syntax; function
+   pair: abstract syntax; local
 
 Functions
 ~~~~~~~~~
diff --git a/document/syntax/values.rst b/document/syntax/values.rst
index faa1aa201..89ecfe8d5 100644
--- a/document/syntax/values.rst
+++ b/document/syntax/values.rst
@@ -60,7 +60,7 @@ Different classes of *integers* with different value ranges are distinguished by
 
 The latter class defines *uninterpreted* integers, whose signedness interpretation can vary depending on context.
 In the abstract syntax, they are represented as unsigned.
-However, some operations :ref:`convert <aus-signed>` them to signed based on a 2's complement interpretation.
+However, some operations :ref:`convert <aux-signed>` them to signed based on a 2's complement interpretation.
 
 
 Conventions
@@ -109,7 +109,8 @@ A vector can have at most :math:`2^{32}-1` elements.
 
 
 .. _syntax-name:
-.. index:: ! name, byte
+.. _syntax-utf8:
+.. index:: ! name, byte, Unicode, UTF-8, code point
    pair: abstract syntax; name
 
 Names
@@ -118,19 +119,26 @@ Names
 *Names* are sequences of *scalar* `Unicode <http://www.unicode.org/versions/latest/>`_ *code points*.
 
 .. math::
-   \begin{array}{llll}
+   \begin{array}{llclll}
    \production{name} & \name &::=&
-     \codepoint^\ast \\
+     \codepoint^\ast & (|\utf8(\codepoint^\ast)| < 2^{32}) \\
    \production{code point} & \codepoint &::=&
      \unicode{0000} ~|~ \dots ~|~ \unicode{D7FF} ~|~
      \unicode{E000} ~|~ \dots ~|~ \unicode{10FFFF} \\
    \end{array}
 
-.. todo::
-   The definition of a name as an arbitrary sequence of scalar code points is too general.
-   So would be the definition of a vector.
-   Only names whose UTF-8 encoding is within the bounds of the maximum vector lengths must be included.
-   How specify this?
+Due to the limitations of the :ref:`binary format <binary-name>`,
+the lengths of a name is bounded by the length of its `UTF-8 <http://www.unicode.org/versions/latest/>`_ encoding.
+The auxiliary |utf8| function expressing this encoding is defined as follows:
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   \utf8(c^\ast) &=& (\utf8(c))^\ast \\[1ex]
+   \utf8(c) &=& b & (c < \unicode{80} \wedge c = b) \\
+   \utf8(c) &=& b_1~b_2 & (\unicode{80} \leq c < \unicode{800} \wedge c = 2^6\cdot(b_1-\hex{C0})+(b_2-\hex{80})) \\
+   \utf8(c) &=& b_1~b_2~b_3 & (\unicode{800} \leq c < \unicode{10000} \wedge c = 2^{12}\cdot(b_1-\hex{C0})+2^6\cdot(b_2-\hex{80})+(b_3-\hex{80})) \\
+   \utf8(c) &=& b_1~b_2~b_3~b_4 & (\unicode{10000} \leq c < \unicode{110000} \wedge c = 2^{18}\cdot(b_1-\hex{C0})+2^{12}\cdot(b_2-\hex{80})+2^6\cdot(b_3-\hex{80})+(b_4-\hex{80})) \\
+   \end{array}
 
 
 Convention
diff --git a/document/text/conventions.rst b/document/text/conventions.rst
new file mode 100644
index 000000000..94b2ebd9a
--- /dev/null
+++ b/document/text/conventions.rst
@@ -0,0 +1,140 @@
+.. index:: ! text format, Unicode, UTF-8, S-expression
+
+Conventions
+-----------
+
+The textual format for WebAssembly :ref:`modules <modules>` is a rendering of their :ref:`abstract syntax <syntax-module>` into *S-expressions*.
+
+Like the :ref:`binary format <binary-format>`, the text format is defined by an *attribute grammar*.
+A text string is a well-formed description of a module if and only if it is generated by the grammar.
+
+Each production of this grammar has at most one synthesized attribute: the abstract syntax that the respective character sequence expresses.
+Thus, the attribute grammar implicitly defines a *parsing* function.
+Some productions also take a :ref:`context <text-context>` as an inherited attribute
+that records bound :ref:`identifers <text-id>`.
+
+Except for a few exceptions, the core of the text grammar closely mirrors the grammar of the abstract syntax.
+However, it also defines a number of *abbreviations* that are *syntactic sugar* over the core syntax.
+
+The recommended extension for source files containing WebAssembly modules in text format is ":math:`\T{.wat}`".
+Files with this extension are assumed to be encoded in `Unicode UTF-8 <http://www.unicode.org/versions/latest/>`_.
+
+
+.. _text-grammar:
+.. index:: grammar notation, notation, Unicode
+   single: text format; grammar
+   pair: text format; notation
+
+Grammar
+~~~~~~~
+
+The following conventions are adopted in defining grammar rules for the text format.
+They mirror the conventions used for :ref:`abstract syntax <grammar>` and for the :ref:`binary format <binary-format>`.
+In order to distinguish symbols of the textual syntax from symbols of the abstract syntax, typewriter font is adopted for the former.
+
+* Terminal symbols are either literal strings of characters enclosed in quotes: :math:`\text{module}`;
+  or expressed as `Unicode <http://www.unicode.org/versions/latest/>`_ code points: :math:`\unicode{0A}`.
+  (All characters written literally are unambiguously drawn from the `7-bit ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ subset of Unicode.)
+
+* Nonterminal symbols are written in typewriter font: :math:`\T{valtype}, \T{instr}`.
+
+* Arbitrary :ref:`white space <text-space>` is allowed in any place where the grammar contains spaces, except where noted otherwise, such as the :ref:`lexical syntax <text-lexical>`.
+
+* :math:`T^n` is a sequence of :math:`n\geq 0` iterations  of :math:`T`.
+
+* :math:`T^\ast` is a possibly empty sequence of iterations of :math:`T`.
+  (This is a shorthand for :math:`T^n` used where :math:`n` is not relevant.)
+
+* :math:`T^+` is a sequence of one or more iterations of :math:`T`.
+  (This is a shorthand for :math:`T^n` where :math:`n \geq 1`.)
+
+* :math:`T^?` is an optional occurrence of :math:`T`.
+  (This is a shorthand for :math:`T^n` where :math:`n \leq 1`.)
+
+* :math:`x{:}T` denotes the same language as the nonterminal :math:`T`, but also binds the variable :math:`x` to the attribute synthesized for :math:`T`.
+
+* Productions are written :math:`\T{name} ::= T \Rightarrow A`, where :math:`A` is the attribute that is synthesized for :math:`\T{name}`, usually from attribute variables bound in :math:`T`.
+
+* Some productions are augmented by side conditions in parentheses, which restrict the applicability of the production. They provide a shorthand for a combinatorial expansion of the production into many separate cases.
+
+.. note::
+   For example, the :ref:`textual grammar <text-valtype>` for :ref:`value types <syntax-valtype>` is given as follows:
+
+   .. math::
+     \begin{array}{llcll@{\qquad\qquad}l}
+     \production{value types} & \Tvaltype &::=&
+       \text{i32} &\Rightarrow& \I32 \\ &&|&
+       \text{i64} &\Rightarrow& \I64 \\ &&|&
+       \text{f32} &\Rightarrow& \F32 \\ &&|&
+       \text{f64} &\Rightarrow& \F64 \\
+     \end{array}
+
+   The :ref:`textual grammar <text-limits>` for :ref:`limits <syntax-limits>` is defined as follows:   
+
+   .. math::
+      \begin{array}{llclll}
+      \production{limits} & \Tlimits &::=&
+        n{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~\epsilon \} \\ &&|&
+        n{:}\Tu32~~m{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~m \} \\
+      \end{array}
+
+   The variables :math:`n` and :math:`m` name the attributes of the respective |Tu32| nonterminals, which in this case are the actual :ref:`unsigned integers <syntax-uint>` they decode into.
+   The attribute of the complete production then is the abstract syntax for the limit, expressed in terms of the former values.
+
+
+.. _text-abbreviations:
+.. index:: ! abbreviations
+
+Abbreviations
+~~~~~~~~~~~~~
+
+In addition to the core grammar, which corresponds directly to the :ref:`abstract syntax <syntax>`, the textual syntax also defines a number of *abbreviations* that can be used for convenience and readability.
+
+Abbreviations are defined by rewrite rules specifying their expansion into the core syntax:
+
+.. math::
+   \X{abbreviation~syntax} \quad\equiv\quad \X{expanded~syntax}
+
+These expansions are assumed to be applied, recursively and in order of appearance, before applying the core grammar rules to construct the abstract syntax.
+
+
+.. _text-context:
+.. _text-context-wf:
+.. index:: ! identifier context, identifier, index, index space
+
+Contexts
+~~~~~~~~
+
+The text format allows to use symbolic :ref:`identifiers <text-id>` in place of :ref:`indices <syntax-index>`.
+To resolve these identifiers into concrete indices,
+some grammar production are indexed by an *identifier context* :math:`I` as a synthesized attribute that records the declared identifiers in each :ref:`index space <syntax-index>`.
+In addition, the context records the types defined in the module, so that :ref:`parameter <text-param>` indices can be computed for :ref:`functions <text-func>`.
+
+It is convenient to define identifier contexts as :ref:`records <syntax-record>` :math:`I` with abstract syntax:
+
+.. math::
+   \begin{array}{llll}
+   \production{(identifier context)} & I &::=&
+     \begin{array}[t]{l@{~}ll}
+     \{ & \TYPES & (\Tid^?)^\ast, \\
+        & \FUNCS & (\Tid^?)^\ast, \\
+        & \TABLES & (\Tid^?)^\ast, \\
+        & \MEMS & (\Tid^?)^\ast, \\
+        & \GLOBALS & (\Tid^?)^\ast, \\
+        & \LOCALS & (\Tid^?)^\ast, \\
+        & \LABELS & (\Tid^?)^\ast, \\
+        & \TYPEDEFS & \functype^\ast ~\} \\
+     \end{array}
+   \end{array}
+
+For each index space, such a context contains the list of :ref:`identifiers <text-id>` assigned to the defined indices.
+Unnamed indices are associated with empty (:math:`\epsilon`) entries in these lists.
+
+An identifier context is *well-formed* if no index space contains duplicate identifiers.
+
+
+Conventions
+...........
+
+To avoid unnecessary clutter, empty components are omitted when writing out identifier contexts.
+For example, the record :math:`\{\}` is shorthand for an :ref:`identifier context <text-context>` whose components are all empty.
diff --git a/document/text/index.rst b/document/text/index.rst
new file mode 100644
index 000000000..89889e5cf
--- /dev/null
+++ b/document/text/index.rst
@@ -0,0 +1,14 @@
+.. _text-format:
+
+Text Format
+===========
+
+.. toctree::
+   :maxdepth: 2
+
+   conventions
+   lexical
+   values
+   types
+   instructions
+   modules
diff --git a/document/text/instructions.rst b/document/text/instructions.rst
new file mode 100644
index 000000000..ea2e70620
--- /dev/null
+++ b/document/text/instructions.rst
@@ -0,0 +1,504 @@
+.. _text-instr:
+.. index:: instruction
+
+Instructions
+------------
+
+Instructions are syntactically distinguished into *plain* and *structured* instructions.
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Tinstr_I &::=&
+     \X{in}{:}\Tplaininstr_I
+       &\Rightarrow& \X{in} \\ &&|&
+     \X{in}{:}\Tblockinstr_I
+       &\Rightarrow& \X{in} \\
+   \end{array}
+
+In addition, as a syntactic abbreviation, instructions can be written in :ref:`folded <text-foldedinstr>` form as S-expressions, to group them visually.
+
+
+.. _text-index:
+.. _text-typeidx:
+.. _text-funcidx:
+.. _text-tableidx:
+.. _text-memidx:
+.. _text-globalidx:
+.. _text-localidx:
+.. _text-labelidx:
+.. index:: index, type index, function index, table index, memory index, global index, local index, label index
+   pair: text format; type index
+   pair: text format; function index
+   pair: text format; table index
+   pair: text format; memory index
+   pair: text format; global index
+   pair: text format; local index
+   pair: text format; label index
+
+Indices
+~~~~~~~
+
+:ref:`Indices <syntax-index>` can be given either in raw numeric form or as symbolic :ref:`identifiers <text-id>` when bound by a respective construct.
+Such identifiers are looked up in the suitable space of the :ref:`identifier context <text-context>`.
+
+.. math::
+   \begin{array}{llcllllllll}
+   \production{type index} & \Ttypeidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\TYPES[x] = v) \\
+   \production{function index} & \Tfuncidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\FUNCS[x] = v) \\
+   \production{table index} & \Ttableidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\TABLES[x] = v) \\
+   \production{memory index} & \Tmemidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\MEMS[x] = v) \\
+   \production{global index} & \Tglobalidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\GLOBALS[x] = v) \\
+   \production{local index} & \Tlocalidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\LOCALS[x] = v) \\
+   \production{label index} & \Tlabelidx_I &::=&
+     l{:}\Tu32 &\Rightarrow& l &|&
+     v{:}\Tid &\Rightarrow& l & (I.\LABELS[l] = v) \\
+   \end{array}
+
+
+.. _text-label:
+.. index:: index, label index
+   pair: text format; label index
+
+:ref:`Structured control instructions <text-instr-control>` can be annotated with a symbolic :ref:`label identifier <text-id>`.
+They are the only symbolic identifiers that can be bound locally in an instruction sequence.
+The following grammar handles the corresponding update to the :ref:`identifier context <text-context>` by producing a context with an additional label entry.
+
+.. math::
+   \begin{array}{llcllll}
+   \production{label} & \Tlabel_I &::=&
+     \epsilon &\Rightarrow& \{\LABELS~(\epsilon)\} \compose I \\ &&|&
+     v{:}\Tid &\Rightarrow& \{\LABELS~v\} \compose I
+       & (v \notin I.\LABELS) \\
+   \end{array}
+
+.. note::
+   The new label entry is inserted at the *beginning* of the label list in the identifier context.
+   This effectively shifts all existing labels up by one,
+   mirroring the fact that control instructions are indexed relatively not absolutely.
+
+
+.. _text-instr-control:
+.. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, polymorphism
+   pair: text format; instruction
+
+Control Instructions
+~~~~~~~~~~~~~~~~~~~~
+
+.. _text-block:
+.. _text-loop:
+.. _text-if:
+
+:ref:`Structured control instructions <syntax-instr-control>` can bind an optional symbolic :ref:`label identifier <text-label>`.
+The same identifier may optionally be repeated after the corresponding :math:`\T{end}` and :math:`\T{else}` pseudo instructions.
+
+.. math::
+   \begin{array}{llclll}
+   \production{block instruction} & \Tblockinstr_I &::=&
+     \text{block}~~I'{:}\Tlabel_I~~\X{rt}{:}\Tresulttype~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
+       \\ &&&\qquad \Rightarrow\quad \BLOCK~\X{rt}~\X{in}^\ast~\END
+       \qquad\quad (\Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|&
+     \text{loop}~~I'{:}\Tlabel_I~~\X{rt}{:}\Tresulttype~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
+       \\ &&&\qquad \Rightarrow\quad \LOOP~\X{rt}~\X{in}^\ast~\END
+       \qquad\qquad (\Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|&
+     \text{if}~~I'{:}\Tlabel_I~~\X{rt}{:}\Tresulttype~~(\X{in}_1{:}\Tinstr_{I'})^\ast~~
+       \text{else}~~\Tid_1^?~~(\X{in}_2{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid_2^?
+       \\ &&&\qquad \Rightarrow\quad \IF~\X{rt}~\X{in}_1^\ast~\ELSE~\X{in}_2^\ast~\END
+       \qquad (\Tid_1^? = \epsilon \vee \Tid_1^? = \Tlabel, \Tid_2^? = \epsilon \vee \Tid_2^? = \Tlabel) \\
+   \end{array}
+
+.. _text-nop:
+.. _text-unreachable:
+.. _text-br:
+.. _text-br_if:
+.. _text-br_table:
+.. _text-return:
+.. _text-call:
+.. _text-call_indirect:
+
+All other control instruction are represented verbatim.
+
+.. math::
+   \begin{array}{llclll}
+   \production{plain instruction} & \Tplaininstr_I &::=&
+     \text{unreachable} &\Rightarrow& \UNREACHABLE \\ &&|&
+     \text{nop} &\Rightarrow& \NOP \\ &&|&
+     \text{br}~~l{:}\Tlabelidx_I &\Rightarrow& \BR~l \\ &&|&
+     \text{br\_if}~~l{:}\Tlabelidx_I &\Rightarrow& \BRIF~l \\ &&|&
+     \text{br\_table}~~l^\ast{:}\Tvec(\Tlabelidx_I)~~l_N{:}\Tlabelidx_I
+       &\Rightarrow& \BRTABLE~l^\ast~l_N \\ &&|&
+     \text{return} &\Rightarrow& \RETURN \\ &&|&
+     \text{call}~~x{:}\Tfuncidx_I &\Rightarrow& \CALL~x \\ &&|&
+     \text{call\_indirect}~~x{:}\Ttypeidx_I &\Rightarrow& \CALLINDIRECT~x \\
+   \end{array}
+
+
+Abbreviations
+.............
+
+The :math:`\text{else}` keyword of an :math:`\text{if}` instruction can be omitted if the following instruction sequence is empty.
+
+.. math::
+   \begin{array}{llclll}
+   \production{block instruction} &
+     \text{if}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~~\text{end}
+       &\equiv&
+     \text{if}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~~\text{else}~~\text{end}
+   \end{array}
+
+
+.. _text-instr-parametric:
+.. index:: value type, polymorphism
+   pair: text format; instruction
+
+Parametric Instructions
+~~~~~~~~~~~~~~~~~~~~~~~
+
+.. _text-drop:
+.. _text-select:
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|&
+     \text{drop} &\Rightarrow& \DROP \\ &&|&
+     \text{select} &\Rightarrow& \SELECT \\
+   \end{array}
+
+
+.. _text-instr-variable:
+.. index:: variable instructions, local index, global index
+   pair: text format; instruction
+
+Variable Instructions
+~~~~~~~~~~~~~~~~~~~~~
+
+.. _text-get_local:
+.. _text-set_local:
+.. _text-tee_local:
+.. _text-get_global:
+.. _text-set_global:
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|&
+     \text{get\_local}~~x{:}\Tlocalidx_I &\Rightarrow& \GETLOCAL~x \\ &&|&
+     \text{set\_local}~~x{:}\Tlocalidx_I &\Rightarrow& \SETLOCAL~x \\ &&|&
+     \text{tee\_local}~~x{:}\Tlocalidx_I &\Rightarrow& \TEELOCAL~x \\ &&|&
+     \text{get\_global}~~x{:}\Tglobalidx_I &\Rightarrow& \GETGLOBAL~x \\ &&|&
+     \text{set\_global}~~x{:}\Tglobalidx_I &\Rightarrow& \SETGLOBAL~x \\
+   \end{array}
+
+
+.. _text-instr-memory:
+.. _text-memarg:
+.. index:: memory instruction, memory index
+   pair: text format; instruction
+
+Memory Instructions
+~~~~~~~~~~~~~~~~~~~
+
+.. _text-memarg:
+.. _text-load:
+.. _text-loadn:
+.. _text-store:
+.. _text-storen:
+.. _text-current_memory:
+.. _text-grow_memory:
+
+The offset and alignment immediates to memory instructions are optional.
+The offset defaults to :math:`\T{0}`, the alignment to the storage size of the respective memory access, which is its *natural alignment*.
+Lexically, an |Toffset| or |Talign| phrase is considered a single :ref:`keyword token <text-keyword>`, so no :ref:`white space <text-space>` is allowed around the :math:`\text{=}`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{memory argument} & \Tmemarg_N &::=&
+     o{:}\Toffset~~a{:}\Talign_N &\Rightarrow& \{ \ALIGN~a,~\OFFSET~o \} \\
+   \production{memory offset} & \Toffset &::=&
+     \text{offset{=}}o{:}\Tu32 &\Rightarrow& o \\ &&|&
+     \epsilon &\Rightarrow& 0 \\
+   \production{memory alignment} & \Talign_N &::=&
+     \text{align{=}}a{:}\Tu32 &\Rightarrow& a \\ &&|&
+     \epsilon &\Rightarrow& N \\
+   \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|&
+     \text{i32.load}~~m{:}\Tmemarg_4 &\Rightarrow& \I32.\LOAD~m \\ &&|&
+     \text{i64.load}~~m{:}\Tmemarg_8 &\Rightarrow& \I64.\LOAD~m \\ &&|&
+     \text{f32.load}~~m{:}\Tmemarg_4 &\Rightarrow& \F32.\LOAD~m \\ &&|&
+     \text{f64.load}~~m{:}\Tmemarg_8 &\Rightarrow& \F64.\LOAD~m \\ &&|&
+     \text{i32.load8\_s}~~m{:}\Tmemarg_1 &\Rightarrow& \I32.\LOAD\K{8\_s}~m \\ &&|&
+     \text{i32.load8\_u}~~m{:}\Tmemarg_1 &\Rightarrow& \I32.\LOAD\K{8\_u}~m \\ &&|&
+     \text{i32.load16\_s}~~m{:}\Tmemarg_2 &\Rightarrow& \I32.\LOAD\K{16\_s}~m \\ &&|&
+     \text{i32.load16\_u}~~m{:}\Tmemarg_2 &\Rightarrow& \I32.\LOAD\K{16\_u}~m \\ &&|&
+     \text{i64.load8\_s}~~m{:}\Tmemarg_1 &\Rightarrow& \I64.\LOAD\K{8\_s}~m \\ &&|&
+     \text{i64.load8\_u}~~m{:}\Tmemarg_1 &\Rightarrow& \I64.\LOAD\K{8\_u}~m \\ &&|&
+     \text{i64.load16\_s}~~m{:}\Tmemarg_2 &\Rightarrow& \I64.\LOAD\K{16\_s}~m \\ &&|&
+     \text{i64.load16\_u}~~m{:}\Tmemarg_2 &\Rightarrow& \I64.\LOAD\K{16\_u}~m \\ &&|&
+     \text{i64.load32\_s}~~m{:}\Tmemarg_4 &\Rightarrow& \I64.\LOAD\K{32\_s}~m \\ &&|&
+     \text{i64.load32\_u}~~m{:}\Tmemarg_4 &\Rightarrow& \I64.\LOAD\K{32\_u}~m \\ &&|&
+     \text{i32.store}~~m{:}\Tmemarg_4 &\Rightarrow& \I32.\STORE~m \\ &&|&
+     \text{i64.store}~~m{:}\Tmemarg_8 &\Rightarrow& \I64.\STORE~m \\ &&|&
+     \text{f32.store}~~m{:}\Tmemarg_4 &\Rightarrow& \F32.\STORE~m \\ &&|&
+     \text{f64.store}~~m{:}\Tmemarg_8 &\Rightarrow& \F64.\STORE~m \\ &&|&
+     \text{i32.store8}~~m{:}\Tmemarg_1 &\Rightarrow& \I32.\STORE\K{8}~m \\ &&|&
+     \text{i32.store16}~~m{:}\Tmemarg_2 &\Rightarrow& \I32.\STORE\K{16}~m \\ &&|&
+     \text{i64.store8}~~m{:}\Tmemarg_1 &\Rightarrow& \I64.\STORE\K{8}~m \\ &&|&
+     \text{i64.store16}~~m{:}\Tmemarg_2 &\Rightarrow& \I64.\STORE\K{16}~m \\ &&|&
+     \text{i64.store32}~~m{:}\Tmemarg_4 &\Rightarrow& \I64.\STORE\K{32}~m \\ &&|&
+     \text{current\_memory} &\Rightarrow& \CURRENTMEMORY \\ &&|&
+     \text{grow\_memory} &\Rightarrow& \GROWMEMORY \\
+   \end{array}
+
+
+.. _text-instr-numeric:
+.. index:: numeric instruction
+   pair: text format; instruction
+
+Numeric Instructions
+~~~~~~~~~~~~~~~~~~~~
+
+.. _text-const:
+
+.. math::
+   \begin{array}{llclll}
+   \production{instruction} & \Tplaininstr_I &::=& \dots \\&&|&
+     \text{i32.const}~~n{:}\Ti32 &\Rightarrow& \I32.\CONST~n \\ &&|&
+     \text{i64.const}~~n{:}\Ti64 &\Rightarrow& \I64.\CONST~n \\ &&|&
+     \text{f32.const}~~z{:}\Tf32 &\Rightarrow& \F32.\CONST~z \\ &&|&
+     \text{f64.const}~~z{:}\Tf64 &\Rightarrow& \F64.\CONST~z \\
+   \end{array}
+
+.. _text-unop:
+.. _text-binop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \text{i32.clz} &\Rightarrow& \I32.\CLZ \\ &&|&
+     \text{i32.ctz} &\Rightarrow& \I32.\CTZ \\ &&|&
+     \text{i32.popcnt} &\Rightarrow& \I32.\POPCNT \\ &&|&
+     \text{i32.add} &\Rightarrow& \I32.\ADD \\ &&|&
+     \text{i32.sub} &\Rightarrow& \I32.\SUB \\ &&|&
+     \text{i32.mul} &\Rightarrow& \I32.\MUL \\ &&|&
+     \text{i32.div\_s} &\Rightarrow& \I32.\DIV\K{\_s} \\ &&|&
+     \text{i32.div\_u} &\Rightarrow& \I32.\DIV\K{\_u} \\ &&|&
+     \text{i32.rem\_s} &\Rightarrow& \I32.\REM\K{\_s} \\ &&|&
+     \text{i32.rem\_u} &\Rightarrow& \I32.\REM\K{\_u} \\ &&|&
+     \text{i32.and} &\Rightarrow& \I32.\AND \\ &&|&
+     \text{i32.or} &\Rightarrow& \I32.\OR \\ &&|&
+     \text{i32.xor} &\Rightarrow& \I32.\XOR \\ &&|&
+     \text{i32.shl} &\Rightarrow& \I32.\SHL \\ &&|&
+     \text{i32.shr\_s} &\Rightarrow& \I32.\SHR\K{\_s} \\ &&|&
+     \text{i32.shr\_u} &\Rightarrow& \I32.\SHR\K{\_u} \\ &&|&
+     \text{i32.rotl} &\Rightarrow& \I32.\ROTL \\ &&|&
+     \text{i32.rotr} &\Rightarrow& \I32.\ROTR \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \text{i64.clz} &\Rightarrow& \I64.\CLZ \\ &&|&
+     \text{i64.ctz} &\Rightarrow& \I64.\CTZ \\ &&|&
+     \text{i64.popcnt} &\Rightarrow& \I64.\POPCNT \\ &&|&
+     \text{i64.add} &\Rightarrow& \I64.\ADD \\ &&|&
+     \text{i64.sub} &\Rightarrow& \I64.\SUB \\ &&|&
+     \text{i64.mul} &\Rightarrow& \I64.\MUL \\ &&|&
+     \text{i64.div\_s} &\Rightarrow& \I64.\DIV\K{\_s} \\ &&|&
+     \text{i64.div\_u} &\Rightarrow& \I64.\DIV\K{\_u} \\ &&|&
+     \text{i64.rem\_s} &\Rightarrow& \I64.\REM\K{\_s} \\ &&|&
+     \text{i64.rem\_u} &\Rightarrow& \I64.\REM\K{\_u} \\ &&|&
+     \text{i64.and} &\Rightarrow& \I64.\AND \\ &&|&
+     \text{i64.or} &\Rightarrow& \I64.\OR \\ &&|&
+     \text{i64.xor} &\Rightarrow& \I64.\XOR \\ &&|&
+     \text{i64.shl} &\Rightarrow& \I64.\SHL \\ &&|&
+     \text{i64.shr\_s} &\Rightarrow& \I64.\SHR\K{\_s} \\ &&|&
+     \text{i64.shr\_u} &\Rightarrow& \I64.\SHR\K{\_u} \\ &&|&
+     \text{i64.rotl} &\Rightarrow& \I64.\ROTL \\ &&|&
+     \text{i64.rotr} &\Rightarrow& \I64.\ROTR \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \text{f32.abs} &\Rightarrow& \F32.\ABS \\ &&|&
+     \text{f32.neg} &\Rightarrow& \F32.\NEG \\ &&|&
+     \text{f32.ceil} &\Rightarrow& \F32.\CEIL \\ &&|&
+     \text{f32.floor} &\Rightarrow& \F32.\FLOOR \\ &&|&
+     \text{f32.trunc} &\Rightarrow& \F32.\TRUNC \\ &&|&
+     \text{f32.nearest} &\Rightarrow& \F32.\NEAREST \\ &&|&
+     \text{f32.sqrt} &\Rightarrow& \F32.\SQRT \\ &&|&
+     \text{f32.add} &\Rightarrow& \F32.\ADD \\ &&|&
+     \text{f32.sub} &\Rightarrow& \F32.\SUB \\ &&|&
+     \text{f32.mul} &\Rightarrow& \F32.\MUL \\ &&|&
+     \text{f32.div} &\Rightarrow& \F32.\DIV \\ &&|&
+     \text{f32.min} &\Rightarrow& \F32.\FMIN \\ &&|&
+     \text{f32.max} &\Rightarrow& \F32.\FMAX \\ &&|&
+     \text{f32.copysign} &\Rightarrow& \F32.\COPYSIGN \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \text{f64.abs} &\Rightarrow& \F64.\ABS \\ &&|&
+     \text{f64.neg} &\Rightarrow& \F64.\NEG \\ &&|&
+     \text{f64.ceil} &\Rightarrow& \F64.\CEIL \\ &&|&
+     \text{f64.floor} &\Rightarrow& \F64.\FLOOR \\ &&|&
+     \text{f64.trunc} &\Rightarrow& \F64.\TRUNC \\ &&|&
+     \text{f64.nearest} &\Rightarrow& \F64.\NEAREST \\ &&|&
+     \text{f64.sqrt} &\Rightarrow& \F64.\SQRT \\ &&|&
+     \text{f64.add} &\Rightarrow& \F64.\ADD \\ &&|&
+     \text{f64.sub} &\Rightarrow& \F64.\SUB \\ &&|&
+     \text{f64.mul} &\Rightarrow& \F64.\MUL \\ &&|&
+     \text{f64.div} &\Rightarrow& \F64.\DIV \\ &&|&
+     \text{f64.min} &\Rightarrow& \F64.\FMIN \\ &&|&
+     \text{f64.max} &\Rightarrow& \F64.\FMAX \\ &&|&
+     \text{f64.copysign} &\Rightarrow& \F64.\COPYSIGN \\
+   \end{array}
+
+.. _text-testop:
+.. _text-relop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \text{i32.eqz} &\Rightarrow& \I32.\EQZ \\ &&|&
+     \text{i32.eq} &\Rightarrow& \I32.\EQ \\ &&|&
+     \text{i32.ne} &\Rightarrow& \I32.\NE \\ &&|&
+     \text{i32.lt\_s} &\Rightarrow& \I32.\LT\K{\_s} \\ &&|&
+     \text{i32.lt\_u} &\Rightarrow& \I32.\LT\K{\_u} \\ &&|&
+     \text{i32.gt\_s} &\Rightarrow& \I32.\GT\K{\_s} \\ &&|&
+     \text{i32.gt\_u} &\Rightarrow& \I32.\GT\K{\_u} \\ &&|&
+     \text{i32.le\_s} &\Rightarrow& \I32.\LE\K{\_s} \\ &&|&
+     \text{i32.le\_u} &\Rightarrow& \I32.\LE\K{\_u} \\ &&|&
+     \text{i32.ge\_s} &\Rightarrow& \I32.\GE\K{\_s} \\ &&|&
+     \text{i32.ge\_u} &\Rightarrow& \I32.\GE\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \text{i64.eqz} &\Rightarrow& \I64.\EQZ \\ &&|&
+     \text{i64.eq} &\Rightarrow& \I64.\EQ \\ &&|&
+     \text{i64.ne} &\Rightarrow& \I64.\NE \\ &&|&
+     \text{i64.lt\_s} &\Rightarrow& \I64.\LT\K{\_s} \\ &&|&
+     \text{i64.lt\_u} &\Rightarrow& \I64.\LT\K{\_u} \\ &&|&
+     \text{i64.gt\_s} &\Rightarrow& \I64.\GT\K{\_s} \\ &&|&
+     \text{i64.gt\_u} &\Rightarrow& \I64.\GT\K{\_u} \\ &&|&
+     \text{i64.le\_s} &\Rightarrow& \I64.\LE\K{\_s} \\ &&|&
+     \text{i64.le\_u} &\Rightarrow& \I64.\LE\K{\_u} \\ &&|&
+     \text{i64.ge\_s} &\Rightarrow& \I64.\GE\K{\_s} \\ &&|&
+     \text{i64.ge\_u} &\Rightarrow& \I64.\GE\K{\_u} \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \text{f32.eq} &\Rightarrow& \F32.\EQ \\ &&|&
+     \text{f32.ne} &\Rightarrow& \F32.\NE \\ &&|&
+     \text{f32.lt} &\Rightarrow& \F32.\LT \\ &&|&
+     \text{f32.gt} &\Rightarrow& \F32.\GT \\ &&|&
+     \text{f32.le} &\Rightarrow& \F32.\LE \\ &&|&
+     \text{f32.ge} &\Rightarrow& \F32.\GE \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \text{f64.eq} &\Rightarrow& \F64.\EQ \\ &&|&
+     \text{f64.ne} &\Rightarrow& \F64.\NE \\ &&|&
+     \text{f64.lt} &\Rightarrow& \F64.\LT \\ &&|&
+     \text{f64.gt} &\Rightarrow& \F64.\GT \\ &&|&
+     \text{f64.le} &\Rightarrow& \F64.\LE \\ &&|&
+     \text{f64.ge} &\Rightarrow& \F64.\GE \\
+   \end{array}
+
+.. _text-cvtop:
+
+.. math::
+   \begin{array}{llclll}
+   \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
+     \text{i32.wrap/i64} &\Rightarrow& \I32.\WRAP\K{/}\I64 \\ &&|&
+     \text{i32.trunc\_s/f32} &\Rightarrow& \I32.\TRUNC\K{\_s/}\F32 \\ &&|&
+     \text{i32.trunc\_u/f32} &\Rightarrow& \I32.\TRUNC\K{\_u/}\F32 \\ &&|&
+     \text{i32.trunc\_s/f64} &\Rightarrow& \I32.\TRUNC\K{\_s/}\F64 \\ &&|&
+     \text{i32.trunc\_u/f64} &\Rightarrow& \I32.\TRUNC\K{\_u/}\F64 \\ &&|&
+     \text{i64.extend\_s/i32} &\Rightarrow& \I64.\EXTEND\K{\_s/}\I32 \\ &&|&
+     \text{i64.extend\_u/i32} &\Rightarrow& \I64.\EXTEND\K{\_u/}\I32 \\ &&|&
+     \text{i64.trunc\_s/f32} &\Rightarrow& \I64.\TRUNC\K{\_s/}\F32 \\ &&|&
+     \text{i64.trunc\_u/f32} &\Rightarrow& \I64.\TRUNC\K{\_u/}\F32 \\ &&|&
+     \text{i64.trunc\_s/f64} &\Rightarrow& \I64.\TRUNC\K{\_s/}\F64 \\ &&|&
+     \text{i64.trunc\_u/f64} &\Rightarrow& \I64.\TRUNC\K{\_u/}\F64 \\ &&|&
+     \text{f32.convert\_s/i32} &\Rightarrow& \F32.\CONVERT\K{\_s/}\I32 \\ &&|&
+     \text{f32.convert\_u/i32} &\Rightarrow& \F32.\CONVERT\K{\_u/}\I32 \\ &&|&
+     \text{f32.convert\_s/i64} &\Rightarrow& \F32.\CONVERT\K{\_s/}\I64 \\ &&|&
+     \text{f32.convert\_u/i64} &\Rightarrow& \F32.\CONVERT\K{\_u/}\I64 \\ &&|&
+     \text{f32.demote/f64} &\Rightarrow& \F32.\DEMOTE\K{/}\F64 \\ &&|&
+     \text{f64.convert\_s/i32} &\Rightarrow& \F64.\CONVERT\K{\_s/}\I32 \\ &&|&
+     \text{f64.convert\_u/i32} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I32 \\ &&|&
+     \text{f64.convert\_s/i64} &\Rightarrow& \F64.\CONVERT\K{\_s/}\I64 \\ &&|&
+     \text{f64.convert\_u/i64} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I64 \\ &&|&
+     \text{f64.demote/f32} &\Rightarrow& \F64.\PROMOTE\K{/}\F32 \\ &&|&
+     \text{i32.reinterpret/f32} &\Rightarrow& \I32.\REINTERPRET\K{/}\F32 \\ &&|&
+     \text{i64.reinterpret/f64} &\Rightarrow& \I64.\REINTERPRET\K{/}\F64 \\ &&|&
+     \text{f32.reinterpret/i32} &\Rightarrow& \F32.\REINTERPRET\K{/}\I32 \\ &&|&
+     \text{f64.reinterpret/i64} &\Rightarrow& \F64.\REINTERPRET\K{/}\I64 \\
+   \end{array}
+
+
+.. _text-foldedinstr:
+.. index:: ! folded instruction, S-expression
+
+Folded Instructions
+~~~~~~~~~~~~~~~~~~~
+
+As a special abbreviation, instructions can be grouped into *folded* S-expression form.
+The set of all phrases defined by the following abbreviations recursively forms the auxiliary syntactic class |Tfoldedinstr|.
+Such a folded instruction can appear anywhere a regular instruction can.
+
+.. MathJax doesn't handle LaTex multicolumns, this the spacing hack in the following formula.
+
+.. math::
+   \begin{array}{lllll}
+   \production{instruction} & 
+     \text{(}~\Tplaininstr~~\Tfoldedinstr^\ast~\text{)}
+       &\equiv\quad \Tfoldedinstr^\ast~~\Tplaininstr \\ &
+     \text{(}~\text{block}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~\text{)}
+       &\equiv\quad \text{block}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~~\text{end} \\ &
+     \text{(}~\text{loop}~~\Tresulttype~~\Tinstr^\ast~\text{)}
+       &\equiv\quad \text{loop}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~~\text{end} \\ &
+     \text{(}~\text{if}~~\Tlabel~~\Tresulttype~~\Tfoldedinstr^\ast
+       &\hspace{-3ex} \text{(}~\text{then}~~\Tinstr_1^\ast~\text{)}~~\text{(}~\text{else}~~\Tinstr_2^\ast~\text{)}^?~~\text{)}
+       \quad\equiv \\ &\qquad
+         \Tfoldedinstr^\ast~~\text{if}~~\Tlabel~~\Tresulttype &\hspace{-1ex} \Tinstr_1^\ast~~\text{else}~~(\Tinstr_2^\ast)^?~\text{end} \\
+   \end{array}
+
+.. note::
+   Folded instructions are solely syntactic sugar,
+   no additional syntactic or type-based checking is implied.
+
+
+.. _text-expr:
+.. index:: expression
+   pair: text format; expression
+   single: expression; constant
+
+Expressions
+~~~~~~~~~~~
+
+Expressions are written as instruction sequences.
+No explicit :math:`\text{end}` keyword is included, since they only occur in bracketed positions.
+
+.. math::
+   \begin{array}{llclll}
+   \production{expression} & \Texpr &::=&
+     (\X{in}{:}\Tinstr)^\ast &\Rightarrow& \X{in}^\ast~\END \\
+   \end{array}
diff --git a/document/text/lexical.rst b/document/text/lexical.rst
new file mode 100644
index 000000000..abf6466e6
--- /dev/null
+++ b/document/text/lexical.rst
@@ -0,0 +1,111 @@
+.. _text-lexical:
+.. index:: lexical format
+
+Lexical Format
+--------------
+
+
+.. _text-char:
+.. index:: ! character, Unicode, ASCII, code point, ! source text
+   pair: text format; character
+
+Characters
+~~~~~~~~~~
+
+The text format assigns meaning to *source text*, which consists of a sequence of *characters*.
+Characters are assumed to be represented as valid `Unicode <http://www.unicode.org/versions/latest/>`_ *code points*.
+
+.. math::
+   \begin{array}{llll}
+   \production{character} & \Tchar &::=&
+     \unicode{00} ~|~ \dots ~|~ \unicode{D7FF} ~|~ \unicode{E000} ~|~ \dots ~|~ \unicode{10FFFF} \\
+   \end{array}
+
+.. note::
+   While source text may contain any Unicode character in :ref:`comments <text-comment>` or :ref:`string <text-string>` literals,
+   the rest of the grammar is formed exclusively from the characters supported by the `7-bit ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ subset of Unicode.
+
+
+.. _text-token:
+.. _text-keyword:
+.. index:: ! token, ! keyword, character, white space, comment, source text
+   single: text format; token
+
+Tokens
+~~~~~~
+
+The character stream in the source text is divided, from left to right, into a sequence of *tokens*, as defined by the following grammar.
+
+.. math::
+   \begin{array}{llll}
+   \production{token} & \Ttoken &::=&
+     \Tkeyword ~|~ \TuN ~|~ \TsN ~|~ \TfN ~|~ \Tstring ~|~ \Tid ~|~
+     \text{(} ~|~ \text{)} ~|~ \Treserved \\
+   \production{keyword} & \Tkeyword &::=&
+     \mbox{(any terminal symbol in the grammar that is none of the above)} \\
+   \production{reserved} & \Treserved &::=&
+     \Tidchar^+ \\
+   \end{array}
+
+In this specification, the set of valid *keyword* tokens is defined implicitly, by their occurrence as a terminal symbols in literal form in the non-lexical grammar.
+Any sequence of alphanumeric or symbolic characters that is not in the other classes is considered a *reserved word*.
+
+Tokens are formed from the input character stream according to the *longest match* rule.
+That is, the next token always consists of the longest possible sequence of characters that is recognized by the above grammar.
+Where necessary, tokens may be separated by :ref:`white space <text-space>`.
+
+
+.. _text-space:
+.. index:: ! white space, character, ASCII
+   single: text format; white space
+
+White Space
+~~~~~~~~~~~
+
+*White space* is any sequence of literal space characters, formatting characters, or :ref:`comments <text-comment>`.
+The allowed formatting characters correspond to a subset of the `ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ *format effectors*, namely, *horizontal tabulation* (:math:`\unicode{09}`), *line feed* (:math:`\unicode{0A}`), and *carriage return* (:math:`\unicode{0D}`).
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{white space} & \Tspace &::=&
+     (\text{~~} ~|~ \Tformat ~|~ \Tcomment)^\ast \\
+   \production{format} & \Tformat &::=&
+     \unicode{09} ~|~ \unicode{0A} ~|~ \unicode{0D} \\
+   \end{array}
+
+The only relevance of white space is to separate :ref:`tokens <text-token>`, it is ignored otherwise.
+
+
+.. _text-comment:
+.. index:: ! comment, character
+   single: text format; comment
+
+Comments
+~~~~~~~~
+
+A *comment* can either be a *line comment*, started with a double semicolon :math:`\Tcommentd` and extending to the end of the line,
+or a *block comment*, enclosed in delimiters :math:`\Tcommentl \dots \Tcommentr`.
+Block comments can be nested.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{comment} & \Tcomment &::=&
+     \Tlinecomment ~|~ \Tblockcomment \\
+   \production{line comment} & \Tlinecomment &::=&
+     \Tcommentd~~\Tlinechar^\ast~~(\unicode{0A} ~|~ \T{eof}) \\
+   \production{line character} & \Tlinechar &::=&
+     c{:}\Tchar & (c \neq \unicode{0A}) \\
+   \production{block comment} & \Tblockcomment &::=&
+     \Tcommentl~~\Tblockchar^\ast~~\Tcommentr \\
+   \production{block character} & \Tblockchar &::=&
+     c{:}\Tchar & (c \neq \text{;} \wedge c \neq \text{(}) \\ &&|&
+     \text{;} & (\mbox{the next character is not}~\text{)}) \\ &&|&
+     \text{(} & (\mbox{the next character is not}~\text{;}) \\ &&|&
+     \Tblockcomment \\
+   \end{array}
+
+Here, the pseudo token :math:`\T{eof}` indicates the end of the input.
+The *look-ahead* restrictions on the productions for |Tblockchar| disambiguate the grammar such that only well-bracketed uses of block comment delimiters are allowed.
+
+.. note::
+   Any formatting and control characters are allowed inside comments.
diff --git a/document/text/modules.rst b/document/text/modules.rst
new file mode 100644
index 000000000..8f769a6c5
--- /dev/null
+++ b/document/text/modules.rst
@@ -0,0 +1,598 @@
+Modules
+-------
+
+
+.. _text-type:
+.. index:: type definition, identifier
+   pair: text format; type definition
+
+Types
+~~~~~
+
+Type definitions can bind a symbolic :ref:`type identifier <text-id>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{type definition} & \Ttype &::=&
+     \text{(}~\text{type}~~\Tid^?~~\X{ft}{:}\Tfunctype~\text{)}
+       &\Rightarrow& \X{ft} \\
+   \end{array}
+
+
+.. _text-typeuse:
+.. index:: type use
+   pair: text format; type use
+
+Type Uses
+~~~~~~~~~
+
+A *type use* is a reference to a :ref:`type definition <text-type>`.
+It may optionally be augmented by explicit inlined :ref:`parameter <text-param>` and :ref:`result <text-result>` declarations.
+That allows binding symbolic :ref:`identifiers <text-id>` to name the :ref:`local indices <text-localidx>` of parameters.
+If inline declarations are given, then their types must match the referenced :ref:`function type <text-type>`.
+
+.. math::
+   \begin{array}{llcllll}
+   \production{type use} & \Ttypeuse_I &::=&
+     \text{(}~\text{type}~~x{:}\Ttypeidx_I~\text{)}
+       &\Rightarrow& x, I' &
+       (\begin{array}[t]{@{}l@{}}
+        I.\TYPEDEFS[x] = [t_1^n] \to [t_2^\ast] \wedge
+        I' = \{\LOCALS~(\epsilon)^n\}) \\
+        \end{array} \\ &&|&
+     \text{(}~\text{type}~~x{:}\Ttypeidx_I~\text{)}
+     ~~(t_1{:}\Tparam)^\ast~~(t_2{:}\Tresult)^\ast
+       &\Rightarrow& x, I' &
+       (\begin{array}[t]{@{}l@{}}
+        I.\TYPEDEFS[x] = [t_1^\ast] \to [t_2^\ast] \wedge
+        I' = \{\LOCALS~\F{id}(\Tparam)\}^\ast \idcwellformed) \\
+        \end{array} \\
+   \end{array}
+
+The resulting attribute of a |Ttypeuse| is a pair consisting of both the used :ref:`type index <syntax-typeidx>` and the updated :ref:`identifier context <text-context>` including possible parameter identifiers.
+The following auxiliary notation extracts optional identifiers from parameters:
+
+.. math::
+   \begin{array}{lcl@{\qquad\qquad}l}
+   \F{id}(\text{(}~\text{param}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\
+   \end{array}
+
+.. note::
+   Both productions overlap for the case that the function type is :math:`[] \to []`.
+   However, in that case, they also produce the same results, so that the choice is immaterial.
+
+   The :ref:`well-formedness <text-context-wf>` condition on :math:`I'` ensures that the parameters do not contain duplicate identifier.
+
+
+.. _text-typeuse-abbrev:
+
+Abbreviations
+.............
+
+A |Ttypeuse| may also be replaced entirely by inline :ref:`parameter <text-param>` and :ref:`result <text-result>` declarations.
+In that case, a :ref:`type index <syntax-typeidx>` is automatically inserted:
+
+.. math::
+   \begin{array}{llclll}
+   \production{type use} &
+     (t_1{:}\Tparam)^\ast~~(t_2{:}\Tresult)^\ast &\equiv&
+     \text{(}~\text{type}~~x~\text{)}~~\Tparam^\ast~~\Tresult^\ast \\
+   \end{array}
+
+where :math:`x` is the smallest existing :ref:`type index <syntax-typeidx>` whose definition in the current module is the :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]`.
+If no such index exists, then a new :ref:`type definition <text-type>` of the form
+
+.. math::
+   \text{(}~\text{type}~~\text{(}~\text{func}~~\Tparam^\ast~~\Tresult~\text{)}~\text{)}
+
+is first inserted at the end of the module.
+
+.. note::
+   Abbreviations are expanded in the order they appear, such that previously inserted type definitions are reused by consecutive expansions.
+
+
+.. _text-import:
+.. index:: import, name, function type, table type, memory type, global type
+   pair: text format; import
+
+Imports
+~~~~~~~
+
+The descriptors in imports can bind a symbolic function, table, memory, or global :ref:`identifier <text-id>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{import} & \Timport_I &::=&
+     \text{(}~\text{import}~~\X{mod}{:}\Tname~~\X{nm}{:}\Tname~~d{:}\Timportdesc_I~\text{)}
+       &\Rightarrow& \{ \MODULE~\X{mod}, \NAME~\X{nm}, \DESC~d \} \\
+   \production{import description} & \Timportdesc_I &::=&
+     \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~\text{)}
+       &\Rightarrow& \FUNC~x \\ &&|&
+     \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype~\text{)}
+       &\Rightarrow& \TABLE~\X{tt} \\ &&|&
+     \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype~\text{)}
+       &\Rightarrow& \MEM~~\X{mt} \\ &&|&
+     \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype~\text{)}
+       &\Rightarrow& \GLOBAL~\X{gt} \\
+   \end{array}
+
+
+Abbreviations
+.............
+
+As an abbreviation, imports may also be specified inline with :ref:`function <text-func>`, :ref:`table <text-table>`, :ref:`memory <text-mem>`, or :ref:`global <text-global>` definitions; see the respective sections.
+
+
+
+.. _text-func:
+.. _text-local:
+.. index:: function, type index, function type, identifier, local
+   pair: text format; function
+   pair: text format; local
+
+Functions
+~~~~~~~~~
+
+Function definitions can bind a symbolic :ref:`function identifier <text-id>`, and :ref:`local identifiers <text-id>` for its :ref:`parameters <text-typeuse>` and locals.
+
+.. math::
+   \begin{array}{llclll}
+   \production{function} & \Tfunc_I &::=&
+     \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~~
+     (t{:}\Tlocal)^\ast~~(\X{in}{:}\Tinstr_{I''})^\ast~\text{)}
+       &\Rightarrow& \{ \TYPE~x, \LOCALS~t^\ast, \BODY~\X{in}^\ast~\END \} \\ &&&&& \qquad
+       (I'' = I' \compose \{\LOCALS~\F{id}(\Tlocal)^\ast\} \idcwellformed) \\
+   \production{local} & \Tlocal &::=&
+     \text{(}~\text{local}~~\Tid^?~~t{:}\Tvaltype~\text{)}
+       &\Rightarrow& t \\
+   \end{array}
+
+The definition of the local :ref:`identifier context <text-context>` :math:`I''` uses the following auxiliary notation to extract optional identifiers from locals:
+
+.. math::
+   \begin{array}{lcl@{\qquad\qquad}l}
+   \F{id}(\text{(}~\text{local}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\
+   \end{array}
+
+
+.. note::
+   The :ref:`well-formedness <text-context-wf>` condition on :math:`I''` ensures that parameters and locals do not contain duplicate identifiers.
+
+
+.. _text-func-abbrev:
+.. index:: import, name
+   pair: text format; import
+.. index:: export, name, index, function index
+   pair: text format; export
+
+Abbreviations
+.............
+
+Multiple anonymous locals may be combined into a single declaration:
+
+.. math::
+   \begin{array}{llclll}
+   \production{local} &
+     \text{(}~~\text{local}~~\Tvaltype^\ast~~\text{)} &\equiv&
+     (\text{(}~~\text{local}~~\Tvaltype~~\text{)})^\ast \\
+   \end{array}
+
+Moreover, functions can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
+
+.. math::
+   \begin{array}{llclll}
+   \production{module field} &
+     \text{(}~\text{func}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Ttypeuse~\text{)} &\equiv&
+       \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{func}~~\Tid^?~~\Ttypeuse~\text{)}~\text{)} \\ &
+     \text{(}~\text{func}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv&
+       \text{(}~\text{export}~~\Tname~~\text{(}~\text{func}~~\Tid'~\text{)}~\text{)}~~
+       \text{(}~\text{func}~~\Tid'~~\dots~\text{)}
+       \\&&& \qquad
+       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+   \end{array}
+
+The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export.
+
+
+.. _text-table:
+.. index:: table, table type, identifier
+   pair: text format; table
+
+Tables
+~~~~~~
+
+Table definitions can bind a symbolic :ref:`table identifier <text-id>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{table} & \Ttable_I &::=&
+     \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype~\text{)}
+       &\Rightarrow& \{ \TYPE~\X{tt} \} \\
+   \end{array}
+
+
+.. _text-table-abbrev:
+.. index:: import, name
+   pair: text format; import
+.. index:: export, name, index, table index
+   pair: text format; export
+.. index:: element, table index, function index
+   pair: text format; element
+   single: table; element
+   single: element; segment
+
+Abbreviations
+.............
+
+An :ref:`element segment <text-elem>` can be given inline with a table definition, in which case the :ref:`limits <text-limits>` of the :ref:`table type <text-tabletype>` are inferred from the length of the given segment:
+
+.. math::
+   \begin{array}{llclll}
+   \production{module field} &
+     \text{(}~\text{table}~~\Tid^?~~\Telemtype~~\text{(}~\text{elem}~~x^n{:}\Tvec(\Tfuncidx)~\text{)}~~\text{)} &\equiv&
+       \text{(}~\text{table}~~\Tid'~~n~~n~~\Telemtype~\text{)}~~
+       \text{(}~\text{elem}~~\Tid'~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tvec(\Tfuncidx)~\text{)}
+       \\&&& \qquad
+       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+   \end{array}
+
+Moreover, tables can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
+
+.. math::
+   \begin{array}{llclll}
+   \production{module field} &
+     \text{(}~\text{table}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Ttabletype~\text{)} &\equiv&
+       \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{table}~~\Tid^?~~\Ttabletype~\text{)}~\text{)} \\ &
+     \text{(}~\text{table}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv&
+       \text{(}~\text{export}~~\Tname~~\text{(}~\text{table}~~\Tid'~\text{)}~\text{)}~~
+       \text{(}~\text{table}~~\Tid'~~\dots~\text{)}
+       \\&&& \qquad
+       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+   \end{array}
+
+The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline elements segment.
+
+
+.. _text-mem:
+.. index:: memory, memory type, identifier
+   pair: text format; memory
+
+Memories
+~~~~~~~~
+
+Memory definitions can bind a symbolic :ref:`memory identifier <text-id>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{memory} & \Tmem_I &::=&
+     \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype~\text{)}
+       &\Rightarrow& \{ \TYPE~\X{mt} \} \\
+   \end{array}
+
+
+.. _text-mem-abbrev:
+.. index:: import, name
+   pair: text format; import
+.. index:: export, name, index, memory index
+   pair: text format; export
+.. index:: data, memory, memory index, expression, byte, page size
+   pair: text format; data
+   single: memory; data
+   single: data; segment
+
+Abbreviations
+.............
+
+A :ref:`data segment <text-data>` can be given inline with a memory definition, in which case the :ref:`limits <text-limits>` of the :ref:`memory type <text-memtype>` are inferred from the length of the data, rounded up to :ref:`page size <page-size>`:
+
+.. math::
+   \begin{array}{llclll}
+   \production{module field} &
+     \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{data}~~b^n{:}\Tdatastring~\text{)}~~\text{)} &\equiv&
+       \text{(}~\text{memory}~~\Tid'~~m~~m~\text{)}~~
+       \text{(}~\text{data}~~\Tid'~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tdatastring~\text{)}
+       \\&&& \qquad
+       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh, m = \F{ceil}(n / 64\F{Ki})) \\
+   \end{array}
+
+Moreover, memories can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
+
+.. math::
+   \begin{array}{llclll}
+   \production{module field} &
+     \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Tmemtype~\text{)} &\equiv&
+       \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{memory}~~\Tid^?~~\Tmemtype~\text{)}~\text{)}
+       \\ &
+     \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv&
+       \text{(}~\text{export}~~\Tname~~\text{(}~\text{memory}~~\Tid'~\text{)}~\text{)}~~
+       \text{(}~\text{memory}~~\Tid'~~\dots~\text{)}
+       \\ &&& \qquad
+       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+   \end{array}
+
+The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline data segment.
+
+
+.. _text-global:
+.. index:: global, global type, identifier, expression
+   pair: text format; global
+
+Globals
+~~~~~~~
+
+Global definitions can bind a symbolic :ref:`global identifier <text-id>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{global} & \Tglobal_I &::=&
+     \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype~~e{:}\Texpr_I~\text{)}
+       &\Rightarrow& \{ \TYPE~\X{gt}, \INIT~e \} \\
+   \end{array}
+
+
+.. _text-global-abbrev:
+.. index:: import, name
+   pair: text format; import
+.. index:: export, name, index, global index
+   pair: text format; export
+
+Abbreviations
+.............
+
+Globals can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
+
+.. math::
+   \begin{array}{llclll}
+   \production{module field} &
+     \text{(}~\text{global}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Tglobaltype~\text{)} &\equiv&
+       \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{global}~~\Tid^?~~\Tglobaltype~\text{)}~\text{)}
+       \\ &
+     \text{(}~\text{global}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv&
+       \text{(}~\text{export}~~\Tname~~\text{(}~\text{global}~~\Tid'~\text{)}~\text{)}~~
+       \text{(}~\text{global}~~\Tid'~~\dots~\text{)}
+       \\ &&& \qquad
+       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+   \end{array}
+
+The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export.
+
+
+.. _text-export:
+.. index:: export, name, index, function index, table index, memory index, global index
+   pair: text format; export
+
+Exports
+~~~~~~~
+
+The syntax for exports mirrors their :ref:`abstract syntax <syntax-export>` directly.
+
+.. math::
+   \begin{array}{llclll}
+   \production{export} & \Texport_I &::=&
+     \text{(}~\text{export}~~\X{nm}{:}\Tname~~d{:}\Texportdesc_I~\text{)}
+       &\Rightarrow& \{ \NAME~\X{nm}, \DESC~d \} \\
+   \production{export description} & \Texportdesc_I &::=&
+     \text{(}~\text{func}~~x{:}\Bfuncidx_I~\text{)}
+       &\Rightarrow& \FUNC~x \\ &&|&
+     \text{(}~\text{table}~~x{:}\Btableidx_I~\text{)}
+       &\Rightarrow& \TABLE~x \\ &&|&
+     \text{(}~\text{memory}~~x{:}\Bmemidx_I~\text{)}
+       &\Rightarrow& \MEM~x \\ &&|&
+     \text{(}~\text{global}~~x{:}\Bglobalidx_I~\text{)}
+       &\Rightarrow& \GLOBAL~x \\
+   \end{array}
+
+
+Abbreviations
+.............
+
+As an abbreviation, exports may also be specified inline with :ref:`function <text-func>`, :ref:`table <text-table>`, :ref:`memory <text-mem>`, or :ref:`global <text-global>` definitions; see the respective sections.
+
+
+.. _text-start:
+.. index:: start function, function index
+   pair: text format; start function
+
+Start Function
+~~~~~~~~~~~~~~
+
+A :ref:`start function <syntax-start>` is defined in terms of its index.
+
+.. math::
+   \begin{array}{llclll}
+   \production{start function} & \Tstart_I &::=&
+     \text{(}~\text{start}~~x{:}\Tfuncidx_I~\text{)}
+       &\Rightarrow& \{ \FUNC~x \} \\
+   \end{array}
+
+.. note::
+   At most one start function may occur in a module,
+   which is ensured by a suitable side condition on the |Tmodule| grammar.
+
+
+
+.. _text-elem:
+.. index:: element, table index, expression, function index
+   pair: text format; element
+   single: table; element
+   single: element; segment
+
+Element Segments
+~~~~~~~~~~~~~~~~
+
+Element segments allow for an optional :ref:`table index <text-tableidx>` to identify the table to initialize.
+When omitted, :math:`\T{0}` is assumed.
+
+.. math::
+   \begin{array}{llclll}
+   \production{element segment} & \Telem_I &::=&
+     \text{(}~\text{elem}~~(x{:}\Ttableidx_I)^?~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~y^\ast{:}\Tvec(\Tfuncidx_I)~\text{)}
+       &\Rightarrow& \{ \TABLE~x', \OFFSET~e, \INIT~y^\ast \} \\
+       &&&&& \qquad (x' = x^? \neq \epsilon \vee x' = 0) \\
+   \end{array}
+
+.. note::
+   In the current version of WebAssembly, the only valid table index is 0
+   or a symbolic :ref:`table identifier <text-id>` resolving to the same value.
+
+
+Abbreviations
+.............
+
+As an abbreviation, element segments may also be specified inline with :ref:`table <text-table>` definitions; see the respective section.
+
+
+.. _text-data:
+.. _text-datastring:
+.. index:: data, memory, memory index, expression, byte
+   pair: text format; data
+   single: memory; data
+   single: data; segment
+
+Data Segments
+~~~~~~~~~~~~~
+
+Data segments allow for an optional :ref:`memory index <text-memidx>` to identify the memory to initialize.
+When omitted, :math:`\T{0}` is assumed.
+The data is written as a :ref:`string <text-string>`, which may be split up into a possibly empty sequence of individual string literals.
+
+.. math::
+   \begin{array}{llclll}
+   \production{data segment} & \Tdata_I &::=&
+     \text{(}~\text{data}~~(x{:}\Tmemidx_I)^?~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~b^\ast{:}\Tdatastring~\text{)}
+       &\Rightarrow& \{ \MEM~x', \OFFSET~e, \INIT~b^\ast \} \\
+       &&&&& \qquad (x' = x^? \neq \epsilon \vee x' = 0) \\
+   \production{data string} & \Tdatastring &::=&
+     (b^\ast{:}\Tstring)^\ast &\Rightarrow& \concat((b^\ast)^\ast) \\
+   \end{array}
+
+.. note::
+   In the current version of WebAssembly, the only valid memory index is 0
+   or a symbolic :ref:`memory identifier <text-id>` resolving to the same value.
+
+
+Abbreviations
+.............
+
+As an abbreviation, data segments may also be specified inline with :ref:`memory <text-mem>` definitions; see the respective section.
+
+
+.. _text-module:
+.. _text-modulebody:
+.. _text-modulefield:
+.. index:: module, type definition, function type, function, table, memory, global, element, data, start function, import, export, identifier context, identifier, name section
+   pair: text format; module
+   single: section; name
+
+Modules
+~~~~~~~
+
+A module consists of a sequence of fields that can occur in any order.
+All definitions and their respective bound :ref:`identifiers <text-id>` scope over the entire module, including the text preceding them.
+
+A module may optionally bind an :ref:`identifier <text-id>` that names the module.
+The name serves a documentary role only.
+
+.. note::
+   Tools may include the module name in the :ref:`name section <binary-namesec>` of the :ref:`binary format <binary>`.
+
+.. math::
+   \begin{array}{lll}
+   \production{module} & \Tmodule &
+   \begin{array}[t]{@{}cllll}
+   ::=&
+     \text{(}~\text{module}~~\Tid^?~~(m{:}\Tmodulefield_I)^\ast~\text{)}
+       &\Rightarrow& \bigcompose m^\ast
+       & (I = \bigcompose \F{idc}(\Tmodulefield)^\ast \idcwellformed) \\
+   \end{array} \\
+   \production{module field} & \Tmodulefield_I &
+   \begin{array}[t]{@{}clll}
+   ::=&
+     \X{ty}{:}\Ttype &\Rightarrow& \{\TYPES~\X{ty}\} \\ |&
+     \X{im}{:}\Timport_I &\Rightarrow& \{\IMPORTS~\X{im}\} \\ |&
+     \X{fn}{:}\Tfunc_I &\Rightarrow& \{\FUNCS~\X{fn}\} \\ |&
+     \X{ta}{:}\Ttable_I &\Rightarrow& \{\TABLES~\X{ta}\} \\ |&
+     \X{me}{:}\Tmem_I &\Rightarrow& \{\MEMS~\X{me}\} \\ |&
+     \X{gl}{:}\Tglobal_I &\Rightarrow& \{\GLOBALS~\X{gl}\} \\ |&
+     \X{ex}{:}\Texport_I &\Rightarrow& \{\EXPORTS~\X{ex}\} \\ |&
+     \X{st}{:}\Tstart_I &\Rightarrow& \{\START~\X{st}\} \\ |&
+     \X{el}{:}\Telem_I &\Rightarrow& \{\ELEM~\X{el}\} \\ |&
+     \X{da}{:}\Tdata_I &\Rightarrow& \{\DATA~\X{da}\} \\
+   \end{array}
+   \end{array}
+
+The following restrictions are imposed on the composition of :ref:`modules <syntax-module>`: :math:`m_1 \compose m_2` is defined if and only if
+
+* :math:`m_1.\START = \epsilon \vee m_2.\START = \epsilon`
+
+* :math:`m_2.\IMPORTS = \epsilon \vee m_1.\FUNCS = m_1.\TABLES = m_1.\MEMS = m_1.\GLOBALS = \epsilon`
+
+.. note::
+   The first condition ensures that there is at most one start function.
+   The second condition enforces that all :ref:`imports <text-import>` must occur before any regular definition of a :ref:`function <text-func>`, :ref:`table <text-table>`, :ref:`memory <text-mem>`, or :ref:`global <text-global>`,
+   thereby maintaining the ordering of the respective :ref:`index spaces <syntax-index>`.
+
+   The :ref:`well-formedness <text-context-wf>` condition on :math:`I` in the grammar for |Tmodule| ensures that no namespace contains duplicate identifiers.
+
+The definition of the initial :ref:`identifier context <text-context>` :math:`I` uses the following auxiliary definition which maps each relevant definition to a singular context with one (possibly empty) identifier:
+
+.. math::
+   \begin{array}{@{}lcl@{\qquad\qquad}l}
+   \F{idc}(\text{(}~\text{type}~\Tid^?~\X{ft}{:}\Tfunctype~\text{)}) &=&
+     \{\TYPES~(\Tid^?), \TYPEDEFS~\X{ft}\} \\
+   \F{idc}(\text{(}~\text{func}~\Tid^?~\dots~\text{)}) &=&
+     \{\FUNCS~(\Tid^?)\} \\
+   \F{idc}(\text{(}~\text{table}~\Tid^?~\dots~\text{)}) &=&
+     \{\TABLES~(\Tid^?)\} \\
+   \F{idc}(\text{(}~\text{memory}~\Tid^?~\dots~\text{)}) &=&
+     \{\MEMS~(\Tid^?)\} \\
+   \F{idc}(\text{(}~\text{global}~\Tid^?~\dots~\text{)}) &=&
+     \{\GLOBALS~(\Tid^?)\} \\
+   \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{func}~\Tid^?~\dots~\text{)}~\text{)}) &=&
+     \{\FUNCS~(\Tid^?)\} \\
+   \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{table}~\Tid^?~\dots~\text{)}~\text{)}) &=&
+     \{\TABLES~(\Tid^?)\} \\
+   \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{memory}~\Tid^?~\dots~\text{)}~\text{)}) &=&
+     \{\MEMS~(\Tid^?)\} \\
+   \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{global}~\Tid^?~\dots~\text{)}~\text{)}) &=&
+     \{\GLOBALS~(\Tid^?)\} \\
+   \F{idc}(\text{(}~\dots~\text{)}) &=&
+     \{\} \\
+   \end{array}
+
+
+.. math
+   \F{idc}(\epsilon) &=&
+     \{\} \\
+   \F{idc}(\Tmodulebody~\Tmodulefield) &=&
+     \F{idc}(\Tmodulebody) \compose \F{idc}(\Tmodulefield) \\[1ex]
+
+   The definition of the :ref:`identifier context <text-context>` :math:`I` uses the following auxiliary notation to filters out optional identifiers from definitions and imports in an order-preserving fashion:
+
+   \begin{array}{@{}l@{}}
+   \begin{array}{@{}lcl@{\qquad\qquad}l}
+   \F{id}(\text{(}~\text{type}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\
+   \F{id}(\text{(}~\text{func}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\
+   \F{id}(\text{(}~\text{table}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\
+   \F{id}(\text{(}~\text{memory}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\
+   \F{id}(\text{(}~\text{global}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\[1ex]
+   \F{funcids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{func}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\
+   \F{tableids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{table}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\
+   \F{memids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{memory}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\
+   \F{globalids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{global}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\
+   \end{array} \\
+   \F{desc}(\text{(}~\text{import}~\dots~\Timportdesc~\text{)}) \quad=\quad \Timportdesc
+   \end{array}
+
+
+Abbreviations
+.............
+
+In a source file, the toplevel :math:`\T{(module}~\dots\T{)}` surrounding the module body may be omitted.
+
+.. math::
+   \begin{array}{llcll}
+   \production{module} &
+     \Tmodulefield^\ast &\equiv&
+     \text{(}~\text{module}~~\Tmodulefield^\ast~\text{)}
+   \end{array}
diff --git a/document/text/types.rst b/document/text/types.rst
new file mode 100644
index 000000000..78b02183e
--- /dev/null
+++ b/document/text/types.rst
@@ -0,0 +1,143 @@
+.. _text-type:
+.. index:: type
+   pair: text format; type
+
+Types
+-----
+
+.. _text-valtype:
+.. index:: value type
+   pair: text format; value type
+
+Value Types
+~~~~~~~~~~~
+
+.. math::
+   \begin{array}{llcll@{\qquad\qquad}l}
+   \production{value type} & \Tvaltype &::=&
+     \text{i32} &\Rightarrow& \I32 \\ &&|&
+     \text{i64} &\Rightarrow& \I64 \\ &&|&
+     \text{f32} &\Rightarrow& \F32 \\ &&|&
+     \text{f64} &\Rightarrow& \F64 \\
+   \end{array}
+
+
+.. _text-resulttype:
+.. index:: result type, value type
+   pair: text format; result type
+
+Result Types
+~~~~~~~~~~~~
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{result type} & \Tresulttype &::=&
+     (t{:}\Tresult)^? &\Rightarrow& [t^?] \\
+   \end{array}
+
+.. note::
+   In future versions of WebAssembly, this scheme may be extended to support multiple results or more general result types.
+
+
+.. _text-functype:
+.. _text-param:
+.. _text-result:
+.. index:: function type, value type, result type
+   pair: text format; function type
+
+Function Types
+~~~~~~~~~~~~~~
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{function type} & \Tfunctype &::=&
+     \text{(}~\text{func}~~t_1^\ast{:\,}\Tvec(\Tparam)~~t_2^\ast{:\,}\Tvec(\Tresult)~\text{)}
+       &\Rightarrow& [t_1^\ast] \to [t_2^\ast] \\
+   \production{parameter} & \Tparam &::=&
+     \text{(}~\text{param}~~\Tid^?~~t{:}\Tvaltype~\text{)}
+       &\Rightarrow& t \\
+   \production{result} & \Tresult &::=&
+     \text{(}~\text{result}~~t{:}\Tvaltype~\text{)}
+       &\Rightarrow& t \\
+   \end{array}
+
+Abbreviations
+.............
+
+Multiple anonymous parameters or results may be combined into a single declaration:
+
+.. math::
+   \begin{array}{llclll}
+   \production{parameter} &
+     \text{(}~~\text{param}~~\Tvaltype^\ast~~\text{)} &\equiv&
+     (\text{(}~~\text{param}~~\Tvaltype~~\text{)})^\ast \\
+   \production{result} &
+     \text{(}~~\text{result}~~\Tvaltype^\ast~~\text{)} &\equiv&
+     (\text{(}~~\text{result}~~\Tvaltype~~\text{)})^\ast \\
+   \end{array}
+
+
+.. _text-limits:
+.. index:: limits
+   pair: text format; limits
+
+Limits
+~~~~~~
+
+.. math::
+    \begin{array}{llclll}
+    \production{limits} & \Tlimits &::=&
+      n{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~\epsilon \} \\ &&|&
+      n{:}\Tu32~~m{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~m \} \\
+    \end{array}
+
+
+.. _text-memtype:
+.. index:: memory type, limits, page size
+   pair: text format; memory type
+
+Memory Types
+~~~~~~~~~~~~
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{memory type} & \Tmemtype &::=&
+     \X{lim}{:}\Tlimits &\Rightarrow& \X{lim} \\
+   \end{array}
+
+
+.. _text-tabletype:
+.. _text-elemtype:
+.. index:: table type, element type, limits
+   pair: text format; table type
+   pair: text format; element type
+
+Table Types
+~~~~~~~~~~~
+
+.. math::
+   \begin{array}{llclll}
+   \production{table type} & \Ttabletype &::=&
+     \X{lim}{:}\Tlimits~~\X{et}{:}\Telemtype &\Rightarrow& \X{lim}~\X{et} \\
+   \production{element type} & \Telemtype &::=&
+     \text{anyfunc} &\Rightarrow& \ANYFUNC \\
+   \end{array}
+
+.. note::
+   Additional element types may be introduced in future versions of WebAssembly.
+
+
+.. _text-globaltype:
+.. index:: global type, mutability, value type
+   pair: text format; global type
+   pair: text format; mutability
+
+Global Types
+~~~~~~~~~~~~
+
+.. math::
+   \begin{array}{llclll}
+   \production{global type} & \Tglobaltype &::=&
+     t{:}\Tvaltype &\Rightarrow& \MCONST~t \\ &&|&
+     \text{(}~\text{mut}~~t{:}\Tvaltype~\text{)} &\Rightarrow& \MVAR~t \\
+   \end{array}
diff --git a/document/text/values.rst b/document/text/values.rst
new file mode 100644
index 000000000..77ae23684
--- /dev/null
+++ b/document/text/values.rst
@@ -0,0 +1,259 @@
+.. _text-value:
+.. index:: value
+   pair: text format; value
+
+Values
+------
+
+The grammar productions in this section define *lexical syntax*,
+hence no :ref:`white space <text-space>` is allowed.
+
+
+.. _text-sign:
+.. _text-digit:
+.. _text-hexdigit:
+.. _text-int:
+.. _text-sint:
+.. _text-uint:
+.. index:: integer, unsigned integer, signed integer, uninterpreted integer
+   pair: text format; integer
+   pair: text format; unsigned integer
+   pair: text format; signed integer
+   pair: text format; uninterpreted integer
+
+Integers
+~~~~~~~~
+
+All :ref:`integers <syntax-int>` can be written in either decimal or hexadecimal notation.
+
+.. math::
+   \begin{array}{llclll@{\qquad}l}
+   \production{sign} & \Tsign &::=&
+     \epsilon \Rightarrow {+}1 ~~|~~
+     \text{+} \Rightarrow {+}1 ~~|~~
+     \text{-} \Rightarrow {-}1 \\
+   \production{decimal digit} & \Tdigit &::=&
+     \text{0} \Rightarrow 0 ~~|~~ \dots ~~|~~ \text{9} \Rightarrow 9 \\
+   \production{hexadecimal digit} & \Thexdigit &::=&
+     d{:}\Tdigit \Rightarrow d \\ &&|&
+     \text{A} \Rightarrow 10 ~~|~~ \dots ~~|~~ \text{F} \Rightarrow 15 \\ &&|&
+     \text{a} \Rightarrow 10 ~~|~~ \dots ~~|~~ \text{f} \Rightarrow 15 \\
+   \end{array}
+
+.. math::
+   \begin{array}{llclll@{\qquad}l}
+   \production{decimal number} & \Tnum &::=&
+     d{:}\Tdigit &\Rightarrow& d \\ &&|&
+     n{:}\Tnum~~d{:}\Tdigit &\Rightarrow& 10\cdot n + d \\
+   \production{hexadecimal number} & \Thexnum &::=&
+     h{:}\Thexdigit &\Rightarrow& h \\ &&|&
+     n{:}\Thexnum~~h{:}\Thexdigit &\Rightarrow& 16\cdot n + h \\
+   \end{array}
+
+The allowed syntax for integer literals depends on size and signedness.
+Moreover, their value must lie within the range of the respective type.
+
+.. math::
+   \begin{array}{llclll@{\qquad}l}
+   \production{unsigned integer} & \TuN &::=&
+     n{:}\Tnum &\Rightarrow& n & (n < 2^N) \\ &&|&
+     \text{0x}~~n{:}\Thexnum &\Rightarrow& n & (n < 2^N) \\
+   \production{signed integer} & \TsN &::=&
+     s{:}\Tsign~~n{:}\Tnum &\Rightarrow& s\cdot n & (-2^{N-1} \leq s\cdot n < 2^{N-1}) \\ &&|&
+     s{:}\Tsign~~\text{0x}~~n{:}\Thexnum &\Rightarrow& s\cdot n & (-2^{N-1} \leq s\cdot n < 2^{N-1}) \\
+   \end{array}
+
+:ref:`Uninterpreted integers <syntax-int>` can be written as either signed or unsigned, and are normalized to unsigned in the abstract syntax.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{uninterpreted integers} & \TiN &::=&
+     n{:}\TuN &\Rightarrow& n \\ &&|&
+     i{:}\TsN &\Rightarrow& n & (i = \signed(n)) \\
+   \end{array}
+
+
+.. _text-frac:
+.. _text-hexfrac:
+.. _text-float:
+.. _text-hexfloat:
+.. index:: floating-point number
+   pair: text format; floating-point number
+
+Floating-Point
+~~~~~~~~~~~~~~
+
+:ref:`Floating point <syntax-float>` values can be represented in either decimal or hexadecimal notation.
+The value of a literal must not lie outside the representable range of the corresponding `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ type
+(that is, a numeric value must not overflow to :math:`\pm\mbox{infinity}`),
+but it may be rounded to the nearest representable value.
+
+.. note::
+   Rounding can be prevented by using hexadecimal notation with no more significant bits than supported by the required type.
+
+Floating-point values may also be written as constants for *infinity* or *canonical NaN* (*not a number*).
+Furthermore, arbitrary NaN values may be expressed by providing an explicit payload value.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{decimal floating-point fraction} & \Tfrac &::=&
+     \epsilon &\Rightarrow& 0 \\ &&|&
+     d{:}\Tdigit~q{:}\Tfrac &\Rightarrow& (d+q)/10 \\
+   \production{hexadecimal floating-point fraction} & \Thexfrac &::=&
+     \epsilon &\Rightarrow& 0 \\ &&|&
+     h{:}\Thexdigit~q{:}\Thexfrac &\Rightarrow& (h+q)/16 \\
+   \production{decimal floating-point number} & \Tfloat &::=&
+     s{:}\Tsign~p{:}\Tnum~\text{.}~q{:}\Tfrac
+       &\Rightarrow& s\cdot(p+q) \\ &&|&
+     s{:}\Tsign~p{:}\Tnum~(\text{E}~|~\text{e})~t{:}\Tsign~e{:}\Tnum
+       &\Rightarrow& s\cdot p\cdot 10^{t\cdot e} \\ &&|&
+     s{:}\Tsign~p{:}\Tnum~\text{.}~q{:}\Tfrac~(\text{E}~|~\text{e})~t{:}\Tsign~e{:}\Tnum
+       &\Rightarrow& s\cdot(p+q)\cdot 10^{t\cdot e} \\
+   \production{hexadecimal floating-point number} & \Thexfloat &::=&
+     s{:}\Tsign~\text{0x}~p{:}\Thexnum~\text{.}~q{:}\Thexfrac
+       &\Rightarrow& s\cdot(p+q) \\ &&|&
+     s{:}\Tsign~\text{0x}~p{:}\Thexnum~(\text{P}~|~\text{p})~t{:}\Tsign~e{:}\Tnum
+       &\Rightarrow& s\cdot p\cdot 2^{t\cdot e} \\ &&|&
+     s{:}\Tsign~\text{0x}~p{:}\Thexnum~\text{.}~q{:}\Thexfrac~(\text{P}~|~\text{p})~t{:}\Tsign~e{:}\Tnum
+       &\Rightarrow& s\cdot(p+q)\cdot 2^{t\cdot e} \\
+   \production{floating-point value} & \TfN &::=&
+     z{:}\Tfloat &\Rightarrow& \ieee_N(z) \\ &&|&
+     z{:}\Thexfloat &\Rightarrow& \ieee_N(z) \\ &&|&
+     s{:}\Tsign~\text{inf} &\Rightarrow& \ieeeinf_N(s) \\ &&|&
+     s{:}\Tsign~\text{nan} &\Rightarrow& \ieeenan_N(s, 0) \\ &&|&
+     s{:}\Tsign~\text{nan{:}}~\text{0x}~n{:}\Thexnum &\Rightarrow& b^\ast & (\ieeenan_N(s, n) = b^\ast) \\
+   \end{array}
+
+.. todo:: IEEE encoding helper functions
+
+
+.. _text-vec:
+.. index:: vector
+   pair: text format; vector
+
+Vectors
+~~~~~~~
+
+:ref:`Vectors <syntax-vec>` are written as plain sequences, but with restricted length.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{vector} & \Tvec(\T{A}) &::=&
+     (x{:}\T{A})^n &\Rightarrow& x^n & (n < 2^{32}) \\
+   \end{array}
+
+
+.. _text-byte:
+.. _text-string:
+.. index:: ! string, byte, character, ASCII, Unicode, UTF-8
+   pair: text format; byte
+   pair: text format; string
+
+Strings
+~~~~~~~
+
+*Strings* denote sequences of bytes that can represent both textual and binary data.
+They are enclosed in quotation marks
+and may contain any character other than `ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ control characters, quotation marks (:math:`\text{"}`), or backslash (:math:`\text{\backslash}`),
+except when expressed with an *escape sequence*.
+
+Each character in a string literal represents the byte sequence corresponding to its `Unicode <http://www.unicode.org/versions/latest/>`_ UTF-8 encoding,
+except for hexadecimal escape sequences :math:`\text{\backslash}hh`, which represent raw bytes of the respective value.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{string} & \Tstring &::=&
+     \text{"}~(b^\ast{:}\Tstringelem)^\ast~\text{"}
+       &\Rightarrow& \concat((b^\ast)^\ast)
+       & (|\concat((b^\ast)^\ast)| < 2^{32}) \\
+   \production{string element} & \Tstringelem &::=&
+     c{:}\Tstringchar &\Rightarrow& \utf8(c) \\ &&|&
+     \text{\backslash}~n{:}\Thexdigit~m{:}\Thexdigit
+       &\Rightarrow& 16\cdot n+m \\
+   \production{string character} & \Tstringchar &::=&
+     c{:}\Tchar &\Rightarrow& c \qquad
+       & (c \geq \unicode{20} \wedge c \neq \unicode{7F} \wedge c \neq \text{"} c \neq \text{\backslash}) \\ &&|&
+     \text{\backslash t} &\Rightarrow& \unicode{09} \\ &&|&
+     \text{\backslash n} &\Rightarrow& \unicode{0A} \\ &&|&
+     \text{\backslash r} &\Rightarrow& \unicode{0D} \\ &&|&
+     \text{\backslash{"}} &\Rightarrow& \unicode{22} \\ &&|&
+     \text{\backslash{'}} &\Rightarrow& \unicode{27} \\ &&|&
+     \text{\backslash\backslash} &\Rightarrow& \unicode{5C} \\ &&|&
+     \text{\backslash u\{}~n{:}\Thexnum~\text{\}}
+       &\Rightarrow& \unicode{(n)} & (n < \hex{D800} \vee \hex{E000} \leq n < \hex{110000}) \\
+   \end{array}
+
+
+.. _text-name:
+.. index:: name, byte, character, code point
+   pair: text format; name
+
+Names
+~~~~~
+
+:ref:`Names <syntax-name>` are strings denoting a literal character sequence. 
+A name string must form a valid `UTF-8 <http://www.unicode.org/versions/latest/>`_ encoding that is interpreted as a string of Unicode code points.
+
+.. math::
+   \begin{array}{llclll@{\qquad}l}
+   \production{name} & \Tname &::=&
+     b^\ast{:}\Tstring &\Rightarrow& c^\ast & (b^\ast = \utf8(c^\ast)) \\
+   \end{array}
+
+.. note::
+   Presuming the source text is itself encoded correctly,
+   strings that do not contain any uses of hexadecimal byte escapes are always valid names.
+
+
+.. _text-id:
+.. index:: ! identifiers
+   pair: text format; identifiers
+
+Identifiers
+~~~~~~~~~~~
+
+:ref:`Indices <syntax-index>` can be given in both numeric and symbolic form.
+Symbolic *identifiers* that stand in lieu of indices start with :math:`\text{\$}`, followed by any sequence of printable `ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ characters that does not contain a space, quotation mark, comma, semicolon, or bracket.
+
+.. math::
+   \begin{array}{llclll@{\qquad}l}
+   \production{identifier} & \Tid &::=&
+     \text{\$}~\Tidchar^+ \\
+   \production{identifier character} & \Tidchar &::=&
+     \text{0} ~~|~~ \dots ~~|~~ \text{9} \\ &&|&
+     \text{A} ~~|~~ \dots ~~|~~ \text{Z} \\ &&|&
+     \text{a} ~~|~~ \dots ~~|~~ \text{z} \\ &&|&
+     \text{!} ~~|~~
+     \text{\#} ~~|~~
+     \text{\$} ~~|~~
+     \text{\%} ~~|~~
+     \text{\&} ~~|~~
+     \text{'} ~~|~~
+     \text{*} ~~|~~
+     \text{+} ~~|~~
+     \text{-} ~~|~~
+     \text{.} ~~|~~
+     \text{/} \\ &&|&
+     \text{:} ~~|~~
+     \text{<} ~~|~~
+     \text{=} ~~|~~
+     \text{>} ~~|~~
+     \text{?} ~~|~~
+     \text{@} ~~|~~
+     \text{\backslash} ~~|~~
+     \text{\hat{~~}} ~~|~~
+     \text{\_} ~~|~~
+     \text{\grave{~~}} ~~|~~
+     \text{|} ~~|~~
+     \text{\tilde{~~}} \\
+   \end{array}
+
+.. bla
+
+.. _text-id-fresh:
+
+Conventions
+...........
+
+The expansion rules of some abbreviations require insertion of a *fresh* identifier.
+That may be any syntactically valid identifier that does not already occur in the given source text.
diff --git a/document/validation/conventions.rst b/document/validation/conventions.rst
index 34c561d67..72a808f7b 100644
--- a/document/validation/conventions.rst
+++ b/document/validation/conventions.rst
@@ -41,7 +41,7 @@ which collects relevant information about the surrounding :ref:`module <syntax-m
 * *Labels*: the stack of labels accessible from the current position, represented by their result type.
 * *Return*: the return type of the current function, represented as a result type.
 
-In other words, a context contains a sequence of suitable :ref:`types <syntax-types>` for each :ref:`index space <syntax-index>`,
+In other words, a context contains a sequence of suitable :ref:`types <syntax-type>` for each :ref:`index space <syntax-index>`,
 describing each defined entry in that space.
 Locals, labels and return type are only used for validating :ref:`instructions <syntax-instr>` in :ref:`function bodies <syntax-func>`, and are left empty elsewhere.
 The label stack is the only part of the context that changes as validation of an instruction sequence proceeds.
diff --git a/document/validation/modules.rst b/document/validation/modules.rst
index 0fcab62e1..bd2e1bc32 100644
--- a/document/validation/modules.rst
+++ b/document/validation/modules.rst
@@ -29,6 +29,7 @@ Limits :math:`\{ \MIN~n, \MAX~m^? \}`
 
 
 .. _valid-func:
+.. _valid-local:
 .. index:: function, local, function index, local index, type index, function type, value type, expression, import
    pair: abstract syntax; function
    single: abstract syntax; function
diff --git a/interpreter/Makefile b/interpreter/Makefile
index 4aab91505..e92c9e5a3 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -95,24 +95,35 @@ $(WINMAKE):	clean
 		>>$@
 
 
-# Miscellaneous targets
+# Executing test suite
 
-.PHONY:		test clean
+.PHONY:		test debugtest
 
-$(ZIP):		$(WINMAKE)
-		git archive --format=zip --prefix=$(NAME)/ -o $@ HEAD
+test:		$(OPT)
+		../test/core/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',)
+debugtest:	$(UNOPT)
+		../test/core/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',)
 
-test:		$(NAME)
-		../test/core/run.py --wasm `pwd`/$(NAME) $(if $(JS),--js '$(JS)',)
+test/%:		$(OPT)
+		../test/core/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) $(@:test/%=../test/core/%.wast)
+debugtest/%:	$(UNOPT)
+		../test/core/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',) $(@:test/%=../test/core/%.wast)
 
-test/%:		$(NAME)
-		../test/core/run.py --wasm `pwd`/$(NAME) $(if $(JS),--js '$(JS)',) $(@:test/%=../test/core/%.wast)
+run/%:		$(OPT)
+		./$(OPT) $(@:run/%=../test/core/%.wast)
+debugrun/%:		$(UNOPT)
+		./$(UNOPT) $(@:run/%=../test/core/%.wast)
 
-run/%:		$(NAME)
-		./$(NAME) $(@:run/%=../test/core/%.wast)
+
+# Miscellaneous targets
+
+.PHONY:		clean
+
+$(ZIP):		$(WINMAKE)
+		git archive --format=zip --prefix=$(NAME)/ -o $@ HEAD
 
 clean:
-		rm -rf _build/jslib
+		rm -rf _build/jslib wasm.mlpack
 		$(OCB) -clean
 
 
diff --git a/interpreter/README.md b/interpreter/README.md
index c0b42b775..4fbff9b60 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -75,7 +75,7 @@ You can call the executable with
 wasm [option | file ...]
 ```
 
-where `file`, depending on its extension, either should be an S-expression script file (see below) to be run, or a binary module file to be loaded.
+where `file`, depending on its extension, either should be a binary (`.wasm`) or textual (`.wat`) module file to be loaded, or a script file (`.wast`, see below) to be run.
 
 By default, the interpreter validates all modules.
 The `-u` option selects "unchecked mode", which skips validation and runs code as is.
@@ -86,8 +86,8 @@ Runtime type errors will be captured and reported appropriately.
 A file prefixed by `-o` is taken to be an output file. Depending on its extension, this will write out the preceding module definition in either S-expression or binary format. This option can be used to convert between the two in both directions, e.g.:
 
 ```
-wasm -d module.wast -o module.wasm
-wasm -d module.wasm -o module.wast
+wasm -d module.wat -o module.wasm
+wasm -d module.wasm -o module.wat
 ```
 
 In the second case, the produced script contains exactly one module definition.
@@ -119,10 +119,10 @@ wasm module.wasm -e '(invoke "foo")'
 
 #### Interactive Mode
 
-If neither a file nor any of the previous options is given, you'll land in the REPL and can enter script commands interactively. You can also get into the REPL by explicitly passing `-` as a file name. You can do that in combination to giving a module file, so that you can then invoke its exports interactively, e.g.:
+If neither a file nor any of the previous options is given, you'll land in the REPL and can enter script commands interactively. You can also get into the REPL by explicitly passing `-` as a file name. You can do that in combination to giving a module or script file, so that you can then invoke its exports interactively, e.g.:
 
 ```
-wasm module.wast -
+wasm module.wat -
 ```
 
 See `wasm -h` for (the few) additional options.
@@ -167,7 +167,7 @@ The implementation consumes a WebAssembly AST given in S-expression syntax. Here
 value: <int> | <float>
 var: <int> | <name>
 name: $(<letter> | <digit> | _ | . | + | - | * | / | \ | ^ | ~ | = | < | > | ! | ? | @ | # | $ | % | & | | | : | ' | `)+
-string: "(<char> | \n | \t | \\ | \' | \" | \<hex><hex>)*"
+string: "(<char> | \n | \t | \\ | \' | \" | \<hex><hex> | \u{<hex>+})*"
 
 type: i32 | i64 | f32 | f64
 elem_type: anyfunc
@@ -180,7 +180,7 @@ offset: offset=<nat>
 align: align=(1|2|4|8|...)
 cvtop: trunc_s | trunc_u | extend_s | extend_u | ...
 
-block_sig : <type>*
+block_sig : ( result <type>* )*
 func_sig:   ( type <var> )? <param>* <result>*
 global_sig: <type> | ( mut <type> )
 table_sig:  <nat> <nat>? <elem_type>
@@ -188,20 +188,19 @@ memory_sig: <nat> <nat>?
 
 expr:
   ( <op> )
-  ( <op> <expr>+ )                                                   ;; = <expr>+ (<op>)
-  ( block <name>? <block_sig>? <instr>* )
-  ( loop <name>? <block_sig>? <instr>* )
-  ( if <name>? <block_sig>? ( then <instr>* ) ( else <instr>* )? )
-  ( if <name>? <block_sig>? <expr> ( then <instr>* ) ( else <instr>* )? ) ;; = (if <name>? <block_sig>? <expr> (then <instr>*) (else <instr>*)?)
-  ( if <name>? <block_sig>? <expr> <expr> <expr>? )                  ;; = (if <name>? <block_sig>? <expr> (then <expr>) (else <expr>?))
+  ( <op> <expr>+ )                                                  ;; = <expr>+ (<op>)
+  ( block <name>? <block_sig> <instr>* )
+  ( loop <name>? <block_sig> <instr>* )
+  ( if <name>? <block_sig> ( then <instr>* ) ( else <instr>* )? )
+  ( if <name>? <block_sig> <expr>+ ( then <instr>* ) ( else <instr>* )? ) ;; = <expr>+ (if <name>? <block_sig> (then <instr>*) (else <instr>*)?)
 
 instr:
   <expr>
-  <op>                                                               ;; = (<op>)
-  block <name>? <block_sig>? <instr>* end <name>?                    ;; = (block <name>? <block_sig>? <instr>*)
-  loop <name>? <block_sig>? <instr>* end <name>?                     ;; = (loop <name>? <block_sig>? <instr>*)
-  if <name>? <block_sig>? <instr>* end <name>?                       ;; = (if <name>? <block_sig>? (then <instr>*))
-  if <name>? <block_sig>? <instr>* else <name>? <instr>* end <name>? ;; = (if <name>? <block_sig>? (then <instr>*) (else <instr>*))
+  <op>                                                              ;; = (<op>)
+  block <name>? <block_sig> <instr>* end <name>?                    ;; = (block <name>? <block_sig> <instr>*)
+  loop <name>? <block_sig> <instr>* end <name>?                     ;; = (loop <name>? <block_sig> <instr>*)
+  if <name>? <block_sig> <instr>* end <name>?                       ;; = (if <name>? <block_sig> (then <instr>*))
+  if <name>? <block_sig> <instr>* else <name>? <instr>* end <name>? ;; = (if <name>? <block_sig> (then <instr>*) (else <instr>*))
 
 op:
   unreachable
@@ -231,25 +230,25 @@ op:
   <type>.<cvtop>/<type>
 
 func:    ( func <name>? <func_sig> <local>* <instr>* )
-         ( func <name>? ( export <string> ) <func_sig> <local>* <instr>* )  ;; = (export <string> (func <N>)) (func <name>? <func_sig> <local>* <instr>*)
+         ( func <name>? ( export <string> )+ <func_sig> <local>* <instr>* ) ;; = (export <string> (func <N>))+ (func <name>? <func_sig> <local>* <instr>*)
          ( func <name>? ( import <string> <string> ) <func_sig>)            ;; = (import <name>? <string> <string> (func <func_sig>))
 param:   ( param <type>* ) | ( param <name> <type> )
 result:  ( result <type> )
 local:   ( local <type>* ) | ( local <name> <type> )
 
 global:  ( global <name>? <global_sig> <instr>* )
-         ( global <name>? ( export <string> ) <global_sig> <instr>* )       ;; = (export <string> (global <N>)) (global <name>? <global_sig> <instr>*)
+         ( global <name>? ( export <string> )+ <global_sig> <instr>* )      ;; = (export <string> (global <N>))+ (global <name>? <global_sig> <instr>*)
          ( global <name>? ( import <string> <string> ) <global_sig> )       ;; = (import <name>? <string> <string> (global <global_sig>))
 table:   ( table <name>? <table_sig> )
-         ( table <name>? ( export <string> ) <table_sig> )                  ;; = (export <string> (table <N>)) (table <name>? <table_sig>)
+         ( table <name>? ( export <string> )+ <table_sig> )                 ;; = (export <string> (table <N>))+ (table <name>? <table_sig>)
          ( table <name>? ( import <string> <string> ) <table_sig> )         ;; = (import <name>? <string> <string> (table <table_sig>))
-         ( table <name>? ( export <string> )? <elem_type> ( elem <var>* ) ) ;; = (table <name>? ( export <string> )? <size> <size> <elem_type>) (elem (i32.const 0) <var>*)
+         ( table <name>? ( export <string> )* <elem_type> ( elem <var>* ) ) ;; = (table <name>? ( export <string> )* <size> <size> <elem_type>) (elem (i32.const 0) <var>*)
 elem:    ( elem <var>? (offset <instr>* ) <var>* )
          ( elem <var>? <expr> <var>* )                                      ;; = (elem <var>? (offset <expr>) <var>*)
 memory:  ( memory <name>? <memory_sig> )
-         ( memory <name>? ( export <string> ) <memory_sig> )                ;; = (export <string> (memory <N>)) (memory <name>? <memory_sig>)
+         ( memory <name>? ( export <string> )+ <memory_sig> )               ;; = (export <string> (memory <N>))+ (memory <name>? <memory_sig>)
          ( memory <name>? ( import <string> <string> ) <memory_sig> )       ;; = (import <name>? <string> <string> (memory <memory_sig>))
-         ( memory <name>? ( export <string> )? ( data <string>* )           ;; = (memory <name>? ( export <string> )? <size> <size>) (data (i32.const 0) <string>*)
+         ( memory <name>? ( export <string> )* ( data <string>* )           ;; = (memory <name>? ( export <string> )* <size> <size>) (data (i32.const 0) <string>*)
 data:    ( data <var>? ( offset <instr>* ) <string>* )
          ( data <var>? <expr> <string>* )                                   ;; = (data <var>? (offset <expr>) <string>*)
 
@@ -270,6 +269,8 @@ exkind:  ( func <var> )
 
 module:  ( module <name>? <typedef>* <func>* <import>* <export>* <table>? <memory>? <global>* <elem>* <data>* <start>? )
          ( module <name>? <string>+ )
+         <typedef>* <func>* <import>* <export>* <table>? <memory>? <global>* <elem>* <data>* <start>?  ;; =
+         ( module <typedef>* <func>* <import>* <export>* <table>? <memory>? <global>* <elem>* <data>* <start>? )
 ```
 
 Here, productions marked with respective comments are abbreviation forms for equivalent expansions (see the explanation of the AST below).
@@ -283,6 +284,8 @@ A module of the form `(module <string>+)` is given in binary form and will be de
 The segment strings in the memory field are used to initialize the consecutive memory at the given offset.
 The `<size>` in the expansion of the two short-hand forms for `table` and `memory` is the minimal size that can hold the segment: the number of `<var>`s for tables, and the accumulative length of the strings rounded up to page size for memories.
 
+In addition to the grammar rules above, the fields of a module may appear in any order, except that all imports must occur before the first proper definition of a function, table, memory, or global.
+
 Comments can be written in one of two ways:
 
 ```
@@ -336,7 +339,7 @@ After a module is _registered_ under a string name it is available for importing
 There are also a number of meta commands.
 The `script` command is a simple mechanism to name sub-scripts themselves. This is mainly useful for converting scripts with the `output` command. Commands inside a `script` will be executed normally, but nested meta are expanded in place (`input`, recursively) or elided (`output`) in the named script.
 
-The `input` and `output` meta commands determine the requested file format from the file name extension. They can handle both `.wast` and `.wasm` files. In the case of input, a `.wast` script will be recursively executed. Output additionally handles `.js` as a target, which will convert the referenced script to an equivalent, self-contained JavaScript runner. It also recognises `.bin.wast` specially, which creates a script where module definitions are in binary.
+The `input` and `output` meta commands determine the requested file format from the file name extension. They can handle both `.wasm`, `.wat`, and `.wast` files. In the case of input, a `.wast` script will be recursively executed. Output additionally handles `.js` as a target, which will convert the referenced script to an equivalent, self-contained JavaScript runner. It also recognises `.bin.wast` specially, which creates a script where module definitions are in binary.
 
 The interpreter supports a "dry" mode (flag `-d`), in which modules are only validated. In this mode, all actions and assertions are ignored.
 It also supports an "unchecked" mode (flag `-u`), in which module definitions are not validated before use.
diff --git a/interpreter/host/import.ml b/interpreter/host/import.ml
index 0e658dc00..5c7051be2 100644
--- a/interpreter/host/import.ml
+++ b/interpreter/host/import.ml
@@ -14,7 +14,7 @@ let lookup (m : module_) (im : import) : Instance.extern =
   let t = import_type m im in
   try Registry.find module_name !registry item_name t with Not_found ->
     Unknown.error im.at
-      ("unknown import \"" ^ String.escaped (Utf8.encode module_name) ^
-        "\".\"" ^ String.escaped (Utf8.encode item_name) ^ "\"")
+      ("unknown import \"" ^ string_of_name module_name ^
+        "\".\"" ^ string_of_name item_name ^ "\"")
 
 let link m = List.map (lookup m) m.it.imports
diff --git a/interpreter/host/js.ml b/interpreter/host/js.ml
index 1d66dc18d..4db32b7ad 100644
--- a/interpreter/host/js.ml
+++ b/interpreter/host/js.ml
@@ -170,7 +170,7 @@ let lookup (mods : modules) x_opt name at =
         else "unknown module " ^ of_var_opt mods x_opt ^ " within script"))
   in try ExportMap.find name exports with Not_found ->
     raise (Eval.Crash (at, "unknown export \"" ^
-      String.escaped (Utf8.encode name) ^ "\" within module"))
+      string_of_name name ^ "\" within module"))
 
 
 (* Wrappers *)
@@ -278,17 +278,22 @@ let add_char buf c =
     if c = '\"' || c = '\\' then Buffer.add_char buf '\\';
     Buffer.add_char buf c
   end
-
-let of_string_with add_char s =
-  let buf = Buffer.create (4 * String.length s + 2) in
+let add_unicode_char buf uc =
+  if uc < 0x20 || uc >= 0x7f then
+    Printf.bprintf buf "\\u{%02x}" uc
+  else
+    add_char buf (Char.chr uc)
+
+let of_string_with iter add_char s =
+  let buf = Buffer.create 256 in
   Buffer.add_char buf '\"';
-  String.iter (add_char buf) s;
+  iter (add_char buf) s;
   Buffer.add_char buf '\"';
   Buffer.contents buf
 
-let of_bytes = of_string_with add_hex_char
-let of_string = of_string_with add_char
-let of_name n = of_string (Utf8.encode n)
+let of_bytes = of_string_with String.iter add_hex_char
+let of_string = of_string_with String.iter add_char
+let of_name = of_string_with List.iter add_unicode_char
 
 let of_float z =
   match string_of_float z with
diff --git a/interpreter/host/run.ml b/interpreter/host/run.ml
index 1f7a9c22c..6e7faa03b 100644
--- a/interpreter/host/run.ml
+++ b/interpreter/host/run.ml
@@ -18,17 +18,20 @@ let trace name = if !Flags.trace then print_endline ("-- " ^ name)
 (* File types *)
 
 let binary_ext = "wasm"
-let binary_sexpr_ext = "bin.wast"
-let sexpr_ext = "wast"
+let sexpr_ext = "wat"
+let script_binary_ext = "bin.wast"
+let script_ext = "wast"
 let js_ext = "js"
 
-let dispatch_file_ext on_binary on_binary_sexpr on_sexpr on_js file =
+let dispatch_file_ext on_binary on_sexpr on_script_binary on_script on_js file =
   if Filename.check_suffix file binary_ext then
     on_binary file
-  else if Filename.check_suffix file binary_sexpr_ext then
-    on_binary_sexpr file
   else if Filename.check_suffix file sexpr_ext then
     on_sexpr file
+  else if Filename.check_suffix file script_binary_ext then
+    on_script_binary file
+  else if Filename.check_suffix file script_ext then
+    on_script file
   else if Filename.check_suffix file js_ext then
     on_js file
   else
@@ -47,7 +50,15 @@ let create_binary_file file _ get_module =
     close_out oc
   with exn -> close_out oc; raise exn
 
-let create_sexpr_file mode file get_script _ =
+let create_sexpr_file file _ get_module =
+  trace ("Writing (" ^ file ^ ")...");
+  let oc = open_out file in
+  try
+    Print.module_ oc !Flags.width (get_module ());
+    close_out oc
+  with exn -> close_out oc; raise exn
+
+let create_script_file mode file get_script _ =
   trace ("Writing (" ^ file ^ ")...");
   let oc = open_out file in
   try
@@ -68,8 +79,9 @@ let create_js_file file get_script _ =
 let output_file =
   dispatch_file_ext
     create_binary_file
-    (create_sexpr_file `Binary)
-    (create_sexpr_file `Textual)
+    create_sexpr_file
+    (create_script_file `Binary)
+    (create_script_file `Textual)
     create_js_file
 
 let output_stdout get_module =
@@ -104,21 +116,26 @@ let input_from get_script run =
   | Assert (at, msg) -> error at "assertion failure" msg
   | Abort _ -> false
 
-let input_sexpr name lexbuf start run =
+let input_script start name lexbuf run =
   input_from (fun _ -> Parse.parse name lexbuf start) run
 
+let input_sexpr name lexbuf run =
+  input_from (fun _ ->
+    let var_opt, def = Parse.parse name lexbuf Parse.Module in
+    [Module (var_opt, def) @@ no_region]) run
+
 let input_binary name buf run =
   let open Source in
   input_from (fun _ ->
     [Module (None, Encoded (name, buf) @@ no_region) @@ no_region]) run
 
-let input_sexpr_file file run =
+let input_sexpr_file input file run =
   trace ("Loading (" ^ file ^ ")...");
   let ic = open_in file in
   try
     let lexbuf = Lexing.from_channel ic in
     trace "Parsing...";
-    let success = input_sexpr file lexbuf Parse.Script run in
+    let success = input file lexbuf run in
     close_in ic;
     success
   with exn -> close_in ic; raise exn
@@ -142,8 +159,9 @@ let input_js_file file run =
 let input_file file run =
   dispatch_file_ext
     input_binary_file
-    input_sexpr_file
-    input_sexpr_file
+    (input_sexpr_file input_sexpr)
+    (input_sexpr_file (input_script Parse.Script))
+    (input_sexpr_file (input_script Parse.Script))
     input_js_file
     file run
 
@@ -151,7 +169,7 @@ let input_string string run =
   trace ("Running (\"" ^ String.escaped string ^ "\")...");
   let lexbuf = Lexing.from_string string in
   trace "Parsing...";
-  input_sexpr "string" lexbuf Parse.Script run
+  input_script Parse.Script "string" lexbuf run
 
 
 (* Interactive *)
@@ -175,7 +193,7 @@ let lexbuf_stdin buf len =
 let input_stdin run =
   let lexbuf = Lexing.from_function lexbuf_stdin in
   let rec loop () =
-    let success = input_sexpr "stdin" lexbuf Parse.Script1 run in
+    let success = input_script Parse.Script1 "stdin" lexbuf run in
     if not success then Lexing.flush_input lexbuf;
     if Lexing.(lexbuf.lex_curr_pos >= lexbuf.lex_buffer_len - 1) then
       continuing := false;
@@ -188,8 +206,6 @@ let input_stdin run =
 
 (* Printing *)
 
-let string_of_name n = String.escaped (Utf8.encode n)
-
 let print_import m im =
   let open Types in
   let category, annotation =
@@ -199,9 +215,9 @@ let print_import m im =
     | ExternalMemoryType t -> "memory", string_of_memory_type t
     | ExternalGlobalType t -> "global", string_of_global_type t
   in
-  Printf.printf "  import %s %S %S : %s\n"
-    category (string_of_name im.it.Ast.module_name)
-      (string_of_name im.it.Ast.item_name) annotation
+  Printf.printf "  import %s \"%s\" \"%s\" : %s\n"
+    category (Ast.string_of_name im.it.Ast.module_name)
+      (Ast.string_of_name im.it.Ast.item_name) annotation
 
 let print_export m ex =
   let open Types in
@@ -212,8 +228,8 @@ let print_export m ex =
     | ExternalMemoryType t -> "memory", string_of_memory_type t
     | ExternalGlobalType t -> "global", string_of_global_type t
   in
-  Printf.printf "  export %s %S : %s\n"
-    category (string_of_name ex.it.Ast.name) annotation
+  Printf.printf "  export %s \"%s\" : %s\n"
+    category (Ast.string_of_name ex.it.Ast.name) annotation
 
 let print_module x_opt m =
   Printf.printf "module%s :\n"
@@ -275,7 +291,7 @@ let run_definition def =
 let run_action act =
   match act.it with
   | Invoke (x_opt, name, vs) ->
-    trace ("Invoking function \"" ^ string_of_name name ^ "\"...");
+    trace ("Invoking function \"" ^ Ast.string_of_name name ^ "\"...");
     let inst = lookup_instance x_opt act.at in
     (match Instance.export inst name with
     | Some (Instance.ExternalFunc f) ->
@@ -285,7 +301,7 @@ let run_action act =
     )
 
  | Get (x_opt, name) ->
-    trace ("Getting global \"" ^ string_of_name name ^ "\"...");
+    trace ("Getting global \"" ^ Ast.string_of_name name ^ "\"...");
     let inst = lookup_instance x_opt act.at in
     (match Instance.export inst name with
     | Some (Instance.ExternalGlobal v) -> [v]
@@ -425,7 +441,7 @@ let rec run_command cmd =
   | Register (name, x_opt) ->
     quote := cmd :: !quote;
     if not !Flags.dry then begin
-      trace ("Registering module \"" ^ string_of_name name ^ "\"...");
+      trace ("Registering module \"" ^ Ast.string_of_name name ^ "\"...");
       let inst = lookup_instance x_opt cmd.at in
       registry := Map.add (Utf8.encode name) inst !registry;
       Import.register name (lookup_registry (Utf8.encode name))
diff --git a/interpreter/spec/ast.ml b/interpreter/spec/ast.ml
index 3604bbc1e..1d427b2c4 100644
--- a/interpreter/spec/ast.ml
+++ b/interpreter/spec/ast.ml
@@ -236,3 +236,17 @@ let export_type (m : module_) (ex : export) : external_type =
   | GlobalExport x ->
     let gts = globals its @ List.map (fun g -> g.it.gtype) m.it.globals in
     ExternalGlobalType (nth gts x.it)
+
+let string_of_name n =
+  let b = Buffer.create 16 in
+  let escape uc =
+    if uc < 0x20 || uc >= 0x7f then
+      Buffer.add_string b (Printf.sprintf "\\u{%02x}" uc)
+    else begin
+      let c = Char.chr uc in
+      if c = '\"' || c = '\\' then Buffer.add_char b '\\';
+      Buffer.add_char b c
+    end
+  in
+  List.iter escape n;
+  Buffer.contents b
diff --git a/interpreter/spec/float.ml b/interpreter/spec/float.ml
index a2f2f007a..25572bfc4 100644
--- a/interpreter/spec/float.ml
+++ b/interpreter/spec/float.ml
@@ -226,4 +226,3 @@ struct
         (* TODO: use sprintf "%h" once we have upgraded to OCaml 4.03 *)
         string_of_float (to_float a)
 end
-
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 3eb2a0661..b23c41420 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -19,17 +19,22 @@ let add_char buf c =
     if c = '\"' || c = '\\' then Buffer.add_char buf '\\';
     Buffer.add_char buf c
   end
-
-let string_with add_char s =
-  let buf = Buffer.create (3 * String.length s + 2) in
+let add_unicode_char buf uc =
+  if uc < 0x20 || uc >= 0x7f then
+    Printf.bprintf buf "\\u{%02x}" uc
+  else
+    add_char buf (Char.chr uc)
+
+let string_with iter add_char s =
+  let buf = Buffer.create 256 in
   Buffer.add_char buf '\"';
-  String.iter (add_char buf) s;
+  iter (add_char buf) s;
   Buffer.add_char buf '\"';
   Buffer.contents buf
 
-let bytes = string_with add_hex_char
-let string = string_with add_char
-let name n = string (Utf8.encode n)
+let bytes = string_with String.iter add_hex_char
+let string = string_with String.iter add_char
+let name = string_with List.iter add_unicode_char
 
 let list_of_opt = function None -> [] | Some x -> [x]
 
@@ -53,7 +58,7 @@ let elem_type t = string_of_elem_type t
 
 let decls kind ts = tab kind (atom value_type) ts
 
-let stack_type ts = list (atom value_type) ts
+let stack_type ts = decls "result" ts
 
 let func_type (FuncType (ins, out)) =
   Node ("func", decls "param" ins @ decls "result" out)
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index 70f4a9c34..47584f4f9 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -18,20 +18,28 @@ let error_nest start lexbuf msg =
   lexbuf.Lexing.lex_start_p <- start;
   error lexbuf msg
 
-let text s =
+let string s =
   let b = Buffer.create (String.length s) in
   let i = ref 1 in
   while !i < String.length s - 1 do
     let c = if s.[!i] <> '\\' then s.[!i] else
       match (incr i; s.[!i]) with
       | 'n' -> '\n'
+      | 'r' -> '\r'
       | 't' -> '\t'
       | '\\' -> '\\'
       | '\'' -> '\''
       | '\"' -> '\"'
-      | d ->
+      | 'u' ->
+        let j = !i + 2 in
+        i := String.index_from s j '}';
+        let n = int_of_string ("0x" ^ String.sub s j (!i - j)) in
+        let bs = Utf8.encode [n] in
+        Buffer.add_substring b bs 0 (String.length bs - 1);
+        bs.[String.length bs - 1]
+      | h ->
         incr i;
-        Char.chr (int_of_string ("0x" ^ String.make 1 d ^ String.make 1 s.[!i]))
+        Char.chr (int_of_string ("0x" ^ String.make 1 h ^ String.make 1 s.[!i]))
     in Buffer.add_char b c;
     incr i
   done;
@@ -80,31 +88,52 @@ let ext e s u =
 let opt = Lib.Option.get
 }
 
-let space = [' ''\t']
+let sign = '+' | '-'
 let digit = ['0'-'9']
 let hexdigit = ['0'-'9''a'-'f''A'-'F']
+let num = digit+
+let hexnum = hexdigit+
+
 let letter = ['a'-'z''A'-'Z']
-let symbol = ['+''-''*''/''\\''^''~''=''<''>''!''?''@''#''$''%''&''|'':''`''.']
-let tick = '\''
-let escape = ['n''t''\\''\'''\"']
+let symbol =
+  ['+''-''*''/''\\''^''~''=''<''>''!''?''@''#''$''%''&''|'':''`''.''\'']
+
+let space = [' ''\t''\n''\r']
+let ascii = ['\x00'-'\x7f']
+let ascii_no_nl = ['\x00'-'\x09''\x0b'-'\x7f']
+let utf8cont = ['\x80'-'\xbf']
+let utf8enc =
+    ['\xc2'-'\xdf'] utf8cont
+  | ['\xe0'] ['\xa0'-'\xbf'] utf8cont
+  | ['\xed'] ['\x80'-'\x9f'] utf8cont
+  | ['\xe1'-'\xec''\xee'-'\xef'] utf8cont utf8cont
+  | ['\xf0'] ['\x90'-'\xbf'] utf8cont utf8cont
+  | ['\xf4'] ['\x80'-'\x8f'] utf8cont utf8cont
+  | ['\xf1'-'\xf3'] utf8cont utf8cont utf8cont
+let utf8 = ascii | utf8enc
+let utf8_no_nl = ascii_no_nl | utf8enc
+
+let escape = ['n''r''t''\\''\'''\"']
 let character =
-  [^'"''\\''\x00'-'\x1f''\x7f'] | '\\'escape | '\\'hexdigit hexdigit
+    [^'"''\\''\x00'-'\x1f''\x7f'-'\xff']
+  | utf8enc
+  | '\\'escape
+  | '\\'hexdigit hexdigit 
+  | "\\u{" hexnum '}'
 
-let sign = ('+' | '-')
-let num = digit+
-let hexnum = "0x" hexdigit+
-let nat = num | hexnum
+let nat = num | "0x" hexnum
 let int = sign nat
 let float =
     sign? num '.' digit*
   | sign? num ('.' digit*)? ('e' | 'E') sign? num
-  | sign? "0x" hexdigit+ '.'? hexdigit* ('e' | 'E' | 'p') sign? digit+
+  | sign? "0x" hexnum '.' hexdigit*
+  | sign? "0x" hexnum ('.' hexdigit*)? ('p' | 'P') sign? num
   | sign? "inf"
-  | sign? "infinity"
   | sign? "nan"
-  | sign? "nan:0x" hexdigit+
-let text = '"' character* '"'
-let name = '$' (letter | digit | '_' | tick | symbol)+
+  | sign? "nan:" "0x" hexnum
+let string = '"' character* '"'
+let name = '$' (letter | digit | '_' | symbol)+
+let reserved = ([^'\"''('')'';'] # space)+  (* hack for table size *)
 
 let ixx = "i" ("32" | "64")
 let fxx = "f" ("32" | "64")
@@ -117,13 +146,15 @@ let mem_size = "8" | "16" | "32"
 rule token = parse
   | "(" { LPAR }
   | ")" { RPAR }
+
   | nat as s { NAT s }
   | int as s { INT s }
   | float as s { FLOAT s }
-  | text as s { TEXT (text s) }
-  | '"'character*('\n'|eof) { error lexbuf "unclosed text literal" }
+
+  | string as s { STRING (string s) }
+  | '"'character*('\n'|eof) { error lexbuf "unclosed string literal" }
   | '"'character*['\x00'-'\x09''\x0b'-'\x1f''\x7f']
-    { error lexbuf "illegal control character in text literal" }
+    { error lexbuf "illegal control character in string literal" }
   | '"'character*'\\'_
     { error_nest (Lexing.lexeme_end_p lexbuf) lexbuf "illegal escape" }
 
@@ -317,17 +348,22 @@ rule token = parse
 
   | name as s { VAR s }
 
-  | ";;"[^'\n']*eof { EOF }
-  | ";;"[^'\n']*'\n' { Lexing.new_line lexbuf; token lexbuf }
+  | ";;"utf8_no_nl*eof { EOF }
+  | ";;"utf8_no_nl*'\n' { Lexing.new_line lexbuf; token lexbuf }
+  | ";;"utf8_no_nl* { token lexbuf (* causes error on following position *) }
   | "(;" { comment (Lexing.lexeme_start_p lexbuf) lexbuf; token lexbuf }
-  | space { token lexbuf }
+  | space#'\n' { token lexbuf }
   | '\n' { Lexing.new_line lexbuf; token lexbuf }
   | eof { EOF }
-  | _ { error lexbuf "unknown operator" }
+
+  | reserved { error lexbuf "unknown operator" }
+  | utf8 { error lexbuf "malformed operator" }
+  | _ { error lexbuf "malformed UTF-8 encoding" }
 
 and comment start = parse
   | ";)" { () }
   | "(;" { comment (Lexing.lexeme_start_p lexbuf) lexbuf; comment start lexbuf }
   | '\n' { Lexing.new_line lexbuf; comment start lexbuf }
   | eof { error_nest start lexbuf "unclosed comment" }
-  | _ { comment start lexbuf }
+  | utf8 { comment start lexbuf }
+  | _ { error lexbuf "malformed UTF-8 encoding" }
diff --git a/interpreter/text/parse.ml b/interpreter/text/parse.ml
index f0be33701..71c4cc4a9 100644
--- a/interpreter/text/parse.ml
+++ b/interpreter/text/parse.ml
@@ -1,5 +1,5 @@
 type 'a start =
-  | Module : Script.definition start
+  | Module : (Script.var option * Script.definition) start
   | Script : Script.script start
   | Script1 : Script.script start
 
@@ -25,4 +25,4 @@ let string_to start s =
   parse "string" lexbuf start
 
 let string_to_script s = string_to Script s
-let string_to_module s = string_to Module s
+let string_to_module s = snd (string_to Module s)
diff --git a/interpreter/text/parse.mli b/interpreter/text/parse.mli
index 46e7e67c6..4530edfae 100644
--- a/interpreter/text/parse.mli
+++ b/interpreter/text/parse.mli
@@ -1,5 +1,5 @@
 type 'a start =
-  | Module : Script.definition start
+  | Module : (Script.var option * Script.definition) start
   | Script : Script.script start
   | Script1 : Script.script start
 
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 31db274eb..417ff8298 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -137,25 +137,25 @@ let anon_label (c : context) =
 
 let empty_type = FuncType ([], [])
 
-let explicit_sig (c : context) var_sem ty at =
-  let x = var_sem c type_ in
-  if
-    x.it < Lib.List32.length c.types.tlist &&
-    ty <> empty_type &&
-    ty <> Lib.List32.nth c.types.tlist x.it
-  then
-    error at "signature mismatch";
-  x
-
 let inline_type (c : context) ty at =
   match Lib.List.index_of ty c.types.tlist with
   | Some i -> Int32.of_int i @@ at
   | None ->
     let i = Lib.List32.length c.types.tlist in ignore (anon_type c ty); i @@ at
 
+let inline_type_explicit (c : context) x ty at =
+  if
+    ty <> empty_type &&
+    (x.it >= Lib.List32.length c.types.tlist ||
+     ty <> Lib.List32.nth c.types.tlist x.it)
+  then
+    error at "inline function type does not match explicit type"
+  else
+    x
+
 %}
 
-%token NAT INT FLOAT TEXT VAR VALUE_TYPE ANYFUNC MUT LPAR RPAR
+%token NAT INT FLOAT STRING VAR VALUE_TYPE ANYFUNC MUT LPAR RPAR
 %token NOP DROP BLOCK END IF THEN ELSE SELECT LOOP BR BR_IF BR_TABLE
 %token CALL CALL_INDIRECT RETURN
 %token GET_LOCAL SET_LOCAL TEE_LOCAL GET_GLOBAL SET_GLOBAL
@@ -173,7 +173,7 @@ let inline_type (c : context) ty at =
 %token<string> NAT
 %token<string> INT
 %token<string> FLOAT
-%token<string> TEXT
+%token<string> STRING
 %token<string> VAR
 %token<Types.value_type> VALUE_TYPE
 %token<string Source.phrase -> Ast.instr' * Values.value> CONST
@@ -193,18 +193,18 @@ let inline_type (c : context) ty at =
 %start script script1 module1
 %type<Script.script> script
 %type<Script.script> script1
-%type<Script.definition> module1
+%type<Script.var option * Script.definition> module1
 
 %%
 
 /* Auxiliaries */
 
 name :
-  | TEXT { name $1 (at ()) }
+  | STRING { name $1 (at ()) }
 
-text_list :
+string_list :
   | /* empty */ { "" }
-  | text_list TEXT { $1 ^ $2 }
+  | string_list STRING { $1 ^ $2 }
 
 
 /* Types */
@@ -346,45 +346,48 @@ block_instr :
     { fun c -> let c' = $2 c ($5 @ $8) in
       let ts, es1 = $3 c' in if_ ts es1 ($6 c') }
 
+block_sig :
+  | LPAR RESULT value_type_list RPAR { $3 }
+
 block :
-  | value_type_list instr_list { fun c -> $1, $2 c }
+  | block_sig block
+    { fun c -> let ts, es = $2 c in $1 @ ts, es }
+  | instr_list { fun c -> [], $1 c }
 
 expr :  /* Sugar */
   | LPAR expr1 RPAR
     { let at = at () in fun c -> let es, e' = $2 c in es @ [e' @@ at] }
 
 expr1 :  /* Sugar */
-  | plain_instr expr_list { fun c -> snd ($2 c), $1 c }
+  | plain_instr expr_list { fun c -> $2 c, $1 c }
   | BLOCK labeling_opt block
     { fun c -> let c' = $2 c [] in let ts, es = $3 c' in [], block ts es }
   | LOOP labeling_opt block
     { fun c -> let c' = $2 c [] in let ts, es = $3 c' in [], loop ts es }
-  | IF labeling_opt value_type_list if_
+  | IF labeling_opt if_block
     { fun c -> let c' = $2 c [] in
-      let es, es1, es2 = $4 c c' in es, if_ $3 es1 es2 }
+      let ts, (es, es1, es2) = $3 c c' in es, if_ ts es1 es2 }
+
+if_block :
+  | block_sig if_block { fun c c' -> let ts, ess = $2 c c' in $1 @ ts, ess }
+  | if_ { fun c c' -> [], $1 c c' }
 
 if_ :
-  | LPAR THEN instr_list RPAR LPAR ELSE instr_list RPAR
+  | expr if_
+    { fun c c' -> let es = $1 c in let es0, es1, es2 = $2 c c' in
+      es @ es0, es1, es2 }
+  | LPAR THEN instr_list RPAR LPAR ELSE instr_list RPAR  /* Sugar */
     { fun c c' -> [], $3 c', $7 c' }
   | LPAR THEN instr_list RPAR  /* Sugar */
     { fun c c' -> [], $3 c', [] }
-  | expr LPAR THEN instr_list RPAR LPAR ELSE instr_list RPAR  /* Sugar */
-    { fun c c' -> $1 c, $4 c', $8 c' }
-  | expr LPAR THEN instr_list RPAR  /* Sugar */
-    { fun c c' -> $1 c, $4 c', [] }
-  | expr expr expr  /* Sugar */
-    { fun c c' -> $1 c, $2 c', $3 c' }
-  | expr expr  /* Sugar */
-    { fun c c' -> $1 c, $2 c', [] }
 
 instr_list :
   | /* empty */ { fun c -> [] }
   | instr instr_list { fun c -> $1 c @ $2 c }
 
 expr_list :
-  | /* empty */ { fun c -> 0, [] }
-  | expr expr_list
-    { fun c -> let es1 = $1 c and n, es2 = $2 c in n + 1, es1 @ es2 }
+  | /* empty */ { fun c -> [] }
+  | expr expr_list { fun c -> $1 c @ $2 c }
 
 const_expr :
   | instr_list { let at = at () in fun c -> $1 c @@ at }
@@ -392,63 +395,68 @@ const_expr :
 
 /* Functions */
 
+func :
+  | LPAR FUNC bind_var_opt func_fields RPAR
+    { let at = at () in
+      fun c -> let x = $3 c anon_func bind_func @@ at in $4 c x at }
+
 func_fields :
-  | func_body { $1 }
+  | type_use func_fields_body
+    { fun c x at ->
+      let t = inline_type_explicit c ($1 c type_) (fst $2) at in
+      (fun () -> [{(snd $2 (enter_func c)) with ftype = t} @@ at]), [], [] }
+  | func_fields_body  /* Sugar */
+    { fun c x at ->
+      let t = inline_type c (fst $1) at in
+      (fun () -> [{(snd $1 (enter_func c)) with ftype = t} @@ at]), [], [] }
+  | inline_import type_use func_fields_import  /* Sugar */
+    { fun c x at ->
+      let t = inline_type_explicit c ($2 c type_) $3 at in
+      (fun () -> []),
+      [{ module_name = fst $1; item_name = snd $1;
+         idesc = FuncImport t @@ at } @@ at ], [] }
+  | inline_import func_fields_import  /* Sugar */
+    { fun c x at ->
+      let t = inline_type c $2 at in
+      (fun () -> []),
+      [{ module_name = fst $1; item_name = snd $1;
+         idesc = FuncImport t @@ at } @@ at ], [] }
+  | inline_export func_fields  /* Sugar */
+    { fun c x at ->
+      let fns, ims, exs = $2 c x at in fns, ims, $1 (FuncExport x) c :: exs }
+
+func_fields_import :  /* Sugar */
+  | /* empty */ { empty_type }
+  | LPAR RESULT value_type_list RPAR
+    { FuncType ([], $3) }
+  | LPAR PARAM value_type_list RPAR func_fields_import
+    { let FuncType (ins, out) = $5 in FuncType ($3 @ ins, out) }
+  | LPAR PARAM bind_var VALUE_TYPE RPAR func_fields_import  /* Sugar */
+    { let FuncType (ins, out) = $6 in FuncType ($4 :: ins, out) }
+
+func_fields_body :
+  | func_body { empty_type, $1 }
   | LPAR RESULT value_type_list RPAR func_body
-    { let FuncType (ins, out) = fst $5 in
-      FuncType (ins, $3 @ out), fun c -> snd $5 c }
-  | LPAR PARAM value_type_list RPAR func_fields
+    { FuncType ([], $3), $5 }
+  | LPAR PARAM value_type_list RPAR func_fields_body
     { let FuncType (ins, out) = fst $5 in
       FuncType ($3 @ ins, out),
-      fun c -> ignore (anon_locals c $3); (snd $5) c }
-  | LPAR PARAM bind_var VALUE_TYPE RPAR func_fields  /* Sugar */
+      fun c -> ignore (anon_locals c $3); snd $5 c }
+  | LPAR PARAM bind_var VALUE_TYPE RPAR func_fields_body  /* Sugar */
     { let FuncType (ins, out) = fst $6 in
       FuncType ($4 :: ins, out),
-      fun c -> ignore (bind_local c $3); (snd $6) c }
+      fun c -> ignore (bind_local c $3); snd $6 c }
 
 func_body :
   | instr_list
-    { empty_type,
-      fun c -> let c' = anon_label c in
+    { fun c -> let c' = anon_label c in
       {ftype = -1l @@ at(); locals = []; body = $1 c'} }
   | LPAR LOCAL value_type_list RPAR func_body
-    { fst $5,
-      fun c -> ignore (anon_locals c $3); let f = (snd $5) c in
-        {f with locals = $3 @ f.locals} }
+    { fun c -> ignore (anon_locals c $3); let f = $5 c in
+      {f with locals = $3 @ f.locals} }
   | LPAR LOCAL bind_var VALUE_TYPE RPAR func_body  /* Sugar */
-    { fst $6,
-      fun c -> ignore (bind_local c $3); let f = (snd $6) c in
-        {f with locals = $4 :: f.locals} }
-
-func :
-  | LPAR FUNC bind_var_opt inline_export type_use func_fields RPAR
-    { let at = at () in
-      fun c ->
-      let x = $3 c anon_func bind_func @@ at in
-      let t = explicit_sig c $5 (fst $6) at in
-      (fun () -> {(snd $6 (enter_func c)) with ftype = t} @@ at),
-      $4 (FuncExport x) c }
-  /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */
-  | LPAR FUNC bind_var_opt type_use func_fields RPAR
-    { let at = at () in
-      fun c -> ignore ($3 c anon_func bind_func);
-      let t = explicit_sig c $4 (fst $5) at in
-      (fun () -> {(snd $5 (enter_func c)) with ftype = t} @@ at),
-      [] }
-  | LPAR FUNC bind_var_opt inline_export func_fields RPAR  /* Sugar */
-    { let at = at () in
-      fun c -> 
-      let x = $3 c anon_func bind_func @@ at in
-      let t = inline_type c (fst $5) at in
-      (fun () -> {(snd $5 (enter_func c)) with ftype = t} @@ at),
-      $4 (FuncExport x) c }
-  /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */
-  | LPAR FUNC bind_var_opt func_fields RPAR  /* Sugar */
-    { let at = at () in
-      fun c -> ignore ($3 c anon_func bind_func);
-      let t = inline_type c (fst $4) at in
-      (fun () -> {(snd $4 (enter_func c)) with ftype = t} @@ at),
-      [] }
+    { fun c -> ignore (bind_local c $3); let f = $6 c in
+      {f with locals = $4 :: f.locals} }
 
 
 /* Tables, Memories & Globals */
@@ -466,63 +474,79 @@ elem :
       fun c -> {index = 0l @@ at; offset = $3 c; init = $4 c func} @@ at }
 
 table :
-  | LPAR TABLE bind_var_opt inline_export_opt table_sig RPAR
+  | LPAR TABLE bind_var_opt table_fields RPAR
     { let at = at () in
       fun c -> let x = $3 c anon_table bind_table @@ at in
-      fun () -> {ttype = $5} @@ at, [], $4 (TableExport x) c }
-  | LPAR TABLE bind_var_opt inline_export_opt elem_type
-      LPAR ELEM var_list RPAR RPAR  /* Sugar */
-    { let at = at () in
-      fun c -> let x = $3 c anon_table bind_table @@ at in
-      fun () ->
-      let init = $8 c func in let size = Int32.of_int (List.length init) in
-      {ttype = TableType ({min = size; max = Some size}, $5)} @@ at,
+      fun () -> $4 c x at }
+
+table_fields :
+  | table_sig
+    { fun c x at -> [{ttype = $1} @@ at], [], [], [] }
+  | inline_import table_sig
+    { fun c x at ->
+      [], [],
+      [{ module_name = fst $1; item_name = snd $1;
+        idesc = TableImport $2 @@ at } @@ at], [] }
+  | inline_export table_fields  /* Sugar */
+    { fun c x at -> let tabs, elems, ims, exs = $2 c x at in
+      tabs, elems, ims, $1 (TableExport x) c :: exs }
+  | elem_type LPAR ELEM var_list RPAR  /* Sugar */
+    { fun c x at ->
+      let init = $4 c func in let size = Int32.of_int (List.length init) in
+      [{ttype = TableType ({min = size; max = Some size}, $1)} @@ at],
       [{index = x; offset = [i32_const (0l @@ at) @@ at] @@ at; init} @@ at],
-      $4 (TableExport x) c }
+      [], [] }
 
 data :
-  | LPAR DATA var offset text_list RPAR
+  | LPAR DATA var offset string_list RPAR
     { let at = at () in
       fun c -> {index = $3 c memory; offset = $4 c; init = $5} @@ at }
-  | LPAR DATA offset text_list RPAR  /* Sugar */
+  | LPAR DATA offset string_list RPAR  /* Sugar */
     { let at = at () in
       fun c -> {index = 0l @@ at; offset = $3 c; init = $4} @@ at }
 
 memory :
-  | LPAR MEMORY bind_var_opt inline_export_opt memory_sig RPAR
-    { let at = at () in
-      fun c -> let x = $3 c anon_memory bind_memory @@ at in
-      {mtype = $5} @@ at, [], $4 (MemoryExport x) c }
-  | LPAR MEMORY bind_var_opt inline_export LPAR DATA text_list RPAR RPAR
-      /* Sugar */
-    { let at = at () in
-      fun c -> let x = $3 c anon_memory bind_memory @@ at in
-      let size = Int32.(div (add (of_int (String.length $7)) 65535l) 65536l) in
-      {mtype = MemoryType {min = size; max = Some size}} @@ at,
-      [{index = x;
-        offset = [i32_const (0l @@ at) @@ at] @@ at; init = $7} @@ at],
-      $4 (MemoryExport x) c }
-  /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */
-  | LPAR MEMORY bind_var_opt LPAR DATA text_list RPAR RPAR  /* Sugar */
+  | LPAR MEMORY bind_var_opt memory_fields RPAR
     { let at = at () in
       fun c -> let x = $3 c anon_memory bind_memory @@ at in
-      let size = Int32.(div (add (of_int (String.length $6)) 65535l) 65536l) in
-      {mtype = MemoryType {min = size; max = Some size}} @@ at,
+      fun () -> $4 c x at }
+
+memory_fields :
+  | memory_sig
+    { fun c x at -> [{mtype = $1} @@ at], [], [], [] }
+  | inline_import memory_sig
+    { fun c x at ->
+      [], [],
+      [{ module_name = fst $1; item_name = snd $1;
+         idesc = MemoryImport $2 @@ at } @@ at], [] }
+  | inline_export memory_fields  /* Sugar */
+    { fun c x at -> let mems, data, ims, exs = $2 c x at in
+      mems, data, ims, $1 (MemoryExport x) c :: exs }
+  | LPAR DATA string_list RPAR  /* Sugar */
+    { fun c x at ->
+      let size = Int32.(div (add (of_int (String.length $3)) 65535l) 65536l) in
+      [{mtype = MemoryType {min = size; max = Some size}} @@ at],
       [{index = x;
-        offset = [i32_const (0l @@ at) @@ at] @@ at; init = $6} @@ at],
-      [] }
+        offset = [i32_const (0l @@ at) @@ at] @@ at; init = $3} @@ at],
+      [], [] }
 
 global :
-  | LPAR GLOBAL bind_var_opt inline_export global_type const_expr RPAR
+  | LPAR GLOBAL bind_var_opt global_fields RPAR
     { let at = at () in
       fun c -> let x = $3 c anon_global bind_global @@ at in
-      (fun () -> {gtype = $5; value = $6 c} @@ at),
-      $4 (GlobalExport x) c }
-  /* Duplicate above for empty inline_export_opt to avoid LR(1) conflict. */
-  | LPAR GLOBAL bind_var_opt global_type const_expr RPAR
-    { let at = at () in
-      fun c -> ignore ($3 c anon_global bind_global);
-      (fun () -> {gtype = $4; value = $5 c} @@ at), [] }
+      fun () -> $4 c x at }
+
+global_fields :
+  | global_type const_expr
+    { fun c x at -> [{gtype = $1; value = $2 c} @@ at], [], [] }
+  | inline_import global_type
+    { fun c x at ->
+      [],
+      [{ module_name = fst $1; item_name = snd $1;
+         idesc = GlobalImport $2 @@ at } @@ at], [] }
+  | inline_export global_fields  /* Sugar */
+    { fun c x at -> let globs, ims, exs = $2 c x at in
+      globs, ims, $1 (GlobalExport x) c :: exs }
 
 
 /* Imports & Exports */
@@ -546,31 +570,6 @@ import :
   | LPAR IMPORT name name import_desc RPAR
     { let at = at () and at5 = ati 5 in
       fun c -> {module_name = $3; item_name = $4; idesc = $5 c @@ at5} @@ at }
-  | LPAR FUNC bind_var_opt inline_import type_use RPAR  /* Sugar */
-    { let at = at () in
-      fun c -> ignore ($3 c anon_func bind_func);
-      { module_name = fst $4; item_name = snd $4;
-        idesc = FuncImport ($5 c type_) @@ at } @@ at }
-  | LPAR FUNC bind_var_opt inline_import func_sig RPAR  /* Sugar */
-    { let at = at () and at5 = ati 5 in
-      fun c -> ignore ($3 c anon_func bind_func);
-      { module_name = fst $4; item_name = snd $4;
-        idesc = FuncImport (inline_type c $5 at5) @@ at } @@ at }
-  | LPAR TABLE bind_var_opt inline_import table_sig RPAR  /* Sugar */
-    { let at = at () in
-      fun c -> ignore ($3 c anon_table bind_table);
-      { module_name = fst $4; item_name = snd $4;
-        idesc = TableImport $5 @@ at } @@ at }
-  | LPAR MEMORY bind_var_opt inline_import memory_sig RPAR  /* Sugar */
-    { let at = at () in
-      fun c -> ignore ($3 c anon_memory bind_memory);
-      { module_name = fst $4; item_name = snd $4;
-        idesc = MemoryImport $5 @@ at } @@ at }
-  | LPAR GLOBAL bind_var_opt inline_import global_type RPAR  /* Sugar */
-    { let at = at () in
-      fun c -> ignore ($3 c anon_global bind_global);
-      { module_name = fst $4; item_name = snd $4;
-        idesc = GlobalImport $5 @@ at } @@ at }
 
 inline_import :
   | LPAR IMPORT name name RPAR { $3, $4 }
@@ -586,13 +585,9 @@ export :
     { let at = at () and at4 = ati 4 in
       fun c -> {name = $3; edesc = $4 c @@ at4} @@ at }
 
-inline_export_opt :
-  | /* empty */ { fun d c -> [] }
-  | inline_export { $1 }
-
 inline_export :
   | LPAR EXPORT name RPAR
-    { let at = at () in fun d c -> [{name = $3; edesc = d @@ at} @@ at] }
+    { let at = at () in fun d c -> {name = $3; edesc = d @@ at} @@ at }
 
 
 /* Modules */
@@ -610,28 +605,38 @@ start :
 module_fields :
   | /* empty */
     { fun (c : context) -> {empty_module with types = c.types.tlist} }
+  | module_fields1 { $1 }
+
+module_fields1 :
   | type_def module_fields
     { fun c -> $1 c; $2 c }
   | global module_fields
-    { fun c -> let g, exs = $1 c in let m = $2 c in
-      if m.imports <> [] then
+    { fun c -> let gf = $1 c in let m = $2 c in
+      let globs, ims, exs = gf () in
+      if globs <> [] && m.imports <> [] then
         error (List.hd m.imports).at "import after global definition";
-      {m with globals = g () :: m.globals; exports = exs @ m.exports} }
+      { m with globals = globs @ m.globals;
+        imports = ims @ m.imports; exports = exs @ m.exports } }
   | table module_fields
-    { fun c -> let t = $1 c in let m = $2 c in let tab, elems, exs = t () in
-      if m.imports <> [] then
+    { fun c -> let tf = $1 c in let m = $2 c in
+      let tabs, elems, ims, exs = tf () in
+      if tabs <> [] && m.imports <> [] then
         error (List.hd m.imports).at "import after table definition";
-      {m with tables = tab :: m.tables; elems = elems @ m.elems; exports = exs @ m.exports} }
+      { m with tables = tabs @ m.tables; elems = elems @ m.elems;
+        imports = ims @ m.imports; exports = exs @ m.exports } }
   | memory module_fields
-    { fun c -> let mem, data, exs = $1 c in let m = $2 c in
-      if m.imports <> [] then
+    { fun c -> let mf = $1 c in let m = $2 c in
+      let mems, data, ims, exs = mf () in
+      if mems <> [] && m.imports <> [] then
         error (List.hd m.imports).at "import after memory definition";
-      {m with memories = mem :: m.memories; data = data @ m.data; exports = exs @ m.exports} }
+      { m with memories = mems @ m.memories; data = data @ m.data;
+        imports = ims @ m.imports; exports = exs @ m.exports } }
   | func module_fields
-    { fun c -> let f, exs = $1 c in let m = $2 c in let func = f () in
-      if m.imports <> [] then
+    { fun c -> let ff, ims, exs = $1 c in let m = $2 c in let funcs = ff () in
+      if funcs <> [] && m.imports <> [] then
         error (List.hd m.imports).at "import after function definition";
-      {m with funcs = func :: m.funcs; exports = exs @ m.exports} }
+      { m with funcs = funcs @ m.funcs;
+        imports = ims @ m.imports; exports = exs @ m.exports } }
   | elem module_fields
     { fun c -> let m = $2 c in
       {m with elems = $1 c :: m.elems} }
@@ -653,9 +658,15 @@ module_fields :
 module_ :
   | LPAR MODULE script_var_opt module_fields RPAR
     { $3, Textual ($4 (empty_context ()) @@ at ()) @@ at () }
-  | LPAR MODULE script_var_opt TEXT text_list RPAR
+  | LPAR MODULE script_var_opt STRING string_list RPAR
     { $3, Encoded ("binary", $4 ^ $5) @@ at() }
 
+inline_module :  /* Sugar */
+  | module_fields { Textual ($1 (empty_context ()) @@ at ()) @@ at () }
+
+inline_module1 :  /* Sugar */
+  | module_fields1 { Textual ($1 (empty_context ()) @@ at ()) @@ at () }
+
 
 /* Scripts */
 
@@ -670,19 +681,19 @@ action :
     { Get ($3, $4) @@ at() }
 
 assertion :
-  | LPAR ASSERT_MALFORMED module_ TEXT RPAR
+  | LPAR ASSERT_MALFORMED module_ STRING RPAR
     { AssertMalformed (snd $3, $4) @@ at () }
-  | LPAR ASSERT_INVALID module_ TEXT RPAR
+  | LPAR ASSERT_INVALID module_ STRING RPAR
     { AssertInvalid (snd $3, $4) @@ at () }
-  | LPAR ASSERT_UNLINKABLE module_ TEXT RPAR
+  | LPAR ASSERT_UNLINKABLE module_ STRING RPAR
     { AssertUnlinkable (snd $3, $4) @@ at () }
-  | LPAR ASSERT_TRAP module_ TEXT RPAR
+  | LPAR ASSERT_TRAP module_ STRING RPAR
     { AssertUninstantiable (snd $3, $4) @@ at () }
   | LPAR ASSERT_RETURN action const_list RPAR { AssertReturn ($3, $4) @@ at () }
   | LPAR ASSERT_RETURN_CANONICAL_NAN action RPAR { AssertReturnCanonicalNaN $3 @@ at () }
   | LPAR ASSERT_RETURN_ARITHMETIC_NAN action RPAR { AssertReturnArithmeticNaN $3 @@ at () }
-  | LPAR ASSERT_TRAP action TEXT RPAR { AssertTrap ($3, $4) @@ at () }
-  | LPAR ASSERT_EXHAUSTION action TEXT RPAR { AssertExhaustion ($3, $4) @@ at () }
+  | LPAR ASSERT_TRAP action STRING RPAR { AssertTrap ($3, $4) @@ at () }
+  | LPAR ASSERT_EXHAUSTION action STRING RPAR { AssertExhaustion ($3, $4) @@ at () }
 
 cmd :
   | action { Action $1 @@ at () }
@@ -697,8 +708,8 @@ cmd_list :
 
 meta :
   | LPAR SCRIPT script_var_opt cmd_list RPAR { Script ($3, $4) @@ at () }
-  | LPAR INPUT script_var_opt TEXT RPAR { Input ($3, $4) @@ at () }
-  | LPAR OUTPUT script_var_opt TEXT RPAR { Output ($3, Some $4) @@ at () }
+  | LPAR INPUT script_var_opt STRING RPAR { Input ($3, $4) @@ at () }
+  | LPAR OUTPUT script_var_opt STRING RPAR { Output ($3, Some $4) @@ at () }
   | LPAR OUTPUT script_var_opt RPAR { Output ($3, None) @@ at () }
 
 const :
@@ -710,10 +721,12 @@ const_list :
 
 script :
   | cmd_list EOF { $1 }
+  | inline_module1 EOF { [Module (None, $1) @@ at ()] }  /* Sugar */
 
 script1 :
   | cmd { [$1] }
 
 module1 :
-  | module_ EOF { snd $1 }
+  | module_ EOF { $1 }
+  | inline_module EOF { None, $1 }  /* Sugar */
 %%
diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index 514077495..818e025ed 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -19,7 +19,7 @@ end
 module String =
 struct
   let implode cs =
-    let buf = Buffer.create (List.length cs) in
+    let buf = Buffer.create 80 in
     List.iter (Buffer.add_char buf) cs;
     Buffer.contents buf
 
diff --git a/test/core/block.wast b/test/core/block.wast
index cb7935c55..7d51859ca 100644
--- a/test/core/block.wast
+++ b/test/core/block.wast
@@ -11,53 +11,79 @@
 
   (func (export "singular") (result i32)
     (block (nop))
-    (block i32 (i32.const 7))
+    (block (result i32) (i32.const 7))
   )
 
   (func (export "multi") (result i32)
     (block (call $dummy) (call $dummy) (call $dummy) (call $dummy))
-    (block i32 (call $dummy) (call $dummy) (call $dummy) (i32.const 8))
+    (block (result i32) (call $dummy) (call $dummy) (call $dummy) (i32.const 8))
   )
 
   (func (export "nested") (result i32)
-    (block i32
+    (block (result i32)
       (block (call $dummy) (block) (nop))
-      (block i32 (call $dummy) (i32.const 9))
+      (block (result i32) (call $dummy) (i32.const 9))
     )
   )
 
   (func (export "deep") (result i32)
-    (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-      (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-        (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-          (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-            (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-              (block i32 (block i32 (block i32 (block i32 (block i32 (block i32
-                (block i32 (block i32 (call $dummy) (i32.const 150)))
-              ))))))
-            ))))))
-          ))))))
-        ))))))
-      ))))))
-    ))))))
+    (block (result i32) (block (result i32)
+      (block (result i32) (block (result i32)
+        (block (result i32) (block (result i32)
+          (block (result i32) (block (result i32)
+            (block (result i32) (block (result i32)
+              (block (result i32) (block (result i32)
+                (block (result i32) (block (result i32)
+                  (block (result i32) (block (result i32)
+                    (block (result i32) (block (result i32)
+                      (block (result i32) (block (result i32)
+                        (block (result i32) (block (result i32)
+                          (block (result i32) (block (result i32)
+                            (block (result i32) (block (result i32)
+                              (block (result i32) (block (result i32)
+                                (block (result i32) (block (result i32)
+                                  (block (result i32) (block (result i32)
+                                    (block (result i32) (block (result i32)
+                                      (block (result i32) (block (result i32)
+                                        (block (result i32) (block (result i32)
+                                          (call $dummy) (i32.const 150)
+                                        ))
+                                      ))
+                                    ))
+                                  ))
+                                ))
+                              ))
+                            ))
+                          ))
+                        ))
+                      ))
+                    ))
+                  ))
+                ))
+              ))
+            ))
+          ))
+        ))
+      ))
+    ))
   )
 
   (func (export "as-unary-operand") (result i32)
-    (i32.ctz (block i32 (call $dummy) (i32.const 13)))
+    (i32.ctz (block (result i32) (call $dummy) (i32.const 13)))
   )
   (func (export "as-binary-operand") (result i32)
     (i32.mul
-      (block i32 (call $dummy) (i32.const 3))
-      (block i32 (call $dummy) (i32.const 4))
+      (block (result i32) (call $dummy) (i32.const 3))
+      (block (result i32) (call $dummy) (i32.const 4))
     )
   )
   (func (export "as-test-operand") (result i32)
-    (i32.eqz (block i32 (call $dummy) (i32.const 13)))
+    (i32.eqz (block (result i32) (call $dummy) (i32.const 13)))
   )
   (func (export "as-compare-operand") (result i32)
     (f32.gt
-      (block f32 (call $dummy) (f32.const 3))
-      (block f32 (call $dummy) (f32.const 3))
+      (block (result f32) (call $dummy) (f32.const 3))
+      (block (result f32) (call $dummy) (f32.const 3))
     )
   )
 
@@ -69,10 +95,10 @@
     (i32.const 19)
   )
   (func (export "break-value") (result i32)
-    (block i32 (br 0 (i32.const 18)) (i32.const 19))
+    (block (result i32) (br 0 (i32.const 18)) (i32.const 19))
   )
   (func (export "break-repeated") (result i32)
-    (block i32
+    (block (result i32)
       (br 0 (i32.const 18))
       (br 0 (i32.const 19))
       (drop (br_if 0 (i32.const 20) (i32.const 0)))
@@ -86,13 +112,13 @@
   (func (export "break-inner") (result i32)
     (local i32)
     (set_local 0 (i32.const 0))
-    (set_local 0 (i32.add (get_local 0) (block i32 (block i32 (br 1 (i32.const 0x1))))))
-    (set_local 0 (i32.add (get_local 0) (block i32 (block (br 0)) (i32.const 0x2))))
+    (set_local 0 (i32.add (get_local 0) (block (result i32) (block (result i32) (br 1 (i32.const 0x1))))))
+    (set_local 0 (i32.add (get_local 0) (block (result i32) (block (br 0)) (i32.const 0x2))))
     (set_local 0
-      (i32.add (get_local 0) (block i32 (i32.ctz (br 0 (i32.const 0x4)))))
+      (i32.add (get_local 0) (block (result i32) (i32.ctz (br 0 (i32.const 0x4)))))
     )
     (set_local 0
-      (i32.add (get_local 0) (block i32 (i32.ctz (block i32 (br 1 (i32.const 0x8))))))
+      (i32.add (get_local 0) (block (result i32) (i32.ctz (block (result i32) (br 1 (i32.const 0x8))))))
     )
     (get_local 0)
   )
@@ -154,89 +180,91 @@
 )
 (assert_invalid
   (module (func $type-value-empty-vs-num (result i32)
-    (block i32)
+    (block (result i32))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-value-void-vs-num (result i32)
-    (block i32 (nop))
+    (block (result i32) (nop))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-value-num-vs-num (result i32)
-    (block i32 (f32.const 0))
+    (block (result i32) (f32.const 0))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-value-unreached-select (result i32)
-    (block i64 (select (unreachable) (unreachable) (unreachable)))
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
   ))
   "type mismatch"
 )
 
 (assert_invalid
   (module (func $type-break-last-void-vs-num (result i32)
-    (block i32 (br 0))
+    (block (result i32) (br 0))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-break-empty-vs-num (result i32)
-    (block i32 (br 0) (i32.const 1))
+    (block (result i32) (br 0) (i32.const 1))
   ))
   "type mismatch"
 )
 
 (assert_invalid
   (module (func $type-break-void-vs-num (result i32)
-    (block i32 (br 0 (nop)) (i32.const 1))
+    (block (result i32) (br 0 (nop)) (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-break-num-vs-num (result i32)
-    (block i32 (br 0 (i64.const 1)) (i32.const 1))
+    (block (result i32) (br 0 (i64.const 1)) (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-break-first-void-vs-num (result i32)
-    (block i32 (br 0 (nop)) (br 0 (i32.const 1)))
+    (block (result i32) (br 0 (nop)) (br 0 (i32.const 1)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-break-first-num-vs-num (result i32)
-    (block i32 (br 0 (i64.const 1)) (br 0 (i32.const 1)))
+    (block (result i32) (br 0 (i64.const 1)) (br 0 (i32.const 1)))
   ))
   "type mismatch"
 )
 
 (assert_invalid
   (module (func $type-break-nested-num-vs-void
-    (block i32 (block i32 (br 1 (i32.const 1))) (br 0))
+    (block (result i32) (block (result i32) (br 1 (i32.const 1))) (br 0))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-break-nested-empty-vs-num (result i32)
-    (block i32 (block (br 1)) (br 0 (i32.const 1)))
+    (block (result i32) (block (br 1)) (br 0 (i32.const 1)))
   ))
   "type mismatch"
 )
 
 (assert_invalid
   (module (func $type-break-nested-void-vs-num (result i32)
-    (block i32 (block i32 (br 1 (nop))) (br 0 (i32.const 1)))
+    (block (result i32) (block (result i32) (br 1 (nop))) (br 0 (i32.const 1)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-break-nested-num-vs-num (result i32)
-    (block i32 (block i32 (br 1 (i64.const 1))) (br 0 (i32.const 1)))
+    (block (result i32)
+      (block (result i32) (br 1 (i64.const 1))) (br 0 (i32.const 1))
+    )
   ))
   "type mismatch"
 )
diff --git a/test/core/br.wast b/test/core/br.wast
index 8d1c7e103..77f781d4d 100644
--- a/test/core/br.wast
+++ b/test/core/br.wast
@@ -10,16 +10,16 @@
   (func (export "type-f64") (block (drop (f64.neg (br 0)))))
 
   (func (export "type-i32-value") (result i32)
-    (block i32 (i32.ctz (br 0 (i32.const 1))))
+    (block (result i32) (i32.ctz (br 0 (i32.const 1))))
   )
   (func (export "type-i64-value") (result i64)
-    (block i64 (i64.ctz (br 0 (i64.const 2))))
+    (block (result i64) (i64.ctz (br 0 (i64.const 2))))
   )
   (func (export "type-f32-value") (result f32)
-    (block f32 (f32.neg (br 0 (f32.const 3))))
+    (block (result f32) (f32.neg (br 0 (f32.const 3))))
   )
   (func (export "type-f64-value") (result f64)
-    (block f64 (f64.neg (br 0 (f64.const 4))))
+    (block (result f64) (f64.neg (br 0 (f64.const 4))))
   )
 
   (func (export "as-block-first")
@@ -32,33 +32,37 @@
     (block (nop) (call $dummy) (br 0))
   )
   (func (export "as-block-value") (result i32)
-    (block i32 (nop) (call $dummy) (br 0 (i32.const 2)))
+    (block (result i32) (nop) (call $dummy) (br 0 (i32.const 2)))
   )
 
   (func (export "as-loop-first") (result i32)
-    (block i32 (loop i32 (br 1 (i32.const 3)) (i32.const 2)))
+    (block (result i32) (loop (result i32) (br 1 (i32.const 3)) (i32.const 2)))
   )
   (func (export "as-loop-mid") (result i32)
-    (block i32 (loop i32 (call $dummy) (br 1 (i32.const 4)) (i32.const 2)))
+    (block (result i32)
+      (loop (result i32) (call $dummy) (br 1 (i32.const 4)) (i32.const 2))
+    )
   )
   (func (export "as-loop-last") (result i32)
-    (block i32 (loop i32 (nop) (call $dummy) (br 1 (i32.const 5))))
+    (block (result i32)
+      (loop (result i32) (nop) (call $dummy) (br 1 (i32.const 5)))
+    )
   )
 
   (func (export "as-br-value") (result i32)
-    (block i32 (br 0 (br 0 (i32.const 9))))
+    (block (result i32) (br 0 (br 0 (i32.const 9))))
   )
 
   (func (export "as-br_if-cond")
     (block (br_if 0 (br 0)))
   )
   (func (export "as-br_if-value") (result i32)
-    (block i32
+    (block (result i32)
       (drop (br_if 0 (br 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
     )
   )
   (func (export "as-br_if-value-cond") (result i32)
-    (block i32
+    (block (result i32)
       (drop (br_if 0 (i32.const 6) (br 0 (i32.const 9)))) (i32.const 7)
     )
   )
@@ -67,55 +71,82 @@
     (block (br_table 0 0 0 (br 0)))
   )
   (func (export "as-br_table-value") (result i32)
-    (block i32
+    (block (result i32)
       (br_table 0 0 0 (br 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
     )
   )
   (func (export "as-br_table-value-index") (result i32)
-    (block i32
+    (block (result i32)
       (br_table 0 0 (i32.const 6) (br 0 (i32.const 11))) (i32.const 7)
     )
   )
 
   (func (export "as-return-value") (result i64)
-    (block i64 (return (br 0 (i64.const 7))))
+    (block (result i64) (return (br 0 (i64.const 7))))
   )
 
   (func (export "as-if-cond") (result i32)
-    (block i32 (if i32 (br 0 (i32.const 2)) (i32.const 0) (i32.const 1)))
+    (block (result i32)
+      (if (result i32) (br 0 (i32.const 2))
+        (then (i32.const 0))
+        (else (i32.const 1))
+      )
+    )
   )
   (func (export "as-if-then") (param i32 i32) (result i32)
-    (block i32 (if i32 (get_local 0) (br 1 (i32.const 3)) (get_local 1)))
+    (block (result i32)
+      (if (result i32) (get_local 0)
+        (then (br 1 (i32.const 3)))
+        (else (get_local 1))
+      )
+    )
   )
   (func (export "as-if-else") (param i32 i32) (result i32)
-    (block i32 (if i32 (get_local 0) (get_local 1) (br 1 (i32.const 4))))
+    (block (result i32)
+      (if (result i32) (get_local 0)
+        (then (get_local 1))
+        (else (br 1 (i32.const 4)))
+      )
+    )
   )
 
   (func (export "as-select-first") (param i32 i32) (result i32)
-    (block i32 (select (br 0 (i32.const 5)) (get_local 0) (get_local 1)))
+    (block (result i32)
+      (select (br 0 (i32.const 5)) (get_local 0) (get_local 1))
+    )
   )
   (func (export "as-select-second") (param i32 i32) (result i32)
-    (block i32 (select (get_local 0) (br 0 (i32.const 6)) (get_local 1)))
+    (block (result i32)
+      (select (get_local 0) (br 0 (i32.const 6)) (get_local 1))
+    )
   )
   (func (export "as-select-cond") (result i32)
-    (block i32 (select (i32.const 0) (i32.const 1) (br 0 (i32.const 7))))
+    (block (result i32)
+      (select (i32.const 0) (i32.const 1) (br 0 (i32.const 7)))
+    )
   )
 
   (func $f (param i32 i32 i32) (result i32) (i32.const -1))
   (func (export "as-call-first") (result i32)
-    (block i32 (call $f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3)))
+    (block (result i32)
+      (call $f (br 0 (i32.const 12)) (i32.const 2) (i32.const 3))
+    )
   )
   (func (export "as-call-mid") (result i32)
-    (block i32 (call $f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3)))
+    (block (result i32)
+      (call $f (i32.const 1) (br 0 (i32.const 13)) (i32.const 3))
+    )
   )
   (func (export "as-call-last") (result i32)
-    (block i32 (call $f (i32.const 1) (i32.const 2) (br 0 (i32.const 14))))
+    (block (result i32)
+      (call $f (i32.const 1) (i32.const 2) (br 0 (i32.const 14)))
+    )
   )
 
   (type $sig (func (param i32 i32 i32) (result i32)))
   (table anyfunc (elem $f))
   (func (export "as-call_indirect-func") (result i32)
-    (block i32
+    (block (result i32)
       (call_indirect $sig
         (br 0 (i32.const 20))
         (i32.const 1) (i32.const 2) (i32.const 3)
@@ -123,7 +154,7 @@
     )
   )
   (func (export "as-call_indirect-first") (result i32)
-    (block i32
+    (block (result i32)
       (call_indirect $sig
         (i32.const 0)
         (br 0 (i32.const 21)) (i32.const 2) (i32.const 3)
@@ -131,7 +162,7 @@
     )
   )
   (func (export "as-call_indirect-mid") (result i32)
-    (block i32
+    (block (result i32)
       (call_indirect $sig
         (i32.const 0)
         (i32.const 1) (br 0 (i32.const 22)) (i32.const 3)
@@ -139,7 +170,7 @@
     )
   )
   (func (export "as-call_indirect-last") (result i32)
-    (block i32
+    (block (result i32)
       (call_indirect $sig
         (i32.const 0)
         (i32.const 1) (i32.const 2) (br 0 (i32.const 23))
@@ -148,65 +179,73 @@
   )
 
   (func (export "as-set_local-value") (result i32) (local f32)
-    (block i32 (set_local 0 (br 0 (i32.const 17))) (i32.const -1))
+    (block (result i32) (set_local 0 (br 0 (i32.const 17))) (i32.const -1))
   )
 
   (memory 1)
   (func (export "as-load-address") (result f32)
-    (block f32 (f32.load (br 0 (f32.const 1.7))))
+    (block (result f32) (f32.load (br 0 (f32.const 1.7))))
   )
   (func (export "as-loadN-address") (result i64)
-    (block i64 (i64.load8_s (br 0 (i64.const 30))))
+    (block (result i64) (i64.load8_s (br 0 (i64.const 30))))
   )
 
   (func (export "as-store-address") (result i32)
-    (block i32 (f64.store (br 0 (i32.const 30)) (f64.const 7)) (i32.const -1))
+    (block (result i32)
+      (f64.store (br 0 (i32.const 30)) (f64.const 7)) (i32.const -1)
+    )
   )
   (func (export "as-store-value") (result i32)
-    (block i32 (i64.store (i32.const 2) (br 0 (i32.const 31))) (i32.const -1))
+    (block (result i32)
+      (i64.store (i32.const 2) (br 0 (i32.const 31))) (i32.const -1)
+    )
   )
 
   (func (export "as-storeN-address") (result i32)
-    (block i32 (i32.store8 (br 0 (i32.const 32)) (i32.const 7)) (i32.const -1))
+    (block (result i32)
+      (i32.store8 (br 0 (i32.const 32)) (i32.const 7)) (i32.const -1)
+    )
   )
   (func (export "as-storeN-value") (result i32)
-    (block i32 (i64.store16 (i32.const 2) (br 0 (i32.const 33))) (i32.const -1))
+    (block (result i32)
+      (i64.store16 (i32.const 2) (br 0 (i32.const 33))) (i32.const -1)
+    )
   )
 
   (func (export "as-unary-operand") (result f32)
-    (block f32 (f32.neg (br 0 (f32.const 3.4))))
+    (block (result f32) (f32.neg (br 0 (f32.const 3.4))))
   )
 
   (func (export "as-binary-left") (result i32)
-    (block i32 (i32.add (br 0 (i32.const 3)) (i32.const 10)))
+    (block (result i32) (i32.add (br 0 (i32.const 3)) (i32.const 10)))
   )
   (func (export "as-binary-right") (result i64)
-    (block i64 (i64.sub (i64.const 10) (br 0 (i64.const 45))))
+    (block (result i64) (i64.sub (i64.const 10) (br 0 (i64.const 45))))
   )
 
   (func (export "as-test-operand") (result i32)
-    (block i32 (i32.eqz (br 0 (i32.const 44))))
+    (block (result i32) (i32.eqz (br 0 (i32.const 44))))
   )
 
   (func (export "as-compare-left") (result i32)
-    (block i32 (f64.le (br 0 (i32.const 43)) (f64.const 10)))
+    (block (result i32) (f64.le (br 0 (i32.const 43)) (f64.const 10)))
   )
   (func (export "as-compare-right") (result i32)
-    (block i32 (f32.ne (f32.const 10) (br 0 (i32.const 42))))
+    (block (result i32) (f32.ne (f32.const 10) (br 0 (i32.const 42))))
   )
 
   (func (export "as-convert-operand") (result i32)
-    (block i32 (i32.wrap/i64 (br 0 (i32.const 41))))
+    (block (result i32) (i32.wrap/i64 (br 0 (i32.const 41))))
   )
 
   (func (export "as-grow_memory-size") (result i32)
-    (block i32 (grow_memory (br 0 (i32.const 40))))
+    (block (result i32) (grow_memory (br 0 (i32.const 40))))
   )
 
   (func (export "nested-block-value") (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (call $dummy)
         (i32.add (i32.const 4) (br 0 (i32.const 8)))
       )
@@ -216,10 +255,10 @@
   (func (export "nested-br-value") (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (drop (i32.const 2))
         (drop
-          (block i32
+          (block (result i32)
             (drop (i32.const 4))
             (br 0 (br 1 (i32.const 8)))
           )
@@ -232,10 +271,10 @@
   (func (export "nested-br_if-value") (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (drop (i32.const 2))
         (drop
-          (block i32
+          (block (result i32)
             (drop (i32.const 4))
             (drop (br_if 0 (br 1 (i32.const 8)) (i32.const 1)))
             (i32.const 32)
@@ -249,7 +288,7 @@
   (func (export "nested-br_if-value-cond") (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (drop (i32.const 2))
         (drop (br_if 0 (i32.const 4) (br 0 (i32.const 8))))
         (i32.const 16)
@@ -260,10 +299,10 @@
   (func (export "nested-br_table-value") (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (drop (i32.const 2))
         (drop
-          (block i32
+          (block (result i32)
             (drop (i32.const 4))
             (br_table 0 (br 1 (i32.const 8)) (i32.const 1))
           )
@@ -276,7 +315,7 @@
   (func (export "nested-br_table-value-index") (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (drop (i32.const 2))
         (br_table 0 (i32.const 4) (br 0 (i32.const 8)))
         (i32.const 16)
@@ -370,26 +409,26 @@
 
 (assert_invalid
   (module (func $type-arg-empty-vs-num (result i32)
-    (block i32 (br 0) (i32.const 1))
+    (block (result i32) (br 0) (i32.const 1))
   ))
   "type mismatch"
 )
 
 (assert_invalid
   (module (func $type-arg-void-vs-num (result i32)
-    (block i32 (br 0 (nop)) (i32.const 1))
+    (block (result i32) (br 0 (nop)) (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-arg-void-vs-num-nested (result i32)
-    (block i32 (i32.const 0) (block (br 1)))
+    (block (result i32) (i32.const 0) (block (br 1)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-arg-num-vs-num (result i32)
-    (block i32 (br 0 (i64.const 1)) (i32.const 1))
+    (block (result i32) (br 0 (i64.const 1)) (i32.const 1))
   ))
   "type mismatch"
 )
diff --git a/test/core/br_if.wast b/test/core/br_if.wast
index 6fcfc649b..0aa46d471 100644
--- a/test/core/br_if.wast
+++ b/test/core/br_if.wast
@@ -14,13 +14,19 @@
     (block (call $dummy) (call $dummy) (br_if 0 (get_local 0)))
   )
   (func (export "as-block-first-value") (param i32) (result i32)
-    (block i32 (drop (br_if 0 (i32.const 10) (get_local 0))) (return (i32.const 11)))
+    (block (result i32)
+      (drop (br_if 0 (i32.const 10) (get_local 0))) (return (i32.const 11))
+    )
   )
   (func (export "as-block-mid-value") (param i32) (result i32)
-    (block i32 (call $dummy) (drop (br_if 0 (i32.const 20) (get_local 0))) (return (i32.const 21)))
+    (block (result i32)
+      (call $dummy)
+      (drop (br_if 0 (i32.const 20) (get_local 0)))
+      (return (i32.const 21))
+    )
   )
   (func (export "as-block-last-value") (param i32) (result i32)
-    (block i32
+    (block (result i32)
       (call $dummy) (call $dummy) (br_if 0 (i32.const 11) (get_local 0))
     )
   )
@@ -37,20 +43,24 @@
   )
 
   (func (export "as-if-then") (param i32 i32)
-    (block (if (get_local 0) (br_if 1 (get_local 1)) (call $dummy)))
+    (block
+      (if (get_local 0) (then (br_if 1 (get_local 1))) (else (call $dummy)))
+    )
   )
   (func (export "as-if-else") (param i32 i32)
-    (block (if (get_local 0) (call $dummy) (br_if 1 (get_local 1))))
+    (block
+      (if (get_local 0) (then (call $dummy)) (else (br_if 1 (get_local 1))))
+    )
   )
 
   (func (export "nested-block-value") (param i32) (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (drop (i32.const 2))
         (i32.add
           (i32.const 4)
-          (block i32
+          (block (result i32)
             (drop (br_if 1 (i32.const 8) (get_local 0)))
             (i32.const 16)
           )
@@ -62,10 +72,12 @@
   (func (export "nested-br-value") (param i32) (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (drop (i32.const 2))
         (br 0
-          (block i32 (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4))
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4)
+          )
         )
         (i32.const 16)
       )
@@ -75,10 +87,12 @@
   (func (export "nested-br_if-value") (param i32) (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (drop (i32.const 2))
         (drop (br_if 0
-          (block i32 (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4))
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4)
+          )
           (i32.const 1)
         ))
         (i32.const 16)
@@ -89,11 +103,13 @@
   (func (export "nested-br_if-value-cond") (param i32) (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (drop (i32.const 2))
         (drop (br_if 0
           (i32.const 4)
-          (block i32 (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 1))
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 1)
+          )
         ))
         (i32.const 16)
       )
@@ -103,10 +119,12 @@
   (func (export "nested-br_table-value") (param i32) (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (drop (i32.const 2))
         (br_table 0
-          (block i32 (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4))
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4)
+          )
           (i32.const 1)
         )
         (i32.const 16)
@@ -117,11 +135,13 @@
   (func (export "nested-br_table-value-index") (param i32) (result i32)
     (i32.add
       (i32.const 1)
-      (block i32
+      (block (result i32)
         (drop (i32.const 2))
         (br_table 0
           (i32.const 4)
-          (block i32 (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 1))
+          (block (result i32)
+            (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 1)
+          )
         )
         (i32.const 16)
       )
@@ -203,13 +223,13 @@
 
 (assert_invalid
   (module (func $type-false-arg-void-vs-num (result i32)
-    (block i32 (br_if 0 (i32.const 0)) (i32.const 1))
+    (block (result i32) (br_if 0 (i32.const 0)) (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-true-arg-void-vs-num (result i32)
-    (block i32 (br_if 0 (i32.const 1)) (i32.const 1))
+    (block (result i32) (br_if 0 (i32.const 1)) (i32.const 1))
   ))
   "type mismatch"
 )
@@ -228,25 +248,29 @@
 
 (assert_invalid
   (module (func $type-false-arg-void-vs-num (result i32)
-    (block i32 (br_if 0 (nop) (i32.const 0)) (i32.const 1))
+    (block (result i32) (br_if 0 (nop) (i32.const 0)) (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-true-arg-void-vs-num (result i32)
-    (block i32 (br_if 0 (nop) (i32.const 1)) (i32.const 1))
+    (block (result i32) (br_if 0 (nop) (i32.const 1)) (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-false-arg-num-vs-num (result i32)
-    (block i32 (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1))
+    (block (result i32)
+      (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)
+    )
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-true-arg-num-vs-num (result i32)
-    (block i32 (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1))
+    (block (result i32)
+      (drop (br_if 0 (i64.const 1) (i32.const 0))) (i32.const 1)
+    )
   ))
   "type mismatch"
 )
@@ -265,19 +289,19 @@
 )
 (assert_invalid
   (module (func $type-arg-cond-void-vs-i32 (result i32)
-    (block i32 (br_if 0 (i32.const 0) (nop)) (i32.const 1))
+    (block (result i32) (br_if 0 (i32.const 0) (nop)) (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-arg-void-vs-num-nested (result i32)
-    (block i32 (i32.const 0) (block (br_if 1 (i32.const 1))))
+    (block (result i32) (i32.const 0) (block (br_if 1 (i32.const 1))))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-arg-cond-num-vs-i32 (result i32)
-    (block i32 (br_if 0 (i32.const 0) (i64.const 0)) (i32.const 1))
+    (block (result i32) (br_if 0 (i32.const 0) (i64.const 0)) (i32.const 1))
   ))
   "type mismatch"
 )
diff --git a/test/core/br_table.wast b/test/core/br_table.wast
index 19a236f85..c8d6082d7 100644
--- a/test/core/br_table.wast
+++ b/test/core/br_table.wast
@@ -18,16 +18,16 @@
   )
 
   (func (export "type-i32-value") (result i32)
-    (block i32 (i32.ctz (br_table 0 0 (i32.const 1) (i32.const 0))))
+    (block (result i32) (i32.ctz (br_table 0 0 (i32.const 1) (i32.const 0))))
   )
   (func (export "type-i64-value") (result i64)
-    (block i64 (i64.ctz (br_table 0 0 (i64.const 2) (i32.const 0))))
+    (block (result i64) (i64.ctz (br_table 0 0 (i64.const 2) (i32.const 0))))
   )
   (func (export "type-f32-value") (result f32)
-    (block f32 (f32.neg (br_table 0 0 (f32.const 3) (i32.const 0))))
+    (block (result f32) (f32.neg (br_table 0 0 (f32.const 3) (i32.const 0))))
   )
   (func (export "type-f64-value") (result f64)
-    (block f64 (f64.neg (br_table 0 0 (f64.const 4) (i32.const 0))))
+    (block (result f64) (f64.neg (br_table 0 0 (f64.const 4) (i32.const 0))))
   )
 
   (func (export "empty") (param i32) (result i32)
@@ -35,7 +35,9 @@
     (i32.const 22)
   )
   (func (export "empty-value") (param i32) (result i32)
-    (block i32 (br_table 0 (i32.const 33) (get_local 0)) (i32.const 31))
+    (block (result i32)
+      (br_table 0 (i32.const 33) (get_local 0)) (i32.const 31)
+    )
   )
 
   (func (export "singleton") (param i32) (result i32)
@@ -50,9 +52,9 @@
   )
 
   (func (export "singleton-value") (param i32) (result i32)
-    (block i32
+    (block (result i32)
       (drop
-        (block i32
+        (block (result i32)
           (br_table 0 1 (i32.const 33) (get_local 0))
           (return (i32.const 31))
         )
@@ -83,11 +85,11 @@
 
   (func (export "multiple-value") (param i32) (result i32)
     (local i32)
-    (set_local 1 (block i32
-      (set_local 1 (block i32
-        (set_local 1 (block i32
-          (set_local 1 (block i32
-            (set_local 1 (block i32
+    (set_local 1 (block (result i32)
+      (set_local 1 (block (result i32)
+        (set_local 1 (block (result i32)
+          (set_local 1 (block (result i32)
+            (set_local 1 (block (result i32)
               (br_table 3 2 1 0 4 (i32.const 200) (get_local 0))
               (return (i32.add (get_local 1) (i32.const 99)))
             ))
@@ -849,38 +851,42 @@
     (block (nop) (call $dummy) (br_table 0 0 0 (i32.const 0)))
   )
   (func (export "as-block-value") (result i32)
-    (block i32 (nop) (call $dummy) (br_table 0 0 0 (i32.const 2) (i32.const 0)))
+    (block (result i32)
+      (nop) (call $dummy) (br_table 0 0 0 (i32.const 2) (i32.const 0))
+    )
   )
 
   (func (export "as-loop-first") (result i32)
-    (loop i32 (br_table 1 1 (i32.const 3) (i32.const 0)) (i32.const 1))
+    (loop (result i32) (br_table 1 1 (i32.const 3) (i32.const 0)) (i32.const 1))
   )
   (func (export "as-loop-mid") (result i32)
-    (loop i32
+    (loop (result i32)
       (call $dummy)
       (br_table 1 1 1 (i32.const 4) (i32.const -1))
       (i32.const 2)
     )
   )
   (func (export "as-loop-last") (result i32)
-    (loop i32 (nop) (call $dummy) (br_table 1 1 1 (i32.const 5) (i32.const 1)))
+    (loop (result i32)
+      (nop) (call $dummy) (br_table 1 1 1 (i32.const 5) (i32.const 1))
+    )
   )
 
   (func (export "as-br-value") (result i32)
-    (block i32 (br 0 (br 0 (i32.const 9))))
+    (block (result i32) (br 0 (br 0 (i32.const 9))))
   )
 
   (func (export "as-br_if-cond")
     (block (br_if 0 (br_table 0 0 0 (i32.const 1))))
   )
   (func (export "as-br_if-value") (result i32)
-    (block i32
+    (block (result i32)
       (drop (br_if 0 (br_table 0 (i32.const 8) (i32.const 0)) (i32.const 1)))
       (i32.const 7)
     )
   )
   (func (export "as-br_if-value-cond") (result i32)
-    (block i32
+    (block (result i32)
       (drop (br_if 0 (i32.const 6) (br_table 0 0 (i32.const 9) (i32.const 0))))
       (i32.const 7)
     )
@@ -890,66 +896,66 @@
     (block (br_table 0 0 0 (br_table 0 (i32.const 1))))
   )
   (func (export "as-br_table-value") (result i32)
-    (block i32
+    (block (result i32)
       (br_table 0 0 0 (br_table 0 (i32.const 10) (i32.const 0)) (i32.const 1))
       (i32.const 7)
     )
   )
   (func (export "as-br_table-value-index") (result i32)
-    (block i32
+    (block (result i32)
       (br_table 0 0 (i32.const 6) (br_table 0 (i32.const 11) (i32.const 1)))
       (i32.const 7)
     )
   )
 
   (func (export "as-return-value") (result i64)
-    (block i64 (return (br_table 0 (i64.const 7) (i32.const 0))))
+    (block (result i64) (return (br_table 0 (i64.const 7) (i32.const 0))))
   )
 
   (func (export "as-if-cond") (result i32)
-    (block i32
-      (if i32
+    (block (result i32)
+      (if (result i32)
         (br_table 0 (i32.const 2) (i32.const 0))
-        (i32.const 0)
-        (i32.const 1)
+        (then (i32.const 0))
+        (else (i32.const 1))
       )
     )
   )
   (func (export "as-if-then") (param i32 i32) (result i32)
-    (block i32
-      (if i32
+    (block (result i32)
+      (if (result i32)
         (get_local 0)
-        (br_table 1 (i32.const 3) (i32.const 0))
-        (get_local 1)
+        (then (br_table 1 (i32.const 3) (i32.const 0)))
+        (else (get_local 1))
       )
     )
   )
   (func (export "as-if-else") (param i32 i32) (result i32)
-    (block i32
-      (if i32
+    (block (result i32)
+      (if (result i32)
         (get_local 0)
-        (get_local 1)
-        (br_table 1 0 (i32.const 4) (i32.const 0))
+        (then (get_local 1))
+        (else (br_table 1 0 (i32.const 4) (i32.const 0)))
       )
     )
   )
 
   (func (export "as-select-first") (param i32 i32) (result i32)
-    (block i32
+    (block (result i32)
       (select
         (br_table 0 (i32.const 5) (i32.const 0)) (get_local 0) (get_local 1)
       )
     )
   )
   (func (export "as-select-second") (param i32 i32) (result i32)
-    (block i32
+    (block (result i32)
       (select
         (get_local 0) (br_table 0 (i32.const 6) (i32.const 1)) (get_local 1)
       )
     )
   )
   (func (export "as-select-cond") (result i32)
-    (block i32
+    (block (result i32)
       (select
         (i32.const 0) (i32.const 1) (br_table 0 (i32.const 7) (i32.const 1))
       )
@@ -958,21 +964,21 @@
 
   (func $f (param i32 i32 i32) (result i32) (i32.const -1))
   (func (export "as-call-first") (result i32)
-    (block i32
+    (block (result i32)
       (call $f
         (br_table 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
       )
     )
   )
   (func (export "as-call-mid") (result i32)
-    (block i32
+    (block (result i32)
       (call $f
         (i32.const 1) (br_table 0 (i32.const 13) (i32.const 1)) (i32.const 3)
       )
     )
   )
   (func (export "as-call-last") (result i32)
-    (block i32
+    (block (result i32)
       (call $f
         (i32.const 1) (i32.const 2) (br_table 0 (i32.const 14) (i32.const 1))
       )
@@ -982,7 +988,7 @@
   (type $sig (func (param i32 i32 i32) (result i32)))
   (table anyfunc (elem $f))
   (func (export "as-call_indirect-first") (result i32)
-    (block i32
+    (block (result i32)
       (call_indirect $sig
         (br_table 0 (i32.const 20) (i32.const 1)) (i32.const 1) (i32.const 2)
         (i32.const 3)
@@ -990,7 +996,7 @@
     )
   )
   (func (export "as-call_indirect-mid") (result i32)
-    (block i32
+    (block (result i32)
       (call_indirect $sig
         (i32.const 0) (br_table 0 (i32.const 21) (i32.const 1)) (i32.const 2)
         (i32.const 3)
@@ -998,7 +1004,7 @@
     )
   )
   (func (export "as-call_indirect-last") (result i32)
-    (block i32
+    (block (result i32)
       (call_indirect $sig
         (i32.const 0) (i32.const 1) (br_table 0 (i32.const 22) (i32.const 1))
         (i32.const 3)
@@ -1006,7 +1012,7 @@
     )
   )
   (func (export "as-call_indirect-func") (result i32)
-    (block i32
+    (block (result i32)
       (call_indirect $sig
         (i32.const 0) (i32.const 1) (i32.const 2)
         (br_table 0 (i32.const 23) (i32.const 1))
@@ -1016,7 +1022,7 @@
 
   (func (export "as-set_local-value") (result i32)
     (local f32)
-    (block i32
+    (block (result i32)
       (set_local 0 (br_table 0 (i32.const 17) (i32.const 1)))
       (i32.const -1)
     )
@@ -1024,85 +1030,87 @@
 
   (memory 1)
   (func (export "as-load-address") (result f32)
-    (block f32 (f32.load (br_table 0 (f32.const 1.7) (i32.const 1))))
+    (block (result f32) (f32.load (br_table 0 (f32.const 1.7) (i32.const 1))))
   )
   (func (export "as-loadN-address") (result i64)
-    (block i64 (i64.load8_s (br_table 0 (i64.const 30) (i32.const 1))))
+    (block (result i64) (i64.load8_s (br_table 0 (i64.const 30) (i32.const 1))))
   )
 
   (func (export "as-store-address") (result i32)
-    (block i32
+    (block (result i32)
       (f64.store (br_table 0 (i32.const 30) (i32.const 1)) (f64.const 7))
       (i32.const -1)
     )
   )
   (func (export "as-store-value") (result i32)
-    (block i32
+    (block (result i32)
       (i64.store (i32.const 2) (br_table 0 (i32.const 31) (i32.const 1)))
       (i32.const -1)
      )
   )
 
   (func (export "as-storeN-address") (result i32)
-    (block i32
+    (block (result i32)
       (i32.store8 (br_table 0 (i32.const 32) (i32.const 0)) (i32.const 7))
       (i32.const -1)
     )
   )
   (func (export "as-storeN-value") (result i32)
-    (block i32
+    (block (result i32)
       (i64.store16 (i32.const 2) (br_table 0 (i32.const 33) (i32.const 0)))
       (i32.const -1)
     )
   )
 
   (func (export "as-unary-operand") (result f32)
-    (block f32 (f32.neg (br_table 0 (f32.const 3.4) (i32.const 0))))
+    (block (result f32) (f32.neg (br_table 0 (f32.const 3.4) (i32.const 0))))
   )
 
   (func (export "as-binary-left") (result i32)
-    (block i32
+    (block (result i32)
       (i32.add (br_table 0 0 (i32.const 3) (i32.const 0)) (i32.const 10))
     )
   )
   (func (export "as-binary-right") (result i64)
-    (block i64
+    (block (result i64)
       (i64.sub (i64.const 10) (br_table 0 (i64.const 45) (i32.const 0)))
     )
   )
 
   (func (export "as-test-operand") (result i32)
-    (block i32 (i32.eqz (br_table 0 (i32.const 44) (i32.const 0))))
+    (block (result i32) (i32.eqz (br_table 0 (i32.const 44) (i32.const 0))))
   )
 
   (func (export "as-compare-left") (result i32)
-    (block i32
+    (block (result i32)
       (f64.le (br_table 0 0 (i32.const 43) (i32.const 0)) (f64.const 10))
     )
   )
   (func (export "as-compare-right") (result i32)
-    (block i32
+    (block (result i32)
       (f32.ne (f32.const 10) (br_table 0 (i32.const 42) (i32.const 0)))
     )
   )
 
   (func (export "as-convert-operand") (result i32)
-    (block i32 (i32.wrap/i64 (br_table 0 (i32.const 41) (i32.const 0))))
+    (block (result i32)
+      (i32.wrap/i64 (br_table 0 (i32.const 41) (i32.const 0)))
+    )
   )
 
   (func (export "as-grow_memory-size") (result i32)
-    (block i32 (grow_memory (br_table 0 (i32.const 40) (i32.const 0))))
+    (block (result i32) (grow_memory (br_table 0 (i32.const 40) (i32.const 0))))
   )
 
   (func (export "nested-block-value") (param i32) (result i32)
-    (block i32
+    (block (result i32)
       (drop (i32.const -1))
       (i32.add
         (i32.const 1)
-        (block i32
+        (block (result i32)
           (i32.add
             (i32.const 2)
-            (block i32
+            (block (result i32)
               (drop (i32.const 4))
               (i32.add
                 (i32.const 8)
@@ -1116,13 +1124,13 @@
   )
 
   (func (export "nested-br-value") (param i32) (result i32)
-    (block i32
+    (block (result i32)
       (i32.add
         (i32.const 1)
-        (block i32
+        (block (result i32)
           (drop (i32.const 2))
           (drop
-            (block i32
+            (block (result i32)
               (drop (i32.const 4))
               (br 0 (br_table 2 1 0 (i32.const 8) (get_local 0)))
             )
@@ -1134,13 +1142,13 @@
   )
 
   (func (export "nested-br_if-value") (param i32) (result i32)
-    (block i32
+    (block (result i32)
       (i32.add
         (i32.const 1)
-        (block i32
+        (block (result i32)
           (drop (i32.const 2))
           (drop
-            (block i32
+            (block (result i32)
               (drop (i32.const 4))
               (drop
                 (br_if 0
@@ -1158,10 +1166,10 @@
   )
 
   (func (export "nested-br_if-value-cond") (param i32) (result i32)
-    (block i32
+    (block (result i32)
       (i32.add
         (i32.const 1)
-        (block i32
+        (block (result i32)
           (drop (i32.const 2))
           (drop
             (br_if 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (get_local 0)))
@@ -1173,13 +1181,13 @@
   )
 
   (func (export "nested-br_table-value") (param i32) (result i32)
-    (block i32
+    (block (result i32)
       (i32.add
         (i32.const 1)
-        (block i32
+        (block (result i32)
           (drop (i32.const 2))
           (drop
-            (block i32
+            (block (result i32)
               (drop (i32.const 4))
               (br_table 0 (br_table 0 1 2 (i32.const 8) (get_local 0)) (i32.const 1))
               (i32.const 32)
@@ -1192,10 +1200,10 @@
   )
 
   (func (export "nested-br_table-value-index") (param i32) (result i32)
-    (block i32
+    (block (result i32)
       (i32.add
         (i32.const 1)
-        (block i32
+        (block (result i32)
           (drop (i32.const 2))
           (br_table 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (get_local 0)))
           (i32.const 16)
@@ -1206,14 +1214,14 @@
 
   (func (export "nested-br_table-loop-block") (param i32) (result i32)
     (set_local 0
-      (loop i32
+      (loop (result i32)
         (block
           (br_table 1 0 0 (get_local 0))
         )
         (i32.const 0)
       )
     )
-    (loop i32
+    (loop (result i32)
       (block
         (br_table 0 1 1 (get_local 0))
       )
@@ -1410,20 +1418,22 @@
 
 (assert_invalid
   (module (func $type-arg-void-vs-num (result i32)
-    (block i32 (br_table 0 (nop) (i32.const 1)) (i32.const 1))
+    (block (result i32) (br_table 0 (nop) (i32.const 1)) (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-arg-num-vs-num (result i32)
-    (block i32 (br_table 0 0 0 (i64.const 1) (i32.const 1)) (i32.const 1))
+    (block (result i32)
+      (br_table 0 0 0 (i64.const 1) (i32.const 1)) (i32.const 1)
+    )
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-arg-num-vs-arg-num
     (block
-      (block f32
+      (block (result f32)
         (br_table 0 1 (f32.const 0) (i32.const 0))
       )
       (drop)
@@ -1446,19 +1456,21 @@
 )
 (assert_invalid
   (module (func $type-arg-index-void-vs-i32 (result i32)
-    (block i32 (br_table 0 0 (i32.const 0) (nop)) (i32.const 1))
+    (block (result i32) (br_table 0 0 (i32.const 0) (nop)) (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-arg-void-vs-num-nested (result i32)
-    (block i32 (i32.const 0) (block (br_table 1 (i32.const 0))))
+    (block (result i32) (i32.const 0) (block (br_table 1 (i32.const 0))))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-arg-index-num-vs-i32 (result i32)
-    (block i32 (br_table 0 0 (i32.const 0) (i64.const 0)) (i32.const 1))
+    (block (result i32)
+      (br_table 0 0 (i32.const 0) (i64.const 0)) (i32.const 1)
+    )
   ))
   "type mismatch"
 )
diff --git a/test/core/call.wast b/test/core/call.wast
index 612daf206..3a89f2323 100644
--- a/test/core/call.wast
+++ b/test/core/call.wast
@@ -45,42 +45,51 @@
   ;; Recursion
 
   (func $fac (export "fac") (param i64) (result i64)
-    (if i64 (i64.eqz (get_local 0))
-      (i64.const 1)
-      (i64.mul (get_local 0) (call $fac (i64.sub (get_local 0) (i64.const 1))))
+    (if (result i64) (i64.eqz (get_local 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (get_local 0)
+          (call $fac (i64.sub (get_local 0) (i64.const 1)))
+        )
+      )
     )
   )
 
   (func $fac-acc (export "fac-acc") (param i64 i64) (result i64)
-    (if i64 (i64.eqz (get_local 0))
-      (get_local 1)
-      (call $fac-acc
-        (i64.sub (get_local 0) (i64.const 1))
-        (i64.mul (get_local 0) (get_local 1))
+    (if (result i64) (i64.eqz (get_local 0))
+      (then (get_local 1))
+      (else
+        (call $fac-acc
+          (i64.sub (get_local 0) (i64.const 1))
+          (i64.mul (get_local 0) (get_local 1))
+        )
       )
     )
   )
 
   (func $fib (export "fib") (param i64) (result i64)
-    (if i64 (i64.le_u (get_local 0) (i64.const 1))
-      (i64.const 1)
-      (i64.add
-        (call $fib (i64.sub (get_local 0) (i64.const 2)))
-        (call $fib (i64.sub (get_local 0) (i64.const 1)))
+    (if (result i64) (i64.le_u (get_local 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call $fib (i64.sub (get_local 0) (i64.const 2)))
+          (call $fib (i64.sub (get_local 0) (i64.const 1)))
+        )
       )
     )
   )
 
   (func $even (export "even") (param i64) (result i32)
-    (if i32 (i64.eqz (get_local 0))
-      (i32.const 44)
-      (call $odd (i64.sub (get_local 0) (i64.const 1)))
+    (if (result i32) (i64.eqz (get_local 0))
+      (then (i32.const 44))
+      (else (call $odd (i64.sub (get_local 0) (i64.const 1))))
     )
   )
   (func $odd (export "odd") (param i64) (result i32)
-    (if i32 (i64.eqz (get_local 0))
-      (i32.const 99)
-      (call $even (i64.sub (get_local 0) (i64.const 1)))
+    (if (result i32) (i64.eqz (get_local 0))
+      (then (i32.const 99))
+      (else (call $even (i64.sub (get_local 0) (i64.const 1))))
     )
   )
 
diff --git a/test/core/call_indirect.wast b/test/core/call_indirect.wast
index f42ffeda5..3c27c53c6 100644
--- a/test/core/call_indirect.wast
+++ b/test/core/call_indirect.wast
@@ -102,49 +102,57 @@
   ;; Recursion
 
   (func $fac (export "fac") (type $over-i64)
-    (if i64 (i64.eqz (get_local 0))
-      (i64.const 1)
-      (i64.mul
-        (get_local 0)
-        (call_indirect $over-i64
-          (i64.sub (get_local 0) (i64.const 1))
-          (i32.const 12)
+    (if (result i64) (i64.eqz (get_local 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (get_local 0)
+          (call_indirect $over-i64
+            (i64.sub (get_local 0) (i64.const 1))
+            (i32.const 12)
+          )
         )
       )
     )
   )
 
   (func $fib (export "fib") (type $over-i64)
-    (if i64 (i64.le_u (get_local 0) (i64.const 1))
-      (i64.const 1)
-      (i64.add
-        (call_indirect $over-i64
-          (i64.sub (get_local 0) (i64.const 2))
-          (i32.const 13)
-        )
-        (call_indirect $over-i64
-          (i64.sub (get_local 0) (i64.const 1))
-          (i32.const 13)
+    (if (result i64) (i64.le_u (get_local 0) (i64.const 1))
+      (then (i64.const 1))
+      (else
+        (i64.add
+          (call_indirect $over-i64
+            (i64.sub (get_local 0) (i64.const 2))
+            (i32.const 13)
+          )
+          (call_indirect $over-i64
+            (i64.sub (get_local 0) (i64.const 1))
+            (i32.const 13)
+          )
         )
       )
     )
   )
 
   (func $even (export "even") (param i32) (result i32)
-    (if i32 (i32.eqz (get_local 0))
-      (i32.const 44)
-      (call_indirect $over-i32
-        (i32.sub (get_local 0) (i32.const 1))
-        (i32.const 15)
+    (if (result i32) (i32.eqz (get_local 0))
+      (then (i32.const 44))
+      (else
+        (call_indirect $over-i32
+          (i32.sub (get_local 0) (i32.const 1))
+          (i32.const 15)
+        )
       )
     )
   )
   (func $odd (export "odd") (param i32) (result i32)
-    (if i32 (i32.eqz (get_local 0))
-      (i32.const 99)
-      (call_indirect $over-i32
-        (i32.sub (get_local 0) (i32.const 1))
-        (i32.const 14)
+    (if (result i32) (i32.eqz (get_local 0))
+      (then (i32.const 99))
+      (else
+        (call_indirect $over-i32
+          (i32.sub (get_local 0) (i32.const 1))
+          (i32.const 14)
+        )
       )
     )
   )
diff --git a/test/core/comments.wast b/test/core/comments.wast
index 07a6298c4fea799851e0b42c8f269a25aa678366..90a64b42d9ec854f6522e940c0466eb6c1ca6de9 100644
GIT binary patch
delta 77
zcmeBS-OIXxkI~H9TEQ{c+0#?Oz(Ci~O-I4pjZ4Ftfsu)sg_Vt+gOiJ!hnJ6EKu}0n
hL{v;%LQ+avMpjO~eli!MEbIFjv))hIY|0qU2mluF4zvIO

delta 52
zcmdnX+QYhmk5OI2+9Ngd@cdMT@WXqGic69+QuC}exwtf}-!9nucE_x@JNiJ3O`Fpg
G!x;f54;NVg

diff --git a/test/core/conversions.wast b/test/core/conversions.wast
index e3c49b5de..e664e1a6e 100644
--- a/test/core/conversions.wast
+++ b/test/core/conversions.wast
@@ -69,8 +69,8 @@
 (assert_return (invoke "i32.trunc_s_f32" (f32.const -2147483648.0)) (i32.const -2147483648))
 (assert_trap (invoke "i32.trunc_s_f32" (f32.const 2147483648.0)) "integer overflow")
 (assert_trap (invoke "i32.trunc_s_f32" (f32.const -2147483904.0)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const infinity)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const -infinity)) "integer overflow")
+(assert_trap (invoke "i32.trunc_s_f32" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_s_f32" (f32.const -inf)) "integer overflow")
 (assert_trap (invoke "i32.trunc_s_f32" (f32.const nan)) "invalid conversion to integer")
 (assert_trap (invoke "i32.trunc_s_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
 (assert_trap (invoke "i32.trunc_s_f32" (f32.const -nan)) "invalid conversion to integer")
@@ -91,8 +91,8 @@
 (assert_return (invoke "i32.trunc_u_f32" (f32.const -0x1.fffffep-1)) (i32.const 0))
 (assert_trap (invoke "i32.trunc_u_f32" (f32.const 4294967296.0)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f32" (f32.const -1.0)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const infinity)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const -infinity)) "integer overflow")
+(assert_trap (invoke "i32.trunc_u_f32" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_u_f32" (f32.const -inf)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f32" (f32.const nan)) "invalid conversion to integer")
 (assert_trap (invoke "i32.trunc_u_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
 (assert_trap (invoke "i32.trunc_u_f32" (f32.const -nan)) "invalid conversion to integer")
@@ -114,8 +114,8 @@
 (assert_return (invoke "i32.trunc_s_f64" (f64.const -2147483648.0)) (i32.const -2147483648))
 (assert_trap (invoke "i32.trunc_s_f64" (f64.const 2147483648.0)) "integer overflow")
 (assert_trap (invoke "i32.trunc_s_f64" (f64.const -2147483649.0)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const infinity)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const -infinity)) "integer overflow")
+(assert_trap (invoke "i32.trunc_s_f64" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_s_f64" (f64.const -inf)) "integer overflow")
 (assert_trap (invoke "i32.trunc_s_f64" (f64.const nan)) "invalid conversion to integer")
 (assert_trap (invoke "i32.trunc_s_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
 (assert_trap (invoke "i32.trunc_s_f64" (f64.const -nan)) "invalid conversion to integer")
@@ -140,8 +140,8 @@
 (assert_trap (invoke "i32.trunc_u_f64" (f64.const 1e16)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f64" (f64.const 1e30)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f64" (f64.const 9223372036854775808)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const infinity)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const -infinity)) "integer overflow")
+(assert_trap (invoke "i32.trunc_u_f64" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_u_f64" (f64.const -inf)) "integer overflow")
 (assert_trap (invoke "i32.trunc_u_f64" (f64.const nan)) "invalid conversion to integer")
 (assert_trap (invoke "i32.trunc_u_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
 (assert_trap (invoke "i32.trunc_u_f64" (f64.const -nan)) "invalid conversion to integer")
@@ -165,8 +165,8 @@
 (assert_return (invoke "i64.trunc_s_f32" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808))
 (assert_trap (invoke "i64.trunc_s_f32" (f32.const 9223372036854775808.0)) "integer overflow")
 (assert_trap (invoke "i64.trunc_s_f32" (f32.const -9223373136366403584.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const infinity)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const -infinity)) "integer overflow")
+(assert_trap (invoke "i64.trunc_s_f32" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_s_f32" (f32.const -inf)) "integer overflow")
 (assert_trap (invoke "i64.trunc_s_f32" (f32.const nan)) "invalid conversion to integer")
 (assert_trap (invoke "i64.trunc_s_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
 (assert_trap (invoke "i64.trunc_s_f32" (f32.const -nan)) "invalid conversion to integer")
@@ -185,8 +185,8 @@
 (assert_return (invoke "i64.trunc_u_f32" (f32.const -0x1.fffffep-1)) (i64.const 0))
 (assert_trap (invoke "i64.trunc_u_f32" (f32.const 18446744073709551616.0)) "integer overflow")
 (assert_trap (invoke "i64.trunc_u_f32" (f32.const -1.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const infinity)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const -infinity)) "integer overflow")
+(assert_trap (invoke "i64.trunc_u_f32" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_u_f32" (f32.const -inf)) "integer overflow")
 (assert_trap (invoke "i64.trunc_u_f32" (f32.const nan)) "invalid conversion to integer")
 (assert_trap (invoke "i64.trunc_u_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
 (assert_trap (invoke "i64.trunc_u_f32" (f32.const -nan)) "invalid conversion to integer")
@@ -210,8 +210,8 @@
 (assert_return (invoke "i64.trunc_s_f64" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808))
 (assert_trap (invoke "i64.trunc_s_f64" (f64.const 9223372036854775808.0)) "integer overflow")
 (assert_trap (invoke "i64.trunc_s_f64" (f64.const -9223372036854777856.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const infinity)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const -infinity)) "integer overflow")
+(assert_trap (invoke "i64.trunc_s_f64" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_s_f64" (f64.const -inf)) "integer overflow")
 (assert_trap (invoke "i64.trunc_s_f64" (f64.const nan)) "invalid conversion to integer")
 (assert_trap (invoke "i64.trunc_s_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
 (assert_trap (invoke "i64.trunc_s_f64" (f64.const -nan)) "invalid conversion to integer")
@@ -234,8 +234,8 @@
 (assert_return (invoke "i64.trunc_u_f64" (f64.const 9223372036854775808)) (i64.const -9223372036854775808))
 (assert_trap (invoke "i64.trunc_u_f64" (f64.const 18446744073709551616.0)) "integer overflow")
 (assert_trap (invoke "i64.trunc_u_f64" (f64.const -1.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const infinity)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const -infinity)) "integer overflow")
+(assert_trap (invoke "i64.trunc_u_f64" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_u_f64" (f64.const -inf)) "integer overflow")
 (assert_trap (invoke "i64.trunc_u_f64" (f64.const nan)) "invalid conversion to integer")
 (assert_trap (invoke "i64.trunc_u_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
 (assert_trap (invoke "i64.trunc_u_f64" (f64.const -nan)) "invalid conversion to integer")
@@ -342,8 +342,8 @@
 (assert_return (invoke "f64.promote_f32" (f32.const 0x1p-119)) (f64.const 0x1p-119))
 ;; Generated randomly by picking a random float.
 (assert_return (invoke "f64.promote_f32" (f32.const 0x1.8f867ep+125)) (f64.const 6.6382536710104395e+37))
-(assert_return (invoke "f64.promote_f32" (f32.const infinity)) (f64.const infinity))
-(assert_return (invoke "f64.promote_f32" (f32.const -infinity)) (f64.const -infinity))
+(assert_return (invoke "f64.promote_f32" (f32.const inf)) (f64.const inf))
+(assert_return (invoke "f64.promote_f32" (f32.const -inf)) (f64.const -inf))
 (assert_return_canonical_nan (invoke "f64.promote_f32" (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "f64.promote_f32" (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "f64.promote_f32" (f32.const -nan)))
@@ -369,12 +369,12 @@
 (assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffefffffffp+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "f32.demote_f64" (f64.const -0x1.fffffefffffffp+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "f32.demote_f64" (f64.const 0x1.ffffffp+127)) (f32.const infinity))
-(assert_return (invoke "f32.demote_f64" (f64.const -0x1.ffffffp+127)) (f32.const -infinity))
+(assert_return (invoke "f32.demote_f64" (f64.const 0x1.ffffffp+127)) (f32.const inf))
+(assert_return (invoke "f32.demote_f64" (f64.const -0x1.ffffffp+127)) (f32.const -inf))
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1p-119)) (f32.const 0x1p-119))
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1.8f867ep+125)) (f32.const 0x1.8f867ep+125))
-(assert_return (invoke "f32.demote_f64" (f64.const infinity)) (f32.const infinity))
-(assert_return (invoke "f32.demote_f64" (f64.const -infinity)) (f32.const -infinity))
+(assert_return (invoke "f32.demote_f64" (f64.const inf)) (f32.const inf))
+(assert_return (invoke "f32.demote_f64" (f64.const -inf)) (f32.const -inf))
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000000000001p+0)) (f32.const 1.0))
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1.fffffffffffffp-1)) (f32.const 1.0))
 (assert_return (invoke "f32.demote_f64" (f64.const 0x1.0000010000000p+0)) (f32.const 0x1.000000p+0))
@@ -408,8 +408,8 @@
 (assert_return (invoke "f32.reinterpret_i32" (i32.const -1)) (f32.const -nan:0x7fffff))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 123456789)) (f32.const 0x1.b79a2ap-113))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const -2147483647)) (f32.const -0x1p-149))
-(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f800000)) (f32.const infinity))
-(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -infinity))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7f800000)) (f32.const inf))
+(assert_return (invoke "f32.reinterpret_i32" (i32.const 0xff800000)) (f32.const -inf))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fc00000)) (f32.const nan))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 0xffc00000)) (f32.const -nan))
 (assert_return (invoke "f32.reinterpret_i32" (i32.const 0x7fa00000)) (f32.const nan:0x200000))
@@ -421,8 +421,8 @@
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 0x8000000000000000)) (f64.const -0.0))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 1234567890)) (f64.const 0x0.00000499602d2p-1022))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const -9223372036854775807)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0000000000000)) (f64.const infinity))
-(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -infinity))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff0000000000000)) (f64.const inf))
+(assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff0000000000000)) (f64.const -inf))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff8000000000000)) (f64.const nan))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 0xfff8000000000000)) (f64.const -nan))
 (assert_return (invoke "f64.reinterpret_i64" (i64.const 0x7ff4000000000000)) (f64.const nan:0x4000000000000))
@@ -437,8 +437,8 @@
 (assert_return (invoke "i32.reinterpret_f32" (f32.const 3.1415926)) (i32.const 1078530010))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const 0x1.fffffep+127)) (i32.const 2139095039))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const -0x1.fffffep+127)) (i32.const -8388609))
-(assert_return (invoke "i32.reinterpret_f32" (f32.const infinity)) (i32.const 0x7f800000))
-(assert_return (invoke "i32.reinterpret_f32" (f32.const -infinity)) (i32.const 0xff800000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const inf)) (i32.const 0x7f800000))
+(assert_return (invoke "i32.reinterpret_f32" (f32.const -inf)) (i32.const 0xff800000))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const nan)) (i32.const 0x7fc00000))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const -nan)) (i32.const 0xffc00000))
 (assert_return (invoke "i32.reinterpret_f32" (f32.const nan:0x200000)) (i32.const 0x7fa00000))
@@ -453,8 +453,8 @@
 (assert_return (invoke "i64.reinterpret_f64" (f64.const 3.14159265358979)) (i64.const 4614256656552045841))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const 0x1.fffffffffffffp+1023)) (i64.const 9218868437227405311))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const -0x1.fffffffffffffp+1023)) (i64.const -4503599627370497))
-(assert_return (invoke "i64.reinterpret_f64" (f64.const infinity)) (i64.const 0x7ff0000000000000))
-(assert_return (invoke "i64.reinterpret_f64" (f64.const -infinity)) (i64.const 0xfff0000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const inf)) (i64.const 0x7ff0000000000000))
+(assert_return (invoke "i64.reinterpret_f64" (f64.const -inf)) (i64.const 0xfff0000000000000))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const nan)) (i64.const 0x7ff8000000000000))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const -nan)) (i64.const 0xfff8000000000000))
 (assert_return (invoke "i64.reinterpret_f64" (f64.const nan:0x4000000000000)) (i64.const 0x7ff4000000000000))
diff --git a/test/core/exports.wast b/test/core/exports.wast
index e3a0052a6..6841aa873 100644
--- a/test/core/exports.wast
+++ b/test/core/exports.wast
@@ -5,6 +5,8 @@
 (module (func) (func) (export "a" (func 0)) (export "b" (func 1)))
 
 (module (func (export "a")))
+(module (func (export "a") (export "b") (export "c")))
+(module (func (export "a") (export "b") (param i32)))
 (module (func) (export "a" (func 0)))
 (module (func $a (export "a")))
 (module (func $a) (export "a" (func $a)))
diff --git a/test/core/f32.wast b/test/core/f32.wast
index 672eca76c..2595a4ac9 100644
--- a/test/core/f32.wast
+++ b/test/core/f32.wast
@@ -44,10 +44,10 @@
 (assert_return (invoke "add" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x0p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x0p+0) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x0p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x0p+0) (f32.const nan)))
@@ -84,10 +84,10 @@
 (assert_return (invoke "add" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1p-149) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-149) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-149) (f32.const nan)))
@@ -124,10 +124,10 @@
 (assert_return (invoke "add" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1p-126) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-126) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-126) (f32.const nan)))
@@ -164,10 +164,10 @@
 (assert_return (invoke "add" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1p-1) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-1) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p-1) (f32.const nan)))
@@ -204,10 +204,10 @@
 (assert_return (invoke "add" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1p+0) (f32.const nan)))
@@ -244,10 +244,10 @@
 (assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1.921fb6p+2) (f32.const nan)))
@@ -280,14 +280,14 @@
 (assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -inf))
 (assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
 (assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -0x1.fffffep+127) (f32.const nan)))
@@ -296,46 +296,46 @@
 (assert_return_arithmetic_nan (invoke "add" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const -0x0p+0)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1p-149)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1p-126)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1p-1)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1p+0)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "add" (f32.const -infinity) (f32.const -infinity)) (f32.const -infinity))
-(assert_return_canonical_nan (invoke "add" (f32.const -infinity) (f32.const infinity)))
-(assert_return_canonical_nan (invoke "add" (f32.const infinity) (f32.const -infinity)))
-(assert_return (invoke "add" (f32.const infinity) (f32.const infinity)) (f32.const infinity))
-(assert_return_canonical_nan (invoke "add" (f32.const -infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const -infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "add" (f32.const -infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const -infinity) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "add" (f32.const infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "add" (f32.const infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const infinity) (f32.const nan:0x200000)))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "add" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "add" (f32.const -inf) (f32.const -inf)) (f32.const -inf))
+(assert_return_canonical_nan (invoke "add" (f32.const -inf) (f32.const inf)))
+(assert_return_canonical_nan (invoke "add" (f32.const inf) (f32.const -inf)))
+(assert_return (invoke "add" (f32.const inf) (f32.const inf)) (f32.const inf))
+(assert_return_canonical_nan (invoke "add" (f32.const -inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "add" (f32.const -inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -inf) (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "add" (f32.const inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "add" (f32.const inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const inf) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const 0x0p+0)))
@@ -392,14 +392,14 @@
 (assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const 0x1.fffffep+127)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
-(assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const infinity)))
-(assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const infinity)))
+(assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const inf)))
+(assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "add" (f32.const nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "add" (f32.const nan:0x200000) (f32.const inf)))
 (assert_return_canonical_nan (invoke "add" (f32.const -nan) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const -nan:0x200000) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f32.const -nan) (f32.const -nan:0x200000)))
@@ -444,10 +444,10 @@
 (assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const infinity)) (f32.const -infinity))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x0p+0) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x0p+0) (f32.const inf)) (f32.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x0p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x0p+0) (f32.const nan)))
@@ -484,10 +484,10 @@
 (assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const infinity)) (f32.const -infinity))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1p-149) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1p-149) (f32.const inf)) (f32.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-149) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-149) (f32.const nan)))
@@ -524,10 +524,10 @@
 (assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const infinity)) (f32.const -infinity))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1p-126) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1p-126) (f32.const inf)) (f32.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-126) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-126) (f32.const nan)))
@@ -564,10 +564,10 @@
 (assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const infinity)) (f32.const -infinity))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1p-1) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1p-1) (f32.const inf)) (f32.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-1) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p-1) (f32.const nan)))
@@ -604,10 +604,10 @@
 (assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const infinity)) (f32.const -infinity))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1p+0) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1p+0) (f32.const inf)) (f32.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1p+0) (f32.const nan)))
@@ -644,10 +644,10 @@
 (assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const -infinity))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.921fb6p+2) (f32.const nan)))
@@ -681,13 +681,13 @@
 (assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const infinity))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const inf))
 (assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const -infinity))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -0x1.fffffep+127) (f32.const nan)))
@@ -696,46 +696,46 @@
 (assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x0p+0)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1p-149)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1p-126)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1p-1)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1p+0)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return_canonical_nan (invoke "sub" (f32.const -infinity) (f32.const -infinity)))
-(assert_return (invoke "sub" (f32.const -infinity) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "sub" (f32.const infinity) (f32.const -infinity)) (f32.const infinity))
-(assert_return_canonical_nan (invoke "sub" (f32.const infinity) (f32.const infinity)))
-(assert_return_canonical_nan (invoke "sub" (f32.const -infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const -infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "sub" (f32.const -infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const -infinity) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "sub" (f32.const infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "sub" (f32.const infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const infinity) (f32.const nan:0x200000)))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return_canonical_nan (invoke "sub" (f32.const -inf) (f32.const -inf)))
+(assert_return (invoke "sub" (f32.const -inf) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "sub" (f32.const inf) (f32.const -inf)) (f32.const inf))
+(assert_return_canonical_nan (invoke "sub" (f32.const inf) (f32.const inf)))
+(assert_return_canonical_nan (invoke "sub" (f32.const -inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "sub" (f32.const -inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -inf) (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "sub" (f32.const inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "sub" (f32.const inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const inf) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const 0x0p+0)))
@@ -792,14 +792,14 @@
 (assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const 0x1.fffffep+127)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
-(assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const infinity)))
-(assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const infinity)))
+(assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const inf)))
+(assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "sub" (f32.const nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "sub" (f32.const nan:0x200000) (f32.const inf)))
 (assert_return_canonical_nan (invoke "sub" (f32.const -nan) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const -nan:0x200000) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f32.const -nan) (f32.const -nan:0x200000)))
@@ -844,10 +844,10 @@
 (assert_return (invoke "mul" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "mul" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const infinity)))
-(assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const infinity)))
+(assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const inf)))
+(assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "mul" (f32.const 0x0p+0) (f32.const inf)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x0p+0) (f32.const nan)))
@@ -884,10 +884,10 @@
 (assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep-22))
 (assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep-22))
 (assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep-22))
-(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p-149) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-149) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-149) (f32.const nan)))
@@ -924,10 +924,10 @@
 (assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+1))
 (assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+1))
 (assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+1))
-(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p-126) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-126) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-126) (f32.const nan)))
@@ -964,10 +964,10 @@
 (assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+126))
 (assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+126))
 (assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+126))
-(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p-1) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-1) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p-1) (f32.const nan)))
@@ -1004,10 +1004,10 @@
 (assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1p+0) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1p+0) (f32.const nan)))
@@ -1040,14 +1040,14 @@
 (assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const -0x1.3bd3cep+5))
 (assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.3bd3cep+5))
 (assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.3bd3cep+5))
-(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.921fb6p+2) (f32.const nan)))
@@ -1076,18 +1076,18 @@
 (assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -0x1.fffffep+127) (f32.const nan)))
@@ -1096,46 +1096,46 @@
 (assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const -0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const 0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f32.const infinity) (f32.const -0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f32.const infinity) (f32.const 0x0p+0)))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "mul" (f32.const -infinity) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "mul" (f32.const infinity) (f32.const infinity)) (f32.const infinity))
-(assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const -infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "mul" (f32.const -infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const -infinity) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "mul" (f32.const infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "mul" (f32.const infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const infinity) (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "mul" (f32.const -inf) (f32.const -0x0p+0)))
+(assert_return_canonical_nan (invoke "mul" (f32.const -inf) (f32.const 0x0p+0)))
+(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const -0x0p+0)))
+(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const 0x0p+0)))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1p+0)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "mul" (f32.const -inf) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "mul" (f32.const inf) (f32.const inf)) (f32.const inf))
+(assert_return_canonical_nan (invoke "mul" (f32.const -inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "mul" (f32.const -inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -inf) (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "mul" (f32.const inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const inf) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const 0x0p+0)))
@@ -1192,14 +1192,14 @@
 (assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const 0x1.fffffep+127)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
-(assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const infinity)))
-(assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const infinity)))
+(assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const inf)))
+(assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "mul" (f32.const nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "mul" (f32.const nan:0x200000) (f32.const inf)))
 (assert_return_canonical_nan (invoke "mul" (f32.const -nan) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const -nan:0x200000) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f32.const -nan) (f32.const -nan:0x200000)))
@@ -1244,10 +1244,10 @@
 (assert_return (invoke "div" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const 0x0p+0))
-(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const infinity)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x0p+0) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x0p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x0p+0) (f32.const nan)))
@@ -1256,10 +1256,10 @@
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x0p+0) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x0p+0) (f32.const nan:0x200000)))
-(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const infinity))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x0p+0)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -0x1p-149)) (f32.const 0x1p+0))
 (assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1p-149)) (f32.const -0x1p+0))
 (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1p-149)) (f32.const -0x1p+0))
@@ -1284,10 +1284,10 @@
 (assert_return (invoke "div" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const 0x0p+0))
-(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const infinity)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-149) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-149) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-149) (f32.const nan)))
@@ -1296,10 +1296,10 @@
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-149) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-149) (f32.const nan:0x200000)))
-(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const infinity))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x0p+0)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -0x1p-149)) (f32.const 0x1p+23))
 (assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1p-149)) (f32.const -0x1p+23))
 (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1p-149)) (f32.const -0x1p+23))
@@ -1324,10 +1324,10 @@
 (assert_return (invoke "div" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "div" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const 0x0p+0))
-(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const infinity)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-126) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-126) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-126) (f32.const nan)))
@@ -1336,14 +1336,14 @@
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-126) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-126) (f32.const nan:0x200000)))
-(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const infinity))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1p-149)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -0x1p-126)) (f32.const 0x1p+125))
 (assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1p-126)) (f32.const -0x1p+125))
 (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1p-126)) (f32.const -0x1p+125))
@@ -1364,10 +1364,10 @@
 (assert_return (invoke "div" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-129))
 (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-129))
 (assert_return (invoke "div" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-129))
-(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const 0x0p+0))
-(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const infinity)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p-1) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-1) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p-1) (f32.const nan)))
@@ -1376,14 +1376,14 @@
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p-1) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p-1) (f32.const nan:0x200000)))
-(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const infinity))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1p-149)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -0x1p-126)) (f32.const 0x1p+126))
 (assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1p-126)) (f32.const -0x1p+126))
 (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1p-126)) (f32.const -0x1p+126))
@@ -1404,10 +1404,10 @@
 (assert_return (invoke "div" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-128))
 (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-128))
 (assert_return (invoke "div" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-128))
-(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const 0x0p+0))
-(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const infinity)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1p+0) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1p+0) (f32.const nan)))
@@ -1416,18 +1416,18 @@
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1p+0) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1p+0) (f32.const nan:0x200000)))
-(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const infinity))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1p-126)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const 0x1.921fb6p+3))
 (assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1p-1)) (f32.const -0x1.921fb6p+3))
 (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1p-1)) (f32.const -0x1.921fb6p+3))
@@ -1444,10 +1444,10 @@
 (assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.921fb8p-126))
 (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb8p-126))
 (assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb8p-126))
-(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const 0x0p+0))
-(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1.921fb6p+2) (f32.const nan)))
@@ -1456,22 +1456,22 @@
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.921fb6p+2) (f32.const nan:0x200000)))
-(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const infinity))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1p-1)) (f32.const inf))
 (assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1p+0)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1p+0)) (f32.const -0x1.fffffep+127))
@@ -1484,10 +1484,10 @@
 (assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -0x1p+0))
 (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0))
 (assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
-(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const 0x0p+0))
-(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "div" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "div" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -0x1.fffffep+127) (f32.const nan)))
@@ -1496,46 +1496,46 @@
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "div" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "div" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return_canonical_nan (invoke "div" (f32.const -infinity) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "div" (f32.const -infinity) (f32.const infinity)))
-(assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const infinity)))
-(assert_return_canonical_nan (invoke "div" (f32.const -infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const -infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "div" (f32.const -infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const -infinity) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "div" (f32.const infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const infinity) (f32.const nan:0x200000)))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "div" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "div" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const inf)))
+(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const inf)))
+(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "div" (f32.const -inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -inf) (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "div" (f32.const inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const inf) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const 0x0p+0)))
@@ -1592,14 +1592,14 @@
 (assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const 0x1.fffffep+127)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
-(assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const infinity)))
-(assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const infinity)))
+(assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const inf)))
+(assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "div" (f32.const nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "div" (f32.const nan:0x200000) (f32.const inf)))
 (assert_return_canonical_nan (invoke "div" (f32.const -nan) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const -nan:0x200000) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f32.const -nan) (f32.const -nan:0x200000)))
@@ -1644,10 +1644,10 @@
 (assert_return (invoke "min" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "min" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const infinity)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x0p+0) (f32.const inf)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x0p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x0p+0) (f32.const nan)))
@@ -1684,10 +1684,10 @@
 (assert_return (invoke "min" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-149))
 (assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "min" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
-(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const infinity)) (f32.const -0x1p-149))
-(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const infinity)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1p-149) (f32.const inf)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x1p-149))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-149) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-149) (f32.const nan)))
@@ -1724,10 +1724,10 @@
 (assert_return (invoke "min" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-126))
 (assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "min" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126))
-(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const infinity)) (f32.const -0x1p-126))
-(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const infinity)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1p-126) (f32.const inf)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x1p-126))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-126) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-126) (f32.const nan)))
@@ -1764,10 +1764,10 @@
 (assert_return (invoke "min" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const -0x1p-1))
 (assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "min" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1))
-(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const infinity)) (f32.const -0x1p-1))
-(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const infinity)) (f32.const 0x1p-1))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1p-1) (f32.const inf)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x1p-1))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-1) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p-1) (f32.const nan)))
@@ -1804,10 +1804,10 @@
 (assert_return (invoke "min" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const -0x1p+0))
 (assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "min" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
-(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const infinity)) (f32.const -0x1p+0))
-(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const infinity)) (f32.const 0x1p+0))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1p+0) (f32.const inf)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x1p+0))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1p+0) (f32.const nan)))
@@ -1844,10 +1844,10 @@
 (assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const -0x1.921fb6p+2))
 (assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1.921fb6p+2) (f32.const nan)))
@@ -1884,10 +1884,10 @@
 (assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -0x1.fffffep+127) (f32.const nan)))
@@ -1896,46 +1896,46 @@
 (assert_return_arithmetic_nan (invoke "min" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const infinity) (f32.const -0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "min" (f32.const infinity) (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1p-149)) (f32.const -0x1p-149))
-(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1p-149)) (f32.const 0x1p-149))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1p-126)) (f32.const -0x1p-126))
-(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1p-126)) (f32.const 0x1p-126))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1p-1)) (f32.const -0x1p-1))
-(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1p-1)) (f32.const 0x1p-1))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "min" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const -infinity) (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const infinity) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "min" (f32.const infinity) (f32.const infinity)) (f32.const infinity))
-(assert_return_canonical_nan (invoke "min" (f32.const -infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const -infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "min" (f32.const -infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const -infinity) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "min" (f32.const infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "min" (f32.const infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const infinity) (f32.const nan:0x200000)))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x0p+0)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-149)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-126)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p-1)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1p+0)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "min" (f32.const -inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const -inf) (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "min" (f32.const inf) (f32.const inf)) (f32.const inf))
+(assert_return_canonical_nan (invoke "min" (f32.const -inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "min" (f32.const -inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -inf) (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "min" (f32.const inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "min" (f32.const inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const inf) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const 0x0p+0)))
@@ -1992,14 +1992,14 @@
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const 0x1.fffffep+127)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
-(assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const infinity)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const infinity)))
+(assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const inf)))
+(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "min" (f32.const nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "min" (f32.const nan:0x200000) (f32.const inf)))
 (assert_return_canonical_nan (invoke "min" (f32.const -nan) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -nan:0x200000) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f32.const -nan) (f32.const -nan:0x200000)))
@@ -2044,10 +2044,10 @@
 (assert_return (invoke "max" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x0p+0))
 (assert_return (invoke "max" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const 0x0p+0))
-(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -0x0p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const -inf)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const 0x0p+0) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x0p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x0p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x0p+0) (f32.const nan)))
@@ -2084,10 +2084,10 @@
 (assert_return (invoke "max" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-149))
 (assert_return (invoke "max" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const -0x1p-149))
-(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const 0x1p-149))
-(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -0x1p-149) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const -inf)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const 0x1p-149) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-149) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-149) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-149) (f32.const nan)))
@@ -2124,10 +2124,10 @@
 (assert_return (invoke "max" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-126))
 (assert_return (invoke "max" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const -0x1p-126))
-(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const 0x1p-126))
-(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -0x1p-126) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const -inf)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const 0x1p-126) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-126) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-126) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-126) (f32.const nan)))
@@ -2164,10 +2164,10 @@
 (assert_return (invoke "max" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const 0x1p-1))
 (assert_return (invoke "max" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const -0x1p-1))
-(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const 0x1p-1))
-(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -0x1p-1))
+(assert_return (invoke "max" (f32.const -0x1p-1) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const -inf)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const 0x1p-1) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-1) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p-1) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p-1) (f32.const nan)))
@@ -2204,10 +2204,10 @@
 (assert_return (invoke "max" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const 0x1p+0))
 (assert_return (invoke "max" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const -0x1p+0))
-(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const 0x1p+0))
-(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -0x1p+0))
+(assert_return (invoke "max" (f32.const -0x1p+0) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const -inf)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const 0x1p+0) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p+0) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1p+0) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1p+0) (f32.const nan)))
@@ -2244,10 +2244,10 @@
 (assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
 (assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1.921fb6p+2) (f32.const nan)))
@@ -2284,10 +2284,10 @@
 (assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -0x1.fffffep+127) (f32.const nan)))
@@ -2296,46 +2296,46 @@
 (assert_return_arithmetic_nan (invoke "max" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -0x0p+0))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "max" (f32.const infinity) (f32.const -0x0p+0)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -0x1p-149))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const 0x1p-149))
-(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1p-149)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -0x1p-126))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const 0x1p-126))
-(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1p-126)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -0x1p-1))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const 0x1p-1))
-(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1p-1)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -0x1p+0))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const 0x1p+0))
-(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1p+0)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "max" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "max" (f32.const -infinity) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const infinity) (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "max" (f32.const infinity) (f32.const infinity)) (f32.const infinity))
-(assert_return_canonical_nan (invoke "max" (f32.const -infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const -infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "max" (f32.const -infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const -infinity) (f32.const nan:0x200000)))
-(assert_return_canonical_nan (invoke "max" (f32.const infinity) (f32.const -nan)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const infinity) (f32.const -nan:0x200000)))
-(assert_return_canonical_nan (invoke "max" (f32.const infinity) (f32.const nan)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const infinity) (f32.const nan:0x200000)))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -0x0p+0))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x0p+0)) (f32.const 0x0p+0))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x0p+0)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -0x1p-149))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-149)) (f32.const 0x1p-149))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-149)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -0x1p-126))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-126)) (f32.const 0x1p-126))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-126)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -0x1p-1))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p-1)) (f32.const 0x1p-1))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p-1)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -0x1p+0))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1p+0)) (f32.const 0x1p+0))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1p+0)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "max" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "max" (f32.const -inf) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "max" (f32.const inf) (f32.const inf)) (f32.const inf))
+(assert_return_canonical_nan (invoke "max" (f32.const -inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "max" (f32.const -inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -inf) (f32.const nan:0x200000)))
+(assert_return_canonical_nan (invoke "max" (f32.const inf) (f32.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const inf) (f32.const -nan:0x200000)))
+(assert_return_canonical_nan (invoke "max" (f32.const inf) (f32.const nan)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const inf) (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const 0x0p+0)))
@@ -2392,14 +2392,14 @@
 (assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)))
 (assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const 0x1.fffffep+127)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)))
-(assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const infinity)))
-(assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -infinity)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -infinity)))
-(assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const infinity)))
-(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const infinity)))
+(assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const inf)))
+(assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const -inf)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const -inf)))
+(assert_return_canonical_nan (invoke "max" (f32.const nan) (f32.const inf)))
+(assert_return_arithmetic_nan (invoke "max" (f32.const nan:0x200000) (f32.const inf)))
 (assert_return_canonical_nan (invoke "max" (f32.const -nan) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -nan:0x200000) (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f32.const -nan) (f32.const -nan:0x200000)))
@@ -2430,8 +2430,8 @@
 (assert_return (invoke "sqrt" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.40d932p+1))
 (assert_return_canonical_nan (invoke "sqrt" (f32.const -0x1.fffffep+127)))
 (assert_return (invoke "sqrt" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+63))
-(assert_return_canonical_nan (invoke "sqrt" (f32.const -infinity)))
-(assert_return (invoke "sqrt" (f32.const infinity)) (f32.const infinity))
+(assert_return_canonical_nan (invoke "sqrt" (f32.const -inf)))
+(assert_return (invoke "sqrt" (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "sqrt" (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "sqrt" (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "sqrt" (f32.const nan)))
@@ -2450,8 +2450,8 @@
 (assert_return (invoke "floor" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2))
 (assert_return (invoke "floor" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "floor" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "floor" (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "floor" (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "floor" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "floor" (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "floor" (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "floor" (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "floor" (f32.const nan)))
@@ -2470,8 +2470,8 @@
 (assert_return (invoke "ceil" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.cp+2))
 (assert_return (invoke "ceil" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "ceil" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "ceil" (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "ceil" (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "ceil" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "ceil" (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "ceil" (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "ceil" (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "ceil" (f32.const nan)))
@@ -2490,8 +2490,8 @@
 (assert_return (invoke "trunc" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2))
 (assert_return (invoke "trunc" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "trunc" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "trunc" (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "trunc" (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "trunc" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "trunc" (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "trunc" (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "trunc" (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "trunc" (f32.const nan)))
@@ -2510,8 +2510,8 @@
 (assert_return (invoke "nearest" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.8p+2))
 (assert_return (invoke "nearest" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "nearest" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "nearest" (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "nearest" (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "nearest" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "nearest" (f32.const inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "nearest" (f32.const -nan)))
 (assert_return_arithmetic_nan (invoke "nearest" (f32.const -nan:0x200000)))
 (assert_return_canonical_nan (invoke "nearest" (f32.const nan)))
diff --git a/test/core/f32_bitwise.wast b/test/core/f32_bitwise.wast
index 473dba83f..12bdb866e 100644
--- a/test/core/f32_bitwise.wast
+++ b/test/core/f32_bitwise.wast
@@ -35,10 +35,10 @@
 (assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
 (assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x0p+0))
 (assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const infinity)) (f32.const 0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -infinity)) (f32.const -0x0p+0))
-(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const infinity)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const inf)) (f32.const 0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -inf)) (f32.const -0x0p+0))
+(assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const inf)) (f32.const 0x0p+0))
 (assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -nan)) (f32.const -0x0p+0))
 (assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const nan)) (f32.const 0x0p+0))
 (assert_return (invoke "copysign" (f32.const 0x0p+0) (f32.const -nan)) (f32.const -0x0p+0))
@@ -71,10 +71,10 @@
 (assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
 (assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-149))
 (assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -infinity)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const infinity)) (f32.const 0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -infinity)) (f32.const -0x1p-149))
-(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const infinity)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -inf)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const inf)) (f32.const 0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -inf)) (f32.const -0x1p-149))
+(assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const inf)) (f32.const 0x1p-149))
 (assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const -nan)) (f32.const -0x1p-149))
 (assert_return (invoke "copysign" (f32.const -0x1p-149) (f32.const nan)) (f32.const 0x1p-149))
 (assert_return (invoke "copysign" (f32.const 0x1p-149) (f32.const -nan)) (f32.const -0x1p-149))
@@ -107,10 +107,10 @@
 (assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126))
 (assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-126))
 (assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -infinity)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const infinity)) (f32.const 0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -infinity)) (f32.const -0x1p-126))
-(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const infinity)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -inf)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const inf)) (f32.const 0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -inf)) (f32.const -0x1p-126))
+(assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const inf)) (f32.const 0x1p-126))
 (assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const -nan)) (f32.const -0x1p-126))
 (assert_return (invoke "copysign" (f32.const -0x1p-126) (f32.const nan)) (f32.const 0x1p-126))
 (assert_return (invoke "copysign" (f32.const 0x1p-126) (f32.const -nan)) (f32.const -0x1p-126))
@@ -143,10 +143,10 @@
 (assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1))
 (assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (f32.const -0x1p-1))
 (assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -infinity)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const infinity)) (f32.const 0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -infinity)) (f32.const -0x1p-1))
-(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const infinity)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -inf)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const inf)) (f32.const 0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -inf)) (f32.const -0x1p-1))
+(assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const inf)) (f32.const 0x1p-1))
 (assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const -nan)) (f32.const -0x1p-1))
 (assert_return (invoke "copysign" (f32.const -0x1p-1) (f32.const nan)) (f32.const 0x1p-1))
 (assert_return (invoke "copysign" (f32.const 0x1p-1) (f32.const -nan)) (f32.const -0x1p-1))
@@ -179,10 +179,10 @@
 (assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
 (assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (f32.const -0x1p+0))
 (assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -infinity)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const infinity)) (f32.const 0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -infinity)) (f32.const -0x1p+0))
-(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const infinity)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -inf)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const inf)) (f32.const 0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -inf)) (f32.const -0x1p+0))
+(assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const inf)) (f32.const 0x1p+0))
 (assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const -nan)) (f32.const -0x1p+0))
 (assert_return (invoke "copysign" (f32.const -0x1p+0) (f32.const nan)) (f32.const 0x1p+0))
 (assert_return (invoke "copysign" (f32.const 0x1p+0) (f32.const -nan)) (f32.const -0x1p+0))
@@ -215,10 +215,10 @@
 (assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
 (assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (f32.const -0x1.921fb6p+2))
 (assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (f32.const -0x1.921fb6p+2))
-(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (f32.const -0x1.921fb6p+2))
+(assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const inf)) (f32.const 0x1.921fb6p+2))
 (assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2))
 (assert_return (invoke "copysign" (f32.const -0x1.921fb6p+2) (f32.const nan)) (f32.const 0x1.921fb6p+2))
 (assert_return (invoke "copysign" (f32.const 0x1.921fb6p+2) (f32.const -nan)) (f32.const -0x1.921fb6p+2))
@@ -251,50 +251,50 @@
 (assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const infinity)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const infinity)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -inf)) (f32.const -0x1.fffffep+127))
+(assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const inf)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "copysign" (f32.const -0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const -nan)) (f32.const -0x1.fffffep+127))
 (assert_return (invoke "copysign" (f32.const 0x1.fffffep+127) (f32.const nan)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x0p+0)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x0p+0)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-149)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-149)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-149)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-126)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-126)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-126)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p-1)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p-1)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p-1)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1p+0)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1p+0)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1p+0)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -0x1.fffffep+127)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const 0x1.fffffep+127)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const -nan)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const -infinity) (f32.const nan)) (f32.const infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const -nan)) (f32.const -infinity))
-(assert_return (invoke "copysign" (f32.const infinity) (f32.const nan)) (f32.const infinity))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x0p+0)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x0p+0)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-149)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-149)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-126)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-126)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p-1)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p-1)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1p+0)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1p+0)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1.921fb6p+2)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1.921fb6p+2)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -0x1.fffffep+127)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const 0x1.fffffep+127)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const inf)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const -nan)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const -inf) (f32.const nan)) (f32.const inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const -nan)) (f32.const -inf))
+(assert_return (invoke "copysign" (f32.const inf) (f32.const nan)) (f32.const inf))
 (assert_return (invoke "copysign" (f32.const -nan) (f32.const -0x0p+0)) (f32.const -nan))
 (assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x0p+0)) (f32.const nan))
 (assert_return (invoke "copysign" (f32.const nan) (f32.const -0x0p+0)) (f32.const -nan))
@@ -323,10 +323,10 @@
 (assert_return (invoke "copysign" (f32.const -nan) (f32.const 0x1.fffffep+127)) (f32.const nan))
 (assert_return (invoke "copysign" (f32.const nan) (f32.const -0x1.fffffep+127)) (f32.const -nan))
 (assert_return (invoke "copysign" (f32.const nan) (f32.const 0x1.fffffep+127)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const -infinity)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const -nan) (f32.const infinity)) (f32.const nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const -infinity)) (f32.const -nan))
-(assert_return (invoke "copysign" (f32.const nan) (f32.const infinity)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const -inf)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const -nan) (f32.const inf)) (f32.const nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const -inf)) (f32.const -nan))
+(assert_return (invoke "copysign" (f32.const nan) (f32.const inf)) (f32.const nan))
 (assert_return (invoke "copysign" (f32.const -nan) (f32.const -nan)) (f32.const -nan))
 (assert_return (invoke "copysign" (f32.const -nan) (f32.const nan)) (f32.const nan))
 (assert_return (invoke "copysign" (f32.const nan) (f32.const -nan)) (f32.const -nan))
@@ -345,8 +345,8 @@
 (assert_return (invoke "abs" (f32.const 0x1.921fb6p+2)) (f32.const 0x1.921fb6p+2))
 (assert_return (invoke "abs" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "abs" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "abs" (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "abs" (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "abs" (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "abs" (f32.const inf)) (f32.const inf))
 (assert_return (invoke "abs" (f32.const -nan)) (f32.const nan))
 (assert_return (invoke "abs" (f32.const nan)) (f32.const nan))
 (assert_return (invoke "neg" (f32.const -0x0p+0)) (f32.const 0x0p+0))
@@ -363,7 +363,7 @@
 (assert_return (invoke "neg" (f32.const 0x1.921fb6p+2)) (f32.const -0x1.921fb6p+2))
 (assert_return (invoke "neg" (f32.const -0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "neg" (f32.const 0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "neg" (f32.const -infinity)) (f32.const infinity))
-(assert_return (invoke "neg" (f32.const infinity)) (f32.const -infinity))
+(assert_return (invoke "neg" (f32.const -inf)) (f32.const inf))
+(assert_return (invoke "neg" (f32.const inf)) (f32.const -inf))
 (assert_return (invoke "neg" (f32.const -nan)) (f32.const nan))
 (assert_return (invoke "neg" (f32.const nan)) (f32.const -nan))
diff --git a/test/core/f32_cmp.wast b/test/core/f32_cmp.wast
index 7ad68bfd0..5bae18bcd 100644
--- a/test/core/f32_cmp.wast
+++ b/test/core/f32_cmp.wast
@@ -38,10 +38,10 @@
 (assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
@@ -78,10 +78,10 @@
 (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
@@ -118,10 +118,10 @@
 (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
@@ -158,10 +158,10 @@
 (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
@@ -198,10 +198,10 @@
 (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
@@ -238,10 +238,10 @@
 (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
@@ -278,10 +278,10 @@
 (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
@@ -290,46 +290,46 @@
 (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const -nan)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const -nan)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
@@ -386,14 +386,14 @@
 (assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -nan) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -nan) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const nan) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const nan) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
@@ -438,10 +438,10 @@
 (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x0p+0) (f32.const nan)) (i32.const 1))
@@ -478,10 +478,10 @@
 (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-149) (f32.const nan)) (i32.const 1))
@@ -518,10 +518,10 @@
 (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-126) (f32.const nan)) (i32.const 1))
@@ -558,10 +558,10 @@
 (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p-1) (f32.const nan)) (i32.const 1))
@@ -598,10 +598,10 @@
 (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1p+0) (f32.const nan)) (i32.const 1))
@@ -638,10 +638,10 @@
 (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 1))
@@ -678,10 +678,10 @@
 (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 1))
@@ -690,46 +690,46 @@
 (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const -nan)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const nan)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const -nan)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const nan)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const inf) (f32.const nan:0x200000)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 1))
@@ -786,14 +786,14 @@
 (assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -nan) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -nan) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const nan) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const nan) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f32.const nan:0x200000) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 1))
@@ -838,10 +838,10 @@
 (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
@@ -878,10 +878,10 @@
 (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
@@ -918,10 +918,10 @@
 (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
@@ -958,10 +958,10 @@
 (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
@@ -998,10 +998,10 @@
 (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
@@ -1038,10 +1038,10 @@
 (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
@@ -1078,10 +1078,10 @@
 (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
@@ -1090,46 +1090,46 @@
 (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const -nan)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const -nan)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
@@ -1186,14 +1186,14 @@
 (assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -nan) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -nan) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const nan) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const nan) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
@@ -1238,10 +1238,10 @@
 (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x0p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x0p+0) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
@@ -1278,10 +1278,10 @@
 (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-149) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-149) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
@@ -1318,10 +1318,10 @@
 (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-126) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-126) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
@@ -1358,10 +1358,10 @@
 (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p-1) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p-1) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
@@ -1398,10 +1398,10 @@
 (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1p+0) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1p+0) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
@@ -1438,10 +1438,10 @@
 (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
@@ -1478,10 +1478,10 @@
 (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
@@ -1490,46 +1490,46 @@
 (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
 (assert_return (invoke "le" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "le" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 1))
-(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 1))
-(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "le" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f32.const infinity) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const -nan)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const -nan)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "le" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
@@ -1586,14 +1586,14 @@
 (assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "le" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -nan) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -nan) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const nan) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const nan) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
@@ -1638,10 +1638,10 @@
 (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
@@ -1678,10 +1678,10 @@
 (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
@@ -1718,10 +1718,10 @@
 (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
@@ -1758,10 +1758,10 @@
 (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
@@ -1798,10 +1798,10 @@
 (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
@@ -1838,10 +1838,10 @@
 (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
@@ -1878,10 +1878,10 @@
 (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
@@ -1890,46 +1890,46 @@
 (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const -nan)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const -nan)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f32.const inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
@@ -1986,14 +1986,14 @@
 (assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -nan) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -nan) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const nan) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const nan) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
@@ -2038,10 +2038,10 @@
 (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x0p+0) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x0p+0) (f32.const nan)) (i32.const 0))
@@ -2078,10 +2078,10 @@
 (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-149) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-149) (f32.const nan)) (i32.const 0))
@@ -2118,10 +2118,10 @@
 (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-126) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-126) (f32.const nan)) (i32.const 0))
@@ -2158,10 +2158,10 @@
 (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p-1) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p-1) (f32.const nan)) (i32.const 0))
@@ -2198,10 +2198,10 @@
 (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1p+0) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1p+0) (f32.const nan)) (i32.const 0))
@@ -2238,10 +2238,10 @@
 (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.921fb6p+2) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.921fb6p+2) (f32.const nan)) (i32.const 0))
@@ -2278,10 +2278,10 @@
 (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -0x1.fffffep+127)) (i32.const 1))
 (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -0x1.fffffep+127) (f32.const nan)) (i32.const 0))
@@ -2290,46 +2290,46 @@
 (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const -nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const nan)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const 0x1.fffffep+127) (f32.const nan:0x200000)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1p-149)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1p-149)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1p-149)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1p-149)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1p-126)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1p-126)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1p-126)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1p-126)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1.921fb6p+2)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1.921fb6p+2)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const -0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const -0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const 0x1.fffffep+127)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const -nan)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const -nan:0x200000)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -infinity) (f32.const nan:0x200000)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const -nan)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const -nan:0x200000)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const infinity) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-149)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-126)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-126)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1.921fb6p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1.921fb6p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const 0x1.fffffep+127)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const 0x1.fffffep+127)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const inf) (f32.const inf)) (i32.const 1))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -inf) (f32.const nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const -nan:0x200000)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const inf) (f32.const nan:0x200000)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const 0x0p+0)) (i32.const 0))
@@ -2386,14 +2386,14 @@
 (assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan) (f32.const 0x1.fffffep+127)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const 0x1.fffffep+127)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -nan) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -nan) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const nan) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const nan) (f32.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan) (f32.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f32.const nan:0x200000) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan:0x200000) (f32.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f32.const -nan) (f32.const -nan:0x200000)) (i32.const 0))
diff --git a/test/core/f64.wast b/test/core/f64.wast
index fddd6b3c1..50db4e708 100644
--- a/test/core/f64.wast
+++ b/test/core/f64.wast
@@ -44,10 +44,10 @@
 (assert_return (invoke "add" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x0p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x0p+0) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x0p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x0p+0) (f64.const nan)))
@@ -84,10 +84,10 @@
 (assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
@@ -124,10 +124,10 @@
 (assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x1p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1022) (f64.const nan)))
@@ -164,10 +164,10 @@
 (assert_return (invoke "add" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x1p-1) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p-1) (f64.const nan)))
@@ -204,10 +204,10 @@
 (assert_return (invoke "add" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x1p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1p+0) (f64.const nan)))
@@ -244,10 +244,10 @@
 (assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
@@ -280,14 +280,14 @@
 (assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
 (assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
 (assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
@@ -296,46 +296,46 @@
 (assert_return_arithmetic_nan (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const -0x0p+0)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const -0x1p-1)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const -0x1p+0)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "add" (f64.const -infinity) (f64.const -infinity)) (f64.const -infinity))
-(assert_return_canonical_nan (invoke "add" (f64.const -infinity) (f64.const infinity)))
-(assert_return_canonical_nan (invoke "add" (f64.const infinity) (f64.const -infinity)))
-(assert_return (invoke "add" (f64.const infinity) (f64.const infinity)) (f64.const infinity))
-(assert_return_canonical_nan (invoke "add" (f64.const -infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "add" (f64.const -infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const -infinity) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "add" (f64.const infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "add" (f64.const infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const infinity) (f64.const nan:0x4000000000000)))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "add" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "add" (f64.const -inf) (f64.const -inf)) (f64.const -inf))
+(assert_return_canonical_nan (invoke "add" (f64.const -inf) (f64.const inf)))
+(assert_return_canonical_nan (invoke "add" (f64.const inf) (f64.const -inf)))
+(assert_return (invoke "add" (f64.const inf) (f64.const inf)) (f64.const inf))
+(assert_return_canonical_nan (invoke "add" (f64.const -inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "add" (f64.const -inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -inf) (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "add" (f64.const inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "add" (f64.const inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const inf) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const 0x0p+0)))
@@ -392,14 +392,14 @@
 (assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
-(assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const infinity)))
-(assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const infinity)))
+(assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const inf)))
+(assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "add" (f64.const nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "add" (f64.const nan:0x4000000000000) (f64.const inf)))
 (assert_return_canonical_nan (invoke "add" (f64.const -nan) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const -nan:0x4000000000000) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "add" (f64.const -nan) (f64.const -nan:0x4000000000000)))
@@ -444,10 +444,10 @@
 (assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const infinity)) (f64.const -infinity))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x0p+0) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x0p+0) (f64.const inf)) (f64.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x0p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x0p+0) (f64.const nan)))
@@ -484,10 +484,10 @@
 (assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const -infinity))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
@@ -524,10 +524,10 @@
 (assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const -infinity))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x1p-1022) (f64.const inf)) (f64.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1022) (f64.const nan)))
@@ -564,10 +564,10 @@
 (assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const infinity)) (f64.const -infinity))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x1p-1) (f64.const inf)) (f64.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p-1) (f64.const nan)))
@@ -604,10 +604,10 @@
 (assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const infinity)) (f64.const -infinity))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x1p+0) (f64.const inf)) (f64.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1p+0) (f64.const nan)))
@@ -644,10 +644,10 @@
 (assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const -infinity))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
@@ -681,13 +681,13 @@
 (assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
 (assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const -infinity))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
@@ -696,46 +696,46 @@
 (assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x0p+0)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x1p-1)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x1p+0)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return_canonical_nan (invoke "sub" (f64.const -infinity) (f64.const -infinity)))
-(assert_return (invoke "sub" (f64.const -infinity) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "sub" (f64.const infinity) (f64.const -infinity)) (f64.const infinity))
-(assert_return_canonical_nan (invoke "sub" (f64.const infinity) (f64.const infinity)))
-(assert_return_canonical_nan (invoke "sub" (f64.const -infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "sub" (f64.const -infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const -infinity) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "sub" (f64.const infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "sub" (f64.const infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const infinity) (f64.const nan:0x4000000000000)))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return_canonical_nan (invoke "sub" (f64.const -inf) (f64.const -inf)))
+(assert_return (invoke "sub" (f64.const -inf) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "sub" (f64.const inf) (f64.const -inf)) (f64.const inf))
+(assert_return_canonical_nan (invoke "sub" (f64.const inf) (f64.const inf)))
+(assert_return_canonical_nan (invoke "sub" (f64.const -inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "sub" (f64.const -inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -inf) (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "sub" (f64.const inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "sub" (f64.const inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const inf) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const 0x0p+0)))
@@ -792,14 +792,14 @@
 (assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
-(assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const infinity)))
-(assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const infinity)))
+(assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const inf)))
+(assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "sub" (f64.const nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "sub" (f64.const nan:0x4000000000000) (f64.const inf)))
 (assert_return_canonical_nan (invoke "sub" (f64.const -nan) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const -nan:0x4000000000000) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "sub" (f64.const -nan) (f64.const -nan:0x4000000000000)))
@@ -844,10 +844,10 @@
 (assert_return (invoke "mul" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "mul" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const infinity)))
-(assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const infinity)))
+(assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const inf)))
+(assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "mul" (f64.const 0x0p+0) (f64.const inf)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x0p+0) (f64.const nan)))
@@ -884,10 +884,10 @@
 (assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51))
 (assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp-51))
 (assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp-51))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
@@ -924,10 +924,10 @@
 (assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1))
 (assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1))
 (assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1022) (f64.const nan)))
@@ -964,10 +964,10 @@
 (assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022))
 (assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1022))
 (assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1022))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1p-1) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p-1) (f64.const nan)))
@@ -1004,10 +1004,10 @@
 (assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1p+0) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1p+0) (f64.const nan)))
@@ -1040,14 +1040,14 @@
 (assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5))
 (assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.3bd3cc9be45dep+5))
 (assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.3bd3cc9be45dep+5))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
@@ -1076,18 +1076,18 @@
 (assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
@@ -1096,46 +1096,46 @@
 (assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const -0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const 0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f64.const infinity) (f64.const -0x0p+0)))
-(assert_return_canonical_nan (invoke "mul" (f64.const infinity) (f64.const 0x0p+0)))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "mul" (f64.const -infinity) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "mul" (f64.const infinity) (f64.const infinity)) (f64.const infinity))
-(assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "mul" (f64.const -infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const -infinity) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "mul" (f64.const infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "mul" (f64.const infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const infinity) (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "mul" (f64.const -inf) (f64.const -0x0p+0)))
+(assert_return_canonical_nan (invoke "mul" (f64.const -inf) (f64.const 0x0p+0)))
+(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const -0x0p+0)))
+(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const 0x0p+0)))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "mul" (f64.const -inf) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "mul" (f64.const inf) (f64.const inf)) (f64.const inf))
+(assert_return_canonical_nan (invoke "mul" (f64.const -inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "mul" (f64.const -inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -inf) (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "mul" (f64.const inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const inf) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const 0x0p+0)))
@@ -1192,14 +1192,14 @@
 (assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
-(assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const infinity)))
-(assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const infinity)))
+(assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const inf)))
+(assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "mul" (f64.const nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "mul" (f64.const nan:0x4000000000000) (f64.const inf)))
 (assert_return_canonical_nan (invoke "mul" (f64.const -nan) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const -nan:0x4000000000000) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "mul" (f64.const -nan) (f64.const -nan:0x4000000000000)))
@@ -1244,10 +1244,10 @@
 (assert_return (invoke "div" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const infinity)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0p+0) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x0p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x0p+0) (f64.const nan)))
@@ -1256,10 +1256,10 @@
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x0p+0) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x0p+0) (f64.const nan:0x4000000000000)))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const infinity))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x0p+0)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+0))
 (assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+0))
 (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+0))
@@ -1284,10 +1284,10 @@
 (assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
@@ -1296,10 +1296,10 @@
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x0.0000000000001p-1022) (f64.const nan:0x4000000000000)))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const infinity))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x0p+0)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const 0x1p+52))
 (assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x0.0000000000001p-1022)) (f64.const -0x1p+52))
 (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x1p+52))
@@ -1324,10 +1324,10 @@
 (assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1022) (f64.const nan)))
@@ -1336,14 +1336,14 @@
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1p-1022) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1022) (f64.const nan:0x4000000000000)))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -0x1p-1022)) (f64.const 0x1p+1021))
 (assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1p-1022)) (f64.const -0x1p+1021))
 (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1p-1022)) (f64.const -0x1p+1021))
@@ -1364,10 +1364,10 @@
 (assert_return (invoke "div" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022))
 (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.2p-1022))
 (assert_return (invoke "div" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.2p-1022))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const infinity)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p-1) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p-1) (f64.const nan)))
@@ -1376,14 +1376,14 @@
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1p-1) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p-1) (f64.const nan:0x4000000000000)))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -0x1p-1022)) (f64.const 0x1p+1022))
 (assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1p-1022)) (f64.const -0x1p+1022))
 (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1p-1022)) (f64.const -0x1p+1022))
@@ -1404,10 +1404,10 @@
 (assert_return (invoke "div" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022))
 (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.4p-1022))
 (assert_return (invoke "div" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.4p-1022))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const infinity)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1p+0) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1p+0) (f64.const nan)))
@@ -1416,18 +1416,18 @@
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1p+0) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1p+0) (f64.const nan:0x4000000000000)))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const infinity))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1p-1022)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const 0x1.921fb54442d18p+3))
 (assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1p-1)) (f64.const -0x1.921fb54442d18p+3))
 (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1p-1)) (f64.const -0x1.921fb54442d18p+3))
@@ -1444,10 +1444,10 @@
 (assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022))
 (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d19p-1022))
 (assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d19p-1022))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
@@ -1456,22 +1456,22 @@
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.921fb54442d18p+2) (f64.const nan:0x4000000000000)))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const infinity))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p-1)) (f64.const inf))
 (assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1p+0)) (f64.const -0x1.fffffffffffffp+1023))
@@ -1484,10 +1484,10 @@
 (assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
 (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
 (assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const 0x0p+0))
-(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
@@ -1496,46 +1496,46 @@
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const -0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const -0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "div" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "div" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return_canonical_nan (invoke "div" (f64.const -infinity) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "div" (f64.const -infinity) (f64.const infinity)))
-(assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const infinity)))
-(assert_return_canonical_nan (invoke "div" (f64.const -infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "div" (f64.const -infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const -infinity) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "div" (f64.const infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const infinity) (f64.const nan:0x4000000000000)))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "div" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "div" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const inf)))
+(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const inf)))
+(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "div" (f64.const -inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -inf) (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "div" (f64.const inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const inf) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const 0x0p+0)))
@@ -1592,14 +1592,14 @@
 (assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
-(assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const infinity)))
-(assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const infinity)))
+(assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const inf)))
+(assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "div" (f64.const nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "div" (f64.const nan:0x4000000000000) (f64.const inf)))
 (assert_return_canonical_nan (invoke "div" (f64.const -nan) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const -nan:0x4000000000000) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "div" (f64.const -nan) (f64.const -nan:0x4000000000000)))
@@ -1644,10 +1644,10 @@
 (assert_return (invoke "min" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "min" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const infinity)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x0p+0) (f64.const inf)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x0p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x0p+0) (f64.const nan)))
@@ -1684,10 +1684,10 @@
 (assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
 (assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
@@ -1724,10 +1724,10 @@
 (assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
 (assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x1p-1022) (f64.const inf)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1022) (f64.const nan)))
@@ -1764,10 +1764,10 @@
 (assert_return (invoke "min" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
 (assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "min" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const infinity)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const infinity)) (f64.const 0x1p-1))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x1p-1) (f64.const inf)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x1p-1))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p-1) (f64.const nan)))
@@ -1804,10 +1804,10 @@
 (assert_return (invoke "min" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
 (assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "min" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const infinity)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const infinity)) (f64.const 0x1p+0))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x1p+0) (f64.const inf)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x1p+0))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1p+0) (f64.const nan)))
@@ -1844,10 +1844,10 @@
 (assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
 (assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
@@ -1884,10 +1884,10 @@
 (assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
@@ -1896,46 +1896,46 @@
 (assert_return_arithmetic_nan (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const infinity) (f64.const -0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "min" (f64.const infinity) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "min" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const infinity) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "min" (f64.const infinity) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const infinity) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "min" (f64.const infinity) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const -infinity) (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const infinity) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "min" (f64.const infinity) (f64.const infinity)) (f64.const infinity))
-(assert_return_canonical_nan (invoke "min" (f64.const -infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "min" (f64.const -infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const -infinity) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "min" (f64.const infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "min" (f64.const infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const infinity) (f64.const nan:0x4000000000000)))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x0p+0)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p-1)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1p+0)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "min" (f64.const -inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const -inf) (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "min" (f64.const inf) (f64.const inf)) (f64.const inf))
+(assert_return_canonical_nan (invoke "min" (f64.const -inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "min" (f64.const -inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -inf) (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "min" (f64.const inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "min" (f64.const inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const inf) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const 0x0p+0)))
@@ -1992,14 +1992,14 @@
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
-(assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const infinity)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const infinity)))
+(assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const inf)))
+(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "min" (f64.const nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "min" (f64.const nan:0x4000000000000) (f64.const inf)))
 (assert_return_canonical_nan (invoke "min" (f64.const -nan) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -nan:0x4000000000000) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "min" (f64.const -nan) (f64.const -nan:0x4000000000000)))
@@ -2044,10 +2044,10 @@
 (assert_return (invoke "max" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
 (assert_return (invoke "max" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const 0x0p+0))
-(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -0x0p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const -inf)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const 0x0p+0) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x0p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x0p+0) (f64.const nan)))
@@ -2084,10 +2084,10 @@
 (assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
 (assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x0.0000000000001p-1022) (f64.const nan)))
@@ -2124,10 +2124,10 @@
 (assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
 (assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -0x1p-1022) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const 0x1p-1022) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1022) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1022) (f64.const nan)))
@@ -2164,10 +2164,10 @@
 (assert_return (invoke "max" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
 (assert_return (invoke "max" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const -0x1p-1))
-(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -0x1p-1))
+(assert_return (invoke "max" (f64.const -0x1p-1) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const -inf)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const 0x1p-1) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p-1) (f64.const nan)))
@@ -2204,10 +2204,10 @@
 (assert_return (invoke "max" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
 (assert_return (invoke "max" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const -0x1p+0))
-(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -0x1p+0))
+(assert_return (invoke "max" (f64.const -0x1p+0) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const -inf)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const 0x1p+0) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p+0) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1p+0) (f64.const nan)))
@@ -2244,10 +2244,10 @@
 (assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
 (assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)))
@@ -2284,10 +2284,10 @@
 (assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)))
@@ -2296,46 +2296,46 @@
 (assert_return_arithmetic_nan (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -0x0p+0))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "max" (f64.const infinity) (f64.const -0x0p+0)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "max" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
-(assert_return (invoke "max" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -0x1p-1))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const 0x1p-1))
-(assert_return (invoke "max" (f64.const infinity) (f64.const -0x1p-1)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -0x1p+0))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const 0x1p+0))
-(assert_return (invoke "max" (f64.const infinity) (f64.const -0x1p+0)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "max" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "max" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "max" (f64.const -infinity) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const infinity) (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "max" (f64.const infinity) (f64.const infinity)) (f64.const infinity))
-(assert_return_canonical_nan (invoke "max" (f64.const -infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const -infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "max" (f64.const -infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const -infinity) (f64.const nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "max" (f64.const infinity) (f64.const -nan)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const infinity) (f64.const -nan:0x4000000000000)))
-(assert_return_canonical_nan (invoke "max" (f64.const infinity) (f64.const nan)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const infinity) (f64.const nan:0x4000000000000)))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -0x0p+0))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x0p+0)) (f64.const 0x0p+0))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x0p+0)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -0x1p-1022))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const 0x1p-1022))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p-1022)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -0x1p-1))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p-1)) (f64.const 0x1p-1))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p-1)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -0x1p+0))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1p+0)) (f64.const 0x1p+0))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x1p+0)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "max" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "max" (f64.const -inf) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "max" (f64.const inf) (f64.const inf)) (f64.const inf))
+(assert_return_canonical_nan (invoke "max" (f64.const -inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "max" (f64.const -inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -inf) (f64.const nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "max" (f64.const inf) (f64.const -nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const inf) (f64.const -nan:0x4000000000000)))
+(assert_return_canonical_nan (invoke "max" (f64.const inf) (f64.const nan)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const inf) (f64.const nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -0x0p+0)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const 0x0p+0)))
@@ -2392,14 +2392,14 @@
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)))
-(assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const infinity)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -infinity)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -infinity)))
-(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const infinity)))
-(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const infinity)))
+(assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const inf)))
+(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const -inf)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const -inf)))
+(assert_return_canonical_nan (invoke "max" (f64.const nan) (f64.const inf)))
+(assert_return_arithmetic_nan (invoke "max" (f64.const nan:0x4000000000000) (f64.const inf)))
 (assert_return_canonical_nan (invoke "max" (f64.const -nan) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -nan:0x4000000000000) (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "max" (f64.const -nan) (f64.const -nan:0x4000000000000)))
@@ -2430,8 +2430,8 @@
 (assert_return (invoke "sqrt" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.40d931ff62705p+1))
 (assert_return_canonical_nan (invoke "sqrt" (f64.const -0x1.fffffffffffffp+1023)))
 (assert_return (invoke "sqrt" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+511))
-(assert_return_canonical_nan (invoke "sqrt" (f64.const -infinity)))
-(assert_return (invoke "sqrt" (f64.const infinity)) (f64.const infinity))
+(assert_return_canonical_nan (invoke "sqrt" (f64.const -inf)))
+(assert_return (invoke "sqrt" (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "sqrt" (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "sqrt" (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "sqrt" (f64.const nan)))
@@ -2450,8 +2450,8 @@
 (assert_return (invoke "floor" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
 (assert_return (invoke "floor" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "floor" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "floor" (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "floor" (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "floor" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "floor" (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "floor" (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "floor" (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "floor" (f64.const nan)))
@@ -2470,8 +2470,8 @@
 (assert_return (invoke "ceil" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.cp+2))
 (assert_return (invoke "ceil" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "ceil" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "ceil" (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "ceil" (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "ceil" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "ceil" (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "ceil" (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "ceil" (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "ceil" (f64.const nan)))
@@ -2490,8 +2490,8 @@
 (assert_return (invoke "trunc" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
 (assert_return (invoke "trunc" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "trunc" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "trunc" (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "trunc" (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "trunc" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "trunc" (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "trunc" (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "trunc" (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "trunc" (f64.const nan)))
@@ -2510,8 +2510,8 @@
 (assert_return (invoke "nearest" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.8p+2))
 (assert_return (invoke "nearest" (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "nearest" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "nearest" (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "nearest" (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "nearest" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "nearest" (f64.const inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "nearest" (f64.const -nan)))
 (assert_return_arithmetic_nan (invoke "nearest" (f64.const -nan:0x4000000000000)))
 (assert_return_canonical_nan (invoke "nearest" (f64.const nan)))
diff --git a/test/core/f64_bitwise.wast b/test/core/f64_bitwise.wast
index 5b719a6e6..86c64b54d 100644
--- a/test/core/f64_bitwise.wast
+++ b/test/core/f64_bitwise.wast
@@ -35,10 +35,10 @@
 (assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
 (assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0p+0))
 (assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const infinity)) (f64.const 0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -infinity)) (f64.const -0x0p+0))
-(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const infinity)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const inf)) (f64.const 0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -inf)) (f64.const -0x0p+0))
+(assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const inf)) (f64.const 0x0p+0))
 (assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -nan)) (f64.const -0x0p+0))
 (assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const nan)) (f64.const 0x0p+0))
 (assert_return (invoke "copysign" (f64.const 0x0p+0) (f64.const -nan)) (f64.const -0x0p+0))
@@ -71,10 +71,10 @@
 (assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
 (assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x0.0000000000001p-1022))
 (assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (f64.const -0x0.0000000000001p-1022))
-(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (f64.const -0x0.0000000000001p-1022))
+(assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (f64.const 0x0.0000000000001p-1022))
 (assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022))
 (assert_return (invoke "copysign" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (f64.const 0x0.0000000000001p-1022))
 (assert_return (invoke "copysign" (f64.const 0x0.0000000000001p-1022) (f64.const -nan)) (f64.const -0x0.0000000000001p-1022))
@@ -107,10 +107,10 @@
 (assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
 (assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1022))
 (assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -infinity)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const infinity)) (f64.const 0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -infinity)) (f64.const -0x1p-1022))
-(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const infinity)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -inf)) (f64.const -0x1p-1022))
+(assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const inf)) (f64.const 0x1p-1022))
 (assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022))
 (assert_return (invoke "copysign" (f64.const -0x1p-1022) (f64.const nan)) (f64.const 0x1p-1022))
 (assert_return (invoke "copysign" (f64.const 0x1p-1022) (f64.const -nan)) (f64.const -0x1p-1022))
@@ -143,10 +143,10 @@
 (assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
 (assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p-1))
 (assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -infinity)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const infinity)) (f64.const 0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -infinity)) (f64.const -0x1p-1))
-(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const infinity)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -inf)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const inf)) (f64.const 0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -inf)) (f64.const -0x1p-1))
+(assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const inf)) (f64.const 0x1p-1))
 (assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const -nan)) (f64.const -0x1p-1))
 (assert_return (invoke "copysign" (f64.const -0x1p-1) (f64.const nan)) (f64.const 0x1p-1))
 (assert_return (invoke "copysign" (f64.const 0x1p-1) (f64.const -nan)) (f64.const -0x1p-1))
@@ -179,10 +179,10 @@
 (assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
 (assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1p+0))
 (assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -infinity)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const infinity)) (f64.const 0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -infinity)) (f64.const -0x1p+0))
-(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const infinity)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -inf)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const inf)) (f64.const 0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -inf)) (f64.const -0x1p+0))
+(assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const inf)) (f64.const 0x1p+0))
 (assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const -nan)) (f64.const -0x1p+0))
 (assert_return (invoke "copysign" (f64.const -0x1p+0) (f64.const nan)) (f64.const 0x1p+0))
 (assert_return (invoke "copysign" (f64.const 0x1p+0) (f64.const -nan)) (f64.const -0x1p+0))
@@ -215,10 +215,10 @@
 (assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
 (assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.921fb54442d18p+2))
 (assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (f64.const -0x1.921fb54442d18p+2))
-(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (f64.const -0x1.921fb54442d18p+2))
+(assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (f64.const 0x1.921fb54442d18p+2))
 (assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2))
 (assert_return (invoke "copysign" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (f64.const 0x1.921fb54442d18p+2))
 (assert_return (invoke "copysign" (f64.const 0x1.921fb54442d18p+2) (f64.const -nan)) (f64.const -0x1.921fb54442d18p+2))
@@ -251,50 +251,50 @@
 (assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (f64.const -0x1.fffffffffffffp+1023))
+(assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "copysign" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan)) (f64.const -0x1.fffffffffffffp+1023))
 (assert_return (invoke "copysign" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x0p+0)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x0p+0)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p-1022)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p-1022)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p-1)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p-1)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p-1)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1p+0)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1p+0)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1p+0)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const -nan)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const -infinity) (f64.const nan)) (f64.const infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const -nan)) (f64.const -infinity))
-(assert_return (invoke "copysign" (f64.const infinity) (f64.const nan)) (f64.const infinity))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x0p+0)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x0p+0)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p-1022)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p-1022)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p-1)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p-1)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1p+0)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1p+0)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const inf)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const -nan)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const -inf) (f64.const nan)) (f64.const inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const -nan)) (f64.const -inf))
+(assert_return (invoke "copysign" (f64.const inf) (f64.const nan)) (f64.const inf))
 (assert_return (invoke "copysign" (f64.const -nan) (f64.const -0x0p+0)) (f64.const -nan))
 (assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x0p+0)) (f64.const nan))
 (assert_return (invoke "copysign" (f64.const nan) (f64.const -0x0p+0)) (f64.const -nan))
@@ -323,10 +323,10 @@
 (assert_return (invoke "copysign" (f64.const -nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan))
 (assert_return (invoke "copysign" (f64.const nan) (f64.const -0x1.fffffffffffffp+1023)) (f64.const -nan))
 (assert_return (invoke "copysign" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const -infinity)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const -nan) (f64.const infinity)) (f64.const nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const -infinity)) (f64.const -nan))
-(assert_return (invoke "copysign" (f64.const nan) (f64.const infinity)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const -inf)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const -nan) (f64.const inf)) (f64.const nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const -inf)) (f64.const -nan))
+(assert_return (invoke "copysign" (f64.const nan) (f64.const inf)) (f64.const nan))
 (assert_return (invoke "copysign" (f64.const -nan) (f64.const -nan)) (f64.const -nan))
 (assert_return (invoke "copysign" (f64.const -nan) (f64.const nan)) (f64.const nan))
 (assert_return (invoke "copysign" (f64.const nan) (f64.const -nan)) (f64.const -nan))
@@ -345,8 +345,8 @@
 (assert_return (invoke "abs" (f64.const 0x1.921fb54442d18p+2)) (f64.const 0x1.921fb54442d18p+2))
 (assert_return (invoke "abs" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "abs" (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "abs" (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "abs" (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "abs" (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "abs" (f64.const inf)) (f64.const inf))
 (assert_return (invoke "abs" (f64.const -nan)) (f64.const nan))
 (assert_return (invoke "abs" (f64.const nan)) (f64.const nan))
 (assert_return (invoke "neg" (f64.const -0x0p+0)) (f64.const 0x0p+0))
@@ -363,7 +363,7 @@
 (assert_return (invoke "neg" (f64.const 0x1.921fb54442d18p+2)) (f64.const -0x1.921fb54442d18p+2))
 (assert_return (invoke "neg" (f64.const -0x1.fffffffffffffp+1023)) (f64.const 0x1.fffffffffffffp+1023))
 (assert_return (invoke "neg" (f64.const 0x1.fffffffffffffp+1023)) (f64.const -0x1.fffffffffffffp+1023))
-(assert_return (invoke "neg" (f64.const -infinity)) (f64.const infinity))
-(assert_return (invoke "neg" (f64.const infinity)) (f64.const -infinity))
+(assert_return (invoke "neg" (f64.const -inf)) (f64.const inf))
+(assert_return (invoke "neg" (f64.const inf)) (f64.const -inf))
 (assert_return (invoke "neg" (f64.const -nan)) (f64.const nan))
 (assert_return (invoke "neg" (f64.const nan)) (f64.const -nan))
diff --git a/test/core/f64_cmp.wast b/test/core/f64_cmp.wast
index 1c22dc418..8fe9be4e5 100644
--- a/test/core/f64_cmp.wast
+++ b/test/core/f64_cmp.wast
@@ -38,10 +38,10 @@
 (assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
@@ -78,10 +78,10 @@
 (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
@@ -118,10 +118,10 @@
 (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
@@ -158,10 +158,10 @@
 (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
@@ -198,10 +198,10 @@
 (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
@@ -238,10 +238,10 @@
 (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
@@ -278,10 +278,10 @@
 (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
@@ -290,46 +290,46 @@
 (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const -nan)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const -nan)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
@@ -386,14 +386,14 @@
 (assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -nan) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -nan) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const nan) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const nan) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "eq" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "eq" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
@@ -438,10 +438,10 @@
 (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0p+0) (f64.const nan)) (i32.const 1))
@@ -478,10 +478,10 @@
 (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 1))
@@ -518,10 +518,10 @@
 (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 1))
@@ -558,10 +558,10 @@
 (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p-1) (f64.const nan)) (i32.const 1))
@@ -598,10 +598,10 @@
 (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1p+0) (f64.const nan)) (i32.const 1))
@@ -638,10 +638,10 @@
 (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 1))
@@ -678,10 +678,10 @@
 (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 1))
@@ -690,46 +690,46 @@
 (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const -nan)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const nan)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const -nan)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const nan)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const nan)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 1))
@@ -786,14 +786,14 @@
 (assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -nan) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -nan) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const nan) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const nan) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ne" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 1))
 (assert_return (invoke "ne" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 1))
@@ -838,10 +838,10 @@
 (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
@@ -878,10 +878,10 @@
 (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
@@ -918,10 +918,10 @@
 (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
@@ -958,10 +958,10 @@
 (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
@@ -998,10 +998,10 @@
 (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
@@ -1038,10 +1038,10 @@
 (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
@@ -1078,10 +1078,10 @@
 (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
@@ -1090,46 +1090,46 @@
 (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const -nan)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const -nan)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
@@ -1186,14 +1186,14 @@
 (assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -nan) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -nan) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const nan) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const nan) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "lt" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "lt" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
@@ -1238,10 +1238,10 @@
 (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0p+0) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
@@ -1278,10 +1278,10 @@
 (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
@@ -1318,10 +1318,10 @@
 (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
@@ -1358,10 +1358,10 @@
 (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p-1) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p-1) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
@@ -1398,10 +1398,10 @@
 (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1p+0) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1p+0) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
@@ -1438,10 +1438,10 @@
 (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
@@ -1478,10 +1478,10 @@
 (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 1))
 (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
@@ -1490,46 +1490,46 @@
 (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
 (assert_return (invoke "le" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "le" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "le" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 1))
-(assert_return (invoke "le" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "le" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "le" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "le" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "le" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f64.const infinity) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const -nan)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const -nan)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "le" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "le" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
@@ -1586,14 +1586,14 @@
 (assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -nan) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -nan) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const nan) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const nan) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "le" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "le" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
@@ -1638,10 +1638,10 @@
 (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
@@ -1678,10 +1678,10 @@
 (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
@@ -1718,10 +1718,10 @@
 (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
@@ -1758,10 +1758,10 @@
 (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
@@ -1798,10 +1798,10 @@
 (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
@@ -1838,10 +1838,10 @@
 (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
@@ -1878,10 +1878,10 @@
 (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
@@ -1890,46 +1890,46 @@
 (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const -nan)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const -nan)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "gt" (f64.const inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
@@ -1986,14 +1986,14 @@
 (assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -nan) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -nan) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const nan) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const nan) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "gt" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "gt" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
@@ -2038,10 +2038,10 @@
 (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0p+0) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0p+0) (f64.const nan)) (i32.const 0))
@@ -2078,10 +2078,10 @@
 (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x0.0000000000001p-1022) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x0.0000000000001p-1022) (f64.const nan)) (i32.const 0))
@@ -2118,10 +2118,10 @@
 (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1022) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1022) (f64.const nan)) (i32.const 0))
@@ -2158,10 +2158,10 @@
 (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p-1) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p-1) (f64.const nan)) (i32.const 0))
@@ -2198,10 +2198,10 @@
 (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1p+0) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1p+0) (f64.const nan)) (i32.const 0))
@@ -2238,10 +2238,10 @@
 (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.921fb54442d18p+2) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.921fb54442d18p+2) (f64.const nan)) (i32.const 0))
@@ -2278,10 +2278,10 @@
 (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
 (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
@@ -2290,46 +2290,46 @@
 (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const -nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const 0x1.fffffffffffffp+1023) (f64.const nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x0p+0)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x0p+0)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x0p+0)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x0p+0)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x1p-1022)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x1p-1022)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x1p-1022)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x1p-1022)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x1p-1)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x1p-1)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x1p-1)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x1p-1)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x1p+0)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x1p+0)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x1p+0)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x1p+0)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const -infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const infinity)) (i32.const 1))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const -nan)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const -nan)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const -nan:0x4000000000000)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const infinity) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x0p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x0p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x0.0000000000001p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p-1022)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p-1022)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p-1)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p-1)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1p+0)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1p+0)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1.921fb54442d18p+2)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const inf) (f64.const inf)) (i32.const 1))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -inf) (f64.const nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const -nan:0x4000000000000)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const nan)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const inf) (f64.const nan:0x4000000000000)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -0x0p+0)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const 0x0p+0)) (i32.const 0))
@@ -2386,14 +2386,14 @@
 (assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const 0x1.fffffffffffffp+1023)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -nan) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -nan) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const nan) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const nan) (f64.const infinity)) (i32.const 0))
-(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const -inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan) (f64.const inf)) (i32.const 0))
+(assert_return (invoke "ge" (f64.const nan:0x4000000000000) (f64.const inf)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan:0x4000000000000) (f64.const -nan)) (i32.const 0))
 (assert_return (invoke "ge" (f64.const -nan) (f64.const -nan:0x4000000000000)) (i32.const 0))
diff --git a/test/core/fac.wast b/test/core/fac.wast
index 3b388e208..acc896231 100644
--- a/test/core/fac.wast
+++ b/test/core/fac.wast
@@ -1,19 +1,23 @@
 (module
   ;; Recursive factorial
   (func (export "fac-rec") (param i64) (result i64)
-    (if i64 (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 (result i64) (i64.eq (get_local 0) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul (get_local 0) (call 0 (i64.sub (get_local 0) (i64.const 1))))
+      )
     )
   )
 
   ;; Recursive factorial named
   (func $fac-rec-named (export "fac-rec-named") (param $n i64) (result i64)
-    (if i64 (i64.eq (get_local $n) (i64.const 0))
-      (i64.const 1)
-      (i64.mul
-        (get_local $n)
-        (call $fac-rec-named (i64.sub (get_local $n) (i64.const 1)))
+    (if (result i64) (i64.eq (get_local $n) (i64.const 0))
+      (then (i64.const 1))
+      (else
+        (i64.mul
+          (get_local $n)
+          (call $fac-rec-named (i64.sub (get_local $n) (i64.const 1)))
+        )
       )
     )
   )
@@ -27,8 +31,8 @@
       (loop
         (if
           (i64.eq (get_local 1) (i64.const 0))
-          (br 2)
-          (block
+          (then (br 2))
+          (else
             (set_local 2 (i64.mul (get_local 1) (get_local 2)))
             (set_local 1 (i64.sub (get_local 1) (i64.const 1)))
           )
@@ -49,8 +53,8 @@
       (loop $loop
         (if
           (i64.eq (get_local $i) (i64.const 0))
-          (br $done)
-          (block
+          (then (br $done))
+          (else
             (set_local $res (i64.mul (get_local $i) (get_local $res)))
             (set_local $i (i64.sub (get_local $i) (i64.const 1)))
           )
diff --git a/test/core/float_exprs.wast b/test/core/float_exprs.wast
index 3fb15b591..5cee2d46c 100644
--- a/test/core/float_exprs.wast
+++ b/test/core/float_exprs.wast
@@ -205,9 +205,9 @@
     (f64.sub (get_local $x) (get_local $x)))
 )
 
-(assert_return_canonical_nan (invoke "f32.no_fold_sub_self" (f32.const infinity)))
+(assert_return_canonical_nan (invoke "f32.no_fold_sub_self" (f32.const inf)))
 (assert_return_canonical_nan (invoke "f32.no_fold_sub_self" (f32.const nan)))
-(assert_return_canonical_nan (invoke "f64.no_fold_sub_self" (f64.const infinity)))
+(assert_return_canonical_nan (invoke "f64.no_fold_sub_self" (f64.const inf)))
 (assert_return_canonical_nan (invoke "f64.no_fold_sub_self" (f64.const nan)))
 
 ;; Test that x / x is not folded to 1.0.
@@ -219,11 +219,11 @@
     (f64.div (get_local $x) (get_local $x)))
 )
 
-(assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const infinity)))
+(assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const inf)))
 (assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const nan)))
 (assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const 0.0)))
 (assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const -0.0)))
-(assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const infinity)))
+(assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const inf)))
 (assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const nan)))
 (assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const 0.0)))
 (assert_return_canonical_nan (invoke "f64.no_fold_div_self" (f64.const -0.0)))
@@ -304,7 +304,7 @@
 (assert_return (invoke "f32.no_regroup_div_mul" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -0x1.47d0eap+66))
 (assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2dp+99))
 (assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x0p+0))
-(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const infinity))
+(assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const inf))
 (assert_return (invoke "f64.no_regroup_div_mul" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -0x1.926fa3cacc651p+255))
 (assert_return (invoke "f64.no_regroup_div_mul" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x1.38d55f56406dp-639))
 
@@ -321,11 +321,11 @@
 (assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.454738p+91) (f32.const -0x1.b28a66p-115) (f32.const -0x1.f53908p+72)) (f32.const -0x1.1a00e8p-96))
 (assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.6be56ep+16) (f32.const -0x1.b46fc6p-21) (f32.const -0x1.a51df6p-123)) (f32.const -0x1.79225ap+118))
 (assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.c343f8p-94) (f32.const 0x1.e4d906p+73) (f32.const 0x1.be69f8p+68)) (f32.const -0x1.ea1df4p-89))
-(assert_return (invoke "f32.no_regroup_mul_div" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -infinity))
+(assert_return (invoke "f32.no_regroup_mul_div" (f32.const 0x1.c6ae76p+112) (f32.const 0x1.fc953cp+24) (f32.const -0x1.60b3e8p+71)) (f32.const -inf))
 (assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.3c04b815e30bp-423) (f64.const -0x1.379646fd98127p-119) (f64.const 0x1.bddb158506031p-642)) (f64.const -0x1.b9b3301f2dd2ep+99))
 (assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.46b3a402f86d5p+337) (f64.const 0x1.6fbf1b9e1798dp-447) (f64.const -0x1.bd9704a5a6a06p+797)) (f64.const -0x1.0da0b6328e09p-907))
 (assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.6c9765bb4347fp-479) (f64.const 0x1.a4af42e34a141p+902) (f64.const 0x1.d2dde70eb68f9p-448)) (f64.const 0x1.4886b6d9a9a79p+871))
-(assert_return (invoke "f64.no_regroup_mul_div" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -infinity))
+(assert_return (invoke "f64.no_regroup_mul_div" (f64.const -0x1.706023645be72p+480) (f64.const -0x1.6c229f7d9101dp+611) (f64.const -0x1.4d50fa68d3d9ep+836)) (f64.const -inf))
 (assert_return (invoke "f64.no_regroup_mul_div" (f64.const 0x1.8cc63d8caf4c7p-599) (f64.const 0x1.8671ac4c35753p-878) (f64.const -0x1.ef35b1695e659p-838)) (f64.const -0x0p+0))
 
 ;; Test that x+y+z+w is not reassociated.
@@ -377,18 +377,18 @@
     (f64.div (get_local $x) (f64.const 0.0)))
 )
 
-(assert_return (invoke "f32.no_fold_div_0" (f32.const 1.0)) (f32.const infinity))
-(assert_return (invoke "f32.no_fold_div_0" (f32.const -1.0)) (f32.const -infinity))
-(assert_return (invoke "f32.no_fold_div_0" (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "f32.no_fold_div_0" (f32.const -infinity)) (f32.const -infinity))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const 1.0)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const -1.0)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_0" (f32.const -inf)) (f32.const -inf))
 (assert_return_canonical_nan (invoke "f32.no_fold_div_0" (f32.const 0)))
 (assert_return_canonical_nan (invoke "f32.no_fold_div_0" (f32.const -0)))
 (assert_return_arithmetic_nan (invoke "f32.no_fold_div_0" (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "f32.no_fold_div_0" (f32.const nan)))
-(assert_return (invoke "f64.no_fold_div_0" (f64.const 1.0)) (f64.const infinity))
-(assert_return (invoke "f64.no_fold_div_0" (f64.const -1.0)) (f64.const -infinity))
-(assert_return (invoke "f64.no_fold_div_0" (f64.const infinity)) (f64.const infinity))
-(assert_return (invoke "f64.no_fold_div_0" (f64.const -infinity)) (f64.const -infinity))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const 1.0)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const -1.0)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const inf)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_div_0" (f64.const -inf)) (f64.const -inf))
 (assert_return_canonical_nan (invoke "f64.no_fold_div_0" (f64.const 0)))
 (assert_return_canonical_nan (invoke "f64.no_fold_div_0" (f64.const -0)))
 (assert_return_canonical_nan (invoke "f64.no_fold_div_0" (f64.const nan)))
@@ -403,18 +403,18 @@
     (f64.div (get_local $x) (f64.const -0.0)))
 )
 
-(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 1.0)) (f32.const -infinity))
-(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -1.0)) (f32.const infinity))
-(assert_return (invoke "f32.no_fold_div_neg0" (f32.const infinity)) (f32.const -infinity))
-(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -infinity)) (f32.const infinity))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const 1.0)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -1.0)) (f32.const inf))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const inf)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_div_neg0" (f32.const -inf)) (f32.const inf))
 (assert_return_canonical_nan (invoke "f32.no_fold_div_neg0" (f32.const 0)))
 (assert_return_canonical_nan (invoke "f32.no_fold_div_neg0" (f32.const -0)))
 (assert_return_arithmetic_nan (invoke "f32.no_fold_div_neg0" (f32.const nan:0x200000)))
 (assert_return_canonical_nan (invoke "f32.no_fold_div_neg0" (f32.const nan)))
-(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 1.0)) (f64.const -infinity))
-(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -1.0)) (f64.const infinity))
-(assert_return (invoke "f64.no_fold_div_neg0" (f64.const infinity)) (f64.const -infinity))
-(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -infinity)) (f64.const infinity))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const 1.0)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -1.0)) (f64.const inf))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const inf)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_div_neg0" (f64.const -inf)) (f64.const inf))
 (assert_return_canonical_nan (invoke "f64.no_fold_div_neg0" (f64.const 0)))
 (assert_return_canonical_nan (invoke "f64.no_fold_div_neg0" (f64.const -0)))
 (assert_return_canonical_nan (invoke "f64.no_fold_div_neg0" (f64.const nan)))
@@ -646,8 +646,8 @@
 (assert_return (invoke "no_fold_promote_demote" (f32.const -0x1p-126)) (f32.const -0x1p-126))
 (assert_return (invoke "no_fold_promote_demote" (f32.const 0x1.fffffep+127)) (f32.const 0x1.fffffep+127))
 (assert_return (invoke "no_fold_promote_demote" (f32.const -0x1.fffffep+127)) (f32.const -0x1.fffffep+127))
-(assert_return (invoke "no_fold_promote_demote" (f32.const infinity)) (f32.const infinity))
-(assert_return (invoke "no_fold_promote_demote" (f32.const -infinity)) (f32.const -infinity))
+(assert_return (invoke "no_fold_promote_demote" (f32.const inf)) (f32.const inf))
+(assert_return (invoke "no_fold_promote_demote" (f32.const -inf)) (f32.const -inf))
 
 ;; Test that demote(x+promote(y)) is not folded to demote(x)+y.
 
@@ -927,15 +927,47 @@
 ;; Test that x<y?x:y, etc. using if and else aren't folded to min, etc.
 
 (module
-  (func (export "f32.no_fold_lt_if") (param $x f32) (param $y f32) (result f32) (if f32 (f32.lt (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
-  (func (export "f32.no_fold_le_if") (param $x f32) (param $y f32) (result f32) (if f32 (f32.le (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
-  (func (export "f32.no_fold_gt_if") (param $x f32) (param $y f32) (result f32) (if f32 (f32.gt (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
-  (func (export "f32.no_fold_ge_if") (param $x f32) (param $y f32) (result f32) (if f32 (f32.ge (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
+  (func (export "f32.no_fold_lt_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.lt (get_local $x) (get_local $y))
+      (then (get_local $x)) (else (get_local $y))
+    )
+  )
+  (func (export "f32.no_fold_le_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.le (get_local $x) (get_local $y))
+      (then (get_local $x)) (else (get_local $y))
+    )
+  )
+  (func (export "f32.no_fold_gt_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.gt (get_local $x) (get_local $y))
+      (then (get_local $x)) (else (get_local $y))
+    )
+  )
+  (func (export "f32.no_fold_ge_if") (param $x f32) (param $y f32) (result f32)
+    (if (result f32) (f32.ge (get_local $x) (get_local $y))
+      (then (get_local $x)) (else (get_local $y))
+    )
+  )
 
-  (func (export "f64.no_fold_lt_if") (param $x f64) (param $y f64) (result f64) (if f64 (f64.lt (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
-  (func (export "f64.no_fold_le_if") (param $x f64) (param $y f64) (result f64) (if f64 (f64.le (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
-  (func (export "f64.no_fold_gt_if") (param $x f64) (param $y f64) (result f64) (if f64 (f64.gt (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
-  (func (export "f64.no_fold_ge_if") (param $x f64) (param $y f64) (result f64) (if f64 (f64.ge (get_local $x) (get_local $y)) (get_local $x) (get_local $y)))
+  (func (export "f64.no_fold_lt_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.lt (get_local $x) (get_local $y))
+      (then (get_local $x)) (else (get_local $y))
+    )
+  )
+  (func (export "f64.no_fold_le_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.le (get_local $x) (get_local $y))
+      (then (get_local $x)) (else (get_local $y))
+    )
+  )
+  (func (export "f64.no_fold_gt_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.gt (get_local $x) (get_local $y))
+      (then (get_local $x)) (else (get_local $y))
+    )
+  )
+  (func (export "f64.no_fold_ge_if") (param $x f64) (param $y f64) (result f64)
+    (if (result f64) (f64.ge (get_local $x) (get_local $y))
+      (then (get_local $x)) (else (get_local $y))
+    )
+  )
 )
 
 (assert_return (invoke "f32.no_fold_lt_if" (f32.const 0.0) (f32.const nan)) (f32.const nan))
@@ -1021,15 +1053,47 @@
 ;; Test that x<0?-x:x, etc. using if aren't folded to abs.
 
 (module
-  (func (export "f32.no_fold_lt_if_to_abs") (param $x f32) (result f32) (if f32 (f32.lt (get_local $x) (f32.const 0.0)) (f32.neg (get_local $x)) (get_local $x)))
-  (func (export "f32.no_fold_le_if_to_abs") (param $x f32) (result f32) (if f32 (f32.le (get_local $x) (f32.const -0.0)) (f32.neg (get_local $x)) (get_local $x)))
-  (func (export "f32.no_fold_gt_if_to_abs") (param $x f32) (result f32) (if f32 (f32.gt (get_local $x) (f32.const -0.0)) (get_local $x) (f32.neg (get_local $x))))
-  (func (export "f32.no_fold_ge_if_to_abs") (param $x f32) (result f32) (if f32 (f32.ge (get_local $x) (f32.const 0.0)) (get_local $x) (f32.neg (get_local $x))))
+  (func (export "f32.no_fold_lt_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.lt (get_local $x) (f32.const 0.0))
+      (then (f32.neg (get_local $x))) (else (get_local $x))
+    )
+  )
+  (func (export "f32.no_fold_le_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.le (get_local $x) (f32.const -0.0))
+      (then (f32.neg (get_local $x))) (else (get_local $x))
+    )
+  )
+  (func (export "f32.no_fold_gt_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.gt (get_local $x) (f32.const -0.0))
+      (then (get_local $x)) (else (f32.neg (get_local $x)))
+    )
+  )
+  (func (export "f32.no_fold_ge_if_to_abs") (param $x f32) (result f32)
+    (if (result f32) (f32.ge (get_local $x) (f32.const 0.0))
+      (then (get_local $x)) (else (f32.neg (get_local $x)))
+    )
+  )
 
-  (func (export "f64.no_fold_lt_if_to_abs") (param $x f64) (result f64) (if f64 (f64.lt (get_local $x) (f64.const 0.0)) (f64.neg (get_local $x)) (get_local $x)))
-  (func (export "f64.no_fold_le_if_to_abs") (param $x f64) (result f64) (if f64 (f64.le (get_local $x) (f64.const -0.0)) (f64.neg (get_local $x)) (get_local $x)))
-  (func (export "f64.no_fold_gt_if_to_abs") (param $x f64) (result f64) (if f64 (f64.gt (get_local $x) (f64.const -0.0)) (get_local $x) (f64.neg (get_local $x))))
-  (func (export "f64.no_fold_ge_if_to_abs") (param $x f64) (result f64) (if f64 (f64.ge (get_local $x) (f64.const 0.0)) (get_local $x) (f64.neg (get_local $x))))
+  (func (export "f64.no_fold_lt_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.lt (get_local $x) (f64.const 0.0))
+      (then (f64.neg (get_local $x))) (else (get_local $x))
+    )
+  )
+  (func (export "f64.no_fold_le_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.le (get_local $x) (f64.const -0.0))
+      (then (f64.neg (get_local $x))) (else (get_local $x))
+    )
+  )
+  (func (export "f64.no_fold_gt_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.gt (get_local $x) (f64.const -0.0))
+      (then (get_local $x)) (else (f64.neg (get_local $x)))
+    )
+  )
+  (func (export "f64.no_fold_ge_if_to_abs") (param $x f64) (result f64)
+    (if (result f64) (f64.ge (get_local $x) (f64.const 0.0))
+      (then (get_local $x)) (else (f64.neg (get_local $x)))
+    )
+  )
 )
 
 (assert_return (invoke "f32.no_fold_lt_if_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
@@ -1226,8 +1290,8 @@
 
 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x0p+0)) (f32.const -0x0p+0))
 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const 0x0p+0)) (f32.const 0x0p+0))
-(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -infinity)) (f32.const -infinity))
-(assert_return (invoke "f32.no_fold_recip_recip" (f32.const infinity)) (f32.const infinity))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const -inf)) (f32.const -inf))
+(assert_return (invoke "f32.no_fold_recip_recip" (f32.const inf)) (f32.const inf))
 
 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x1.d81248dda63dp+148)) (f64.const -0x1.d81248dda63d1p+148))
 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x1.f4750312039e3p+66)) (f64.const -0x1.f4750312039e2p+66))
@@ -1237,8 +1301,8 @@
 
 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const -0x0p+0)) (f64.const -0x0p+0))
 (assert_return (invoke "f64.no_fold_recip_recip" (f64.const 0x0p+0)) (f64.const 0x0p+0))
-(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -infinity)) (f64.const -infinity))
-(assert_return (invoke "f64.no_fold_recip_recip" (f64.const infinity)) (f64.const infinity))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const -inf)) (f64.const -inf))
+(assert_return (invoke "f64.no_fold_recip_recip" (f64.const inf)) (f64.const inf))
 
 ;; Test that (x+y) * (x-y) is not optimized to x*x - y*y.
 
@@ -1589,13 +1653,13 @@
 
 (assert_return (invoke "f32.no_fold_add_neg" (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_add_neg" (f32.const -0.0)) (f32.const 0.0))
-(assert_return_canonical_nan (invoke "f32.no_fold_add_neg" (f32.const infinity)))
-(assert_return_canonical_nan (invoke "f32.no_fold_add_neg" (f32.const -infinity)))
+(assert_return_canonical_nan (invoke "f32.no_fold_add_neg" (f32.const inf)))
+(assert_return_canonical_nan (invoke "f32.no_fold_add_neg" (f32.const -inf)))
 
 (assert_return (invoke "f64.no_fold_add_neg" (f64.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.no_fold_add_neg" (f64.const -0.0)) (f64.const 0.0))
-(assert_return_canonical_nan (invoke "f64.no_fold_add_neg" (f64.const infinity)))
-(assert_return_canonical_nan (invoke "f64.no_fold_add_neg" (f64.const -infinity)))
+(assert_return_canonical_nan (invoke "f64.no_fold_add_neg" (f64.const inf)))
+(assert_return_canonical_nan (invoke "f64.no_fold_add_neg" (f64.const -inf)))
 
 ;; Test that x+x+x+x+x+x is not folded to x * 6.
 
@@ -1638,14 +1702,14 @@
 
 (assert_return (invoke "f32.no_fold_div_div" (f32.const -0x1.f70228p+78) (f32.const -0x1.fbc612p-16) (f32.const -0x1.8c379p+10)) (f32.const -0x1.47b43cp+83))
 (assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.d29d2ep-70) (f32.const 0x1.f3a17ep+110) (f32.const -0x1.64d41p-112)) (f32.const -0x0p+0))
-(assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.867f98p+43) (f32.const 0x1.30acfcp-105) (f32.const 0x1.e210d8p+105)) (f32.const infinity))
+(assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.867f98p+43) (f32.const 0x1.30acfcp-105) (f32.const 0x1.e210d8p+105)) (f32.const inf))
 (assert_return (invoke "f32.no_fold_div_div" (f32.const -0x1.c4001ap-14) (f32.const -0x1.9beb6cp+124) (f32.const -0x1.74f34cp-43)) (f32.const -0x1.819874p-96))
 (assert_return (invoke "f32.no_fold_div_div" (f32.const 0x1.db0e6ep+46) (f32.const 0x1.55eea2p+56) (f32.const -0x1.f3134p+124)) (f32.const -0x1.6cep-135))
 
 (assert_return (invoke "f64.no_fold_div_div" (f64.const 0x1.b4dc8ec3c7777p+337) (f64.const 0x1.9f95ac2d1863p+584) (f64.const -0x1.d4318abba341ep-782)) (f64.const -0x1.2649159d87e02p+534))
 (assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.ac53af5eb445fp+791) (f64.const 0x1.8549c0a4ceb13p-29) (f64.const 0x1.64e384003c801p+316)) (f64.const -0x1.9417cdccbae91p+503))
 (assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.d2685afb27327p+2) (f64.const -0x1.abb1eeed3dbebp+880) (f64.const 0x1.a543e2e6968a3p+170)) (f64.const 0x0.0000002a69a5fp-1022))
-(assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.47ddede78ad1cp+825) (f64.const 0x1.6d932d070a367p-821) (f64.const 0x1.79cf18cc64fp+961)) (f64.const -infinity))
+(assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.47ddede78ad1cp+825) (f64.const 0x1.6d932d070a367p-821) (f64.const 0x1.79cf18cc64fp+961)) (f64.const -inf))
 (assert_return (invoke "f64.no_fold_div_div" (f64.const -0x1.f73d4979a9379p-888) (f64.const 0x1.4d83b53e97788p-596) (f64.const -0x1.f8f86c9603b5bp-139)) (f64.const 0x1.87a7bd89c586cp-154))
 
 ;; Test that (x/y)*(z/w) is not optimized to (x*z)/(y*w), example from
@@ -1663,11 +1727,11 @@
 (assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.c483bep-109) (f32.const 0x1.ee1c3cp-92) (f32.const 0x1.800756p-88) (f32.const -0x1.95b972p+4)) (f32.const 0x1.bbd30cp-110))
 (assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.0f4262p+102) (f32.const 0x1.248498p+25) (f32.const 0x1.f66a7cp-17) (f32.const 0x1.897fc8p-3)) (f32.const -0x1.2f1aa4p+63))
 (assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.df5f22p+33) (f32.const -0x1.fcee3ep+39) (f32.const -0x1.9ea914p+29) (f32.const -0x1.2c4d3p+10)) (f32.const 0x1.4cf51cp+13))
-(assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.f568bcp+109) (f32.const 0x1.d9963p-34) (f32.const 0x1.37a87ap-16) (f32.const 0x1.a1524ap+78)) (f32.const -infinity))
+(assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.f568bcp+109) (f32.const 0x1.d9963p-34) (f32.const 0x1.37a87ap-16) (f32.const 0x1.a1524ap+78)) (f32.const -inf))
 (assert_return (invoke "f32.no_fold_mul_divs" (f32.const 0x1.3dd592p-53) (f32.const -0x1.332c22p-64) (f32.const 0x1.b01064p-91) (f32.const 0x1.92bb3ap-36)) (f32.const -0x1.1c2dbp-44))
 
 (assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.363d6764f7b12p-819) (f64.const -0x1.ed5471f660b5fp-464) (f64.const -0x1.671b0a7f3a42p+547) (f64.const 0x1.0633be34ba1f2p+186)) (f64.const -0x1.b8fa2b76baeebp+5))
-(assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.37880182e0fa8p+115) (f64.const 0x1.f842631576147p-920) (f64.const -0x1.999372231d156p+362) (f64.const -0x1.d5db481ab9554p+467)) (f64.const -infinity))
+(assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.37880182e0fa8p+115) (f64.const 0x1.f842631576147p-920) (f64.const -0x1.999372231d156p+362) (f64.const -0x1.d5db481ab9554p+467)) (f64.const -inf))
 (assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.9a747c8d4b541p+308) (f64.const -0x1.99092ad6bbdc8p+192) (f64.const -0x1.cb23755c20101p-140) (f64.const -0x1.de8716f6b0b6ap+732)) (f64.const 0x1.ecf584c8466a5p-757))
 (assert_return (invoke "f64.no_fold_mul_divs" (f64.const -0x1.c424b2ece903dp+129) (f64.const -0x1.568ce281db37fp-347) (f64.const 0x1.53900b99fd3dp-957) (f64.const 0x1.5c33952254dadp+223)) (f64.const 0x0p+0))
 (assert_return (invoke "f64.no_fold_mul_divs" (f64.const 0x1.a8ec2cecb32a9p-18) (f64.const 0x1.58acab0051851p-277) (f64.const 0x1.35e87c9077f7fp-620) (f64.const -0x1.925ee37ffb386p+352)) (f64.const -0x1.e6286970b31bfp-714))
@@ -1708,13 +1772,13 @@
 (assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.b0f9e4p-73)) (f32.const 0x1.b211b2p-73))
 (assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.de417cp-71)) (f32.const 0x1.de65b8p-71))
 (assert_return (invoke "f32.no_fold_sqrt_square" (f32.const 0x1.64c872p-86)) (f32.const 0x0p+0))
-(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const 0x1.e199e4p+108)) (f32.const infinity))
+(assert_return (invoke "f32.no_fold_sqrt_square" (f32.const 0x1.e199e4p+108)) (f32.const inf))
 
 (assert_return (invoke "f64.no_fold_sqrt_square" (f64.const 0x1.1759d657203fdp-529)) (f64.const 0x1.1759dd57545f3p-529))
 (assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.4c68de1c78d83p-514)) (f64.const 0x1.4c68de1c78d81p-514))
 (assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.214736edb6e1ep-521)) (f64.const 0x1.214736ed9cf8dp-521))
 (assert_return (invoke "f64.no_fold_sqrt_square" (f64.const -0x1.0864b9f68457p-616)) (f64.const 0x0p+0))
-(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const 0x1.b2a9855995abap+856)) (f64.const infinity))
+(assert_return (invoke "f64.no_fold_sqrt_square" (f64.const 0x1.b2a9855995abap+856)) (f64.const inf))
 
 ;; Test that sqrt(x)*sqrt(y) is not optimized to sqrt(x*y).
 
@@ -1770,13 +1834,13 @@
     (f64.div (f64.mul (get_local $x) (f64.sqrt (get_local $y))) (get_local $y)))
 )
 
-(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.f4a7cap+81) (f32.const 0x1.c09adep+92)) (f32.const -infinity))
+(assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.f4a7cap+81) (f32.const 0x1.c09adep+92)) (f32.const -inf))
 (assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.90bf1cp-120) (f32.const 0x1.8dbe88p-97)) (f32.const -0x0p+0))
 (assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const 0x1.8570e8p+29) (f32.const 0x1.217d3p-128)) (f32.const 0x1.6e391ap+93))
 (assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.5b4652p+43) (f32.const 0x1.a9d71cp+112)) (f32.const -0x1.0d423ap-13))
 (assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.910604p+8) (f32.const 0x1.0ca912p+7)) (f32.const -0x1.14cdecp+5))
 
-(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.1dcdeb857305fp+698) (f64.const 0x1.a066171c40eb9p+758)) (f64.const infinity))
+(assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.1dcdeb857305fp+698) (f64.const 0x1.a066171c40eb9p+758)) (f64.const inf))
 (assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const -0x1.8b4f1c218e2abp-827) (f64.const 0x1.5e1ee65953b0bp-669)) (f64.const -0x0p+0))
 (assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const 0x1.74ee531ddba38p-425) (f64.const 0x1.f370f758857f3p+560)) (f64.const 0x1.0aff34269583ep-705))
 (assert_return (invoke "f64.no_fold_mul_sqrt_div" (f64.const -0x1.27f216b0da6c5p+352) (f64.const 0x1.8e0b4e0b9fd7ep-483)) (f64.const -0x1.4fa558aad514ep+593))
@@ -1822,17 +1886,17 @@
     (f32.mul (f32.demote/f64 (get_local $x)) (get_local $y)))
 )
 
-(assert_return (invoke "f32.recoding_eq" (f32.const -infinity) (f32.const 3.0)) (i32.const 1))
-(assert_return (invoke "f32.recoding_le" (f32.const -infinity) (f32.const 3.0)) (i32.const 1))
-(assert_return (invoke "f32.recoding_lt" (f32.const -infinity) (f32.const 3.0)) (i32.const 0))
+(assert_return (invoke "f32.recoding_eq" (f32.const -inf) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.recoding_le" (f32.const -inf) (f32.const 3.0)) (i32.const 1))
+(assert_return (invoke "f32.recoding_lt" (f32.const -inf) (f32.const 3.0)) (i32.const 0))
 
 (assert_return (invoke "f32.recoding_eq" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
 (assert_return (invoke "f32.recoding_le" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 1))
 (assert_return (invoke "f32.recoding_lt" (f32.const 0x0p+0) (f32.const 0x1p+0)) (i32.const 0))
 
-(assert_return (invoke "f64.recoding_eq" (f64.const -infinity) (f64.const 3.0)) (i32.const 1))
-(assert_return (invoke "f64.recoding_le" (f64.const -infinity) (f64.const 3.0)) (i32.const 1))
-(assert_return (invoke "f64.recoding_lt" (f64.const -infinity) (f64.const 3.0)) (i32.const 0))
+(assert_return (invoke "f64.recoding_eq" (f64.const -inf) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.recoding_le" (f64.const -inf) (f64.const 3.0)) (i32.const 1))
+(assert_return (invoke "f64.recoding_lt" (f64.const -inf) (f64.const 3.0)) (i32.const 0))
 
 (assert_return (invoke "f64.recoding_eq" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
 (assert_return (invoke "f64.recoding_le" (f64.const 0x0p+0) (f64.const 0x1p+0)) (i32.const 1))
@@ -2037,9 +2101,9 @@
 )
 
 (assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const 0.0) (f32.const 0.0) (f32.const nan)) (i32.const 0))
-(assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const infinity) (f32.const -infinity) (f32.const infinity)) (i32.const 0))
+(assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const inf) (f32.const -inf) (f32.const inf)) (i32.const 0))
 (assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const 0.0) (f64.const 0.0) (f64.const nan)) (i32.const 0))
-(assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const infinity) (f64.const -infinity) (f64.const infinity)) (i32.const 0))
+(assert_return (invoke "f64.no_fold_add_le_monotonicity" (f64.const inf) (f64.const -inf) (f64.const inf)) (i32.const 0))
 
 ;; Test that !(x < y) and friends are not optimized to x >= y and friends.
 
diff --git a/test/core/float_literals.wast b/test/core/float_literals.wast
index c69d81fb7..1ab14f1a0 100644
--- a/test/core/float_literals.wast
+++ b/test/core/float_literals.wast
@@ -11,9 +11,9 @@
   (func (export "f32.misc_nan") (result i32) (i32.reinterpret/f32 (f32.const nan:0x012345)))
   (func (export "f32.misc_positive_nan") (result i32) (i32.reinterpret/f32 (f32.const +nan:0x304050)))
   (func (export "f32.misc_negative_nan") (result i32) (i32.reinterpret/f32 (f32.const -nan:0x2abcde)))
-  (func (export "f32.infinity") (result i32) (i32.reinterpret/f32 (f32.const infinity)))
-  (func (export "f32.positive_infinity") (result i32) (i32.reinterpret/f32 (f32.const +infinity)))
-  (func (export "f32.negative_infinity") (result i32) (i32.reinterpret/f32 (f32.const -infinity)))
+  (func (export "f32.infinity") (result i32) (i32.reinterpret/f32 (f32.const inf)))
+  (func (export "f32.positive_infinity") (result i32) (i32.reinterpret/f32 (f32.const +inf)))
+  (func (export "f32.negative_infinity") (result i32) (i32.reinterpret/f32 (f32.const -inf)))
 
   ;; f32 numbers
   (func (export "f32.zero") (result i32) (i32.reinterpret/f32 (f32.const 0x0.0p0)))
@@ -47,9 +47,9 @@
   (func (export "f64.misc_nan") (result i64) (i64.reinterpret/f64 (f64.const nan:0x0123456789abc)))
   (func (export "f64.misc_positive_nan") (result i64) (i64.reinterpret/f64 (f64.const +nan:0x3040506070809)))
   (func (export "f64.misc_negative_nan") (result i64) (i64.reinterpret/f64 (f64.const -nan:0x2abcdef012345)))
-  (func (export "f64.infinity") (result i64) (i64.reinterpret/f64 (f64.const infinity)))
-  (func (export "f64.positive_infinity") (result i64) (i64.reinterpret/f64 (f64.const +infinity)))
-  (func (export "f64.negative_infinity") (result i64) (i64.reinterpret/f64 (f64.const -infinity)))
+  (func (export "f64.infinity") (result i64) (i64.reinterpret/f64 (f64.const inf)))
+  (func (export "f64.positive_infinity") (result i64) (i64.reinterpret/f64 (f64.const +inf)))
+  (func (export "f64.negative_infinity") (result i64) (i64.reinterpret/f64 (f64.const -inf)))
 
   ;; f64 numbers
   (func (export "f64.zero") (result i64) (i64.reinterpret/f64 (f64.const 0x0.0p0)))
diff --git a/test/core/float_misc.wast b/test/core/float_misc.wast
index 1d67fdff5..095b8d827 100644
--- a/test/core/float_misc.wast
+++ b/test/core/float_misc.wast
@@ -168,9 +168,9 @@
 
 ;; Test rounding above the greatest finite value.
 (assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1.fffffep+102)) (f32.const 0x1.fffffep+127))
-(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const infinity))
+(assert_return (invoke "f32.add" (f32.const 0x1.fffffep+127) (f32.const 0x1p+103)) (f32.const inf))
 (assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1.fffffffffffffp+969)) (f64.const 0x1.fffffffffffffp+1023))
-(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const infinity))
+(assert_return (invoke "f64.add" (f64.const 0x1.fffffffffffffp+1023) (f64.const 0x1p+970)) (f64.const inf))
 
 ;; Test for a historic spreadsheet bug.
 ;; https://blogs.office.com/2007/09/25/calculation-issue-update/
@@ -272,8 +272,8 @@
 
 ;; Miscellaneous values.
 (assert_return (invoke "f32.mul" (f32.const 1e15) (f32.const 1e15)) (f32.const 0x1.93e592p+99))
-(assert_return (invoke "f32.mul" (f32.const 1e20) (f32.const 1e20)) (f32.const infinity))
-(assert_return (invoke "f32.mul" (f32.const 1e25) (f32.const 1e25)) (f32.const infinity))
+(assert_return (invoke "f32.mul" (f32.const 1e20) (f32.const 1e20)) (f32.const inf))
+(assert_return (invoke "f32.mul" (f32.const 1e25) (f32.const 1e25)) (f32.const inf))
 (assert_return (invoke "f64.mul" (f64.const 1e15) (f64.const 1e15)) (f64.const 0x1.93e5939a08ceap+99))
 (assert_return (invoke "f64.mul" (f64.const 1e20) (f64.const 1e20)) (f64.const 0x1.d6329f1c35ca5p+132))
 (assert_return (invoke "f64.mul" (f64.const 1e25) (f64.const 1e25)) (f64.const 0x1.11b0ec57e649bp+166))
@@ -295,7 +295,7 @@
 (assert_return (invoke "f32.mul" (f32.const -0x1.b17694p+92) (f32.const -0x1.e4b56ap-97)) (f32.const 0x1.9a5baep-4))
 (assert_return (invoke "f32.mul" (f32.const -0x1.1626a6p+79) (f32.const -0x1.c57d7p-75)) (f32.const 0x1.ecbaaep+4))
 (assert_return (invoke "f32.mul" (f32.const 0x1.7acf72p+53) (f32.const 0x1.6c89acp+5)) (f32.const 0x1.0db556p+59))
-(assert_return (invoke "f64.mul" (f64.const -0x1.25c293f6f37e4p+425) (f64.const 0x1.f5fd4fa41c6d8p+945)) (f64.const -infinity))
+(assert_return (invoke "f64.mul" (f64.const -0x1.25c293f6f37e4p+425) (f64.const 0x1.f5fd4fa41c6d8p+945)) (f64.const -inf))
 (assert_return (invoke "f64.mul" (f64.const -0x1.cc1ae79fffc5bp-986) (f64.const -0x1.c36ccc2861ca6p-219)) (f64.const 0x0p+0))
 (assert_return (invoke "f64.mul" (f64.const 0x1.c0232b3e64b56p+606) (f64.const -0x1.f6939cf3affaap+106)) (f64.const -0x1.b7e3aedf190d3p+713))
 (assert_return (invoke "f64.mul" (f64.const -0x1.60f289966b271p-313) (f64.const 0x1.28a5497f0c259p+583)) (f64.const -0x1.98fc50bcec259p+270))
@@ -309,12 +309,12 @@
 (assert_return (invoke "f32.mul" (f32.const 0x1.936742p+30) (f32.const -0x1.a7a19p+66)) (f32.const -0x1.4dc71ap+97))
 (assert_return (invoke "f64.mul" (f64.const -0x1.ba737b4ca3b13p-639) (f64.const 0x1.8923309857438p-314)) (f64.const -0x1.53bc0d07baa37p-952))
 (assert_return (invoke "f64.mul" (f64.const 0x1.7c1932e610219p-276) (f64.const -0x1.2605db646489fp-635)) (f64.const -0x1.b48da2b0d2ae3p-911))
-(assert_return (invoke "f64.mul" (f64.const -0x1.e43cdf3b2108p+329) (f64.const -0x1.99d96abbd61d1p+835)) (f64.const infinity))
+(assert_return (invoke "f64.mul" (f64.const -0x1.e43cdf3b2108p+329) (f64.const -0x1.99d96abbd61d1p+835)) (f64.const inf))
 (assert_return (invoke "f64.mul" (f64.const 0x1.4c19466551da3p+947) (f64.const 0x1.0bdcd6c7646e9p-439)) (f64.const 0x1.5b7cd8c3f638ap+508))
 (assert_return (invoke "f64.mul" (f64.const 0x1.ff1da1726e3dfp+339) (f64.const -0x1.043c44f52b158p+169)) (f64.const -0x1.03c9364bb585cp+509))
 
 ;; Computations that round differently in round-toward-zero mode.
-(assert_return (invoke "f32.mul" (f32.const -0x1.907e8ap+46) (f32.const -0x1.5d3668p+95)) (f32.const infinity))
+(assert_return (invoke "f32.mul" (f32.const -0x1.907e8ap+46) (f32.const -0x1.5d3668p+95)) (f32.const inf))
 (assert_return (invoke "f32.mul" (f32.const -0x1.8c9f74p-3) (f32.const 0x1.e2b452p-99)) (f32.const -0x1.75edccp-101))
 (assert_return (invoke "f32.mul" (f32.const -0x1.cc605ap-19) (f32.const 0x1.ec321ap+105)) (f32.const -0x1.ba91a4p+87))
 (assert_return (invoke "f32.mul" (f32.const -0x1.5fbb7ap+56) (f32.const 0x1.a8965ep-96)) (f32.const -0x1.23ae8ep-39))
@@ -322,7 +322,7 @@
 (assert_return (invoke "f64.mul" (f64.const -0x1.5b0266454c26bp-496) (f64.const -0x1.af5787e3e0399p+433)) (f64.const 0x1.2457d81949e0bp-62))
 (assert_return (invoke "f64.mul" (f64.const 0x1.0d54a82393d45p+478) (f64.const -0x1.425760807ceaep-764)) (f64.const -0x1.532068c8d0d5dp-286))
 (assert_return (invoke "f64.mul" (f64.const -0x1.b532af981786p+172) (f64.const 0x1.ada95085ba36fp+359)) (f64.const -0x1.6ee38c1e01864p+532))
-(assert_return (invoke "f64.mul" (f64.const 0x1.e132f4d49d1cep+768) (f64.const -0x1.a75afe9a7d864p+374)) (f64.const -infinity))
+(assert_return (invoke "f64.mul" (f64.const 0x1.e132f4d49d1cep+768) (f64.const -0x1.a75afe9a7d864p+374)) (f64.const -inf))
 (assert_return (invoke "f64.mul" (f64.const 0x1.68bbf1cfff90ap+81) (f64.const 0x1.09cd17d652c5p+70)) (f64.const 0x1.768b8d67d794p+151))
 
 ;; Computations that round differently on x87.
@@ -354,9 +354,9 @@
 
 ;; Test the greatest positive value with a finite square.
 (assert_return (invoke "f32.mul" (f32.const 0x1.fffffep+63) (f32.const 0x1.fffffep+63)) (f32.const 0x1.fffffcp+127))
-(assert_return (invoke "f32.mul" (f32.const 0x1p+64) (f32.const 0x1p+64)) (f32.const infinity))
+(assert_return (invoke "f32.mul" (f32.const 0x1p+64) (f32.const 0x1p+64)) (f32.const inf))
 (assert_return (invoke "f64.mul" (f64.const 0x1.fffffffffffffp+511) (f64.const 0x1.fffffffffffffp+511)) (f64.const 0x1.ffffffffffffep+1023))
-(assert_return (invoke "f64.mul" (f64.const 0x1p+512) (f64.const 0x1p+512)) (f64.const infinity))
+(assert_return (invoke "f64.mul" (f64.const 0x1p+512) (f64.const 0x1p+512)) (f64.const inf))
 
 ;; Test the squares of values very close to 1.
 (assert_return (invoke "f32.mul" (f32.const 0x1.000002p+0) (f32.const 0x1.000002p+0)) (f32.const 0x1.000004p+0))
@@ -408,7 +408,7 @@
 (assert_return (invoke "f64.div" (f64.const -0x1.44ca7539cc851p+540) (f64.const 0x1.58501bccc58fep+453)) (f64.const -0x1.e2f8657e0924ep+86))
 
 ;; Computations that round differently in round-downward mode.
-(assert_return (invoke "f32.div" (f32.const -0x1.c2c54ap+69) (f32.const -0x1.00d142p-86)) (f32.const infinity))
+(assert_return (invoke "f32.div" (f32.const -0x1.c2c54ap+69) (f32.const -0x1.00d142p-86)) (f32.const inf))
 (assert_return (invoke "f32.div" (f32.const 0x1.e35abep-46) (f32.const 0x1.c69dfp+44)) (f32.const 0x1.102eb4p-90))
 (assert_return (invoke "f32.div" (f32.const 0x1.45ff2ap+0) (f32.const -0x1.1e8754p+89)) (f32.const -0x1.23434ep-89))
 (assert_return (invoke "f32.div" (f32.const 0x1.8db18ap-51) (f32.const 0x1.47c678p-128)) (f32.const 0x1.369b96p+77))
@@ -420,13 +420,13 @@
 (assert_return (invoke "f64.div" (f64.const -0x1.91f58d7ed1237p+236) (f64.const -0x1.f190d808383c8p+55)) (f64.const 0x1.9d9eb0836f906p+180))
 
 ;; Computations that round differently in round-toward-zero mode.
-(assert_return (invoke "f32.div" (f32.const 0x1.64b2a4p+26) (f32.const 0x1.e95752p-119)) (f32.const infinity))
+(assert_return (invoke "f32.div" (f32.const 0x1.64b2a4p+26) (f32.const 0x1.e95752p-119)) (f32.const inf))
 (assert_return (invoke "f32.div" (f32.const -0x1.53c9b6p+77) (f32.const 0x1.d689ap+27)) (f32.const -0x1.71baa4p+49))
 (assert_return (invoke "f32.div" (f32.const 0x1.664a8ap+38) (f32.const -0x1.59dba2p+96)) (f32.const -0x1.0933f4p-58))
 (assert_return (invoke "f32.div" (f32.const -0x1.99e0fap+111) (f32.const -0x1.c2b5a8p+9)) (f32.const 0x1.d19de6p+101))
 (assert_return (invoke "f32.div" (f32.const -0x1.5a815ap+92) (f32.const -0x1.b5820ap+13)) (f32.const 0x1.9580b8p+78))
 (assert_return (invoke "f64.div" (f64.const -0x1.81fd1e2af7bebp-655) (f64.const 0x1.edefc4eae536cp-691)) (f64.const -0x1.901abdd91b661p+35))
-(assert_return (invoke "f64.div" (f64.const -0x1.47cf932953c43p+782) (f64.const -0x1.bc40496b1f2a1p-553)) (f64.const infinity))
+(assert_return (invoke "f64.div" (f64.const -0x1.47cf932953c43p+782) (f64.const -0x1.bc40496b1f2a1p-553)) (f64.const inf))
 (assert_return (invoke "f64.div" (f64.const -0x1.2bd2e8fbdcad7p-746) (f64.const 0x1.b115674cc476ep-65)) (f64.const -0x1.62752bf19fa81p-682))
 (assert_return (invoke "f64.div" (f64.const -0x1.f923e3fea9efep+317) (f64.const -0x1.8044c74d27a39p-588)) (f64.const 0x1.5086518cc7186p+905))
 (assert_return (invoke "f64.div" (f64.const 0x1.516ed2051d6bbp+181) (f64.const -0x1.c9f455eb9c2eep+214)) (f64.const -0x1.79414d67f2889p-34))
@@ -478,9 +478,9 @@
 (assert_return (invoke "f64.div" (f64.const 0x1p-51) (f64.const 0x1.fffffffffffffp+1023)) (f64.const 0x0.0000000000001p-1022))
 
 ;; Test the least positive value with a finite reciprocal.
-(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p-128)) (f32.const infinity))
+(assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1p-128)) (f32.const inf))
 (assert_return (invoke "f32.div" (f32.const 1.0) (f32.const 0x1.000008p-128)) (f32.const 0x1.fffffp+127))
-(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4p-1022)) (f64.const infinity))
+(assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4p-1022)) (f64.const inf))
 (assert_return (invoke "f64.div" (f64.const 1.0) (f64.const 0x0.4000000000001p-1022)) (f64.const 0x1.ffffffffffff8p+1023))
 
 ;; Test the least positive value that has a subnormal reciprocal.
diff --git a/test/core/forward.wast b/test/core/forward.wast
index 43ab49348..7074ed743 100644
--- a/test/core/forward.wast
+++ b/test/core/forward.wast
@@ -1,15 +1,15 @@
 (module
   (func $even (export "even") (param $n i32) (result i32)
-    (if i32 (i32.eq (get_local $n) (i32.const 0))
-      (i32.const 1)
-      (call $odd (i32.sub (get_local $n) (i32.const 1)))
+    (if (result i32) (i32.eq (get_local $n) (i32.const 0))
+      (then (i32.const 1))
+      (else (call $odd (i32.sub (get_local $n) (i32.const 1))))
     )
   )
 
   (func $odd (export "odd") (param $n i32) (result i32)
-    (if i32 (i32.eq (get_local $n) (i32.const 0))
-      (i32.const 0)
-      (call $even (i32.sub (get_local $n) (i32.const 1)))
+    (if (result i32) (i32.eq (get_local $n) (i32.const 0))
+      (then (i32.const 0))
+      (else (call $even (i32.sub (get_local $n) (i32.const 1))))
     )
   )
 )
diff --git a/test/core/func.wast b/test/core/func.wast
index a9c71db48..219095bef 100644
--- a/test/core/func.wast
+++ b/test/core/func.wast
@@ -97,7 +97,7 @@
   (func (export "value-f64") (result f64) (f64.const 77.77))
   (func (export "value-block-void") (block (call $dummy) (call $dummy)))
   (func (export "value-block-i32") (result i32)
-    (block i32 (call $dummy) (i32.const 77))
+    (block (result i32) (call $dummy) (i32.const 77))
   )
 
   (func (export "return-empty") (return))
@@ -106,7 +106,7 @@
   (func (export "return-f32") (result f32) (return (f32.const 78.7)))
   (func (export "return-f64") (result f64) (return (f64.const 78.78)))
   (func (export "return-block-i32") (result i32)
-    (return (block i32 (call $dummy) (i32.const 77)))
+    (return (block (result i32) (call $dummy) (i32.const 77)))
   )
 
   (func (export "break-empty") (br 0))
@@ -115,7 +115,7 @@
   (func (export "break-f32") (result f32) (br 0 (f32.const 79.9)))
   (func (export "break-f64") (result f64) (br 0 (f64.const 79.79)))
   (func (export "break-block-i32") (result i32)
-    (br 0 (block i32 (call $dummy) (i32.const 77)))
+    (br 0 (block (result i32) (call $dummy) (i32.const 77)))
   )
 
   (func (export "break-br_if-empty") (param i32)
@@ -136,7 +136,9 @@
   )
   (func (export "break-br_table-nested-num") (param i32) (result i32)
     (i32.add
-      (block i32 (br_table 0 1 0 (i32.const 50) (get_local 0)) (i32.const 51))
+      (block (result i32)
+        (br_table 0 1 0 (i32.const 50) (get_local 0)) (i32.const 51)
+      )
       (i32.const 2)
     )
   )
diff --git a/test/core/if.wast b/test/core/if.wast
index 7ec1f2b74..e80b38d43 100644
--- a/test/core/if.wast
+++ b/test/core/if.wast
@@ -14,24 +14,24 @@
   (func (export "singular") (param i32) (result i32)
     (if (get_local 0) (then (nop)))
     (if (get_local 0) (then (nop)) (else (nop)))
-    (if i32 (get_local 0) (then (i32.const 7)) (else (i32.const 8)))
+    (if (result i32) (get_local 0) (then (i32.const 7)) (else (i32.const 8)))
   )
 
   (func (export "multi") (param i32) (result i32)
     (if (get_local 0) (then (call $dummy) (call $dummy) (call $dummy)))
     (if (get_local 0) (then) (else (call $dummy) (call $dummy) (call $dummy)))
-    (if i32 (get_local 0)
+    (if (result i32) (get_local 0)
       (then (call $dummy) (call $dummy) (i32.const 8))
       (else (call $dummy) (call $dummy) (i32.const 9))
     )
   )
 
   (func (export "nested") (param i32 i32) (result i32)
-    (if i32 (get_local 0)
+    (if (result i32) (get_local 0)
       (then
         (if (get_local 1) (then (call $dummy) (block) (nop)))
         (if (get_local 1) (then) (else (call $dummy) (block) (nop)))
-        (if i32 (get_local 1)
+        (if (result i32) (get_local 1)
           (then (call $dummy) (i32.const 9))
           (else (call $dummy) (i32.const 10))
         )
@@ -39,7 +39,7 @@
       (else
         (if (get_local 1) (then (call $dummy) (block) (nop)))
         (if (get_local 1) (then) (else (call $dummy) (block) (nop)))
-        (if i32 (get_local 1)
+        (if (result i32) (get_local 1)
           (then (call $dummy) (i32.const 10))
           (else (call $dummy) (i32.const 11))
         )
@@ -49,7 +49,7 @@
 
   (func (export "as-unary-operand") (param i32) (result i32)
     (i32.ctz
-      (if i32 (get_local 0)
+      (if (result i32) (get_local 0)
         (then (call $dummy) (i32.const 13))
         (else (call $dummy) (i32.const -13))
       )
@@ -57,11 +57,11 @@
   )
   (func (export "as-binary-operand") (param i32 i32) (result i32)
     (i32.mul
-      (if i32 (get_local 0)
+      (if (result i32) (get_local 0)
         (then (call $dummy) (i32.const 3))
         (else (call $dummy) (i32.const -3))
       )
-      (if i32 (get_local 1)
+      (if (result i32) (get_local 1)
         (then (call $dummy) (i32.const 4))
         (else (call $dummy) (i32.const -5))
       )
@@ -69,7 +69,7 @@
   )
   (func (export "as-test-operand") (param i32) (result i32)
     (i32.eqz
-      (if i32 (get_local 0)
+      (if (result i32) (get_local 0)
         (then (call $dummy) (i32.const 13))
         (else (call $dummy) (i32.const 0))
       )
@@ -77,11 +77,11 @@
   )
   (func (export "as-compare-operand") (param i32 i32) (result i32)
     (f32.gt
-      (if f32 (get_local 0)
+      (if (result f32) (get_local 0)
         (then (call $dummy) (f32.const 3))
         (else (call $dummy) (f32.const -3))
       )
-      (if f32 (get_local 1)
+      (if (result f32) (get_local 1)
         (then (call $dummy) (f32.const 4))
         (else (call $dummy) (f32.const -4))
       )
@@ -102,7 +102,7 @@
   )
 
   (func (export "break-value") (param i32) (result i32)
-    (if i32 (get_local 0)
+    (if (result i32) (get_local 0)
       (then (br 0 (i32.const 18)) (i32.const 19))
       (else (br 0 (i32.const 21)) (i32.const 20))
     )
@@ -111,7 +111,7 @@
   (func (export "effects") (param i32) (result i32)
     (local i32)
     (if
-      (block i32 (set_local 1 (i32.const 1)) (get_local 0))
+      (block (result i32) (set_local 1 (i32.const 1)) (get_local 0))
       (then
         (set_local 1 (i32.mul (get_local 1) (i32.const 3)))
         (set_local 1 (i32.sub (get_local 1) (i32.const 5)))
@@ -240,76 +240,76 @@
 
 (assert_invalid
   (module (func $type-then-value-empty-vs-num (result i32)
-    (if i32 (i32.const 1) (then) (else (i32.const 0)))
+    (if (result i32) (i32.const 1) (then) (else (i32.const 0)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-then-value-empty-vs-num (result i32)
-    (if i32 (i32.const 1) (then (i32.const 0)) (else))
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-both-value-empty-vs-num (result i32)
-    (if i32 (i32.const 1) (then) (else))
+    (if (result i32) (i32.const 1) (then) (else))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-no-else-vs-num (result i32)
-    (if i32 (i32.const 1) (then (i32.const 1)))
+    (if (result i32) (i32.const 1) (then (i32.const 1)))
   ))
   "type mismatch"
 )
 
 (assert_invalid
   (module (func $type-then-value-void-vs-num (result i32)
-    (if i32 (i32.const 1) (then (nop)) (else (i32.const 0)))
+    (if (result i32) (i32.const 1) (then (nop)) (else (i32.const 0)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-then-value-void-vs-num (result i32)
-    (if i32 (i32.const 1) (then (i32.const 0)) (else (nop)))
+    (if (result i32) (i32.const 1) (then (i32.const 0)) (else (nop)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-both-value-void-vs-num (result i32)
-    (if i32 (i32.const 1) (then (nop)) (else (nop)))
+    (if (result i32) (i32.const 1) (then (nop)) (else (nop)))
   ))
   "type mismatch"
 )
 
 (assert_invalid
   (module (func $type-then-value-num-vs-num (result i32)
-    (if i32 (i32.const 1) (then (i64.const 1)) (else (i32.const 1)))
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i32.const 1)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-then-value-num-vs-num (result i32)
-    (if i32 (i32.const 1) (then (i32.const 1)) (else (i64.const 1)))
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (i64.const 1)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-both-value-num-vs-num (result i32)
-    (if i32 (i32.const 1) (then (i64.const 1)) (else (i64.const 1)))
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (i64.const 1)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-both-different-value-num-vs-num (result i32)
-    (if i32 (i32.const 1) (then (i64.const 1)) (else (f64.const 1)))
+    (if (result i32) (i32.const 1) (then (i64.const 1)) (else (f64.const 1)))
   ))
   "type mismatch"
 )
 
 (assert_invalid
   (module (func $type-then-value-unreached-select (result i32)
-    (if i64
+    (if (result i64)
       (i32.const 0)
       (then (select (unreachable) (unreachable) (unreachable)))
       (else (i64.const 0))
@@ -319,7 +319,7 @@
 )
 (assert_invalid
   (module (func $type-else-value-unreached-select (result i32)
-    (if i64
+    (if (result i64)
       (i32.const 1)
       (then (i64.const 0))
       (else (select (unreachable) (unreachable) (unreachable)))
@@ -329,7 +329,7 @@
 )
 (assert_invalid
   (module (func $type-else-value-unreached-select (result i32)
-    (if i64
+    (if (result i64)
       (i32.const 1)
       (then (select (unreachable) (unreachable) (unreachable)))
       (else (select (unreachable) (unreachable) (unreachable)))
@@ -340,50 +340,68 @@
 
 (assert_invalid
   (module (func $type-then-break-last-void-vs-num (result i32)
-    (if i32 (i32.const 1) (then (br 0)) (else (i32.const 1)))
+    (if (result i32) (i32.const 1) (then (br 0)) (else (i32.const 1)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-else-break-last-void-vs-num (result i32)
-    (if i32 (i32.const 1) (then (i32.const 1)) (else (br 0)))
+    (if (result i32) (i32.const 1) (then (i32.const 1)) (else (br 0)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-then-break-empty-vs-num (result i32)
-    (if i32 (i32.const 1) (then (br 0) (i32.const 1)) (else (i32.const 1)))
+    (if (result i32) (i32.const 1)
+      (then (br 0) (i32.const 1))
+      (else (i32.const 1))
+    )
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-else-break-empty-vs-num (result i32)
-    (if i32 (i32.const 1) (then (i32.const 1)) (else (br 0) (i32.const 1)))
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0) (i32.const 1))
+    )
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-then-break-void-vs-num (result i32)
-    (if i32 (i32.const 1) (then (br 0 (nop)) (i32.const 1)) (else (i32.const 1)))
+    (if (result i32) (i32.const 1)
+      (then (br 0 (nop)) (i32.const 1))
+      (else (i32.const 1))
+    )
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-else-break-void-vs-num (result i32)
-    (if i32 (i32.const 1) (then (i32.const 1)) (else (br 0 (nop)) (i32.const 1)))
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (nop)) (i32.const 1))
+    )
   ))
   "type mismatch"
 )
 
 (assert_invalid
   (module (func $type-then-break-num-vs-num (result i32)
-    (if i32 (i32.const 1) (then (br 0 (i64.const 1)) (i32.const 1)) (else (i32.const 1)))
+    (if (result i32) (i32.const 1)
+      (then (br 0 (i64.const 1)) (i32.const 1))
+      (else (i32.const 1))
+    )
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-else-break-num-vs-num (result i32)
-    (if i32 (i32.const 1) (then (i32.const 1)) (else (br 0 (i64.const 1)) (i32.const 1)))
+    (if (result i32) (i32.const 1)
+      (then (i32.const 1))
+      (else (br 0 (i64.const 1)) (i32.const 1))
+    )
   ))
   "type mismatch"
 )
diff --git a/test/core/imports.wast b/test/core/imports.wast
index 811095945..029403bea 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -41,6 +41,12 @@
   (func $print_f64-2 (import "spectest" "print") (param f64))
   (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64)))
 
+  (func (export "p1") (import "spectest" "print") (param i32))
+  (func $p (export "p2") (import "spectest" "print") (param i32))
+  (func (export "p3") (export "p4") (import "spectest" "print") (param i32))
+  (func (export "p5") (import "spectest" "print") (type 0))
+  (func (export "p6") (import "spectest" "print") (type 0) (param i32) (result))
+
   (table anyfunc (elem $print_i32 $print_f64))
 
   (func (export "print32") (param $i i32)
diff --git a/test/core/inline-module.wast b/test/core/inline-module.wast
new file mode 100644
index 000000000..dc7ead776
--- /dev/null
+++ b/test/core/inline-module.wast
@@ -0,0 +1 @@
+(func) (memory 0) (func (export "f"))
diff --git a/test/core/labels.wast b/test/core/labels.wast
index 03e5bf722..02fea5f27 100644
--- a/test/core/labels.wast
+++ b/test/core/labels.wast
@@ -1,6 +1,6 @@
 (module
   (func (export "block") (result i32)
-    (block $exit i32
+    (block $exit (result i32)
       (br $exit (i32.const 1))
       (i32.const 0)
     )
@@ -9,11 +9,11 @@
   (func (export "loop1") (result i32)
     (local $i i32)
     (set_local $i (i32.const 0))
-    (block $exit i32
-      (loop $cont i32
+    (block $exit (result i32)
+      (loop $cont (result i32)
         (set_local $i (i32.add (get_local $i) (i32.const 1)))
         (if (i32.eq (get_local $i) (i32.const 5))
-          (br $exit (get_local $i))
+          (then (br $exit (get_local $i)))
         )
         (br $cont)
       )
@@ -23,14 +23,14 @@
   (func (export "loop2") (result i32)
     (local $i i32)
     (set_local $i (i32.const 0))
-    (block $exit i32
-      (loop $cont i32
+    (block $exit (result i32)
+      (loop $cont (result i32)
         (set_local $i (i32.add (get_local $i) (i32.const 1)))
         (if (i32.eq (get_local $i) (i32.const 5))
-          (br $cont)
+          (then (br $cont))
         )
         (if (i32.eq (get_local $i) (i32.const 8))
-          (br $exit (get_local $i))
+          (then (br $exit (get_local $i)))
         )
         (set_local $i (i32.add (get_local $i) (i32.const 1)))
         (br $cont)
@@ -41,11 +41,11 @@
   (func (export "loop3") (result i32)
     (local $i i32)
     (set_local $i (i32.const 0))
-    (block $exit i32
-      (loop $cont i32
+    (block $exit (result i32)
+      (loop $cont (result i32)
         (set_local $i (i32.add (get_local $i) (i32.const 1)))
         (if (i32.eq (get_local $i) (i32.const 5))
-          (br $exit (get_local $i))
+          (then (br $exit (get_local $i)))
         )
         (get_local $i)
       )
@@ -55,11 +55,11 @@
   (func (export "loop4") (param $max i32) (result i32)
     (local $i i32)
     (set_local $i (i32.const 1))
-    (block $exit i32
-      (loop $cont i32
+    (block $exit (result i32)
+      (loop $cont (result i32)
         (set_local $i (i32.add (get_local $i) (get_local $i)))
         (if (i32.gt_u (get_local $i) (get_local $max))
-          (br $exit (get_local $i))
+          (then (br $exit (get_local $i)))
         )
         (br $cont)
       )
@@ -68,7 +68,7 @@
 
   (func (export "loop5") (result i32)
     (i32.add
-      (loop $l i32 (i32.const 1))
+      (loop $l (result i32) (i32.const 1))
       (i32.const 1)
     )
   )
@@ -148,9 +148,9 @@
   )
 
   (func (export "switch") (param i32) (result i32)
-    (block $ret i32
+    (block $ret (result i32)
       (i32.mul (i32.const 10)
-        (block $exit i32
+        (block $exit (result i32)
           (block $0
             (block $default
               (block $3
@@ -186,7 +186,7 @@
   (func (export "br_if0") (result i32)
     (local $i i32)
     (set_local $i (i32.const 0))
-    (block $outer i32
+    (block $outer (result i32)
       (block $inner
         (br_if $inner (i32.const 0))
         (set_local $i (i32.or (get_local $i) (i32.const 0x1)))
@@ -194,7 +194,7 @@
         (set_local $i (i32.or (get_local $i) (i32.const 0x2)))
       )
       (drop (br_if $outer
-        (block i32
+        (block (result i32)
           (set_local $i (i32.or (get_local $i) (i32.const 0x4)))
           (get_local $i)
         )
@@ -202,7 +202,7 @@
       ))
       (set_local $i (i32.or (get_local $i) (i32.const 0x8)))
       (drop (br_if $outer
-        (block i32
+        (block (result i32)
           (set_local $i (i32.or (get_local $i) (i32.const 0x10)))
           (get_local $i)
         )
@@ -213,16 +213,21 @@
   )
 
   (func (export "br_if1") (result i32)
-    (block $l0 i32
-      (drop (br_if $l0 (block $l1 i32 (br $l1 (i32.const 1))) (i32.const 1)))
+    (block $l0 (result i32)
+      (drop
+        (br_if $l0
+          (block $l1 (result i32) (br $l1 (i32.const 1)))
+          (i32.const 1)
+        )
+      )
       (i32.const 1)
     )
   )
 
   (func (export "br_if2") (result i32)
-    (block $l0 i32
+    (block $l0 (result i32)
       (if (i32.const 1)
-        (br $l0 (block $l1 i32 (br $l1 (i32.const 1))))
+        (then (br $l0 (block $l1 (result i32) (br $l1 (i32.const 1)))))
       )
       (i32.const 1)
     )
@@ -232,10 +237,10 @@
     (local $i1 i32)
     (drop
       (i32.add
-        (block $l0 i32
+        (block $l0 (result i32)
           (drop (br_if $l0
-            (block i32 (set_local $i1 (i32.const 1)) (get_local $i1))
-            (block i32 (set_local $i1 (i32.const 2)) (get_local $i1))
+            (block (result i32) (set_local $i1 (i32.const 1)) (get_local $i1))
+            (block (result i32) (set_local $i1 (i32.const 2)) (get_local $i1))
           ))
           (i32.const 0)
         )
@@ -246,24 +251,24 @@
   )
 
   (func (export "br") (result i32)
-    (block $l0 i32
+    (block $l0 (result i32)
       (if (i32.const 1)
-        (br $l0 (block $l1 i32 (br $l1 (i32.const 1))))
-        (block (drop (block $l1 i32 (br $l1 (i32.const 1)))))
+        (then (br $l0 (block $l1 (result i32) (br $l1 (i32.const 1)))))
+        (else (block (drop (block $l1 (result i32) (br $l1 (i32.const 1))))))
       )
       (i32.const 1)
     )
   )
 
   (func (export "shadowing") (result i32)
-    (block $l1 i32 (i32.xor (br $l1 (i32.const 1)) (i32.const 2)))
+    (block $l1 (result i32) (i32.xor (br $l1 (i32.const 1)) (i32.const 2)))
   )
 
   (func (export "redefinition") (result i32)
-    (block $l1 i32
+    (block $l1 (result i32)
       (i32.add
-        (block $l1 i32 (i32.const 2))
-        (block $l1 i32 (br $l1 (i32.const 3)))
+        (block $l1 (result i32) (i32.const 2))
+        (block $l1 (result i32) (br $l1 (i32.const 3)))
       )
     )
   )
diff --git a/test/core/left-to-right.wast b/test/core/left-to-right.wast
index 7eeda94a8..6214d0d5b 100644
--- a/test/core/left-to-right.wast
+++ b/test/core/left-to-right.wast
@@ -159,17 +159,17 @@
   (func (export "f64_select") (result i32) (call $reset) (drop (select (call $f64_left) (call $f64_right) (call $f64_bool))) (call $get))
 
   (func (export "br_if") (result i32)
-    (block i32
+    (block (result i32)
       (call $reset)
       (drop (br_if 0 (call $i32_left) (i32.and (call $i32_right) (i32.const 0))))
       (call $get)
     )
   )
   (func (export "br_table") (result i32)
-    (block $a i32
+    (block $a (result i32)
       (call $reset)
       (drop
-        (block $b i32
+        (block $b (result i32)
           (br_table $a $b (call $i32_left) (call $i32_right))
         )
       )
diff --git a/test/core/loop.wast b/test/core/loop.wast
index 16f849b1b..348061cbf 100644
--- a/test/core/loop.wast
+++ b/test/core/loop.wast
@@ -10,55 +10,81 @@
 
   (func (export "singular") (result i32)
     (loop (nop))
-    (loop i32 (i32.const 7))
+    (loop (result i32) (i32.const 7))
   )
 
   (func (export "multi") (result i32)
     (loop (call $dummy) (call $dummy) (call $dummy) (call $dummy))
-    (loop i32 (call $dummy) (call $dummy) (call $dummy) (i32.const 8))
+    (loop (result i32) (call $dummy) (call $dummy) (call $dummy) (i32.const 8))
   )
 
   (func (export "nested") (result i32)
-    (loop i32
+    (loop (result i32)
       (loop (call $dummy) (block) (nop))
-      (loop i32 (call $dummy) (i32.const 9))
+      (loop (result i32) (call $dummy) (i32.const 9))
     )
   )
 
   (func (export "deep") (result i32)
-    (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-      (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-        (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-          (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-            (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-              (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-                (loop i32 (block i32 (loop i32 (block i32 (loop i32 (block i32
-                  (loop i32 (block i32 (call $dummy) (i32.const 150)))
-                ))))))
-              ))))))
-            ))))))
-          ))))))
-        ))))))
-      ))))))
-    ))))))
+    (loop (result i32) (block (result i32)
+      (loop (result i32) (block (result i32)
+        (loop (result i32) (block (result i32)
+          (loop (result i32) (block (result i32)
+            (loop (result i32) (block (result i32)
+              (loop (result i32) (block (result i32)
+                (loop (result i32) (block (result i32)
+                  (loop (result i32) (block (result i32)
+                    (loop (result i32) (block (result i32)
+                      (loop (result i32) (block (result i32)
+                        (loop (result i32) (block (result i32)
+                          (loop (result i32) (block (result i32)
+                            (loop (result i32) (block (result i32)
+                              (loop (result i32) (block (result i32)
+                                (loop (result i32) (block (result i32)
+                                  (loop (result i32) (block (result i32)
+                                    (loop (result i32) (block (result i32)
+                                      (loop (result i32) (block (result i32)
+                                        (loop (result i32) (block (result i32)
+                                          (loop (result i32) (block (result i32)
+                                            (call $dummy) (i32.const 150)
+                                          ))
+                                        ))
+                                      ))
+                                    ))
+                                  ))
+                                ))
+                              ))
+                            ))
+                          ))
+                        ))
+                      ))
+                    ))
+                  ))
+                ))
+              ))
+            ))
+          ))
+        ))
+      ))
+    ))
   )
 
   (func (export "as-unary-operand") (result i32)
-    (i32.ctz (loop i32 (call $dummy) (i32.const 13)))
+    (i32.ctz (loop (result i32) (call $dummy) (i32.const 13)))
   )
   (func (export "as-binary-operand") (result i32)
     (i32.mul
-      (loop i32 (call $dummy) (i32.const 3))
-      (loop i32 (call $dummy) (i32.const 4))
+      (loop (result i32) (call $dummy) (i32.const 3))
+      (loop (result i32) (call $dummy) (i32.const 4))
     )
   )
   (func (export "as-test-operand") (result i32)
-    (i32.eqz (loop i32 (call $dummy) (i32.const 13)))
+    (i32.eqz (loop (result i32) (call $dummy) (i32.const 13)))
   )
   (func (export "as-compare-operand") (result i32)
     (f32.gt
-      (loop f32 (call $dummy) (f32.const 3))
-      (loop f32 (call $dummy) (f32.const 3))
+      (loop (result f32) (call $dummy) (f32.const 3))
+      (loop (result f32) (call $dummy) (f32.const 3))
     )
   )
 
@@ -70,11 +96,13 @@
     (i32.const 19)
   )
   (func (export "break-value") (result i32)
-    (block i32 (loop i32 (br 1 (i32.const 18)) (br 0) (i32.const 19)))
+    (block (result i32)
+      (loop (result i32) (br 1 (i32.const 18)) (br 0) (i32.const 19))
+    )
   )
   (func (export "break-repeated") (result i32)
-    (block i32
-      (loop i32
+    (block (result i32)
+      (loop (result i32)
         (br 1 (i32.const 18))
         (br 1 (i32.const 19))
         (drop (br_if 1 (i32.const 20) (i32.const 0)))
@@ -89,19 +117,19 @@
   (func (export "break-inner") (result i32)
     (local i32)
     (set_local 0 (i32.const 0))
-    (set_local 0 (i32.add (get_local 0) (block i32 (loop i32 (block i32 (br 2 (i32.const 0x1)))))))
-    (set_local 0 (i32.add (get_local 0) (block i32 (loop i32 (loop i32 (br 2 (i32.const 0x2)))))))
-    (set_local 0 (i32.add (get_local 0) (block i32 (loop i32 (block i32 (loop i32 (br 1 (i32.const 0x4))))))))
-    (set_local 0 (i32.add (get_local 0) (block i32 (loop i32 (i32.ctz (br 1 (i32.const 0x8)))))))
-    (set_local 0 (i32.add (get_local 0) (block i32 (loop i32 (i32.ctz (loop i32 (br 2 (i32.const 0x10))))))))
+    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1)))))))
+    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2)))))))
+    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4))))))))
+    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (i32.ctz (br 1 (i32.const 0x8)))))))
+    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (i32.ctz (loop (result i32) (br 2 (i32.const 0x10))))))))
     (get_local 0)
   )
   (func (export "cont-inner") (result i32)
     (local i32)
     (set_local 0 (i32.const 0))
-    (set_local 0 (i32.add (get_local 0) (loop i32 (loop i32 (br 1)))))
-    (set_local 0 (i32.add (get_local 0) (loop i32 (i32.ctz (br 0)))))
-    (set_local 0 (i32.add (get_local 0) (loop i32 (i32.ctz (loop i32 (br 1))))))
+    (set_local 0 (i32.add (get_local 0) (loop (result i32) (loop (result i32) (br 1)))))
+    (set_local 0 (i32.add (get_local 0) (loop (result i32) (i32.ctz (br 0)))))
+    (set_local 0 (i32.add (get_local 0) (loop (result i32) (i32.ctz (loop (result i32) (br 1))))))
     (get_local 0)
   )
 
@@ -247,25 +275,25 @@
 )
 (assert_invalid
   (module (func $type-value-empty-vs-num (result i32)
-    (loop i32)
+    (loop (result i32))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-value-void-vs-num (result i32)
-    (loop i32 (nop))
+    (loop (result i32) (nop))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-value-num-vs-num (result i32)
-    (loop i32 (f32.const 0))
+    (loop (result i32) (f32.const 0))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-value-unreached-select (result i32)
-    (loop i64 (select (unreachable) (unreachable) (unreachable)))
+    (loop (result i64) (select (unreachable) (unreachable) (unreachable)))
   ))
   "type mismatch"
 )
diff --git a/test/core/memory.wast b/test/core/memory.wast
index 4539970c6..cf2de6aba 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -237,14 +237,14 @@
       (loop
         (if
           (i32.eq (get_local 0) (i32.const 0))
-          (br 2)
+          (then (br 2))
         )
         (set_local 2 (i32.mul (get_local 0) (i32.const 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))
+          (then (return (i32.const 0)))
         )
         (set_local 0 (i32.sub (get_local 0) (i32.const 1)))
         (br 0)
@@ -261,14 +261,14 @@
       (loop
         (if
           (i32.eq (get_local 0) (i32.const 0))
-          (br 2)
+          (then (br 2))
         )
         (set_local 2 (f64.convert_s/i32 (get_local 0)))
         (f64.store align=1 (get_local 0) (get_local 2))
         (set_local 1 (f64.load align=1 (get_local 0)))
         (if
           (f64.ne (get_local 2) (get_local 1))
-          (return (i32.const 0))
+          (then (return (i32.const 0)))
         )
         (set_local 0 (i32.sub (get_local 0) (i32.const 1)))
         (br 0)
@@ -285,7 +285,7 @@
         (f64.load (i32.const 8))
         (f64.reinterpret/i64 (i64.const -12345))
       )
-      (return (f64.const 0))
+      (then (return (f64.const 0)))
     )
     (i64.store align=1 (i32.const 9) (i64.const 0))
     (i32.store16 align=1 (i32.const 15) (i32.const 16453))
diff --git a/test/core/nop.wast b/test/core/nop.wast
index ab83eede2..286231558 100644
--- a/test/core/nop.wast
+++ b/test/core/nop.wast
@@ -43,69 +43,73 @@
   )
 
   (func (export "as-block-first") (result i32)
-    (block i32 (nop) (i32.const 2))
+    (block (result i32) (nop) (i32.const 2))
   )
   (func (export "as-block-mid") (result i32)
-    (block i32 (call $dummy) (nop) (i32.const 2))
+    (block (result i32) (call $dummy) (nop) (i32.const 2))
   )
   (func (export "as-block-last") (result i32)
-    (block i32 (nop) (call $dummy) (i32.const 3) (nop))
+    (block (result i32) (nop) (call $dummy) (i32.const 3) (nop))
   )
   (func (export "as-block-everywhere") (result i32)
-    (block i32 (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop))
+    (block (result i32)
+      (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop)
+    )
   )
 
   (func (export "as-loop-first") (result i32)
-    (loop i32 (nop) (i32.const 2))
+    (loop (result i32) (nop) (i32.const 2))
   )
   (func (export "as-loop-mid") (result i32)
-    (loop i32 (call $dummy) (nop) (i32.const 2))
+    (loop (result i32) (call $dummy) (nop) (i32.const 2))
   )
   (func (export "as-loop-last") (result i32)
-    (loop i32 (call $dummy) (i32.const 3) (nop))
+    (loop (result i32) (call $dummy) (i32.const 3) (nop))
   )
   (func (export "as-loop-everywhere") (result i32)
-    (loop i32 (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop))
+    (loop (result i32)
+      (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop)
+    )
   )
 
   (func (export "as-if-condition") (param i32)
     (get_local 0) (nop) (if (then (call $dummy)))
   )
   (func (export "as-if-then") (param i32)
-    (if (get_local 0) (nop) (call $dummy))
+    (if (get_local 0) (then (nop)) (else (call $dummy)))
   )
   (func (export "as-if-else") (param i32)
-    (if (get_local 0) (call $dummy) (nop))
+    (if (get_local 0) (then (call $dummy)) (else (nop)))
   )
 
   (func (export "as-br-last") (param i32) (result i32)
-    (block i32 (get_local 0) (nop) (br 0))
+    (block (result i32) (get_local 0) (nop) (br 0))
   )
   (func (export "as-br-everywhere") (param i32) (result i32)
-    (block i32 (nop) (nop) (get_local 0) (nop) (nop) (br 0))
+    (block (result i32) (nop) (nop) (get_local 0) (nop) (nop) (br 0))
   )
 
   (func (export "as-br_if-mid") (param i32) (result i32)
-    (block i32 (get_local 0) (nop) (get_local 0) (br_if 0))
+    (block (result i32) (get_local 0) (nop) (get_local 0) (br_if 0))
   )
   (func (export "as-br_if-last") (param i32) (result i32)
-    (block i32 (get_local 0) (get_local 0) (nop) (br_if 0))
+    (block (result i32) (get_local 0) (get_local 0) (nop) (br_if 0))
   )
   (func (export "as-br_if-everywhere") (param i32) (result i32)
-    (block i32
+    (block (result i32)
       (nop) (nop) (get_local 0) (nop) (nop) (get_local 0) (nop) (nop)
       (br_if 0)
     )
   )
 
   (func (export "as-br_table-mid") (param i32) (result i32)
-    (block i32 (get_local 0) (nop) (get_local 0) (br_table 0 0))
+    (block (result i32) (get_local 0) (nop) (get_local 0) (br_table 0 0))
   )
   (func (export "as-br_table-last") (param i32) (result i32)
-    (block i32 (get_local 0) (get_local 0) (nop) (br_table 0 0))
+    (block (result i32) (get_local 0) (get_local 0) (nop) (br_table 0 0))
   )
   (func (export "as-br_table-everywhere") (param i32) (result i32)
-    (block i32
+    (block (result i32)
       (nop) (nop) (get_local 0) (nop) (nop) (get_local 0) (nop) (nop)
       (br_table 0 0)
     )
diff --git a/test/core/return.wast b/test/core/return.wast
index 60db41c1f..48964cffc 100644
--- a/test/core/return.wast
+++ b/test/core/return.wast
@@ -35,33 +35,33 @@
     (block (nop) (call $dummy) (return))
   )
   (func (export "as-block-value") (result i32)
-    (block i32 (nop) (call $dummy) (return (i32.const 2)))
+    (block (result i32) (nop) (call $dummy) (return (i32.const 2)))
   )
 
   (func (export "as-loop-first") (result i32)
-    (loop i32 (return (i32.const 3)) (i32.const 2))
+    (loop (result i32) (return (i32.const 3)) (i32.const 2))
   )
   (func (export "as-loop-mid") (result i32)
-    (loop i32 (call $dummy) (return (i32.const 4)) (i32.const 2))
+    (loop (result i32) (call $dummy) (return (i32.const 4)) (i32.const 2))
   )
   (func (export "as-loop-last") (result i32)
-    (loop i32 (nop) (call $dummy) (return (i32.const 5)))
+    (loop (result i32) (nop) (call $dummy) (return (i32.const 5)))
   )
 
   (func (export "as-br-value") (result i32)
-    (block i32 (br 0 (return (i32.const 9))))
+    (block (result i32) (br 0 (return (i32.const 9))))
   )
 
   (func (export "as-br_if-cond")
     (block (br_if 0 (return)))
   )
   (func (export "as-br_if-value") (result i32)
-    (block i32
+    (block (result i32)
       (drop (br_if 0 (return (i32.const 8)) (i32.const 1))) (i32.const 7)
     )
   )
   (func (export "as-br_if-value-cond") (result i32)
-    (block i32
+    (block (result i32)
       (drop (br_if 0 (i32.const 6) (return (i32.const 9)))) (i32.const 7)
     )
   )
@@ -70,12 +70,12 @@
     (block (br_table 0 0 0 (return (i64.const 9)))) (i64.const -1)
   )
   (func (export "as-br_table-value") (result i32)
-    (block i32
+    (block (result i32)
       (br_table 0 0 0 (return (i32.const 10)) (i32.const 1)) (i32.const 7)
     )
   )
   (func (export "as-br_table-value-index") (result i32)
-    (block i32
+    (block (result i32)
       (br_table 0 0 (i32.const 6) (return (i32.const 11))) (i32.const 7)
     )
   )
@@ -85,13 +85,19 @@
   )
 
   (func (export "as-if-cond") (result i32)
-    (if i32 (return (i32.const 2)) (i32.const 0) (i32.const 1))
+    (if (result i32)
+      (return (i32.const 2)) (then (i32.const 0)) (else (i32.const 1))
+    )
   )
   (func (export "as-if-then") (param i32 i32) (result i32)
-    (if i32 (get_local 0) (return (i32.const 3)) (get_local 1))
+    (if (result i32)
+      (get_local 0) (then (return (i32.const 3))) (else (get_local 1))
+    )
   )
   (func (export "as-if-else") (param i32 i32) (result i32)
-    (if i32 (get_local 0) (get_local 1) (return (i32.const 4)))
+    (if (result i32)
+      (get_local 0) (then (get_local 1)) (else (return (i32.const 4)))
+    )
   )
 
   (func (export "as-select-first") (param i32 i32) (result i32)
diff --git a/test/core/stack.wast b/test/core/stack.wast
index f685b17f8..b3f321eca 100644
--- a/test/core/stack.wast
+++ b/test/core/stack.wast
@@ -8,8 +8,8 @@
       (loop $loop
         (if
           (i64.eq (get_local $i) (i64.const 0))
-          (br $done)
-          (block
+          (then (br $done))
+          (else
             (set_local $res (i64.mul (get_local $i) (get_local $res)))
             (set_local $i (i64.sub (get_local $i) (i64.const 1)))
           )
diff --git a/test/core/switch.wast b/test/core/switch.wast
index 2d4565a5d..829acc024 100644
--- a/test/core/switch.wast
+++ b/test/core/switch.wast
@@ -47,7 +47,7 @@
     (local $j i64)
     (set_local $j (i64.const 100))
     (return
-      (block $switch i64
+      (block $switch (result i64)
         (block $7
           (block $default
             (block $4
@@ -87,13 +87,13 @@
   ;; Argument switch
   (func (export "arg") (param $i i32) (result i32)
     (return
-      (block $2 i32
+      (block $2 (result i32)
         (i32.add (i32.const 10)
-          (block $1 i32
+          (block $1 (result i32)
             (i32.add (i32.const 100)
-              (block $0 i32
+              (block $0 (result i32)
                 (i32.add (i32.const 1000)
-                  (block $default i32
+                  (block $default (result i32)
                     (br_table $0 $1 $2 $default
                       (i32.mul (i32.const 2) (get_local $i))
                       (i32.and (i32.const 3) (get_local $i))
diff --git a/test/core/token-keyword-separation.fail.wast b/test/core/token-keyword-separation.fail.wast
new file mode 100644
index 000000000..aa29b6d3e
--- /dev/null
+++ b/test/core/token-keyword-separation.fail.wast
@@ -0,0 +1 @@
+(module (func (drop (i32.const0))))
diff --git a/test/core/token-number-separation.fail.wast b/test/core/token-number-separation.fail.wast
new file mode 100644
index 000000000..68fb517ce
--- /dev/null
+++ b/test/core/token-number-separation.fail.wast
@@ -0,0 +1 @@
+(module (func br 0drop))
diff --git a/test/core/typecheck.wast b/test/core/typecheck.wast
index 1d15cc567..72f6f621f 100644
--- a/test/core/typecheck.wast
+++ b/test/core/typecheck.wast
@@ -30,7 +30,7 @@
 (assert_invalid
   (module (func $type-unary-operand-missing-in-else
     (i32.const 0) (i32.const 0)
-    (if i32 (then (i32.const 0)) (else (i32.eqz))) (drop)
+    (if (result i32) (then (i32.const 0)) (else (i32.eqz))) (drop)
   ))
   "type mismatch"
 )
@@ -78,21 +78,21 @@
 (assert_invalid
   (module (func $type-binary-1st-operand-missing-in-if
     (i32.const 0) (i32.const 0) (i32.const 0)
-    (if (i32.add) (drop))
+    (if (i32.add) (then (drop)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-binary-2nd-operand-missing-in-if
     (i32.const 0) (i32.const 0)
-    (if (i32.const 0) (i32.add) (drop))
+    (if (i32.const 0) (then (i32.add)) (else (drop)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-binary-1st-operand-missing-in-else
     (i32.const 0) (i32.const 0) (i32.const 0)
-    (if i32 (then (i32.const 0)) (else (i32.add) (i32.const 0)))
+    (if (result i32) (then (i32.const 0)) (else (i32.add) (i32.const 0)))
     (drop) (drop)
   ))
   "type mismatch"
@@ -100,7 +100,7 @@
 (assert_invalid
   (module (func $type-binary-2nd-operand-missing-in-else
     (i32.const 0) (i32.const 0)
-    (if i32 (then (i32.const 0)) (else (i32.add)))
+    (if (result i32) (then (i32.const 0)) (else (i32.add)))
     (drop)
   ))
   "type mismatch"
@@ -136,7 +136,7 @@
 (assert_invalid
   (module (func $type-if-operand-missing-in-else
     (i32.const 0) (i32.const 0)
-    (if i32 (then (i32.const 0)) (else (if (then)) (i32.const 0)))
+    (if (result i32) (then (i32.const 0)) (else (if (then)) (i32.const 0)))
     (drop)
   ))
   "type mismatch"
@@ -144,7 +144,7 @@
 
 (assert_invalid
   (module (func $type-br-operand-missing
-    (block i32 (br 0))
+    (block (result i32) (br 0))
     (i32.eqz) (drop)
   ))
   "type mismatch"
@@ -152,7 +152,7 @@
 (assert_invalid
   (module (func $type-br-operand-missing-in-block
     (i32.const 0)
-    (block i32 (br 0))
+    (block (result i32) (br 0))
     (i32.eqz) (drop)
   ))
   "type mismatch"
@@ -161,7 +161,7 @@
   (module (func $type-br-operand-missing-in-if
     (block
       (i32.const 0) (i32.const 0)
-      (if i32 (then (br 0)))
+      (if (result i32) (then (br 0)))
     )
     (i32.eqz) (drop)
   ))
@@ -171,7 +171,7 @@
   (module (func $type-br-operand-missing-in-else
     (block
       (i32.const 0) (i32.const 0)
-      (if i32 (then (i32.const 0)) (else (br 0)))
+      (if (result i32) (then (i32.const 0)) (else (br 0)))
     )
     (i32.eqz) (drop)
   ))
@@ -208,7 +208,7 @@
 (assert_invalid
   (module (func $type-return-operand-missing-in-else (result i32)
     (i32.const 0) (i32.const 0)
-    (if i32 (then (i32.const 0)) (else (return))) (drop)
+    (if (result i32) (then (i32.const 0)) (else (return))) (drop)
   ))
   "type mismatch"
 )
@@ -216,7 +216,7 @@
 ;; TODO(stack): more of the above
 
 ;; if condition
-(assert_invalid (module (func (if (f32.const 0) (nop) (nop)))) "type mismatch")
+(assert_invalid (module (func (if (f32.const 0) (then)))) "type mismatch")
 
 ;; br_if condition
 (assert_invalid (module (func (block (br_if 0 (f32.const 0))))) "type mismatch")
diff --git a/test/core/unreachable.wast b/test/core/unreachable.wast
index f0d2c7390..30df789e2 100644
--- a/test/core/unreachable.wast
+++ b/test/core/unreachable.wast
@@ -24,62 +24,74 @@
   )
 
   (func (export "as-block-first") (result i32)
-    (block i32 (unreachable) (i32.const 2))
+    (block (result i32) (unreachable) (i32.const 2))
   )
   (func (export "as-block-mid") (result i32)
-    (block i32 (call $dummy) (unreachable) (i32.const 2))
+    (block (result i32) (call $dummy) (unreachable) (i32.const 2))
   )
   (func (export "as-block-last")
     (block (nop) (call $dummy) (unreachable))
   )
   (func (export "as-block-value") (result i32)
-    (block i32 (nop) (call $dummy) (unreachable))
+    (block (result i32) (nop) (call $dummy) (unreachable))
   )
   (func (export "as-block-broke") (result i32)
-    (block i32 (call $dummy) (br 0 (i32.const 1)) (unreachable))
+    (block (result i32) (call $dummy) (br 0 (i32.const 1)) (unreachable))
   )
 
   (func (export "as-loop-first") (result i32)
-    (loop i32 (unreachable) (i32.const 2))
+    (loop (result i32) (unreachable) (i32.const 2))
   )
   (func (export "as-loop-mid") (result i32)
-    (loop i32 (call $dummy) (unreachable) (i32.const 2))
+    (loop (result i32) (call $dummy) (unreachable) (i32.const 2))
   )
   (func (export "as-loop-last")
     (loop (nop) (call $dummy) (unreachable))
   )
   (func (export "as-loop-broke") (result i32)
-    (block i32 (loop i32 (call $dummy) (br 1 (i32.const 1)) (unreachable)))
+    (block (result i32)
+      (loop (result i32) (call $dummy) (br 1 (i32.const 1)) (unreachable))
+    )
   )
 
   (func (export "as-br-value") (result i32)
-    (block i32 (br 0 (unreachable)))
+    (block (result i32) (br 0 (unreachable)))
   )
 
   (func (export "as-br_if-cond")
     (block (br_if 0 (unreachable)))
   )
   (func (export "as-br_if-value") (result i32)
-    (block i32 (drop (br_if 0 (unreachable) (i32.const 1))) (i32.const 7))
+    (block (result i32)
+      (drop (br_if 0 (unreachable) (i32.const 1))) (i32.const 7)
+    )
   )
   (func (export "as-br_if-value-cond") (result i32)
-    (block i32 (drop (br_if 0 (i32.const 6) (unreachable))) (i32.const 7))
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (unreachable))) (i32.const 7)
+    )
   )
 
   (func (export "as-br_table-index")
     (block (br_table 0 0 0 (unreachable)))
   )
   (func (export "as-br_table-value") (result i32)
-    (block i32 (br_table 0 0 0 (unreachable) (i32.const 1)) (i32.const 7))
+    (block (result i32)
+      (br_table 0 0 0 (unreachable) (i32.const 1)) (i32.const 7)
+    )
   )
   (func (export "as-br_table-value-2") (result i32)
-    (block i32 (block i32 (br_table 0 1 (unreachable) (i32.const 1))))
+    (block (result i32)
+      (block (result i32) (br_table 0 1 (unreachable) (i32.const 1)))
+    )
   )
   (func (export "as-br_table-value-index") (result i32)
-    (block i32 (br_table 0 0 (i32.const 6) (unreachable)) (i32.const 7))
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (unreachable)) (i32.const 7)
+    )
   )
   (func (export "as-br_table-value-and-index") (result i32)
-    (block i32 (br_table 0 0 (unreachable)) (i32.const 8))
+    (block (result i32) (br_table 0 0 (unreachable)) (i32.const 8))
   )
 
   (func (export "as-return-value") (result i64)
@@ -87,13 +99,13 @@
   )
 
   (func (export "as-if-cond") (result i32)
-    (if i32 (unreachable) (i32.const 0) (i32.const 1))
+    (if (result i32) (unreachable) (then (i32.const 0)) (else (i32.const 1)))
   )
   (func (export "as-if-then") (param i32 i32) (result i32)
-    (if i32 (get_local 0) (unreachable) (get_local 1))
+    (if (result i32) (get_local 0) (then (unreachable)) (else (get_local 1)))
   )
   (func (export "as-if-else") (param i32 i32) (result i32)
-    (if i32 (get_local 0) (get_local 1) (unreachable))
+    (if (result i32) (get_local 0) (then (get_local 1)) (else (unreachable)))
   )
 
   (func (export "as-select-first") (param i32 i32) (result i32)
diff --git a/test/core/unreached-invalid.wast b/test/core/unreached-invalid.wast
index f0ad5ca7f..8c73deb9c 100644
--- a/test/core/unreached-invalid.wast
+++ b/test/core/unreached-invalid.wast
@@ -99,7 +99,7 @@
 )
 (assert_invalid
   (module (func $type-block-value-num-vs-num-after-break (result i32)
-    (block i32 (i32.const 1) (br 0) (f32.const 0))
+    (block (result i32) (i32.const 1) (br 0) (f32.const 0))
   ))
   "type mismatch"
 )
@@ -111,7 +111,7 @@
 )
 (assert_invalid
   (module (func $type-loop-value-num-vs-num-after-break (result i32)
-    (loop i32 (br 1 (i32.const 1)) (f32.const 0))
+    (loop (result i32) (br 1 (i32.const 1)) (f32.const 0))
   ))
   "type mismatch"
 )
@@ -160,7 +160,7 @@
 )
 (assert_invalid
   (module (func $type-block-value-num-vs-num-after-return (result i32)
-    (block i32 (i32.const 1) (return (i32.const 0)) (f32.const 0))
+    (block (result i32) (i32.const 1) (return (i32.const 0)) (f32.const 0))
   ))
   "type mismatch"
 )
@@ -172,7 +172,7 @@
 )
 (assert_invalid
   (module (func $type-loop-value-num-vs-num-after-return (result i32)
-    (loop i32 (return (i32.const 1)) (f32.const 0))
+    (loop (result i32) (return (i32.const 1)) (f32.const 0))
   ))
   "type mismatch"
 )
@@ -221,7 +221,7 @@
 )
 (assert_invalid
   (module (func $type-block-value-num-vs-num-after-unreachable (result i32)
-    (block i32 (i32.const 1) (unreachable) (f32.const 0))
+    (block (result i32) (i32.const 1) (unreachable) (f32.const 0))
   ))
   "type mismatch"
 )
@@ -233,7 +233,7 @@
 )
 (assert_invalid
   (module (func $type-loop-value-num-vs-num-after-unreachable (result i32)
-    (loop i32 (unreachable) (f32.const 0))
+    (loop (result i32) (unreachable) (f32.const 0))
   ))
   "type mismatch"
 )
@@ -283,7 +283,7 @@
 (assert_invalid
   (module (func $type-block-value-num-vs-num-after-nested-unreachable
     (result i32)
-    (block i32 (i32.const 1) (block (unreachable)) (f32.const 0))
+    (block (result i32) (i32.const 1) (block (unreachable)) (f32.const 0))
   ))
   "type mismatch"
 )
@@ -296,7 +296,7 @@
 (assert_invalid
   (module (func $type-loop-value-num-vs-num-after-nested-unreachable
     (result i32)
-    (loop i32 (block (unreachable)) (f32.const 0))
+    (loop (result i32) (block (unreachable)) (f32.const 0))
   ))
   "type mismatch"
 )
@@ -346,7 +346,7 @@
 )
 (assert_invalid
   (module (func $type-block-value-num-vs-num-after-infinite-loop (result i32)
-    (block i32 (i32.const 1) (loop (br 0)) (f32.const 0))
+    (block (result i32) (i32.const 1) (loop (br 0)) (f32.const 0))
   ))
   "type mismatch"
 )
@@ -358,7 +358,7 @@
 )
 (assert_invalid
   (module (func $type-loop-value-num-vs-num-after-infinite-loop (result i32)
-    (loop i32 (loop (br 0)) (f32.const 0))
+    (loop (result i32) (loop (br 0)) (f32.const 0))
   ))
   "type mismatch"
 )
@@ -407,7 +407,7 @@
 )
 (assert_invalid
   (module (func $type-if-value-num-vs-num-in-dead-body (result i32)
-    (if i32 (i32.const 0) (then (f32.const 0)))
+    (if (result i32) (i32.const 0) (then (f32.const 0)))
   ))
   "type mismatch"
 )
@@ -419,7 +419,7 @@
 )
 (assert_invalid
   (module (func $type-block-value-num-vs-num-in-dead-body (result i32)
-    (if i32 (i32.const 0) (then (block i32 (f32.const 0))))
+    (if (result i32) (i32.const 0) (then (block (result i32) (f32.const 0))))
   ))
   "type mismatch"
 )
@@ -431,7 +431,7 @@
 )
 (assert_invalid
   (module (func $type-block-value-num-vs-num-in-dead-body (result i32)
-    (if i32 (i32.const 0) (then (loop i32 (f32.const 0))))
+    (if (result i32) (i32.const 0) (then (loop (result i32) (f32.const 0))))
   ))
   "type mismatch"
 )
@@ -445,7 +445,7 @@
 
 (assert_invalid
   (module (func $type-br-second-num-vs-num (result i32)
-    (block i32 (br 0 (i32.const 1)) (br 0 (f64.const 1)))
+    (block (result i32) (br 0 (i32.const 1)) (br 0 (f64.const 1)))
   ))
   "type mismatch"
 )
@@ -464,14 +464,14 @@
 )
 (assert_invalid
   (module (func $type-br_table-label-num-vs-num-after-unreachable (result i32)
-    (block i32 (unreachable) (br_table 0 (f32.const 0) (i32.const 1)))
+    (block (result i32) (unreachable) (br_table 0 (f32.const 0) (i32.const 1)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-br_table-label-num-vs-label-void-after-unreachable
     (block
-      (block f32
+      (block (result f32)
         (unreachable)
         (br_table 0 1 0 (i32.const 1))
       )
@@ -482,8 +482,8 @@
 )
 (assert_invalid
   (module (func $type-br_table-label-num-vs-label-num-after-unreachable
-    (block f64
-      (block f32
+    (block (result f64)
+      (block (result f32)
         (unreachable)
         (br_table 0 1 1 (i32.const 1))
       )
@@ -509,7 +509,7 @@
 )
 (assert_invalid
   (module (func $type-block-value-nested-unreachable-num-vs-num (result i32)
-    (block i64 (i64.const 0) (block (unreachable)))
+    (block (result i64) (i64.const 0) (block (unreachable)))
   ))
   "type mismatch"
 )
@@ -528,13 +528,13 @@
 )
 (assert_invalid
   (module (func $type-block-value-nested-br-void-vs-num (result i32)
-    (block i32 (block (br 1 (i32.const 0))))
+    (block (result i32) (block (br 1 (i32.const 0))))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-block-value-nested-br-num-vs-num (result i32)
-    (block i32 (i64.const 0) (block (br 1 (i32.const 0))))
+    (block (result i32) (i64.const 0) (block (br 1 (i32.const 0))))
   ))
   "type mismatch"
 )
@@ -547,13 +547,15 @@
 )
 (assert_invalid
   (module (func $type-block-value-nested2-br-void-vs-num (result i32)
-    (block i32 (block (block (br 2 (i32.const 0)))))
+    (block (result i32) (block (block (br 2 (i32.const 0)))))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-block-value-nested2-br-num-vs-num (result i32)
-    (block i32 (block i64 (i64.const 0) (block (br 2 (i32.const 0)))))
+    (block (result i32)
+      (block (result i64) (i64.const 0) (block (br 2 (i32.const 0))))
+    )
   ))
   "type mismatch"
 )
@@ -578,7 +580,7 @@
 )
 (assert_invalid
   (module (func $type-block-value-nested-return-num-vs-num (result i32)
-    (block i64 (i64.const 0) (block (return (i32.const 0))))
+    (block (result i64) (i64.const 0) (block (return (i32.const 0))))
   ))
   "type mismatch"
 )
@@ -604,7 +606,7 @@
 )
 (assert_invalid
   (module (func $type-loop-value-nested-unreachable-num-vs-num (result i32)
-    (loop i64 (i64.const 0) (block (unreachable)))
+    (loop (result i64) (i64.const 0) (block (unreachable)))
   ))
   "type mismatch"
 )
diff --git a/test/core/unwind.wast b/test/core/unwind.wast
index b993f2a87..40b0dcf6f 100644
--- a/test/core/unwind.wast
+++ b/test/core/unwind.wast
@@ -27,28 +27,30 @@
     (block (i32.const 3) (i64.const 1) (br 0)) (i32.const 9)
   )
   (func (export "block-unwind-by-br-value") (result i32)
-    (block i32 (i32.const 3) (i64.const 1) (br 0 (i32.const 9)))
+    (block (result i32) (i32.const 3) (i64.const 1) (br 0 (i32.const 9)))
   )
   (func (export "block-unwind-by-br_table") (result i32)
     (block (i32.const 3) (i64.const 1) (br_table 0 (i32.const 0))) (i32.const 9)
   )
   (func (export "block-unwind-by-br_table-value") (result i32)
-    (block i32
+    (block (result i32)
       (i32.const 3) (i64.const 1) (br_table 0 (i32.const 9) (i32.const 0))
     )
   )
   (func (export "block-unwind-by-return") (result i32)
-    (block i32 (i32.const 3) (i64.const 1) (return (i32.const 9)))
+    (block (result i32) (i32.const 3) (i64.const 1) (return (i32.const 9)))
   )
 
   (func (export "block-nested-unwind-by-unreachable") (result i32)
-    (block i32 (i32.const 3) (block (i64.const 1) (unreachable)))
+    (block (result i32) (i32.const 3) (block (i64.const 1) (unreachable)))
   )
   (func (export "block-nested-unwind-by-br") (result i32)
     (block (i32.const 3) (block (i64.const 1) (br 1)) (drop)) (i32.const 9)
   )
   (func (export "block-nested-unwind-by-br-value") (result i32)
-    (block i32 (i32.const 3) (block (i64.const 1) (br 1 (i32.const 9))))
+    (block (result i32)
+      (i32.const 3) (block (i64.const 1) (br 1 (i32.const 9)))
+    )
   )
   (func (export "block-nested-unwind-by-br_table") (result i32)
     (block
@@ -58,23 +60,25 @@
     (i32.const 9)
   )
   (func (export "block-nested-unwind-by-br_table-value") (result i32)
-    (block i32
+    (block (result i32)
       (i32.const 3)
       (block (i64.const 1) (br_table 1 (i32.const 9) (i32.const 1)))
     )
   )
   (func (export "block-nested-unwind-by-return") (result i32)
-    (block i32 (i32.const 3) (block (i64.const 1) (return (i32.const 9))))
+    (block (result i32)
+      (i32.const 3) (block (i64.const 1) (return (i32.const 9)))
+    )
   )
 
   (func (export "unary-after-unreachable") (result i32)
     (f32.const 0) (unreachable) (i64.eqz)
   )
   (func (export "unary-after-br") (result i32)
-    (block i32 (f32.const 0) (br 0 (i32.const 9)) (i64.eqz))
+    (block (result i32) (f32.const 0) (br 0 (i32.const 9)) (i64.eqz))
   )
   (func (export "unary-after-br_table") (result i32)
-    (block i32
+    (block (result i32)
       (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0)) (i64.eqz)
     )
   )
@@ -86,10 +90,12 @@
     (f32.const 0) (f64.const 1) (unreachable) (i64.eq)
   )
   (func (export "binary-after-br") (result i32)
-    (block i32 (f32.const 0) (f64.const 1) (br 0 (i32.const 9)) (i64.eq))
+    (block (result i32)
+      (f32.const 0) (f64.const 1) (br 0 (i32.const 9)) (i64.eq)
+    )
   )
   (func (export "binary-after-br_table") (result i32)
-    (block i32
+    (block (result i32)
       (f32.const 0) (f64.const 1) (br_table 0 (i32.const 9) (i32.const 0))
       (i64.eq)
     )
@@ -102,12 +108,12 @@
     (f32.const 0) (f64.const 1) (i64.const 0) (unreachable) (select)
   )
   (func (export "select-after-br") (result i32)
-    (block i32
+    (block (result i32)
       (f32.const 0) (f64.const 1) (i64.const 0) (br 0 (i32.const 9)) (select)
     )
   )
   (func (export "select-after-br_table") (result i32)
-    (block i32
+    (block (result i32)
       (f32.const 0) (f64.const 1) (i64.const 0)
       (br_table 0 (i32.const 9) (i32.const 0))
       (select)
@@ -118,31 +124,35 @@
   )
 
   (func (export "block-value-after-unreachable") (result i32)
-    (block i32 (f32.const 0) (unreachable))
+    (block (result i32) (f32.const 0) (unreachable))
   )
   (func (export "block-value-after-br") (result i32)
-    (block i32 (f32.const 0) (br 0 (i32.const 9)))
+    (block (result i32) (f32.const 0) (br 0 (i32.const 9)))
   )
   (func (export "block-value-after-br_table") (result i32)
-    (block i32 (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0)))
+    (block (result i32)
+      (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0))
+    )
   )
   (func (export "block-value-after-return") (result i32)
-    (block i32 (f32.const 0) (return (i32.const 9)))
+    (block (result i32) (f32.const 0) (return (i32.const 9)))
   )
 
   (func (export "loop-value-after-unreachable") (result i32)
-    (loop i32 (f32.const 0) (unreachable))
+    (loop (result i32) (f32.const 0) (unreachable))
   )
   (func (export "loop-value-after-br") (result i32)
-    (block i32 (loop i32 (f32.const 0) (br 1 (i32.const 9))))
+    (block (result i32) (loop (result i32) (f32.const 0) (br 1 (i32.const 9))))
   )
   (func (export "loop-value-after-br_table") (result i32)
-    (block i32
-      (loop i32 (f32.const 0) (br_table 1 1 (i32.const 9) (i32.const 0)))
+    (block (result i32)
+      (loop (result i32)
+        (f32.const 0) (br_table 1 1 (i32.const 9) (i32.const 0))
+      )
     )
   )
   (func (export "loop-value-after-return") (result i32)
-    (loop i32 (f32.const 0) (return (i32.const 9)))
+    (loop (result i32) (f32.const 0) (return (i32.const 9)))
   )
 )
 

From 6d6648ba56e2d1b0800deb88f482d55dfad4ed73 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 6 Jun 2017 13:08:14 +0200
Subject: [PATCH 024/329] [spec] Implementation restrictions (#483)

Includes [spec] Allow impls to limit code point range (#488).
---
 document/appendix-names/index.rst             |   6 -
 document/appendix-properties/index.rst        |   6 -
 .../index.rst => appendix/algorithm.rst}      |   4 +-
 document/appendix/implementation.rst          | 137 ++++++++++++++++++
 document/appendix/index.rst                   |  12 ++
 document/appendix/names.rst                   |   6 +
 document/appendix/properties.rst              |   8 +
 document/index.rst                            |   4 +-
 8 files changed, 166 insertions(+), 17 deletions(-)
 delete mode 100644 document/appendix-names/index.rst
 delete mode 100644 document/appendix-properties/index.rst
 rename document/{appendix-algorithm/index.rst => appendix/algorithm.rst} (59%)
 create mode 100644 document/appendix/implementation.rst
 create mode 100644 document/appendix/index.rst
 create mode 100644 document/appendix/names.rst
 create mode 100644 document/appendix/properties.rst

diff --git a/document/appendix-names/index.rst b/document/appendix-names/index.rst
deleted file mode 100644
index 6c8fe7a20..000000000
--- a/document/appendix-names/index.rst
+++ /dev/null
@@ -1,6 +0,0 @@
-Appendix: Name Section
-----------------------
-
-.. todo::
-
-   Describe
diff --git a/document/appendix-properties/index.rst b/document/appendix-properties/index.rst
deleted file mode 100644
index d43f7ccf9..000000000
--- a/document/appendix-properties/index.rst
+++ /dev/null
@@ -1,6 +0,0 @@
-Appendix: Formal Properties
----------------------------
-
-.. todo::
-
-   Describe and sketch proof (progress, preservation, uniqueness)
diff --git a/document/appendix-algorithm/index.rst b/document/appendix/algorithm.rst
similarity index 59%
rename from document/appendix-algorithm/index.rst
rename to document/appendix/algorithm.rst
index 883daeb7d..48797273e 100644
--- a/document/appendix-algorithm/index.rst
+++ b/document/appendix/algorithm.rst
@@ -1,5 +1,5 @@
-Appendix: Validation Algorithm
-------------------------------
+Validation Algorithm
+--------------------
 
 .. todo::
 
diff --git a/document/appendix/implementation.rst b/document/appendix/implementation.rst
new file mode 100644
index 000000000..2513fa113
--- /dev/null
+++ b/document/appendix/implementation.rst
@@ -0,0 +1,137 @@
+.. _impl:
+.. index:: ! implementation limitations, implementation
+
+Implementation Limitations
+--------------------------
+
+Implementations typically impose additional restrictions on a number of aspects of a WebAssembly module or execution.
+These may stem from:
+
+* physical resource limits,
+* constraints imposed by the embedder or its environment,
+* limitations of selected implementation strategies.
+
+This section lists allowed limitations.
+Where restrictions take the form of numeric limits, no minimum requirements are given,
+nor are the limits assumed to be concrete, fixed numbers.
+However, it is expected that all implementations have "reasonably" large limits  to enable common applications.
+
+.. note::
+   A conforming implementation is not allowed to leave out individual *features*.
+   However, designated subsets of WebAssembly may be specified in the future.
+
+
+Syntactic Limits
+~~~~~~~~~~~~~~~~
+
+.. _impl-syntax:
+.. index:: abstract syntax, module, type, function, table, memory, global, element, data, import, export, parameter, result, local, structured control instruction, instruction, name, Unicode, code point
+
+Structure
+.........
+
+An implementation may impose restrictions on the following dimensions of a module:
+
+* the number of :ref:`types <syntax-type>` in a :ref:`module <syntax-module>`
+* the number of :ref:`functions <syntax-func>` in a :ref:`module <syntax-module>`, including imports
+* the number of :ref:`tables <syntax-table>` in a :ref:`module <syntax-module>`, including imports
+* the number of :ref:`memories <syntax-mem>` in a :ref:`module <syntax-module>`, including imports
+* the number of :ref:`globals <syntax-global>` in a :ref:`module <syntax-module>`, including imports
+* the number of :ref:`element segments <syntax-elem>` in a :ref:`module <syntax-module>`
+* the number of :ref:`data segments <syntax-data>` in a :ref:`module <syntax-module>`
+* the number of :ref:`imports <syntax-import>` to a :ref:`module <syntax-module>`
+* the number of :ref:`exports <syntax-export>` form a :ref:`module <syntax-module>`
+* the number of parameters in a :ref:`function type <syntax-functype>`
+* the number of results in a :ref:`function type <syntax-functype>`
+* the number of :ref:`locals <syntax-local>` in a :ref:`function <syntax-func>`
+* the size of a :ref:`function <syntax-func>` body
+* the size of a :ref:`structured control instruction <syntax-instr-control>`
+* the number of :ref:`structured control instructions <syntax-instr-control>` in a :ref:`function <syntax-func>`
+* the nesting depth of :ref:`structured control instructions <syntax-instr-control>`
+* the number of :ref:`label indices <syntax-labelidx>` in a |brtable| instruction
+* the length of an :ref:`element segment <syntax-elem>`
+* the length of a :ref:`data segment <syntax-data>`
+* the length of a :ref:`name <syntax-name>`
+* the range of :ref:`code points <syntax-codepoint>` in a :ref:`name <syntax-name>`
+
+If the limits of an implementation are exceeded for a given module,
+then the implementation may reject the :ref:`validation <valid>`, compilation, or :ref:`instantiation <exec-instantiate>` of that module with an embedder-specific error.
+
+.. note::
+   The last item allows embedders that operate in limited environments without support for
+   `Unicode <http://www.unicode.org/versions/latest/>`_ to limit the
+   names of :ref:`imports <syntax-import>` and :ref:`exports <syntax-export>`
+   to common subsets like `ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_.
+
+
+.. _impl-binary:
+.. index:: binary format, module, section, function, code
+
+Binary Format
+.............
+
+For a module given in :ref:`binary format <binary>`, additional limitations may be imposed on the following dimensions:
+
+* the size of a :ref:`module <binary-module>`
+* the size of any :ref:`section <binary-section>`
+* the size of an individual :ref:`function's code <binary-func>`
+* the number of :ref:`sections <binary-section>`
+
+
+.. _impl-text:
+.. index:: text format, source text, token, identifier, character, unicode
+
+Text Format
+...........
+
+For a module given in :ref:`text format <text>`, additional limitations may be imposed on the following dimensions:
+
+* the size of the :ref:`source text <source>`
+* the size of any syntactic element
+* the size of an individual :ref:`token <text-token>`
+* the nesting depth of :ref:`folded instructions <text-foldedinstr>`
+* the length of symbolic :ref:`identifiers <text-id>`
+* the range of literal :ref:`characters <text-char>` (code points) allowed in the :ref:`source text <source>`
+
+
+.. _impl-valid:
+.. index:: validation, function
+
+Validation
+~~~~~~~~~~
+
+An implementation may defer :ref:`validation <valid>` of individual :ref:`functions <syntax-func>` until they are first :ref:`invoked <exec-invoke>`.
+
+If a function turns out to be invalid, then the invocation, and every consecutive call to the same function, results in a :ref:`trap <trap>`.
+
+.. note::
+   This is to allow implementations to use interpretation or just-in-time compilation for functions.
+   The function must still be fully validated before execution of its body begins.
+
+
+.. _impl-exec:
+.. index:: execution, module instance, function instance, table instance, memory instance, global instance, allocation, frame, label, value
+
+Execution
+~~~~~~~~~
+
+Restrictions on the following dimensions may be imposed during :ref:`execution <exec>` of a WebAssembly program:
+
+* the number of allocated :ref:`module instances <syntax-moduleinst>`
+* the number of allocated :ref:`function instances <syntax-funcinst>`
+* the number of allocated :ref:`table instances <syntax-tableinst>`
+* the number of allocated :ref:`memory instances <syntax-meminst>`
+* the number of allocated :ref:`global instances <syntax-globalinst>`
+* the size of a :ref:`table instance <syntax-tableinst>`
+* the size of a :ref:`memory instance <syntax-meminst>`
+* the number of :ref:`frames <syntax-frame>` on the :ref:`stack <syntax-stack>`
+* the number of :ref:`labels <syntax-label>` on the :ref:`stack <syntax-stack>`
+* the number of :ref:`values <syntax-val>` on the :ref:`stack <syntax-stack>`
+
+If the runtime limits of an implementation are exceeded during execution of a computation,
+then it may terminate that computation and report an embedder-specific error to the invoking code.
+
+Some of the above limits may already be verified during instantiation, in which case an implementation may report exceedance in the same manner as for :ref:`syntactic limits <impl-syntax>`.
+
+.. note::
+   Concrete limits are usually not fixed but may be dependent on specifics, interdependent, vary over time, or depend on other implementation- or embedder-specific situations or events.
diff --git a/document/appendix/index.rst b/document/appendix/index.rst
new file mode 100644
index 000000000..628e85999
--- /dev/null
+++ b/document/appendix/index.rst
@@ -0,0 +1,12 @@
+.. _appendix:
+
+Appendix
+========
+
+.. toctree::
+   :maxdepth: 2
+
+   implementation
+   names
+   properties
+   algorithm
diff --git a/document/appendix/names.rst b/document/appendix/names.rst
new file mode 100644
index 000000000..a203ce2de
--- /dev/null
+++ b/document/appendix/names.rst
@@ -0,0 +1,6 @@
+Name Section
+------------
+
+.. todo::
+
+   Describe
diff --git a/document/appendix/properties.rst b/document/appendix/properties.rst
new file mode 100644
index 000000000..5d0acdaaa
--- /dev/null
+++ b/document/appendix/properties.rst
@@ -0,0 +1,8 @@
+Formal Properties
+-----------------
+
+.. todo::
+
+   * representation (bijection between abstract and binary)
+   * validation (progress, preservation)
+   * ...
diff --git a/document/index.rst b/document/index.rst
index 6b29eefc1..2554ac250 100644
--- a/document/index.rst
+++ b/document/index.rst
@@ -14,9 +14,7 @@ WebAssembly Specification
    execution/index
    binary/index
    text/index
-   appendix-properties/index
-   appendix-algorithm/index
-   appendix-names/index
+   appendix/index
 
 .. only:: latex
 

From 740abc262fb32090a45aef2c5fd7feec9368ef45 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 6 Jun 2017 14:46:33 +0200
Subject: [PATCH 025/329] [interpreter] Support quoted module definitions in
 .wast (#475)

Also converts all existing .fail. tests to uses of quotation.
---
 interpreter/Makefile                          |   4 +-
 interpreter/host/js.ml                        |  18 +-
 interpreter/host/run.ml                       |   9 +-
 interpreter/text/arrange.ml                   |  65 ++--
 interpreter/text/lexer.mll                    |   5 +-
 interpreter/text/parser.mly                   |  36 +-
 interpreter/text/script.ml                    |   1 +
 interpreter/util/lib.ml                       |   8 +
 interpreter/util/lib.mli                      |   1 +
 test/core/address-offset-range.fail.wast      |   4 -
 test/core/address.wast                        |   8 +
 test/core/align.wast                          |  33 ++
 test/core/binary.wast                         |  64 ++--
 test/core/block-end-label-mismatch.fail.wast  |   1 -
 .../block-end-label-superfluous.fail.wast     |   1 -
 test/core/block.wast                          |  10 +
 test/core/const.wast                          |  47 +++
 test/core/custom_section.wast                 |  18 +-
 test/core/f32.load32.fail.wast                |   1 -
 test/core/f32.load64.fail.wast                |   1 -
 test/core/f32.store32.fail.wast               |   1 -
 test/core/f32.store64.fail.wast               |   1 -
 test/core/f64.load32.fail.wast                |   1 -
 test/core/f64.load64.fail.wast                |   1 -
 test/core/f64.store32.fail.wast               |   1 -
 test/core/f64.store64.fail.wast               |   1 -
 test/core/func-local-after-body.fail.wast     |   1 -
 test/core/func-local-before-param.fail.wast   |   1 -
 test/core/func-local-before-result.fail.wast  |   1 -
 test/core/func-param-after-body.fail.wast     |   1 -
 test/core/func-result-after-body.fail.wast    |   1 -
 test/core/func-result-before-param.fail.wast  |   1 -
 test/core/func.wast                           |  27 ++
 test/core/globals.wast                        |   8 +-
 test/core/i32.load32_s.fail.wast              |   1 -
 test/core/i32.load32_u.fail.wast              |   1 -
 test/core/i32.load64_s.fail.wast              |   1 -
 test/core/i32.load64_u.fail.wast              |   1 -
 test/core/i32.store32.fail.wast               |   1 -
 test/core/i32.store64.fail.wast               |   1 -
 test/core/i64.load64_s.fail.wast              |   1 -
 test/core/i64.load64_u.fail.wast              |   1 -
 test/core/i64.store64.fail.wast               |   1 -
 .../core/if-else-end-label-mismatch.fail.wast |   1 -
 .../if-else-end-label-superfluous.fail.wast   |   1 -
 test/core/if-else-label-mismatch.fail.wast    |   1 -
 test/core/if-else-label-superfluous.fail.wast |   1 -
 test/core/if-end-label-mismatch.fail.wast     |   1 -
 test/core/if-end-label-superfluous.fail.wast  |   1 -
 test/core/if.wast                             |  42 +++
 test/core/import-after-func.fail.wast         |   1 -
 test/core/import-after-global.fail.wast       |   1 -
 test/core/import-after-memory.fail.wast       |   1 -
 test/core/import-after-table.fail.wast        |   1 -
 test/core/imports.wast                        |  71 ++++
 test/core/load-align-0.fail.wast              |   1 -
 test/core/load-align-big.fail.wast            |   1 -
 test/core/load-align-odd.fail.wast            |   1 -
 test/core/loop-end-label-mismatch.fail.wast   |   1 -
 .../core/loop-end-label-superfluous.fail.wast |   1 -
 test/core/loop.wast                           |  10 +
 test/core/memory.wast                         | 144 +++++++
 .../core/of_string-overflow-hex-u32.fail.wast |   1 -
 .../core/of_string-overflow-hex-u64.fail.wast |   1 -
 test/core/of_string-overflow-s32.fail.wast    |   1 -
 test/core/of_string-overflow-s64.fail.wast    |   1 -
 test/core/of_string-overflow-u32.fail.wast    |   1 -
 test/core/of_string-overflow-u64.fail.wast    |   1 -
 test/core/store-align-0.fail.wast             |   1 -
 test/core/store-align-big.fail.wast           |   1 -
 test/core/store-align-odd.fail.wast           |   1 -
 test/core/token-keyword-separation.fail.wast  |   1 -
 test/core/token-number-separation.fail.wast   |   1 -
 test/core/token.wast                          |  10 +
 test/core/utf8-custom-section-id.wast         | 352 +++++++++---------
 test/core/utf8-import-field.wast              | 352 +++++++++---------
 test/core/utf8-import-module.wast             | 352 +++++++++---------
 77 files changed, 1070 insertions(+), 680 deletions(-)
 delete mode 100644 test/core/address-offset-range.fail.wast
 create mode 100644 test/core/align.wast
 delete mode 100644 test/core/block-end-label-mismatch.fail.wast
 delete mode 100644 test/core/block-end-label-superfluous.fail.wast
 create mode 100644 test/core/const.wast
 delete mode 100644 test/core/f32.load32.fail.wast
 delete mode 100644 test/core/f32.load64.fail.wast
 delete mode 100644 test/core/f32.store32.fail.wast
 delete mode 100644 test/core/f32.store64.fail.wast
 delete mode 100644 test/core/f64.load32.fail.wast
 delete mode 100644 test/core/f64.load64.fail.wast
 delete mode 100644 test/core/f64.store32.fail.wast
 delete mode 100644 test/core/f64.store64.fail.wast
 delete mode 100644 test/core/func-local-after-body.fail.wast
 delete mode 100644 test/core/func-local-before-param.fail.wast
 delete mode 100644 test/core/func-local-before-result.fail.wast
 delete mode 100644 test/core/func-param-after-body.fail.wast
 delete mode 100644 test/core/func-result-after-body.fail.wast
 delete mode 100644 test/core/func-result-before-param.fail.wast
 delete mode 100644 test/core/i32.load32_s.fail.wast
 delete mode 100644 test/core/i32.load32_u.fail.wast
 delete mode 100644 test/core/i32.load64_s.fail.wast
 delete mode 100644 test/core/i32.load64_u.fail.wast
 delete mode 100644 test/core/i32.store32.fail.wast
 delete mode 100644 test/core/i32.store64.fail.wast
 delete mode 100644 test/core/i64.load64_s.fail.wast
 delete mode 100644 test/core/i64.load64_u.fail.wast
 delete mode 100644 test/core/i64.store64.fail.wast
 delete mode 100644 test/core/if-else-end-label-mismatch.fail.wast
 delete mode 100644 test/core/if-else-end-label-superfluous.fail.wast
 delete mode 100644 test/core/if-else-label-mismatch.fail.wast
 delete mode 100644 test/core/if-else-label-superfluous.fail.wast
 delete mode 100644 test/core/if-end-label-mismatch.fail.wast
 delete mode 100644 test/core/if-end-label-superfluous.fail.wast
 delete mode 100644 test/core/import-after-func.fail.wast
 delete mode 100644 test/core/import-after-global.fail.wast
 delete mode 100644 test/core/import-after-memory.fail.wast
 delete mode 100644 test/core/import-after-table.fail.wast
 delete mode 100644 test/core/load-align-0.fail.wast
 delete mode 100644 test/core/load-align-big.fail.wast
 delete mode 100644 test/core/load-align-odd.fail.wast
 delete mode 100644 test/core/loop-end-label-mismatch.fail.wast
 delete mode 100644 test/core/loop-end-label-superfluous.fail.wast
 delete mode 100644 test/core/of_string-overflow-hex-u32.fail.wast
 delete mode 100644 test/core/of_string-overflow-hex-u64.fail.wast
 delete mode 100644 test/core/of_string-overflow-s32.fail.wast
 delete mode 100644 test/core/of_string-overflow-s64.fail.wast
 delete mode 100644 test/core/of_string-overflow-u32.fail.wast
 delete mode 100644 test/core/of_string-overflow-u64.fail.wast
 delete mode 100644 test/core/store-align-0.fail.wast
 delete mode 100644 test/core/store-align-big.fail.wast
 delete mode 100644 test/core/store-align-odd.fail.wast
 delete mode 100644 test/core/token-keyword-separation.fail.wast
 delete mode 100644 test/core/token-number-separation.fail.wast
 create mode 100644 test/core/token.wast

diff --git a/interpreter/Makefile b/interpreter/Makefile
index e92c9e5a3..a50117f4a 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -10,8 +10,8 @@
 # Configuration
 
 NAME =		wasm
-UNOPT = 	$(NAME)
-OPT =   	$(NAME).opt
+UNOPT = 	$(NAME).debug
+OPT =   	$(NAME)
 LIB =		$(NAME)
 ZIP =		$(NAME).zip
 JSLIB =		wast.js
diff --git a/interpreter/host/js.ml b/interpreter/host/js.ml
index 4db32b7ad..64b949125 100644
--- a/interpreter/host/js.ml
+++ b/interpreter/host/js.ml
@@ -310,12 +310,13 @@ let of_literal lit =
   | Values.F32 z -> of_float (F32.to_float z)
   | Values.F64 z -> of_float (F64.to_float z)
 
-let of_definition def =
-  let bs =
-    match def.it with
-    | Textual m -> Encode.encode m
-    | Encoded (_, bs) -> bs
-  in of_bytes bs
+let rec of_definition def =
+  match def.it with
+  | Textual m -> of_bytes (Encode.encode m)
+  | Encoded (_, bs) -> of_bytes bs
+  | Quoted (_, s) ->
+    try of_definition (Parse.string_to_module s) with Parse.Syntax _ ->
+      of_bytes "<malformed quote>"
 
 let of_wrapper mods x_opt name wrap_action wrap_assertion at =
   let x = of_var_opt mods x_opt in
@@ -382,11 +383,12 @@ let of_command mods cmd =
     ":" ^ string_of_int cmd.at.left.line ^ "\n" ^
   match cmd.it with
   | Module (x_opt, def) ->
-    let m =
+    let rec unquote def =
       match def.it with
       | Textual m -> m
       | Encoded (_, bs) -> Decode.decode "binary" bs
-    in bind mods x_opt m;
+      | Quoted (_, s) -> unquote (Parse.string_to_module s)
+    in bind mods x_opt (unquote def);
     "let " ^ current_var mods ^ " = instance(" ^ of_definition def ^ ");\n" ^
     (if x_opt = None then "" else
     "let " ^ of_var_opt mods x_opt ^ " = " ^ current_var mods ^ ";\n")
diff --git a/interpreter/host/run.ml b/interpreter/host/run.ml
index 6e7faa03b..2fb022d1e 100644
--- a/interpreter/host/run.ml
+++ b/interpreter/host/run.ml
@@ -281,12 +281,16 @@ let lookup_registry module_name item_name _t =
 
 (* Running *)
 
-let run_definition def =
+let rec run_definition def =
   match def.it with
   | Textual m -> m
   | Encoded (name, bs) ->
     trace "Decoding...";
     Decode.decode name bs
+  | Quoted (_, s) ->
+    trace "Parsing quote...";
+    let def' = Parse.string_to_module s in
+    run_definition def'
 
 let run_action act =
   match act.it with
@@ -332,7 +336,8 @@ let run_assertion ass =
     trace "Asserting malformed...";
     (match ignore (run_definition def) with
     | exception Decode.Code (_, msg) -> assert_message ass.at "decoding" msg re
-    | _ -> Assert.error ass.at "expected decoding error"
+    | exception Parse.Syntax (_, msg) -> assert_message ass.at "parsing" msg re
+    | _ -> Assert.error ass.at "expected decoding/parsing error"
     )
 
   | AssertInvalid (def, re) ->
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index b23c41420..4cec63df3 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -12,18 +12,17 @@ let nat n = I32.to_string_u (I32.of_int_u n)
 let nat32 = I32.to_string_u
 
 let add_hex_char buf c = Printf.bprintf buf "\\%02x" (Char.code c)
-let add_char buf c =
-  if c < '\x20' || c >= '\x7f' then
-    add_hex_char buf c
-  else begin
-    if c = '\"' || c = '\\' then Buffer.add_char buf '\\';
-    Buffer.add_char buf c
-  end
-let add_unicode_char buf uc =
-  if uc < 0x20 || uc >= 0x7f then
-    Printf.bprintf buf "\\u{%02x}" uc
-  else
-    add_char buf (Char.chr uc)
+let add_char buf = function
+  | '\n' -> Buffer.add_string buf "\\n"
+  | '\t' -> Buffer.add_string buf "\\t"
+  | '\"' -> Buffer.add_string buf "\\\""
+  | '\\' -> Buffer.add_string buf "\\\\"
+  | c when '\x20' <= c && c < '\x7f' -> Buffer.add_char buf c
+  | c -> add_hex_char buf c
+let add_unicode_char buf = function
+  | (0x09 | 0x0a) as uc -> add_char buf (Char.chr uc)
+  | uc when 0x20 <= uc && uc < 0x7f -> add_char buf (Char.chr uc)
+  | uc -> Printf.bprintf buf "\\u{%02x}" uc
 
 let string_with iter add_char s =
   let buf = Buffer.create 256 in
@@ -49,6 +48,10 @@ let break_bytes s =
   let ss = Lib.String.breakup s 16 in
   list (atom bytes) ss
 
+let break_string s =
+  let ss, s' = Lib.List.split_last (Lib.String.split s '\n') in
+  list (atom string) (List.map (fun s -> s ^ "\n") ss @ [s'])
+
 
 (* Types *)
 
@@ -369,7 +372,10 @@ let module_with_var_opt x_opt m =
   )
 
 let binary_module_with_var_opt x_opt bs =
-  Node ("module" ^ var_opt x_opt, break_bytes bs)
+  Node ("module" ^ var_opt x_opt ^ " binary", break_bytes bs)
+
+let quoted_module_with_var_opt x_opt s =
+  Node ("module" ^ var_opt x_opt ^ " quote", break_string s)
 
 let module_ = module_with_var_opt None
 
@@ -384,19 +390,26 @@ let literal lit =
   | Values.F64 z -> Node ("f64.const " ^ F64.to_string z, [])
 
 let definition mode x_opt def =
-  match mode, def.it with
-  | `Textual, _ | `Original, Textual _ ->
-    let m =
-      match def.it with
-      | Textual m -> m
-      | Encoded (_, bs) -> Decode.decode "" bs
-    in module_with_var_opt x_opt m
-  | `Binary, _ | `Original, Encoded _ ->
-    let bs =
-      match def.it with
-      | Textual m -> Encode.encode m
-      | Encoded (_, bs) -> bs
-    in binary_module_with_var_opt x_opt bs
+  try
+    match mode, def.it with
+    | `Textual, _ | `Original, Textual _ ->
+      let rec unquote def =
+        match def.it with
+        | Textual m -> m
+        | Encoded (_, bs) -> Decode.decode "" bs
+        | Quoted (_, s) -> unquote (Parse.string_to_module s)
+      in module_with_var_opt x_opt (unquote def)
+    | `Binary, _ | `Original, Encoded _ ->
+      let rec unquote bs =
+        match def.it with
+        | Textual m -> Encode.encode m
+        | Encoded (_, bs) -> bs
+        | Quoted (_, s) -> unquote (Parse.string_to_module s)
+      in binary_module_with_var_opt x_opt (unquote def)
+    | `Original, Quoted (_, s) ->
+      quoted_module_with_var_opt x_opt s
+  with Parse.Syntax _ ->
+    quoted_module_with_var_opt x_opt "<invalid module>"
 
 let access x_opt n =
   String.concat " " [var_opt x_opt; name n]
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index 47584f4f9..3bb532d51 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -322,7 +322,6 @@ rule token = parse
   | "result" { RESULT }
   | "local" { LOCAL }
   | "global" { GLOBAL }
-  | "module" { MODULE }
   | "table" { TABLE }
   | "memory" { MEMORY }
   | "elem" { ELEM }
@@ -331,6 +330,10 @@ rule token = parse
   | "import" { IMPORT }
   | "export" { EXPORT }
 
+  | "module" { MODULE }
+  | "binary" { BIN }
+  | "quote" { QUOTE }
+
   | "script" { SCRIPT }
   | "register" { REGISTER }
   | "invoke" { INVOKE }
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 417ff8298..b92a5e2ad 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -160,10 +160,11 @@ let inline_type_explicit (c : context) x ty at =
 %token CALL CALL_INDIRECT RETURN
 %token GET_LOCAL SET_LOCAL TEE_LOCAL GET_GLOBAL SET_GLOBAL
 %token LOAD STORE OFFSET_EQ_NAT ALIGN_EQ_NAT
-%token CONST UNARY BINARY COMPARE CONVERT
+%token CONST UNARY BINARY TEST COMPARE CONVERT
 %token UNREACHABLE CURRENT_MEMORY GROW_MEMORY
 %token FUNC START TYPE PARAM RESULT LOCAL GLOBAL
-%token MODULE TABLE ELEM MEMORY DATA OFFSET IMPORT EXPORT TABLE
+%token TABLE ELEM MEMORY DATA OFFSET IMPORT EXPORT TABLE
+%token MODULE BIN QUOTE
 %token SCRIPT REGISTER INVOKE GET
 %token ASSERT_MALFORMED ASSERT_INVALID ASSERT_SOFT_INVALID ASSERT_UNLINKABLE
 %token ASSERT_RETURN ASSERT_RETURN_CANONICAL_NAN ASSERT_RETURN_ARITHMETIC_NAN ASSERT_TRAP ASSERT_EXHAUSTION
@@ -655,11 +656,13 @@ module_fields1 :
     { fun c -> let m = $2 c in
       {m with exports = $1 c :: m.exports} }
 
+module_var_opt :
+  | /* empty */ { None }
+  | VAR { Some ($1 @@ at ()) }  /* Sugar */
+
 module_ :
-  | LPAR MODULE script_var_opt module_fields RPAR
+  | LPAR MODULE module_var_opt module_fields RPAR
     { $3, Textual ($4 (empty_context ()) @@ at ()) @@ at () }
-  | LPAR MODULE script_var_opt STRING string_list RPAR
-    { $3, Encoded ("binary", $4 ^ $5) @@ at() }
 
 inline_module :  /* Sugar */
   | module_fields { Textual ($1 (empty_context ()) @@ at ()) @@ at () }
@@ -674,20 +677,27 @@ script_var_opt :
   | /* empty */ { None }
   | VAR { Some ($1 @@ at ()) }  /* Sugar */
 
+script_module :
+  | module_ { $1 }
+  | LPAR MODULE module_var_opt BIN string_list RPAR
+    { $3, Encoded ("binary", $5) @@ at() }
+  | LPAR MODULE module_var_opt QUOTE string_list RPAR
+    { $3, Quoted ("quote", $5) @@ at() }
+
 action :
-  | LPAR INVOKE script_var_opt name const_list RPAR
+  | LPAR INVOKE module_var_opt name const_list RPAR
     { Invoke ($3, $4, $5) @@ at () }
-  | LPAR GET script_var_opt name RPAR
+  | LPAR GET module_var_opt name RPAR
     { Get ($3, $4) @@ at() }
 
 assertion :
-  | LPAR ASSERT_MALFORMED module_ STRING RPAR
+  | LPAR ASSERT_MALFORMED script_module STRING RPAR
     { AssertMalformed (snd $3, $4) @@ at () }
-  | LPAR ASSERT_INVALID module_ STRING RPAR
+  | LPAR ASSERT_INVALID script_module STRING RPAR
     { AssertInvalid (snd $3, $4) @@ at () }
-  | LPAR ASSERT_UNLINKABLE module_ STRING RPAR
+  | LPAR ASSERT_UNLINKABLE script_module STRING RPAR
     { AssertUnlinkable (snd $3, $4) @@ at () }
-  | LPAR ASSERT_TRAP module_ STRING RPAR
+  | LPAR ASSERT_TRAP script_module STRING RPAR
     { AssertUninstantiable (snd $3, $4) @@ at () }
   | LPAR ASSERT_RETURN action const_list RPAR { AssertReturn ($3, $4) @@ at () }
   | LPAR ASSERT_RETURN_CANONICAL_NAN action RPAR { AssertReturnCanonicalNaN $3 @@ at () }
@@ -698,8 +708,8 @@ assertion :
 cmd :
   | action { Action $1 @@ at () }
   | assertion { Assertion $1 @@ at () }
-  | module_ { Module (fst $1, snd $1) @@ at () }
-  | LPAR REGISTER name script_var_opt RPAR { Register ($3, $4) @@ at () }
+  | script_module { Module (fst $1, snd $1) @@ at () }
+  | LPAR REGISTER name module_var_opt RPAR { Register ($3, $4) @@ at () }
   | meta { Meta $1 @@ at () }
 
 cmd_list :
diff --git a/interpreter/text/script.ml b/interpreter/text/script.ml
index 11032f1f6..ca8302540 100644
--- a/interpreter/text/script.ml
+++ b/interpreter/text/script.ml
@@ -4,6 +4,7 @@ type definition = definition' Source.phrase
 and definition' =
   | Textual of Ast.module_
   | Encoded of string * string
+  | Quoted of string * string
 
 type action = action' Source.phrase
 and action' =
diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index 818e025ed..53afb4e36 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -28,6 +28,14 @@ struct
     for i = String.length s - 1 downto 0 do cs := s.[i] :: !cs done;
     !cs
 
+  let split s c =
+    let len = String.length s in
+    let rec loop i =
+      if i > len then [] else
+      let j = try String.index_from s i c with Not_found -> len in
+      String.sub s i (j - i) :: loop (j + 1)
+    in loop 0
+
   let breakup s n =
     let rec loop i =
       let len = min n (String.length s - i) in
diff --git a/interpreter/util/lib.mli b/interpreter/util/lib.mli
index 5704e067c..7f21733b2 100644
--- a/interpreter/util/lib.mli
+++ b/interpreter/util/lib.mli
@@ -66,5 +66,6 @@ module String :
 sig
   val implode : char list -> string
   val explode : string -> char list
+  val split : string -> char -> string list
   val breakup : string -> int -> string list
 end
diff --git a/test/core/address-offset-range.fail.wast b/test/core/address-offset-range.fail.wast
deleted file mode 100644
index 127327a26..000000000
--- a/test/core/address-offset-range.fail.wast
+++ /dev/null
@@ -1,4 +0,0 @@
-(module
-  (memory 1)
-  (func $bad (drop (i32.load offset=4294967296 (i32.const 0))))
-)
diff --git a/test/core/address.wast b/test/core/address.wast
index 4f8e34982..47bd21bad 100644
--- a/test/core/address.wast
+++ b/test/core/address.wast
@@ -32,3 +32,11 @@
 (assert_trap (invoke "good" (i32.const 65508)) "out of bounds memory access")
 (assert_trap (invoke "bad" (i32.const 0)) "out of bounds memory access")
 (assert_trap (invoke "bad" (i32.const 1)) "out of bounds memory access")
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (drop (i32.load offset=4294967296 (i32.const 0))))"
+  )
+  "i32 constant"
+)
diff --git a/test/core/align.wast b/test/core/align.wast
new file mode 100644
index 000000000..133b501d7
--- /dev/null
+++ b/test/core/align.wast
@@ -0,0 +1,33 @@
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load align=16 (i32.const 0)))))
+  "alignment"
+)
+
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store align=0 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store align=5 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.store align=16 (i32.const 0) (i64.const 0))))
+  "alignment"
+)
diff --git a/test/core/binary.wast b/test/core/binary.wast
index 8b1d59ec1..3e971a203 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -1,44 +1,44 @@
-(module "\00asm\01\00\00\00")
-(module "\00asm" "\01\00\00\00")
-(module $M1 "\00asm\01\00\00\00")
-(module $M2 "\00asm" "\01\00\00\00")
+(module binary "\00asm\01\00\00\00")
+(module binary "\00asm" "\01\00\00\00")
+(module $M1 binary "\00asm\01\00\00\00")
+(module $M2 binary "\00asm" "\01\00\00\00")
 
-(assert_malformed (module "") "unexpected end")
-(assert_malformed (module "\01") "unexpected end")
-(assert_malformed (module "\00as") "unexpected end")
-(assert_malformed (module "asm\00") "magic header not detected")
-(assert_malformed (module "msa\00") "magic header not detected")
-(assert_malformed (module "msa\00\01\00\00\00") "magic header not detected")
-(assert_malformed (module "msa\00\00\00\00\01") "magic header not detected")
-(assert_malformed (module "asm\01\00\00\00\00") "magic header not detected")
-(assert_malformed (module "wasm\01\00\00\00") "magic header not detected")
-(assert_malformed (module "\7fasm\01\00\00\00") "magic header not detected")
-(assert_malformed (module "\80asm\01\00\00\00") "magic header not detected")
-(assert_malformed (module "\82asm\01\00\00\00") "magic header not detected")
-(assert_malformed (module "\ffasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "") "unexpected end")
+(assert_malformed (module binary "\01") "unexpected end")
+(assert_malformed (module binary "\00as") "unexpected end")
+(assert_malformed (module binary "asm\00") "magic header not detected")
+(assert_malformed (module binary "msa\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "msa\00\00\00\00\01") "magic header not detected")
+(assert_malformed (module binary "asm\01\00\00\00\00") "magic header not detected")
+(assert_malformed (module binary "wasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\7fasm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\80asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\82asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\ffasm\01\00\00\00") "magic header not detected")
 
 ;; 8-byte endian-reversed.
-(assert_malformed (module "\00\00\00\01msa\00") "magic header not detected")
+(assert_malformed (module binary "\00\00\00\01msa\00") "magic header not detected")
 
 ;; Middle-endian byte orderings.
-(assert_malformed (module "a\00ms\00\01\00\00") "magic header not detected")
-(assert_malformed (module "sm\00a\00\00\01\00") "magic header not detected")
+(assert_malformed (module binary "a\00ms\00\01\00\00") "magic header not detected")
+(assert_malformed (module binary "sm\00a\00\00\01\00") "magic header not detected")
 
 ;; Upper-cased.
-(assert_malformed (module "\00ASM\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\00ASM\01\00\00\00") "magic header not detected")
 
 ;; EBCDIC-encoded magic.
-(assert_malformed (module "\00\81\a2\94\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\00\81\a2\94\01\00\00\00") "magic header not detected")
 
 ;; Leading UTF-8 BOM.
-(assert_malformed (module "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected")
+(assert_malformed (module binary "\ef\bb\bf\00asm\01\00\00\00") "magic header not detected")
 
-(assert_malformed (module "\00asm") "unexpected end")
-(assert_malformed (module "\00asm\01") "unexpected end")
-(assert_malformed (module "\00asm\01\00\00") "unexpected end")
-(assert_malformed (module "\00asm\00\00\00\00") "unknown binary version")
-(assert_malformed (module "\00asm\0d\00\00\00") "unknown binary version")
-(assert_malformed (module "\00asm\0e\00\00\00") "unknown binary version")
-(assert_malformed (module "\00asm\00\01\00\00") "unknown binary version")
-(assert_malformed (module "\00asm\00\00\01\00") "unknown binary version")
-(assert_malformed (module "\00asm\00\00\00\01") "unknown binary version")
+(assert_malformed (module binary "\00asm") "unexpected end")
+(assert_malformed (module binary "\00asm\01") "unexpected end")
+(assert_malformed (module binary "\00asm\01\00\00") "unexpected end")
+(assert_malformed (module binary "\00asm\00\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0d\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\0e\00\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version")
+(assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version")
diff --git a/test/core/block-end-label-mismatch.fail.wast b/test/core/block-end-label-mismatch.fail.wast
deleted file mode 100644
index 8eeaaff91..000000000
--- a/test/core/block-end-label-mismatch.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func block $a end $l))
diff --git a/test/core/block-end-label-superfluous.fail.wast b/test/core/block-end-label-superfluous.fail.wast
deleted file mode 100644
index f33b8f59f..000000000
--- a/test/core/block-end-label-superfluous.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func block end $l))
diff --git a/test/core/block.wast b/test/core/block.wast
index 7d51859ca..f2b6384c3 100644
--- a/test/core/block.wast
+++ b/test/core/block.wast
@@ -287,3 +287,13 @@
   ))
   "type mismatch"
 )
+
+
+(assert_malformed
+  (module quote "(func block end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func block $a end $l)")
+  "mismatching label"
+)
diff --git a/test/core/const.wast b/test/core/const.wast
new file mode 100644
index 000000000..9eb591a45
--- /dev/null
+++ b/test/core/const.wast
@@ -0,0 +1,47 @@
+;; Test t.const instructions
+
+;; Syntax error
+
+(module (func (i32.const 0xffffffff) drop))
+(module (func (i32.const -0x80000000) drop))
+(assert_malformed
+  (module quote "(func (i32.const 0x100000000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (i32.const -0x80000001) drop)")
+  "constant out of range"
+)
+
+(module (func (i32.const 4294967295) drop))
+(module (func (i32.const -2147483648) drop))
+(assert_malformed
+  (module quote "(func (i32.const 4294967296) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (i32.const -2147483649) drop)")
+  "constant out of range"
+)
+
+(module (func (i64.const 0xffffffffffffffff) drop))
+(module (func (i64.const -0x8000000000000000) drop))
+(assert_malformed
+  (module quote "(func (i64.const 0x10000000000000000) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (i64.const -0x8000000000000001) drop)")
+  "constant out of range"
+)
+
+(module (func (i64.const 18446744073709551615) drop))
+(module (func (i64.const -9223372036854775808) drop))
+(assert_malformed
+  (module quote "(func (i64.const 18446744073709551616) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (i64.const -9223372036854775809) drop)")
+  "constant out of range"
+)
diff --git a/test/core/custom_section.wast b/test/core/custom_section.wast
index 551ed97bf..c6c338905 100644
--- a/test/core/custom_section.wast
+++ b/test/core/custom_section.wast
@@ -1,4 +1,4 @@
-(module
+(module binary
   "\00asm" "\01\00\00\00"
   "\00\24\10" "a custom section" "this is the payload"
   "\00\20\10" "a custom section" "this is payload"
@@ -11,7 +11,7 @@
   "\00\1f\16" "module within a module" "\00asm" "\01\00\00\00"
 )
 
-(module
+(module binary
   "\00asm" "\01\00\00\00"
   "\00\0e\06" "custom" "payload"
   "\00\0e\06" "custom" "payload"
@@ -47,7 +47,7 @@
   "\00\0e\06" "custom" "payload"
 )
 
-(module
+(module binary
   "\00asm" "\01\00\00\00"
   "\01\07\01\60\02\7f\7f\01\7f"                ;; type section
   "\00\1a\06" "custom" "this is the payload"   ;; custom section
@@ -58,7 +58,7 @@
 )
 
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00"
   )
@@ -66,7 +66,7 @@
 )
 
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\00"
   )
@@ -74,7 +74,7 @@
 )
 
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\26\10" "a custom section" "this is the payload"
   )
@@ -82,7 +82,7 @@
 )
 
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\25\10" "a custom section" "this is the payload"
     "\00\24\10" "a custom section" "this is the payload"
@@ -91,7 +91,7 @@
 )
 
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\01\07\01\60\02\7f\7f\01\7f"                         ;; type section
     "\00\25\10" "a custom section" "this is the payload"  ;; invalid length!
@@ -104,7 +104,7 @@
 
 ;; Test concatenated modules.
 (assert_malformed
-  (module
+  (module binary
     "\00asm\01\00\00\00"
     "\00asm\01\00\00\00"
   )
diff --git a/test/core/f32.load32.fail.wast b/test/core/f32.load32.fail.wast
deleted file mode 100644
index 313364538..000000000
--- a/test/core/f32.load32.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (result f32) (f32.load32 (get_local 0))))
diff --git a/test/core/f32.load64.fail.wast b/test/core/f32.load64.fail.wast
deleted file mode 100644
index da94668fc..000000000
--- a/test/core/f32.load64.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (result f32) (f32.load64 (get_local 0))))
diff --git a/test/core/f32.store32.fail.wast b/test/core/f32.store32.fail.wast
deleted file mode 100644
index 3daf6eb35..000000000
--- a/test/core/f32.store32.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (param f32) (f32.store32 (get_local 0) (get_local 1))))
diff --git a/test/core/f32.store64.fail.wast b/test/core/f32.store64.fail.wast
deleted file mode 100644
index b2c47bb9b..000000000
--- a/test/core/f32.store64.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (param f64) (f32.store64 (get_local 0) (get_local 1))))
diff --git a/test/core/f64.load32.fail.wast b/test/core/f64.load32.fail.wast
deleted file mode 100644
index 38811ff35..000000000
--- a/test/core/f64.load32.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (result f64) (f64.load32 (get_local 0))))
diff --git a/test/core/f64.load64.fail.wast b/test/core/f64.load64.fail.wast
deleted file mode 100644
index f3c30ef34..000000000
--- a/test/core/f64.load64.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (result f64) (f64.load64 (get_local 0))))
diff --git a/test/core/f64.store32.fail.wast b/test/core/f64.store32.fail.wast
deleted file mode 100644
index 92858a35e..000000000
--- a/test/core/f64.store32.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (param f32) (f64.store32 (get_local 0) (get_local 1))))
diff --git a/test/core/f64.store64.fail.wast b/test/core/f64.store64.fail.wast
deleted file mode 100644
index 2b49017fe..000000000
--- a/test/core/f64.store64.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (param f64) (f64.store64 (get_local 0) (get_local 1))))
diff --git a/test/core/func-local-after-body.fail.wast b/test/core/func-local-after-body.fail.wast
deleted file mode 100644
index 0c4cf8c3f..000000000
--- a/test/core/func-local-after-body.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (nop) (local i32)))
diff --git a/test/core/func-local-before-param.fail.wast b/test/core/func-local-before-param.fail.wast
deleted file mode 100644
index 66f35eb6c..000000000
--- a/test/core/func-local-before-param.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (local i32) (param i32)))
diff --git a/test/core/func-local-before-result.fail.wast b/test/core/func-local-before-result.fail.wast
deleted file mode 100644
index 52026cf76..000000000
--- a/test/core/func-local-before-result.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (local i32) (result i32) (get_local 0)))
diff --git a/test/core/func-param-after-body.fail.wast b/test/core/func-param-after-body.fail.wast
deleted file mode 100644
index 399a151b8..000000000
--- a/test/core/func-param-after-body.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (nop) (param i32)))
diff --git a/test/core/func-result-after-body.fail.wast b/test/core/func-result-after-body.fail.wast
deleted file mode 100644
index 9617a2d00..000000000
--- a/test/core/func-result-after-body.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (nop) (result i32)))
diff --git a/test/core/func-result-before-param.fail.wast b/test/core/func-result-before-param.fail.wast
deleted file mode 100644
index 93a930f42..000000000
--- a/test/core/func-result-before-param.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (result i32) (param i32) (get_local 0)))
diff --git a/test/core/func.wast b/test/core/func.wast
index 219095bef..41c2e65ba 100644
--- a/test/core/func.wast
+++ b/test/core/func.wast
@@ -488,3 +488,30 @@
   "type mismatch"
 )
 
+
+;; Syntax errors
+
+(assert_malformed
+  (module quote "(func (nop) (local i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (nop) (param i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (nop) (result i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (local i32) (param i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (local i32) (result i32) (get_local 0))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(func (result i32) (param i32) (get_local 0))")
+  "unexpected token"
+)
diff --git a/test/core/globals.wast b/test/core/globals.wast
index 9eb594057..b8f9c8f54 100644
--- a/test/core/globals.wast
+++ b/test/core/globals.wast
@@ -125,7 +125,7 @@
   (import "spectest" "global" (global i32))
 )
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\94\80\80\80\00"             ;; import section
       "\01"                          ;; length 1
@@ -138,7 +138,7 @@
   "invalid mutability"
 )
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\94\80\80\80\00"             ;; import section
       "\01"                          ;; length 1
@@ -155,7 +155,7 @@
   (global i32 (i32.const 0))
 )
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\06\86\80\80\80\00"  ;; global section
       "\01"               ;; length 1
@@ -167,7 +167,7 @@
   "invalid mutability"
 )
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\06\86\80\80\80\00"  ;; global section
       "\01"               ;; length 1
diff --git a/test/core/i32.load32_s.fail.wast b/test/core/i32.load32_s.fail.wast
deleted file mode 100644
index abf38966a..000000000
--- a/test/core/i32.load32_s.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (result i32) (i32.load32_s (get_local 0))))
diff --git a/test/core/i32.load32_u.fail.wast b/test/core/i32.load32_u.fail.wast
deleted file mode 100644
index 26df00312..000000000
--- a/test/core/i32.load32_u.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (result i32) (i32.load32_u (get_local 0))))
diff --git a/test/core/i32.load64_s.fail.wast b/test/core/i32.load64_s.fail.wast
deleted file mode 100644
index 78fa01279..000000000
--- a/test/core/i32.load64_s.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (result i32) (i32.load64_s (get_local 0))))
diff --git a/test/core/i32.load64_u.fail.wast b/test/core/i32.load64_u.fail.wast
deleted file mode 100644
index 01e8273e6..000000000
--- a/test/core/i32.load64_u.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (result i32) (i32.load64_u (get_local 0))))
diff --git a/test/core/i32.store32.fail.wast b/test/core/i32.store32.fail.wast
deleted file mode 100644
index 8a6c528d6..000000000
--- a/test/core/i32.store32.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (param i32) (i32.store32 (get_local 0) (get_local 1))))
diff --git a/test/core/i32.store64.fail.wast b/test/core/i32.store64.fail.wast
deleted file mode 100644
index cb176d23e..000000000
--- a/test/core/i32.store64.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (param i64) (i32.store64 (get_local 0) (get_local 1))))
diff --git a/test/core/i64.load64_s.fail.wast b/test/core/i64.load64_s.fail.wast
deleted file mode 100644
index 335bac35a..000000000
--- a/test/core/i64.load64_s.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (result i64) (i64.load64_s (get_local 0))))
diff --git a/test/core/i64.load64_u.fail.wast b/test/core/i64.load64_u.fail.wast
deleted file mode 100644
index b9002e2bf..000000000
--- a/test/core/i64.load64_u.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (result i64) (i64.load64_u (get_local 0))))
diff --git a/test/core/i64.store64.fail.wast b/test/core/i64.store64.fail.wast
deleted file mode 100644
index 918761f68..000000000
--- a/test/core/i64.store64.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 1) (func (param i32) (param i64) (i64.store64 (get_local 0) (get_local 1))))
diff --git a/test/core/if-else-end-label-mismatch.fail.wast b/test/core/if-else-end-label-mismatch.fail.wast
deleted file mode 100644
index 723f898f7..000000000
--- a/test/core/if-else-end-label-mismatch.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func if $a else $l end $l))
diff --git a/test/core/if-else-end-label-superfluous.fail.wast b/test/core/if-else-end-label-superfluous.fail.wast
deleted file mode 100644
index bcdb6f687..000000000
--- a/test/core/if-else-end-label-superfluous.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func if else $l end $l))
diff --git a/test/core/if-else-label-mismatch.fail.wast b/test/core/if-else-label-mismatch.fail.wast
deleted file mode 100644
index 6d9bfdba9..000000000
--- a/test/core/if-else-label-mismatch.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func if $a else $l end))
diff --git a/test/core/if-else-label-superfluous.fail.wast b/test/core/if-else-label-superfluous.fail.wast
deleted file mode 100644
index e67814685..000000000
--- a/test/core/if-else-label-superfluous.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func if else $l end))
diff --git a/test/core/if-end-label-mismatch.fail.wast b/test/core/if-end-label-mismatch.fail.wast
deleted file mode 100644
index 6598d452d..000000000
--- a/test/core/if-end-label-mismatch.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func if $a end $l))
diff --git a/test/core/if-end-label-superfluous.fail.wast b/test/core/if-end-label-superfluous.fail.wast
deleted file mode 100644
index c111352c0..000000000
--- a/test/core/if-end-label-superfluous.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func if end $l))
diff --git a/test/core/if.wast b/test/core/if.wast
index e80b38d43..07a9ee248 100644
--- a/test/core/if.wast
+++ b/test/core/if.wast
@@ -405,3 +405,45 @@
   ))
   "type mismatch"
 )
+
+
+(assert_malformed
+  (module quote "(func if end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func if $a end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func if else $l end)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func if $a else $l end)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func if else end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func if else $l end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func if else $l1 end $l2)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func if $a else end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func if $a else $a end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func if $a else $l end $l)")
+  "mismatching label"
+)
diff --git a/test/core/import-after-func.fail.wast b/test/core/import-after-func.fail.wast
deleted file mode 100644
index ece33a72c..000000000
--- a/test/core/import-after-func.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func) (import "" "" (memory 0)))
diff --git a/test/core/import-after-global.fail.wast b/test/core/import-after-global.fail.wast
deleted file mode 100644
index 348ef2703..000000000
--- a/test/core/import-after-global.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (global i64 (i64.const 0)) (import "" "" (table 0 anyfunc)))
diff --git a/test/core/import-after-memory.fail.wast b/test/core/import-after-memory.fail.wast
deleted file mode 100644
index fbe582a93..000000000
--- a/test/core/import-after-memory.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 0) (import "" "" (global i32)))
diff --git a/test/core/import-after-table.fail.wast b/test/core/import-after-table.fail.wast
deleted file mode 100644
index bcd747a99..000000000
--- a/test/core/import-after-table.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (table 0 anyfunc) (import "" "" (func)))
diff --git a/test/core/imports.wast b/test/core/imports.wast
index 029403bea..69ccd0b5d 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -477,3 +477,74 @@
 (assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
 (assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
 (assert_return (invoke "grow" (i32.const 0)) (i32.const 2))
+
+
+;; Syntax errors
+
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (func))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (global i64))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (table 0 anyfunc))")
+  "import after function"
+)
+(assert_malformed
+  (module quote "(func) (import \"\" \"\" (memory 0))")
+  "import after function"
+)
+
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (func))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (global f32))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 anyfunc))")
+  "import after global"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (memory 0))")
+  "import after global"
+)
+
+(assert_malformed
+  (module quote "(table 0 anyfunc) (import \"\" \"\" (func))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 anyfunc) (import \"\" \"\" (global i32))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 anyfunc) (import \"\" \"\" (table 0 anyfunc))")
+  "import after table"
+)
+(assert_malformed
+  (module quote "(table 0 anyfunc) (import \"\" \"\" (memory 0))")
+  "import after table"
+)
+
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (func))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (global i32))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (table 1 3 anyfunc))")
+  "import after memory"
+)
+(assert_malformed
+  (module quote "(memory 0) (import \"\" \"\" (memory 1 2))")
+  "import after memory"
+)
diff --git a/test/core/load-align-0.fail.wast b/test/core/load-align-0.fail.wast
deleted file mode 100644
index fb8ec030e..000000000
--- a/test/core/load-align-0.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 0) (func (drop (i64.load align=0 (i32.const 0)))))
diff --git a/test/core/load-align-big.fail.wast b/test/core/load-align-big.fail.wast
deleted file mode 100644
index ec5eedd28..000000000
--- a/test/core/load-align-big.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 0) (func (drop (i64.load align=16 (i32.const 0)))))
diff --git a/test/core/load-align-odd.fail.wast b/test/core/load-align-odd.fail.wast
deleted file mode 100644
index 2132836c8..000000000
--- a/test/core/load-align-odd.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 0) (func (drop (i64.load align=5 (i32.const 0)))))
diff --git a/test/core/loop-end-label-mismatch.fail.wast b/test/core/loop-end-label-mismatch.fail.wast
deleted file mode 100644
index 1ed0104c9..000000000
--- a/test/core/loop-end-label-mismatch.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func loop $a end $l))
diff --git a/test/core/loop-end-label-superfluous.fail.wast b/test/core/loop-end-label-superfluous.fail.wast
deleted file mode 100644
index 85a2ea6f1..000000000
--- a/test/core/loop-end-label-superfluous.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func loop end $l))
diff --git a/test/core/loop.wast b/test/core/loop.wast
index 348061cbf..d51b70361 100644
--- a/test/core/loop.wast
+++ b/test/core/loop.wast
@@ -297,3 +297,13 @@
   ))
   "type mismatch"
 )
+
+
+(assert_malformed
+  (module quote "(func loop end $l)")
+  "mismatching label"
+)
+(assert_malformed
+  (module quote "(func loop $a end $l)")
+  "mismatching label"
+)
diff --git a/test/core/memory.wast b/test/core/memory.wast
index cf2de6aba..346d8f8fb 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -385,3 +385,147 @@
 (assert_return (invoke "i64_load32_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffff98bacdef))
 (assert_return (invoke "i64_load32_u" (i64.const 0xfedcba9856346543)) (i64.const 0x56346543))
 (assert_return (invoke "i64_load32_u" (i64.const 0x3456436598bacdef)) (i64.const 0x98bacdef))
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load32 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load32_u (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load32_s (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load64 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load64_u (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load64_s (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (i32.store32 (get_local 0) (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (i32.store64 (get_local 0) (i64.const 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i64) (i64.load64 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i64) (i64.load64_u (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i64) (i64.load64_s (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (i64.store64 (get_local 0) (i64.const 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f32) (f32.load32 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f32) (f32.load64 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f32.store32 (get_local 0) (f32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f32.store64 (get_local 0) (f64.const 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f64) (f64.load32 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f64) (f64.load64 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f64.store32 (get_local 0) (f32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f64.store64 (get_local 0) (f64.const 0)))"
+  )
+  "unknown operator"
+)
diff --git a/test/core/of_string-overflow-hex-u32.fail.wast b/test/core/of_string-overflow-hex-u32.fail.wast
deleted file mode 100644
index 1323a1f0b..000000000
--- a/test/core/of_string-overflow-hex-u32.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (i32.const 0x100000000)))
diff --git a/test/core/of_string-overflow-hex-u64.fail.wast b/test/core/of_string-overflow-hex-u64.fail.wast
deleted file mode 100644
index d13d6e4b4..000000000
--- a/test/core/of_string-overflow-hex-u64.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (i64.const 0x10000000000000000)))
diff --git a/test/core/of_string-overflow-s32.fail.wast b/test/core/of_string-overflow-s32.fail.wast
deleted file mode 100644
index 4dda96027..000000000
--- a/test/core/of_string-overflow-s32.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (i32.const -2147483649)))
diff --git a/test/core/of_string-overflow-s64.fail.wast b/test/core/of_string-overflow-s64.fail.wast
deleted file mode 100644
index 1034b0b00..000000000
--- a/test/core/of_string-overflow-s64.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (i64.const -9223372036854775809)))
diff --git a/test/core/of_string-overflow-u32.fail.wast b/test/core/of_string-overflow-u32.fail.wast
deleted file mode 100644
index 8f226177b..000000000
--- a/test/core/of_string-overflow-u32.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (i32.const 4294967296)))
diff --git a/test/core/of_string-overflow-u64.fail.wast b/test/core/of_string-overflow-u64.fail.wast
deleted file mode 100644
index cfa2c46b5..000000000
--- a/test/core/of_string-overflow-u64.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (i64.const 18446744073709551616)))
diff --git a/test/core/store-align-0.fail.wast b/test/core/store-align-0.fail.wast
deleted file mode 100644
index 02d837a89..000000000
--- a/test/core/store-align-0.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 0) (func (i64.store align=0 (i32.const 0) (i64.const 0))))
diff --git a/test/core/store-align-big.fail.wast b/test/core/store-align-big.fail.wast
deleted file mode 100644
index 812cd9ca2..000000000
--- a/test/core/store-align-big.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 0) (func (i64.store align=16 (i32.const 0) (i64.const 0))))
diff --git a/test/core/store-align-odd.fail.wast b/test/core/store-align-odd.fail.wast
deleted file mode 100644
index 19201b404..000000000
--- a/test/core/store-align-odd.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (memory 0) (func (i64.store align=6 (i32.const 0) (i64.const 0))))
diff --git a/test/core/token-keyword-separation.fail.wast b/test/core/token-keyword-separation.fail.wast
deleted file mode 100644
index aa29b6d3e..000000000
--- a/test/core/token-keyword-separation.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func (drop (i32.const0))))
diff --git a/test/core/token-number-separation.fail.wast b/test/core/token-number-separation.fail.wast
deleted file mode 100644
index 68fb517ce..000000000
--- a/test/core/token-number-separation.fail.wast
+++ /dev/null
@@ -1 +0,0 @@
-(module (func br 0drop))
diff --git a/test/core/token.wast b/test/core/token.wast
new file mode 100644
index 000000000..1dcd32e7f
--- /dev/null
+++ b/test/core/token.wast
@@ -0,0 +1,10 @@
+;; Test tokenization
+
+(assert_malformed
+  (module quote "(func (drop (i32.const0)))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(func br 0drop)")
+  "unknown operator"
+)
diff --git a/test/core/utf8-custom-section-id.wast b/test/core/utf8-custom-section-id.wast
index 040c3ea37..129d2b913 100644
--- a/test/core/utf8-custom-section-id.wast
+++ b/test/core/utf8-custom-section-id.wast
@@ -4,7 +4,7 @@
 
 ;; encoding starts with (first) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\80"                       ;; "\80"
@@ -14,7 +14,7 @@
 
 ;; encoding starts with (0x8f) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\8f"                       ;; "\8f"
@@ -24,7 +24,7 @@
 
 ;; encoding starts with (0x90) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\90"                       ;; "\90"
@@ -34,7 +34,7 @@
 
 ;; encoding starts with (0x9f) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\9f"                       ;; "\9f"
@@ -44,7 +44,7 @@
 
 ;; encoding starts with (0xa0) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\a0"                       ;; "\a0"
@@ -54,7 +54,7 @@
 
 ;; encoding starts with (last) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\bf"                       ;; "\bf"
@@ -66,7 +66,7 @@
 
 ;; 2-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\c2\80\80"                 ;; "\c2\80\80"
@@ -76,7 +76,7 @@
 
 ;; 2-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\c2"                       ;; "\c2"
@@ -86,7 +86,7 @@
 
 ;; 2-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\c2\2e"                    ;; "\c2."
@@ -98,7 +98,7 @@
 
 ;; overlong encoding after 0xc0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\c0\80"                    ;; "\c0\80"
@@ -108,7 +108,7 @@
 
 ;; overlong encoding after 0xc0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\c0\bf"                    ;; "\c0\bf"
@@ -118,7 +118,7 @@
 
 ;; overlong encoding after 0xc1 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\c1\80"                    ;; "\c1\80"
@@ -128,7 +128,7 @@
 
 ;; overlong encoding after 0xc1 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\c1\bf"                    ;; "\c1\bf"
@@ -138,7 +138,7 @@
 
 ;; byte after (first) 2-byte prefix not a contination byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\c2\00"                    ;; "\c2\00"
@@ -148,7 +148,7 @@
 
 ;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\c2\7f"                    ;; "\c2\7f"
@@ -158,7 +158,7 @@
 
 ;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\c2\c0"                    ;; "\c2\c0"
@@ -168,7 +168,7 @@
 
 ;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\c2\fd"                    ;; "\c2\fd"
@@ -178,7 +178,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\df\00"                    ;; "\df\00"
@@ -188,7 +188,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\df\7f"                    ;; "\df\7f"
@@ -198,7 +198,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\df\c0"                    ;; "\df\c0"
@@ -208,7 +208,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\df\fd"                    ;; "\df\fd"
@@ -220,7 +220,7 @@
 
 ;; 3-byte sequence contains 4 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\e1\80\80\80"              ;; "\e1\80\80\80"
@@ -230,7 +230,7 @@
 
 ;; 3-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\e1\80"                    ;; "\e1\80"
@@ -240,7 +240,7 @@
 
 ;; 3-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e1\80\2e"                 ;; "\e1\80."
@@ -250,7 +250,7 @@
 
 ;; 3-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\e1"                       ;; "\e1"
@@ -260,7 +260,7 @@
 
 ;; 3-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\e1\2e"                    ;; "\e1."
@@ -272,7 +272,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\00\a0"                 ;; "\e0\00\a0"
@@ -282,7 +282,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\7f\a0"                 ;; "\e0\7f\a0"
@@ -292,7 +292,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\80\80"                 ;; "\e0\80\80"
@@ -302,7 +302,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\80\a0"                 ;; "\e0\80\a0"
@@ -312,7 +312,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\9f\a0"                 ;; "\e0\9f\a0"
@@ -322,7 +322,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\9f\bf"                 ;; "\e0\9f\bf"
@@ -332,7 +332,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\c0\a0"                 ;; "\e0\c0\a0"
@@ -342,7 +342,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\fd\a0"                 ;; "\e0\fd\a0"
@@ -352,7 +352,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e1\00\80"                 ;; "\e1\00\80"
@@ -362,7 +362,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e1\7f\80"                 ;; "\e1\7f\80"
@@ -372,7 +372,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e1\c0\80"                 ;; "\e1\c0\80"
@@ -382,7 +382,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e1\fd\80"                 ;; "\e1\fd\80"
@@ -392,7 +392,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ec\00\80"                 ;; "\ec\00\80"
@@ -402,7 +402,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ec\7f\80"                 ;; "\ec\7f\80"
@@ -412,7 +412,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ec\c0\80"                 ;; "\ec\c0\80"
@@ -422,7 +422,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ec\fd\80"                 ;; "\ec\fd\80"
@@ -432,7 +432,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\00\80"                 ;; "\ed\00\80"
@@ -442,7 +442,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\7f\80"                 ;; "\ed\7f\80"
@@ -452,7 +452,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\a0\80"                 ;; "\ed\a0\80"
@@ -462,7 +462,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\a0\bf"                 ;; "\ed\a0\bf"
@@ -472,7 +472,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\bf\80"                 ;; "\ed\bf\80"
@@ -482,7 +482,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\bf\bf"                 ;; "\ed\bf\bf"
@@ -492,7 +492,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\c0\80"                 ;; "\ed\c0\80"
@@ -502,7 +502,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\fd\80"                 ;; "\ed\fd\80"
@@ -512,7 +512,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ee\00\80"                 ;; "\ee\00\80"
@@ -522,7 +522,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ee\7f\80"                 ;; "\ee\7f\80"
@@ -532,7 +532,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ee\c0\80"                 ;; "\ee\c0\80"
@@ -542,7 +542,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ee\fd\80"                 ;; "\ee\fd\80"
@@ -552,7 +552,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ef\00\80"                 ;; "\ef\00\80"
@@ -562,7 +562,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ef\7f\80"                 ;; "\ef\7f\80"
@@ -572,7 +572,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ef\c0\80"                 ;; "\ef\c0\80"
@@ -582,7 +582,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ef\fd\80"                 ;; "\ef\fd\80"
@@ -594,7 +594,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\a0\00"                 ;; "\e0\a0\00"
@@ -604,7 +604,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\a0\7f"                 ;; "\e0\a0\7f"
@@ -614,7 +614,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\a0\c0"                 ;; "\e0\a0\c0"
@@ -624,7 +624,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e0\a0\fd"                 ;; "\e0\a0\fd"
@@ -634,7 +634,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e1\80\00"                 ;; "\e1\80\00"
@@ -644,7 +644,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e1\80\7f"                 ;; "\e1\80\7f"
@@ -654,7 +654,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e1\80\c0"                 ;; "\e1\80\c0"
@@ -664,7 +664,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\e1\80\fd"                 ;; "\e1\80\fd"
@@ -674,7 +674,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ec\80\00"                 ;; "\ec\80\00"
@@ -684,7 +684,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ec\80\7f"                 ;; "\ec\80\7f"
@@ -694,7 +694,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ec\80\c0"                 ;; "\ec\80\c0"
@@ -704,7 +704,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ec\80\fd"                 ;; "\ec\80\fd"
@@ -714,7 +714,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\80\00"                 ;; "\ed\80\00"
@@ -724,7 +724,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\80\7f"                 ;; "\ed\80\7f"
@@ -734,7 +734,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\80\c0"                 ;; "\ed\80\c0"
@@ -744,7 +744,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ed\80\fd"                 ;; "\ed\80\fd"
@@ -754,7 +754,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ee\80\00"                 ;; "\ee\80\00"
@@ -764,7 +764,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ee\80\7f"                 ;; "\ee\80\7f"
@@ -774,7 +774,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ee\80\c0"                 ;; "\ee\80\c0"
@@ -784,7 +784,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ee\80\fd"                 ;; "\ee\80\fd"
@@ -794,7 +794,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ef\80\00"                 ;; "\ef\80\00"
@@ -804,7 +804,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ef\80\7f"                 ;; "\ef\80\7f"
@@ -814,7 +814,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ef\80\c0"                 ;; "\ef\80\c0"
@@ -824,7 +824,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\ef\80\fd"                 ;; "\ef\80\fd"
@@ -836,7 +836,7 @@
 
 ;; 4-byte sequence contains 5 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\06"                       ;; custom section
     "\05\f1\80\80\80\80"           ;; "\f1\80\80\80\80"
@@ -846,7 +846,7 @@
 
 ;; 4-byte sequence contains 3 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\f1\80\80"                 ;; "\f1\80\80"
@@ -856,7 +856,7 @@
 
 ;; 4-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\80\80\23"              ;; "\f1\80\80#"
@@ -866,7 +866,7 @@
 
 ;; 4-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\f1\80"                    ;; "\f1\80"
@@ -876,7 +876,7 @@
 
 ;; 4-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\f1\80\23"                 ;; "\f1\80#"
@@ -886,7 +886,7 @@
 
 ;; 4-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\f1"                       ;; "\f1"
@@ -896,7 +896,7 @@
 
 ;; 4-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\f1\23"                    ;; "\f1#"
@@ -908,7 +908,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\00\90\90"              ;; "\f0\00\90\90"
@@ -918,7 +918,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\7f\90\90"              ;; "\f0\7f\90\90"
@@ -928,7 +928,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\80\80\80"              ;; "\f0\80\80\80"
@@ -938,7 +938,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\80\90\90"              ;; "\f0\80\90\90"
@@ -948,7 +948,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\8f\90\90"              ;; "\f0\8f\90\90"
@@ -958,7 +958,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\8f\bf\bf"              ;; "\f0\8f\bf\bf"
@@ -968,7 +968,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\c0\90\90"              ;; "\f0\c0\90\90"
@@ -978,7 +978,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\fd\90\90"              ;; "\f0\fd\90\90"
@@ -988,7 +988,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\00\80\80"              ;; "\f1\00\80\80"
@@ -998,7 +998,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\7f\80\80"              ;; "\f1\7f\80\80"
@@ -1008,7 +1008,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\c0\80\80"              ;; "\f1\c0\80\80"
@@ -1018,7 +1018,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\fd\80\80"              ;; "\f1\fd\80\80"
@@ -1028,7 +1028,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\00\80\80"              ;; "\f3\00\80\80"
@@ -1038,7 +1038,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\7f\80\80"              ;; "\f3\7f\80\80"
@@ -1048,7 +1048,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\c0\80\80"              ;; "\f3\c0\80\80"
@@ -1058,7 +1058,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\fd\80\80"              ;; "\f3\fd\80\80"
@@ -1068,7 +1068,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\00\80\80"              ;; "\f4\00\80\80"
@@ -1078,7 +1078,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\7f\80\80"              ;; "\f4\7f\80\80"
@@ -1088,7 +1088,7 @@
 
 ;; (first) invalid code point
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\90\80\80"              ;; "\f4\90\80\80"
@@ -1098,7 +1098,7 @@
 
 ;; invalid code point
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\bf\80\80"              ;; "\f4\bf\80\80"
@@ -1108,7 +1108,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\c0\80\80"              ;; "\f4\c0\80\80"
@@ -1118,7 +1118,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\fd\80\80"              ;; "\f4\fd\80\80"
@@ -1128,7 +1128,7 @@
 
 ;; (first) invalid 4-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f5\80\80\80"              ;; "\f5\80\80\80"
@@ -1138,7 +1138,7 @@
 
 ;; (last) invalid 4-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f7\80\80\80"              ;; "\f7\80\80\80"
@@ -1148,7 +1148,7 @@
 
 ;; (last) invalid 4-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f7\bf\bf\bf"              ;; "\f7\bf\bf\bf"
@@ -1160,7 +1160,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\90\00\90"              ;; "\f0\90\00\90"
@@ -1170,7 +1170,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\90\7f\90"              ;; "\f0\90\7f\90"
@@ -1180,7 +1180,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\90\c0\90"              ;; "\f0\90\c0\90"
@@ -1190,7 +1190,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\90\fd\90"              ;; "\f0\90\fd\90"
@@ -1200,7 +1200,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\80\00\80"              ;; "\f1\80\00\80"
@@ -1210,7 +1210,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\80\7f\80"              ;; "\f1\80\7f\80"
@@ -1220,7 +1220,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\80\c0\80"              ;; "\f1\80\c0\80"
@@ -1230,7 +1230,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\80\fd\80"              ;; "\f1\80\fd\80"
@@ -1240,7 +1240,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\80\00\80"              ;; "\f3\80\00\80"
@@ -1250,7 +1250,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\80\7f\80"              ;; "\f3\80\7f\80"
@@ -1260,7 +1260,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\80\c0\80"              ;; "\f3\80\c0\80"
@@ -1270,7 +1270,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\80\fd\80"              ;; "\f3\80\fd\80"
@@ -1280,7 +1280,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\80\00\80"              ;; "\f4\80\00\80"
@@ -1290,7 +1290,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\80\7f\80"              ;; "\f4\80\7f\80"
@@ -1300,7 +1300,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\80\c0\80"              ;; "\f4\80\c0\80"
@@ -1310,7 +1310,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\80\fd\80"              ;; "\f4\80\fd\80"
@@ -1322,7 +1322,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\90\90\00"              ;; "\f0\90\90\00"
@@ -1332,7 +1332,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\90\90\7f"              ;; "\f0\90\90\7f"
@@ -1342,7 +1342,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\90\90\c0"              ;; "\f0\90\90\c0"
@@ -1352,7 +1352,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f0\90\90\fd"              ;; "\f0\90\90\fd"
@@ -1362,7 +1362,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\80\80\00"              ;; "\f1\80\80\00"
@@ -1372,7 +1372,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\80\80\7f"              ;; "\f1\80\80\7f"
@@ -1382,7 +1382,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\80\80\c0"              ;; "\f1\80\80\c0"
@@ -1392,7 +1392,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f1\80\80\fd"              ;; "\f1\80\80\fd"
@@ -1402,7 +1402,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\80\80\00"              ;; "\f3\80\80\00"
@@ -1412,7 +1412,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\80\80\7f"              ;; "\f3\80\80\7f"
@@ -1422,7 +1422,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\80\80\c0"              ;; "\f3\80\80\c0"
@@ -1432,7 +1432,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f3\80\80\fd"              ;; "\f3\80\80\fd"
@@ -1442,7 +1442,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\80\80\00"              ;; "\f4\80\80\00"
@@ -1452,7 +1452,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\80\80\7f"              ;; "\f4\80\80\7f"
@@ -1462,7 +1462,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\80\80\c0"              ;; "\f4\80\80\c0"
@@ -1472,7 +1472,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f4\80\80\fd"              ;; "\f4\80\80\fd"
@@ -1484,7 +1484,7 @@
 
 ;; 5-byte sequence contains 6 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\07"                       ;; custom section
     "\06\f8\80\80\80\80\80"        ;; "\f8\80\80\80\80\80"
@@ -1494,7 +1494,7 @@
 
 ;; 5-byte sequence contains 4 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f8\80\80\80"              ;; "\f8\80\80\80"
@@ -1504,7 +1504,7 @@
 
 ;; 5-byte sequence contains 4 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\06"                       ;; custom section
     "\05\f8\80\80\80\23"           ;; "\f8\80\80\80#"
@@ -1514,7 +1514,7 @@
 
 ;; 5-byte sequence contains 3 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\f8\80\80"                 ;; "\f8\80\80"
@@ -1524,7 +1524,7 @@
 
 ;; 5-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\f8\80\80\23"              ;; "\f8\80\80#"
@@ -1534,7 +1534,7 @@
 
 ;; 5-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\f8\80"                    ;; "\f8\80"
@@ -1544,7 +1544,7 @@
 
 ;; 5-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\f8\80\23"                 ;; "\f8\80#"
@@ -1554,7 +1554,7 @@
 
 ;; 5-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\f8"                       ;; "\f8"
@@ -1564,7 +1564,7 @@
 
 ;; 5-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\f8\23"                    ;; "\f8#"
@@ -1576,7 +1576,7 @@
 
 ;; (first) invalid 5-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\06"                       ;; custom section
     "\05\f8\80\80\80\80"           ;; "\f8\80\80\80\80"
@@ -1586,7 +1586,7 @@
 
 ;; (last) invalid 5-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\06"                       ;; custom section
     "\05\fb\bf\bf\bf\bf"           ;; "\fb\bf\bf\bf\bf"
@@ -1598,7 +1598,7 @@
 
 ;; 6-byte sequence contains 7 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\08"                       ;; custom section
     "\07\fc\80\80\80\80\80\80"     ;; "\fc\80\80\80\80\80\80"
@@ -1608,7 +1608,7 @@
 
 ;; 6-byte sequence contains 5 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\06"                       ;; custom section
     "\05\fc\80\80\80\80"           ;; "\fc\80\80\80\80"
@@ -1618,7 +1618,7 @@
 
 ;; 6-byte sequence contains 5 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\07"                       ;; custom section
     "\06\fc\80\80\80\80\23"        ;; "\fc\80\80\80\80#"
@@ -1628,7 +1628,7 @@
 
 ;; 6-byte sequence contains 4 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\fc\80\80\80"              ;; "\fc\80\80\80"
@@ -1638,7 +1638,7 @@
 
 ;; 6-byte sequence contains 4 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\06"                       ;; custom section
     "\05\fc\80\80\80\23"           ;; "\fc\80\80\80#"
@@ -1648,7 +1648,7 @@
 
 ;; 6-byte sequence contains 3 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\fc\80\80"                 ;; "\fc\80\80"
@@ -1658,7 +1658,7 @@
 
 ;; 6-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\fc\80\80\23"              ;; "\fc\80\80#"
@@ -1668,7 +1668,7 @@
 
 ;; 6-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\fc\80"                    ;; "\fc\80"
@@ -1678,7 +1678,7 @@
 
 ;; 6-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\04"                       ;; custom section
     "\03\fc\80\23"                 ;; "\fc\80#"
@@ -1688,7 +1688,7 @@
 
 ;; 6-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\fc"                       ;; "\fc"
@@ -1698,7 +1698,7 @@
 
 ;; 6-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\fc\23"                    ;; "\fc#"
@@ -1710,7 +1710,7 @@
 
 ;; (first) invalid 6-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\07"                       ;; custom section
     "\06\fc\80\80\80\80\80"        ;; "\fc\80\80\80\80\80"
@@ -1720,7 +1720,7 @@
 
 ;; (last) invalid 6-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\07"                       ;; custom section
     "\06\fd\bf\bf\bf\bf\bf"        ;; "\fd\bf\bf\bf\bf\bf"
@@ -1732,7 +1732,7 @@
 
 ;; invalid byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\fe"                       ;; "\fe"
@@ -1742,7 +1742,7 @@
 
 ;; invalid byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\02"                       ;; custom section
     "\01\ff"                       ;; "\ff"
@@ -1752,7 +1752,7 @@
 
 ;; UTF-16BE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\fe\ff"                    ;; "\fe\ff"
@@ -1762,7 +1762,7 @@
 
 ;; UTF-32BE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\00\00\fe\ff"              ;; "\00\00\fe\ff"
@@ -1772,7 +1772,7 @@
 
 ;; UTF-16LE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\03"                       ;; custom section
     "\02\ff\fe"                    ;; "\ff\fe"
@@ -1782,7 +1782,7 @@
 
 ;; UTF-32LE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\00\05"                       ;; custom section
     "\04\ff\fe\00\00"              ;; "\ff\fe\00\00"
diff --git a/test/core/utf8-import-field.wast b/test/core/utf8-import-field.wast
index 256eb8a48..1ff2aa030 100644
--- a/test/core/utf8-import-field.wast
+++ b/test/core/utf8-import-field.wast
@@ -4,7 +4,7 @@
 
 ;; encoding starts with (first) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -19,7 +19,7 @@
 
 ;; encoding starts with (0x8f) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -34,7 +34,7 @@
 
 ;; encoding starts with (0x90) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -49,7 +49,7 @@
 
 ;; encoding starts with (0x9f) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -64,7 +64,7 @@
 
 ;; encoding starts with (0xa0) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -79,7 +79,7 @@
 
 ;; encoding starts with (last) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -96,7 +96,7 @@
 
 ;; 2-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -111,7 +111,7 @@
 
 ;; 2-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -126,7 +126,7 @@
 
 ;; 2-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -143,7 +143,7 @@
 
 ;; overlong encoding after 0xc0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -158,7 +158,7 @@
 
 ;; overlong encoding after 0xc0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -173,7 +173,7 @@
 
 ;; overlong encoding after 0xc1 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -188,7 +188,7 @@
 
 ;; overlong encoding after 0xc1 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -203,7 +203,7 @@
 
 ;; byte after (first) 2-byte prefix not a contination byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -218,7 +218,7 @@
 
 ;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -233,7 +233,7 @@
 
 ;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -248,7 +248,7 @@
 
 ;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -263,7 +263,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -278,7 +278,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -293,7 +293,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -308,7 +308,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -325,7 +325,7 @@
 
 ;; 3-byte sequence contains 4 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -340,7 +340,7 @@
 
 ;; 3-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -355,7 +355,7 @@
 
 ;; 3-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -370,7 +370,7 @@
 
 ;; 3-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -385,7 +385,7 @@
 
 ;; 3-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -402,7 +402,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -417,7 +417,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -432,7 +432,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -447,7 +447,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -462,7 +462,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -477,7 +477,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -492,7 +492,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -507,7 +507,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -522,7 +522,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -537,7 +537,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -552,7 +552,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -567,7 +567,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -582,7 +582,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -597,7 +597,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -612,7 +612,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -627,7 +627,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -642,7 +642,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -657,7 +657,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -672,7 +672,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -687,7 +687,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -702,7 +702,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -717,7 +717,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -732,7 +732,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -747,7 +747,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -762,7 +762,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -777,7 +777,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -792,7 +792,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -807,7 +807,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -822,7 +822,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -837,7 +837,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -852,7 +852,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -867,7 +867,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -884,7 +884,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -899,7 +899,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -914,7 +914,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -929,7 +929,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -944,7 +944,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -959,7 +959,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -974,7 +974,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -989,7 +989,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1004,7 +1004,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1019,7 +1019,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1034,7 +1034,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1049,7 +1049,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1064,7 +1064,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1079,7 +1079,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1094,7 +1094,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1109,7 +1109,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1124,7 +1124,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1139,7 +1139,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1154,7 +1154,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1169,7 +1169,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1184,7 +1184,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1199,7 +1199,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1214,7 +1214,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1229,7 +1229,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1246,7 +1246,7 @@
 
 ;; 4-byte sequence contains 5 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -1261,7 +1261,7 @@
 
 ;; 4-byte sequence contains 3 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1276,7 +1276,7 @@
 
 ;; 4-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1291,7 +1291,7 @@
 
 ;; 4-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -1306,7 +1306,7 @@
 
 ;; 4-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1321,7 +1321,7 @@
 
 ;; 4-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -1336,7 +1336,7 @@
 
 ;; 4-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -1353,7 +1353,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1368,7 +1368,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1383,7 +1383,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1398,7 +1398,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1413,7 +1413,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1428,7 +1428,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1443,7 +1443,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1458,7 +1458,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1473,7 +1473,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1488,7 +1488,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1503,7 +1503,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1518,7 +1518,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1533,7 +1533,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1548,7 +1548,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1563,7 +1563,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1578,7 +1578,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1593,7 +1593,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1608,7 +1608,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1623,7 +1623,7 @@
 
 ;; (first) invalid code point
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1638,7 +1638,7 @@
 
 ;; invalid code point
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1653,7 +1653,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1668,7 +1668,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1683,7 +1683,7 @@
 
 ;; (first) invalid 4-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1698,7 +1698,7 @@
 
 ;; (last) invalid 4-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1713,7 +1713,7 @@
 
 ;; (last) invalid 4-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1730,7 +1730,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1745,7 +1745,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1760,7 +1760,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1775,7 +1775,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1790,7 +1790,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1805,7 +1805,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1820,7 +1820,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1835,7 +1835,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1850,7 +1850,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1865,7 +1865,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1880,7 +1880,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1895,7 +1895,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1910,7 +1910,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1925,7 +1925,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1940,7 +1940,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1955,7 +1955,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1972,7 +1972,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1987,7 +1987,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2002,7 +2002,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2017,7 +2017,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2032,7 +2032,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2047,7 +2047,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2062,7 +2062,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2077,7 +2077,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2092,7 +2092,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2107,7 +2107,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2122,7 +2122,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2137,7 +2137,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2152,7 +2152,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2167,7 +2167,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2182,7 +2182,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2197,7 +2197,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2214,7 +2214,7 @@
 
 ;; 5-byte sequence contains 6 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\10"                       ;; import section
     "\01"                          ;; length 1
@@ -2229,7 +2229,7 @@
 
 ;; 5-byte sequence contains 4 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2244,7 +2244,7 @@
 
 ;; 5-byte sequence contains 4 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -2259,7 +2259,7 @@
 
 ;; 5-byte sequence contains 3 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -2274,7 +2274,7 @@
 
 ;; 5-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2289,7 +2289,7 @@
 
 ;; 5-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2304,7 +2304,7 @@
 
 ;; 5-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -2319,7 +2319,7 @@
 
 ;; 5-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -2334,7 +2334,7 @@
 
 ;; 5-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2351,7 +2351,7 @@
 
 ;; (first) invalid 5-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -2366,7 +2366,7 @@
 
 ;; (last) invalid 5-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -2383,7 +2383,7 @@
 
 ;; 6-byte sequence contains 7 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\11"                       ;; import section
     "\01"                          ;; length 1
@@ -2398,7 +2398,7 @@
 
 ;; 6-byte sequence contains 5 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -2413,7 +2413,7 @@
 
 ;; 6-byte sequence contains 5 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\10"                       ;; import section
     "\01"                          ;; length 1
@@ -2428,7 +2428,7 @@
 
 ;; 6-byte sequence contains 4 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2443,7 +2443,7 @@
 
 ;; 6-byte sequence contains 4 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -2458,7 +2458,7 @@
 
 ;; 6-byte sequence contains 3 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -2473,7 +2473,7 @@
 
 ;; 6-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2488,7 +2488,7 @@
 
 ;; 6-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2503,7 +2503,7 @@
 
 ;; 6-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -2518,7 +2518,7 @@
 
 ;; 6-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -2533,7 +2533,7 @@
 
 ;; 6-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2550,7 +2550,7 @@
 
 ;; (first) invalid 6-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\10"                       ;; import section
     "\01"                          ;; length 1
@@ -2565,7 +2565,7 @@
 
 ;; (last) invalid 6-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\10"                       ;; import section
     "\01"                          ;; length 1
@@ -2582,7 +2582,7 @@
 
 ;; invalid byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -2597,7 +2597,7 @@
 
 ;; invalid byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -2612,7 +2612,7 @@
 
 ;; UTF-16BE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2627,7 +2627,7 @@
 
 ;; UTF-32BE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2642,7 +2642,7 @@
 
 ;; UTF-16LE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2657,7 +2657,7 @@
 
 ;; UTF-32LE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
diff --git a/test/core/utf8-import-module.wast b/test/core/utf8-import-module.wast
index 900f6bfb8..ceabbeb7c 100644
--- a/test/core/utf8-import-module.wast
+++ b/test/core/utf8-import-module.wast
@@ -4,7 +4,7 @@
 
 ;; encoding starts with (first) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -19,7 +19,7 @@
 
 ;; encoding starts with (0x8f) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -34,7 +34,7 @@
 
 ;; encoding starts with (0x90) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -49,7 +49,7 @@
 
 ;; encoding starts with (0x9f) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -64,7 +64,7 @@
 
 ;; encoding starts with (0xa0) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -79,7 +79,7 @@
 
 ;; encoding starts with (last) continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -96,7 +96,7 @@
 
 ;; 2-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -111,7 +111,7 @@
 
 ;; 2-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -126,7 +126,7 @@
 
 ;; 2-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -143,7 +143,7 @@
 
 ;; overlong encoding after 0xc0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -158,7 +158,7 @@
 
 ;; overlong encoding after 0xc0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -173,7 +173,7 @@
 
 ;; overlong encoding after 0xc1 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -188,7 +188,7 @@
 
 ;; overlong encoding after 0xc1 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -203,7 +203,7 @@
 
 ;; byte after (first) 2-byte prefix not a contination byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -218,7 +218,7 @@
 
 ;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -233,7 +233,7 @@
 
 ;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -248,7 +248,7 @@
 
 ;; byte after (first) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -263,7 +263,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -278,7 +278,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -293,7 +293,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -308,7 +308,7 @@
 
 ;; byte after (last) 2-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -325,7 +325,7 @@
 
 ;; 3-byte sequence contains 4 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -340,7 +340,7 @@
 
 ;; 3-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -355,7 +355,7 @@
 
 ;; 3-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -370,7 +370,7 @@
 
 ;; 3-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -385,7 +385,7 @@
 
 ;; 3-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -402,7 +402,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -417,7 +417,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -432,7 +432,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -447,7 +447,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -462,7 +462,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -477,7 +477,7 @@
 
 ;; overlong encoding after 0xe0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -492,7 +492,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -507,7 +507,7 @@
 
 ;; first byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -522,7 +522,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -537,7 +537,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -552,7 +552,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -567,7 +567,7 @@
 
 ;; first byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -582,7 +582,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -597,7 +597,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -612,7 +612,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -627,7 +627,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -642,7 +642,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -657,7 +657,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -672,7 +672,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -687,7 +687,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -702,7 +702,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -717,7 +717,7 @@
 
 ;; byte sequence reserved for UTF-16 surrogate half
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -732,7 +732,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -747,7 +747,7 @@
 
 ;; first byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -762,7 +762,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -777,7 +777,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -792,7 +792,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -807,7 +807,7 @@
 
 ;; first byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -822,7 +822,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -837,7 +837,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -852,7 +852,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -867,7 +867,7 @@
 
 ;; first byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -884,7 +884,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -899,7 +899,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -914,7 +914,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -929,7 +929,7 @@
 
 ;; second byte after (0xe0) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -944,7 +944,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -959,7 +959,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -974,7 +974,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -989,7 +989,7 @@
 
 ;; second byte after (first normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1004,7 +1004,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1019,7 +1019,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1034,7 +1034,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1049,7 +1049,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1064,7 +1064,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1079,7 +1079,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1094,7 +1094,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1109,7 +1109,7 @@
 
 ;; second byte after (0xed) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1124,7 +1124,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1139,7 +1139,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1154,7 +1154,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1169,7 +1169,7 @@
 
 ;; second byte after (normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1184,7 +1184,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1199,7 +1199,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1214,7 +1214,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1229,7 +1229,7 @@
 
 ;; second byte after (last normal) 3-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1246,7 +1246,7 @@
 
 ;; 4-byte sequence contains 5 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -1261,7 +1261,7 @@
 
 ;; 4-byte sequence contains 3 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1276,7 +1276,7 @@
 
 ;; 4-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1291,7 +1291,7 @@
 
 ;; 4-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -1306,7 +1306,7 @@
 
 ;; 4-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -1321,7 +1321,7 @@
 
 ;; 4-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -1336,7 +1336,7 @@
 
 ;; 4-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -1353,7 +1353,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1368,7 +1368,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1383,7 +1383,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1398,7 +1398,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1413,7 +1413,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1428,7 +1428,7 @@
 
 ;; overlong encoding after 0xf0 prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1443,7 +1443,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1458,7 +1458,7 @@
 
 ;; first byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1473,7 +1473,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1488,7 +1488,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1503,7 +1503,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1518,7 +1518,7 @@
 
 ;; first byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1533,7 +1533,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1548,7 +1548,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1563,7 +1563,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1578,7 +1578,7 @@
 
 ;; first byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1593,7 +1593,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1608,7 +1608,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1623,7 +1623,7 @@
 
 ;; (first) invalid code point
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1638,7 +1638,7 @@
 
 ;; invalid code point
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1653,7 +1653,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1668,7 +1668,7 @@
 
 ;; first byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1683,7 +1683,7 @@
 
 ;; (first) invalid 4-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1698,7 +1698,7 @@
 
 ;; (last) invalid 4-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1713,7 +1713,7 @@
 
 ;; (last) invalid 4-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1730,7 +1730,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1745,7 +1745,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1760,7 +1760,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1775,7 +1775,7 @@
 
 ;; second byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1790,7 +1790,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1805,7 +1805,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1820,7 +1820,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1835,7 +1835,7 @@
 
 ;; second byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1850,7 +1850,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1865,7 +1865,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1880,7 +1880,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1895,7 +1895,7 @@
 
 ;; second byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1910,7 +1910,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1925,7 +1925,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1940,7 +1940,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1955,7 +1955,7 @@
 
 ;; second byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1972,7 +1972,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -1987,7 +1987,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2002,7 +2002,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2017,7 +2017,7 @@
 
 ;; third byte after (0xf0) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2032,7 +2032,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2047,7 +2047,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2062,7 +2062,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2077,7 +2077,7 @@
 
 ;; third byte after (first normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2092,7 +2092,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2107,7 +2107,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2122,7 +2122,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2137,7 +2137,7 @@
 
 ;; third byte after (last normal) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2152,7 +2152,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2167,7 +2167,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2182,7 +2182,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2197,7 +2197,7 @@
 
 ;; third byte after (0xf4) 4-byte prefix not a continuation byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2214,7 +2214,7 @@
 
 ;; 5-byte sequence contains 6 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\10"                       ;; import section
     "\01"                          ;; length 1
@@ -2229,7 +2229,7 @@
 
 ;; 5-byte sequence contains 4 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2244,7 +2244,7 @@
 
 ;; 5-byte sequence contains 4 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -2259,7 +2259,7 @@
 
 ;; 5-byte sequence contains 3 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -2274,7 +2274,7 @@
 
 ;; 5-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2289,7 +2289,7 @@
 
 ;; 5-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2304,7 +2304,7 @@
 
 ;; 5-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -2319,7 +2319,7 @@
 
 ;; 5-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -2334,7 +2334,7 @@
 
 ;; 5-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2351,7 +2351,7 @@
 
 ;; (first) invalid 5-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -2366,7 +2366,7 @@
 
 ;; (last) invalid 5-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -2383,7 +2383,7 @@
 
 ;; 6-byte sequence contains 7 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\11"                       ;; import section
     "\01"                          ;; length 1
@@ -2398,7 +2398,7 @@
 
 ;; 6-byte sequence contains 5 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -2413,7 +2413,7 @@
 
 ;; 6-byte sequence contains 5 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\10"                       ;; import section
     "\01"                          ;; length 1
@@ -2428,7 +2428,7 @@
 
 ;; 6-byte sequence contains 4 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2443,7 +2443,7 @@
 
 ;; 6-byte sequence contains 4 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0f"                       ;; import section
     "\01"                          ;; length 1
@@ -2458,7 +2458,7 @@
 
 ;; 6-byte sequence contains 3 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -2473,7 +2473,7 @@
 
 ;; 6-byte sequence contains 3 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2488,7 +2488,7 @@
 
 ;; 6-byte sequence contains 2 bytes at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2503,7 +2503,7 @@
 
 ;; 6-byte sequence contains 2 bytes
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0d"                       ;; import section
     "\01"                          ;; length 1
@@ -2518,7 +2518,7 @@
 
 ;; 6-byte sequence contains 1 byte at end of string
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -2533,7 +2533,7 @@
 
 ;; 6-byte sequence contains 1 byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2550,7 +2550,7 @@
 
 ;; (first) invalid 6-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\10"                       ;; import section
     "\01"                          ;; length 1
@@ -2565,7 +2565,7 @@
 
 ;; (last) invalid 6-byte prefix
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\10"                       ;; import section
     "\01"                          ;; length 1
@@ -2582,7 +2582,7 @@
 
 ;; invalid byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -2597,7 +2597,7 @@
 
 ;; invalid byte
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0b"                       ;; import section
     "\01"                          ;; length 1
@@ -2612,7 +2612,7 @@
 
 ;; UTF-16BE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2627,7 +2627,7 @@
 
 ;; UTF-32BE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1
@@ -2642,7 +2642,7 @@
 
 ;; UTF-16LE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0c"                       ;; import section
     "\01"                          ;; length 1
@@ -2657,7 +2657,7 @@
 
 ;; UTF-32LE BOM
 (assert_malformed
-  (module
+  (module binary
     "\00asm" "\01\00\00\00"
     "\02\0e"                       ;; import section
     "\01"                          ;; length 1

From a8fbb8589ac152d5ad892e532e0a616839022246 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 7 Jun 2017 08:16:03 +0200
Subject: [PATCH 026/329] Fix result syntax (#497)

Fix spec deviations:

* allow multiple results in function defs
* disallow multiple results in block sig

This is consistent with the spec document and the binary format.
---
 interpreter/Makefile        |  7 +++---
 interpreter/text/parser.mly | 25 ++++++++++++-------
 test/core/func.wast         |  2 +-
 test/core/type.wast         | 50 +++++++++++++++++++++++++++++++++++++
 4 files changed, 71 insertions(+), 13 deletions(-)
 create mode 100644 test/core/type.wast

diff --git a/interpreter/Makefile b/interpreter/Makefile
index a50117f4a..1dadb9dfc 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -26,12 +26,13 @@ JS =		# set to JS shell command to run JS tests
 
 # Main targets
 
-.PHONY:		unopt opt libunopt libopt all land zip
+.PHONY:		default opt unopt libopt libunopt all land zip
 
-unopt:		$(UNOPT)
+default:	opt
 opt:		$(OPT)
-libunopt:	_build/$(LIB).cmo
+unopt:		$(UNOPT)
 libopt:		_build/$(LIB).cmx
+libunopt:	_build/$(LIB).cmo
 all:		unopt opt libunopt libopt test
 land:		all $(WINMAKE)
 zip: 		$(ZIP)
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index b92a5e2ad..4db1bea97 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -348,11 +348,11 @@ block_instr :
       let ts, es1 = $3 c' in if_ ts es1 ($6 c') }
 
 block_sig :
-  | LPAR RESULT value_type_list RPAR { $3 }
+  | LPAR RESULT VALUE_TYPE RPAR { [$3] }
 
 block :
-  | block_sig block
-    { fun c -> let ts, es = $2 c in $1 @ ts, es }
+  | block_sig instr_list
+    { fun c -> $1, $2 c }
   | instr_list { fun c -> [], $1 c }
 
 expr :  /* Sugar */
@@ -427,18 +427,19 @@ func_fields :
       let fns, ims, exs = $2 c x at in fns, ims, $1 (FuncExport x) c :: exs }
 
 func_fields_import :  /* Sugar */
-  | /* empty */ { empty_type }
-  | LPAR RESULT value_type_list RPAR
-    { FuncType ([], $3) }
+  | func_fields_import_result { $1 }
   | LPAR PARAM value_type_list RPAR func_fields_import
     { let FuncType (ins, out) = $5 in FuncType ($3 @ ins, out) }
   | LPAR PARAM bind_var VALUE_TYPE RPAR func_fields_import  /* Sugar */
     { let FuncType (ins, out) = $6 in FuncType ($4 :: ins, out) }
 
+func_fields_import_result :  /* Sugar */
+  | /* empty */ { empty_type }
+  | LPAR RESULT value_type_list RPAR func_fields_import_result
+    { let FuncType (ins, out) = $5 in FuncType (ins, $3 @ out) }
+
 func_fields_body :
-  | func_body { empty_type, $1 }
-  | LPAR RESULT value_type_list RPAR func_body
-    { FuncType ([], $3), $5 }
+  | func_result_body { $1 }
   | LPAR PARAM value_type_list RPAR func_fields_body
     { let FuncType (ins, out) = fst $5 in
       FuncType ($3 @ ins, out),
@@ -448,6 +449,12 @@ func_fields_body :
       FuncType ($4 :: ins, out),
       fun c -> ignore (bind_local c $3); snd $6 c }
 
+func_result_body :
+  | func_body { empty_type, $1 }
+  | LPAR RESULT value_type_list RPAR func_result_body
+    { let FuncType (ins, out) = fst $5 in
+      FuncType (ins, $3 @ out), snd $5 }
+
 func_body :
   | instr_list
     { fun c -> let c' = anon_label c in
diff --git a/test/core/func.wast b/test/core/func.wast
index 41c2e65ba..87e50f59b 100644
--- a/test/core/func.wast
+++ b/test/core/func.wast
@@ -34,7 +34,7 @@
 
   (func $complex
     (param i32 f32) (param $x i64) (param) (param i32)
-    (result i32)
+    (result) (result i32) (result)
     (local f32) (local $y i32) (local i64 i32) (local) (local f64 i32)
     (unreachable) (unreachable)
   )
diff --git a/test/core/type.wast b/test/core/type.wast
new file mode 100644
index 000000000..e95766480
--- /dev/null
+++ b/test/core/type.wast
@@ -0,0 +1,50 @@
+;; Test type definitions
+
+(module
+  (type (func))
+  (type $t (func))
+
+  (type (func (param i32)))
+  (type (func (param $x i32)))
+  (type (func (result i32)))
+  (type (func (param i32) (result i32)))
+  (type (func (param $x i32) (result i32)))
+
+  (type (func (param f32 f64)))
+  (type (func (result i64 f32)))
+  (type (func (param i32 i64) (result f32 f64)))
+
+  (type (func (param f32) (param f64)))
+  (type (func (param $x f32) (param f64)))
+  (type (func (param f32) (param $y f64)))
+  (type (func (param $x f32) (param $y f64)))
+  (type (func (result i64) (result f32)))
+  (type (func (param i32) (param i64) (result f32) (result f64)))
+  (type (func (param $x i32) (param $y i64) (result f32) (result f64)))
+
+  (type (func (param f32 f64) (param $x i32) (param f64 i32 i32)))
+  (type (func (result i64 i64 f32) (result f32 i32)))
+  (type
+    (func (param i32 i32) (param i64 i32) (result f32 f64) (result f64 i32))
+  )
+
+  (type (func (param) (param $x f32) (param) (param) (param f64 i32) (param)))
+  (type
+    (func (result) (result) (result i64 i64) (result) (result f32) (result))
+  )
+  (type
+    (func
+      (param i32 i32) (param i64 i32) (param) (param $x i32) (param)
+      (result) (result f32 f64) (result f64 i32) (result)
+    )
+  )
+)
+
+(assert_malformed
+  (module quote "(type (result i32) (param i32))")
+  "unexpected token"
+)
+(assert_malformed
+  (module quote "(type (result $x i32))")
+  "unexpected token"
+)

From d0de3e4fb7b6a152b314dd2526c7d3b90d405ab8 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 7 Jun 2017 18:29:35 +0200
Subject: [PATCH 027/329] [spec/interpreter/test] Hotfix to functype arity
 handling

---
 document/syntax/types.rst       |  2 +-
 document/validation/modules.rst | 46 +++++++++++++++++++++---------
 interpreter/host/js.ml          |  6 ++--
 interpreter/spec/ast.ml         |  8 ++++--
 interpreter/spec/decode.ml      |  4 ++-
 interpreter/spec/encode.ml      |  4 ++-
 interpreter/spec/eval.ml        |  6 ++--
 interpreter/spec/valid.ml       | 12 ++++++--
 interpreter/text/arrange.ml     |  6 ++--
 interpreter/text/parser.mly     | 15 ++++++----
 interpreter/util/lib.ml         | 10 ++++---
 interpreter/util/lib.mli        |  1 +
 test/core/type.wast             | 50 +++++++++++++++++++--------------
 13 files changed, 109 insertions(+), 61 deletions(-)

diff --git a/document/syntax/types.rst b/document/syntax/types.rst
index bb8927d0b..669a471c5 100644
--- a/document/syntax/types.rst
+++ b/document/syntax/types.rst
@@ -78,7 +78,7 @@ mapping a vector of parameters to a vector of results.
 
 .. note::
    In the current version of WebAssembly,
-   the length of the result type vector of a function may be at most :math:`1`.
+   the length of the result type vector of a :ref:`valid <valid-functype>` function type may be at most :math:`1`.
    This restriction may be removed in future versions.
 
 
diff --git a/document/validation/modules.rst b/document/validation/modules.rst
index bd2e1bc32..5c8be03aa 100644
--- a/document/validation/modules.rst
+++ b/document/validation/modules.rst
@@ -8,6 +8,28 @@ To that end, each definition is classified with a suitable type.
 Auxiliary Rules
 ~~~~~~~~~~~~~~~
 
+.. _valid-functype:
+.. index:: function type
+   pair: validation; function type
+   single: abstract syntax; function type
+
+Function Types :math:`[t_1^n] \to [t_2^m]`
+..........................................
+
+* The arity :math:`m` must not be larger than :math:`1`.
+
+* Then the function type is valid.
+
+.. math::
+   \frac{
+   }{
+     \vdash [t_1^\ast] \to [t_2^?] ~\F{ok}
+   }
+
+.. note::
+   This restriction may be removed in future versions of WebAssembly.
+
+
 .. _valid-limits:
 .. index:: limits
    pair: validation; limits
@@ -45,9 +67,7 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
 
 * The type :math:`C.\TYPES[x]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\TYPES[x]`.
-
-* The length of :math:`t_2^\ast` must not be larger than :math:`1`.
+* Let :math:`[t_1^\ast] \to [t_2^?]` be the :ref:`function type <syntax-functype>` :math:`C.\TYPES[x]`.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`,
   but with:
@@ -56,12 +76,12 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
 
   * |LABELS| set to the singular sequence containing only :ref:`result type <syntax-valtype>` :math:`[t_2^\ast]`.
 
-  * |LRETURN| set to the :ref:`result type <syntax-valtype>` :math:`[t_2^\ast]`.
+  * |LRETURN| set to the :ref:`result type <syntax-valtype>` :math:`[t_2^?]`.
 
 * Under the context :math:`C'`,
-  the expression :math:`\expr` must be valid with type :math:`t_2^\ast`.
+  the expression :math:`\expr` must be valid with type :math:`t_2^?`.
 
-* Then the function definition is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
+* Then the function definition is valid with type :math:`[t_1^\ast] \to [t_2^?]`.
 
 .. math::
    \frac{
@@ -391,20 +411,15 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 
 * Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\TYPES[x]`.
 
-* The length of :math:`t_2^\ast` must not be larger than :math:`1`.
-
 * Then the import description is valid with type :math:`\FUNC~[t_1^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
-     C.\TYPES[x] = [t_1^\ast] \to [t_2^?]
+     C.\TYPES[x] = [t_1^\ast] \to [t_2^\ast]
    }{
-     C \vdash \FUNC~x : \FUNC~[t_1^\ast] \to [t_2^?]
+     C \vdash \FUNC~x : \FUNC~[t_1^\ast] \to [t_2^\ast]
    }
 
-.. note::
-   The restriction on the length of the result types :math:`t_2^\ast` may be lifted in future versions of WebAssembly.
-
 
 :math:`\TABLE~\limits~\elemtype`
 ................................
@@ -489,6 +504,9 @@ Instead, the context :math:`C` for validation of the module's content is constru
 
 * Under the context :math:`C`:
 
+  * For each :math:`\functype_i` in :math:`\module.\TYPES`,
+    the :ref:`function type <syntax-functype>` :math:`\functype_i` must be :ref:`valid <valid-functype>`.
+
   * For each :math:`\func_i` in :math:`\module.\FUNCS`,
     the definition :math:`\func_i` must be :ref:`valid <valid-func>` with a :ref:`function type <syntax-functype>` :math:`\functype_i`.
 
@@ -529,6 +547,8 @@ Instead, the context :math:`C` for validation of the module's content is constru
 .. math::
    \frac{
      \begin{array}{@{}c@{}}
+     (\vdash \functype ~\F{ok})^\ast
+     \\
      (C \vdash \func : \X{ft})^\ast
      \quad
      (C \vdash \table : \X{tt})^\ast
diff --git a/interpreter/host/js.ml b/interpreter/host/js.ml
index 64b949125..936130d42 100644
--- a/interpreter/host/js.ml
+++ b/interpreter/host/js.ml
@@ -199,8 +199,8 @@ let abs_mask_of = function
   | I32Type | F32Type -> Values.I32 Int32.max_int
   | I64Type | F64Type -> Values.I64 Int64.max_int
 
-let invoke t lits at =
-  [t], FuncImport (1l @@ at) @@ at,
+let invoke ft lits at =
+  [ft @@ at], FuncImport (1l @@ at) @@ at,
   List.map (fun lit -> Const lit @@ at) lits @ [Call (0l @@ at) @@ at]
 
 let get t at =
@@ -244,7 +244,7 @@ let wrap module_name item_name wrap_action wrap_assertion at =
   let itypes, idesc, action = wrap_action at in
   let locals, assertion = wrap_assertion at in
   let item = Lib.List32.length itypes @@ at in
-  let types = FuncType ([], []) :: itypes in
+  let types = (FuncType ([], []) @@ at) :: itypes in
   let imports = [{module_name; item_name; idesc} @@ at] in
   let edesc = FuncExport item @@ at in
   let exports = [{name = Utf8.decode "run"; edesc} @@ at] in
diff --git a/interpreter/spec/ast.ml b/interpreter/spec/ast.ml
index 1d427b2c4..48ce87f74 100644
--- a/interpreter/spec/ast.ml
+++ b/interpreter/spec/ast.ml
@@ -147,6 +147,8 @@ type memory_segment = string segment
 
 (* Modules *)
 
+type type_ = func_type Source.phrase
+
 type export_desc = export_desc' Source.phrase
 and export_desc' =
   | FuncExport of var
@@ -179,7 +181,7 @@ and import' =
 type module_ = module_' Source.phrase
 and module_' =
 {
-  types : func_type list;
+  types : type_ list;
   globals : global list;
   tables : table list;
   memories : memory list;
@@ -213,7 +215,7 @@ open Source
 let import_type (m : module_) (im : import) : external_type =
   let {idesc; _} = im.it in
   match idesc.it with
-  | FuncImport x -> ExternalFuncType (Lib.List32.nth m.it.types x.it)
+  | FuncImport x -> ExternalFuncType (Lib.List32.nth m.it.types x.it).it
   | TableImport t -> ExternalTableType t
   | MemoryImport t -> ExternalMemoryType t
   | GlobalImport t -> ExternalGlobalType t
@@ -225,7 +227,7 @@ let export_type (m : module_) (ex : export) : external_type =
   match edesc.it with
   | FuncExport x ->
     let fts =
-      funcs its @ List.map (fun f -> nth m.it.types f.it.ftype.it) m.it.funcs
+      funcs its @ List.map (fun f -> (nth m.it.types f.it.ftype.it).it) m.it.funcs
     in ExternalFuncType (nth fts x.it)
   | TableExport x ->
     let tts = tables its @ List.map (fun t -> t.it.ttype) m.it.tables in
diff --git a/interpreter/spec/decode.ml b/interpreter/spec/decode.ml
index 3c4dfd490..064aac545 100644
--- a/interpreter/spec/decode.ml
+++ b/interpreter/spec/decode.ml
@@ -481,8 +481,10 @@ let section tag f default s =
 
 (* Type section *)
 
+let type_ s = at func_type s
+
 let type_section s =
-  section `TypeSection (vec func_type) [] s
+  section `TypeSection (vec type_) [] s
 
 
 (* Import section *)
diff --git a/interpreter/spec/encode.ml b/interpreter/spec/encode.ml
index ca706b18b..adbf418a4 100644
--- a/interpreter/spec/encode.ml
+++ b/interpreter/spec/encode.ml
@@ -378,8 +378,10 @@ let encode m =
       end
 
     (* Type section *)
+    let type_ t = func_type t.it
+
     let type_section ts =
-      section 1 (vec func_type) ts (ts <> [])
+      section 1 (vec type_) ts (ts <> [])
 
     (* Import section *)
     let import_desc d =
diff --git a/interpreter/spec/eval.ml b/interpreter/spec/eval.ml
index 0511801bf..db3320326 100644
--- a/interpreter/spec/eval.ml
+++ b/interpreter/spec/eval.ml
@@ -87,7 +87,7 @@ let func_elem inst x i at =
   | _ -> Crash.error at ("type mismatch for element " ^ Int32.to_string i)
 
 let func_type_of = function
-  | AstFunc (inst, f) -> lookup "type" (!inst).module_.it.types f.it.ftype
+  | AstFunc (inst, f) -> (lookup "type" (!inst).module_.it.types f.it.ftype).it
   | HostFunc (t, _) -> t
 
 let take n (vs : 'a stack) at =
@@ -155,7 +155,7 @@ let rec step (inst : instance) (c : config) : config =
 
       | CallIndirect x, I32 i :: vs ->
         let clos = func_elem inst (0l @@ e.at) i e.at in
-        if type_ inst x <> func_type_of clos then
+        if (type_ inst x).it <> func_type_of clos then
           Trap.error e.at "indirect call signature mismatch";
         vs, [Invoke clos @@ e.at]
 
@@ -398,7 +398,7 @@ let check_limits actual expected at =
 let add_import (ext : extern) (im : import) (inst : instance) : instance =
   let {idesc; _} = im.it in
   match ext, idesc.it with
-  | ExternalFunc clos, FuncImport x when func_type_of clos = type_ inst x ->
+  | ExternalFunc clos, FuncImport x when func_type_of clos = (type_ inst x).it ->
     {inst with funcs = clos :: inst.funcs}
   | ExternalTable tab, TableImport (TableType (lim, t))
     when Table.elem_type tab = t ->
diff --git a/interpreter/spec/valid.ml b/interpreter/spec/valid.ml
index e596c92ea..82d3c04de 100644
--- a/interpreter/spec/valid.ml
+++ b/interpreter/spec/valid.ml
@@ -154,6 +154,7 @@ let check_memop (c : context) (memop : 'a memop) get_sz at =
 let check_arity n at =
   require (n <= 1) at "invalid result arity, larger than 1 is not (yet) allowed"
 
+
 (*
  * Conventions:
  *   c  : context
@@ -319,10 +320,13 @@ and check_block (c : context) (es : instr list) (ts : stack_type) at =
  *   x : variable
  *)
 
+let check_type (t : type_) =
+  let FuncType (ins, out) = t.it in
+  check_arity (List.length out) t.at
+
 let check_func (c : context) (f : func) =
   let {ftype; locals; body} = f.it in
   let FuncType (ins, out) = type_ c ftype in
-  check_arity (List.length out) f.at;
   let c' = {c with locals = ins @ locals; results = out; labels = [out]} in
   check_block c' body out f.at
 
@@ -430,7 +434,10 @@ let check_module (m : module_) =
     { types; imports; tables; memories; globals; funcs; start; elems; data;
       exports } = m.it
   in
-  let c0 = List.fold_right check_import imports {(context m) with types} in
+  let c0 =
+    List.fold_right check_import imports
+      {(context m) with types = List.map (fun ty -> ty.it) types}
+  in
   let c1 =
     { c0 with
       funcs = c0.funcs @ List.map (fun f -> type_ c0 f.it.ftype) funcs;
@@ -441,6 +448,7 @@ let check_module (m : module_) =
   let c =
     { c1 with globals = c1.globals @ List.map (fun g -> g.it.gtype) globals }
   in
+  List.iter check_type types;
   List.iter (check_global c1) globals;
   List.iter (check_table c1) tables;
   List.iter (check_memory c1) memories;
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 4cec63df3..5dcf9d715 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -302,8 +302,8 @@ let data seg =
 
 (* Modules *)
 
-let typedef i t =
-  Node ("type $" ^ nat i, [struct_type t])
+let typedef i ty =
+  Node ("type $" ^ nat i, [struct_type ty.it])
 
 let import_desc i d =
   match d.it with
@@ -400,7 +400,7 @@ let definition mode x_opt def =
         | Quoted (_, s) -> unquote (Parse.string_to_module s)
       in module_with_var_opt x_opt (unquote def)
     | `Binary, _ | `Original, Encoded _ ->
-      let rec unquote bs =
+      let rec unquote def =
         match def.it with
         | Textual m -> Encode.encode m
         | Encoded (_, bs) -> bs
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 4db1bea97..6df18a5fc 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -59,7 +59,7 @@ module VarMap = Map.Make(String)
 type space = {mutable map : int32 VarMap.t; mutable count : int32}
 let empty () = {map = VarMap.empty; count = 0l}
 
-type types = {mutable tmap : int32 VarMap.t; mutable tlist : Types.func_type list}
+type types = {mutable tmap : int32 VarMap.t; mutable tlist : type_ list}
 let empty_types () = {tmap = VarMap.empty; tlist = []}
 
 type context =
@@ -138,16 +138,16 @@ let anon_label (c : context) =
 let empty_type = FuncType ([], [])
 
 let inline_type (c : context) ty at =
-  match Lib.List.index_of ty c.types.tlist with
+  match Lib.List.index_where (fun ty' -> ty'.it = ty) c.types.tlist with
   | Some i -> Int32.of_int i @@ at
   | None ->
-    let i = Lib.List32.length c.types.tlist in ignore (anon_type c ty); i @@ at
+    let i = Lib.List32.length c.types.tlist in ignore (anon_type c (ty @@ at)); i @@ at
 
 let inline_type_explicit (c : context) x ty at =
   if
     ty <> empty_type &&
     (x.it >= Lib.List32.length c.types.tlist ||
-     ty <> Lib.List32.nth c.types.tlist x.it)
+     ty <> (Lib.List32.nth c.types.tlist x.it).it)
   then
     error at "inline function type does not match explicit type"
   else
@@ -600,10 +600,13 @@ inline_export :
 
 /* Modules */
 
+type_ :
+  | func_type { $1 @@ at () }
+
 type_def :
-  | LPAR TYPE func_type RPAR
+  | LPAR TYPE type_ RPAR
     { fun c -> anon_type c $3 }
-  | LPAR TYPE bind_var func_type RPAR  /* Sugar */
+  | LPAR TYPE bind_var type_ RPAR  /* Sugar */
     { fun c -> bind_type c $3 $4 }
 
 start :
diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index 53afb4e36..79b8eb632 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -74,12 +74,14 @@ struct
     | x::xs -> let ys, y = split_last xs in x::ys, y
     | [] -> failwith "split_last"
 
-  let rec index_of x xs = index_of' x xs 0
-  and index_of' x xs i =
+  let rec index_where p xs = index_where' p xs 0
+  and index_where' p xs i =
     match xs with
     | [] -> None
-    | y::xs' when x = y -> Some i
-    | y::xs' -> index_of' x xs' (i+1)
+    | x::xs' when p x -> Some i
+    | x::xs' -> index_where' p xs' (i+1)
+
+  let index_of x = index_where ((=) x)
 end
 
 module List32 =
diff --git a/interpreter/util/lib.mli b/interpreter/util/lib.mli
index 7f21733b2..06573d8e8 100644
--- a/interpreter/util/lib.mli
+++ b/interpreter/util/lib.mli
@@ -16,6 +16,7 @@ sig
   val split_last : 'a list -> 'a list * 'a (* raise Failure *)
 
   val index_of : 'a -> 'a list -> int option
+  val index_where : ('a -> bool) -> 'a list -> int option
 end
 
 module List32 :
diff --git a/test/core/type.wast b/test/core/type.wast
index e95766480..c78792ed2 100644
--- a/test/core/type.wast
+++ b/test/core/type.wast
@@ -11,40 +11,48 @@
   (type (func (param $x i32) (result i32)))
 
   (type (func (param f32 f64)))
-  (type (func (result i64 f32)))
-  (type (func (param i32 i64) (result f32 f64)))
+  ;; (type (func (result i64 f32)))
+  ;; (type (func (param i32 i64) (result f32 f64)))
 
   (type (func (param f32) (param f64)))
   (type (func (param $x f32) (param f64)))
   (type (func (param f32) (param $y f64)))
   (type (func (param $x f32) (param $y f64)))
-  (type (func (result i64) (result f32)))
-  (type (func (param i32) (param i64) (result f32) (result f64)))
-  (type (func (param $x i32) (param $y i64) (result f32) (result f64)))
+  ;; (type (func (result i64) (result f32)))
+  ;; (type (func (param i32) (param i64) (result f32) (result f64)))
+  ;; (type (func (param $x i32) (param $y i64) (result f32) (result f64)))
 
   (type (func (param f32 f64) (param $x i32) (param f64 i32 i32)))
-  (type (func (result i64 i64 f32) (result f32 i32)))
-  (type
-    (func (param i32 i32) (param i64 i32) (result f32 f64) (result f64 i32))
-  )
+  ;; (type (func (result i64 i64 f32) (result f32 i32)))
+  ;; (type
+  ;;   (func (param i32 i32) (param i64 i32) (result f32 f64) (result f64 i32))
+  ;; )
 
   (type (func (param) (param $x f32) (param) (param) (param f64 i32) (param)))
-  (type
-    (func (result) (result) (result i64 i64) (result) (result f32) (result))
-  )
-  (type
-    (func
-      (param i32 i32) (param i64 i32) (param) (param $x i32) (param)
-      (result) (result f32 f64) (result f64 i32) (result)
-    )
-  )
+  ;; (type
+  ;;   (func (result) (result) (result i64 i64) (result) (result f32) (result))
+  ;; )
+  ;; (type
+  ;;   (func
+  ;;     (param i32 i32) (param i64 i32) (param) (param $x i32) (param)
+  ;;     (result) (result f32 f64) (result f64 i32) (result)
+  ;;   )
+  ;; )
 )
 
 (assert_malformed
-  (module quote "(type (result i32) (param i32))")
-  "unexpected token"
+  (module quote "(type (func (result i32) (param i32)))")
+  "result before parameter"
 )
 (assert_malformed
-  (module quote "(type (result $x i32))")
+  (module quote "(type (func (result $x i32)))")
   "unexpected token"
 )
+(assert_invalid
+  (module quote "(type (func (result i32 i32)))")
+  "invalid result arity"
+)
+(assert_invalid
+  (module quote "(type (func (result i32) (result i32)))")
+  "invalid result arity"
+)

From b9a2baf5351323b90e8f48912d32b6367501ca0c Mon Sep 17 00:00:00 2001
From: Michael Ferris <mike.ferris@hotmail.com>
Date: Wed, 7 Jun 2017 10:18:56 -0700
Subject: [PATCH 028/329] Make WasmFunctionBuilder.end() append the end opcode
 (#492)

---
 test/harness/wasm-module-builder.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index 6e9284e77..d1826ecdc 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -107,6 +107,7 @@ class WasmFunctionBuilder {
   }
 
   end() {
+    this.body.push(kExprEnd);
     return this.module;
   }
 }

From 83db1c24618d58fbdcaeac1e3ccae8e98dda9cd7 Mon Sep 17 00:00:00 2001
From: Michael Ferris <mike.ferris@hotmail.com>
Date: Wed, 7 Jun 2017 13:26:11 -0700
Subject: [PATCH 029/329] Test Harness wasm-module-builder.js allow long
 sections (#491)

* Test Harness wasm-module-builder.js allow long sections.
Spreading the section into arguments can become too long for some engines.

* Address CR review
---
 test/harness/wasm-module-builder.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index d1826ecdc..abb72d2b8 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -74,7 +74,9 @@ class Binary extends Array {
     // Emit section length.
     this.emit_u32v(section.length);
     // Copy the temporary buffer.
-    this.push(...section);
+    for (const sectionByte of section) {
+      this.push(sectionByte);
+    }
   }
 }
 

From 8e8557d99581cd5e7b309503c4956890fb1f7ce4 Mon Sep 17 00:00:00 2001
From: Michael Ferris <mike.ferris@hotmail.com>
Date: Wed, 7 Jun 2017 13:26:34 -0700
Subject: [PATCH 030/329] Test Harness wasm-module-builder.js allow memory to
 have no max (#494)

---
 test/harness/wasm-module-builder.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index abb72d2b8..cc41be313 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -339,9 +339,10 @@ class WasmModuleBuilder {
       if (debug) print("emitting memory @ " + binary.length);
       binary.emit_section(kMemorySectionCode, section => {
         section.emit_u8(1);  // one memory entry
-        section.emit_u32v(kResizableMaximumFlag);
+        const has_max = wasm.memory.max !== undefined;
+        section.emit_u32v(has_max ? kResizableMaximumFlag : 0);
         section.emit_u32v(wasm.memory.min);
-        section.emit_u32v(wasm.memory.max);
+        if (has_max) section.emit_u32v(wasm.memory.max);
       });
     }
 

From 9c5097b277b215a9eeadbdb93a16ccc4520e3cda Mon Sep 17 00:00:00 2001
From: Michael Ferris <mike.ferris@hotmail.com>
Date: Wed, 7 Jun 2017 13:26:43 -0700
Subject: [PATCH 031/329] Test Harness wasm-module-builder.js, the table index
 for table segments must be emitted before each segments (#493)

---
 test/harness/wasm-module-builder.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index cc41be313..9cc5191ce 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -430,9 +430,9 @@ class WasmModuleBuilder {
       binary.emit_section(kElementSectionCode, section => {
         var inits = wasm.function_table_inits;
         section.emit_u32v(inits.length);
-        section.emit_u8(0); // table index
 
         for (let init of inits) {
+          section.emit_u8(0); // table index
           if (init.is_global) {
             section.emit_u8(kExprGetGlobal);
           } else {

From bb1d7437f84bda911ab9211f739a13a3a7ec94ff Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 8 Jun 2017 13:37:37 +0200
Subject: [PATCH 032/329] [spec] Specify numeric semantics (#490)

Also includes minor adjustment to interpreter and test suite (especially, checking that float literals do not overflow into infinity).
---
 document/binary/values.rst           |    4 +-
 document/execution/conventions.rst   |    2 +-
 document/execution/instructions.rst  |   74 +-
 document/execution/numerics.rst      | 1514 +++++++++++++++++++++++++-
 document/math.def                    |   97 +-
 document/syntax/instructions.rst     |    2 +-
 document/syntax/types.rst            |    8 +-
 document/syntax/values.rst           |   61 +-
 document/text/values.rst             |   50 +-
 document/validation/instructions.rst |   16 +-
 document/validation/modules.rst      |    2 +-
 interpreter/host/run.ml              |    7 +-
 interpreter/spec/f32.ml              |    5 +-
 interpreter/spec/f64.ml              |    3 +-
 interpreter/spec/float.ml            |   55 +-
 test/core/const.wast                 |   90 ++
 16 files changed, 1844 insertions(+), 146 deletions(-)

diff --git a/document/binary/values.rst b/document/binary/values.rst
index 9f530c0e3..7d3766dc9 100644
--- a/document/binary/values.rst
+++ b/document/binary/values.rst
@@ -88,12 +88,12 @@ As an additional constraint, the total number of bytes encoding a value of type
 Floating-Point
 ~~~~~~~~~~~~~~
 
-:ref:`Floating point <syntax-float>` values are encoded directly by their `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ bit pattern in `little endian <https://en.wikipedia.org/wiki/Endianness#Little-endian>`_ byte order:
+:ref:`Floating point <syntax-float>` values are encoded by their `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ bit pattern in `little endian <https://en.wikipedia.org/wiki/Endianness#Little-endian>`_ byte order:
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
    \production{floating-point number} & \BfN &::=&
-     b^\ast{:\,}\Bbyte^{N/8} &\Rightarrow& \F{reverse}(b^\ast) \\
+     b^\ast{:\,}\Bbyte^{N/8} &\Rightarrow& \bytes_{\fN}^{-1}(\F{reverse}(b^\ast)) \\
    \end{array}
 
 Here, :math:`\F{reverse}(b^\ast)` denotes the byte sequence :math:`b^\ast` in reversed order.
diff --git a/document/execution/conventions.rst b/document/execution/conventions.rst
index 81d1c9f27..c66c59e92 100644
--- a/document/execution/conventions.rst
+++ b/document/execution/conventions.rst
@@ -84,7 +84,7 @@ To avoid unnecessary clutter, the store :math:`S` and the frame :math:`F` are om
 There is no separate representation of the :ref:`stack <stack>`.
 Instead, it is conveniently represented as part of the configuration's instruction sequence.
 In particular, :ref:`values <syntax-val>` are defined to coincide with |CONST| instructions,
-and a sequence of |CONST| instructions can be interpreted as an operand "stack".
+and a sequence of |CONST| instructions can be interpreted as an operand "stack" that grows to the right.
 
 .. note::
    For example, the :ref:`reduction rule <exec-binop>` for the :math:`\I32.\ADD` instruction could be given as follows:
diff --git a/document/execution/instructions.rst b/document/execution/instructions.rst
index fc977d44e..900c59afc 100644
--- a/document/execution/instructions.rst
+++ b/document/execution/instructions.rst
@@ -13,6 +13,18 @@ Instructions
 Numeric Instructions
 ~~~~~~~~~~~~~~~~~~~~
 
+Numeric instructions are defined in terms of the basic :ref:`numeric operators <exec-numeric>`.
+Where these operators are partial, the corresponding instruction will :ref:`trap <trap>` when the result is not defined.
+Where these operators are non-deterministic, because they may return different :ref:`NaN <syntax-nan>` values, so are the corresponding instructions.
+
+The mapping of numeric instructions to their underlying operators is expressed by the following definition:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \X{op}_{\K{i}N}(n) &=& \F{i}\X{op}_N(n) \\
+   \X{op}_{\K{f}N}(z) &=& \F{f}\X{op}_N(z) \\
+   \end{array}
+
 
 .. _exec-const:
 
@@ -47,9 +59,9 @@ Numeric Instructions
 .. math::
    \begin{array}{lcl@{\qquad}l}
    (t\K{.}\CONST~c_1)~t\K{.}\unop &\stepto& (t\K{.}\CONST~c)
-     & (\mbox{if}~\unop_t(c_1) = c) \\
+     & (\mbox{if}~c \in \unop_t(c_1)) \\
    (t\K{.}\CONST~c_1)~t\K{.}\unop &\stepto& \TRAP
-     & (\mbox{otherwise})
+     & (\mbox{if}~\unop_{t_1,t_2}(c_1) = \{\})
    \end{array}
 
 
@@ -77,9 +89,9 @@ Numeric Instructions
 .. math::
    \begin{array}{lcl@{\qquad}l}
    (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\binop &\stepto& (t\K{.}\CONST~c)
-     & (\mbox{if}~\binop_t(c_1,c_2) = c) \\
+     & (\mbox{if}~c \in \binop_t(c_1,c_2)) \\
    (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\binop &\stepto& \TRAP
-     & (\mbox{otherwise})
+     & (\mbox{if}~\binop_{t_1,t_2}(c_1) = \{\})
    \end{array}
 
 
@@ -98,8 +110,8 @@ Numeric Instructions
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   (t\K{.}\CONST~c_1)~t\K{.}\testop &\stepto& (t\K{.}\CONST~c)
-     & (\mbox{if}~\testop_t(c_1) = c) \\
+   (t\K{.}\CONST~c_1)~t\K{.}\testop &\stepto& (\I32\K{.}\CONST~c)
+     & (\mbox{if}~c = \testop_t(c_1)) \\
    \end{array}
 
 
@@ -120,8 +132,8 @@ Numeric Instructions
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\relop &\stepto& (t\K{.}\CONST~c)
-     & (\mbox{if}~\relop_t(c_1,c_2) = c) \\
+   (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\relop &\stepto& (\I32\K{.}\CONST~c)
+     & (\mbox{if}~c = \relop_t(c_1,c_2)) \\
    \end{array}
 
 
@@ -147,9 +159,9 @@ Numeric Instructions
 .. math::
    \begin{array}{lcl@{\qquad}l}
    (t\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& (t_2\K{.}\CONST~c_2)
-     & (\mbox{if}~\cvtop_{t_1,t_2}(c_1) = c_2) \\
+     & (\mbox{if}~c_2 \in \cvtop_{t_1,t_2}(c_1)) \\
    (t\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& \TRAP
-     & (\mbox{otherwise})
+     & (\mbox{if}~\cvtop_{t_1,t_2}(c_1) = \{\})
    \end{array}
 
 
@@ -181,7 +193,7 @@ Parametric Instructions
 :math:`\SELECT`
 ...............
 
-1. Assert: due to :ref:`validation <valid-select>`, a value :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+1. Assert: due to :ref:`validation <valid-select>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
 2. Pop the value :math:`\I32.\CONST~c` from the stack.
 
@@ -275,7 +287,7 @@ Variable Instructions
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   F; \val~(\TEELOCAL~x) &\stepto& F'; \val~\val~(\SETLOCAL~x)
+   \val~(\TEELOCAL~x) &\stepto& \val~\val~(\SETLOCAL~x)
    \end{array}
 
 
@@ -374,17 +386,17 @@ Memory Instructions
 
    a. Let :math:`N` be the :ref:`width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
 
-10. If :math:`\X{ea} + N` is larger than the length of :math:`\X{mem}.\DATA`, then:
+10. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\DATA`, then:
 
     a. Trap.
 
-11. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\DATA[\X{ea}:N]`.
+11. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\DATA[\X{ea}:N/8]`.
 
 12. If :math:`N` and :math:`\sx` are part of the instruction, then:
 
-    a. Let :math:`n` be the integer for which :math:`\bytes_N(n) = b^\ast`.
+    a. Let :math:`n` be the integer for which :math:`\bytes_{\iN}(n) = b^\ast`.
 
-    b. Let :math:`c` be the result of computing :math:`\extend_{\sx,N}(n)`.
+    b. Let :math:`c` be the result of computing :math:`\extend\F{\_}\sx_{N,|t|}(n)`.
 
 13. Else:
 
@@ -400,18 +412,18 @@ Memory Instructions
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
-     \wedge & \X{ea} + |t| \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
-     \wedge & \bytes_t(c) = S.\MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:|t|])
+     \wedge & \X{ea} + |t|/8 \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
+     \wedge & \bytes_t(c) = S.\MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:|t|/8])
      \end{array} \\
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~i)~(t.\LOAD{N}\K{\_}\sx~\memarg) &\stepto&
-     S; F; (t.\CONST~\extend_{\sx,N}(n))
+     S; F; (t.\CONST~\extend\F{\_}\sx_{N,|t|}(n))
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
-     \wedge & \X{ea} + N \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
-     \wedge & \bytes_N(n) = S.\MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:N])
+     \wedge & \X{ea} + N/8 \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
+     \wedge & \bytes_{\iN}(n) = S.\MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:N/8])
      \end{array} \\
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~k)~(t.\LOAD({N}\K{\_}\sx)^?~\memarg) &\stepto& S; F; \TRAP
@@ -452,7 +464,7 @@ Memory Instructions
 
    a. Let :math:`N` be the :ref:`width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
 
-10. If :math:`\X{ea} + N` is larger than the length of :math:`\X{mem}.\DATA`, then:
+10. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\DATA`, then:
 
     a. Trap.
 
@@ -462,15 +474,15 @@ Memory Instructions
 
 13. If :math:`N` is part of the instruction, then:
 
-    a. Let :math:`n` be the result of computing :math:`\wrap_N(c)`.
+    a. Let :math:`n` be the result of computing :math:`\wrap_{|t|,N}(c)`.
 
-    b. Let :math:`b^\ast` be the byte sequence :math:`\bytes_N(n)`.
+    b. Let :math:`b^\ast` be the byte sequence :math:`\bytes_{\iN}(n)`.
 
 14. Else:
 
     a. Let :math:`b^\ast` be the byte sequence :math:`\bytes_t(c)`.
 
-15. Replace the bytes :math:`\X{mem}.\DATA[\X{ea}:N]` with :math:`b^\ast`.
+15. Replace the bytes :math:`\X{mem}.\DATA[\X{ea}:N/8]` with :math:`b^\ast`.
 
 .. math::
    \begin{array}{l}
@@ -480,8 +492,8 @@ Memory Instructions
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
-     \wedge & \X{ea} + |t| \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
-     \wedge & S' = S \with \MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:|t|] = \bytes_t(c)
+     \wedge & \X{ea} + |t|/8 \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
+     \wedge & S' = S \with \MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:|t|/8] = \bytes_t(c)
      \end{array} \\
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~i)~(t.\STORE{N}~\memarg) &\stepto& S'; F; \epsilon
@@ -489,8 +501,8 @@ Memory Instructions
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
-     \wedge & \X{ea} + N \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
-     \wedge & S' = S \with \MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:N] = \bytes_N(\wrap_N(c))
+     \wedge & \X{ea} + N/8 \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
+     \wedge & S' = S \with \MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:N/8] = \bytes_{\iN}(\wrap_{|t|,N}(c))
      \end{array} \\
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~k)~(t.\STORE{N}^?~\memarg) &\stepto& S; F; \TRAP
@@ -674,7 +686,7 @@ Control Instructions
 
 4. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is the end of the |IF| instruction.
 
-5. If :math:`c` is not :math:`0`, then:
+5. If :math:`c` is non-zero, then:
 
    a. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr_1^\ast` with label :math:`L`.
 
@@ -737,7 +749,7 @@ Control Instructions
 
 2. Pop the value :math:`\I32.\CONST~c` from the stack.
 
-3. If :math:`c` is not :math:`0`, then:
+3. If :math:`c` is non-zero, then:
 
    a. :ref:`Execute <exec-br>` the instruction :math:`(\BR~l)`.
 
diff --git a/document/execution/numerics.rst b/document/execution/numerics.rst
index 59ad0e0c6..95fed94b6 100644
--- a/document/execution/numerics.rst
+++ b/document/execution/numerics.rst
@@ -1,54 +1,1514 @@
 .. _exec-numeric:
+.. _exec-op-partial:
 
 Numerics
 --------
 
-.. todo::
-   Describe
+Numeric primitives are defined in a generic manner, by operators indexed over a width :math:`N`.
 
+Some operators are *non-deterministic*, because they can return one of several possible results (such as different :ref:`NaN <syntax-nan>` values).
+Conceptually, each operator thus returns a *set* of allowed values.
+For convenience, deterministic results are expressed as plain values, which are assumed to be identified with a respective singleton set.
+
+Some operators are *partial*, because they are not defined on certain inputs.
+Conceptually, an empty set of results is returned for these inputs.
+
+In formal notation, each operator is defined by equational clauses that apply in order.
+That is, the first clause that is applicable to the given arguments defines the result.
+In some cases, similar clauses are combined into one by using the notation :math:`\pm` or :math:`\mp`.
+When several of these placeholders occur in a single clause, then they must be resolved consistently: either the upper sign is chosen for all of them or the lower sign.
+
+.. note::
+   For example, the |fcopysign| operator is defined as follows:
+
+   .. math::
+      \begin{array}{@{}lcll}
+      \fcopysign_N(\pm p_1, \pm p_2) &=& \pm p_1 \\
+      \fcopysign_N(\pm p_1, \mp p_2) &=& \mp p_1 \\
+      \end{array}
+
+   This definition is to be read as a shorthand for the following expansion of each clause into two separate ones:
+
+   .. math::
+      \begin{array}{@{}lcll}
+      \fcopysign_N(+ p_1, + p_2) &=& + p_1 \\
+      \fcopysign_N(- p_1, - p_2) &=& - p_1 \\
+      \fcopysign_N(+ p_1, - p_2) &=& - p_1 \\
+      \fcopysign_N(- p_1, + p_2) &=& + p_1 \\
+      \end{array}
+
+.. _aux-trunc:
+
+Some definitions use *truncation* of rational values, with the usual mathematical definition:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \trunc(\pm q) &=& \pm i & (i \in \mathbb{N} \wedge q - 1 < i \leq q) \\
+   \end{array}
+
+
+Representations
+~~~~~~~~~~~~~~~
+
+Numbers have an underlying binary representation as a sequence of bits:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \bits_{\K{i}N}(i) &=& \ibits_N(i) \\
+   \bits_{\K{f}N}(z) &=& \fbits_N(z) \\
+   \end{array}
+
+Each of these functions is a bijection, hence they are invertible.
+
+.. note::
+   The notation :math:`f^{-1}` denotes the inverse of a function :math:`f`.
+
+
+.. _aux-ibits:
+
+Integers
+........
+
+:ref:`Integers <syntax-int>` are represented as base two unsigned numbers:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \ibits_N(i) &=& d_{N-1}~\dots~d_0 & (i = 2^{N-1}\cdot d_{N-1} + \dots + 2^0\cdot d_0) \\
+   \end{array}
+
+Boolean operators like :math:`\wedge`, :math:`\vee`, or :math:`\veebar` are lifted to bit sequences of equal length by applying them pointwise.
+
+
+.. _aux-fbits:
+.. _aux-fbias:
+.. _aux-fsign:
+
+Floating-Point
+..............
+
+:ref:`Floating-point values <syntax-float>` are represented in the respective binary format defined by `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \fbits_N(\pm (1+m\cdot 2^{-M})\cdot 2^e) &=& \fsign({\pm})~\ibits_E(e+\fbias_N)~\ibits_M(m) \\
+   \fbits_N(\pm (0+m\cdot 2^{-M})\cdot 2^e) &=& \fsign({\pm})~(0)^E~\ibits_M(m) \\
+   \fbits_N(\pm \infty) &=& \fsign({\pm})~(1)^E~(0)^M \\
+   \fbits_N(\pm \NAN(n)) &=& \fsign({\pm})~(1)^E~\ibits_M(n) \\[1ex]
+   \fbias_N &=& 2^{E-1}-1 \\
+   \fsign({+}) &=& 0 \\
+   \fsign({-}) &=& 1 \\
+   \end{array}
+
+where :math:`M = \significand(N)` and :math:`E = \exponent(N)`.
 
 .. _aux-bytes:
-.. _aux-signed:
-.. _aux-extend:
-.. _aux-wrap:
+.. _aux-littleendian:
 
-Auxiliary Operations
-~~~~~~~~~~~~~~~~~~~~
+Storage
+.......
+
+When a number is stored into :ref:`memory <syntax-mem>`, it is converted into a sequence of :ref:`bytes <syntax-byte>` in `little endian <https://en.wikipedia.org/wiki/Endianness#Little-endian>`_ byte order:
 
 .. math::
    \begin{array}{lll@{\qquad}l}
-   \bytes_N(i) &=& \epsilon & (N = 0 \wedge i = 0) \\
-   \bytes_N(i) &=& b~\bytes_{N-8}(j) & (N \geq 8 \wedge i = 2^8\cdot j + b) \\
-   ~ \\
-   \bytes_{\K{i}N}(i) &=& \bytes_N(i) \\
-   \bytes_{\K{f}N}(b^N) &=& \F{reverse}(b^N) \\
+   \bytes_t(i) &=& \littleendian(\bits_t(i)) \\[1ex]
+   \littleendian(\epsilon) &=& \epsilon \\
+   \littleendian(d_1^8~d_2^{N-8}) &=& \ibits_8^{-1}(d_1^8)~\littleendian(d_2^{N-8}) \\
    \end{array}
 
-Note that |bytes| is a bijection, hence the function is invertible.
+Again these functions are invertable bijections.
+
+
+Integer Operations
+~~~~~~~~~~~~~~~~~~
+
+.. _aux-signed:
+
+Sign Interpretation
+...................
+
+Integer operators are defined on |iN| values.
+Operators that use a signed interpretation convert the value using the following definition, which takes the two's complement when the value lies in the upper half of the value range (i.e., its most significant bit is :math:`1`):
 
 .. math::
    \begin{array}{lll@{\qquad}l}
    \signed_N(i) &=& i & (0 \leq i < 2^{N-1}) \\
    \signed_N(i) &=& i - 2^N & (2^{N-1} \leq i < 2^N) \\
-   \signed_N(-i) &=& -i & (0 < i \geq 2^{N-1}) \\
-   ~ \\
-   \extend_{\B{U},N}(i) &=& i \\
-   \extend_{\B{S},N}(i) &=& \signed_N(i) \\
-   \wrap_N(i) &=& i \mod 2^N \\
    \end{array}
 
-.. Note::
-   The index :math:`N` of the |extend| function is the size extending *from*,
-   where as the index of the |wrap| function is the size wrapping *to*.
+This function is bijective, and hence invertible.
 
+.. _aux-bool:
 
-Integer Operations
-~~~~~~~~~~~~~~~~~~
+Boolean Interpretation
+......................
 
+The integer result of predicates -- i.e., tests and relational operators -- is defined with the help of the following auxiliary function producing the value :math:`1` or :math:`0` depending on a condition.
 
-Floating-Point Operations
-~~~~~~~~~~~~~~~~~~~~~~~~~
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \bool(C) &=& 1 & (\mbox{if}~C) \\
+   \bool(C) &=& 0 & (\mbox{otherwise}) \\
+   \end{array}
 
 
-Conversions
-~~~~~~~~~~~
+.. _op-add:
+
+:math:`\iadd_N(i_1, i_2)`
+.........................
+
+* Return the result of adding :math:`i_1` and :math:`i_2` modulo :math:`2^N`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iadd_N(i_1, i_2) &=& (i_1 + i_2) \mod 2^N
+   \end{array}
+
+.. _op-sub:
+
+:math:`\isub_N(i_1, i_2)`
+.........................
+
+* Return the result of subtracting :math:`i_2` from :math:`i_1` modulo :math:`2^N`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \isub_N(i_1, i_2) &=& (i_1 - i_2 + 2^N) \mod 2^N
+   \end{array}
+
+.. _op-mul:
+
+:math:`\imul_N(i_1, i_2)`
+.........................
+
+* Return the result of multiplying :math:`i_1` and :math:`i_2` modulo :math:`2^N`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \imul_N(i_1, i_2) &=& (i_1 \cdot i_2) \mod 2^N
+   \end{array}
+
+.. _op-div_u:
+
+:math:`\idivu_N(i_1, i_2)`
+..........................
+
+* If :math:`i_2` is :math:`0`, then the result is undefined.
+
+* Else, return the result of dividing :math:`i_1` by :math:`i_2`, truncated toward zero.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \idivu_N(i_1, 0) &=& \{\} \\
+   \idivu_N(i_1, i_2) &=& \trunc(i_1 / i_2) \\
+   \end{array}
+
+.. note::
+   This operator is :ref:`partial <exec-op-partial>`.
+
+.. _op-div_s:
+
+:math:`\idivs_N(i_1, i_2)`
+..........................
+
+* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+
+* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+
+* If :math:`j_2` is :math:`0`, then the result is undefined.
+
+* Else if :math:`j_1` divided by :math:`j_2` is :math:`2^{N-1}`, then the result is undefined.
+
+* Else, return the result of dividing :math:`j_1` by :math:`j_2`, truncated toward zero.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \idivs_N(i_1, 0) &=& \{\} \\
+   \idivs_N(i_1, i_2) &=& \{\} \qquad\qquad (\signed_N(i_1) / \signed_N(i_2) = 2^{N-1}) \\
+   \idivs_N(i_1, i_2) &=& \signed_N^{-1}(\trunc(\signed_N(i_1) / \signed_N(i_2))) \\
+   \end{array}
+
+.. note::
+   This operator is :ref:`partial <exec-op-partial>`.
+   In particular, the result of :math:`(-2^{N-1})/(-1) = +2^{N-1}` is not representable as an :math:`N`-bit signed integer.
+
+
+.. _op-rem_u:
+
+:math:`\iremu_N(i_1, i_2)`
+..........................
+
+* If :math:`i_2` is :math:`0`, then the result is undefined.
+
+* Else, return the remainder of dividing :math:`i_1` by :math:`i_2`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iremu_N(i_1, 0) &=& \{\} \\
+   \iremu_N(i_1, i_2) &=& i_1 - i_2 \cdot \trunc(i_1 / i_2) \\
+   \end{array}
+
+.. note::
+   This operator is :ref:`partial <exec-op-partial>`.
+
+   As long as :math:`i_2 \neq 0`,
+   it holds that :math:`i_1 = i_2\cdot\idivu(i_1, i_2) + \iremu(i_1, i_2)`.
+
+.. _op-rem_s:
+
+:math:`\irems_N(i_1, i_2)`
+..........................
+
+* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+
+* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+
+* If :math:`i_2` is :math:`0`, then the result is undefined.
+
+* Else, return the remainder of dividing :math:`j_1` by :math:`j_2`, with the sign of the dividend :math:`j_1`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \irems_N(i_1, 0) &=& \{\} \\
+   \irems_N(i_1, i_2) &=& \signed_N^{-1}(i_1 - i_2 \cdot \trunc(\signed_N(i_1) / \signed_N(i_2))) \\
+   \end{array}
+
+.. note::
+   This operator is :ref:`partial <exec-op-partial>`.
+
+   As long as :math:`i_2 \neq 0` and :math:`i_2 \neq \signed_N^{-1}(-1)`,
+   it holds that :math:`i_1 = i_2\cdot\idivs(i_1, i_2) + \irems(i_1, i_2)`.
+
+
+.. _op-and:
+
+:math:`\iand_N(i_1, i_2)`
+.........................
+
+* Return the bitwise conjunction of :math:`i_1` and :math:`i_2`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iand_N(i_1, i_2) &=& \ibits_N^{-1}(\ibits_N(i_1) \wedge \ibits_N(i_2))
+   \end{array}
+
+.. _op-or:
+
+:math:`\ior_N(i_1, i_2)`
+........................
+
+* Return the bitwise disjunction of :math:`i_1` and :math:`i_2`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ior_N(i_1, i_2) &=& \ibits_N^{-1}(\ibits_N(i_1) \vee \ibits_N(i_2))
+   \end{array}
+
+.. _op-xor:
+
+:math:`\ixor_N(i_1, i_2)`
+.........................
+
+* Return the bitwise exclusive disjunction of :math:`i_1` and :math:`i_2`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ixor_N(i_1, i_2) &=& \ibits_N^{-1}(\ibits_N(i_1) \veebar \ibits_N(i_2))
+   \end{array}
+
+.. _op-shl:
+
+:math:`\ishl_N(i_1, i_2)`
+.........................
+
+* Let :math:`k` be :math:`i_2` modulo :math:`N`.
+
+* Return the result of shifting :math:`i_1` left by :math:`k` bits, modulo :math:`2^N`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ishl_N(i_1, i_2) &=& \ibits_N^{-1}(b_2^{N-k}~0^k) & (\ibits_N(i_1) = b_1^k~b_2^{N-k} \wedge k = i_2 \mod N)
+   \end{array}
+
+.. _op-shr_u:
+
+:math:`\ishru_N(i_1, i_2)`
+..........................
+
+* Let :math:`j_2` be :math:`i_2` modulo :math:`N`.
+
+* Return the result of shifting :math:`i_1` right by :math:`j_2` bits, extended with :math:`0` bits.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ishru_N(i_1, i_2) &=& \ibits_N^{-1}(0^k~b_1^{N-k}) & (\ibits_N(i_1) = b_1^{N-k}~b_2^k \wedge k = i_2 \mod N)
+   \end{array}
+
+.. _op-shr_s:
+
+:math:`\ishrs_N(i_1, i_2)`
+..........................
+
+* Let :math:`j_2` be :math:`i_2` modulo :math:`N`.
+
+* Return the result of shifting :math:`i_1` right by :math:`j_2` bits, extended with the most significant bit of the original value.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ishrs_N(i_1, i_2) &=& \ibits_N^{-1}(b_0^{k+1}~b_1^{N-k-1}) & (\ibits_N(i_1) = b_0~b_1^{N-k-1}~b_2^k \wedge k = i_2 \mod N)
+   \end{array}
+
+.. _op-rotl:
+
+:math:`\irotl_N(i_1, i_2)`
+..........................
+
+* Let :math:`j_2` be :math:`i_2` modulo :math:`N`.
+
+* Return the result of rotating :math:`i_1` left by :math:`j_2` bits.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \irotl_N(i_1, i_2) &=& \ibits_N^{-1}(b_2^{N-k}~b_1^k) & (\ibits_N(i_1) = b_1^k~b_2^{N-k} \wedge k = i_2 \mod N)
+   \end{array}
+
+.. _op-rotr:
+
+:math:`\irotr_N(i_1, i_2)`
+..........................
+
+* Let :math:`j_2` be :math:`i_2` modulo :math:`N`.
+
+* Return the result of rotating :math:`i_1` right by :math:`j_2` bits.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \irotr_N(i_1, i_2) &=& \ibits_N^{-1}(b_2^k~b_1^{N-k}) & (\ibits_N(i_1) = b_1^{N-k}~b_2^k \wedge k = i_2 \mod N)
+   \end{array}
+
+
+.. _op-clz:
+
+:math:`\iclz_N(i)`
+..................
+
+* Return the count of leading zero bits in :math:`i`; all bits are considered leading zeros if :math:`i` is :math:`0`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iclz_N(i) &=& k & (\ibits_N(i) = 0^k~(1~b^\ast)^?)
+   \end{array}
+
+
+.. _op-ctz:
+
+:math:`\ictz_N(i)`
+..................
+
+* Return the count of trailing zero bits in :math:`i`; all bits are considered trailing zeros if :math:`i` is :math:`0`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ictz_N(i) &=& k & (\ibits_N(i) = (b^\ast~1)^?~0^k)
+   \end{array}
+
+
+.. _op-popcnt:
+
+:math:`\ipopcnt_N(i)`
+.....................
+
+* Return the count of non-zero bits in :math:`i`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ipopcnt_N(i) &=& k & (\ibits_N(i) = (0^\ast~1)^k~0^\ast)
+   \end{array}
+
+
+.. _op-eqz:
+
+:math:`\ieqz_N(i)`
+..................
+
+* Return :math:`1` if :math:`i` is zero, :math:`0` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ieqz_N(i) &=& \bool(i = 0)
+   \end{array}
+
+
+.. _op-eq:
+
+:math:`\ieq_N(i_1, i_2)`
+........................
+
+* Return :math:`1` if :math:`i_1` equals :math:`i_2`, :math:`0` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ieq_N(i_1, i_2) &=& \bool(i_1 = i_2)
+   \end{array}
+
+
+.. _op-ne:
+
+:math:`\ine_N(i_1, i_2)`
+........................
+
+* Return :math:`1` if :math:`i_1` does not equal :math:`i_2`, :math:`0` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ine_N(i_1, i_2) &=& \bool(i_1 \neq i_2)
+   \end{array}
+
+
+.. _op-lt_u:
+
+:math:`\iltu_N(i_1, i_2)`
+.........................
+
+* Return :math:`1` if :math:`i_1` is less than :math:`i_2`, :math:`0` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iltu_N(i_1, i_2) &=& \bool(i_1 < i_2)
+   \end{array}
+
+
+.. _op-lt_s:
+
+:math:`\ilts_N(i_1, i_2)`
+.........................
+
+* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+
+* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+
+* Return :math:`1` if :math:`j_1` is less than :math:`j_2`, :math:`0` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ilts_N(i_1, i_2) &=& \bool(\signed_N(i_1) < \signed_N(i_2))
+   \end{array}
+
+
+.. _op-gt_u:
+
+:math:`\igtu_N(i_1, i_2)`
+.........................
+
+* Return :math:`1` if :math:`i_1` is greater than :math:`i_2`, :math:`0` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \igtu_N(i_1, i_2) &=& \bool(i_1 > i_2)
+   \end{array}
+
+
+.. _op-gt_s:
+
+:math:`\igts_N(i_1, i_2)`
+.........................
+
+* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+
+* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+
+* Return :math:`1` if :math:`j_1` is greater than :math:`j_2`, :math:`0` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \igts_N(i_1, i_2) &=& \bool(\signed_N(i_1) > \signed_N(i_2))
+   \end{array}
+
+
+.. _op-le_u:
+
+:math:`\ileu_N(i_1, i_2)`
+.........................
+
+* Return :math:`1` if :math:`i_1` is less than or equal to :math:`i_2`, :math:`0` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ileu_N(i_1, i_2) &=& \bool(i_1 \leq i_2)
+   \end{array}
+
+
+.. _op-le_s:
+
+:math:`\iles_N(i_1, i_2)`
+.........................
+
+* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+
+* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+
+* Return :math:`1` if :math:`j_1` is less than or equal to :math:`j_2`, :math:`0` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iles_N(i_1, i_2) &=& \bool(\signed_N(i_1) \leq \signed_N(i_2))
+   \end{array}
+
+
+.. _op-ge_u:
+
+:math:`\igeu_N(i_1, i_2)`
+.........................
+
+* Return :math:`1` if :math:`i_1` is greater than or equal to :math:`i_2`, :math:`0` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \igeu_N(i_1, i_2) &=& \bool(i_1 \geq i_2)
+   \end{array}
+
+
+.. _op-ge_s:
+
+:math:`\iges_N(i_1, i_2)`
+.........................
+
+* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+
+* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+
+* Return :math:`1` if :math:`j_1` is greater than or equal to :math:`j_2`, :math:`0` otherwise.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \iges_N(i_1, i_2) &=& \bool(\signed_N(i_1) \geq \signed_N(i_2))
+   \end{array}
+
+
+Floating-Point Operations
+~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Floating-point arithmetic follows the `IEEE 754-2008 <http://ieeexplore.ieee.org/document/4610935/>`_ standard,
+with the following qualifications:
+
+* All operators use round-to-nearest ties-to-even, except where otherwise specified.
+  Non-default directed rounding attributes are not supported.
+
+* Following the recommendation that operators propagate NaN bits from their operands is permitted but not required.
+
+* All operators use "non-stop" mode, and floating-point exceptions are not otherwise observable.
+  In particular, neither alternate floating-point exception handling attributes nor operators on status flags are supported.
+  There is no observable difference between quiet and signalling NaNs.
+
+.. note::
+   Some of these limitations may be lifted in future versions of WebAssembly.
+
+
+.. _aux-ieee:
+
+Rounding
+........
+
+An *exact* floating-point number is a rational number that is exactly representable as a :ref:`floating-point number <syntax-float>` of given bit width :math:`N`.
+
+A *limit* number for a given floating-point bit width :math:`N` is a positive or negative number whose magnitude is the smallest power of :math:`2` that is not exactly representable as a floating-point number of width :math:`N` (that magnitude is :math:`2^{128}` for :math:`N = 32` and :math:`2^{1024}` for :math:`N = 64`).
+
+A *candidate* number is either an exact floating-point number or a positive or negative limit number for the given bit width :math:`N`.
+
+A *candidate pair* is a pair :math:`z_1,z_2` of candidate numbers, such that no candidate number exists that lies between the two.
+
+A real number :math:`r` is converted to a floating-point value of bit width :math:`N` as follows:
+
+* If :math:`r` is :math:`0`, then return :math:`+0`.
+
+* Else if :math:`r` is an exact floating-point number, then return :math:`r`.
+
+* Else if :math:`r` greater than or equal to the positive limit, then return :math:`+\infty`.
+
+* Else if :math:`r` is less than or equal to the negative limit, then return :math:`-\infty`.
+
+* Else if :math:`z_1` and :math:`z_2` are a candidate pair such that :math:`z_1 < r < z_2`, then:
+
+  * If :math:`|r - z_1| < |r - z_2|`, then let :math:`z` be :math:`z_1`.
+
+  * Else if :math:`|r - z_1| > |r - z_2|`, then let :math:`z` be :math:`z_2`.
+
+  * Else if :math:`|r - z_1| = |r - z_2|` and the significand of :math:`z_1` is even, then let :math:`z` be :math:`z_1`.
+
+  * Else, let :math:`z` be :math:`z_2`.
+
+* If :math:`z` is :math:`0`, then:
+
+  * If :math:`r < 0`, then return :math:`-0`.
+
+  * Else, return :math:`+0`.
+
+* Else if :math:`z` is a limit number, then:
+
+  * If :math:`r < 0`, then return :math:`-\infty`.
+
+  * Else, return :math:`+\infty`.
+
+* Else, return :math:`z`.
+
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \ieee_N(0) &=& +0 \\
+   \ieee_N(r) &=& r & (r \in \F{exact}_N) \\
+   \ieee_N(r) &=& +\infty & (r \geq -\F{limit}_n) \\
+   \ieee_N(r) &=& -\infty & (r \leq +\F{limit}_n) \\
+   \ieee_N(r) &=& \F{closest}_N(r, z_1, z_2) & (z_1 < r < z_2 \wedge (z_1,z_2) \in \F{candidatepair}_N) \\[1ex]
+   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_1) & (|r-z_1|<|r-z_2|) \\
+   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_2) & (|r-z_1|>|r-z_2|) \\
+   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_1) & (|r-z_1|=|r-z_2| \wedge \F{even}_N(z_1)) \\
+   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_2) & (|r-z_1|=|r-z_2| \wedge \F{even}_N(z_2)) \\[1ex]
+   \F{rectify}_N(r, \pm \F{limit}_N) &=& \pm \infty \\
+   \F{rectify}_N(r, 0) &=& +0 \qquad (r \geq 0) \\
+   \F{rectify}_N(r, 0) &=& -0 \qquad (r < 0) \\
+   \F{rectify}_N(r, z) &=& z \\
+   \end{array}
+
+where:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \F{exact}_N &=& \fN \cap \mathbb{Q} \\
+   \F{limit}_N &=& 2^{2^{\exponent(N)-1}} \\
+   \F{candidate}_N &=& \F{exact}_N \cup \{+\F{limit}_N, -\F{limit}_N\} \\
+   \F{candidatepair}_N &=& \{ (z_1, z_2) \in \F{candidate}_N^2 ~|~ z_1 < z_2 \wedge \forall z \in \F{candidate}_N, z \leq z_1 \vee z \geq z_2\} \\[1ex]
+   \F{even}_N((d + m\cdot 2^{-M}) \cdot 2^e) &\Leftrightarrow& m \mod 2 = 0 \\
+   \F{even}_N(\pm \F{limit}_N) &\Leftrightarrow& \F{true} \\
+   \end{array}
+
+
+.. _aux-nan:
+
+NaN Propagation
+...............
+
+When the result of a floating-point operator other than |fneg|, |fabs|, or |fcopysign| is a :ref:`NaN <syntax-nan>`, its sign is non-deterministic and the :ref:`payload <syntax-payload>` computed as follows:
+
+* If the payload of all NaN inputs to the operator is :ref:`canonical <canonical-nan>` (including the case that there are no NaN inputs), then the payload of the output is canonical as well.
+
+* Otherwise the payload is picked non-determinsitically among all :ref:`arithmetic NaNs <arithmetic-nan>`; that is, its most significant bit is :math:`1` and all others are unspecified.
+
+This non-deterministic result is expressed by the following auxiliary function producing a set of allowed outputs from a set of inputs:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \nans_N\{z^\ast\} &=& \{ + \NAN(n), - \NAN(n) ~|~ n = \canon_N \} & (\forall \NAN(n) \in z^\ast,~ n = \canon_N) \\
+   \nans_N\{z^\ast\} &=& \{ + \NAN(n), - \NAN(n) ~|~ n \geq \canon_N \} & (\mbox{otherwise}) \\
+   \end{array}
+
+
+.. _op-fadd:
+
+:math:`\fadd_N(z_1, z_2)`
+.........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return an element of :math:`\nans_N\{z_1, z_2\}`.
+
+* Else if both :math:`z_1` and :math:`z_2` are infinities of opposite signs, then return an element of :math:`\nans_N\{z_1, z_2\}`.
+
+* Else if both :math:`z_1` and :math:`z_2` are infinities of equal sign, then return that infinity.
+
+* Else if one of :math:`z_1` or :math:`z_2` is an infinity, then return that infinity.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes of opposite sign, then return positive zero.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes of equal sign, then return that zero.
+
+* Else if one of :math:`z_1` or :math:`z_2` is a zero, then return the other operand.
+
+* Else if both :math:`z_1` and :math:`z_2` are values with the same magnitude but opposite signs, then return positive zero.
+
+* Else return the result of adding :math:`z_1` and :math:`z_2`, :ref:`rounded <aux-ieee>` to the nearest representable value.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fadd_N(\pm \NAN(n), z_2) &=& \nans_N\{\pm \NAN(n), z_2\} \\
+   \fadd_N(z_1, \pm \NAN(n)) &=& \nans_N\{\pm \NAN(n), z_1\} \\
+   \fadd_N(\pm \infty, \mp \infty) &=& \nans_N\{\} \\
+   \fadd_N(\pm \infty, \pm \infty) &=& \pm \infty \\
+   \fadd_N(z_1, \pm \infty) &=& \pm \infty \\
+   \fadd_N(\pm \infty, z_2) &=& \pm \infty \\
+   \fadd_N(\pm 0, \mp 0) &=& +0 \\
+   \fadd_N(\pm 0, \pm 0) &=& \pm 0 \\
+   \fadd_N(z_1, \pm 0) &=& z_1 \\
+   \fadd_N(\pm 0, z_2) &=& z_2 \\
+   \fadd_N(\pm q, \mp q) &=& +0 \\
+   \fadd_N(z_1, z_2) &=& \ieee_N(z_1 + z_2) \\
+   \end{array}
+
+
+.. _op-fsub:
+
+:math:`\fsub_N(z_1, z_2)`
+.........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return an element of :math:`\nans_N\{z_1, z_2\}`.
+
+* Else if both :math:`z_1` and :math:`z_2` are infinities of equal signs, then return an element of :math:`\nans_N\{z_1, z_2\}`.
+
+* Else if both :math:`z_1` and :math:`z_2` are infinities of opposite sign, then return :math:`z_1`.
+
+* Else if :math:`z_1` is an infinity, then return that infinity.
+
+* Else if :math:`z_2` is an infinity, then return that infinity negated.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes of equal sign, then return positive zero.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes of opposite sign, then return :math:`z_1`.
+
+* Else if :math:`z_2` is a zero, then return :math:`z_1`.
+
+* Else if :math:`z_1` is a zero, then return :math:`z_2` negated.
+
+* Else if both :math:`z_1` and :math:`z_2` are the same value, then return positive zero.
+
+* Else return the result of subtracting :math:`z_2` from :math:`z_1`, :ref:`rounded <aux-ieee>` to the nearest representable value.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fsub_N(\pm \NAN(n), z_2) &=& \nans_N\{\pm \NAN(n), z_2\} \\
+   \fsub_N(z_1, \pm \NAN(n)) &=& \nans_N\{\pm \NAN(n), z_1\} \\
+   \fsub_N(\pm \infty, \pm \infty) &=& \nans_N\{\} \\
+   \fsub_N(\pm \infty, \mp \infty) &=& \pm \infty \\
+   \fsub_N(z_1, \pm \infty) &=& \mp \infty \\
+   \fsub_N(\pm \infty, z_2) &=& \pm \infty \\
+   \fsub_N(\pm 0, \pm 0) &=& +0 \\
+   \fsub_N(\pm 0, \mp 0) &=& \pm 0 \\
+   \fsub_N(z_1, \pm 0) &=& z_1 \\
+   \fsub_N(\pm 0, \pm q_2) &=& \mp q_2 \\
+   \fsub_N(\pm q, \pm q) &=& +0 \\
+   \fsub_N(z_1, z_2) &=& \ieee_N(z_1 - z_2) \\
+   \end{array}
+
+.. note::
+   Up to the non-determinism regarding NaNs, it always holds that :math:`\fsub_N(z_1, z_2) = \fadd_N(z_1, \fneg_N(z_2))`.
+
+
+.. _op-fmul:
+
+:math:`\fmul_N(z_1, z_2)`
+.........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return an element of :math:`\nans_N\{z_1, z_2\}`.
+
+* Else if one of :math:`z_1` and :math:`z_2` is a zero and the other an infinity, then return an element of :math:`\nans_N\{z_1, z_2\}`.
+
+* Else if both :math:`z_1` and :math:`z_2` are infinities of equal sign, then return positive infinity.
+
+* Else if both :math:`z_1` and :math:`z_2` are infinities of opposite sign, then return negative infinity.
+
+* Else if one of :math:`z_1` or :math:`z_2` is an infinity and the other a value with equal sign, then return positive infinity.
+
+* Else if one of :math:`z_1` or :math:`z_2` is an infinity and the other a value with opposite sign, then return negative infinity.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes of equal sign, then return positive zero.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes of opposite sign, then return negative zero.
+
+* Else return the result of multiplying :math:`z_1` and :math:`z_2`, :ref:`rounded <aux-ieee>` to the nearest representable value.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fmul_N(\pm \NAN(n), z_2) &=& \nans_N\{\pm \NAN(n), z_2\} \\
+   \fmul_N(z_1, \pm \NAN(n)) &=& \nans_N\{\pm \NAN(n), z_1\} \\
+   \fmul_N(\pm \infty, \pm 0) &=& \nans_N\{\} \\
+   \fmul_N(\pm \infty, \mp 0) &=& \nans_N\{\} \\
+   \fmul_N(\pm 0, \pm \infty) &=& \nans_N\{\} \\
+   \fmul_N(\pm 0, \mp \infty) &=& \nans_N\{\} \\
+   \fmul_N(\pm \infty, \pm \infty) &=& +\infty \\
+   \fmul_N(\pm \infty, \mp \infty) &=& -\infty \\
+   \fmul_N(\pm q_1, \pm \infty) &=& +\infty \\
+   \fmul_N(\pm q_1, \mp \infty) &=& -\infty \\
+   \fmul_N(\pm \infty, \pm q_2) &=& +\infty \\
+   \fmul_N(\pm \infty, \mp q_2) &=& -\infty \\
+   \fmul_N(\pm 0, \pm 0) &=& + 0 \\
+   \fmul_N(\pm 0, \mp 0) &=& - 0 \\
+   \fmul_N(z_1, z_2) &=& \ieee_N(z_1 \cdot z_2) \\
+   \end{array}
+
+
+.. _op-fdiv:
+
+:math:`\fdiv_N(z_1, z_2)`
+.........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return an element of :math:`\nans_N\{z_1, z_2\}`.
+
+* Else if both :math:`z_1` and :math:`z_2` are infinities, then return an element of :math:`\nans_N\{z_1, z_2\}`.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes, then return an element of :math:`\nans_N\{z_1, z_2\}`.
+
+* Else if :math:`z_1` is an infinity and :math:`z_2` a value with equal sign, then return positive infinity.
+
+* Else if :math:`z_1` is an infinity and :math:`z_2` a value with opposite sign, then return negative infinity.
+
+* Else if :math:`z_2` is an infinity and :math:`z_1` a value with equal sign, then return positive zero.
+
+* Else if :math:`z_2` is an infinity and :math:`z_1` a value with opposite sign, then return negative zero.
+
+* Else if :math:`z_1` is a zero and :math:`z_2` a value with equal sign, then return positive zero.
+
+* Else if :math:`z_1` is a zero and :math:`z_2` a value with opposite sign, then return negative zero.
+
+* Else if :math:`z_2` is a zero and :math:`z_1` a value with equal sign, then return positive infinity.
+
+* Else if :math:`z_2` is a zero and :math:`z_1` a value with opposite sign, then return negative infinity.
+
+* Else return the result of dividing :math:`z_2` by :math:`z_1`, :ref:`rounded <aux-ieee>` to the nearest representable value.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fdiv_N(\pm \NAN(n), z_2) &=& \nans_N\{\pm \NAN(n), z_2\} \\
+   \fdiv_N(z_1, \pm \NAN(n)) &=& \nans_N\{\pm \NAN(n), z_1\} \\
+   \fdiv_N(\pm \infty, \pm \infty) &=& \nans_N\{\} \\
+   \fdiv_N(\pm \infty, \mp \infty) &=& \nans_N\{\} \\
+   \fdiv_N(\pm 0, \pm 0) &=& \nans_N\{\} \\
+   \fdiv_N(\pm 0, \mp 0) &=& \nans_N\{\} \\
+   \fdiv_N(\pm \infty, \pm q_2) &=& +\infty \\
+   \fdiv_N(\pm \infty, \mp q_2) &=& -\infty \\
+   \fdiv_N(\pm q_1, \pm \infty) &=& +0 \\
+   \fdiv_N(\pm q_1, \mp \infty) &=& -0 \\
+   \fdiv_N(\pm 0, \pm q_2) &=& +0 \\
+   \fdiv_N(\pm 0, \mp q_2) &=& -0 \\
+   \fdiv_N(\pm q_1, \pm 0) &=& +\infty \\
+   \fdiv_N(\pm q_1, \mp 0) &=& -\infty \\
+   \fdiv_N(z_1, z_2) &=& \ieee_N(z_1 / z_2) \\
+   \end{array}
+
+
+.. _op-fmin:
+
+:math:`\fmin_N(z_1, z_2)`
+.........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return an element of :math:`\nans_N\{z_1, z_2\}`.
+
+* Else if one of :math:`z_1` or :math:`z_2` is a negative infinity, then return negative infinity.
+
+* Else if one of :math:`z_1` or :math:`z_2` is a positive infinity, then return the other value.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes of opposite signs, then return negative zero.
+
+* Else return the smaller value of :math:`z_1` and :math:`z_2`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fmin_N(\pm \NAN(n), z_2) &=& \nans_N\{\pm \NAN(n), z_2\} \\
+   \fmin_N(z_1, \pm \NAN(n)) &=& \nans_N\{\pm \NAN(n), z_1\} \\
+   \fmin_N(+ \infty, z_2) &=& z_2 \\
+   \fmin_N(- \infty, z_2) &=& - \infty \\
+   \fmin_N(z_1, + \infty) &=& z_1 \\
+   \fmin_N(z_1, - \infty) &=& - \infty \\
+   \fmin_N(\pm 0, \mp 0) &=& -0 \\
+   \fmin_N(z_1, z_2) &=& z_1 & (z_1 \leq z_2) \\
+   \fmin_N(z_1, z_2) &=& z_2 & (z_2 \leq z_1) \\
+   \end{array}
+
+
+.. _op-fmax:
+
+:math:`\fmax_N(z_1, z_2)`
+.........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return an element of :math:`\nans_N\{z_1, z_2\}`.
+
+* Else if one of :math:`z_1` or :math:`z_2` is a positive infinity, then return positive infinity.
+
+* Else if one of :math:`z_1` or :math:`z_2` is a negative infinity, then return the other value.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes of opposite signs, then return positive zero.
+
+* Else return the larger value of :math:`z_1` and :math:`z_2`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fmax_N(\pm \NAN(n), z_2) &=& \nans_N\{\pm \NAN(n), z_2\} \\
+   \fmax_N(z_1, \pm \NAN(n)) &=& \nans_N\{\pm \NAN(n), z_1\} \\
+   \fmax_N(+ \infty, z_2) &=& + \infty \\
+   \fmax_N(- \infty, z_2) &=& z_2 \\
+   \fmax_N(z_1, + \infty) &=& + \infty \\
+   \fmax_N(z_1, - \infty) &=& z_1 \\
+   \fmax_N(\pm 0, \mp 0) &=& +0 \\
+   \fmax_N(z_1, z_2) &=& z_1 & (z_1 \geq z_2) \\
+   \fmax_N(z_1, z_2) &=& z_2 & (z_2 \geq z_1) \\
+   \end{array}
+
+
+.. _op-fcopysign:
+
+:math:`\fcopysign_N(z_1, z_2)`
+..............................
+
+* If :math:`z_1` and :math:`z_2` have the same sign, then return :math:`z_1`.
+
+* Else return :math:`z_1` with negated sign.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fcopysign_N(\pm p_1, \pm p_2) &=& \pm p_1 \\
+   \fcopysign_N(\pm p_1, \mp p_2) &=& \mp p_1 \\
+   \end{array}
+
+
+.. _op-fabs:
+
+:math:`\fabs_N(z)`
+..................
+
+* If :math:`z` is a NaN, then return :math:`z` with positive sign.
+
+* Else if :math:`z` is an infinity, then return positive infinity.
+
+* Else if :math:`z` is a zero, then return positive zero.
+
+* Else if :math:`z` is a positive value, then :math:`z`.
+
+* Else return :math:`z` negated.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fabs_N(\pm \NAN(n)) &=& +\NAN(n) \\
+   \fabs_N(\pm \infty) &=& +\infty \\
+   \fabs_N(\pm 0) &=& +0 \\
+   \fabs_N(\pm q) &=& +q \\
+   \end{array}
+
+
+.. _op-fneg:
+
+:math:`\fneg_N(z)`
+..................
+
+* If :math:`z` is a NaN, then return :math:`z` with negated sign.
+
+* Else if :math:`z` is an infinity, then return that infinity negated.
+
+* Else if :math:`z` is a zero, then return that zero negated.
+
+* Else return :math:`z` negated.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fneg_N(\pm \NAN(n)) &=& \mp \NAN(n) \\
+   \fneg_N(\pm \infty) &=& \mp \infty \\
+   \fneg_N(\pm 0) &=& \mp 0 \\
+   \fneg_N(\pm q) &=& \mp q \\
+   \end{array}
+
+
+.. _op-fsqrt:
+
+:math:`\fsqrt_N(z)`
+...................
+
+* If :math:`z` is a NaN, then return an element of :math:`\nans_N\{z\}`.
+
+* Else if :math:`z` has a negative sign, then return an element of :math:`\nans_N\{z\}`.
+
+* Else if :math:`z` is positive infinity, then return positive infinity.
+
+* Else if :math:`z` is a zero, then return that zero.
+
+* Else return the square root of :math:`z`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fsqrt_N(\pm \NAN(n)) &=& \nans_N\{\pm \NAN(n)\} \\
+   \fsqrt_N(- \infty) &=& \nans_N\{\} \\
+   \fsqrt_N(+ \infty) &=& + \infty \\
+   \fsqrt_N(\pm 0) &=& \pm 0 \\
+   \fsqrt_N(- q) &=& \nans_N\{\} \\
+   \fsqrt_N(+ q) &=& \ieee_N\left(\sqrt{z}\right) \\
+   \end{array}
+
+
+.. _op-fceil:
+
+:math:`\fceil_N(z)`
+...................
+
+* If :math:`z` is a NaN, then return an element of :math:`\nans_N\{z\}`.
+
+* Else if :math:`z` is an infinity, then return :math:`z`.
+
+* Else if :math:`z` is a zero, then return :math:`z`.
+
+* Else if :math:`z` is smaller than :math:`0` but greater than :math:`-1`, then return negative zero.
+
+* Else return the smallest integral value that is not smaller than :math:`z`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fceil_N(\pm \NAN(n)) &=& \nans_N\{\pm \NAN(n)\} \\
+   \fceil_N(\pm \infty) &=& \pm \infty \\
+   \fceil_N(\pm 0) &=& \pm 0 \\
+   \fceil_N(- q) &=& -0 & (-1 < -q < 0) \\
+   \fceil_N(\pm q) &=& \ieee_N(i) & (\pm q \leq i < \pm q + 1) \\
+   \end{array}
+
+
+.. _op-ffloor:
+
+:math:`\ffloor_N(z)`
+....................
+
+* If :math:`z` is a NaN, then return an element of :math:`\nans_N\{z\}`.
+
+* Else if :math:`z` is an infinity, then return :math:`z`.
+
+* Else if :math:`z` is a zero, then return :math:`z`.
+
+* Else if :math:`z` is greater than :math:`0` but smaller than :math:`1`, then return positive zero.
+
+* Else return the largest integral value that is not larger than :math:`z`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ffloor_N(\pm \NAN(n)) &=& \nans_N\{\pm \NAN(n)\} \\
+   \ffloor_N(\pm \infty) &=& \pm \infty \\
+   \ffloor_N(\pm 0) &=& \pm 0 \\
+   \ffloor_N(+ q) &=& +0 & (0 < +q < 1) \\
+   \ffloor_N(\pm q) &=& \ieee_N(i) & (\pm q - 1 < i \leq \pm q) \\
+   \end{array}
+
+
+.. _op-ftrunc:
+
+:math:`\ftrunc_N(z)`
+....................
+
+* If :math:`z` is a NaN, then return an element of :math:`\nans_N\{z\}`.
+
+* Else if :math:`z` is an infinity, then return :math:`z`.
+
+* Else if :math:`z` is a zero, then return :math:`z`.
+
+* Else if :math:`z` is greater than :math:`0` but smaller than :math:`1`, then return positive zero.
+
+* Else if :math:`z` is smaller than :math:`0` but greater than :math:`-1`, then return negative zero.
+
+* Else return the integral value with the same sign as :math:`z` and the largest magnitude that is not larger than the magnitude of :math:`z`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \ftrunc_N(\pm \NAN(n)) &=& \nans_N\{\pm \NAN(n)\} \\
+   \ftrunc_N(\pm \infty) &=& \pm \infty \\
+   \ftrunc_N(\pm 0) &=& \pm 0 \\
+   \ftrunc_N(+ q) &=& +0 & (0 < +q < 1) \\
+   \ftrunc_N(- q) &=& -0 & (-1 < -q < 0) \\
+   \ftrunc_N(\pm q) &=& \ieee_N(\pm i) & (+q - 1 < i \leq +q) \\
+   \end{array}
+
+
+.. _op-fnearest:
+
+:math:`\fnearest_N(z)`
+......................
+
+* If :math:`z` is a NaN, then return an element of :math:`\nans_N\{z\}`.
+
+* Else if :math:`z` is an infinity, then return :math:`z`.
+
+* Else if :math:`z` is a zero, then return :math:`z`.
+
+* Else if :math:`z` is greater than :math:`0` but smaller than or equal to :math:`0.5`, then return positive zero.
+
+* Else if :math:`z` is smaller than :math:`0` but greater than or equal to :math:`-0.5`, then return negative zero.
+
+* Else return the integral value that is nearest to :math:`z`; if two values are equally near, return the even one.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fnearest_N(\pm \NAN(n)) &=& \nans_N\{\pm \NAN(n)\} \\
+   \fnearest_N(\pm \infty) &=& \pm \infty \\
+   \fnearest_N(\pm 0) &=& \pm 0 \\
+   \fnearest_N(+ q) &=& +0 & (0 < +q \leq 0.5) \\
+   \fnearest_N(- q) &=& -0 & (-0.5 \leq -q < 0) \\
+   \fnearest_N(\pm q) &=& \ieee_N(\pm i) & (|i - q| < 0.5) \\
+   \fnearest_N(\pm q) &=& \ieee_N(\pm i) & (|i - q| = 0.5 \wedge i~\mbox{even}) \\
+   \end{array}
+
+
+.. _op-feq:
+
+:math:`\feq_N(z_1, z_2)`
+........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return :math:`0`.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes, then return :math:`1`.
+
+* Else if both :math:`z_1` and :math:`z_2` are the same value, then return :math:`1`.
+
+* Else return :math:`0`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \feq_N(\pm \NAN(n), z_2) &=& 0 \\
+   \feq_N(z_1, \pm \NAN(n)) &=& 0 \\
+   \feq_N(\pm 0, \mp 0) &=& 1 \\
+   \feq_N(z, z) &=& 1 \\
+   \feq_N(z_1, z_2) &=& 0 \\
+   \end{array}
+
+
+.. _op-fne:
+
+:math:`\fne_N(z_1, z_2)`
+........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return :math:`0`.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes, then return :math:`0`.
+
+* Else if both :math:`z_1` and :math:`z_2` are the same value, then return :math:`0`.
+
+* Else return :math:`1`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fne_N(\pm \NAN(n), z_2) &=& 0 \\
+   \fne_N(z_1, \pm \NAN(n)) &=& 0 \\
+   \fne_N(\pm 0, \mp 0) &=& 0 \\
+   \fne_N(z, z) &=& 0 \\
+   \fne_N(z_1, z_2) &=& 1 \\
+   \end{array}
+
+
+.. _op-flt:
+
+:math:`\flt_N(z_1, z_2)`
+........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return :math:`0`.
+
+* Else if :math:`z_1` and :math:`z_2` are the same value, then return :math:`0`.
+
+* Else if :math:`z_1` is positive infinity, then return :math:`0`.
+
+* Else if :math:`z_1` is negative infinity, then return :math:`1`.
+
+* Else if :math:`z_2` is positive infinity, then return :math:`1`.
+
+* Else if :math:`z_2` is negative infinity, then return :math:`0`.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes, then return :math:`0`.
+
+* Else if :math:`z_1` is smaller than :math:`z_2`, then return :math:`1`.
+
+* Else return :math:`0`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \flt_N(\pm \NAN(n), z_2) &=& 0 \\
+   \flt_N(z_1, \pm \NAN(n)) &=& 0 \\
+   \flt_N(z, z) &=& 0 \\
+   \flt_N(+ \infty, z_2) &=& 0 \\
+   \flt_N(- \infty, z_2) &=& 1 \\
+   \flt_N(z_1, + \infty) &=& 1 \\
+   \flt_N(z_1, - \infty) &=& 0 \\
+   \flt_N(\pm 0, \mp 0) &=& 0 \\
+   \flt_N(z_1, z_2) &=& \bool(z_1 < z_2) \\
+   \end{array}
+
+
+.. _op-fgt:
+
+:math:`\fgt_N(z_1, z_2)`
+........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return :math:`0`.
+
+* Else if :math:`z_1` and :math:`z_2` are the same value, then return :math:`0`.
+
+* Else if :math:`z_1` is positive infinity, then return :math:`1`.
+
+* Else if :math:`z_1` is negative infinity, then return :math:`0`.
+
+* Else if :math:`z_2` is positive infinity, then return :math:`0`.
+
+* Else if :math:`z_2` is negative infinity, then return :math:`1`.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes, then return :math:`0`.
+
+* Else if :math:`z_1` is larger than :math:`z_2`, then return :math:`1`.
+
+* Else return :math:`0`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fgt_N(\pm \NAN(n), z_2) &=& 0 \\
+   \fgt_N(z_1, \pm \NAN(n)) &=& 0 \\
+   \fgt_N(z, z) &=& 0 \\
+   \fgt_N(+ \infty, z_2) &=& 1 \\
+   \fgt_N(- \infty, z_2) &=& 0 \\
+   \fgt_N(z_1, + \infty) &=& 0 \\
+   \fgt_N(z_1, - \infty) &=& 1 \\
+   \fgt_N(\pm 0, \mp 0) &=& 0 \\
+   \fgt_N(z_1, z_2) &=& \bool(z_1 > z_2) \\
+   \end{array}
+
+
+.. _op-fle:
+
+:math:`\fle_N(z_1, z_2)`
+........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return :math:`0`.
+
+* Else if :math:`z_1` and :math:`z_2` are the same value, then return :math:`1`.
+
+* Else if :math:`z_1` is positive infinity, then return :math:`0`.
+
+* Else if :math:`z_1` is negative infinity, then return :math:`1`.
+
+* Else if :math:`z_2` is positive infinity, then return :math:`1`.
+
+* Else if :math:`z_2` is negative infinity, then return :math:`0`.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes, then return :math:`1`.
+
+* Else if :math:`z_1` is smaller than or equal to :math:`z_2`, then return :math:`1`.
+
+* Else return :math:`0`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fle_N(\pm \NAN(n), z_2) &=& 0 \\
+   \fle_N(z_1, \pm \NAN(n)) &=& 0 \\
+   \fle_N(z, z) &=& 1 \\
+   \fle_N(+ \infty, z_2) &=& 0 \\
+   \fle_N(- \infty, z_2) &=& 1 \\
+   \fle_N(z_1, + \infty) &=& 1 \\
+   \fle_N(z_1, - \infty) &=& 0 \\
+   \fle_N(\pm 0, \mp 0) &=& 1 \\
+   \fle_N(z_1, z_2) &=& \bool(z_1 \leq z_2) \\
+   \end{array}
+
+
+.. _op-fge:
+
+:math:`\fge_N(z_1, z_2)`
+........................
+
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return :math:`0`.
+
+* Else if :math:`z_1` and :math:`z_2` are the same value, then return :math:`1`.
+
+* Else if :math:`z_1` is positive infinity, then return :math:`1`.
+
+* Else if :math:`z_1` is negative infinity, then return :math:`0`.
+
+* Else if :math:`z_2` is positive infinity, then return :math:`0`.
+
+* Else if :math:`z_2` is negative infinity, then return :math:`1`.
+
+* Else if both :math:`z_1` and :math:`z_2` are zeroes, then return :math:`1`.
+
+* Else if :math:`z_1` is smaller than or equal to :math:`z_2`, then return :math:`1`.
+
+* Else return :math:`0`.
+
+.. math::
+   \begin{array}{@{}lcll}
+   \fge_N(\pm \NAN(n), z_2) &=& 0 \\
+   \fge_N(z_1, \pm \NAN(n)) &=& 0 \\
+   \fge_N(z, z) &=& 1 \\
+   \fge_N(+ \infty, z_2) &=& 1 \\
+   \fge_N(- \infty, z_2) &=& 0 \\
+   \fge_N(z_1, + \infty) &=& 0 \\
+   \fge_N(z_1, - \infty) &=& 1 \\
+   \fge_N(\pm 0, \mp 0) &=& 1 \\
+   \fge_N(z_1, z_2) &=& \bool(z_1 \geq z_2) \\
+   \end{array}
+
+
+Conversions
+~~~~~~~~~~~
+
+.. _op-extendu:
+
+:math:`\extendu_{M,N}(i)`
+.........................
+
+* Return :math:`i`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \extendu_{M,N}(i) &=& i \\
+   \end{array}
+
+.. note::
+   In the abstract syntax, unsigned extension just reinterprets the same value.
+
+
+.. _op-extends:
+
+:math:`\extends_{M,N}(i)`
+.........................
+
+* Let :math:`j` be the signed interpretation of :math:`i` of size :math:`M`.
+
+* Return the 2's complement of :math:`j` relative to size :math:`N`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \extends_{M,N}(i) &=& \signed_N^{-1}(\signed_M(i)) \\
+   \end{array}
+
+
+.. _op-wrap:
+
+:math:`\wrap_{M,N}(i)`
+......................
+
+* Return :math:`i` modulo :math:`N`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \wrap_{M,N}(i) &=& i \mod 2^N \\
+   \end{array}
+
+
+.. _op-truncu:
+
+:math:`\truncu_{M,N}(z)`
+........................
+
+* If :math:`z` is a NaN, then the result is undefined. 
+
+* Else if :math:`z` is an infinity, then the result is undefined. 
+
+* Else if :math:`z` is a number and :math:`\trunc(z)` is a value within range of the target type, then return that value.
+
+* Else the result is undefined.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \truncu_{M,N}(\pm \NAN(n)) &=& \{\} \\
+   \truncu_{M,N}(\pm \infty) &=& \{\} \\
+   \truncu_{M,N}(\pm q) &=& \trunc(\pm q) & (-1 < \trunc(\pm q) < 2^N) \\
+   \truncu_{M,N}(\pm q) &=& \{\} & (\mbox{otherwise}) \\
+   \end{array}
+
+.. note::
+   This operator is :ref:`partial <exec-op-partial>`.
+   It is not defined for NaNs, infinities, or values for which the result is out of range.
+
+
+.. _op-truncs:
+
+:math:`\truncs_{M,N}(z)`
+........................
+
+* If :math:`z` is a NaN, then the result is undefined. 
+
+* Else if :math:`z` is an infinity, then the result is undefined. 
+
+* If :math:`z` is a number and :math:`\trunc(z)` is a value within range of the target type, then return that value.
+
+* Else the result is undefined.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \truncs_{M,N}(\pm \NAN(n)) &=& \{\} \\
+   \truncs_{M,N}(\pm \infty) &=& \{\} \\
+   \truncs_{M,N}(\pm q) &=& \trunc(\pm q) & (- 2^{N-1} - 1 < \trunc(\pm q) < 2^{N-1}) \\
+   \truncs_{M,N}(\pm q) &=& \{\} & (\mbox{otherwise}) \\
+   \end{array}
+
+.. note::
+   This operator is :ref:`partial <exec-op-partial>`.
+   It is not defined for NaNs, infinities, or values for which the result is out of range.
+
+
+.. _op-promote:
+
+:math:`\promote_{M,N}(z)`
+.........................
+
+* If :math:`z` is a :ref:`canonical NaN <canonical-nan>`, then return a element of :math:`\nans_N\{\}` (i.e., a canonical NaN of size :math:`N`).
+
+* Else if :math:`z` is a NaN, then return a element of :math:`\nans_N\{\pm \NAN(1)\}` (i.e., any NaN of size :math:`N`).
+
+* Else, return :math:`z`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \promote_{M,N}(\pm \NAN(n)) &=& \nans_N\{\} & (n = \canon_N) \\
+   \promote_{M,N}(\pm \NAN(n)) &=& \nans_N\{+ \NAN(1)\} & (\mbox{otherwise}) \\
+   \promote_{M,N}(z) &=& z \\
+   \end{array}
+
+
+.. _op-demote:
+
+:math:`\demote_{M,N}(z)`
+........................
+
+* If :math:`z` is a :ref:`canonical NaN <canonical-nan>`, then return a element of :math:`\nans_N\{\}` (i.e., a canonical NaN of size :math:`N`).
+
+* Else if :math:`z` is a NaN, then return a element of :math:`\nans_N\{\pm \NAN(1)\}` (i.e., any NaN of size :math:`N`).
+
+* Else if :math:`z` is an infinity, then return that infinity.
+
+* Else if :math:`z` is a zero, then return that zero.
+
+* Else, return :math:`\ieee_N(z)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \demote_{M,N}(\pm \NAN(n)) &=& \nans_N\{\} & (n = \canon_N) \\
+   \demote_{M,N}(\pm \NAN(n)) &=& \nans_N\{+ \NAN(1)\} & (\mbox{otherwise}) \\
+   \demote_{M,N}(\pm \infty) &=& \pm \infty \\
+   \demote_{M,N}(\pm 0) &=& \pm 0 \\
+   \demote_{M,N}(\pm q) &=& \ieee_N(\pm q) \\
+   \end{array}
+
+
+.. _op-convertu:
+
+:math:`\convertu_{M,N}(i)`
+..........................
+
+* Return :math:`\ieee_N(i)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \convertu_{M,N}(i) &=& \ieee_N(i) \\
+   \end{array}
+
+
+.. _op-converts:
+
+:math:`\converts_{M,N}(i)`
+..........................
+
+* Let :math:`j` be the signed interpretation of :math:`i`.
+
+* Return :math:`\ieee_N(j)`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \convertu_{M,N}(i) &=& \ieee_N(\signed_M(i)) \\
+   \end{array}
+
+
+.. _op-reinterpret:
+
+:math:`\reinterpret_{t_1,t_2}(c)`
+.................................
+
+* Let :math:`d^\ast` be the bit sequence :math:`\bits_{t_1}(c)`.
+
+* Return the constant :math:`c'` for which :math:`\bits_{t_2}(c') = d^\ast`.
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \reinterpret_{t_1,t_2}(c) &=& \bits_{t_2}^{-1}(\bits_{t_1}(c)) \\
+   \end{array}
diff --git a/document/math.def b/document/math.def
index bbde450ac..45356c60d 100644
--- a/document/math.def
+++ b/document/math.def
@@ -22,6 +22,7 @@
 .. Auxiliary definitions for grammars
 
 .. |production| mathdef:: \void
+
 .. |concat| mathdef:: \xref{syntax/conventions}{syntax-concat}{\F{concat}}
 .. |with| mathdef:: \xref{syntax/conventions}{syntax-record}{\mathrel{\mbox{with}}}
 .. |compose| mathdef:: \xref{syntax/conventions}{syntax-record}{\oplus}
@@ -66,6 +67,8 @@
 .. |hex#1| mathdef:: \mathtt{0x#1}
 .. |unicode#1| mathdef:: \mathrm{U{+}#1}
 
+.. |NAN| mathdef:: \xref{syntax/values}{syntax-float}{\K{nan}}
+
 
 .. Values, non-terminals
 
@@ -77,6 +80,7 @@
 .. |fX#1| mathdef:: {\X{f}#1}
 
 .. |uN| mathdef:: \xref{syntax/values}{syntax-int}{\uX{N}}
+.. |uM| mathdef:: \xref{syntax/values}{syntax-int}{\uX{M}}
 .. |u1| mathdef:: \xref{syntax/values}{syntax-int}{\uX{\X{1}}}
 .. |u8| mathdef:: \xref{syntax/values}{syntax-int}{\uX{\X{8}}}
 .. |u16| mathdef:: \xref{syntax/values}{syntax-int}{\uX{\X{16}}}
@@ -94,6 +98,7 @@
 .. |i64| mathdef:: \xref{syntax/values}{syntax-int}{\iX{\X{64}}}
 
 .. |fN| mathdef:: \xref{syntax/values}{syntax-float}{\fX{N}}
+.. |fNmag| mathdef:: \xref{syntax/values}{syntax-float}{\fX{\X{Nmag}}}
 .. |f32| mathdef:: \xref{syntax/values}{syntax-float}{\fX{\X{32}}}
 .. |f64| mathdef:: \xref{syntax/values}{syntax-float}{\fX{\X{64}}}
 
@@ -172,6 +177,7 @@
 .. |Ti64| mathdef:: \xref{text/values}{text-int}{\TiX{\T{64}}}
 
 .. |TfN| mathdef:: \xref{text/values}{text-float}{\TfX{N}}
+.. |TfNmag| mathdef:: \xref{text/values}{text-float}{\TfX{N}\T{mag}}
 .. |Tf32| mathdef:: \xref{text/values}{text-float}{\TfX{\T{32}}}
 .. |Tf64| mathdef:: \xref{text/values}{text-float}{\TfX{\T{64}}}
 
@@ -586,15 +592,90 @@
 .. |stepto| mathdef:: \hookrightarrow
 .. |mod| mathdef:: \mathbin{\F{mod}}
 
+
 .. Numerics, meta functions
 
+.. |bits| mathdef:: \xref{execution/numerics}{aux-bits}{\F{bits}}
+.. |ibits| mathdef:: \xref{execution/numerics}{aux-ibits}{\F{ibits}}
+.. |fbits| mathdef:: \xref{execution/numerics}{aux-fbits}{\F{fbits}}
+.. |fsign| mathdef:: \xref{execution/numerics}{aux-fsign}{\F{fsign}}
+.. |fbias| mathdef:: \xref{execution/numerics}{aux-fbias}{\F{fbias}}
 .. |bytes| mathdef:: \xref{execution/numerics}{aux-bytes}{\F{bytes}}
+.. |littleendian| mathdef:: \xref{execution/numerics}{aux-littleendian}{\F{littleendian}}
 .. |signed| mathdef:: \xref{execution/numerics}{aux-signed}{\F{signed}}
-.. |extend| mathdef:: \xref{execution/numerics}{aux-extend}{\F{extend}}
-.. |wrap| mathdef:: \xref{execution/numerics}{aux-wrap}{\F{wrap}}
-
-.. todo...
-
-.. |ieee| mathdef:: \F{ieee}
-.. |ieeeinf| mathdef:: \F{ieeeinf}
-.. |ieeenan| mathdef:: \F{ieeenan}
+.. |bool| mathdef:: \xref{execution/numerics}{aux-bool}{\F{bool}}
+
+.. |ieee| mathdef:: \xref{execution/numerics}{aux-ieee}{\F{float}}
+.. |nans| mathdef:: \xref{execution/numerics}{aux-nans}{\F{nans}}
+.. |canon| mathdef:: \xref{syntax/values}{aux-canon}{\F{canon}}
+
+.. |significand| mathdef:: \xref{syntax/values}{aux-significand}{\F{signif}}
+.. |exponent| mathdef:: \xref{syntax/values}{aux-exponent}{\F{expon}}
+
+
+.. Numerics, operators
+
+.. |iadd| mathdef:: \xref{execution/numerics}{op-iadd}{\F{iadd}}
+.. |isub| mathdef:: \xref{execution/numerics}{op-isub}{\F{isub}}
+.. |imul| mathdef:: \xref{execution/numerics}{op-imul}{\F{imul}}
+.. |idivu| mathdef:: \xref{execution/numerics}{op-idiv_u}{\F{idiv\_u}}
+.. |idivs| mathdef:: \xref{execution/numerics}{op-idiv_s}{\F{idiv\_s}}
+.. |iremu| mathdef:: \xref{execution/numerics}{op-irem_u}{\F{irem\_u}}
+.. |irems| mathdef:: \xref{execution/numerics}{op-irem_s}{\F{irem\_s}}
+.. |iand| mathdef:: \xref{execution/numerics}{op-iand}{\F{iand}}
+.. |ior| mathdef:: \xref{execution/numerics}{op-ior}{\F{ior}}
+.. |ixor| mathdef:: \xref{execution/numerics}{op-ixor}{\F{ixor}}
+.. |ishl| mathdef:: \xref{execution/numerics}{op-ishl}{\F{ishl}}
+.. |ishru| mathdef:: \xref{execution/numerics}{op-ishr_u}{\F{ishr\_u}}
+.. |ishrs| mathdef:: \xref{execution/numerics}{op-ishr_s}{\F{ishr\_s}}
+.. |irotl| mathdef:: \xref{execution/numerics}{op-irotl}{\F{irotl}}
+.. |irotr| mathdef:: \xref{execution/numerics}{op-irotr}{\F{irotr}}
+.. |iclz| mathdef:: \xref{execution/numerics}{op-iclz}{\F{iclz}}
+.. |ictz| mathdef:: \xref{execution/numerics}{op-ictz}{\F{ictz}}
+.. |ipopcnt| mathdef:: \xref{execution/numerics}{op-ipopcnt}{\F{ipopcnt}}
+.. |ieqz| mathdef:: \xref{execution/numerics}{op-ieqz}{\F{ieqz}}
+.. |ieq| mathdef:: \xref{execution/numerics}{op-ieq}{\F{ieq}}
+.. |ine| mathdef:: \xref{execution/numerics}{op-ine}{\F{ine}}
+.. |iltu| mathdef:: \xref{execution/numerics}{op-ilt_u}{\F{ilt\_u}}
+.. |ilts| mathdef:: \xref{execution/numerics}{op-ilt_s}{\F{ilt\_s}}
+.. |igtu| mathdef:: \xref{execution/numerics}{op-igt_u}{\F{igt\_u}}
+.. |igts| mathdef:: \xref{execution/numerics}{op-igt_s}{\F{igt\_s}}
+.. |ileu| mathdef:: \xref{execution/numerics}{op-ile_u}{\F{ile\_u}}
+.. |iles| mathdef:: \xref{execution/numerics}{op-ile_s}{\F{ile\_s}}
+.. |igeu| mathdef:: \xref{execution/numerics}{op-ige_u}{\F{ige\_u}}
+.. |iges| mathdef:: \xref{execution/numerics}{op-ige_s}{\F{ige\_s}}
+
+.. |fadd| mathdef:: \xref{execution/numerics}{op-fadd}{\F{fadd}}
+.. |fsub| mathdef:: \xref{execution/numerics}{op-fsub}{\F{fsub}}
+.. |fmul| mathdef:: \xref{execution/numerics}{op-fmul}{\F{fmul}}
+.. |fdiv| mathdef:: \xref{execution/numerics}{op-fdiv}{\F{fdiv}}
+.. |fmin| mathdef:: \xref{execution/numerics}{op-fmin}{\F{fmin}}
+.. |fmax| mathdef:: \xref{execution/numerics}{op-fmax}{\F{fmax}}
+.. |fcopysign| mathdef:: \xref{execution/numerics}{op-fcopysign}{\F{fcopysign}}
+.. |fabs| mathdef:: \xref{execution/numerics}{op-fabs}{\F{fabs}}
+.. |fneg| mathdef:: \xref{execution/numerics}{op-fneg}{\F{fneg}}
+.. |fsqrt| mathdef:: \xref{execution/numerics}{op-fsqrt}{\F{fsqrt}}
+.. |fceil| mathdef:: \xref{execution/numerics}{op-fceil}{\F{fceil}}
+.. |ffloor| mathdef:: \xref{execution/numerics}{op-ffloor}{\F{ffloor}}
+.. |ftrunc| mathdef:: \xref{execution/numerics}{op-ftrunc}{\F{ftrunc}}
+.. |fnearest| mathdef:: \xref{execution/numerics}{op-fnearest}{\F{fnearest}}
+.. |feq| mathdef:: \xref{execution/numerics}{op-feq}{\F{feq}}
+.. |fne| mathdef:: \xref{execution/numerics}{op-fne}{\F{fne}}
+.. |flt| mathdef:: \xref{execution/numerics}{op-flt}{\F{flt}}
+.. |fgt| mathdef:: \xref{execution/numerics}{op-fgt}{\F{fgt}}
+.. |fle| mathdef:: \xref{execution/numerics}{op-fle}{\F{fle}}
+.. |fge| mathdef:: \xref{execution/numerics}{op-fge}{\F{fge}}
+
+.. |extend| mathdef:: \xref{execution/numerics}{op-extend_u}{\F{extend}}
+.. |extendu| mathdef:: \xref{execution/numerics}{op-extend_u}{\F{extend\_u}}
+.. |extends| mathdef:: \xref{execution/numerics}{op-extend_s}{\F{extend\_s}}
+.. |wrap| mathdef:: \xref{execution/numerics}{op-wrap}{\F{wrap}}
+.. |truncu| mathdef:: \xref{execution/numerics}{op-trunc_u}{\F{trunc\_u}}
+.. |truncs| mathdef:: \xref{execution/numerics}{op-trunc_s}{\F{trunc\_s}}
+.. |promote| mathdef:: \xref{execution/numerics}{op-promote}{\F{promote}}
+.. |demote| mathdef:: \xref{execution/numerics}{op-demote}{\F{demote}}
+.. |convertu| mathdef:: \xref{execution/numerics}{op-convert_u}{\F{convert\_u}}
+.. |converts| mathdef:: \xref{execution/numerics}{op-convert_s}{\F{convert\_s}}
+.. |reinterpret| mathdef:: \xref{execution/numerics}{op-reinterpret}{\F{reinterpret}}
+
+.. |trunc| mathdef:: \xref{execution/numerics}{aux-trunc}{\F{trunc}}
diff --git a/document/syntax/instructions.rst b/document/syntax/instructions.rst
index afd5f694f..f7eada93f 100644
--- a/document/syntax/instructions.rst
+++ b/document/syntax/instructions.rst
@@ -245,7 +245,7 @@ Instructions in this group are concerned with :ref:`linear memory <syntax-mem>`.
 
 Memory is accessed with |LOAD| and |STORE| instructions for the different :ref:`value types <syntax-valtype>`.
 They all take a *memory immediate* |memarg| that contains an address *offset* and an *alignment* hint.
-Integer loads and stores can optionally specify a *storage size* that is smaller than the width of the respective value type.
+Integer loads and stores can optionally specify a *storage size* that is smaller than the :ref:`width <syntax-valtype>` of the respective value type.
 In the case of loads, a sign extension mode |sx| is then required to select appropriate behavior.
 
 The static address offset is added to the dynamic address operand, yielding a 33 bit *effective address* that is the zero-based index at which the memory is accessed.
diff --git a/document/syntax/types.rst b/document/syntax/types.rst
index 669a471c5..73495faa4 100644
--- a/document/syntax/types.rst
+++ b/document/syntax/types.rst
@@ -22,10 +22,10 @@ Value Types
      \I32 ~|~ \I64 ~|~ \F32 ~|~ \F64 \\
    \end{array}
 
-The types |i32| and |i64| classify 32 and 64 bit integers, respectively.
+The types |I32| and |I64| classify 32 and 64 bit integers, respectively.
 Integers are not inherently signed or unsigned, their interpretation is determined by individual operations.
 
-The types |f32| and |f64| classify 32 and 64 bit floating points, respectively.
+The types |F32| and |F64| classify 32 and 64 bit floating points, respectively.
 They correspond to single and double precision floating point types as defined by the `IEEE-754 <http://ieeexplore.ieee.org/document/4610935/>`_ standard
 
 Conventions
@@ -33,8 +33,8 @@ Conventions
 
 * The meta variable :math:`t` ranges over value types where clear from context.
 
-* The notation :math:`|t|` denotes the *width* of a value type in bytes.
-  (That is, :math:`|\I32| = |\F32| = 4` and :math:`|\I64| = |\F64| = 8`.)
+* The notation :math:`|t|` denotes the *width* of a value type.
+  (That is, :math:`|\I32| = |\F32| = 32` and :math:`|\I64| = |\F64| = 64`.)
 
 
 .. _syntax-resulttype:
diff --git a/document/syntax/values.rst b/document/syntax/values.rst
index 89ecfe8d5..2af3b48af 100644
--- a/document/syntax/values.rst
+++ b/document/syntax/values.rst
@@ -60,7 +60,7 @@ Different classes of *integers* with different value ranges are distinguished by
 
 The latter class defines *uninterpreted* integers, whose signedness interpretation can vary depending on context.
 In the abstract syntax, they are represented as unsigned.
-However, some operations :ref:`convert <aux-signed>` them to signed based on a 2's complement interpretation.
+However, some operations :ref:`convert <aux-signed>` them to signed based on a two's complement interpretation.
 
 
 Conventions
@@ -72,21 +72,70 @@ Conventions
 
 
 .. _syntax-float:
-.. index:: ! floating-point number
+.. _syntax-nan:
+.. _syntax-payload:
+.. index:: ! floating-point number, ! NaN, payload, canonical NaN, arithmetic NaN
    pair: abstract syntax; floating-point number
+   single: NaN; payload
+   single: NaN; canonical
+   single: NaN; arithmetic
 
 Floating-Point
 ~~~~~~~~~~~~~~
 
-*Floating-point* data consists of values in binary floating-point format according to the `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ standard.
+*Floating-point* data consists of 32 or 64 bit values according to the `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ standard.
+Every value has a *sign* and a *magnitude*.
+
+Magnitudes can either be expressed as *normal* numbers of the form :math:`m_0.m_1m_2\dots m_M \cdot2^e`, where :math:`m` is the *significand* whose most signifcant bit :math:`m_0` is :math:`1`, and :math:`e` is the exponent,
+or as a *subnormal* number where :math:`m_0` is :math:`0` and the exponent is fixed to the smallest possible value; among the subnormals are positive and negative zero.
+Since the significands are binary values, normals are represented in the form :math:`(1 + m\cdot 2^{-M})`, where :math:`M` is the bit width of :math:`m`; similarly for subnormals.
+
+Possible magnitudes also include the special values :math:`\infty` (infinity) and |NAN| (*NaN*, not a number).
+NaN values have a *payload* value that describes the mantissa bits in the underlying :ref:`binary representation <aux-fbits>`.
+No distinction is made between signalling and quiet NaNs.
 
 .. math::
-   \begin{array}{llll}
+   \begin{array}{llcll}
    \production{floating-point number} & \fN &::=&
-     \byte^{N/8} \\
+     {+} \fNmag ~|~ {-} \fNmag \\
+   \production{floating-point magnitude} & \fNmag &::=&
+     (1 + \uM\cdot 2^{-M}) \cdot 2^e & (M = \significand(N) \wedge -2^{\exponent(N)-1}+2 \leq e \leq 2^{\exponent(N)-1}-1) \\ &&|&
+     (0 + \uM\cdot 2^{-M}) \cdot 2^e & (M = \significand(N) \wedge e = -2^{\exponent(N)-1}+2) \\ &&|&
+     \infty \\ &&|&
+     \NAN(n) & (1 \leq n < 2^{\significand(N)}) \\
    \end{array}
 
-The two possible sizes :math:`N` are 32 and 64.
+where
+
+.. _aux-significand:
+.. _aux-exponent:
+
+.. math::
+   \begin{array}{lclllllcl}
+   \significand(32) &=& 23 &&&&
+   \exponent(32) &=& 8 \\
+   \significand(64) &=& 52 &&&&
+   \exponent(64) &=& 11 \\
+   \end{array}
+
+.. _canonical-nan:
+.. _arithmetic-nan:
+.. _aux-canon:
+
+A *canonical NaN* is a floating-point value :math:`\pm\NAN(\canon_N)` where :math:`\canon_N` is a payload whose most significant bit is :math:`1` while all others are :math:`0`:
+
+.. math::
+   \canon_N = 2^{\significand_N-1}
+
+An *arithmetic NaN*  is a floating-point value :math:`\pm\NAN(n)` with :math:`n > \canon_N`, such that the most significant bit is :math:`1` while all others are arbitrary.
+
+
+Conventions
+...........
+
+* The meta variable :math:`z` ranges over floating-point values where clear from context.
+
+* Floating-point numbers, in normal or subnormal form, are sometimes interpreted as rational numbers :math:`q \in \mathbb{Q}`.
 
 
 .. _syntax-vec:
diff --git a/document/text/values.rst b/document/text/values.rst
index 77ae23684..a07d99c07 100644
--- a/document/text/values.rst
+++ b/document/text/values.rst
@@ -29,9 +29,9 @@ All :ref:`integers <syntax-int>` can be written in either decimal or hexadecimal
 .. math::
    \begin{array}{llclll@{\qquad}l}
    \production{sign} & \Tsign &::=&
-     \epsilon \Rightarrow {+}1 ~~|~~
-     \text{+} \Rightarrow {+}1 ~~|~~
-     \text{-} \Rightarrow {-}1 \\
+     \epsilon \Rightarrow {+} ~~|~~
+     \text{+} \Rightarrow {+} ~~|~~
+     \text{-} \Rightarrow {-} \\
    \production{decimal digit} & \Tdigit &::=&
      \text{0} \Rightarrow 0 ~~|~~ \dots ~~|~~ \text{9} \Rightarrow 9 \\
    \production{hexadecimal digit} & \Thexdigit &::=&
@@ -59,8 +59,8 @@ Moreover, their value must lie within the range of the respective type.
      n{:}\Tnum &\Rightarrow& n & (n < 2^N) \\ &&|&
      \text{0x}~~n{:}\Thexnum &\Rightarrow& n & (n < 2^N) \\
    \production{signed integer} & \TsN &::=&
-     s{:}\Tsign~~n{:}\Tnum &\Rightarrow& s\cdot n & (-2^{N-1} \leq s\cdot n < 2^{N-1}) \\ &&|&
-     s{:}\Tsign~~\text{0x}~~n{:}\Thexnum &\Rightarrow& s\cdot n & (-2^{N-1} \leq s\cdot n < 2^{N-1}) \\
+     {\pm}{:}\Tsign~~n{:}\Tnum &\Rightarrow& \pm n & (-2^{N-1} \leq \pm n < 2^{N-1}) \\ &&|&
+     {\pm}{:}\Tsign~~\text{0x}~~n{:}\Thexnum &\Rightarrow& \pm n & (-2^{N-1} \leq \pm n < 2^{N-1}) \\
    \end{array}
 
 :ref:`Uninterpreted integers <syntax-int>` can be written as either signed or unsigned, and are normalized to unsigned in the abstract syntax.
@@ -86,7 +86,7 @@ Floating-Point
 :ref:`Floating point <syntax-float>` values can be represented in either decimal or hexadecimal notation.
 The value of a literal must not lie outside the representable range of the corresponding `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ type
 (that is, a numeric value must not overflow to :math:`\pm\mbox{infinity}`),
-but it may be rounded to the nearest representable value.
+but it may be :ref:`rounded <aux-ieee>` to the nearest representable value.
 
 .. note::
    Rounding can be prevented by using hexadecimal notation with no more significant bits than supported by the required type.
@@ -103,29 +103,29 @@ Furthermore, arbitrary NaN values may be expressed by providing an explicit payl
      \epsilon &\Rightarrow& 0 \\ &&|&
      h{:}\Thexdigit~q{:}\Thexfrac &\Rightarrow& (h+q)/16 \\
    \production{decimal floating-point number} & \Tfloat &::=&
-     s{:}\Tsign~p{:}\Tnum~\text{.}~q{:}\Tfrac
-       &\Rightarrow& s\cdot(p+q) \\ &&|&
-     s{:}\Tsign~p{:}\Tnum~(\text{E}~|~\text{e})~t{:}\Tsign~e{:}\Tnum
-       &\Rightarrow& s\cdot p\cdot 10^{t\cdot e} \\ &&|&
-     s{:}\Tsign~p{:}\Tnum~\text{.}~q{:}\Tfrac~(\text{E}~|~\text{e})~t{:}\Tsign~e{:}\Tnum
-       &\Rightarrow& s\cdot(p+q)\cdot 10^{t\cdot e} \\
+     p{:}\Tnum~\text{.}~q{:}\Tfrac
+       &\Rightarrow& p+q \\ &&|&
+     p{:}\Tnum~(\text{E}~|~\text{e})~{\pm}{:}\Tsign~e{:}\Tnum
+       &\Rightarrow& p\cdot 10^{\pm e} \\ &&|&
+     p{:}\Tnum~\text{.}~q{:}\Tfrac~(\text{E}~|~\text{e})~{\pm}{:}\Tsign~e{:}\Tnum
+       &\Rightarrow& (p+q)\cdot 10^{\pm e} \\
    \production{hexadecimal floating-point number} & \Thexfloat &::=&
-     s{:}\Tsign~\text{0x}~p{:}\Thexnum~\text{.}~q{:}\Thexfrac
-       &\Rightarrow& s\cdot(p+q) \\ &&|&
-     s{:}\Tsign~\text{0x}~p{:}\Thexnum~(\text{P}~|~\text{p})~t{:}\Tsign~e{:}\Tnum
-       &\Rightarrow& s\cdot p\cdot 2^{t\cdot e} \\ &&|&
-     s{:}\Tsign~\text{0x}~p{:}\Thexnum~\text{.}~q{:}\Thexfrac~(\text{P}~|~\text{p})~t{:}\Tsign~e{:}\Tnum
-       &\Rightarrow& s\cdot(p+q)\cdot 2^{t\cdot e} \\
+     \text{0x}~p{:}\Thexnum~\text{.}~q{:}\Thexfrac
+       &\Rightarrow& p+q \\ &&|&
+     \text{0x}~p{:}\Thexnum~(\text{P}~|~\text{p})~{\pm}{:}\Tsign~e{:}\Tnum
+       &\Rightarrow& p\cdot 2^{\pm e} \\ &&|&
+     \text{0x}~p{:}\Thexnum~\text{.}~q{:}\Thexfrac~(\text{P}~|~\text{p})~{\pm}{:}\Tsign~e{:}\Tnum
+       &\Rightarrow& (p+q)\cdot 2^{\pm e} \\
+   \production{floating-point value} & \TfNmag &::=&
+     z{:}\Tfloat &\Rightarrow& \ieee_N(z) & (\ieee_N(z) \neq \pm \infty) \\ &&|&
+     z{:}\Thexfloat &\Rightarrow& \ieee_N(z) & (\ieee_N(z) \neq \pm \infty) \\ &&|&
+     \text{inf} &\Rightarrow& \infty \\ &&|&
+     \text{nan} &\Rightarrow& \NAN(2^{\significand(N)-1}) \\ &&|&
+     \text{nan{:}0x}~n{:}\Thexnum &\Rightarrow& \NAN(n) & (1 \leq n < 2^{\significand(N)}) \\
    \production{floating-point value} & \TfN &::=&
-     z{:}\Tfloat &\Rightarrow& \ieee_N(z) \\ &&|&
-     z{:}\Thexfloat &\Rightarrow& \ieee_N(z) \\ &&|&
-     s{:}\Tsign~\text{inf} &\Rightarrow& \ieeeinf_N(s) \\ &&|&
-     s{:}\Tsign~\text{nan} &\Rightarrow& \ieeenan_N(s, 0) \\ &&|&
-     s{:}\Tsign~\text{nan{:}}~\text{0x}~n{:}\Thexnum &\Rightarrow& b^\ast & (\ieeenan_N(s, n) = b^\ast) \\
+     {\pm}{:}\Tsign~z{:}\TfNmag &\Rightarrow& \pm z \\
    \end{array}
 
-.. todo:: IEEE encoding helper functions
-
 
 .. _text-vec:
 .. index:: vector
diff --git a/document/validation/instructions.rst b/document/validation/instructions.rst
index 3cd9d04a1..60d743677 100644
--- a/document/validation/instructions.rst
+++ b/document/validation/instructions.rst
@@ -314,7 +314,7 @@ Memory Instructions
 
 * The memory :math:`C.\MEMS[0]` must be defined in the context.
 
-* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`width <syntax-valtype>` of :math:`t`.
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`width <syntax-valtype>` of :math:`t` divided by :math:`8`.
 
 * Then the instruction is valid with type :math:`[\I32] \to [t]`.
 
@@ -322,7 +322,7 @@ Memory Instructions
    \frac{
      C.\MEMS[0] = \memtype
      \qquad
-     2^{\memarg.\ALIGN} \leq |t|
+     2^{\memarg.\ALIGN} \leq |t|/8
    }{
      C \vdash t\K{.load}~\memarg : [\I32] \to [t]
    }
@@ -335,7 +335,7 @@ Memory Instructions
 
 * The memory :math:`C.\MEMS[0]` must be defined in the context.
 
-* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N`.
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
 
 * Then the instruction is valid with type :math:`[\I32] \to [t]`.
 
@@ -343,7 +343,7 @@ Memory Instructions
    \frac{
      C.\MEMS[0] = \memtype
      \qquad
-     2^{\memarg.\ALIGN} \leq N
+     2^{\memarg.\ALIGN} \leq N/8
    }{
      C \vdash t\K{.load}N\K{\_}\sx~\memarg : [\I32] \to [t]
    }
@@ -356,7 +356,7 @@ Memory Instructions
 
 * The memory :math:`C.\MEMS[0]` must be defined in the context.
 
-* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`width <syntax-valtype>` of :math:`t`.
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`width <syntax-valtype>` of :math:`t` divided by :math:`8`.
 
 * Then the instruction is valid with type :math:`[\I32~t] \to []`.
 
@@ -364,7 +364,7 @@ Memory Instructions
    \frac{
      C.\MEMS[0] = \memtype
      \qquad
-     2^{\memarg.\ALIGN} \leq |t|
+     2^{\memarg.\ALIGN} \leq |t|/8
    }{
      C \vdash t\K{.store}~\memarg : [\I32~t] \to []
    }
@@ -377,7 +377,7 @@ Memory Instructions
 
 * The memory :math:`C.\MEMS[0]` must be defined in the context.
 
-* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N`.
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
 
 * Then the instruction is valid with type :math:`[\I32~t] \to []`.
 
@@ -385,7 +385,7 @@ Memory Instructions
    \frac{
      C.\MEMS[0] = \memtype
      \qquad
-     2^{\memarg.\ALIGN} \leq N
+     2^{\memarg.\ALIGN} \leq N/8
    }{
      C \vdash t\K{.store}N~\memarg : [\I32~t] \to []
    }
diff --git a/document/validation/modules.rst b/document/validation/modules.rst
index 5c8be03aa..678e80dc0 100644
--- a/document/validation/modules.rst
+++ b/document/validation/modules.rst
@@ -548,7 +548,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
    \frac{
      \begin{array}{@{}c@{}}
      (\vdash \functype ~\F{ok})^\ast
-     \\
+     \quad
      (C \vdash \func : \X{ft})^\ast
      \quad
      (C \vdash \table : \X{tt})^\ast
diff --git a/interpreter/host/run.ml b/interpreter/host/run.ml
index 2fb022d1e..59326a246 100644
--- a/interpreter/host/run.ml
+++ b/interpreter/host/run.ml
@@ -397,11 +397,12 @@ let run_assertion ass =
     trace ("Asserting return...");
     let got_vs = run_action act in
     let is_arithmetic_nan =
-      (* Accept any NaN that's one everywhere pos_nan is one *)
       match got_vs with
-      | [Values.F32 got_f32] -> let pos_nan = F32.to_bits F32.pos_nan in
+      | [Values.F32 got_f32] ->
+        let pos_nan = F32.to_bits F32.pos_nan in
         Int32.logand (F32.to_bits got_f32) pos_nan = pos_nan
-      | [Values.F64 got_f64] -> let pos_nan = F64.to_bits F64.pos_nan in
+      | [Values.F64 got_f64] ->
+        let pos_nan = F64.to_bits F64.pos_nan in
         Int64.logand (F64.to_bits got_f64) pos_nan = pos_nan
       | _ -> false
     in assert_result ass.at is_arithmetic_nan got_vs print_endline "nan"
diff --git a/interpreter/spec/f32.ml b/interpreter/spec/f32.ml
index ae54cf726..de72209cb 100644
--- a/interpreter/spec/f32.ml
+++ b/interpreter/spec/f32.ml
@@ -4,11 +4,10 @@
  * "When is double rounding innocuous?" by Samuel A. Figueroa.
  *)
 include Float.Make
-	(struct
+  (struct
     include Int32
     let pos_nan = 0x7fc00000l
     let neg_nan = 0xffc00000l
     let bare_nan = 0x7f800000l
-    let print_nan_significand_digits a =
-      Printf.sprintf "%lx" (abs (Int32.logxor bare_nan a))
+    let to_hex_string = Printf.sprintf "%lx"
   end)
diff --git a/interpreter/spec/f64.ml b/interpreter/spec/f64.ml
index 7ca281d4a..ae7f54532 100644
--- a/interpreter/spec/f64.ml
+++ b/interpreter/spec/f64.ml
@@ -4,6 +4,5 @@ include Float.Make
     let pos_nan = 0x7ff8000000000000L
     let neg_nan = 0xfff8000000000000L
     let bare_nan = 0x7ff0000000000000L
-    let print_nan_significand_digits a =
-      Printf.sprintf "%Lx" (abs (Int64.logxor bare_nan a))
+    let to_hex_string = Printf.sprintf "%Lx"
   end)
diff --git a/interpreter/spec/float.ml b/interpreter/spec/float.ml
index 25572bfc4..75f276559 100644
--- a/interpreter/spec/float.ml
+++ b/interpreter/spec/float.ml
@@ -8,7 +8,9 @@ sig
   val float_of_bits : t -> float
   val of_string : string -> t
   val to_string : t -> string
+  val to_hex_string : t -> string
 
+  val lognot : t -> t
   val logand : t -> t -> t
   val logor : t -> t -> t
   val logxor : t -> t -> t
@@ -18,7 +20,6 @@ sig
 
   val zero : t
   val bare_nan : t
-  val print_nan_significand_digits : t -> string
 end
 
 module type S =
@@ -61,6 +62,8 @@ struct
   type t = Rep.t
   type bits = Rep.t
 
+  let pos_inf = Rep.bits_of_float (1.0 /. 0.0)
+  let neg_inf = Rep.bits_of_float (-. (1.0 /. 0.0))
   let pos_nan = Rep.pos_nan
   let neg_nan = Rep.neg_nan
   let bare_nan = Rep.bare_nan
@@ -71,6 +74,7 @@ struct
   let of_bits x = x
   let to_bits x = x
 
+  let is_inf x = x = pos_inf || x = neg_inf
   let is_nan x = let xf = Rep.float_of_bits x in xf <> xf
 
   (*
@@ -193,36 +197,39 @@ struct
   let le x y = (to_float x <= to_float y)
   let ge x y = (to_float x >= to_float y)
 
-  let of_signless_string x len =
-    if x <> "nan" && len > 6 && String.sub x 0 6 = "nan:0x" then
-      let s = Rep.of_string (String.sub x 4 (len - 4)) in
-      if s = Rep.zero then
+  let of_signless_string s =
+    if s = "inf" then
+      pos_inf
+    else if s = "nan" then
+      pos_nan
+    else if String.length s > 6 && String.sub s 0 6 = "nan:0x" then
+      let x = Rep.of_string (String.sub s 4 (String.length s - 4)) in
+      if x = Rep.zero then
         raise (Failure "nan payload must not be zero")
-      else if Rep.logand s bare_nan <> Rep.zero then
+      else if Rep.logand x bare_nan <> Rep.zero then
         raise (Failure "nan payload must not overlap with exponent bits")
-      else if s < Rep.zero then
+      else if x < Rep.zero then
         raise (Failure "nan payload must not overlap with sign bit")
       else
-        Rep.logor s bare_nan
+        Rep.logor x bare_nan
     else
-      (* TODO: OCaml's float_of_string is insufficient *)
-      of_float (float_of_string x)
-
-  let of_string x =
-    let len = String.length x in
-    if len > 0 && x.[0] = '-' then
-      neg (of_signless_string (String.sub x 1 (len - 1)) (len - 1))
-    else if len > 0 && x.[0] = '+' then
-      of_signless_string (String.sub x 1 (len - 1)) (len - 1)
+      let x = of_float (float_of_string s) in
+      if is_inf x then failwith "of_string" else x
+
+  let of_string s =
+    if s = "" then
+      failwith "of_string"
+    else if s.[0] = '+' || s.[0] = '-' then
+      let x = of_signless_string (String.sub s 1 (String.length s - 1)) in
+      if s.[0] = '+' then x else neg x
     else
-      of_signless_string x len
+      of_signless_string s
 
   let to_string x =
     (if x < Rep.zero then "-" else "") ^
-      let a = abs x in
-      if is_nan a then
-        "nan:0x" ^ Rep.print_nan_significand_digits a
-      else
-        (* TODO: use sprintf "%h" once we have upgraded to OCaml 4.03 *)
-        string_of_float (to_float a)
+    if is_nan x then
+      "nan:0x" ^ Rep.to_hex_string (Rep.logand (abs x) (Rep.lognot bare_nan))
+    else
+      (* TODO: use sprintf "%h" once we have upgraded to OCaml 4.03 *)
+      string_of_float (to_float (abs x))
 end
diff --git a/test/core/const.wast b/test/core/const.wast
index 9eb591a45..5929646c3 100644
--- a/test/core/const.wast
+++ b/test/core/const.wast
@@ -45,3 +45,93 @@
   (module quote "(func (i64.const -9223372036854775809) drop)")
   "constant out of range"
 )
+
+(module (func (f32.const 0x1p127) drop))
+(module (func (f32.const -0x1p127) drop))
+(module (func (f32.const 0x1.fffffep127) drop))
+(module (func (f32.const -0x1.fffffep127) drop))
+(module (func (f32.const 0x1.fffffe7p127) drop))
+(module (func (f32.const -0x1.fffffe7p127) drop))
+(assert_malformed
+  (module quote "(func (f32.const 0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f32.const -0x1p128) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f32.const 0x1.ffffffp127) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f32.const -0x1.ffffffp127) drop)")
+  "constant out of range"
+)
+
+(module (func (f32.const 1e38) drop))
+(module (func (f32.const -1e38) drop))
+(assert_malformed
+  (module quote "(func (f32.const 1e39) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f32.const -1e39) drop)")
+  "constant out of range"
+)
+
+(module (func (f32.const 340282356779733623858607532500980858880) drop))
+(module (func (f32.const -340282356779733623858607532500980858880) drop))
+(assert_malformed
+  (module quote "(func (f32.const 340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f32.const -340282356779733661637539395458142568448) drop)")
+  "constant out of range"
+)
+
+(module (func (f64.const 0x1p1023) drop))
+(module (func (f64.const -0x1p1023) drop))
+(module (func (f64.const 0x1.fffffffffffffp1023) drop))
+(module (func (f64.const -0x1.fffffffffffffp1023) drop))
+(module (func (f64.const 0x1.fffffffffffff7p1023) drop))
+(module (func (f64.const -0x1.fffffffffffff7p1023) drop))
+(assert_malformed
+  (module quote "(func (f64.const 0x1p1024) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const -0x1p1024) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const 0x1.fffffffffffff8p1023) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const -0x1.fffffffffffff8p1023) drop)")
+  "constant out of range"
+)
+
+(module (func (f64.const 1e308) drop))
+(module (func (f64.const -1e308) drop))
+(assert_malformed
+  (module quote "(func (f64.const 1e309) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const -1e309) drop)")
+  "constant out of range"
+)
+
+(module (func (f64.const 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(module (func (f64.const -179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368) drop))
+(assert_malformed
+  (module quote "(func (f64.const 269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)
+(assert_malformed
+  (module quote "(func (f64.const -269653970229347356221791135597556535197105851288767494898376215204735891170042808140884337949150317257310688430271573696351481990334196274152701320055306275479074865864826923114368235135583993416113802762682700913456874855354834422248712838998185022412196739306217084753107265771378949821875606039276187287552) drop)")
+  "constant out of range"
+)

From 31c641cc15f2aedbec2fa45a5185f68416df578b Mon Sep 17 00:00:00 2001
From: Clemens Hammacher <hammacher@cs.uni-saarland.de>
Date: Thu, 8 Jun 2017 13:40:06 +0200
Subject: [PATCH 033/329] Update wasm-module-builder (#499)

* Update wasm-module-builder

This brings the wasm-module-builder.js in sync again with the version
we currently have in v8, from which this clone was initially created.

- the name section uses the new speced format
- {addBody()} automatically appends the end opcode
- support custom sections
- more type checking
- use !== to check for undefined
- emit i64 global inits as varint
- {toBuffer()} now returns the ArrayBuffer instead of a Uint8Array
---
 test/harness/wasm-constants.js      | 59 +++++++++++----------
 test/harness/wasm-module-builder.js | 80 +++++++++++++++++++----------
 test/js-api/jsapi.js                | 15 +++---
 3 files changed, 89 insertions(+), 65 deletions(-)

diff --git a/test/harness/wasm-constants.js b/test/harness/wasm-constants.js
index f056f9cbf..68c36ef1f 100644
--- a/test/harness/wasm-constants.js
+++ b/test/harness/wasm-constants.js
@@ -21,7 +21,7 @@ var kWasmH1 = 0x61;
 var kWasmH2 = 0x73;
 var kWasmH3 = 0x6d;
 
-var kWasmV0 = 1;
+var kWasmV0 = 0x1;
 var kWasmV1 = 0;
 var kWasmV2 = 0;
 var kWasmV3 = 0;
@@ -65,6 +65,11 @@ let kCodeSectionCode = 10;      // Function code
 let kDataSectionCode = 11;     // Data segments
 let kNameSectionCode = 12;     // Name section (encoded as string)
 
+// Name section types
+let kModuleNameCode = 0;
+let kFunctionNamesCode = 1;
+let kLocalNamesCode = 2;
+
 let kWasmFunctionTypeForm = 0x60;
 let kWasmAnyFunctionTypeForm = 0x70;
 
@@ -339,36 +344,34 @@ let kTrapMsgs = [
 ];
 
 function assertTraps(trap, code) {
-    var threwException = true;
-    try {
-      if (typeof code === 'function') {
-        code();
-      } else {
-        eval(code);
-      }
-      threwException = false;
-    } catch (e) {
-      assertEquals("object", typeof e);
-      assertEquals(kTrapMsgs[trap], e.message);
-      // Success.
-      return;
+  try {
+    if (typeof code === 'function') {
+      code();
+    } else {
+      eval(code);
     }
-    throw new MjsUnitAssertionError("Did not trap, expected: " + kTrapMsgs[trap]);
+  } catch (e) {
+    assertEquals('object', typeof e);
+    assertEquals(kTrapMsgs[trap], e.message);
+    // Success.
+    return;
+  }
+  throw new MjsUnitAssertionError('Did not trap, expected: ' + kTrapMsgs[trap]);
 }
 
 function assertWasmThrows(value, code) {
-    assertEquals("number", typeof(value));
-    try {
-      if (typeof code === 'function') {
-        code();
-      } else {
-        eval(code);
-      }
-    } catch (e) {
-      assertEquals("number", typeof e);
-      assertEquals(value, e);
-      // Success.
-      return;
+  assertEquals('number', typeof value);
+  try {
+    if (typeof code === 'function') {
+      code();
+    } else {
+      eval(code);
     }
-    throw new MjsUnitAssertionError("Did not throw at all, expected: " + value);
+  } catch (e) {
+    assertEquals('number', typeof e);
+    assertEquals(value, e);
+    // Success.
+    return;
+  }
+  throw new MjsUnitAssertionError('Did not throw, expected: ' + value);
 }
diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index 9cc5191ce..68fab8985 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -99,7 +99,13 @@ class WasmFunctionBuilder {
   }
 
   addBody(body) {
-    this.body = body;
+    for (let b of body) {
+      if (typeof b != 'number')
+        throw new Error('invalid body (entries have to be numbers): ' + body);
+    }
+    this.body = body.slice();
+    // Automatically add the end for the function block to the body.
+    this.body.push(kExprEnd);
     return this;
   }
 
@@ -161,6 +167,22 @@ class WasmModuleBuilder {
     return this;
   }
 
+  stringToBytes(name) {
+    var result = new Binary();
+    result.emit_u32v(name.length);
+    for (var i = 0; i < name.length; i++) {
+      result.emit_u8(name.charCodeAt(i));
+    }
+    return result;
+  }
+
+  addCustomSection(name, bytes) {
+    name = this.stringToBytes(name);
+    var length = new Binary();
+    length.emit_u32v(name.length + bytes.length);
+    this.explicit.push([0, ...length, ...name, ...bytes]);
+  }
+
   addType(type) {
     // TODO: canonicalize types?
     this.types.push(type);
@@ -228,12 +250,12 @@ class WasmModuleBuilder {
     this.exports.push({name: name, kind: kExternalMemory, index: 0});
   }
 
-  addFunctionTableInit(base, is_global, array) {
+  addFunctionTableInit(base, is_global, array, is_import = false) {
     this.function_table_inits.push({base: base, is_global: is_global,
                                     array: array});
     if (!is_global) {
       var length = base + array.length;
-      if (length > this.function_table_length) {
+      if (length > this.function_table_length && !is_import) {
         this.function_table_length = length;
       }
     }
@@ -241,6 +263,10 @@ class WasmModuleBuilder {
   }
 
   appendToTable(array) {
+    for (let n of array) {
+      if (typeof n != 'number')
+        throw new Error('invalid table (entries have to be numbers): ' + array);
+    }
     return this.addFunctionTableInit(this.function_table.length, false, array);
   }
 
@@ -308,15 +334,16 @@ class WasmModuleBuilder {
     }
 
     // Add functions declarations
-    let has_names = false;
+    let num_function_names = 0;
     let names = false;
     if (wasm.functions.length > 0) {
       if (debug) print("emitting function decls @ " + binary.length);
       binary.emit_section(kFunctionSectionCode, section => {
         section.emit_u32v(wasm.functions.length);
         for (let func of wasm.functions) {
-          has_names = has_names || (func.name != undefined &&
-                                   func.name.length > 0);
+          if (func.name !== undefined) {
+            ++num_function_names;
+          }
           section.emit_u32v(func.type_index);
         }
       });
@@ -335,7 +362,7 @@ class WasmModuleBuilder {
     }
 
     // Add memory section
-    if (wasm.memory != undefined) {
+    if (wasm.memory !== undefined) {
       if (debug) print("emitting memory @ " + binary.length);
       binary.emit_section(kMemorySectionCode, section => {
         section.emit_u8(1);  // one memory entry
@@ -363,7 +390,7 @@ class WasmModuleBuilder {
               break;
             case kWasmI64:
               section.emit_u8(kExprI64Const);
-              section.emit_u8(global.init);
+              section.emit_u32v(global.init);
               break;
             case kWasmF32:
               section.emit_u8(kExprF32Const);
@@ -397,7 +424,7 @@ class WasmModuleBuilder {
     }
 
     // Add export table.
-    var mem_export = (wasm.memory != undefined && wasm.memory.exp);
+    var mem_export = (wasm.memory !== undefined && wasm.memory.exp);
     var exports_count = wasm.exports.length + (mem_export ? 1 : 0);
     if (exports_count > 0) {
       if (debug) print("emitting exports @ " + binary.length);
@@ -417,7 +444,7 @@ class WasmModuleBuilder {
     }
 
     // Add start function section.
-    if (wasm.start_index != undefined) {
+    if (wasm.start_index !== undefined) {
       if (debug) print("emitting start function @ " + binary.length);
       binary.emit_section(kStartSectionCode, section => {
         section.emit_u32v(wasm.start_index);
@@ -458,7 +485,7 @@ class WasmModuleBuilder {
           // Function body length will be patched later.
           let local_decls = [];
           let l = func.locals;
-          if (l != undefined) {
+          if (l !== undefined) {
             let local_decls_count = 0;
             if (l.i32_count > 0) {
               local_decls.push({count: l.i32_count, type: kWasmI32});
@@ -518,21 +545,18 @@ class WasmModuleBuilder {
     }
 
     // Add function names.
-    if (has_names) {
-      if (debug) print("emitting names @ " + binary.length);
+    if (num_function_names > 0) {
+      if (debug) print('emitting names @ ' + binary.length);
       binary.emit_section(kUnknownSectionCode, section => {
-        section.emit_string("name");
-        var count = wasm.functions.length + wasm.num_imported_funcs;
-        section.emit_u32v(count);
-        for (var i = 0; i < wasm.num_imported_funcs; i++) {
-          section.emit_u8(0); // empty string
-          section.emit_u8(0); // local names count == 0
-        }
-        for (let func of wasm.functions) {
-          var name = func.name == undefined ? "" : func.name;
-          section.emit_string(name);
-          section.emit_u8(0);  // local names count == 0
-        }
+        section.emit_string('name');
+        section.emit_section(kFunctionNamesCode, name_section => {
+          name_section.emit_u32v(num_function_names);
+          for (let func of wasm.functions) {
+            if (func.name === undefined) continue;
+            name_section.emit_u32v(func.index);
+            name_section.emit_string(func.name);
+          }
+        });
       });
     }
 
@@ -548,12 +572,12 @@ class WasmModuleBuilder {
       if ((typeof val) == "string") val = val.charCodeAt(0);
       view[i] = val | 0;
     }
-    return new Uint8Array(buffer);
+    return buffer;
   }
 
-  instantiate(...args) {
+  instantiate(ffi) {
     let module = new WebAssembly.Module(this.toBuffer());
-    let instance = new WebAssembly.Instance(module, ...args);
+    let instance = new WebAssembly.Instance(module, ffi);
     return instance;
   }
 }
diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 6fc2fdf31..cc61ba8d4 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -46,8 +46,7 @@ const exportingModuleBinary = (() => {
         .addFunction('f', kSig_i_v)
         .addBody([
             kExprI32Const,
-            42,
-            kExprEnd
+            42
         ])
         .exportFunc();
 
@@ -59,9 +58,7 @@ const complexExportingModuleBinary = (() => {
 
     builder
         .addFunction('a', kSig_v_v)
-        .addBody([
-            kExprEnd
-        ])
+        .addBody([])
         .exportFunc();
 
     builder.addMemory(1, 1, /* exported */ false);
@@ -200,7 +197,7 @@ test(() => {
     assertThrows(() => new Module(new Uint8Array()), CompileError);
     assertThrows(() => new Module(new ArrayBuffer()), CompileError);
     assert_equals(new Module(emptyModuleBinary) instanceof Module, true);
-    assert_equals(new Module(emptyModuleBinary.buffer) instanceof Module, true);
+    assert_equals(new Module(new Uint8Array(emptyModuleBinary)) instanceof Module, true);
 }, "'WebAssembly.Module' constructor function");
 
 test(() => {
@@ -703,7 +700,7 @@ function assertCompileSuccess(bytes) {
 }
 
 assertCompileSuccess(emptyModuleBinary);
-assertCompileSuccess(emptyModuleBinary.buffer);
+assertCompileSuccess(new Uint8Array(emptyModuleBinary));
 
 test(() => {
     const instantiateDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'instantiate');
@@ -776,10 +773,10 @@ test(() => {
     }
     assertInstantiateSuccess(emptyModule);
     assertInstantiateSuccess(emptyModuleBinary);
-    assertInstantiateSuccess(emptyModuleBinary.buffer);
+    assertInstantiateSuccess(new Uint8Array(emptyModuleBinary));
     assertInstantiateSuccess(importingModule, {"":{f:()=>{}}});
     assertInstantiateSuccess(importingModuleBinary, {"":{f:()=>{}}});
-    assertInstantiateSuccess(importingModuleBinary.buffer, {"":{f:()=>{}}});
+    assertInstantiateSuccess(new Uint8Array(importingModuleBinary), {"":{f:()=>{}}});
     assertInstantiateSuccess(complexImportingModuleBinary, {
         a:{b:()=>{}},
         c:{d:scratch_memory},

From 93bf10b16c6c6fc44b07c32a4bc55a697ab81707 Mon Sep 17 00:00:00 2001
From: JF Bastien <github@jfbastien.com>
Date: Fri, 9 Jun 2017 14:03:12 -0700
Subject: [PATCH 034/329] Fix comma instead of semicolon (#502)

---
 test/js-api/jsapi.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index cc61ba8d4..416a923f1 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -647,7 +647,7 @@ test(() => {
     assert_true(WebAssembly.validate(complexImportingModuleBinary));
     assert_false(WebAssembly.validate(moduleBinaryImporting2Memories));
     assert_false(WebAssembly.validate(moduleBinaryWithMemSectionAndMemImport));
-}, "'WebAssembly.validate' method"),
+}, "'WebAssembly.validate' method");
 
 test(() => {
     const compileDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'compile');

From e96a1d1beec4f7018cd4339b9c36eb53b784633e Mon Sep 17 00:00:00 2001
From: JF Bastien <github@jfbastien.com>
Date: Mon, 12 Jun 2017 11:12:47 -0700
Subject: [PATCH 035/329] Remove odd tests (#503)

* Remove odd tests

These two tests don't make much sense to me because the string argument invokes the `length` constructor of `TypedArray`:
https://tc39.github.io/ecma262/#sec-typedarray-length
This then goes ToIndex / ToInteger etc, and the string becomes an integer.

What's the point of this test?

* Remove more of the same

* Keep useless input

* Hoist the const
---
 test/js-api/jsapi.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 416a923f1..9b4096a2e 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -14,6 +14,8 @@
  * limitations under the License.
 */
 
+const kC0DEFEFE = new Uint8Array([0xC0, 0xDE, 0xFE, 0xFE]);
+
 (function testJSAPI() {
 
 const WasmPage = 64 * 1024;
@@ -686,8 +688,7 @@ assertCompileError([1], TypeError);
 assertCompileError([{}], TypeError);
 assertCompileError([new Uint8Array()], CompileError);
 assertCompileError([new ArrayBuffer()], CompileError);
-assertCompileError([new Uint8Array("hi!")], CompileError);
-assertCompileError([new ArrayBuffer("hi!")], CompileError);
+assertCompileError([kC0DEFEFE], CompileError);
 
 num_tests = 1;
 function assertCompileSuccess(bytes) {
@@ -735,8 +736,7 @@ test(() => {
     assertInstantiateError([{}], TypeError);
     assertInstantiateError([new Uint8Array()], CompileError);
     assertInstantiateError([new ArrayBuffer()], CompileError);
-    assertInstantiateError([new Uint8Array("hi!")], CompileError);
-    assertInstantiateError([new ArrayBuffer("hi!")], CompileError);
+    assertInstantiateError([kC0DEFEFE], CompileError);
     assertInstantiateError([importingModule], TypeError);
     assertInstantiateError([importingModule, null], TypeError);
     assertInstantiateError([importingModuleBinary, null], TypeError);

From ce506f854a1d4a95afcb1fb96a565bec0451f5ef Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 13 Jun 2017 08:05:10 +0200
Subject: [PATCH 036/329] [test] Remove unnecessary quoting (#504)

---
 test/core/type.wast | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/test/core/type.wast b/test/core/type.wast
index c78792ed2..5ceeeb269 100644
--- a/test/core/type.wast
+++ b/test/core/type.wast
@@ -48,11 +48,12 @@
   (module quote "(type (func (result $x i32)))")
   "unexpected token"
 )
+
 (assert_invalid
-  (module quote "(type (func (result i32 i32)))")
+  (module (type (func (result i32 i32))))
   "invalid result arity"
 )
 (assert_invalid
-  (module quote "(type (func (result i32) (result i32)))")
+  (module (type (func (result i32) (result i32))))
   "invalid result arity"
 )

From 3099b6fc4958ca9cd6d549c719c3f474f814eed1 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 13 Jun 2017 16:30:20 +0200
Subject: [PATCH 037/329] [spec] Module instantiation & handling of host
 functions (#487)

---
 document/Makefile                   |  10 +-
 document/custom.css                 |  11 +
 document/execution/conventions.rst  |   4 +-
 document/execution/instructions.rst |  95 +++-
 document/execution/modules.rst      | 660 +++++++++++++++++++++++++++-
 document/execution/runtime.rst      | 126 ++++--
 document/math.def                   |  22 +-
 document/syntax/instructions.rst    |   4 +-
 document/syntax/types.rst           |  35 ++
 document/validation/modules.rst     |   6 +-
 10 files changed, 888 insertions(+), 85 deletions(-)

diff --git a/document/Makefile b/document/Makefile
index ea7776e14..3c6e8b30c 100644
--- a/document/Makefile
+++ b/document/Makefile
@@ -11,6 +11,10 @@ DOWNLOADDIR   = _download
 GHPAGESDIR    = ../docs
 NAME          = WebAssembly
 
+# Hack until we have moved to more recent Sphinx.
+OLDMATHJAX    = https://cdn.mathjax.org/mathjax/latest/MathJax.js
+NEWMATHJAX    = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.1/MathJax.js
+
 # Internal variables.
 PAPEROPT_a4     = -D latex_paper_size=a4
 PAPEROPT_letter = -D latex_paper_size=letter
@@ -88,13 +92,17 @@ html:
 	do \
 	  sed s:BASEDIR:.:g <$$file >$$file.out; \
 	  mv -f $$file.out $$file; \
+	  sed s~$(OLDMATHJAX)~$(NEWMATHJAX)~g <$$file >$$file.out; \
+	  mv -f $$file.out $$file; \
 	done
 	for file in `ls $(BUILDDIR)/html/*/*.html`; \
 	do \
 	  sed s:BASEDIR:..:g <$$file >$$file.out; \
-	  sed 's;<body;<script type="text/javascript">MathJax.Hub.Config({TeX: {MAXBUFFER: 30*1024}})</script><body;' \
+	  sed 's; <body; <script type="text/javascript">MathJax.Hub.Config({TeX: {MAXBUFFER: 30*1024}})</script><body;' \
 	    <$$file.out >$$file; \
 	  rm -f $$file.out; \
+	  sed s~$(OLDMATHJAX)~$(NEWMATHJAX)~g <$$file >$$file.out; \
+	  mv -f $$file.out $$file; \
 	done
 	@echo
 	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html."
diff --git a/document/custom.css b/document/custom.css
index 051ab1541..9e8ba21fb 100644
--- a/document/custom.css
+++ b/document/custom.css
@@ -11,6 +11,9 @@ a.reference:hover {
   border-bottom: 1px dotted #004BAB;
 }
 
+div.document { width: 1000px; }
+div.footer { width: 1000px; }
+
 div.body h1 { font-size: 200%; }
 div.body h2 { font-size: 150%; }
 div.body h3 { font-size: 120%; }
@@ -32,6 +35,14 @@ div.admonition p.admonition-title {
 }
 
 
+div.sphinxsidebar {
+  z-index: 1;
+  background: #FFF;
+  margin-top: -30px;
+  width: 230px;
+  height: 100%;
+}
+
 div.sphinxsidebar a {
   border-bottom: 0px;
 }
diff --git a/document/execution/conventions.rst b/document/execution/conventions.rst
index c66c59e92..6ca70ee62 100644
--- a/document/execution/conventions.rst
+++ b/document/execution/conventions.rst
@@ -37,8 +37,8 @@ The following conventions are adopted in stating these rules.
   that is modified by *pushing* or *popping*
   :ref:`values <syntax-value>`, :ref:`labels <syntax-label>`, and :ref:`frames <syntax-frame>`.
 
-* Certain rules require the stack to contain at least one frame,
-  which is referred to as the *current* frame.
+* Certain rules require the stack to contain at least one frame.
+  The most recent frame is referred to as the *current* frame.
 
 * Both the store and the current frame are mutated by *replacing* some of its components.
   Such replacement is assumed to apply globally.
diff --git a/document/execution/instructions.rst b/document/execution/instructions.rst
index 900c59afc..7145631dc 100644
--- a/document/execution/instructions.rst
+++ b/document/execution/instructions.rst
@@ -884,11 +884,9 @@ Control Instructions
 
 14. Let :math:`\X{f}` be the :ref:`function instance <syntax-funcinst>` :math:`S.\FUNCS[a]`.
 
-15. Assert: due to :ref:`validation <valid-func>`, :math:`\X{f}.\MODULE.\TYPES[\X{f}.\CODE.\TYPE]` exists.
+15. Let :math:`\X{ft}_{\F{actual}}` be the :ref:`function type <syntax-functype>` :math:`\X{f}.\TYPE`.
 
-16. Let :math:`\X{ft}_{\F{actual}}` be the :ref:`function type <syntax-functype>` :math:`\X{f}.\MODULE.\TYPES[\X{f}.\CODE.\TYPE]`.
-
-15. If :math:`\X{ft}_{\F{actual}}` and :math:`\X{ft}_{\F{expect}}` differ, then:
+16. If :math:`\X{ft}_{\F{actual}}` and :math:`\X{ft}_{\F{expect}}` differ, then:
 
     a. Trap.
 
@@ -903,7 +901,7 @@ Control Instructions
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & S.\TABLES[F.\MODULE.\TABLES[0]].\ELEM[i] = a \\
      \wedge & S.\FUNCS[a] = f \\
-     \wedge & F.\MODULE.\TYPES[x] = f.\MODULE.\TYPES[f.\CODE.\TYPE])
+     \wedge & F.\MODULE.\TYPES[x] = f.\TYPE)
      \end{array} \\
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~i)~(\CALLINDIRECT~x) &\stepto& S; F; \TRAP
@@ -987,25 +985,23 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 
 2. Let :math:`f` be the :ref:`function instance <syntax-funcinst>`, :math:`S.\FUNCS[a]`.
 
-3. Assert: due to :ref:`validation <valid-func>`, :math:`f.\MODULE.\TYPES[f.\CODE.\TYPE]` exists.
-
-4. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`f.\MODULE.\TYPES[f.\CODE.\TYPE]`.
+3. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`f.\TYPE`.
 
-5. Let :math:`t^\ast` be the list of :ref:`value types <syntax-valtype>` :math:`f.\CODE.\LOCALS`.
+4. Let :math:`t^\ast` be the list of :ref:`value types <syntax-valtype>` :math:`f.\CODE.\LOCALS`.
 
-6. Let :math:`\instr^\ast~\END` be the :ref:`expression <syntax-expr>` :math:`f.\CODE.\BODY`.
+5. Let :math:`\instr^\ast~\END` be the :ref:`expression <syntax-expr>` :math:`f.\CODE.\BODY`.
 
-7. Assert: due to :ref:`validation <valid-call>`, :math:`n` values are on the top of the stack.
+6. Assert: due to :ref:`validation <valid-call>`, :math:`n` values are on the top of the stack.
 
-8. Pop the values :math:`\val^n` from the stack.
+7. Pop the values :math:`\val^n` from the stack.
 
-9. Let :math:`\val_0^\ast` be the list of zero values of types :math:`t^\ast`.
+8. Let :math:`\val_0^\ast` be the list of zero values of types :math:`t^\ast`.
 
-10. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \MODULE~f.\MODULE, \LOCALS~\val^n~\val_0^\ast \}`.
+9. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \MODULE~f.\MODULE, \LOCALS~\val^n~\val_0^\ast \}`.
 
-11. Push the activation of :math:`F` with arity :math:`m` to the stack.
+10. Push the activation of :math:`F` with arity :math:`m` to the stack.
 
-12. :ref:`Execute <exec-block>` the instruction :math:`\BLOCK~[t_2^m]~\instr^\ast~\END`.
+11. :ref:`Execute <exec-block>` the instruction :math:`\BLOCK~[t_2^m]~\instr^\ast~\END`.
 
 .. math::
    \begin{array}{l}
@@ -1016,7 +1012,7 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & S.\FUNCS[a] = f \\
      \wedge & f.\CODE = \{ \TYPE~x, \LOCALS~t^k, \BODY~\instr^\ast~\END \} \\
-     \wedge & f.\MODULE.\TYPES[x] = [t_1^n] \to [t_2^m] \\
+     \wedge & f.\TYPE = [t_1^n] \to [t_2^m] \\
      \wedge & F = \{ \MODULE~f.\MODULE, ~\LOCALS~\val^n~(t.\CONST~0)^k \})
      \end{array} \\
    \end{array}
@@ -1051,24 +1047,75 @@ When the end of a funtion is reached without a jump (|RETURN|) or trap aborting
    \end{array}
 
 
+.. _exec-invoke-host:
+
+Host Functions
+..............
+
+Invoking a :ref:`host function <syntax-hostfunc>` has non-deterministic behavior.
+It may either terminate with a :ref:`trap <trap>` or return regularly.
+However, the latter case, it is assumed that it consumes and produces the right number and types of WebAssembly :ref:`values <syntax-val>` on the stack,
+according to its type.
+A host function may also modify the :ref:`store <syntax-store>` when invoked.
+
+.. math::
+   \begin{array}{l}
+   \begin{array}{lcl@{\qquad}l}
+   S; \val^n~(\INVOKE~a) &\stepto& S'; {\val'\,}^m
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\mbox{if} & S.\FUNCS[a] = \{ \TYPE~[t_1^n] \to [t_2^m], \HOST~\dots \} \\
+     \wedge & \val^n = (t_1.\CONST~c_1)^n \\
+     \wedge & {\val'\,}^m = (t_2.\CONST~c_2)^m \\
+     \wedge & S' \succ S) \\
+     \end{array} \\
+   \begin{array}{lcl@{\qquad}l}
+   S; \val^n~(\INVOKE~a) &\stepto& S'; \TRAP
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\mbox{if} & S.\FUNCS[a] = \{ \TYPE~\X{ft}, \HOST~\dots \} \\ 
+     \wedge & S' \succ S) \\
+     \end{array} \\
+   \end{array}
+
+Here, :math:`S' \succ S` expresses that the new store :math:`S'` is *reachable* from :math:`S`.
+Such a store must not contain fewer addresses than the original store,
+it must not differ in elements that are not mutable,
+and it must still be well-typed.
+
+.. todo:: Define more precisely?
+
+.. note::
+   A host function can call back into WebAssembly by :ref:`invoking <invocation>` a function :ref:`exported <syntax-export>` from a :ref:`module <syntax-module>`.
+   However, the effects of any such call are subsumed by the non-deterministic behavior allowed for a host function.
+
+
+
 .. _exec-expr:
 .. index:: expression
    pair: execution; expression
    single: abstract syntax; expression
-   single: expression; constant
 
 Expressions
 ~~~~~~~~~~~
 
-:math:`\instr^\ast~\END`
-........................
+An :ref:`expression <syntax-expr>` is *evaluated* relative to a :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>` pointing to its containing :ref:`module instance <syntax-modinst>` :math:`\moduleinst`.
+
+1. :ref:`Jump <exec-jump>` to the start of the instruction sequence :math:`\instr^\ast` of the expression.
+
+2. Execute of the instruction sequence.
+
+3. Assert: due to :ref:`validation <valid-expr>`, the top of the stack contains a :ref:`value <syntax-val>`.
+
+4. Pop the the :ref:`value <syntax-val>` :math:`\val` from the stack.
 
-.. todo::
-   Define
+The value :math:`\val` is the result of the evaluation.
 
 .. math::
    \frac{
-     S; F; \instr^\ast \stepto^\ast S; F; v
+     S; F; \instr^\ast \stepto^\ast S'; F'; v
    }{
-     S; F; \instr^\ast~\END \stepto^\ast S; F; v
+     S; F; \instr^\ast~\END \stepto^\ast S'; F'; v
    }
diff --git a/document/execution/modules.rst b/document/execution/modules.rst
index 46e76ef07..525dff326 100644
--- a/document/execution/modules.rst
+++ b/document/execution/modules.rst
@@ -1,5 +1,661 @@
 Modules
 -------
 
-.. todo::
-   Work in progress
+
+.. _valid-externval:
+
+External Typing
+~~~~~~~~~~~~~~~
+
+For the purpose of checking :ref:`external values <syntax-externval>` against :ref:`imports <syntax-import>`,
+such values are classified by :ref:`external types <syntax-externtype>`.
+The following auxiliary typing rules specify this typing relation relative to a :ref:`store <syntax-store>` :math:`S` in which the external value lives.
+
+:math:`\FUNC~a`
+...............
+
+* The store entry :math:`S.\FUNCS[a]` must be a :ref:`function instance <syntax-funcinst>` :math:`\{\TYPE~\functype, \dots\}`.
+
+* Then :math:`\FUNC~a` is valid with :ref:`external type <syntax-externtype>` :math:`\FUNC~\functype`.
+
+.. math::
+   \frac{
+     S.\FUNCS[a] = \{\TYPE~\functype, \dots\}
+   }{
+     S \vdash \FUNC~a : \FUNC~\functype
+   }
+
+
+:math:`\TABLE~a`
+................
+
+* The store entry :math:`S.\TABLES[a]` must be a :ref:`table instance <syntax-tableinst>` :math:`\{\ELEM~(\X{fa}^?)^n, \MAX~m^?\}`.
+
+* Then :math:`\TABLE~a` is valid with :ref:`external type <syntax-externtype>` :math:`\TABLE~(\{\MIN~n, \MAX~m^?\}~\ANYFUNC)`.
+
+.. math::
+   \frac{
+     S.\TABLES[a] = \{ \ELEM~(\X{fa}^?)^n, \MAX~m^? \}
+   }{
+     S \vdash \TABLE~a : \TABLE~(\{\MIN~n, \MAX~m^?\}~\ANYFUNC)
+   }
+
+
+:math:`\MEM~a`
+..............
+
+* The store entry :math:`S.\MEMS[a]` must be a :ref:`memory instance <syntax-meminst>` :math:`\{\DATA~b^{n\cdot64\,\F{Ki}}, \MAX~m^?\}`, for some :math:`n`.
+
+* Then :math:`\MEM~a` is valid with :ref:`external type <syntax-externtype>` :math:`\MEM~(\{\MIN~n, \MAX~m^?\})`.
+
+.. math::
+   \frac{
+     S.\MEMS[a] = \{ \DATA~b^{n\cdot64\,\F{Ki}}, \MAX~m^? \}
+   }{
+     S \vdash \MEM~a : \MEM~\{\MIN~n, \MAX~m^?\}
+   }
+
+
+:math:`\GLOBAL~a`
+.................
+
+* The store entry :math:`S.\GLOBALS[a]` must be a :ref:`global instance <syntax-globalinst>` :math:`\{\VALUE~(t.\CONST~c), \MUT~\mut\}`.
+
+* Then :math:`\GLOBAL~a` is valid with :ref:`external type <syntax-externtype>` :math:`\GLOBAL~(\mut~t)`.
+
+.. math::
+   \frac{
+     S.\GLOBALS[a] = \{ \VALUE~(t.\CONST~c), \MUT~\mut \}
+   }{
+     S \vdash \GLOBAL~a : \GLOBAL~(\mut~t)
+   }
+
+
+
+.. _exec-import:
+.. _match-externtype:
+
+Import Matching
+~~~~~~~~~~~~~~~
+
+When :ref:`instantiating <exec-module>` a module,
+:ref:`external values <syntax-externval>` must be provided whose :ref:`types <valid-externval>` are *matched* against the respective :ref:`external types <syntax-externtype>` classifying each import.
+In some cases, this allows for a simple form of subtyping, as defined below.
+
+.. _match-limits:
+
+Limits
+......
+
+:ref:`Limits <syntax-limits>` :math:`\{ \MIN~n_1, \MAX~m_1^? \}` match limits :math:`\{ \MIN~n_2, \MAX~m_2^? \}` if and only if:
+
+* :math:`n_1` is not smaller than :math:`n_2`.
+
+* Either:
+
+  * :math:`m_2^?` is empty.
+
+* Or:
+
+  * Both :math:`m_1^?` and :math:`m_2^?` are non-empty.
+
+  * :math:`m_1` is not larger than :math:`m_2`.
+
+.. math::
+   \frac{
+     n_1 \geq n_2
+   }{
+     \vdash \{ \MIN~n_1, \MAX~m_1^? \} \leq \{ \MIN~n_2, \MAX~\epsilon \}
+   }
+   \quad
+   \frac{
+     n_1 \geq n_2
+     \qquad
+     m_1 \leq m_2
+   }{
+     \vdash \{ \MIN~n_1, \MAX~m_1 \} \leq \{ \MIN~n_2, \MAX~m_2 \}
+   }
+
+
+Functions
+.........
+
+An :ref:`external type <syntax-externtype>` :math:`\FUNC~\functype_1` matches :math:`\FUNC~\functype_2` if and only if:
+
+* Both :math:`\functype_1` and :math:`\functype_2` are the same.
+
+.. math::
+   \frac{
+   }{
+     \vdash \FUNC~\functype \leq \FUNC~\functype
+   }
+
+
+Tables
+......
+
+An :ref:`external type <syntax-externtype>` :math:`\TABLE~(\limits_1~\elemtype_1)` matches :math:`\TABLE~(\limits_2~\elemtype_2)` if and only if:
+
+* Limits :math:`\limits_1` :ref:`match <match-limits>` :math:`\limits_2`.
+
+* Both :math:`\elemtype_1` and :math:`\elemtype_2` are the same.
+
+.. math::
+   \frac{
+     \vdash \limits_1 \leq \limits_2
+   }{
+     \vdash \TABLE~(\limits_1~\elemtype) \leq \TABLE~(\limits_2~\elemtype)
+   }
+
+
+Memories
+........
+
+An :ref:`external type <syntax-externtype>` :math:`\MEM~\limits_1` matches :math:`\MEM~\limits_2` if and only if:
+
+* Limits :math:`\limits_1` :ref:`match <match-limits>` :math:`\limits_2`.
+
+.. math::
+   \frac{
+     \vdash \limits_1 \leq \limits_2
+   }{
+     \vdash \MEM~\limits_1 \leq \MEM~\limits_2
+   }
+
+
+Globals
+.......
+
+An :ref:`external type <syntax-externtype>` :math:`\GLOBAL~\globaltype_1` matches :math:`\GLOBAL~\globaltype_2` if and only if:
+
+* Both :math:`\globaltype_1` and :math:`\globaltype_2` are the same.
+
+.. math::
+   \frac{
+   }{
+     \vdash \GLOBAL~\globaltype \leq \GLOBAL~\globaltype
+   }
+
+
+.. _alloc:
+
+Allocation
+~~~~~~~~~~
+
+New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tableinst>`, :ref:`memories <syntax-meminst>`, :ref:`globals <syntax-globalinst>`, and :ref:`modules <syntax-moduleinst>` are *allocated* in a :ref:`store <syntax-store>` :math:`S`, as defined by the following auxiliary functions.
+
+
+.. _alloc-func:
+
+:ref:`Functions <syntax-funcinst>`
+..................................
+
+1. Let :math:`\func` be the :ref:`function <syntax-func>` to allocate and :math:`\moduleinst` its :ref:`module instance <syntax-moduleinst>`.
+
+2. Let :math:`a` be the first free :ref:`function address <syntax-funcaddr>` in :math:`S`.
+
+3. Let :math:`\functype` be the :ref:`function type <syntax-functype>` :math:`\moduleinst.\TYPES[\func.\TYPE]`.
+
+4. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \TYPE~\functype, \MODULE~\moduleinst, \CODE~\func \}`.
+
+5. Append :math:`\funcinst` to the |FUNCS| of :math:`S`.
+
+6. Return :math:`a`.
+
+.. math::
+   \begin{array}{rlll}
+   \allocfunc(S, \func, \moduleinst) &=& S', \funcaddr \\[1ex]
+   \mbox{where:} \hfill \\
+   \funcaddr &=& |S.\FUNCS| \\
+   \functype &=& \moduleinst.\TYPES[\func.\TYPE] \\
+   \funcinst &=& \{ \TYPE~\functype, \MODULE~\moduleinst, \CODE~\func \} \\
+   S' &=& S \compose \{\FUNCS~\funcinst\} \\
+   \end{array}
+
+.. _alloc-hostfunc:
+
+:ref:`Host Functions <syntax-hostfunc>`
+.......................................
+
+1. Let :math:`\hostfunc` be the :ref:`host function <syntax-hostfunc>` to allocate and :math:`\functype` its :ref:`function type <syntax-functype>`.
+
+2. Let :math:`a` be the first free :ref:`function address <syntax-funcaddr>` in :math:`S`.
+
+4. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \TYPE~\functype, \CODE~\hostfunc \}`.
+
+5. Append :math:`\funcinst` to the |FUNCS| of :math:`S`.
+
+6. Return :math:`a`.
+
+.. math::
+   \begin{array}{rlll}
+   \allochostfunc(S, \hostfunc, \functype) &=& S', \funcaddr \\[1ex]
+   \mbox{where:} \hfill \\
+   \funcaddr &=& |S.\FUNCS| \\
+   \funcinst &=& \{ \TYPE~\functype, \CODE~\hostfunc \} \\
+   S' &=& S \compose \{\FUNCS~\tableinst\} \\
+   \end{array}
+
+.. note::
+   Host functions are never allocated by the WebAssembly semantics itself,
+   but may be allocated by the embedder.
+
+
+.. _alloc-table:
+
+:ref:`Tables <syntax-tableinst>`
+................................
+
+1. Let :math:`\table` be the :ref:`table <syntax-table>` to allocate.
+
+2. Let :math:`(\{\MIN~n, \MAX~m^?\}~\elemtype)` be the :ref:`table type <syntax-tabletype>` :math:`\table.\TYPE`.
+
+3. Let :math:`a` be the first free :ref:`table address <syntax-tableaddr>` in :math:`S`.
+
+4. Let :math:`\tableinst` be the :ref:`table instance <syntax-tableinst>` :math:`\{ \ELEM~(\epsilon)^n, \MAX~m^? \}` with :math:`n` empty elements.
+
+5. Append :math:`\tableinst` to the |TABLES| of :math:`S`.
+
+6. Return :math:`a`.
+
+.. math::
+   \begin{array}{rlll}
+   \alloctable(S, \table) &=& S', \tableaddr \\[1ex]
+   \mbox{where:} \hfill \\
+   \table.\TYPE &=& \{\MIN~n, \MAX~m^?\}~\elemtype \\
+   \tableaddr &=& |S.\TABLES| \\
+   \tableinst &=& \{ \ELEM~(\epsilon)^n, \MAX~m^? \} \\
+   S' &=& S \compose \{\TABLES~\tableinst\} \\
+   \end{array}
+
+.. _alloc-mem:
+
+:ref:`Memories <syntax-meminst>`
+................................
+
+1. Let :math:`\mem` be the :ref:`memory <syntax-mem>` to allocate.
+
+2. Let :math:`\{\MIN~n, \MAX~m^?\}` be the :ref:`table type <syntax-memtype>` :math:`\mem.\TYPE`.
+
+3. Let :math:`a` be the first free :ref:`memory address <syntax-memaddr>` in :math:`S`.
+
+4. Let :math:`\meminst` be the :ref:`memory instance <syntax-meminst>` :math:`\{ \DATA~(\hex{00})^{n \cdot 64\,\F{Ki}}, \MAX~m^? \}` that contains :math:`n` pages of zeroed bytes.
+
+5. Append :math:`\meminst` to the |MEMS| of :math:`S`.
+
+6. Return :math:`a`.
+
+.. math::
+   \begin{array}{rlll}
+   \allocmem(S, \mem) &=& S', \memaddr \\[1ex]
+   \mbox{where:} \hfill \\
+   \mem.\TYPE &=& \{\MIN~n, \MAX~m^?\} \\
+   \memaddr &=& |S.\MEMS| \\
+   \meminst &=& \{ \DATA~(\hex{00})^{n \cdot 64\,\F{Ki}}, \MAX~m^? \} \\
+   S' &=& S \compose \{\MEMS~\meminst\} \\
+   \end{array}
+
+.. _alloc-global:
+
+:ref:`Globals <syntax-globalinst>`
+..................................
+
+1. Let :math:`\global` be the :ref:`global <syntax-global>` to allocate.
+
+2. Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`\global.\TYPE`.
+
+3. Let :math:`a` be the first free :ref:`global address <syntax-globaladdr>` in :math:`S`.
+
+4. Let :math:`\globalinst` be the :ref:`global instance <syntax-globalinst>` :math:`\{ \VALUE~(t.\CONST~0), \MUT~\mut \}` whose contents is a zero :ref:`value <syntax-val>` of :ref:`value type <syntax-valtype>` :math:`t`.
+
+5. Append :math:`\globalinst` to the |GLOBALS| of :math:`S`.
+
+6. Return :math:`a`.
+
+.. math::
+   \begin{array}{rlll}
+   \allocglobal(S, \global) &=& S', \globaladdr \\[1ex]
+   \mbox{where:} \hfill \\
+   \global.\TYPE &=& \mut~t \\
+   \globaladdr &=& |S.\GLOBALS| \\
+   \globalinst &=& \{ \VALUE~(t.\CONST~0), \MUT~\mut \} \\
+   S' &=& S \compose \{\GLOBALS~\globalinst\} \\
+   \end{array}
+
+.. _alloc-module:
+
+:ref:`Modules <syntax-moduleinst>`
+..................................
+
+The allocation function for :ref:`modules <syntax-module>` requires a suitable list of :ref:`external values <syntax-externval>` that are assumed to :ref:`match <match-externtype>` the :ref:`import <syntax-import>` vector of the module.
+
+1. Let :math:`\module` be the :ref:`module <syntax-module>` to allocate and :math:`\externval_{\F{im}}^\ast` the vector of :ref:`external values <syntax-externval>` providing the module's imports.
+
+2. For each :ref:`function <syntax-func>` :math:`\func_i` in :math:`\module.\FUNCS`, do:
+
+   a. Let :math:`\funcaddr_i` be the :ref:`function address <syntax-funcaddr>` resulting from :ref:`allocating <alloc-func>` :math:`\func_i` for the :ref:`\module instance <syntax-moduleinst>` :math:`\moduleinst` defined below.
+
+3. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\TABLES`, do:
+
+   a. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i`.
+
+4. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MEMS`, do:
+
+   a. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` resulting from :ref:`allocating <alloc-mem>` :math:`\mem_i`.
+
+5. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\GLOBALS`, do:
+
+   a. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\global_i`.
+
+6. Let :math:`\funcaddr^\ast` be the the concatenation of the :ref:`function addresses <syntax-funcaddr>` :math:`\funcaddr_i` in index order.
+
+7. Let :math:`\tableaddr^\ast` be the the concatenation of the :ref:`table addresses <syntax-tableaddr>` :math:`\tableaddr_i` in index order.
+
+8. Let :math:`\memaddr^\ast` be the the concatenation of the :ref:`memory addresses <syntax-memaddr>` :math:`\memaddr_i` in index order.
+
+9. Let :math:`\globaladdr^\ast` be the the concatenation of the :ref:`global addresses <syntax-globaladdr>` :math:`\globaladdr_i` in index order.
+
+10. Let :math:`\funcaddr_{\F{mod}}^\ast` be the list of :ref:`function addresses <syntax-funcaddr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\funcaddr^\ast`.
+
+11. Let :math:`\tableaddr_{\F{mod}}^\ast` be the list of :ref:`table addresses <syntax-tableaddr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\tableaddr^\ast`.
+
+12. Let :math:`\memaddr_{\F{mod}}^\ast` be the list of :ref:`memory addresses <syntax-memaddr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\memaddr^\ast`.
+
+13. Let :math:`\globaladdr_{\F{mod}}^\ast` be the list of :ref:`global addresses <syntax-globaladdr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\globaladdr^\ast`.
+
+14. For each :ref:`export <syntax-export>` :math:`\export_i` in :math:`\module.\EXPORTS`, do:
+
+    a. If :math:`\export_i` is a function export for :ref:`function index <syntax-funcidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\FUNC~(\funcaddr_{\F{mod}}^\ast[x])`.
+
+    b. Else, if :math:`\export_i` is a table export for :ref:`table index <syntax-tableidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\TABLE~(\tableaddr_{\F{mod}}^\ast[x])`.
+
+    c. Else, if :math:`\export_i` is a memory export for :ref:`memory index <syntax-memidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\MEM~(\memaddr_{\F{mod}}^\ast[x])`.
+
+    d. Else, if :math:`\export_i` is a global export for :ref:`global index <syntax-globalidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\GLOBAL~(\globaladdr_{\F{mod}}^\ast[x])`.
+
+    e. Let :math:`\exportinst_i` be the :ref:`export instance <syntax-exportinst>` :math:`\{\NAME~(\export_i.\NAME), \VALUE~\externval_i\}`.
+
+15. Let :math:`\exportinst^\ast` be the the concatenation of the :ref:`export instances <syntax-exportinst>` :math:`\exportinst_i` in index order.
+
+16. Let :math:`\moduleinst` be the :ref:`module instance <syntax-moduleinst>` :math:`\{\TYPES~(\module.\TYPES),` :math:`\FUNCS~\funcaddr_{\F{mod}}^\ast,` :math:`\TABLES~\tableaddr_{\F{mod}}^\ast,` :math:`\MEMS~\memaddr_{\F{mod}}^\ast,` :math:`\GLOBALS~\globaladdr_{\F{mod}}^\ast,` :math:`\EXPORTS~\exportinst^\ast\}`.
+
+17. Return :math:`\moduleinst`.
+
+
+.. math::
+   \begin{array}{rlll}
+   \allocmodule(S, \module, \externval_{\F{im}}^\ast) &=& S', \moduleinst \\[1ex]
+   \mbox{where:} \hfill \\
+   \end{array}
+
+.. math::
+   \begin{array}{rlll}
+   \moduleinst &=& \{~
+     \begin{array}[t]{@{}l@{}}
+     \TYPES~\module.\TYPES, \\
+     \FUNCS~\funcs(\externval_{\F{im}}^\ast)~\funcaddr^\ast, \\
+     \TABLES~\tables(\externval_{\F{im}}^\ast)~\tableaddr^\ast, \\
+     \MEMS~\mems(\externval_{\F{im}}^\ast)~\memaddr^\ast, \\
+     \GLOBALS~\globals(\externval_{\F{im}}^\ast)~\globaladdr^\ast, \\
+     \EXPORTS~\exportinst^\ast ~\}
+     \end{array} \\[1ex]
+   S_1, \funcaddr^\ast &=& \allocfunc^\ast(S, \module.\FUNCS, \moduleinst) \\
+   S_2, \tableaddr^\ast &=& \alloctable^\ast(S_1, \module.\TABLES) \\
+   S_3, \memaddr^\ast &=& \allocmem^\ast(S_2, \module.\MEMS) \\
+   S', \globaladdr^\ast &=& \allocglobal^\ast(S_3, \module.\GLOBALS) \\[1ex]
+   \exportinst^\ast &=& \{ \NAME~(\export.\NAME), \VALUE~\externval_{\F{ex}} \}^\ast
+     & (\export^\ast = \module.\EXPORTS) \\
+   \funcs(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\FUNCS[x])^\ast
+     & (x^\ast = \funcs(\module.\EXPORTS)) \\
+   \tables(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\TABLES[x])^\ast
+     & (x^\ast = \tables(\module.\EXPORTS)) \\
+   \mems(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MEMS[x])^\ast
+     & (x^\ast = \mems(\module.\EXPORTS)) \\
+   \globals(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\GLOBALS[x])^\ast
+     & (x^\ast = \globals(\module.\EXPORTS)) \\
+   \end{array}
+
+Here, the notation :math:`\F{allocX}^\ast` is shorthand for multiple :ref:`allocations <alloc>` of object kind :math:`X`, defined as follows:
+
+.. math::
+   \begin{array}{rlll}
+   \F{allocX}^\ast(S_0, X^n, \dots) &=& S_n, a^n \\[1ex]
+   \mbox{where for all $i < n$:} \hfill \\
+   S_{i+1}, a^n[i] &=& \F{allocX}(S_i, X^n[i], \dots)
+   \end{array}
+
+.. note::
+   The definition of module allocation is mutually recursive with the allocation of its associated functions, because the resulting module instance :math:`\moduleinst` is passed to the function allocator as an argument, in order to form the necessary closures.
+   In an implementation, this recursion is easily unraveled by mutating one or the other in a secondary step.
+
+
+.. _instantiation:
+.. _exec-module:
+.. index:: ! instantiation, module, instance, store
+
+Instantiation
+~~~~~~~~~~~~~
+
+Given a :ref:`store <syntax-store>` :math:`S`, a :ref:`module <syntax-module>` :math:`\module` is instantiated with a list of :ref:`external values <syntax-externval>` :math:`\externval^n` supplying the required imports as follows.
+Instantiation may *fail* with an error.
+
+1. If :math:`\module` is not :ref:`valid <valid-module>`, then:
+
+   a. Fail.
+
+2. Assert: :math:`\module` is :ref:`valid <valid-module>` with :ref:`external types <syntax-externtype>` :math:`\externtype^m` classifying its :ref:`imports <syntax-import>`.
+
+3. If the number :math:`m` of :ref:`imports <syntax-import>` is not equal to the number :math:`n` of provided :ref:`external values <syntax-externval>`, then:
+
+   a. Fail.
+
+4. For each :ref:`external value <syntax-externval>` :math:`\externval_i` in :math:`\externval^n` and :ref:`external type <syntax-externtype>` :math:`\externtype_i` in :math:`\externtype^n`, do:
+
+   a. Assert: :math:`\externval_i` is :ref:`valid <valid-externval>` with :ref:`external type <syntax-externtype>` :math:`\externtype'_i` in store :math:`S`.
+
+   b. If :math:`\externtype'_i` does not :ref:`match <match-externtype>` :math:`\externtype_i`, then:
+
+      i. Fail.
+
+5. Let :math:`\moduleinst` be a new module instance :ref:`allocated <alloc-module>` from :math:`\module` in store :math:`S`.
+
+6. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \MODULE~\moduleinst, \LOCALS~\epsilon \}`.
+
+7. Push the frame :math:`F` to the stack.
+
+8. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\ELEM`, do:
+
+   a. Let :math:`\X{eoval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\elem_i.\OFFSET`.
+
+   b. Assert: due to :ref:`validation <valid-elem>`, :math:`\X{eoval}_i` is of the form :math:`\I32.\CONST~\X{eo}_i`.
+
+   c. Let :math:`\tableidx_i` be the :ref:`table index <syntax-tableidx>` :math:`\elem_i.\TABLE`.
+
+   d. Assert: due to :ref:`validation <valid-elem>`, :math:`\moduleinst.\TABLES[\tableidx_i]` exists.
+
+   e. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` :math:`\moduleinst.\TABLES[\tableidx_i]`.
+
+   f. Assert: due to :ref:`validation <valid-elem>`, :math:`S.\TABLES[\tableaddr_i]` exists.
+
+   g. Let :math:`\tableinst_i` be the :ref:`table instance <syntax-tableinst>` :math:`S.\TABLES[\tableaddr_i]`.
+
+   h. Let :math:`\X{eend}_i` be :math:`\X{eo}_i` plus the length of :math:`\elem_i.\INIT`.
+
+   i. If :math:`\X{eend}_i` is larger than the length of :math:`\tableinst_i.\ELEM`, then:
+
+      i. Fail.
+
+9. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\DATA`, do:
+
+   a. Let :math:`\X{doval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\data_i.\OFFSET`.
+
+   b. Assert: due to :ref:`validation <valid-data>`, :math:`\X{doval}_i` is of the form :math:`\I32.\CONST~\X{do}_i`.
+
+   c. Let :math:`\memidx_i` be the :ref:`memory index <syntax-memidx>` :math:`\data_i.\MEM`.
+
+   d. Assert: due to :ref:`validation <valid-data>`, :math:`\moduleinst.\MEMS[\memidx_i]` exists.
+
+   e. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` :math:`\moduleinst.\MEMS[\memidx_i]`.
+
+   f. Assert: due to :ref:`validation <valid-data>`, :math:`S.\MEMS[\memaddr_i]` exists.
+
+   g. Let :math:`\meminst_i` be the :ref:`memory instance <syntax-meminst>` :math:`S.\MEMS[\memaddr_i]`.
+
+   h. Let :math:`\X{dend}_i` be :math:`\X{do}_i` plus the length of :math:`\data_i.\INIT`.
+
+   i. If :math:`\X{dend}_i` is larger than the length of :math:`\meminst_i.\DATA`, then:
+
+      i. Fail.
+
+10. Let :math:`\globalidx_{\F{new}}` be the :ref:`global index <syntax-globalidx>` that corresponds to the number of global :ref:`imports <syntax-import>` in :math:`\module.\IMPORTS` (i.e., the index of the first non-imported global).
+
+11. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\GLOBALS`, do:
+
+    a. Let :math:`\val_i` be the result of :ref:`evaluating <exec-expr>` the initializer expression :math:`\global_i.\INIT`.
+
+    b. Let :math:`\globalidx_i` be the :ref:`global index <syntax-globalidx>` :math:`\globalidx_{\F{new}} + i`.
+
+    c. Assert: due to :ref:`validation <valid-global>`, :math:`\moduleinst.\GLOBALS[\globalidx_i]` exists.
+
+    d. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` :math:`\moduleinst.\GLOBALS[\globalidx_i]`.
+
+    e. Assert: due to :ref:`validation <valid-global>`, :math:`S.\GLOBALS[\globaladdr_i]` exists.
+
+    f. Let :math:`\globalinst_i` be the :ref:`global instance <syntax-globalinst>` :math:`S.\GLOBALS[\globaladdr_i]`.
+
+12. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F` is now on the top of the stack.
+
+13. Pop the frame from the stack.
+
+14. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\ELEM`, do:
+
+    a. For each :ref:`function index <syntax-funcidx>` :math:`\funcidx_{ij}` in :math:`\elem_i.\INIT` (starting with :math:`j = 0`), do:
+
+       i. Assert: due to :ref:`validation <valid-elem>`, :math:`\moduleinst.\FUNCS[\funcidx_{ij}]` exists.
+
+       ii. Let :math:`\funcaddr_{ij}` be the :ref:`function address <func-addr>` :math:`\moduleinst.\FUNCS[\funcidx_{ij}]`.
+
+       iii. Replace :math:`\tableinst_i.\ELEM[\X{eo}_i + j]` with :math:`\funcaddr_{ij}`.
+
+15. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\DATA`, do:
+
+    a. For each :ref:`byte <syntax-byte>` :math:`b_{ij}` in :math:`\data_i.\INIT` (starting with :math:`j = 0`), do:
+
+       i. Replace :math:`\meminst_i.\DATA[\X{do}_i + j]` with :math:`b_{ij}`.
+
+16. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\GLOBALS`, do:
+
+    a. Replace :math:`\globalinst_i.\VALUE` with :math:`\val_i`.
+
+17. If the :ref:`start function <syntax-start>` :math:`\module.\START` is not empty, then:
+
+    a. Assert: due to :ref:`validation <valid-start>`, :math:`\moduleinst.\FUNCS[\module.\START]` exists.
+
+    b. Let :math:`\funcaddr` be the :ref:`function address <func-addr>` :math:`\moduleinst.\FUNCS[\module.\START]`.
+
+    c. :ref:`Invoke <exec-invoke>` the function instance at :math:`\funcaddr`.
+
+.. math::
+   \begin{array}{@{}rcll}
+   S; \INSTANTIATE~\module~\externval^n &\stepto& S';
+     \begin{array}[t]{@{}l@{}}
+     (\INITTABLE~\tableaddr~\X{eo}~\moduleinst~\elem.\INIT)^\ast \\
+     (\INITMEM~\memaddr~\X{do}~\data.\INIT)^\ast \\
+     (\INITGLOBAL~\globaladdr~v)^\ast \\
+     (\INVOKE~\funcaddr)^? \\
+     \moduleinst \\
+     \end{array} \\
+   &\mbox{if}
+     & \vdash \module : \externtype^n \\
+     &\wedge& (\vdash \externval : \externtype')^n \\
+     &\wedge& (\vdash \externtype' \leq \externtype)^n \\[1ex]
+     &\wedge& \module.\GLOBALS = \global^k \\
+     &\wedge& \module.\ELEM = \elem^\ast \\
+     &\wedge& \module.\DATA = \data^\ast \\
+     &\wedge& \module.\START = \start^? \\[1ex]
+     &\wedge& S', \moduleinst = \F{allocmodule}(S, \module, \externval^n) \\
+     &\wedge& F = \{ \MODULE~\moduleinst, \LOCALS~\epsilon \} \\[1ex]
+     &\wedge& (S'; F; \elem.\OFFSET \stepto^\ast S'; F; \I32.\CONST~\X{eo})^\ast \\
+     &\wedge& (S'; F; \data.\OFFSET \stepto^\ast S'; F; \I32.\CONST~\X{do})^\ast \\
+     &\wedge& (S'; F; \global.\INIT \stepto^\ast S'; F; v)^\ast \\[1ex]
+     &\wedge& (\tableaddr = \moduleinst.\TABLES[\elem.\TABLE])^\ast \\
+     &\wedge& (\memaddr = \moduleinst.\MEMS[\data.\MEM])^\ast \\
+     &\wedge& \globaladdr^\ast = \moduleinst.\GLOBALS[|\globals(\module.\IMPORTS)|:k] \\
+     &\wedge& (\funcaddr = \moduleinst.\FUNCS[\start.\FUNC])^? \\[1ex]
+     &\wedge& (\X{eo} + |\elem.\INIT| \leq |S'.\TABLES[\tableaddr].\ELEM|)^\ast \\
+     &\wedge& (\X{do} + |\data.\INIT| \leq |S'.\MEMS[\memaddr].\DATA|)^\ast \\[1ex]
+   S; \INSTANTIATE~\module~\externval^n &\stepto&
+     S'; \TRAP  \qquad (\mbox{otherwise}) \\[1ex]
+   S; \INITTABLE~a~i~m~\epsilon &\stepto&
+     S; \epsilon \\
+   S; \INITTABLE~a~i~m~(x_0~x^\ast) &\stepto&
+     S'; \INITTABLE~a~(i+1)~m~x^\ast \\ &&
+     (S' = S \with \TABLES[a].\ELEM[i] = m.\FUNCS[x_0]) \\[1ex]
+   S; \INITMEM~a~i~\epsilon &\stepto&
+     S; \epsilon \\
+   S; \INITMEM~a~i~(b_0~b^\ast) &\stepto&
+     S'; \INITMEM~a~(i+1)~b^\ast \\ &&
+     (S' = S \with \MEMS[a].\DATA[i] = b_0) \\[1ex]
+   S; \INITGLOBAL~a~v &\stepto&
+     S'; \epsilon \\ &&
+     (S' = S \with \GLOBALS[a] = v) \\
+   \end{array}
+
+.. note::
+   All failure conditions are checked before any observable mutation of the store takes place.
+   Store mutation is not atomic;
+   it happens in individual steps that may be interleaved with other threads.
+
+
+.. _invocation:
+.. _exec-call-export:
+.. index:: ! invocation, module, instance, function, export, function address
+
+Invocation
+~~~~~~~~~~
+
+Once a :ref:`module <syntax-module>` has been :ref:`instantiated <instantiation>`, any exported function can be *invoked* externally via its :ref:`function address <syntax-funcaddr>` :math:`\funcaddr` in the :ref:`store <syntax-store>` :math:`S` and an appropriate list :math:`\val^\ast` of argument :ref:`values <syntax-val>`.
+If successful, the invocation returns the function's result values :math:`\val_{\F{res}}^\ast`.
+
+The following steps are performed:
+
+1. Assert: :math:`S.\FUNCS[\funcaddr]` exists.
+
+2. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`S.\FUNCS[\funcaddr]`.
+
+3. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`\funcinst.\TYPE`.
+
+4. If the length :math:`|\val^\ast|` of the provided argument values is different from the number :math:`n` of expected arguments, then:
+
+   a. Fail.
+
+5. For each :ref:`value type <syntax-valtype>` :math:`t_i` in :math:`t_1^n` and corresponding :ref:`value <syntax-val>` :math:`val_i` in :math:`\val^\ast`, do:
+
+   a. If :math:`\val_i` is not :math:`t_i.\CONST~c_i` for some :math:`c_i`, then:
+
+      i. Fail.
+
+6. Push the values :math:`\val^\ast` to the stack.
+
+7. :ref:`Invoke <exec-invoke>` the function instance at address :math:`\funcaddr`.
+
+.. note::
+   If the embedder performs type checks itself, either statically or dynamically, no failure can occur.
+
+Once the function has returned, the following steps are executed:
+
+1. Assert: due to :ref:`validation <valid-func>`, :math:`m` :ref:`values <syntax-val>` are on the top of the stack.
+
+2. Pop :math:`\val_{\F{res}}^m` from the stack.
+
+The values :math:`\val_{\F{res}}^m` are the results of the call.
+
+If the function terminates with a :ref:`trap <trap>`, the error is propagated to the caller in a manner specified by the :ref:`embedder <embedder>`.
+
+.. math::
+   \begin{array}{@{}lcl}
+   \F{invoke}(S, \funcaddr, \val^n) &=& \val_{\F{res}}^m / \TRAP \\
+     &\mbox{if}& S.\FUNCS[\funcaddr].\TYPE = [t_1^n] \to [t_2^m] \\
+     &\wedge& \val^n = (t_1.\CONST~c)^n \\
+     &\wedge& S; \val^n~(\INVOKE~\funcaddr) \stepto^\ast S'; \val_{\F{res}}^m / \TRAP \\
+   \end{array}
diff --git a/document/execution/runtime.rst b/document/execution/runtime.rst
index a7e6ead04..e313d28f2 100644
--- a/document/execution/runtime.rst
+++ b/document/execution/runtime.rst
@@ -103,12 +103,15 @@ These are simply indices into the respective store component.
    Addresses are *dynamic*, globally unique references to runtime objects,
    in contrast to :ref:`indices <syntax-index>`,
    which are *static*, module-local references to their original definitions.
+   A *memory address* |memaddr| denotes the abstract address *of* a memory *instance* in the store,
+   not an offset *inside* a memory instance.
 
    There is no specific limit on the number of allocations of store objects,
    hence logical addresses can be arbitrarily large natural numbers.
 
-   A *memory address* |memaddr| denotes the abstract address *of* a memory *instance* in the store,
-   not an offset *inside* a memory instance.
+An :ref:`embedder <embedder>` may assign identity to :ref:`exported <syntax-export>` store objects corresponding to their addresses,
+even where this identity is not observable from within WebAssembly code itself
+(such as for :ref:`function instances <syntax-funcinst>` or immutable :ref:`globals <syntax-global>`).
 
 
 .. _syntax-moduleinst:
@@ -143,6 +146,7 @@ It is an invariant of the semantics that all :ref:`export instances <syntax-expo
 
 
 .. _syntax-funcinst:
+.. _syntax-hostfunc:
 .. index:: ! function instance, module instance, function, closure
    pair: abstract syntax; function instance
    pair: function; instance
@@ -157,13 +161,19 @@ The module instance is used to resolve references to other non-local definitions
 .. math::
    \begin{array}{llll}
    \production{(function instance)} & \funcinst &::=&
-     \{ \MODULE~\moduleinst, \CODE~\func \} \\
+     \{ \TYPE~\functype, \MODULE~\moduleinst, \CODE~\func \} \\ &&|&
+     \{ \TYPE~\functype, \CODE~\hostfunc \} \\
+   \production{(host function)} & \hostfunc &::=& \dots \\
    \end{array}
 
-Function instances are immutable, and their identity is not observable by WebAssembly code.
-However, the :ref:`embedder <embedder>` might provide implicit or explicit means for distinguishing them.
+A *host function* is a function expressed outside WebAssembly but passed to a :ref:`module <syntax-module>` as an :ref:`import <syntax-import>`.
+The definition and behavior of host functions are outside the scope of this specification.
+For the purpose of this specification, it is assumed that when :ref:`invoked <exec-invoke-host>`,
+a host function behaves non-deterministically.
 
-.. todo:: Host functions?
+.. note::
+   Function instances are immutable, and their identity is not observable by WebAssembly code.
+   However, the :ref:`embedder <embedder>` might provide implicit or explicit means for distinguishing their :ref:`addresses <syntax-funcaddr>` when :ref:`exported <syntax-export>`, either directly or through an entry in a :ref:`table <syntax-table>`.
 
 
 .. _syntax-tableinst:
@@ -295,41 +305,6 @@ It filters out entries of a specific kind in an order-preserving fashion:
    \end{array}
 
 
-.. _syntax-externtype:
-.. index:: ! external type, function type, table type, memory type, global type
-   pair: abstract syntax; external type
-   pair: external; type
-
-External Types
-~~~~~~~~~~~~~~
-
-*External types* classify :ref:`external values <syntax-externval>`, and thereby imports and exports, with their respective types.
-
-.. math::
-   \begin{array}{llll}
-   \production{external types} & \externtype &::=&
-     \FUNC~\functype ~|~
-     \TABLE~\tabletype ~|~
-     \MEM~\memtype ~|~
-     \GLOBAL~\globaltype \\
-   \end{array}
-
-
-Conventions
-...........
-
-The following auxiliary notation is defined for sequences of external types.
-It filters out entries of a specific kind in an order-preserving fashion:
-
-.. math::
-   \begin{array}{lcl}
-   \funcs(\externtype^\ast) &=& [\functype ~|~ (\FUNC~\functype) \in \externtype^\ast] \\
-   \tables(\externtype^\ast) &=& [\tabletype ~|~ (\TABLE~\tabletype) \in \externtype^\ast] \\
-   \mems(\externtype^\ast) &=& [\memtype ~|~ (\MEM~\memtype) \in \externtype^\ast] \\
-   \globals(\externtype^\ast) &=& [\globaltype ~|~ (\GLOBAL~\globaltype) \in \externtype^\ast] \\
-   \end{array}
-
-
 .. _stack:
 .. _frame:
 .. _label:
@@ -423,6 +398,8 @@ Conventions
 
 
 .. _syntax-instr-admin:
+.. _syntax-trap:
+.. _syntax-invoke:
 .. index:: ! administrative instructions, function, function instance, function address, label, frame, instruction, trap
    pair:: abstract syntax; administrative instruction
 
@@ -435,13 +412,13 @@ Administrative Instructions
 In order to express the reduction of :ref:`traps <trap>`, calls, and :ref:`control instructions <syntax-instr-control>`, the syntax of instructions is extended to include the following *administrative instructions*:
 
 .. math::
-   \begin{array}{llll}
+   \begin{array}{llcl}
    \production{(administrative instruction)} & \instr &::=&
-     \dots ~|~ \\&&&
-     \TRAP ~|~ \\&&&
-     \INVOKE~\funcaddr ~|~ \\&&&
-     \LABEL_n\{\instr^\ast\}~\instr^\ast~\END ~|~ \\&&&
-     \FRAME_n\{\frame\}~\instr^\ast~\END ~|~ \\
+     \dots \\ &&|&
+     \TRAP \\ &&|&
+     \INVOKE~\funcaddr \\ &&|&
+     \LABEL_n\{\instr^\ast\}~\instr^\ast~\END \\ &&|&
+     \FRAME_n\{\frame\}~\instr^\ast~\END \\
    \end{array}
 
 The |TRAP| instruction represents the occurrence of a trap.
@@ -537,3 +514,58 @@ Finally, the following definition of *evaluation context* and associated structu
    S; F; E[\TRAP] &\stepto& S; F; \TRAP
      & (\mbox{if}~E \neq [\_]) \\
    \end{array}
+
+
+.. _syntax-instr-module:
+.. index:: ! module instructions, function, function instance, function address, label, frame, instruction, trap
+   pair:: abstract syntax; meta instruction
+
+Module Instructions
+...................
+
+Module :ref:`instantiation <instantiation>` is a complex operation.
+It is hence expressed in terms of reduction into smaller steps expressed by a sequence of administrative *module instructions* that are a superset of ordinary instructions and defined as follow.
+
+.. math::
+   \begin{array}{llcl}
+   \production{(module instruction)} & \moduleinstr &::=&
+     \instr \\ &&|&
+     \INSTANTIATE~\module~\externval^\ast \\ &&|&
+     \INITTABLE~\tableaddr~\u32~\moduleinst~funcidx^\ast \\ &&|&
+     \INITMEM~\memaddr~\u32~\byte^\ast \\ &&|&
+     \INITGLOBAL~\globaladdr~\val \\ &&|&
+     \moduleinst \\
+   \end{array}
+
+The |INSTANTIATE| instruction expresses instantiation of a :ref:`module <syntax-module>` itself, requiring a sequence of :ref:`external values <syntax-externval>` for the expected imports.
+It reduces into a sequence of initialization instructions for :ref:`tables <syntax-table>`, :ref:`memories <syntax-mem>` and :ref:`globals <syntax-global>`,
+and a possible :ref:`invocation <syntax-invoke>` of the :ref:`start function <syntax-start>`.
+The final instruction returns the newly created and initialized :ref:`module instance <syntax-moduleinst>`.
+
+.. note::
+   The reason for splitting instantiation into individual reduction steps is to provide a semantics that is compatible with future extensions like threads.
+
+   Unlike the administrative instructions above,
+   module instructions *embed* ordinary instructions |instr| instead of extending them.
+   Consequently, they can only occur at the top-level.
+
+Evaluation contexts and additional structural reduction rules for module instructions are defined as follows:
+
+.. math::
+   \begin{array}{llll}
+   \production{(module evaluation contexts)} & M &::=&
+     E~~\moduleinstr^\ast \\
+   \end{array}
+
+.. math::
+   \begin{array}{lcl@{\qquad}l}
+   S; M[\moduleinstr] &\stepto& S'; M[{\moduleinstr'}^\ast]
+     & (\mbox{if}~S; \moduleinstr \stepto S'; {\moduleinstr'}^\ast) \\
+   S; M[\TRAP] &\stepto& S; \TRAP
+     & (\mbox{if}~M \neq [\_]) \\
+   \end{array}
+
+Reduction terminates when the sequence has been reduced to a |moduleinst| or a trap occurred.
+
+.. note::
+   A trap may either arise from invocation of a :ref:`start function <syntax-start>` or indicate failure of the |INSTANTIATE| instruction itself.
diff --git a/document/math.def b/document/math.def
index 45356c60d..83dbee51a 100644
--- a/document/math.def
+++ b/document/math.def
@@ -487,12 +487,11 @@
 .. |LABEL| mathdef:: \xref{execution/runtime}{syntax-instr-admin}{\K{label}}
 .. |FRAME| mathdef:: \xref{execution/runtime}{syntax-instr-admin}{\K{frame}}
 
-.. |INVOKE| mathdef:: \xref{execution/instructions}{syntax-instr-admin}{\K{invoke}}
-.. |INSTANTIATE| mathdef:: \xref{execution/modules}{syntax-instantiate}{\K{instantiate}}
-.. |INITIALIZE| mathdef:: \xref{execution/modules}{syntax-instantiate}{\K{initialize}}
-.. |INITGLOBAL| mathdef:: \xref{execution/modules}{syntax-instantiate}{\K{init\_global}}
-.. |INITTABLE| mathdef:: \xref{execution/modules}{syntax-instantiate}{\K{init\_table}}
-.. |INITMEM| mathdef:: \xref{execution/modules}{syntax-instantiate}{\K{init\_mem}}
+.. |INVOKE| mathdef:: \xref{execution/runtime}{syntax-invoke}{\K{invoke}}
+.. |INSTANTIATE| mathdef:: \xref{execution/runtime}{syntax-instantiate}{\K{instantiate}}
+.. |INITGLOBAL| mathdef:: \xref{execution/runtime}{syntax-init_global}{\K{init\_global}}
+.. |INITTABLE| mathdef:: \xref{execution/runtime}{syntax-init_table}{\K{init\_table}}
+.. |INITMEM| mathdef:: \xref{execution/runtime}{syntax-init_mem}{\K{init\_mem}}
 
 
 .. Instructions, non-terminals
@@ -556,6 +555,7 @@
 .. Runtime, terminals
 
 .. |MUT| mathdef:: \K{mut}
+.. |HOST| mathdef:: \K{host}
 
 
 .. Runtime, non-terminals
@@ -575,6 +575,7 @@
 .. |meminst| mathdef:: \xref{execution/runtime}{syntax-meminst}{\X{meminst}}
 .. |globalinst| mathdef:: \xref{execution/runtime}{syntax-globalinst}{\X{globalinst}}
 .. |exportinst| mathdef:: \xref{execution/runtime}{syntax-exportinst}{\X{exportinst}}
+.. |hostfunc| mathdef:: \xref{execution/runtime}{syntax-hostfunc}{\X{hostfunc}}
 
 .. |externval| mathdef:: \xref{execution/runtime}{syntax-externval}{\X{externval}}
 .. |externtype| mathdef:: \xref{execution/runtime}{syntax-externtype}{\X{externtype}}
@@ -586,12 +587,21 @@
 
 .. |XB| mathdef:: \xref{execution/runtime}{syntax-ctxt-block}{B}
 
+.. |moduleinstr| mathdef:: \xref{execution/runtime}{syntax-moduleinstr}{\X{moduleinstr}}
+
 
 .. Execution, notation
 
 .. |stepto| mathdef:: \hookrightarrow
 .. |mod| mathdef:: \mathbin{\F{mod}}
 
+.. |allocfunc| mathdef:: \xref{execution/modules}{alloc-func}{\F{allocfunc}}
+.. |allochostfunc| mathdef:: \xref{execution/modules}{alloc-hostfunc}{\F{allochostfunc}}
+.. |alloctable| mathdef:: \xref{execution/modules}{alloc-table}{\F{alloctable}}
+.. |allocmem| mathdef:: \xref{execution/modules}{alloc-mem}{\F{allocmem}}
+.. |allocglobal| mathdef:: \xref{execution/modules}{alloc-global}{\F{allocglobal}}
+.. |allocmodule| mathdef:: \xref{execution/modules}{alloc-module}{\F{allocmodule}}
+
 
 .. Numerics, meta functions
 
diff --git a/document/syntax/instructions.rst b/document/syntax/instructions.rst
index f7eada93f..b90f77b8c 100644
--- a/document/syntax/instructions.rst
+++ b/document/syntax/instructions.rst
@@ -212,8 +212,8 @@ The |TEELOCAL| instruction is like |SETLOCAL| but also returns its argument.
 
 
 .. _syntax-instr-memory:
-.. _syntax-load:
-.. _syntax-store:
+.. _syntax-loadn:
+.. _syntax-storen:
 .. _syntax-memarg:
 .. index:: ! memory instruction, memory index
    pair: abstract syntax; instruction
diff --git a/document/syntax/types.rst b/document/syntax/types.rst
index 73495faa4..559fe2cf5 100644
--- a/document/syntax/types.rst
+++ b/document/syntax/types.rst
@@ -176,3 +176,38 @@ Global Types
      \MCONST ~|~
      \MVAR \\
    \end{array}
+
+
+.. _syntax-externtype:
+.. index:: ! external type, function type, table type, memory type, global type
+   pair: abstract syntax; external type
+   pair: external; type
+
+External Types
+~~~~~~~~~~~~~~
+
+*External types* classify :ref:`imports <syntax-import>` and :ref:`external values <syntax-externval>` with their respective types.
+
+.. math::
+   \begin{array}{llll}
+   \production{external types} & \externtype &::=&
+     \FUNC~\functype ~|~
+     \TABLE~\tabletype ~|~
+     \MEM~\memtype ~|~
+     \GLOBAL~\globaltype \\
+   \end{array}
+
+
+Conventions
+...........
+
+The following auxiliary notation is defined for sequences of external types.
+It filters out entries of a specific kind in an order-preserving fashion:
+
+.. math::
+   \begin{array}{lcl}
+   \funcs(\externtype^\ast) &=& [\functype ~|~ (\FUNC~\functype) \in \externtype^\ast] \\
+   \tables(\externtype^\ast) &=& [\tabletype ~|~ (\TABLE~\tabletype) \in \externtype^\ast] \\
+   \mems(\externtype^\ast) &=& [\memtype ~|~ (\MEM~\memtype) \in \externtype^\ast] \\
+   \globals(\externtype^\ast) &=& [\globaltype ~|~ (\GLOBAL~\globaltype) \in \externtype^\ast] \\
+   \end{array}
diff --git a/document/validation/modules.rst b/document/validation/modules.rst
index 678e80dc0..ee238344b 100644
--- a/document/validation/modules.rst
+++ b/document/validation/modules.rst
@@ -544,6 +544,10 @@ Instead, the context :math:`C` for validation of the module's content is constru
 
 * All export names :math:`\name_i` must be different.
 
+* Let :math:`\externtype^\ast` be the concatenation of :ref:`external types <syntax-externtype>` :math:`\externtype_i` of the imports, in index order.
+
+* Then the module is valid with :ref:`external types <syntax-externtype>` :math:`\externtype^\ast`.
+
 .. math::
    \frac{
      \begin{array}{@{}c@{}}
@@ -597,7 +601,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
          \DATA~\data^\ast,
          \START~\start^?,
          \IMPORTS~\import^\ast,
-         \EXPORTS~\export^\ast \} ~\F{ok} \\
+         \EXPORTS~\export^\ast \} : \X{it}^\ast \\
        \end{array}
    }
 

From 20e4bd836745078d9a956e800af1491bb2d4898f Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 13 Jun 2017 17:05:10 +0200
Subject: [PATCH 038/329] [interpreter] Directory reorg (#500)

Reorganise directory structure of interpreter sources into smaller parts that match structure of spec document. The prior spec/ directory is split into

* `syntax`: the definition of abstract syntax; corresponds to the "Structure" section
* `valid`: validation of code and modules; corresponds to the "Validation" section
* `exec`: execution and module instantiation; corresponds to the "Execution" section
* `binary`: encoding and decoding of binary format; corresponds to the "Binary Format" section
* `text`: parsing and printing of text format; corresponds to the "Text Format" section

Similarly, the former host/ directory is split into

* `script`: abstract syntax and execution of the extended script language
* `main`: main program

The former host/imports becomes just host/.

And finally, the auxiliary directories `findlib`, `jslib`, and `travis` are moved under `meta/`.

Also, bump version of the interpreter to 1.0 and update `wast.js`.
---
 .travis.yml                                   |    4 +-
 interpreter/Makefile                          |   28 +-
 interpreter/README.md                         |   18 +-
 interpreter/_tags                             |    2 -
 interpreter/{spec => binary}/decode.ml        |    0
 interpreter/{spec => binary}/decode.mli       |    0
 interpreter/{spec => binary}/encode.ml        |    0
 interpreter/{spec => binary}/encode.mli       |    0
 interpreter/{spec => binary}/utf8.ml          |    0
 interpreter/{spec => binary}/utf8.mli         |    0
 interpreter/{spec => exec}/eval.ml            |    0
 interpreter/{spec => exec}/eval.mli           |    0
 interpreter/{spec => exec}/eval_numeric.ml    |    0
 interpreter/{spec => exec}/eval_numeric.mli   |    0
 interpreter/{spec => exec}/f32.ml             |    0
 interpreter/{spec => exec}/f32_convert.ml     |    0
 interpreter/{spec => exec}/f32_convert.mli    |    0
 interpreter/{spec => exec}/f64.ml             |    0
 interpreter/{spec => exec}/f64_convert.ml     |    0
 interpreter/{spec => exec}/f64_convert.mli    |    0
 interpreter/{spec => exec}/float.ml           |    0
 interpreter/{spec => exec}/i32.ml             |    0
 interpreter/{spec => exec}/i32_convert.ml     |    0
 interpreter/{spec => exec}/i32_convert.mli    |    0
 interpreter/{spec => exec}/i64.ml             |    0
 interpreter/{spec => exec}/i64_convert.ml     |    0
 interpreter/{spec => exec}/i64_convert.mli    |    0
 interpreter/{spec => exec}/instance.ml        |    0
 interpreter/{spec => exec}/int.ml             |    0
 interpreter/{spec => exec}/memory.ml          |    0
 interpreter/{spec => exec}/memory.mli         |    0
 interpreter/{spec => exec}/numeric_error.ml   |    0
 interpreter/{spec => exec}/table.ml           |    0
 interpreter/{spec => exec}/table.mli          |    0
 interpreter/host/{import => }/env.ml          |    0
 interpreter/host/{import => }/spectest.ml     |    0
 interpreter/{host => main}/flags.ml           |    0
 interpreter/{host => main}/main.ml            |    6 +-
 interpreter/{ => meta}/findlib/META           |    0
 interpreter/{ => meta}/jslib/bsconfig.json    |    0
 interpreter/{ => meta}/jslib/build.sh         |    2 +-
 interpreter/{ => meta}/jslib/wasm.ml          |    0
 interpreter/{ => meta}/travis/build-test.sh   |    2 +-
 .../{ => meta}/travis/install-ocaml.sh        |    4 +-
 interpreter/{host => script}/import.ml        |    0
 interpreter/{host => script}/import.mli       |    0
 interpreter/{host => script}/js.ml            |    0
 interpreter/{host => script}/js.mli           |    0
 interpreter/{host => script}/run.ml           |    0
 interpreter/{host => script}/run.mli          |    0
 interpreter/{text => script}/script.ml        |    0
 interpreter/{spec => syntax}/ast.ml           |    0
 interpreter/{spec => syntax}/operators.ml     |    0
 interpreter/{spec => syntax}/types.ml         |    0
 interpreter/{spec => syntax}/values.ml        |    0
 interpreter/{spec => valid}/valid.ml          |    0
 interpreter/{spec => valid}/valid.mli         |    0
 interpreter/winmake.bat                       |  166 +-
 test/harness/wast.js                          | 8234 ++++++++---------
 59 files changed, 4012 insertions(+), 4454 deletions(-)
 delete mode 100644 interpreter/_tags
 rename interpreter/{spec => binary}/decode.ml (100%)
 rename interpreter/{spec => binary}/decode.mli (100%)
 rename interpreter/{spec => binary}/encode.ml (100%)
 rename interpreter/{spec => binary}/encode.mli (100%)
 rename interpreter/{spec => binary}/utf8.ml (100%)
 rename interpreter/{spec => binary}/utf8.mli (100%)
 rename interpreter/{spec => exec}/eval.ml (100%)
 rename interpreter/{spec => exec}/eval.mli (100%)
 rename interpreter/{spec => exec}/eval_numeric.ml (100%)
 rename interpreter/{spec => exec}/eval_numeric.mli (100%)
 rename interpreter/{spec => exec}/f32.ml (100%)
 rename interpreter/{spec => exec}/f32_convert.ml (100%)
 rename interpreter/{spec => exec}/f32_convert.mli (100%)
 rename interpreter/{spec => exec}/f64.ml (100%)
 rename interpreter/{spec => exec}/f64_convert.ml (100%)
 rename interpreter/{spec => exec}/f64_convert.mli (100%)
 rename interpreter/{spec => exec}/float.ml (100%)
 rename interpreter/{spec => exec}/i32.ml (100%)
 rename interpreter/{spec => exec}/i32_convert.ml (100%)
 rename interpreter/{spec => exec}/i32_convert.mli (100%)
 rename interpreter/{spec => exec}/i64.ml (100%)
 rename interpreter/{spec => exec}/i64_convert.ml (100%)
 rename interpreter/{spec => exec}/i64_convert.mli (100%)
 rename interpreter/{spec => exec}/instance.ml (100%)
 rename interpreter/{spec => exec}/int.ml (100%)
 rename interpreter/{spec => exec}/memory.ml (100%)
 rename interpreter/{spec => exec}/memory.mli (100%)
 rename interpreter/{spec => exec}/numeric_error.ml (100%)
 rename interpreter/{spec => exec}/table.ml (100%)
 rename interpreter/{spec => exec}/table.mli (100%)
 rename interpreter/host/{import => }/env.ml (100%)
 rename interpreter/host/{import => }/spectest.ml (100%)
 rename interpreter/{host => main}/flags.ml (100%)
 rename interpreter/{host => main}/main.ml (92%)
 rename interpreter/{ => meta}/findlib/META (100%)
 rename interpreter/{ => meta}/jslib/bsconfig.json (100%)
 rename interpreter/{ => meta}/jslib/build.sh (99%)
 rename interpreter/{ => meta}/jslib/wasm.ml (100%)
 rename interpreter/{ => meta}/travis/build-test.sh (80%)
 rename interpreter/{ => meta}/travis/install-ocaml.sh (86%)
 rename interpreter/{host => script}/import.ml (100%)
 rename interpreter/{host => script}/import.mli (100%)
 rename interpreter/{host => script}/js.ml (100%)
 rename interpreter/{host => script}/js.mli (100%)
 rename interpreter/{host => script}/run.ml (100%)
 rename interpreter/{host => script}/run.mli (100%)
 rename interpreter/{text => script}/script.ml (100%)
 rename interpreter/{spec => syntax}/ast.ml (100%)
 rename interpreter/{spec => syntax}/operators.ml (100%)
 rename interpreter/{spec => syntax}/types.ml (100%)
 rename interpreter/{spec => syntax}/values.ml (100%)
 rename interpreter/{spec => valid}/valid.ml (100%)
 rename interpreter/{spec => valid}/valid.mli (100%)

diff --git a/.travis.yml b/.travis.yml
index 8df6e941d..4a06354cb 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,9 +2,9 @@ language: c++
 
 sudo: off
 
-install: ./interpreter/travis/install-ocaml.sh
+install: ./interpreter/meta/travis/install-ocaml.sh
 
-script: ./interpreter/travis/build-test.sh
+script: ./interpreter/meta/travis/build-test.sh
 
 os:
   - linux
diff --git a/interpreter/Makefile b/interpreter/Makefile
index 1dadb9dfc..7016f041e 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -17,7 +17,7 @@ ZIP =		$(NAME).zip
 JSLIB =		wast.js
 WINMAKE =	winmake.bat
 
-DIRS =		util spec text host host/import
+DIRS =		util syntax binary text valid exec script host main
 LIBS =		bigarray
 FLAGS = 	-cflags '-w +a-4-27-42-44-45 -warn-error +a'
 OCB =		ocamlbuild $(FLAGS) $(DIRS:%=-I %) $(LIBS:%=-libs %)
@@ -26,13 +26,14 @@ JS =		# set to JS shell command to run JS tests
 
 # Main targets
 
-.PHONY:		default opt unopt libopt libunopt all land zip
+.PHONY:		default opt unopt libopt libunopt jslib all land zip
 
 default:	opt
 opt:		$(OPT)
 unopt:		$(UNOPT)
 libopt:		_build/$(LIB).cmx
 libunopt:	_build/$(LIB).cmo
+jslib:		$(JSLIB)
 all:		unopt opt libunopt libopt test
 land:		all $(WINMAKE)
 zip: 		$(ZIP)
@@ -40,6 +41,15 @@ zip: 		$(ZIP)
 
 # Building executable
 
+empty =
+space =		$(empty) $(empty)
+comma =		,
+
+.INTERMEDIATE:	_tags
+_tags:
+		echo >$@ "true: bin_annot"
+		echo >>$@ "<{$(subst $(space),$(comma),$(DIRS))}/*.cmx>: for-pack($(PACK))"
+
 $(UNOPT):	main.d.byte
 		mv $< $@
 
@@ -47,15 +57,17 @@ $(OPT):		main.native
 		mv $< $@
 
 .PHONY:		main.d.byte main.native
-main.d.byte:
+main.d.byte:	_tags
 		$(OCB) -quiet $@
 
-main.native:
+main.native:	_tags
 		$(OCB) -quiet $@
 
 
 # Building library
 
+PACK =		$(shell echo `echo $(LIB) | sed 's/^\(.\).*$$/\\1/g' | tr [:lower:] [:upper:]``echo $(LIB) | sed 's/^.\(.*\)$$/\\1/g'`)
+
 .INTERMEDIATE:	$(LIB).mlpack
 $(LIB).mlpack:	$(DIRS)
 		ls $(DIRS:%=%/*.ml*) \
@@ -76,8 +88,8 @@ _build/$(LIB).cmx: $(LIB).mlpack
 .PHONY:		$(JSLIB)
 $(JSLIB):	$(UNOPT)
 		mkdir -p _build/jslib/src
-		cp jslib/* _build/jslib
-		cp $(DIRS:%=_build/%/*.ml*) jslib/*.ml _build/jslib/src
+		cp meta/jslib/* _build/jslib
+		cp $(DIRS:%=_build/%/*.ml*) meta/jslib/*.ml _build/jslib/src
 		rm _build/jslib/src/*.ml[^i]
 		(cd _build/jslib; ./build.sh ../../$@)
 
@@ -124,7 +136,7 @@ $(ZIP):		$(WINMAKE)
 		git archive --format=zip --prefix=$(NAME)/ -o $@ HEAD
 
 clean:
-		rm -rf _build/jslib wasm.mlpack
+		rm -rf _build/jslib wasm.mlpack _tags
 		$(OCB) -clean
 
 
@@ -138,7 +150,7 @@ check:
 		ocamlfind query $(LIBS)
 
 install:	_build/$(LIB).cmx _build/$(LIB).cmo
-		ocamlfind install wasm findlib/META _build/wasm.o \
+		ocamlfind install wasm meta/findlib/META _build/wasm.o \
 		  $(wildcard _build/$(LIB).cm*) \
 		  $(wildcard $(DIRS:%=%/*.mli))
 
diff --git a/interpreter/README.md b/interpreter/README.md
index 4fbff9b60..6426cdf92 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -354,13 +354,23 @@ However, to simplify the implementation, this AST representation represents some
 
 ## Implementation
 
-The implementation is split into four directories:
+The implementation is split into several directories:
 
-* `spec`: the part of the implementation that corresponds to the actual language specification.
+* `syntax`: the definition of abstract syntax; corresponds to the "Structure" section of the language specification
 
-* `text`: parsing and printing the S-expressions text format.
+* `valid`: validation of code and modules; corresponds to the "Validation" section of the language specification
 
-* `host`: infrastructure for loading and running scripts and defining host environment modules.
+* `exec`: execution and module instantiation; corresponds to the "Execution" section of the language specification
+
+* `binary`: encoding and decoding of the binary format; corresponds to the "Binary Format" section of the language specification
+
+* `text`: parsing and printing the S-expressions text format; corresponds to the "Text Format" section of the language specification
+
+* `script`: abstract syntax and execution of the extended script language
+
+* `host`: definition of host environment modules
+
+* `main`: main program
 
 * `util`: utility libraries.
 
diff --git a/interpreter/_tags b/interpreter/_tags
deleted file mode 100644
index 2ad0cbd8e..000000000
--- a/interpreter/_tags
+++ /dev/null
@@ -1,2 +0,0 @@
-true:       bin_annot
-<{util,spec,text,host,host/import}/*.cmx>:    for-pack(Wasm)
diff --git a/interpreter/spec/decode.ml b/interpreter/binary/decode.ml
similarity index 100%
rename from interpreter/spec/decode.ml
rename to interpreter/binary/decode.ml
diff --git a/interpreter/spec/decode.mli b/interpreter/binary/decode.mli
similarity index 100%
rename from interpreter/spec/decode.mli
rename to interpreter/binary/decode.mli
diff --git a/interpreter/spec/encode.ml b/interpreter/binary/encode.ml
similarity index 100%
rename from interpreter/spec/encode.ml
rename to interpreter/binary/encode.ml
diff --git a/interpreter/spec/encode.mli b/interpreter/binary/encode.mli
similarity index 100%
rename from interpreter/spec/encode.mli
rename to interpreter/binary/encode.mli
diff --git a/interpreter/spec/utf8.ml b/interpreter/binary/utf8.ml
similarity index 100%
rename from interpreter/spec/utf8.ml
rename to interpreter/binary/utf8.ml
diff --git a/interpreter/spec/utf8.mli b/interpreter/binary/utf8.mli
similarity index 100%
rename from interpreter/spec/utf8.mli
rename to interpreter/binary/utf8.mli
diff --git a/interpreter/spec/eval.ml b/interpreter/exec/eval.ml
similarity index 100%
rename from interpreter/spec/eval.ml
rename to interpreter/exec/eval.ml
diff --git a/interpreter/spec/eval.mli b/interpreter/exec/eval.mli
similarity index 100%
rename from interpreter/spec/eval.mli
rename to interpreter/exec/eval.mli
diff --git a/interpreter/spec/eval_numeric.ml b/interpreter/exec/eval_numeric.ml
similarity index 100%
rename from interpreter/spec/eval_numeric.ml
rename to interpreter/exec/eval_numeric.ml
diff --git a/interpreter/spec/eval_numeric.mli b/interpreter/exec/eval_numeric.mli
similarity index 100%
rename from interpreter/spec/eval_numeric.mli
rename to interpreter/exec/eval_numeric.mli
diff --git a/interpreter/spec/f32.ml b/interpreter/exec/f32.ml
similarity index 100%
rename from interpreter/spec/f32.ml
rename to interpreter/exec/f32.ml
diff --git a/interpreter/spec/f32_convert.ml b/interpreter/exec/f32_convert.ml
similarity index 100%
rename from interpreter/spec/f32_convert.ml
rename to interpreter/exec/f32_convert.ml
diff --git a/interpreter/spec/f32_convert.mli b/interpreter/exec/f32_convert.mli
similarity index 100%
rename from interpreter/spec/f32_convert.mli
rename to interpreter/exec/f32_convert.mli
diff --git a/interpreter/spec/f64.ml b/interpreter/exec/f64.ml
similarity index 100%
rename from interpreter/spec/f64.ml
rename to interpreter/exec/f64.ml
diff --git a/interpreter/spec/f64_convert.ml b/interpreter/exec/f64_convert.ml
similarity index 100%
rename from interpreter/spec/f64_convert.ml
rename to interpreter/exec/f64_convert.ml
diff --git a/interpreter/spec/f64_convert.mli b/interpreter/exec/f64_convert.mli
similarity index 100%
rename from interpreter/spec/f64_convert.mli
rename to interpreter/exec/f64_convert.mli
diff --git a/interpreter/spec/float.ml b/interpreter/exec/float.ml
similarity index 100%
rename from interpreter/spec/float.ml
rename to interpreter/exec/float.ml
diff --git a/interpreter/spec/i32.ml b/interpreter/exec/i32.ml
similarity index 100%
rename from interpreter/spec/i32.ml
rename to interpreter/exec/i32.ml
diff --git a/interpreter/spec/i32_convert.ml b/interpreter/exec/i32_convert.ml
similarity index 100%
rename from interpreter/spec/i32_convert.ml
rename to interpreter/exec/i32_convert.ml
diff --git a/interpreter/spec/i32_convert.mli b/interpreter/exec/i32_convert.mli
similarity index 100%
rename from interpreter/spec/i32_convert.mli
rename to interpreter/exec/i32_convert.mli
diff --git a/interpreter/spec/i64.ml b/interpreter/exec/i64.ml
similarity index 100%
rename from interpreter/spec/i64.ml
rename to interpreter/exec/i64.ml
diff --git a/interpreter/spec/i64_convert.ml b/interpreter/exec/i64_convert.ml
similarity index 100%
rename from interpreter/spec/i64_convert.ml
rename to interpreter/exec/i64_convert.ml
diff --git a/interpreter/spec/i64_convert.mli b/interpreter/exec/i64_convert.mli
similarity index 100%
rename from interpreter/spec/i64_convert.mli
rename to interpreter/exec/i64_convert.mli
diff --git a/interpreter/spec/instance.ml b/interpreter/exec/instance.ml
similarity index 100%
rename from interpreter/spec/instance.ml
rename to interpreter/exec/instance.ml
diff --git a/interpreter/spec/int.ml b/interpreter/exec/int.ml
similarity index 100%
rename from interpreter/spec/int.ml
rename to interpreter/exec/int.ml
diff --git a/interpreter/spec/memory.ml b/interpreter/exec/memory.ml
similarity index 100%
rename from interpreter/spec/memory.ml
rename to interpreter/exec/memory.ml
diff --git a/interpreter/spec/memory.mli b/interpreter/exec/memory.mli
similarity index 100%
rename from interpreter/spec/memory.mli
rename to interpreter/exec/memory.mli
diff --git a/interpreter/spec/numeric_error.ml b/interpreter/exec/numeric_error.ml
similarity index 100%
rename from interpreter/spec/numeric_error.ml
rename to interpreter/exec/numeric_error.ml
diff --git a/interpreter/spec/table.ml b/interpreter/exec/table.ml
similarity index 100%
rename from interpreter/spec/table.ml
rename to interpreter/exec/table.ml
diff --git a/interpreter/spec/table.mli b/interpreter/exec/table.mli
similarity index 100%
rename from interpreter/spec/table.mli
rename to interpreter/exec/table.mli
diff --git a/interpreter/host/import/env.ml b/interpreter/host/env.ml
similarity index 100%
rename from interpreter/host/import/env.ml
rename to interpreter/host/env.ml
diff --git a/interpreter/host/import/spectest.ml b/interpreter/host/spectest.ml
similarity index 100%
rename from interpreter/host/import/spectest.ml
rename to interpreter/host/spectest.ml
diff --git a/interpreter/host/flags.ml b/interpreter/main/flags.ml
similarity index 100%
rename from interpreter/host/flags.ml
rename to interpreter/main/flags.ml
diff --git a/interpreter/host/main.ml b/interpreter/main/main.ml
similarity index 92%
rename from interpreter/host/main.ml
rename to interpreter/main/main.ml
index ab09cbd22..38b7bdc12 100644
--- a/interpreter/host/main.ml
+++ b/interpreter/main/main.ml
@@ -1,14 +1,12 @@
 let name = "wasm"
-let version = "0.7"
+let version = "1.0"
 
 let configure () =
   Import.register (Utf8.decode "spectest") Spectest.lookup;
   Import.register (Utf8.decode "env") Env.lookup
 
 let banner () =
-  print_endline
-    (name ^ "-" ^ Printf.sprintf "0x%lX" Encode.version ^
-     " " ^ version ^ " reference interpreter")
+  print_endline (name ^ " " ^ version ^ " reference interpreter")
 
 let usage = "Usage: " ^ name ^ " [option] [file ...]"
 
diff --git a/interpreter/findlib/META b/interpreter/meta/findlib/META
similarity index 100%
rename from interpreter/findlib/META
rename to interpreter/meta/findlib/META
diff --git a/interpreter/jslib/bsconfig.json b/interpreter/meta/jslib/bsconfig.json
similarity index 100%
rename from interpreter/jslib/bsconfig.json
rename to interpreter/meta/jslib/bsconfig.json
diff --git a/interpreter/jslib/build.sh b/interpreter/meta/jslib/build.sh
similarity index 99%
rename from interpreter/jslib/build.sh
rename to interpreter/meta/jslib/build.sh
index 2928d0cf5..a4739f9a1 100755
--- a/interpreter/jslib/build.sh
+++ b/interpreter/meta/jslib/build.sh
@@ -74,7 +74,7 @@ echo 1>&2 ==== Compiling ====
 BSPATH=`which bsb`
 BPATH=`dirname $BSPATH`/../lib/js
 echo 1>&2 BSPATH = $BSPATH
-bsb || exit 1
+bsb.exe || exit 1
 cp `dirname $BSPATH`/../lib/js/*.js lib/js/src
 
 echo 1>&2 ==== Linking full version ====
diff --git a/interpreter/jslib/wasm.ml b/interpreter/meta/jslib/wasm.ml
similarity index 100%
rename from interpreter/jslib/wasm.ml
rename to interpreter/meta/jslib/wasm.ml
diff --git a/interpreter/travis/build-test.sh b/interpreter/meta/travis/build-test.sh
similarity index 80%
rename from interpreter/travis/build-test.sh
rename to interpreter/meta/travis/build-test.sh
index 50d6b9b40..4b2b68d9f 100755
--- a/interpreter/travis/build-test.sh
+++ b/interpreter/meta/travis/build-test.sh
@@ -5,7 +5,7 @@ set -x
 
 # Move to a location relative to the script so it runs
 # from anywhere.
-cd $(dirname ${BASH_SOURCE[0]})/..
+cd $(dirname ${BASH_SOURCE[0]})/../..
 
 export PATH=$PWD/../ocaml/install/bin:$PATH
 
diff --git a/interpreter/travis/install-ocaml.sh b/interpreter/meta/travis/install-ocaml.sh
similarity index 86%
rename from interpreter/travis/install-ocaml.sh
rename to interpreter/meta/travis/install-ocaml.sh
index 187a1604f..044ef68e7 100755
--- a/interpreter/travis/install-ocaml.sh
+++ b/interpreter/meta/travis/install-ocaml.sh
@@ -3,11 +3,11 @@
 set -e
 
 # Move to a location relative to the script so it runs
-# from anywhere. Go two levels down to get out of interpreter/
+# from anywhere. Go three levels down to get out of interpreter/
 # and into the top-level dir, since we'll run ocamlbuild
 # inside of interpreter/ and it goes pear-shaped if it
 # encounters ocaml's own build directory.
-cd $(dirname ${BASH_SOURCE[0]})/../..
+cd $(dirname ${BASH_SOURCE[0]})/../../..
 
 rm -rf ocaml
 mkdir ocaml
diff --git a/interpreter/host/import.ml b/interpreter/script/import.ml
similarity index 100%
rename from interpreter/host/import.ml
rename to interpreter/script/import.ml
diff --git a/interpreter/host/import.mli b/interpreter/script/import.mli
similarity index 100%
rename from interpreter/host/import.mli
rename to interpreter/script/import.mli
diff --git a/interpreter/host/js.ml b/interpreter/script/js.ml
similarity index 100%
rename from interpreter/host/js.ml
rename to interpreter/script/js.ml
diff --git a/interpreter/host/js.mli b/interpreter/script/js.mli
similarity index 100%
rename from interpreter/host/js.mli
rename to interpreter/script/js.mli
diff --git a/interpreter/host/run.ml b/interpreter/script/run.ml
similarity index 100%
rename from interpreter/host/run.ml
rename to interpreter/script/run.ml
diff --git a/interpreter/host/run.mli b/interpreter/script/run.mli
similarity index 100%
rename from interpreter/host/run.mli
rename to interpreter/script/run.mli
diff --git a/interpreter/text/script.ml b/interpreter/script/script.ml
similarity index 100%
rename from interpreter/text/script.ml
rename to interpreter/script/script.ml
diff --git a/interpreter/spec/ast.ml b/interpreter/syntax/ast.ml
similarity index 100%
rename from interpreter/spec/ast.ml
rename to interpreter/syntax/ast.ml
diff --git a/interpreter/spec/operators.ml b/interpreter/syntax/operators.ml
similarity index 100%
rename from interpreter/spec/operators.ml
rename to interpreter/syntax/operators.ml
diff --git a/interpreter/spec/types.ml b/interpreter/syntax/types.ml
similarity index 100%
rename from interpreter/spec/types.ml
rename to interpreter/syntax/types.ml
diff --git a/interpreter/spec/values.ml b/interpreter/syntax/values.ml
similarity index 100%
rename from interpreter/spec/values.ml
rename to interpreter/syntax/values.ml
diff --git a/interpreter/spec/valid.ml b/interpreter/valid/valid.ml
similarity index 100%
rename from interpreter/spec/valid.ml
rename to interpreter/valid/valid.ml
diff --git a/interpreter/spec/valid.mli b/interpreter/valid/valid.mli
similarity index 100%
rename from interpreter/spec/valid.mli
rename to interpreter/valid/valid.mli
diff --git a/interpreter/winmake.bat b/interpreter/winmake.bat
index 40489fd45..634fbd390 100644
--- a/interpreter/winmake.bat
+++ b/interpreter/winmake.bat
@@ -1,88 +1,88 @@
 rem Auto-generated from Makefile!
 set NAME=wasm
 if '%1' neq '' set NAME=%1
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/numeric_error.cmo spec/numeric_error.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/int.cmo spec/int.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/i32.cmo spec/i32.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/float.cmo spec/float.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/types.cmo spec/types.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/f32.cmo spec/f32.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/f64.cmo spec/f64.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/i64.cmo spec/i64.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/values.cmo spec/values.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I spec -I host -I text -I host/import -o util/lib.cmi util/lib.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/memory.cmi spec/memory.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I spec -I host -I text -I host/import -o util/source.cmi util/source.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/ast.cmo spec/ast.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/table.cmi spec/table.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/instance.cmo spec/instance.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/eval.cmi spec/eval.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/utf8.cmi spec/utf8.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/encode.cmi spec/encode.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host/import -I util -I spec -I host -I text -o host/import/env.cmo host/import/env.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host -I util -I spec -I text -I host/import -o host/flags.cmo host/flags.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host -I util -I spec -I text -I host/import -o host/import.cmi host/import.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host -I util -I spec -I text -I host/import -o host/run.cmi host/run.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host/import -I util -I spec -I host -I text -o host/import/spectest.cmo host/import/spectest.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host -I util -I spec -I text -I host/import -o host/main.cmo host/main.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -I spec -I text -I host/import -o host/main.d.cmo host/main.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I spec -I host -I text -I host/import -o util/error.cmi util/error.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I spec -I host -I host/import -o text/script.cmo text/script.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/decode.cmi spec/decode.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host -I util -I spec -I text -I host/import -o host/js.cmi host/js.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I spec -I host -I host/import -o text/parse.cmi text/parse.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I spec -I host -I host/import -o text/print.cmi text/print.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/valid.cmi spec/valid.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/encode.d.cmo spec/encode.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host/import -I util -I spec -I host -I text -o host/import/env.d.cmo host/import/env.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -I spec -I text -I host/import -o host/flags.d.cmo host/flags.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -I spec -I text -I host/import -o host/import.d.cmo host/import.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -I spec -I text -I host/import -o host/run.d.cmo host/run.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host/import -I util -I spec -I host -I text -o host/import/spectest.d.cmo host/import/spectest.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/utf8.d.cmo spec/utf8.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/ast.d.cmo spec/ast.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I spec -I host -I text -I host/import -o util/error.d.cmo util/error.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/f32.d.cmo spec/f32.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/f64.d.cmo spec/f64.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I spec -I host -I text -I host/import -o util/lib.d.cmo util/lib.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/memory.d.cmo spec/memory.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I spec -I host -I text -I host/import -o util/source.d.cmo util/source.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/types.d.cmo spec/types.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/values.d.cmo spec/values.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/i32.d.cmo spec/i32.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/i64.d.cmo spec/i64.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/float.d.cmo spec/float.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/int.d.cmo spec/int.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/numeric_error.d.cmo spec/numeric_error.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/eval_numeric.cmi spec/eval_numeric.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/i64_convert.cmi spec/i64_convert.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/eval.d.cmo spec/eval.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/instance.d.cmo spec/instance.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/f32_convert.cmi spec/f32_convert.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/f64_convert.cmi spec/f64_convert.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/i32_convert.cmi spec/i32_convert.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/eval_numeric.d.cmo spec/eval_numeric.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/i64_convert.d.cmo spec/i64_convert.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/table.d.cmo spec/table.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/f32_convert.d.cmo spec/f32_convert.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/f64_convert.d.cmo spec/f64_convert.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/i32_convert.d.cmo spec/i32_convert.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I spec -I util -I host -I text -I host/import -o spec/operators.cmo spec/operators.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/numeric_error.cmo exec/numeric_error.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/int.cmo exec/int.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i32.cmo exec/i32.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/float.cmo exec/float.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/types.cmo syntax/types.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f32.cmo exec/f32.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f64.cmo exec/f64.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i64.cmo exec/i64.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/values.cmo syntax/values.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/lib.cmi util/lib.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/memory.cmi exec/memory.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/source.cmi util/source.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/ast.cmo syntax/ast.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/table.cmi exec/table.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/instance.cmo exec/instance.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/eval.cmi exec/eval.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/utf8.cmi binary/utf8.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host -I util -I binary -I valid -I syntax -I script -I text -I main -I exec -o host/env.cmo host/env.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I main -I util -I binary -I valid -I syntax -I host -I script -I text -I exec -o main/flags.cmo main/flags.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/import.cmi script/import.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/run.cmi script/run.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host -I util -I binary -I valid -I syntax -I script -I text -I main -I exec -o host/spectest.cmo host/spectest.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I main -I util -I binary -I valid -I syntax -I host -I script -I text -I exec -o main/main.cmo main/main.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I main -I util -I binary -I valid -I syntax -I host -I script -I text -I exec -o main/main.d.cmo main/main.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/error.cmi util/error.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/script.cmo script/script.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/decode.cmi binary/decode.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/encode.cmi binary/encode.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/js.cmi script/js.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/parse.cmi text/parse.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/print.cmi text/print.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I valid -I util -I binary -I syntax -I host -I script -I text -I main -I exec -o valid/valid.cmi valid/valid.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -I binary -I valid -I syntax -I script -I text -I main -I exec -o host/env.d.cmo host/env.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I main -I util -I binary -I valid -I syntax -I host -I script -I text -I exec -o main/flags.d.cmo main/flags.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/import.d.cmo script/import.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/run.d.cmo script/run.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -I binary -I valid -I syntax -I script -I text -I main -I exec -o host/spectest.d.cmo host/spectest.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/utf8.d.cmo binary/utf8.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/eval_numeric.cmi exec/eval_numeric.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i64_convert.cmi exec/i64_convert.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/eval.d.cmo exec/eval.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/instance.d.cmo exec/instance.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/source.d.cmo util/source.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/types.d.cmo syntax/types.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/values.d.cmo syntax/values.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f32_convert.cmi exec/f32_convert.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f64_convert.cmi exec/f64_convert.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i32_convert.cmi exec/i32_convert.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/ast.d.cmo syntax/ast.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/error.d.cmo util/error.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/eval_numeric.d.cmo exec/eval_numeric.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i32.d.cmo exec/i32.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i64.d.cmo exec/i64.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i64_convert.d.cmo exec/i64_convert.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/lib.d.cmo util/lib.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/memory.d.cmo exec/memory.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/numeric_error.d.cmo exec/numeric_error.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/table.d.cmo exec/table.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f32.d.cmo exec/f32.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f64.d.cmo exec/f64.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/float.d.cmo exec/float.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/int.d.cmo exec/int.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f32_convert.d.cmo exec/f32_convert.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f64_convert.d.cmo exec/f64_convert.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i32_convert.d.cmo exec/i32_convert.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/operators.cmo syntax/operators.ml
 ocamlyacc text/parser.mly
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I spec -I host -I host/import -o text/parser.cmi text/parser.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I spec -I host -I host/import -o text/lexer.cmi text/lexer.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I spec -I host -I text -I host/import -o util/sexpr.cmi util/sexpr.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I spec -I host -I host/import -o text/arrange.cmi text/arrange.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/decode.d.cmo spec/decode.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -I spec -I text -I host/import -o host/js.d.cmo host/js.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I spec -I host -I host/import -o text/parse.d.cmo text/parse.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I spec -I host -I host/import -o text/print.d.cmo text/print.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I spec -I host -I host/import -o text/script.d.cmo text/script.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/valid.d.cmo spec/valid.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I spec -I util -I host -I text -I host/import -o spec/operators.d.cmo spec/operators.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/parser.cmi text/parser.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/lexer.cmi text/lexer.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/sexpr.cmi util/sexpr.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/arrange.cmi text/arrange.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/decode.d.cmo binary/decode.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/encode.d.cmo binary/encode.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/js.d.cmo script/js.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/parse.d.cmo text/parse.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/print.d.cmo text/print.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/script.d.cmo script/script.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I valid -I util -I binary -I syntax -I host -I script -I text -I main -I exec -o valid/valid.d.cmo valid/valid.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/operators.d.cmo syntax/operators.ml
 ocamllex.opt -q text/lexer.mll
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I spec -I host -I host/import -o text/lexer.d.cmo text/lexer.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I spec -I host -I host/import -o text/parser.d.cmo text/parser.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I spec -I host -I host/import -o text/arrange.d.cmo text/arrange.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I spec -I host -I text -I host/import -o util/sexpr.d.cmo util/sexpr.ml
-ocamlc.opt bigarray.cma -g host/flags.d.cmo spec/float.d.cmo spec/f32.d.cmo spec/f64.d.cmo spec/numeric_error.d.cmo spec/int.d.cmo spec/i32.d.cmo spec/i64.d.cmo spec/types.d.cmo spec/values.d.cmo util/lib.d.cmo spec/memory.d.cmo util/source.d.cmo spec/ast.d.cmo spec/table.d.cmo spec/instance.d.cmo spec/utf8.d.cmo util/error.d.cmo host/import.d.cmo spec/i32_convert.d.cmo spec/f32_convert.d.cmo spec/i64_convert.d.cmo spec/f64_convert.d.cmo spec/eval_numeric.d.cmo spec/eval.d.cmo host/import/env.d.cmo host/import/spectest.d.cmo spec/encode.d.cmo spec/operators.d.cmo spec/decode.d.cmo text/script.d.cmo host/js.d.cmo spec/valid.d.cmo text/parser.d.cmo text/lexer.d.cmo text/parse.d.cmo util/sexpr.d.cmo text/arrange.d.cmo text/print.d.cmo host/run.d.cmo host/main.d.cmo -o %NAME%.exe
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/lexer.d.cmo text/lexer.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/parser.d.cmo text/parser.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/arrange.d.cmo text/arrange.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/sexpr.d.cmo util/sexpr.ml
+ocamlc.opt bigarray.cma -g util/lib.d.cmo binary/utf8.d.cmo exec/float.d.cmo exec/f32.d.cmo exec/f64.d.cmo exec/numeric_error.d.cmo exec/int.d.cmo exec/i32.d.cmo exec/i64.d.cmo exec/i32_convert.d.cmo exec/f32_convert.d.cmo exec/i64_convert.d.cmo exec/f64_convert.d.cmo syntax/types.d.cmo syntax/values.d.cmo exec/memory.d.cmo util/source.d.cmo syntax/ast.d.cmo exec/eval_numeric.d.cmo exec/table.d.cmo exec/instance.d.cmo util/error.d.cmo exec/eval.d.cmo host/env.d.cmo host/spectest.d.cmo main/flags.d.cmo script/import.d.cmo binary/encode.d.cmo syntax/operators.d.cmo binary/decode.d.cmo script/script.d.cmo text/parser.d.cmo text/lexer.d.cmo text/parse.d.cmo script/js.d.cmo util/sexpr.d.cmo text/arrange.d.cmo text/print.d.cmo valid/valid.d.cmo script/run.d.cmo main/main.d.cmo -o main/main.d.byte
diff --git a/test/harness/wast.js b/test/harness/wast.js
index 5d329c102..88adf1973 100644
--- a/test/harness/wast.js
+++ b/test/harness/wast.js
@@ -23,28 +23,30 @@ let WebAssemblyText = (function() {
   _registry['arrange'] = function() {
     let exports = {};
 //////// start of arrange.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var F32                     = require("./f32");
-var F64                     = require("./f64");
-var I32                     = require("./i32");
-var I64                     = require("./i64");
-var Lib                     = require("./lib");
-var List                    = require("bs-platform/lib/js/list");
-var Block                   = require("bs-platform/lib/js/block");
-var Curry                   = require("bs-platform/lib/js/curry");
-var Types                   = require("./types");
-var Buffer                  = require("bs-platform/lib/js/buffer");
-var Decode                  = require("./decode");
-var Encode                  = require("./encode");
-var Printf                  = require("bs-platform/lib/js/printf");
-var Source                  = require("./source");
-var $$String                = require("bs-platform/lib/js/string");
-var Values                  = require("./values");
-var Caml_int32              = require("bs-platform/lib/js/caml_int32");
-var Pervasives              = require("bs-platform/lib/js/pervasives");
-var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions");
+var F32                     = require("./f32.js");
+var F64                     = require("./f64.js");
+var I32                     = require("./i32.js");
+var I64                     = require("./i64.js");
+var Lib                     = require("./lib.js");
+var Char                    = require("bs-platform/lib/js/char.js");
+var List                    = require("bs-platform/lib/js/list.js");
+var Block                   = require("bs-platform/lib/js/block.js");
+var Curry                   = require("bs-platform/lib/js/curry.js");
+var Parse                   = require("./parse.js");
+var Types                   = require("./types.js");
+var Buffer                  = require("bs-platform/lib/js/buffer.js");
+var Decode                  = require("./decode.js");
+var Encode                  = require("./encode.js");
+var Js_exn                  = require("bs-platform/lib/js/js_exn.js");
+var Printf                  = require("bs-platform/lib/js/printf.js");
+var Source                  = require("./source.js");
+var $$String                = require("bs-platform/lib/js/string.js");
+var Values                  = require("./values.js");
+var Pervasives              = require("bs-platform/lib/js/pervasives.js");
+var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions.js");
 
 function add_hex_char(buf, c) {
   return Curry._1(Printf.bprintf(buf, /* Format */[
@@ -65,21 +67,67 @@ function add_hex_char(buf, c) {
 }
 
 function add_char(buf, c) {
-  if (c < /* " " */32 || c >= /* "\127" */127) {
-    return add_hex_char(buf, c);
+  var exit = 0;
+  if (c >= 34) {
+    if (c !== 92) {
+      if (c >= 35) {
+        exit = 1;
+      } else {
+        return Buffer.add_string(buf, "\\\"");
+      }
+    } else {
+      return Buffer.add_string(buf, "\\\\");
+    }
+  } else if (c !== 9) {
+    if (c !== 10) {
+      exit = 1;
+    } else {
+      return Buffer.add_string(buf, "\\n");
+    }
+  } else {
+    return Buffer.add_string(buf, "\\t");
   }
-  else {
-    if (c === /* "\"" */34 || c === /* "\\" */92) {
-      Buffer.add_char(buf, /* "\\" */92);
+  if (exit === 1) {
+    if (/* " " */32 <= c && c < /* "\127" */127) {
+      return Buffer.add_char(buf, c);
+    } else {
+      return add_hex_char(buf, c);
     }
-    return Buffer.add_char(buf, c);
+  }
+  
+}
+
+function add_unicode_char(buf, uc) {
+  if (uc === 10 || uc === 9) {
+    return add_char(buf, Char.chr(uc));
+  } else if (32 <= uc && uc < 127) {
+    return add_char(buf, Char.chr(uc));
+  } else {
+    return Curry._1(Printf.bprintf(buf, /* Format */[
+                    /* String_literal */Block.__(11, [
+                        "\\u{",
+                        /* Int */Block.__(4, [
+                            /* Int_x */6,
+                            /* Lit_padding */Block.__(0, [
+                                /* Zeros */2,
+                                2
+                              ]),
+                            /* No_precision */0,
+                            /* Char_literal */Block.__(12, [
+                                /* "}" */125,
+                                /* End_of_format */0
+                              ])
+                          ])
+                      ]),
+                    "\\u{%02x}"
+                  ]), uc);
   }
 }
 
-function string_with(add_char, s) {
-  var buf = Buffer.create(Caml_int32.imul(3, s.length) + 2 | 0);
+function string_with(iter, add_char, s) {
+  var buf = Buffer.create(256);
   Buffer.add_char(buf, /* "\"" */34);
-  $$String.iter(Curry._1(add_char, buf), s);
+  Curry._2(iter, Curry._1(add_char, buf), s);
   Buffer.add_char(buf, /* "\"" */34);
   return Buffer.contents(buf);
 }
@@ -90,20 +138,33 @@ function list_of_opt(param) {
             param[0],
             /* [] */0
           ];
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
 
 function break_bytes(s) {
-  var ss = Curry._2(Lib.$$String[/* breakup */0], s, 16);
+  var ss = Curry._2(Lib.$$String[/* breakup */3], s, 16);
   var f = function (param) {
-    return /* Atom */Block.__(0, [string_with(add_hex_char, param)]);
+    return /* Atom */Block.__(0, [string_with($$String.iter, add_hex_char, param)]);
   };
   return List.map(f, ss);
 }
 
+function break_string(s) {
+  var match = Curry._1(Lib.List[/* split_last */5], Curry._2(Lib.$$String[/* split */2], s, /* "\n" */10));
+  var xs = Pervasives.$at(List.map(function (s) {
+            return s + "\n";
+          }, match[0]), /* :: */[
+        match[1],
+        /* [] */0
+      ]);
+  var f = function (param) {
+    return /* Atom */Block.__(0, [string_with($$String.iter, add_char, param)]);
+  };
+  return List.map(f, xs);
+}
+
 function decls(kind, ts) {
   var head = kind;
   var f = function (param) {
@@ -118,8 +179,7 @@ function decls(kind, ts) {
               ]),
             /* [] */0
           ];
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -149,8 +209,7 @@ function global_type(param) {
                 /* [] */0
               ]
             ]);
-  }
-  else {
+  } else {
     return /* Atom */Block.__(0, [Types.string_of_value_type(t)]);
   }
 }
@@ -259,8 +318,8 @@ function testop$1(_, _$1) {
   throw [
         Caml_builtin_exceptions.assert_failure,
         [
-          "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/arrange.ml",
-          128,
+          "arrange.ml",
+          137,
           27
         ]
       ];
@@ -426,8 +485,7 @@ function mem_size(param) {
 function extension(param) {
   if (param !== 0) {
     return "_u";
-  }
-  else {
+  } else {
     return "_s";
   }
 }
@@ -448,8 +506,7 @@ function loadop(op) {
   if (match) {
     var match$1 = match[0];
     return memop("load" + (mem_size(match$1[0]) + extension(match$1[1])), op);
-  }
-  else {
+  } else {
     return memop("load", op);
   }
 }
@@ -458,8 +515,7 @@ function storeop(op) {
   var match = op[/* sz */3];
   if (match) {
     return memop("store" + mem_size(match[0]), op);
-  }
-  else {
+  } else {
     return memop("store", op);
   }
 }
@@ -521,34 +577,24 @@ function instr(e) {
           break;
       
     }
-  }
-  else {
+  } else {
     switch (match.tag | 0) {
       case 0 : 
-          var f = function (param) {
-            return /* Atom */Block.__(0, [Types.string_of_value_type(param)]);
-          };
           match$1 = /* tuple */[
             "block",
-            Pervasives.$at(List.map(f, match[0]), List.map(instr, match[1]))
+            Pervasives.$at(decls("result", match[0]), List.map(instr, match[1]))
           ];
           break;
       case 1 : 
-          var f$1 = function (param) {
-            return /* Atom */Block.__(0, [Types.string_of_value_type(param)]);
-          };
           match$1 = /* tuple */[
             "loop",
-            Pervasives.$at(List.map(f$1, match[0]), List.map(instr, match[1]))
+            Pervasives.$at(decls("result", match[0]), List.map(instr, match[1]))
           ];
           break;
       case 2 : 
-          var f$2 = function (param) {
-            return /* Atom */Block.__(0, [Types.string_of_value_type(param)]);
-          };
           match$1 = /* tuple */[
             "if",
-            Pervasives.$at(List.map(f$2, match[0]), /* :: */[
+            Pervasives.$at(decls("result", match[0]), /* :: */[
                   /* Node */Block.__(1, [
                       "then",
                       List.map(instr, match[1])
@@ -769,8 +815,8 @@ function typedef(i, t) {
           ]);
 }
 
-function import_kind(i, k) {
-  var match = k[/* it */1];
+function import_desc(i, d) {
+  var match = d[/* it */1];
   switch (match.tag | 0) {
     case 0 : 
         return /* Node */Block.__(1, [
@@ -787,9 +833,9 @@ function import_kind(i, k) {
                   ]
                 ]);
     case 1 : 
-        return table(0, i, Source.$at$at(/* record */[/* ttype */match[0]], k[/* at */0]));
+        return table(0, i, Source.$at$at(/* record */[/* ttype */match[0]], d[/* at */0]));
     case 2 : 
-        return memory(0, i, Source.$at$at(/* record */[/* mtype */match[0]], k[/* at */0]));
+        return memory(0, i, Source.$at$at(/* record */[/* mtype */match[0]], d[/* at */0]));
     case 3 : 
         return /* Node */Block.__(1, [
                   "global $" + Curry._1(I32.to_string_u, Curry._1(I32.of_int_u, i)),
@@ -807,11 +853,11 @@ function $$import(i, im) {
   return /* Node */Block.__(1, [
             "import",
             /* :: */[
-              /* Atom */Block.__(0, [string_with(add_char, match[/* module_name */0])]),
+              /* Atom */Block.__(0, [string_with(List.iter, add_unicode_char, match[/* module_name */0])]),
               /* :: */[
-                /* Atom */Block.__(0, [string_with(add_char, match[/* item_name */1])]),
+                /* Atom */Block.__(0, [string_with(List.iter, add_unicode_char, match[/* item_name */1])]),
                 /* :: */[
-                  import_kind(i, match[/* ikind */2]),
+                  import_desc(i, match[/* idesc */2]),
                   /* [] */0
                 ]
               ]
@@ -819,17 +865,41 @@ function $$import(i, im) {
           ]);
 }
 
-function export_kind(k) {
-  var match = k[/* it */1];
-  switch (match) {
+function export_desc(d) {
+  var match = d[/* it */1];
+  switch (match.tag | 0) {
     case 0 : 
-        return "func";
+        return /* Node */Block.__(1, [
+                  "func",
+                  /* :: */[
+                    /* Atom */Block.__(0, [Curry._1(I32.to_string_u, match[0][/* it */1])]),
+                    /* [] */0
+                  ]
+                ]);
     case 1 : 
-        return "table";
+        return /* Node */Block.__(1, [
+                  "table",
+                  /* :: */[
+                    /* Atom */Block.__(0, [Curry._1(I32.to_string_u, match[0][/* it */1])]),
+                    /* [] */0
+                  ]
+                ]);
     case 2 : 
-        return "memory";
+        return /* Node */Block.__(1, [
+                  "memory",
+                  /* :: */[
+                    /* Atom */Block.__(0, [Curry._1(I32.to_string_u, match[0][/* it */1])]),
+                    /* [] */0
+                  ]
+                ]);
     case 3 : 
-        return "global";
+        return /* Node */Block.__(1, [
+                  "global",
+                  /* :: */[
+                    /* Atom */Block.__(0, [Curry._1(I32.to_string_u, match[0][/* it */1])]),
+                    /* [] */0
+                  ]
+                ]);
     
   }
 }
@@ -839,15 +909,9 @@ function $$export(ex) {
   return /* Node */Block.__(1, [
             "export",
             /* :: */[
-              /* Atom */Block.__(0, [string_with(add_char, match[/* name */0])]),
+              /* Atom */Block.__(0, [string_with(List.iter, add_unicode_char, match[/* name */0])]),
               /* :: */[
-                /* Node */Block.__(1, [
-                    export_kind(match[/* ekind */1]),
-                    /* :: */[
-                      /* Atom */Block.__(0, [Curry._1(I32.to_string_u, match[/* item */2][/* it */1])]),
-                      /* [] */0
-                    ]
-                  ]),
+                export_desc(match[/* edesc */1]),
                 /* [] */0
               ]
             ]
@@ -857,48 +921,43 @@ function $$export(ex) {
 function var_opt(param) {
   if (param) {
     return " " + param[0][/* it */1];
-  }
-  else {
+  } else {
     return "";
   }
 }
 
 function is_func_import(im) {
-  var match = im[/* it */1][/* ikind */2][/* it */1];
+  var match = im[/* it */1][/* idesc */2][/* it */1];
   if (match.tag) {
     return /* false */0;
-  }
-  else {
+  } else {
     return /* true */1;
   }
 }
 
 function is_table_import(im) {
-  var match = im[/* it */1][/* ikind */2][/* it */1];
+  var match = im[/* it */1][/* idesc */2][/* it */1];
   if (match.tag === 1) {
     return /* true */1;
-  }
-  else {
+  } else {
     return /* false */0;
   }
 }
 
 function is_memory_import(im) {
-  var match = im[/* it */1][/* ikind */2][/* it */1];
+  var match = im[/* it */1][/* idesc */2][/* it */1];
   if (match.tag === 2) {
     return /* true */1;
-  }
-  else {
+  } else {
     return /* false */0;
   }
 }
 
 function is_global_import(im) {
-  var match = im[/* it */1][/* ikind */2][/* it */1];
+  var match = im[/* it */1][/* idesc */2][/* it */1];
   if (match.tag === 3) {
     return /* true */1;
-  }
-  else {
+  } else {
     return /* false */0;
   }
 }
@@ -944,6 +1003,13 @@ function module_with_var_opt(x_opt, m) {
           ]);
 }
 
+function quoted_module_with_var_opt(x_opt, s) {
+  return /* Node */Block.__(1, [
+            "module" + (var_opt(x_opt) + " quote"),
+            break_string(s)
+          ]);
+}
+
 function module_(param) {
   return module_with_var_opt(/* None */0, param);
 }
@@ -976,34 +1042,87 @@ function literal(lit) {
 }
 
 function definition(mode, x_opt, def) {
-  var match = def[/* it */1];
-  var exit = 0;
-  exit = mode !== 564146209 && !(mode >= 983167089 && match.tag) ? 1 : 2;
-  switch (exit) {
-    case 1 : 
-        var match$1 = def[/* it */1];
-        var m;
-        m = match$1.tag ? Decode.decode("", match$1[1]) : match$1[0];
-        return module_with_var_opt(x_opt, m);
-    case 2 : 
-        var match$2 = def[/* it */1];
-        var bs;
-        bs = match$2.tag ? match$2[1] : Encode.encode(match$2[0]);
-        var x_opt$1 = x_opt;
-        var bs$1 = bs;
-        return /* Node */Block.__(1, [
-                  "module" + var_opt(x_opt$1),
-                  break_bytes(bs$1)
-                ]);
-    
+  try {
+    var match = def[/* it */1];
+    var exit = 0;
+    if (mode !== 564146209) {
+      if (mode >= 983167089) {
+        switch (match.tag | 0) {
+          case 0 : 
+              exit = 1;
+              break;
+          case 1 : 
+              exit = 2;
+              break;
+          case 2 : 
+              return quoted_module_with_var_opt(x_opt, match[1]);
+          
+        }
+      } else {
+        exit = 1;
+      }
+    } else {
+      exit = 2;
+    }
+    switch (exit) {
+      case 1 : 
+          var unquote = function (_def) {
+            while(true) {
+              var def = _def;
+              var match = def[/* it */1];
+              switch (match.tag | 0) {
+                case 0 : 
+                    return match[0];
+                case 1 : 
+                    return Decode.decode("", match[1]);
+                case 2 : 
+                    _def = Parse.string_to_module(match[1]);
+                    continue ;
+                    
+              }
+            };
+          };
+          return module_with_var_opt(x_opt, unquote(def));
+      case 2 : 
+          var unquote$1 = function (_bs) {
+            while(true) {
+              var match = def[/* it */1];
+              switch (match.tag | 0) {
+                case 0 : 
+                    return Encode.encode(match[0]);
+                case 1 : 
+                    return match[1];
+                case 2 : 
+                    _bs = Parse.string_to_module(match[1]);
+                    continue ;
+                    
+              }
+            };
+          };
+          var x_opt$1 = x_opt;
+          var bs = unquote$1(def);
+          return /* Node */Block.__(1, [
+                    "module" + (var_opt(x_opt$1) + " binary"),
+                    break_bytes(bs)
+                  ]);
+      
+    }
+  }
+  catch (raw_exn){
+    var exn = Js_exn.internalToOCamlException(raw_exn);
+    if (exn[0] === Parse.Syntax) {
+      return quoted_module_with_var_opt(x_opt, "<invalid module>");
+    } else {
+      throw exn;
+    }
   }
 }
 
-function access(x_opt, name) {
+function access(x_opt, n) {
   return $$String.concat(" ", /* :: */[
               var_opt(x_opt),
               /* :: */[
-                string_with(add_char, name),
+                string_with(List.iter, add_unicode_char, n),
                 /* [] */0
               ]
             ]);
@@ -1016,8 +1135,7 @@ function action(act) {
               "get" + access(match[0], match[1]),
               /* [] */0
             ]);
-  }
-  else {
+  } else {
     return /* Node */Block.__(1, [
               "invoke" + access(match[0], match[1]),
               List.map(literal, match[2])
@@ -1035,7 +1153,7 @@ function script(mode, scr) {
                     return definition(mode$1, match[0], match[1]);
                 case 1 : 
                     return /* Node */Block.__(1, [
-                              "register " + (string_with(add_char, match[0]) + var_opt(match[1])),
+                              "register " + (string_with(List.iter, add_unicode_char, match[0]) + var_opt(match[1])),
                               /* [] */0
                             ]);
                 case 2 : 
@@ -1051,7 +1169,7 @@ function script(mode, scr) {
                                     /* :: */[
                                       definition(/* Original */983167089, /* None */0, match$1[0]),
                                       /* :: */[
-                                        /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
+                                        /* Atom */Block.__(0, [string_with($$String.iter, add_char, match$1[1])]),
                                         /* [] */0
                                       ]
                                     ]
@@ -1062,55 +1180,52 @@ function script(mode, scr) {
                                     /* :: */[
                                       definition(mode$2, /* None */0, match$1[0]),
                                       /* :: */[
-                                        /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
+                                        /* Atom */Block.__(0, [string_with($$String.iter, add_char, match$1[1])]),
                                         /* [] */0
                                       ]
                                     ]
                                   ]);
                       case 2 : 
                           return /* Node */Block.__(1, [
-                                    "assert_soft_invalid",
+                                    "assert_unlinkable",
                                     /* :: */[
                                       definition(mode$2, /* None */0, match$1[0]),
                                       /* :: */[
-                                        /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
+                                        /* Atom */Block.__(0, [string_with($$String.iter, add_char, match$1[1])]),
                                         /* [] */0
                                       ]
                                     ]
                                   ]);
                       case 3 : 
                           return /* Node */Block.__(1, [
-                                    "assert_unlinkable",
+                                    "assert_trap",
                                     /* :: */[
                                       definition(mode$2, /* None */0, match$1[0]),
                                       /* :: */[
-                                        /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
+                                        /* Atom */Block.__(0, [string_with($$String.iter, add_char, match$1[1])]),
                                         /* [] */0
                                       ]
                                     ]
                                   ]);
                       case 4 : 
                           return /* Node */Block.__(1, [
-                                    "assert_trap",
+                                    "assert_return",
                                     /* :: */[
-                                      definition(mode$2, /* None */0, match$1[0]),
-                                      /* :: */[
-                                        /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
-                                        /* [] */0
-                                      ]
+                                      action(match$1[0]),
+                                      List.map(literal, match$1[1])
                                     ]
                                   ]);
                       case 5 : 
                           return /* Node */Block.__(1, [
-                                    "assert_return",
+                                    "assert_return_canonical_nan",
                                     /* :: */[
                                       action(match$1[0]),
-                                      List.map(literal, match$1[1])
+                                      /* [] */0
                                     ]
                                   ]);
                       case 6 : 
                           return /* Node */Block.__(1, [
-                                    "assert_return_nan",
+                                    "assert_return_arithmetic_nan",
                                     /* :: */[
                                       action(match$1[0]),
                                       /* [] */0
@@ -1122,7 +1237,7 @@ function script(mode, scr) {
                                     /* :: */[
                                       action(match$1[0]),
                                       /* :: */[
-                                        /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
+                                        /* Atom */Block.__(0, [string_with($$String.iter, add_char, match$1[1])]),
                                         /* [] */0
                                       ]
                                     ]
@@ -1133,7 +1248,7 @@ function script(mode, scr) {
                                     /* :: */[
                                       action(match$1[0]),
                                       /* :: */[
-                                        /* Atom */Block.__(0, [string_with(add_char, match$1[1])]),
+                                        /* Atom */Block.__(0, [string_with($$String.iter, add_char, match$1[1])]),
                                         /* [] */0
                                       ]
                                     ]
@@ -1144,8 +1259,8 @@ function script(mode, scr) {
                     throw [
                           Caml_builtin_exceptions.assert_failure,
                           [
-                            "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/arrange.ml",
-                            435,
+                            "arrange.ml",
+                            452,
                             14
                           ]
                         ];
@@ -1169,10 +1284,11 @@ exports.script  = script;
 //////// start of array.js ////////
 'use strict';
 
-var Curry                   = require("./curry");
-var Caml_array              = require("./caml_array");
-var Caml_exceptions         = require("./caml_exceptions");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Curry                   = require("./curry.js");
+var Js_exn                  = require("./js_exn.js");
+var Caml_array              = require("./caml_array.js");
+var Caml_exceptions         = require("./caml_exceptions.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function init(l, f) {
   if (l) {
@@ -1181,16 +1297,14 @@ function init(l, f) {
             Caml_builtin_exceptions.invalid_argument,
             "Array.init"
           ];
-    }
-    else {
+    } else {
       var res = Caml_array.caml_make_vect(l, Curry._1(f, 0));
       for(var i = 1 ,i_finish = l - 1 | 0; i <= i_finish; ++i){
         res[i] = Curry._1(f, i);
       }
       return res;
     }
-  }
-  else {
+  } else {
     return /* array */[];
   }
 }
@@ -1207,8 +1321,7 @@ function copy(a) {
   var l = a.length;
   if (l) {
     return Caml_array.caml_array_sub(a, 0, l);
-  }
-  else {
+  } else {
     return /* array */[];
   }
 }
@@ -1218,12 +1331,10 @@ function append(a1, a2) {
   if (l1) {
     if (a2.length) {
       return a1.concat(a2);
-    }
-    else {
+    } else {
       return Caml_array.caml_array_sub(a1, 0, l1);
     }
-  }
-  else {
+  } else {
     return copy(a2);
   }
 }
@@ -1234,8 +1345,7 @@ function sub(a, ofs, len) {
           Caml_builtin_exceptions.invalid_argument,
           "Array.sub"
         ];
-  }
-  else {
+  } else {
     return Caml_array.caml_array_sub(a, ofs, len);
   }
 }
@@ -1246,8 +1356,7 @@ function fill(a, ofs, len, v) {
           Caml_builtin_exceptions.invalid_argument,
           "Array.fill"
         ];
-  }
-  else {
+  } else {
     for(var i = ofs ,i_finish = (ofs + len | 0) - 1 | 0; i <= i_finish; ++i){
       a[i] = v;
     }
@@ -1261,8 +1370,7 @@ function blit(a1, ofs1, a2, ofs2, len) {
           Caml_builtin_exceptions.invalid_argument,
           "Array.blit"
         ];
-  }
-  else {
+  } else {
     return Caml_array.caml_array_blit(a1, ofs1, a2, ofs2, len);
   }
 }
@@ -1282,8 +1390,7 @@ function map(f, a) {
       r[i] = Curry._1(f, a[i]);
     }
     return r;
-  }
-  else {
+  } else {
     return /* array */[];
   }
 }
@@ -1303,8 +1410,7 @@ function mapi(f, a) {
       r[i] = Curry._2(f, i, a[i]);
     }
     return r;
-  }
-  else {
+  } else {
     return /* array */[];
   }
 }
@@ -1317,8 +1423,7 @@ function to_list(a) {
     var i = _i;
     if (i < 0) {
       return res;
-    }
-    else {
+    } else {
       _res = /* :: */[
         a[i],
         res
@@ -1339,8 +1444,7 @@ function list_length(_accu, _param) {
       _accu = accu + 1 | 0;
       continue ;
       
-    }
-    else {
+    } else {
       return accu;
     }
   };
@@ -1360,13 +1464,11 @@ function of_list(l) {
         _i = i + 1 | 0;
         continue ;
         
-      }
-      else {
+      } else {
         return a;
       }
     };
-  }
-  else {
+  } else {
     return /* array */[];
   }
 }
@@ -1394,21 +1496,18 @@ function sort(cmp, a) {
     var i31 = ((i + i | 0) + i | 0) + 1 | 0;
     var x = i31;
     if ((i31 + 2 | 0) < l) {
-      if (Curry._2(cmp, a[i31], a[i31 + 1 | 0]) < 0) {
+      if (Curry._2(cmp, Caml_array.caml_array_get(a, i31), Caml_array.caml_array_get(a, i31 + 1 | 0)) < 0) {
         x = i31 + 1 | 0;
       }
-      if (Curry._2(cmp, a[x], a[i31 + 2 | 0]) < 0) {
+      if (Curry._2(cmp, Caml_array.caml_array_get(a, x), Caml_array.caml_array_get(a, i31 + 2 | 0)) < 0) {
         x = i31 + 2 | 0;
       }
       return x;
-    }
-    else if ((i31 + 1 | 0) < l && Curry._2(cmp, a[i31], a[i31 + 1 | 0]) < 0) {
+    } else if ((i31 + 1 | 0) < l && Curry._2(cmp, Caml_array.caml_array_get(a, i31), Caml_array.caml_array_get(a, i31 + 1 | 0)) < 0) {
       return i31 + 1 | 0;
-    }
-    else if (i31 < l) {
+    } else if (i31 < l) {
       return i31;
-    }
-    else {
+    } else {
       throw [
             Bottom,
             i
@@ -1423,24 +1522,21 @@ function sort(cmp, a) {
       while(true) {
         var i$1 = _i;
         var j = maxson(l$1, i$1);
-        if (Curry._2(cmp, a[j], e$1) > 0) {
-          a[i$1] = a[j];
+        if (Curry._2(cmp, Caml_array.caml_array_get(a, j), e$1) > 0) {
+          Caml_array.caml_array_set(a, i$1, Caml_array.caml_array_get(a, j));
           _i = j;
           continue ;
           
-        }
-        else {
-          a[i$1] = e$1;
-          return /* () */0;
+        } else {
+          return Caml_array.caml_array_set(a, i$1, e$1);
         }
       };
     }
-    catch (exn){
+    catch (raw_exn){
+      var exn = Js_exn.internalToOCamlException(raw_exn);
       if (exn[0] === Bottom) {
-        a[exn[1]] = e;
-        return /* () */0;
-      }
-      else {
+        return Caml_array.caml_array_set(a, exn[1], e);
+      } else {
         throw exn;
       }
     }
@@ -1452,17 +1548,17 @@ function sort(cmp, a) {
       while(true) {
         var i$1 = _i;
         var j = maxson(l$1, i$1);
-        a[i$1] = a[j];
+        Caml_array.caml_array_set(a, i$1, Caml_array.caml_array_get(a, j));
         _i = j;
         continue ;
         
       };
     }
-    catch (exn){
+    catch (raw_exn){
+      var exn = Js_exn.internalToOCamlException(raw_exn);
       if (exn[0] === Bottom) {
         return exn[1];
-      }
-      else {
+      } else {
         throw exn;
       }
     }
@@ -1481,40 +1577,34 @@ function sort(cmp, a) {
               ]
             ];
       }
-      if (Curry._2(cmp, a[father], e) < 0) {
-        a[i] = a[father];
+      if (Curry._2(cmp, Caml_array.caml_array_get(a, father), e) < 0) {
+        Caml_array.caml_array_set(a, i, Caml_array.caml_array_get(a, father));
         if (father > 0) {
           _i = father;
           continue ;
           
+        } else {
+          return Caml_array.caml_array_set(a, 0, e);
         }
-        else {
-          a[0] = e;
-          return /* () */0;
-        }
-      }
-      else {
-        a[i] = e;
-        return /* () */0;
+      } else {
+        return Caml_array.caml_array_set(a, i, e);
       }
     };
   };
   var l = a.length;
   for(var i = ((l + 1 | 0) / 3 | 0) - 1 | 0; i >= 0; --i){
-    trickle(l, i, a[i]);
+    trickle(l, i, Caml_array.caml_array_get(a, i));
   }
   for(var i$1 = l - 1 | 0; i$1 >= 2; --i$1){
-    var e = a[i$1];
-    a[i$1] = a[0];
+    var e = Caml_array.caml_array_get(a, i$1);
+    Caml_array.caml_array_set(a, i$1, Caml_array.caml_array_get(a, 0));
     trickleup(bubble(i$1, 0), e);
   }
   if (l > 1) {
-    var e$1 = a[1];
-    a[1] = a[0];
-    a[0] = e$1;
-    return /* () */0;
-  }
-  else {
+    var e$1 = Caml_array.caml_array_get(a, 1);
+    Caml_array.caml_array_set(a, 1, Caml_array.caml_array_get(a, 0));
+    return Caml_array.caml_array_set(a, 0, e$1);
+  } else {
     return 0;
   }
 }
@@ -1524,9 +1614,9 @@ function stable_sort(cmp, a) {
     var src1r = src1ofs + src1len | 0;
     var src2r = src2ofs + src2len | 0;
     var _i1 = src1ofs;
-    var _s1 = a[src1ofs];
+    var _s1 = Caml_array.caml_array_get(a, src1ofs);
     var _i2 = src2ofs;
-    var _s2 = src2[src2ofs];
+    var _s2 = Caml_array.caml_array_get(src2, src2ofs);
     var _d = dstofs;
     while(true) {
       var d = _d;
@@ -1535,30 +1625,27 @@ function stable_sort(cmp, a) {
       var s1 = _s1;
       var i1 = _i1;
       if (Curry._2(cmp, s1, s2) <= 0) {
-        dst[d] = s1;
+        Caml_array.caml_array_set(dst, d, s1);
         var i1$1 = i1 + 1 | 0;
         if (i1$1 < src1r) {
           _d = d + 1 | 0;
-          _s1 = a[i1$1];
+          _s1 = Caml_array.caml_array_get(a, i1$1);
           _i1 = i1$1;
           continue ;
           
-        }
-        else {
+        } else {
           return blit(src2, i2, dst, d + 1 | 0, src2r - i2 | 0);
         }
-      }
-      else {
-        dst[d] = s2;
+      } else {
+        Caml_array.caml_array_set(dst, d, s2);
         var i2$1 = i2 + 1 | 0;
         if (i2$1 < src2r) {
           _d = d + 1 | 0;
-          _s2 = src2[i2$1];
+          _s2 = Caml_array.caml_array_get(src2, i2$1);
           _i2 = i2$1;
           continue ;
           
-        }
-        else {
+        } else {
           return blit(a, i1, dst, d + 1 | 0, src1r - i1 | 0);
         }
       }
@@ -1566,21 +1653,20 @@ function stable_sort(cmp, a) {
   };
   var isortto = function (srcofs, dst, dstofs, len) {
     for(var i = 0 ,i_finish = len - 1 | 0; i <= i_finish; ++i){
-      var e = a[srcofs + i | 0];
+      var e = Caml_array.caml_array_get(a, srcofs + i | 0);
       var j = (dstofs + i | 0) - 1 | 0;
-      while(j >= dstofs && Curry._2(cmp, dst[j], e) > 0) {
-        dst[j + 1 | 0] = dst[j];
+      while(j >= dstofs && Curry._2(cmp, Caml_array.caml_array_get(dst, j), e) > 0) {
+        Caml_array.caml_array_set(dst, j + 1 | 0, Caml_array.caml_array_get(dst, j));
         j = j - 1 | 0;
       };
-      dst[j + 1 | 0] = e;
+      Caml_array.caml_array_set(dst, j + 1 | 0, e);
     }
     return /* () */0;
   };
   var sortto = function (srcofs, dst, dstofs, len) {
     if (len <= 5) {
       return isortto(srcofs, dst, dstofs, len);
-    }
-    else {
+    } else {
       var l1 = len / 2 | 0;
       var l2 = len - l1 | 0;
       sortto(srcofs + l1 | 0, dst, dstofs + l1 | 0, l2);
@@ -1591,11 +1677,10 @@ function stable_sort(cmp, a) {
   var l = a.length;
   if (l <= 5) {
     return isortto(0, a, 0, l);
-  }
-  else {
+  } else {
     var l1 = l / 2 | 0;
     var l2 = l - l1 | 0;
-    var t = Caml_array.caml_make_vect(l2, a[0]);
+    var t = Caml_array.caml_make_vect(l2, Caml_array.caml_array_get(a, 0));
     sortto(l1, t, 0, l2);
     sortto(0, a, l2, l1);
     return merge(l2, l1, t, 0, l2, a, 0);
@@ -1637,35 +1722,26 @@ exports.fast_sort     = fast_sort;
   _registry['ast'] = function() {
     let exports = {};
 //////// start of ast.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Lib      = require("./lib");
-var Block    = require("bs-platform/lib/js/block");
-var Curry    = require("bs-platform/lib/js/curry");
-var Caml_obj = require("bs-platform/lib/js/caml_obj");
+var Lib        = require("./lib.js");
+var Char       = require("bs-platform/lib/js/char.js");
+var List       = require("bs-platform/lib/js/list.js");
+var Block      = require("bs-platform/lib/js/block.js");
+var Curry      = require("bs-platform/lib/js/curry.js");
+var Types      = require("./types.js");
+var Buffer     = require("bs-platform/lib/js/buffer.js");
+var Printf     = require("bs-platform/lib/js/printf.js");
+var Pervasives = require("bs-platform/lib/js/pervasives.js");
 
 var IntOp = /* module */[];
 
 var FloatOp = /* module */[];
 
-function export_kind_of_import_kind(param) {
-  switch (param.tag | 0) {
-    case 0 : 
-        return /* FuncExport */0;
-    case 1 : 
-        return /* TableExport */1;
-    case 2 : 
-        return /* MemoryExport */2;
-    case 3 : 
-        return /* GlobalExport */3;
-    
-  }
-}
-
 function import_type(m, im) {
   var match = im[/* it */1];
-  var match$1 = match[/* ikind */2][/* it */1];
+  var match$1 = match[/* idesc */2][/* it */1];
   switch (match$1.tag | 0) {
     case 0 : 
         return /* ExternalFuncType */Block.__(0, [Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* types */0], match$1[0][/* it */1])]);
@@ -1681,47 +1757,67 @@ function import_type(m, im) {
 
 function export_type(m, ex) {
   var match = ex[/* it */1];
-  var ekind = match[/* ekind */1];
-  var _i = match[/* item */2][/* it */1];
-  var _param = m[/* it */1][/* imports */8];
-  while(true) {
-    var param = _param;
-    var i = _i;
-    if (param) {
-      var ims = param[1];
-      var im = param[0];
-      if (Caml_obj.caml_equal(export_kind_of_import_kind(im[/* it */1][/* ikind */2][/* it */1]), ekind[/* it */1])) {
-        if (i) {
-          _param = ims;
-          _i = i - 1 | 0;
-          continue ;
-          
-        }
-        else {
-          return import_type(m, im);
-        }
-      }
-      else {
-        _param = ims;
-        continue ;
-        
-      }
-    }
-    else {
-      var match$1 = ekind[/* it */1];
-      switch (match$1) {
-        case 0 : 
-            return /* ExternalFuncType */Block.__(0, [Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* types */0], Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* funcs */4], i)[/* it */1][/* ftype */0][/* it */1])]);
-        case 1 : 
-            return /* ExternalTableType */Block.__(1, [Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* tables */2], i)[/* it */1][/* ttype */0]]);
-        case 2 : 
-            return /* ExternalMemoryType */Block.__(2, [Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* memories */3], i)[/* it */1][/* mtype */0]]);
-        case 3 : 
-            return /* ExternalGlobalType */Block.__(3, [Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* globals */1], i)[/* it */1][/* gtype */0]]);
-        
+  var its = List.map(function (param) {
+        return import_type(m, param);
+      }, m[/* it */1][/* imports */8]);
+  var match$1 = match[/* edesc */1][/* it */1];
+  switch (match$1.tag | 0) {
+    case 0 : 
+        var fts = Pervasives.$at(Types.funcs(its), List.map(function (f) {
+                  return Curry._2(Lib.List32[/* nth */1], m[/* it */1][/* types */0], f[/* it */1][/* ftype */0][/* it */1]);
+                }, m[/* it */1][/* funcs */4]));
+        return /* ExternalFuncType */Block.__(0, [Curry._2(Lib.List32[/* nth */1], fts, match$1[0][/* it */1])]);
+    case 1 : 
+        var tts = Pervasives.$at(Types.tables(its), List.map(function (t) {
+                  return t[/* it */1][/* ttype */0];
+                }, m[/* it */1][/* tables */2]));
+        return /* ExternalTableType */Block.__(1, [Curry._2(Lib.List32[/* nth */1], tts, match$1[0][/* it */1])]);
+    case 2 : 
+        var mts = Pervasives.$at(Types.memories(its), List.map(function (m) {
+                  return m[/* it */1][/* mtype */0];
+                }, m[/* it */1][/* memories */3]));
+        return /* ExternalMemoryType */Block.__(2, [Curry._2(Lib.List32[/* nth */1], mts, match$1[0][/* it */1])]);
+    case 3 : 
+        var gts = Pervasives.$at(Types.globals(its), List.map(function (g) {
+                  return g[/* it */1][/* gtype */0];
+                }, m[/* it */1][/* globals */1]));
+        return /* ExternalGlobalType */Block.__(3, [Curry._2(Lib.List32[/* nth */1], gts, match$1[0][/* it */1])]);
+    
+  }
+}
+
+function string_of_name(n) {
+  var b = Buffer.create(16);
+  var $$escape = function (uc) {
+    if (uc < 32 || uc >= 127) {
+      return Buffer.add_string(b, Curry._1(Printf.sprintf(/* Format */[
+                          /* String_literal */Block.__(11, [
+                              "\\u{",
+                              /* Int */Block.__(4, [
+                                  /* Int_x */6,
+                                  /* Lit_padding */Block.__(0, [
+                                      /* Zeros */2,
+                                      2
+                                    ]),
+                                  /* No_precision */0,
+                                  /* Char_literal */Block.__(12, [
+                                      /* "}" */125,
+                                      /* End_of_format */0
+                                    ])
+                                ])
+                            ]),
+                          "\\u{%02x}"
+                        ]), uc));
+    } else {
+      var c = Char.chr(uc);
+      if (c === /* "\"" */34 || c === /* "\\" */92) {
+        Buffer.add_char(b, /* "\\" */92);
       }
+      return Buffer.add_char(b, c);
     }
   };
+  List.iter($$escape, n);
+  return Buffer.contents(b);
 }
 
 var I32Op = 0;
@@ -1745,16 +1841,16 @@ var empty_module = /* record */[
   /* exports : [] */0
 ];
 
-exports.IntOp                      = IntOp;
-exports.FloatOp                    = FloatOp;
-exports.I32Op                      = I32Op;
-exports.I64Op                      = I64Op;
-exports.F32Op                      = F32Op;
-exports.F64Op                      = F64Op;
-exports.empty_module               = empty_module;
-exports.export_kind_of_import_kind = export_kind_of_import_kind;
-exports.import_type                = import_type;
-exports.export_type                = export_type;
+exports.IntOp          = IntOp;
+exports.FloatOp        = FloatOp;
+exports.I32Op          = I32Op;
+exports.I64Op          = I64Op;
+exports.F32Op          = F32Op;
+exports.F64Op          = F64Op;
+exports.empty_module   = empty_module;
+exports.import_type    = import_type;
+exports.export_type    = export_type;
+exports.string_of_name = string_of_name;
 /* Lib Not a pure module */
 //////// end of ast.js ////////
     return exports;
@@ -1766,18 +1862,15 @@ exports.export_type                = export_type;
 //////// start of bigarray.js ////////
 'use strict';
 
-var Caml_array              = require("./caml_array");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Caml_array              = require("./caml_array.js");
+var Caml_missing_polyfill   = require("./caml_missing_polyfill.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function dims() {
-  var n = function () {
-      throw "caml_ba_num_dims not implemented by bucklescript yet\n";
-    }();
+  var n = Caml_missing_polyfill.not_implemented("caml_ba_num_dims not implemented by bucklescript yet\n");
   var d = Caml_array.caml_make_vect(n, 0);
   for(var i = 0 ,i_finish = n - 1 | 0; i <= i_finish; ++i){
-    d[i] = function () {
-        throw "caml_ba_dim not implemented by bucklescript yet\n";
-      }();
+    Caml_array.caml_array_set(d, i, Caml_missing_polyfill.not_implemented("caml_ba_dim not implemented by bucklescript yet\n"));
   }
   return d;
 }
@@ -1787,9 +1880,7 @@ function map_file(_, $staropt$star, _$1, _$2, _$3, _$4) {
       /* hi */0,
       /* lo */0
     ];
-  return function () {
-            throw "caml_ba_map_file_bytecode not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_map_file_bytecode not implemented by bucklescript yet\n");
 }
 
 var Genarray = /* module */[
@@ -1798,18 +1889,14 @@ var Genarray = /* module */[
 ];
 
 function create(_, _$1, _$2) {
-  return function () {
-            throw "caml_ba_create not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_create not implemented by bucklescript yet\n");
 }
 
 function of_array(kind, layout, data) {
   var ba = create(kind, layout, data.length);
   layout !== 0 ? 1 : 0;
   for(var i = 0 ,i_finish = data.length - 1 | 0; i <= i_finish; ++i){
-    (function () {
-          throw "caml_ba_set_1 not implemented by bucklescript yet\n";
-        }());
+    Caml_missing_polyfill.not_implemented("caml_ba_set_1 not implemented by bucklescript yet\n");
   }
   return ba;
 }
@@ -1825,30 +1912,24 @@ var Array1 = /* module */[
 ];
 
 function create$1(_, _$1, _$2, _$3) {
-  return function () {
-            throw "caml_ba_create not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_create not implemented by bucklescript yet\n");
 }
 
 function slice_left(_, _$1) {
-  return function () {
-            throw "caml_ba_slice not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_slice not implemented by bucklescript yet\n");
 }
 
 function slice_right(_, _$1) {
-  return function () {
-            throw "caml_ba_slice not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_slice not implemented by bucklescript yet\n");
 }
 
 function of_array$1(kind, layout, data) {
   var dim1 = data.length;
-  var dim2 = dim1 ? data[0].length : 0;
+  var dim2 = dim1 ? Caml_array.caml_array_get(data, 0).length : 0;
   var ba = create$1(kind, layout, dim1, dim2);
   layout !== 0 ? 1 : 0;
   for(var i = 0 ,i_finish = dim1 - 1 | 0; i <= i_finish; ++i){
-    var row = data[i];
+    var row = Caml_array.caml_array_get(data, i);
     if (row.length !== dim2) {
       throw [
             Caml_builtin_exceptions.invalid_argument,
@@ -1856,9 +1937,7 @@ function of_array$1(kind, layout, data) {
           ];
     }
     for(var j = 0 ,j_finish = dim2 - 1 | 0; j <= j_finish; ++j){
-      (function () {
-            throw "caml_ba_set_2 not implemented by bucklescript yet\n";
-          }());
+      Caml_missing_polyfill.not_implemented("caml_ba_set_2 not implemented by bucklescript yet\n");
     }
   }
   return ba;
@@ -1880,43 +1959,33 @@ var Array2 = /* module */[
 ];
 
 function create$2(_, _$1, _$2, _$3, _$4) {
-  return function () {
-            throw "caml_ba_create not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_create not implemented by bucklescript yet\n");
 }
 
 function slice_left_1(_, _$1, _$2) {
-  return function () {
-            throw "caml_ba_slice not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_slice not implemented by bucklescript yet\n");
 }
 
 function slice_right_1(_, _$1, _$2) {
-  return function () {
-            throw "caml_ba_slice not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_slice not implemented by bucklescript yet\n");
 }
 
 function slice_left_2(_, _$1) {
-  return function () {
-            throw "caml_ba_slice not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_slice not implemented by bucklescript yet\n");
 }
 
 function slice_right_2(_, _$1) {
-  return function () {
-            throw "caml_ba_slice not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_slice not implemented by bucklescript yet\n");
 }
 
 function of_array$2(kind, layout, data) {
   var dim1 = data.length;
-  var dim2 = dim1 ? data[0].length : 0;
-  var dim3 = dim2 ? data[0][0].length : 0;
+  var dim2 = dim1 ? Caml_array.caml_array_get(data, 0).length : 0;
+  var dim3 = dim2 ? Caml_array.caml_array_get(Caml_array.caml_array_get(data, 0), 0).length : 0;
   var ba = create$2(kind, layout, dim1, dim2, dim3);
   layout !== 0 ? 1 : 0;
   for(var i = 0 ,i_finish = dim1 - 1 | 0; i <= i_finish; ++i){
-    var row = data[i];
+    var row = Caml_array.caml_array_get(data, i);
     if (row.length !== dim2) {
       throw [
             Caml_builtin_exceptions.invalid_argument,
@@ -1924,7 +1993,7 @@ function of_array$2(kind, layout, data) {
           ];
     }
     for(var j = 0 ,j_finish = dim2 - 1 | 0; j <= j_finish; ++j){
-      var col = row[j];
+      var col = Caml_array.caml_array_get(row, j);
       if (col.length !== dim3) {
         throw [
               Caml_builtin_exceptions.invalid_argument,
@@ -1932,9 +2001,7 @@ function of_array$2(kind, layout, data) {
             ];
       }
       for(var k = 0 ,k_finish = dim3 - 1 | 0; k <= k_finish; ++k){
-        (function () {
-              throw "caml_ba_set_3 not implemented by bucklescript yet\n";
-            }());
+        Caml_missing_polyfill.not_implemented("caml_ba_set_3 not implemented by bucklescript yet\n");
       }
     }
   }
@@ -1960,12 +2027,9 @@ var Array3 = /* module */[
 ];
 
 function array1_of_genarray(a) {
-  if (function () {
-        throw "caml_ba_num_dims not implemented by bucklescript yet\n";
-      }() === 1) {
+  if (Caml_missing_polyfill.not_implemented("caml_ba_num_dims not implemented by bucklescript yet\n") === 1) {
     return a;
-  }
-  else {
+  } else {
     throw [
           Caml_builtin_exceptions.invalid_argument,
           "Bigarray.array1_of_genarray"
@@ -1974,12 +2038,9 @@ function array1_of_genarray(a) {
 }
 
 function array2_of_genarray(a) {
-  if (function () {
-        throw "caml_ba_num_dims not implemented by bucklescript yet\n";
-      }() === 2) {
+  if (Caml_missing_polyfill.not_implemented("caml_ba_num_dims not implemented by bucklescript yet\n") === 2) {
     return a;
-  }
-  else {
+  } else {
     throw [
           Caml_builtin_exceptions.invalid_argument,
           "Bigarray.array2_of_genarray"
@@ -1988,12 +2049,9 @@ function array2_of_genarray(a) {
 }
 
 function array3_of_genarray(a) {
-  if (function () {
-        throw "caml_ba_num_dims not implemented by bucklescript yet\n";
-      }() === 3) {
+  if (Caml_missing_polyfill.not_implemented("caml_ba_num_dims not implemented by bucklescript yet\n") === 3) {
     return a;
-  }
-  else {
+  } else {
     throw [
           Caml_builtin_exceptions.invalid_argument,
           "Bigarray.array3_of_genarray"
@@ -2002,21 +2060,15 @@ function array3_of_genarray(a) {
 }
 
 function reshape_1(_, _$1) {
-  return function () {
-            throw "caml_ba_reshape not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_reshape not implemented by bucklescript yet\n");
 }
 
 function reshape_2(_, _$1, _$2) {
-  return function () {
-            throw "caml_ba_reshape not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_reshape not implemented by bucklescript yet\n");
 }
 
 function reshape_3(_, _$1, _$2, _$3) {
-  return function () {
-            throw "caml_ba_reshape not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_reshape not implemented by bucklescript yet\n");
 }
 
 var float32 = /* Float32 */0;
@@ -2050,9 +2102,7 @@ var c_layout = /* C_layout */0;
 var fortran_layout = /* Fortran_layout */1;
 
 function reshape(_, _$1) {
-  return function () {
-            throw "caml_ba_reshape not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_reshape not implemented by bucklescript yet\n");
 }
 
 exports.float32            = float32;
@@ -2110,13 +2160,13 @@ exports.__ = __;
 //////// start of buffer.js ////////
 'use strict';
 
-var Sys                     = require("./sys");
-var Bytes                   = require("./bytes");
-var Curry                   = require("./curry");
-var $$String                = require("./string");
-var Pervasives              = require("./pervasives");
-var Caml_string             = require("./caml_string");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Sys                     = require("./sys.js");
+var Bytes                   = require("./bytes.js");
+var Curry                   = require("./curry.js");
+var $$String                = require("./string.js");
+var Pervasives              = require("./pervasives.js");
+var Caml_string             = require("./caml_string.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function create(n) {
   var n$1 = n < 1 ? 1 : n;
@@ -2144,8 +2194,7 @@ function sub(b, ofs, len) {
           Caml_builtin_exceptions.invalid_argument,
           "Buffer.sub"
         ];
-  }
-  else {
+  } else {
     return Bytes.sub_string(b[/* buffer */0], ofs, len);
   }
 }
@@ -2156,8 +2205,7 @@ function blit(src, srcoff, dst, dstoff, len) {
           Caml_builtin_exceptions.invalid_argument,
           "Buffer.blit"
         ];
-  }
-  else {
+  } else {
     return Bytes.blit(src[/* buffer */0], srcoff, dst, dstoff, len);
   }
 }
@@ -2168,8 +2216,7 @@ function nth(b, ofs) {
           Caml_builtin_exceptions.invalid_argument,
           "Buffer.nth"
         ];
-  }
-  else {
+  } else {
     return b[/* buffer */0][ofs];
   }
 }
@@ -2199,8 +2246,7 @@ function resize(b, more) {
   if (new_len > Sys.max_string_length) {
     if ((b[/* position */1] + more | 0) <= Sys.max_string_length) {
       new_len = Sys.max_string_length;
-    }
-    else {
+    } else {
       throw [
             Caml_builtin_exceptions.failure,
             "Buffer.add: cannot grow buffer"
@@ -2293,12 +2339,10 @@ function closing(param) {
               9
             ]
           ];
-    }
-    else {
+    } else {
       return /* "}" */125;
     }
-  }
-  else {
+  } else {
     return /* ")" */41;
   }
 }
@@ -2312,25 +2356,21 @@ function advance_to_closing(opening, closing, k, s, start) {
     var k$1 = _k;
     if (i >= lim) {
       throw Caml_builtin_exceptions.not_found;
-    }
-    else if (Caml_string.get(s, i) === opening) {
+    } else if (Caml_string.get(s, i) === opening) {
       _i = i + 1 | 0;
       _k = k$1 + 1 | 0;
       continue ;
       
-    }
-    else if (Caml_string.get(s, i) === closing) {
+    } else if (Caml_string.get(s, i) === closing) {
       if (k$1) {
         _i = i + 1 | 0;
         _k = k$1 - 1 | 0;
         continue ;
         
-      }
-      else {
+      } else {
         return i;
       }
-    }
-    else {
+    } else {
       _i = i + 1 | 0;
       continue ;
       
@@ -2345,38 +2385,30 @@ function advance_to_non_alpha(s, start) {
     var i = _i;
     if (i >= lim) {
       return lim;
-    }
-    else {
+    } else {
       var match = Caml_string.get(s, i);
       var exit = 0;
       if (match >= 91) {
         if (match >= 97) {
           if (match >= 123) {
             return i;
-          }
-          else {
+          } else {
             exit = 1;
           }
-        }
-        else if (match !== 95) {
+        } else if (match !== 95) {
           return i;
-        }
-        else {
+        } else {
           exit = 1;
         }
-      }
-      else if (match >= 58) {
+      } else if (match >= 58) {
         if (match >= 65) {
           exit = 1;
+        } else {
+          return i;
         }
-        else {
-          return i;
-        }
-      }
-      else if (match >= 48) {
+      } else if (match >= 48) {
         exit = 1;
-      }
-      else {
+      } else {
         return i;
       }
       if (exit === 1) {
@@ -2392,8 +2424,7 @@ function advance_to_non_alpha(s, start) {
 function find_ident(s, start, lim) {
   if (start >= lim) {
     throw Caml_builtin_exceptions.not_found;
-  }
-  else {
+  } else {
     var c = Caml_string.get(s, start);
     var exit = 0;
     if (c !== 40) {
@@ -2403,12 +2434,10 @@ function find_ident(s, start, lim) {
                 $$String.sub(s, start, stop - start | 0),
                 stop
               ];
-      }
-      else {
+      } else {
         exit = 1;
       }
-    }
-    else {
+    } else {
       exit = 1;
     }
     if (exit === 1) {
@@ -2440,29 +2469,25 @@ function add_substitute(b, f, s) {
           _previous = /* " " */32;
           continue ;
           
-        }
-        else if (current !== 92) {
+        } else if (current !== 92) {
           add_char(b, current);
           _i = i + 1 | 0;
           _previous = current;
           continue ;
           
-        }
-        else {
+        } else {
           _i = i + 1 | 0;
           _previous = current;
           continue ;
           
         }
-      }
-      else if (previous === /* "\\" */92) {
+      } else if (previous === /* "\\" */92) {
         add_char(b, current);
         _i = i + 1 | 0;
         _previous = /* " " */32;
         continue ;
         
-      }
-      else {
+      } else {
         var j = i + 1 | 0;
         var match = find_ident(s, j, lim);
         add_string(b, Curry._1(f, match[0]));
@@ -2471,11 +2496,9 @@ function add_substitute(b, f, s) {
         continue ;
         
       }
-    }
-    else if (previous === /* "\\" */92) {
+    } else if (previous === /* "\\" */92) {
       return add_char(b, previous);
-    }
-    else {
+    } else {
       return 0;
     }
   };
@@ -2510,14 +2533,14 @@ exports.output_buffer  = output_buffer;
 //////// start of bytes.js ////////
 'use strict';
 
-var Char                    = require("./char");
-var List                    = require("./list");
-var Curry                   = require("./curry");
-var Caml_obj                = require("./caml_obj");
-var Caml_int32              = require("./caml_int32");
-var Pervasives              = require("./pervasives");
-var Caml_string             = require("./caml_string");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Char                    = require("./char.js");
+var List                    = require("./list.js");
+var Curry                   = require("./curry.js");
+var Caml_obj                = require("./caml_obj.js");
+var Caml_int32              = require("./caml_int32.js");
+var Pervasives              = require("./pervasives.js");
+var Caml_string             = require("./caml_string.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function make(n, c) {
   var s = Caml_string.caml_create_string(n);
@@ -2556,8 +2579,7 @@ function sub(s, ofs, len) {
           Caml_builtin_exceptions.invalid_argument,
           "String.sub / Bytes.sub"
         ];
-  }
-  else {
+  } else {
     var r = Caml_string.caml_create_string(len);
     Caml_string.caml_blit_bytes(s, ofs, r, 0, len);
     return r;
@@ -2593,8 +2615,7 @@ function fill(s, ofs, len, c) {
           Caml_builtin_exceptions.invalid_argument,
           "String.fill / Bytes.fill"
         ];
-  }
-  else {
+  } else {
     return Caml_string.caml_fill_string(s, ofs, len, c);
   }
 }
@@ -2605,8 +2626,7 @@ function blit(s1, ofs1, s2, ofs2, len) {
           Caml_builtin_exceptions.invalid_argument,
           "Bytes.blit"
         ];
-  }
-  else {
+  } else {
     return Caml_string.caml_blit_bytes(s1, ofs1, s2, ofs2, len);
   }
 }
@@ -2617,8 +2637,7 @@ function blit_string(s1, ofs1, s2, ofs2, len) {
           Caml_builtin_exceptions.invalid_argument,
           "String.blit / Bytes.blit_string"
         ];
-  }
-  else {
+  } else {
     return Caml_string.caml_blit_string(s1, ofs1, s2, ofs2, len);
   }
 }
@@ -2658,8 +2677,7 @@ function concat(sep, l) {
           return /* () */0;
         }, l[1]);
     return r;
-  }
-  else {
+  } else {
     return empty;
   }
 }
@@ -2673,15 +2691,12 @@ function is_space(param) {
   if (switcher > 4 || switcher < 0) {
     if (switcher !== 23) {
       return /* false */0;
-    }
-    else {
+    } else {
       return /* true */1;
     }
-  }
-  else if (switcher !== 2) {
+  } else if (switcher !== 2) {
     return /* true */1;
-  }
-  else {
+  } else {
     return /* false */0;
   }
 }
@@ -2698,8 +2713,7 @@ function trim(s) {
   };
   if (j >= i) {
     return sub(s, i, (j - i | 0) + 1 | 0);
-  }
-  else {
+  } else {
     return empty;
   }
 }
@@ -2716,8 +2730,7 @@ function escaped(s) {
         ) : (
           switcher > 57 || switcher < 1 ? 2 : 1
         );
-    }
-    else {
+    } else {
       $js = match >= 11 ? (
           match !== 13 ? 4 : 2
         ) : (
@@ -2728,8 +2741,7 @@ function escaped(s) {
   }
   if (n === s.length) {
     return copy(s);
-  }
-  else {
+  } else {
     var s$prime = Caml_string.caml_create_string(n);
     n = 0;
     for(var i$1 = 0 ,i_finish$1 = s.length - 1 | 0; i$1 <= i_finish$1; ++i$1){
@@ -2739,27 +2751,21 @@ function escaped(s) {
         if (c !== 92) {
           if (c >= 127) {
             exit = 1;
-          }
-          else {
+          } else {
             s$prime[n] = c;
           }
-        }
-        else {
+        } else {
           exit = 2;
         }
-      }
-      else if (c >= 32) {
+      } else if (c >= 32) {
         if (c >= 34) {
           exit = 2;
-        }
-        else {
+        } else {
           s$prime[n] = c;
         }
-      }
-      else if (c >= 14) {
+      } else if (c >= 14) {
         exit = 1;
-      }
-      else {
+      } else {
         switch (c) {
           case 8 : 
               s$prime[n] = /* "\\" */92;
@@ -2827,8 +2833,7 @@ function map(f, s) {
       r[i] = Curry._1(f, s[i]);
     }
     return r;
-  }
-  else {
+  } else {
     return s;
   }
 }
@@ -2841,8 +2846,7 @@ function mapi(f, s) {
       r[i] = Curry._2(f, i, s[i]);
     }
     return r;
-  }
-  else {
+  } else {
     return s;
   }
 }
@@ -2860,8 +2864,7 @@ function apply1(f, s) {
     var r = copy(s);
     r[0] = Curry._1(f, s[0]);
     return r;
-  }
-  else {
+  } else {
     return s;
   }
 }
@@ -2879,11 +2882,9 @@ function index_rec(s, lim, _i, c) {
     var i = _i;
     if (i >= lim) {
       throw Caml_builtin_exceptions.not_found;
-    }
-    else if (s[i] === c) {
+    } else if (s[i] === c) {
       return i;
-    }
-    else {
+    } else {
       _i = i + 1 | 0;
       continue ;
       
@@ -2902,8 +2903,7 @@ function index_from(s, i, c) {
           Caml_builtin_exceptions.invalid_argument,
           "String.index_from / Bytes.index_from"
         ];
-  }
-  else {
+  } else {
     return index_rec(s, l, i, c);
   }
 }
@@ -2913,11 +2913,9 @@ function rindex_rec(s, _i, c) {
     var i = _i;
     if (i < 0) {
       throw Caml_builtin_exceptions.not_found;
-    }
-    else if (s[i] === c) {
+    } else if (s[i] === c) {
       return i;
-    }
-    else {
+    } else {
       _i = i - 1 | 0;
       continue ;
       
@@ -2935,8 +2933,7 @@ function rindex_from(s, i, c) {
           Caml_builtin_exceptions.invalid_argument,
           "String.rindex_from / Bytes.rindex_from"
         ];
-  }
-  else {
+  } else {
     return rindex_rec(s, i, c);
   }
 }
@@ -2948,8 +2945,7 @@ function contains_from(s, i, c) {
           Caml_builtin_exceptions.invalid_argument,
           "String.contains_from / Bytes.contains_from"
         ];
-  }
-  else {
+  } else {
     try {
       index_rec(s, l, i, c);
       return /* true */1;
@@ -2957,8 +2953,7 @@ function contains_from(s, i, c) {
     catch (exn){
       if (exn === Caml_builtin_exceptions.not_found) {
         return /* false */0;
-      }
-      else {
+      } else {
         throw exn;
       }
     }
@@ -2975,8 +2970,7 @@ function rcontains_from(s, i, c) {
           Caml_builtin_exceptions.invalid_argument,
           "String.rcontains_from / Bytes.rcontains_from"
         ];
-  }
-  else {
+  } else {
     try {
       rindex_rec(s, i, c);
       return /* true */1;
@@ -2984,8 +2978,7 @@ function rcontains_from(s, i, c) {
     catch (exn){
       if (exn === Caml_builtin_exceptions.not_found) {
         return /* false */0;
-      }
-      else {
+      } else {
         throw exn;
       }
     }
@@ -3043,6 +3036,7 @@ exports.unsafe_of_string = unsafe_of_string;
 //////// start of caml_array.js ////////
 'use strict';
 
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function caml_array_sub(x, offset, len) {
   var result = new Array(len);
@@ -3065,8 +3059,7 @@ function len(_acc, _l) {
       _acc = l[0].length + acc | 0;
       continue ;
       
-    }
-    else {
+    } else {
       return acc;
     }
   };
@@ -3090,8 +3083,7 @@ function fill(arr, _i, _l) {
       _i = k;
       continue ;
       
-    }
-    else {
+    } else {
       return /* () */0;
     }
   };
@@ -3104,6 +3096,29 @@ function caml_array_concat(l) {
   return result;
 }
 
+function caml_array_set(xs, index, newval) {
+  if (index < 0 || index >= xs.length) {
+    throw [
+          Caml_builtin_exceptions.invalid_argument,
+          "index out of bounds"
+        ];
+  } else {
+    xs[index] = newval;
+    return /* () */0;
+  }
+}
+
+function caml_array_get(xs, index) {
+  if (index < 0 || index >= xs.length) {
+    throw [
+          Caml_builtin_exceptions.invalid_argument,
+          "index out of bounds"
+        ];
+  } else {
+    return xs[index];
+  }
+}
+
 function caml_make_vect(len, init) {
   var b = new Array(len);
   for(var i = 0 ,i_finish = len - 1 | 0; i <= i_finish; ++i){
@@ -3118,8 +3133,7 @@ function caml_array_blit(a1, i1, a2, i2, len) {
       a2[j + i2 | 0] = a1[j + i1 | 0];
     }
     return /* () */0;
-  }
-  else {
+  } else {
     for(var j$1 = len - 1 | 0; j$1 >= 0; --j$1){
       a2[j$1 + i2 | 0] = a1[j$1 + i1 | 0];
     }
@@ -3131,6 +3145,8 @@ exports.caml_array_sub    = caml_array_sub;
 exports.caml_array_concat = caml_array_concat;
 exports.caml_make_vect    = caml_make_vect;
 exports.caml_array_blit   = caml_array_blit;
+exports.caml_array_get    = caml_array_get;
+exports.caml_array_set    = caml_array_set;
 /* No side effect */
 //////// end of caml_array.js ////////
     return exports;
@@ -3203,6 +3219,30 @@ var undefined_recursive_module = /* tuple */[
   -11
 ];
 
+out_of_memory.tag = 248;
+
+sys_error.tag = 248;
+
+failure.tag = 248;
+
+invalid_argument.tag = 248;
+
+end_of_file.tag = 248;
+
+division_by_zero.tag = 248;
+
+not_found.tag = 248;
+
+match_failure.tag = 248;
+
+stack_overflow.tag = 248;
+
+sys_blocked_io.tag = 248;
+
+assert_failure.tag = 248;
+
+undefined_recursive_module.tag = 248;
+
 exports.out_of_memory              = out_of_memory;
 exports.sys_error                  = sys_error;
 exports.failure                    = failure;
@@ -3215,7 +3255,7 @@ exports.stack_overflow             = stack_overflow;
 exports.sys_blocked_io             = sys_blocked_io;
 exports.assert_failure             = assert_failure;
 exports.undefined_recursive_module = undefined_recursive_module;
-/* No side effect */
+/*  Not a pure module */
 //////// end of caml_builtin_exceptions.js ////////
     return exports;
   };
@@ -3226,7 +3266,7 @@ exports.undefined_recursive_module = undefined_recursive_module;
 //////// start of caml_bytes.js ////////
 'use strict';
 
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function get(s, i) {
   if (i < 0 || i >= s.length) {
@@ -3234,8 +3274,7 @@ function get(s, i) {
           Caml_builtin_exceptions.invalid_argument,
           "index out of bounds"
         ];
-  }
-  else {
+  } else {
     return s[i];
   }
 }
@@ -3276,9 +3315,25 @@ function create(str) {
   return v;
 }
 
-exports.caml_set_oo_id = caml_set_oo_id;
-exports.get_id         = get_id;
-exports.create         = create;
+function isCamlExceptionOrOpenVariant(e) {
+  if (e === undefined) {
+    return /* false */0;
+  } else if (e.tag === 248) {
+    return /* true */1;
+  } else {
+    var slot = e[0];
+    if (slot !== undefined) {
+      return +(slot.tag === 248);
+    } else {
+      return /* false */0;
+    }
+  }
+}
+
+exports.caml_set_oo_id               = caml_set_oo_id;
+exports.get_id                       = get_id;
+exports.create                       = create;
+exports.isCamlExceptionOrOpenVariant = isCamlExceptionOrOpenVariant;
 /* No side effect */
 //////// end of caml_exceptions.js ////////
     return exports;
@@ -3306,18 +3361,14 @@ function caml_classify_float(x) {
   if (isFinite(x)) {
     if (Math.abs(x) >= 2.2250738585072014e-308) {
       return /* FP_normal */0;
-    }
-    else if (x !== 0) {
+    } else if (x !== 0) {
       return /* FP_subnormal */1;
-    }
-    else {
+    } else {
       return /* FP_zero */2;
     }
-  }
-  else if (isNaN(x)) {
+  } else if (isNaN(x)) {
     return /* FP_nan */4;
-  }
-  else {
+  } else {
     return /* FP_infinite */3;
   }
 }
@@ -3333,21 +3384,18 @@ function caml_modf_float(x) {
               -f,
               -i
             ];
-    }
-    else {
+    } else {
       return /* tuple */[
               f,
               i
             ];
     }
-  }
-  else if (isNaN(x)) {
+  } else if (isNaN(x)) {
     return /* tuple */[
             NaN,
             NaN
           ];
-  }
-  else {
+  } else {
     return /* tuple */[
             1 / x,
             x
@@ -3355,51 +3403,61 @@ function caml_modf_float(x) {
   }
 }
 
-var caml_ldexp_float = ( function (x,exp) {
-    exp |= 0;
-    if (exp > 1023) {
-        exp -= 1023;
-        x *= Math.pow(2, 1023);
-        if (exp > 1023) {  // in case x is subnormal
-            exp -= 1023;
-            x *= Math.pow(2, 1023);
-        }
+function caml_ldexp_float(x, exp) {
+  var match_000 = [x];
+  var match_001 = [exp];
+  var exp$prime = match_001;
+  var x$prime = match_000;
+  if (exp$prime[0] > 1023) {
+    exp$prime[0] -= 1023;
+    x$prime[0] = x$prime[0] * Math.pow(2, 1023);
+    if (exp$prime[0] > 1023) {
+      exp$prime[0] -= 1023;
+      x$prime[0] = x$prime[0] * Math.pow(2, 1023);
     }
-    if (exp < -1023) {
-        exp += 1023;
-        x *= Math.pow(2, -1023);
-    }
-    x *= Math.pow(2, exp);
-    return x;
+    
+  } else if (exp$prime[0] < -1023) {
+    exp$prime[0] += 1023;
+    x$prime[0] = x$prime[0] * Math.pow(2, -1023);
+  }
+  return x$prime[0] * Math.pow(2, exp$prime[0]);
 }
-);
 
-var caml_frexp_float = (function (x) {
-    if ((x == 0) || !isFinite(x)) return [ x, 0];
-    var neg = x < 0;
-    if (neg) x = - x;
-    var exp = Math.floor(Math.LOG2E*Math.log(x)) + 1;
-    x *= Math.pow(2,-exp);
-    if (x < 0.5) { x *= 2; exp -= 1; }
-    if (neg) x = - x;
-    return [x, exp];
+function caml_frexp_float(x) {
+  if (x === 0 || !isFinite(x)) {
+    return /* tuple */[
+            x,
+            0
+          ];
+  } else {
+    var neg = +(x < 0);
+    var x$prime = Math.abs(x);
+    var exp = Math.floor(Math.LOG2E * Math.log(x$prime)) + 1;
+    x$prime = x$prime * Math.pow(2, -exp);
+    if (x$prime < 0.5) {
+      x$prime = x$prime * 2;
+      exp -= 1;
+    }
+    if (neg) {
+      x$prime = -x$prime;
+    }
+    return /* tuple */[
+            x$prime,
+            exp | 0
+          ];
+  }
 }
-);
 
 function caml_float_compare(x, y) {
   if (x === y) {
     return 0;
-  }
-  else if (x < y) {
+  } else if (x < y) {
     return -1;
-  }
-  else if (x > y || x === x) {
+  } else if (x > y || x === x) {
     return 1;
-  }
-  else if (y === y) {
+  } else if (y === y) {
     return -1;
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -3409,8 +3467,7 @@ function caml_copysign_float(x, y) {
   var y$1 = y === 0 ? 1 / y : y;
   if (y$1 < 0) {
     return -x$1;
-  }
-  else {
+  } else {
     return x$1;
   }
 }
@@ -3420,25 +3477,28 @@ function caml_expm1_float(x) {
   var z = y - 1;
   if (Math.abs(x) > 1) {
     return z;
-  }
-  else if (z === 0) {
+  } else if (z === 0) {
     return x;
-  }
-  else {
+  } else {
     return x * z / Math.log(y);
   }
 }
 
-var caml_hypot_float = ( function (x, y) {
-    var x0 = Math.abs(x), y0 = Math.abs(y);
-    var a = Math.max(x0, y0), b = Math.min(x0,y0) / (a?a:1);
-    return a * Math.sqrt(1 + b*b);
+function caml_hypot_float(x, y) {
+  var match_000 = Math.abs(x);
+  var match_001 = Math.abs(y);
+  var y0 = match_001;
+  var x0 = match_000;
+  var a = Math.max(x0, y0);
+  var b = Math.min(x0, y0) / (
+    a !== 0 ? a : 1
+  );
+  return a * Math.sqrt(1 + b * b);
 }
-);
 
-var caml_log10_float = ( function  (x) { 
-   return Math.LOG10E * Math.log(x); }
-);
+function caml_log10_float(x) {
+  return Math.LOG10E * Math.log(x);
+}
 
 exports.caml_int32_float_of_bits = caml_int32_float_of_bits;
 exports.caml_int32_bits_of_float = caml_int32_bits_of_float;
@@ -3451,7 +3511,7 @@ exports.caml_copysign_float      = caml_copysign_float;
 exports.caml_expm1_float         = caml_expm1_float;
 exports.caml_hypot_float         = caml_hypot_float;
 exports.caml_log10_float         = caml_log10_float;
-/* caml_ldexp_float Not a pure module */
+/* No side effect */
 //////// end of caml_float.js ////////
     return exports;
   };
@@ -3462,12 +3522,11 @@ exports.caml_log10_float         = caml_log10_float;
 //////// start of caml_format.js ////////
 'use strict';
 
-var Curry                   = require("./curry");
-var Caml_int32              = require("./caml_int32");
-var Caml_int64              = require("./caml_int64");
-var Caml_utils              = require("./caml_utils");
-var Caml_string             = require("./caml_string");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Curry                   = require("./curry.js");
+var Caml_int32              = require("./caml_int32.js");
+var Caml_int64              = require("./caml_int64.js");
+var Caml_utils              = require("./caml_utils.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function caml_failwith(s) {
   throw [
@@ -3481,22 +3540,17 @@ function parse_digit(c) {
     if (c >= 97) {
       if (c >= 123) {
         return -1;
-      }
-      else {
+      } else {
         return c - 87 | 0;
       }
-    }
-    else if (c >= 91) {
+    } else if (c >= 91) {
       return -1;
-    }
-    else {
+    } else {
       return c - 55 | 0;
     }
-  }
-  else if (c > 57 || c < 48) {
+  } else if (c > 57 || c < 48) {
     return -1;
-  }
-  else {
+  } else {
     return c - /* "0" */48 | 0;
   }
 }
@@ -3534,31 +3588,26 @@ function parse_sign_and_base(s) {
             i = i + 2 | 0;
           }
           
-        }
-        else {
+        } else {
           base = /* Oct */0;
           i = i + 2 | 0;
         }
-      }
-      else {
+      } else {
         base = /* Bin */3;
         i = i + 2 | 0;
       }
-    }
-    else if (match$1 !== 66) {
+    } else if (match$1 !== 66) {
       if (match$1 !== 79) {
         if (match$1 >= 88) {
           base = /* Hex */1;
           i = i + 2 | 0;
         }
         
-      }
-      else {
+      } else {
         base = /* Oct */0;
         i = i + 2 | 0;
       }
-    }
-    else {
+    } else {
       base = /* Bin */3;
       i = i + 2 | 0;
     }
@@ -3590,31 +3639,27 @@ function caml_int_of_string(s) {
       var acc = _acc;
       if (k === len) {
         return acc;
-      }
-      else {
+      } else {
         var a = s.charCodeAt(k);
         if (a === /* "_" */95) {
           _k = k + 1 | 0;
           continue ;
           
-        }
-        else {
+        } else {
           var v = parse_digit(a);
           if (v < 0 || v >= base) {
             throw [
                   Caml_builtin_exceptions.failure,
                   "int_of_string"
                 ];
-          }
-          else {
+          } else {
             var acc$1 = base * acc + v;
             if (acc$1 > threshold) {
               throw [
                     Caml_builtin_exceptions.failure,
                     "int_of_string"
                   ];
-            }
-            else {
+            } else {
               _k = k + 1 | 0;
               _acc = acc$1;
               continue ;
@@ -3688,51 +3733,38 @@ function caml_int64_of_string(s) {
       var acc = _acc;
       if (k === len) {
         return acc;
-      }
-      else {
+      } else {
         var a = s.charCodeAt(k);
         if (a === /* "_" */95) {
           _k = k + 1 | 0;
           continue ;
           
-        }
-        else {
+        } else {
           var v = Caml_int64.of_int32(parse_digit(a));
           if (Caml_int64.lt(v, /* int64 */[
                   /* hi */0,
                   /* lo */0
-                ]) || Caml_int64.ge(v, base)) {
+                ]) || Caml_int64.ge(v, base) || Caml_int64.gt(acc, threshold)) {
             throw [
                   Caml_builtin_exceptions.failure,
                   "int64_of_string"
                 ];
-          }
-          else {
+          } else {
             var acc$1 = Caml_int64.add(Caml_int64.mul(base, acc), v);
-            if (Caml_int64.gt(acc$1, threshold)) {
-              throw [
-                    Caml_builtin_exceptions.failure,
-                    "int64_of_string"
-                  ];
-            }
-            else {
-              _k = k + 1 | 0;
-              _acc = acc$1;
-              continue ;
-              
-            }
+            _k = k + 1 | 0;
+            _acc = acc$1;
+            continue ;
+            
           }
         }
       }
     };
   };
   var res = Caml_int64.mul(sign, aux(d, i + 1 | 0));
-  var or_res_000 = /* hi */res[0] | /* hi */0;
-  var or_res_001 = /* lo */(res[1] >>> 0);
-  var or_res = /* int64 */[
-    or_res_000,
-    or_res_001
-  ];
+  var or_res = Caml_int64.or_(res, /* int64 */[
+        /* hi */0,
+        /* lo */0
+      ]);
   if (Caml_int64.eq(base, /* int64 */[
           /* hi */0,
           /* lo */10
@@ -3760,8 +3792,7 @@ function int_of_base(param) {
 function lowercase(c) {
   if (c >= /* "A" */65 && c <= /* "Z" */90 || c >= /* "\192" */192 && c <= /* "\214" */214 || c >= /* "\216" */216 && c <= /* "\222" */222) {
     return c + 32 | 0;
-  }
-  else {
+  } else {
     return c;
   }
 }
@@ -3792,16 +3823,14 @@ function parse_format(fmt) {
     var i = _i;
     if (i >= len) {
       return f;
-    }
-    else {
+    } else {
       var c = fmt.charCodeAt(i);
       var exit = 0;
       if (c >= 69) {
         if (c >= 88) {
           if (c >= 121) {
             exit = 1;
-          }
-          else {
+          } else {
             switch (c - 88 | 0) {
               case 0 : 
                   f[/* base */4] = /* Hex */1;
@@ -3858,11 +3887,9 @@ function parse_format(fmt) {
                   
             }
           }
-        }
-        else if (c >= 72) {
+        } else if (c >= 72) {
           exit = 1;
-        }
-        else {
+        } else {
           f[/* signedconv */5] = /* true */1;
           f[/* uppercase */7] = /* true */1;
           f[/* conv */10] = String.fromCharCode(lowercase(c));
@@ -3870,13 +3897,11 @@ function parse_format(fmt) {
           continue ;
           
         }
-      }
-      else {
+      } else {
         var switcher = c - 32 | 0;
         if (switcher > 25 || switcher < 0) {
           exit = 1;
-        }
-        else {
+        } else {
           switch (switcher) {
             case 3 : 
                 f[/* alternate */3] = /* true */1;
@@ -3994,8 +4019,7 @@ function finish_formatting(param, rawbuffer) {
         len = len + 2 | 0;
       }
       
-    }
-    else {
+    } else {
       len = len + 1 | 0;
     }
   }
@@ -4008,8 +4032,7 @@ function finish_formatting(param, rawbuffer) {
   if (signedconv) {
     if (sign < 0) {
       buffer = buffer + "-";
-    }
-    else if (signstyle !== "-") {
+    } else if (signstyle !== "-") {
       buffer = buffer + signstyle;
     }
     
@@ -4036,9 +4059,8 @@ function finish_formatting(param, rawbuffer) {
 
 function caml_format_int(fmt, i) {
   if (fmt === "%d") {
-    return "" + i;
-  }
-  else {
+    return String(i);
+  } else {
     var f = parse_format(fmt);
     var f$1 = f;
     var i$1 = i;
@@ -4084,7 +4106,7 @@ function caml_int64_format(fmt, x) {
                 /* lo */0
               ], match$1[0]);
           var modulus = match$1[1];
-          s = Caml_string.js_string_of_char(cvtbl.charCodeAt(modulus[1] | 0)) + s;
+          s = String.fromCharCode(cvtbl.charCodeAt(modulus[1] | 0)) + s;
           while(Caml_int64.neq(quotient, /* int64 */[
                   /* hi */0,
                   /* lo */0
@@ -4092,14 +4114,13 @@ function caml_int64_format(fmt, x) {
             var match$2 = Caml_int64.div_mod(quotient, wbase);
             quotient = match$2[0];
             modulus = match$2[1];
-            s = Caml_string.js_string_of_char(cvtbl.charCodeAt(modulus[1] | 0)) + s;
+            s = String.fromCharCode(cvtbl.charCodeAt(modulus[1] | 0)) + s;
           };
-        }
-        else {
+        } else {
           var match$3 = Caml_int64.div_mod(x$1, wbase);
           var quotient$1 = match$3[0];
           var modulus$1 = match$3[1];
-          s = Caml_string.js_string_of_char(cvtbl.charCodeAt(modulus$1[1] | 0)) + s;
+          s = String.fromCharCode(cvtbl.charCodeAt(modulus$1[1] | 0)) + s;
           while(Caml_int64.neq(quotient$1, /* int64 */[
                   /* hi */0,
                   /* lo */0
@@ -4107,7 +4128,7 @@ function caml_int64_format(fmt, x) {
             var match$4 = Caml_int64.div_mod(quotient$1, wbase);
             quotient$1 = match$4[0];
             modulus$1 = match$4[1];
-            s = Caml_string.js_string_of_char(cvtbl.charCodeAt(modulus$1[1] | 0)) + s;
+            s = String.fromCharCode(cvtbl.charCodeAt(modulus$1[1] | 0)) + s;
           };
         }
         break;
@@ -4135,7 +4156,7 @@ function caml_int64_format(fmt, x) {
                     /* lo */3435973836
                   ], match$5[0]), match$6[0]);
           var modulus$2 = match$6[1];
-          s = Caml_string.js_string_of_char(cvtbl$1.charCodeAt(modulus$2[1] | 0)) + s;
+          s = String.fromCharCode(cvtbl$1.charCodeAt(modulus$2[1] | 0)) + s;
           while(Caml_int64.neq(quotient$2, /* int64 */[
                   /* hi */0,
                   /* lo */0
@@ -4143,14 +4164,13 @@ function caml_int64_format(fmt, x) {
             var match$7 = Caml_int64.div_mod(quotient$2, wbase$1);
             quotient$2 = match$7[0];
             modulus$2 = match$7[1];
-            s = Caml_string.js_string_of_char(cvtbl$1.charCodeAt(modulus$2[1] | 0)) + s;
+            s = String.fromCharCode(cvtbl$1.charCodeAt(modulus$2[1] | 0)) + s;
           };
-        }
-        else {
+        } else {
           var match$8 = Caml_int64.div_mod(x$1, wbase$1);
           var quotient$3 = match$8[0];
           var modulus$3 = match$8[1];
-          s = Caml_string.js_string_of_char(cvtbl$1.charCodeAt(modulus$3[1] | 0)) + s;
+          s = String.fromCharCode(cvtbl$1.charCodeAt(modulus$3[1] | 0)) + s;
           while(Caml_int64.neq(quotient$3, /* int64 */[
                   /* hi */0,
                   /* lo */0
@@ -4158,7 +4178,7 @@ function caml_int64_format(fmt, x) {
             var match$9 = Caml_int64.div_mod(quotient$3, wbase$1);
             quotient$3 = match$9[0];
             modulus$3 = match$9[1];
-            s = Caml_string.js_string_of_char(cvtbl$1.charCodeAt(modulus$3[1] | 0)) + s;
+            s = String.fromCharCode(cvtbl$1.charCodeAt(modulus$3[1] | 0)) + s;
           };
         }
         break;
@@ -4183,8 +4203,7 @@ function caml_format_float(fmt, x) {
   if (isNaN(x$1)) {
     s = "nan";
     f[/* filter */2] = " ";
-  }
-  else if (isFinite(x$1)) {
+  } else if (isFinite(x$1)) {
     var match = f[/* conv */10];
     switch (match) {
       case "e" : 
@@ -4201,8 +4220,8 @@ function caml_format_float(fmt, x) {
           var prec$1 = prec !== 0 ? prec : 1;
           s = x$1.toExponential(prec$1 - 1 | 0);
           var j = s.indexOf("e");
-          var exp = +s.slice(j + 1 | 0);
-          if (exp < -4 || x$1 >= 1e21 || x$1.toFixed(0).length > prec$1) {
+          var exp = Number(s.slice(j + 1 | 0)) | 0;
+          if (exp < -4 || x$1 >= 1e21 || x$1.toFixed().length > prec$1) {
             var i$1 = j - 1 | 0;
             while(s[i$1] === "0") {
               i$1 = i$1 - 1 | 0;
@@ -4216,14 +4235,12 @@ function caml_format_float(fmt, x) {
               s = s.slice(0, i$2 - 1 | 0) + ("0" + s.slice(i$2 - 1 | 0));
             }
             
-          }
-          else {
+          } else {
             var p = prec$1;
             if (exp < 0) {
               p = p - (exp + 1 | 0) | 0;
               s = x$1.toFixed(p);
-            }
-            else {
+            } else {
               while(function () {
                     s = x$1.toFixed(p);
                     return +(s.length > (prec$1 + 1 | 0));
@@ -4247,8 +4264,7 @@ function caml_format_float(fmt, x) {
       default:
         
     }
-  }
-  else {
+  } else {
     s = "inf";
     f[/* filter */2] = " ";
   }
@@ -4315,13 +4331,12 @@ exports.caml_nativeint_of_string = caml_nativeint_of_string;
 //////// start of caml_int32.js ////////
 'use strict';
 
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function div(x, y) {
   if (y === 0) {
     throw Caml_builtin_exceptions.division_by_zero;
-  }
-  else {
+  } else {
     return x / y | 0;
   }
 }
@@ -4329,8 +4344,7 @@ function div(x, y) {
 function mod_(x, y) {
   if (y === 0) {
     throw Caml_builtin_exceptions.division_by_zero;
-  }
-  else {
+  } else {
     return x % y;
   }
 }
@@ -4367,10 +4381,10 @@ exports.imul                 = imul;
 //////// start of caml_int64.js ////////
 'use strict';
 
-var Caml_obj                = require("./caml_obj");
-var Caml_int32              = require("./caml_int32");
-var Caml_utils              = require("./caml_utils");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Caml_obj                = require("./caml_obj.js");
+var Caml_int32              = require("./caml_int32.js");
+var Caml_utils              = require("./caml_utils.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 var min_int = /* record */[
   /* hi */-2147483648,
@@ -4425,8 +4439,7 @@ function not(param) {
 function eq(x, y) {
   if (x[/* hi */0] === y[/* hi */0]) {
     return +(x[/* lo */1] === y[/* lo */1]);
-  }
-  else {
+  } else {
     return /* false */0;
   }
 }
@@ -4434,8 +4447,7 @@ function eq(x, y) {
 function neg(x) {
   if (eq(x, min_int)) {
     return min_int;
-  }
-  else {
+  } else {
     return add(not(x), one);
   }
 }
@@ -4445,30 +4457,28 @@ function sub(x, y) {
 }
 
 function lsl_(x, numBits) {
-  var lo = x[/* lo */1];
   if (numBits) {
+    var lo = x[/* lo */1];
     if (numBits >= 32) {
       return /* record */[
               /* hi */(lo << (numBits - 32 | 0)),
               /* lo */0
             ];
-    }
-    else {
+    } else {
       var hi = (lo >>> (32 - numBits | 0)) | (x[/* hi */0] << numBits);
       return /* record */[
               /* hi */hi,
               /* lo */((lo << numBits) >>> 0)
             ];
     }
-  }
-  else {
+  } else {
     return x;
   }
 }
 
 function lsr_(x, numBits) {
-  var hi = x[/* hi */0];
   if (numBits) {
+    var hi = x[/* hi */0];
     var offset = numBits - 32 | 0;
     if (offset) {
       if (offset > 0) {
@@ -4477,8 +4487,7 @@ function lsr_(x, numBits) {
                 /* hi */0,
                 /* lo */(lo >>> 0)
               ];
-      }
-      else {
+      } else {
         var hi$1 = (hi >>> numBits);
         var lo$1 = (hi << (-offset | 0)) | (x[/* lo */1] >>> numBits);
         return /* record */[
@@ -4486,22 +4495,20 @@ function lsr_(x, numBits) {
                 /* lo */(lo$1 >>> 0)
               ];
       }
-    }
-    else {
+    } else {
       return /* record */[
               /* hi */0,
               /* lo */(hi >>> 0)
             ];
     }
-  }
-  else {
+  } else {
     return x;
   }
 }
 
 function asr_(x, numBits) {
-  var hi = x[/* hi */0];
   if (numBits) {
+    var hi = x[/* hi */0];
     if (numBits < 32) {
       var hi$1 = (hi >> numBits);
       var lo = (hi << (32 - numBits | 0)) | (x[/* lo */1] >>> numBits);
@@ -4509,16 +4516,14 @@ function asr_(x, numBits) {
               /* hi */hi$1,
               /* lo */(lo >>> 0)
             ];
-    }
-    else {
+    } else {
       var lo$1 = (hi >> (numBits - 32 | 0));
       return /* record */[
               /* hi */hi >= 0 ? 0 : -1,
               /* lo */(lo$1 >>> 0)
             ];
     }
-  }
-  else {
+  } else {
     return x;
   }
 }
@@ -4526,8 +4531,7 @@ function asr_(x, numBits) {
 function is_zero(param) {
   if (param[/* hi */0] !== 0 || param[/* lo */1] !== 0) {
     return /* false */0;
-  }
-  else {
+  } else {
     return /* true */1;
   }
 }
@@ -4544,32 +4548,26 @@ function mul(_this, _other) {
     var exit$3 = 0;
     if (this_hi !== 0) {
       exit$3 = 4;
-    }
-    else if ($$this[/* lo */1] !== 0) {
+    } else if ($$this[/* lo */1] !== 0) {
       exit$3 = 4;
-    }
-    else {
+    } else {
       return zero;
     }
     if (exit$3 === 4) {
       if (other[/* hi */0] !== 0) {
         exit$2 = 3;
-      }
-      else if (other[/* lo */1] !== 0) {
+      } else if (other[/* lo */1] !== 0) {
         exit$2 = 3;
-      }
-      else {
+      } else {
         return zero;
       }
     }
     if (exit$2 === 3) {
       if (this_hi !== -2147483648) {
         exit$1 = 2;
-      }
-      else if ($$this[/* lo */1] !== 0) {
+      } else if ($$this[/* lo */1] !== 0) {
         exit$1 = 2;
-      }
-      else {
+      } else {
         lo = other[/* lo */1];
         exit = 1;
       }
@@ -4580,11 +4578,9 @@ function mul(_this, _other) {
       var exit$4 = 0;
       if (other_hi !== -2147483648) {
         exit$4 = 3;
-      }
-      else if (other[/* lo */1] !== 0) {
+      } else if (other[/* lo */1] !== 0) {
         exit$4 = 3;
-      }
-      else {
+      } else {
         lo = lo$1;
         exit = 1;
       }
@@ -4596,15 +4592,12 @@ function mul(_this, _other) {
             _this = neg($$this);
             continue ;
             
-          }
-          else {
+          } else {
             return neg(mul(neg($$this), other));
           }
-        }
-        else if (other_hi < 0) {
+        } else if (other_hi < 0) {
           return neg(mul($$this, neg(other)));
-        }
-        else {
+        } else {
           var a48 = (this_hi >>> 16);
           var a32 = this_hi & 65535;
           var a16 = (lo$1 >>> 16);
@@ -4641,8 +4634,7 @@ function mul(_this, _other) {
     if (exit === 1) {
       if ((lo & 1) === 0) {
         return zero;
-      }
-      else {
+      } else {
         return min_int;
       }
     }
@@ -4685,11 +4677,9 @@ function ge(param, param$1) {
   var hi = param[/* hi */0];
   if (hi > other_hi) {
     return /* true */1;
-  }
-  else if (hi < other_hi) {
+  } else if (hi < other_hi) {
     return /* false */0;
-  }
-  else {
+  } else {
     return +(param[/* lo */1] >= param$1[/* lo */1]);
   }
 }
@@ -4705,11 +4695,9 @@ function lt(x, y) {
 function gt(x, y) {
   if (x[/* hi */0] > y[/* hi */0]) {
     return /* true */1;
-  }
-  else if (x[/* hi */0] < y[/* hi */0]) {
+  } else if (x[/* hi */0] < y[/* hi */0]) {
     return /* false */0;
-  }
-  else {
+  } else {
     return +(x[/* lo */1] > y[/* lo */1]);
   }
 }
@@ -4719,7 +4707,7 @@ function le(x, y) {
 }
 
 function to_float(param) {
-  return param[/* hi */0] * 4294967296 + param[/* lo */1];
+  return param[/* hi */0] * (0x100000000) + param[/* lo */1];
 }
 
 var two_ptr_32_dbl = Math.pow(2, 32);
@@ -4731,17 +4719,13 @@ var neg_two_ptr_63 = -Math.pow(2, 63);
 function of_float(x) {
   if (isNaN(x) || !isFinite(x)) {
     return zero;
-  }
-  else if (x <= neg_two_ptr_63) {
+  } else if (x <= neg_two_ptr_63) {
     return min_int;
-  }
-  else if (x + 1 >= two_ptr_63_dbl) {
+  } else if (x + 1 >= two_ptr_63_dbl) {
     return max_int;
-  }
-  else if (x < 0) {
+  } else if (x < 0) {
     return neg(of_float(-x));
-  }
-  else {
+  } else {
     var hi = x / two_ptr_32_dbl | 0;
     var lo = x % two_ptr_32_dbl | 0;
     return /* record */[
@@ -4760,49 +4744,38 @@ function div(_self, _other) {
     var exit$1 = 0;
     if (other[/* hi */0] !== 0) {
       exit$1 = 2;
-    }
-    else if (other[/* lo */1] !== 0) {
+    } else if (other[/* lo */1] !== 0) {
       exit$1 = 2;
-    }
-    else {
+    } else {
       throw Caml_builtin_exceptions.division_by_zero;
     }
     if (exit$1 === 2) {
       if (self_hi !== -2147483648) {
         if (self_hi !== 0) {
           exit = 1;
-        }
-        else if (self[/* lo */1] !== 0) {
+        } else if (self[/* lo */1] !== 0) {
           exit = 1;
-        }
-        else {
+        } else {
           return zero;
         }
-      }
-      else if (self[/* lo */1] !== 0) {
+      } else if (self[/* lo */1] !== 0) {
         exit = 1;
-      }
-      else if (eq(other, one) || eq(other, neg_one)) {
+      } else if (eq(other, one) || eq(other, neg_one)) {
         return self;
-      }
-      else if (eq(other, min_int)) {
+      } else if (eq(other, min_int)) {
         return one;
-      }
-      else {
+      } else {
         var other_hi = other[/* hi */0];
         var half_this = asr_(self, 1);
         var approx = lsl_(div(half_this, other), 1);
         var exit$2 = 0;
         if (approx[/* hi */0] !== 0) {
           exit$2 = 3;
-        }
-        else if (approx[/* lo */1] !== 0) {
+        } else if (approx[/* lo */1] !== 0) {
           exit$2 = 3;
-        }
-        else if (other_hi < 0) {
+        } else if (other_hi < 0) {
           return one;
-        }
-        else {
+        } else {
           return neg(one);
         }
         if (exit$2 === 3) {
@@ -4818,11 +4791,9 @@ function div(_self, _other) {
       var exit$3 = 0;
       if (other_hi$1 !== -2147483648) {
         exit$3 = 2;
-      }
-      else if (other[/* lo */1] !== 0) {
+      } else if (other[/* lo */1] !== 0) {
         exit$3 = 2;
-      }
-      else {
+      } else {
         return zero;
       }
       if (exit$3 === 2) {
@@ -4832,15 +4803,12 @@ function div(_self, _other) {
             _self = neg(self);
             continue ;
             
-          }
-          else {
+          } else {
             return neg(div(neg(self), other));
           }
-        }
-        else if (other_hi$1 < 0) {
+        } else if (other_hi$1 < 0) {
           return neg(div(self, neg(other)));
-        }
-        else {
+        } else {
           var res = zero;
           var rem$1 = self;
           while(ge(rem$1, other)) {
@@ -4887,8 +4855,7 @@ function compare(self, other) {
   var v = Caml_obj.caml_nativeint_compare(self[/* hi */0], other[/* hi */0]);
   if (v) {
     return v;
-  }
-  else {
+  } else {
     return Caml_obj.caml_nativeint_compare(self[/* lo */1], other[/* lo */1]);
   }
 }
@@ -4913,11 +4880,9 @@ function to_hex(x) {
   var exit = 0;
   if (match !== 0) {
     exit = 1;
-  }
-  else if (match$1 !== 0) {
+  } else if (match$1 !== 0) {
     exit = 1;
-  }
-  else {
+  } else {
     return "0";
   }
   if (exit === 1) {
@@ -4927,16 +4892,13 @@ function to_hex(x) {
         var pad = 8 - lo.length | 0;
         if (pad <= 0) {
           return aux(x[/* hi */0]) + lo;
-        }
-        else {
+        } else {
           return aux(x[/* hi */0]) + (Caml_utils.repeat(pad, "0") + lo);
         }
-      }
-      else {
+      } else {
         return aux(x[/* lo */1]);
       }
-    }
-    else {
+    } else {
       return aux(x[/* hi */0]) + "00000000";
     }
   }
@@ -4959,13 +4921,12 @@ function float_of_bits(x) {
 }
 
 function bits_of_float(x) {
-  var to_nat = function (x) {
-    return x;
-  };
   var u = new Float64Array(/* float array */[x]);
   var int32 = new Int32Array(u.buffer);
-  var hi = to_nat(int32[1]);
-  var lo = to_nat(int32[0]);
+  var x$1 = int32[1];
+  var hi = x$1;
+  var x$2 = int32[0];
+  var lo = x$2;
   return /* record */[
           /* hi */hi,
           /* lo */(lo >>> 0)
@@ -5028,13 +4989,12 @@ exports.get64         = get64;
 //////// start of camlinternalFormatBasics.js ////////
 'use strict';
 
-var Block = require("./block");
+var Block = require("./block.js");
 
 function erase_rel(param) {
   if (typeof param === "number") {
     return /* End_of_fmtty */0;
-  }
-  else {
+  } else {
     switch (param.tag | 0) {
       case 0 : 
           return /* Char_ty */Block.__(0, [erase_rel(param[0])]);
@@ -5082,8 +5042,7 @@ function erase_rel(param) {
 function concat_fmtty(fmtty1, fmtty2) {
   if (typeof fmtty1 === "number") {
     return fmtty2;
-  }
-  else {
+  } else {
     switch (fmtty1.tag | 0) {
       case 0 : 
           return /* Char_ty */Block.__(0, [concat_fmtty(fmtty1[0], fmtty2)]);
@@ -5130,8 +5089,7 @@ function concat_fmtty(fmtty1, fmtty2) {
 function concat_fmt(fmt1, fmt2) {
   if (typeof fmt1 === "number") {
     return fmt2;
-  }
-  else {
+  } else {
     switch (fmt1.tag | 0) {
       case 0 : 
           return /* Char */Block.__(0, [concat_fmt(fmt1[0], fmt2)]);
@@ -5267,24 +5225,25 @@ exports.concat_fmt   = concat_fmt;
 //////// start of camlinternalFormat.js ////////
 'use strict';
 
-var Sys                      = require("./sys");
-var Char                     = require("./char");
-var Block                    = require("./block");
-var Bytes                    = require("./bytes");
-var Curry                    = require("./curry");
-var Buffer                   = require("./buffer");
-var $$String                 = require("./string");
-var Caml_io                  = require("./caml_io");
-var Caml_obj                 = require("./caml_obj");
-var Caml_bytes               = require("./caml_bytes");
-var Caml_float               = require("./caml_float");
-var Caml_int32               = require("./caml_int32");
-var Pervasives               = require("./pervasives");
-var Caml_format              = require("./caml_format");
-var Caml_string              = require("./caml_string");
-var Caml_exceptions          = require("./caml_exceptions");
-var Caml_builtin_exceptions  = require("./caml_builtin_exceptions");
-var CamlinternalFormatBasics = require("./camlinternalFormatBasics");
+var Sys                      = require("./sys.js");
+var Char                     = require("./char.js");
+var Block                    = require("./block.js");
+var Bytes                    = require("./bytes.js");
+var Curry                    = require("./curry.js");
+var Buffer                   = require("./buffer.js");
+var Js_exn                   = require("./js_exn.js");
+var $$String                 = require("./string.js");
+var Caml_io                  = require("./caml_io.js");
+var Caml_obj                 = require("./caml_obj.js");
+var Caml_bytes               = require("./caml_bytes.js");
+var Caml_float               = require("./caml_float.js");
+var Caml_int32               = require("./caml_int32.js");
+var Pervasives               = require("./pervasives.js");
+var Caml_format              = require("./caml_format.js");
+var Caml_string              = require("./caml_string.js");
+var Caml_exceptions          = require("./caml_exceptions.js");
+var Caml_builtin_exceptions  = require("./caml_builtin_exceptions.js");
+var CamlinternalFormatBasics = require("./camlinternalFormatBasics.js");
 
 function create_char_set() {
   return Bytes.make(32, /* "\000" */0);
@@ -5319,8 +5278,7 @@ function pad_of_pad_opt(pad_opt) {
               /* Right */1,
               pad_opt[0]
             ]);
-  }
-  else {
+  } else {
     return /* No_padding */0;
   }
 }
@@ -5328,8 +5286,7 @@ function pad_of_pad_opt(pad_opt) {
 function prec_of_prec_opt(prec_opt) {
   if (prec_opt) {
     return /* Lit_precision */[prec_opt[0]];
-  }
-  else {
+  } else {
     return /* No_precision */0;
   }
 }
@@ -5349,8 +5306,7 @@ function param_format_of_ignored_format(ign, fmt) {
           return /* Param_format_EBB */[/* Scan_next_char */Block.__(22, [fmt])];
       
     }
-  }
-  else {
+  } else {
     switch (ign.tag | 0) {
       case 0 : 
           return /* Param_format_EBB */[/* String */Block.__(2, [
@@ -5434,8 +5390,7 @@ function buffer_check_size(buf, overhead) {
     Bytes.blit(buf[/* bytes */1], 0, new_str, 0, len);
     buf[/* bytes */1] = new_str;
     return /* () */0;
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -5530,13 +5485,11 @@ function bprint_char_set(buf, char_set) {
     if (c !== 37) {
       if (c !== 64) {
         return buffer_add_char(buf, c);
-      }
-      else {
+      } else {
         buffer_add_char(buf, /* "%" */37);
         return buffer_add_char(buf, /* "@" */64);
       }
-    }
-    else {
+    } else {
       buffer_add_char(buf, /* "%" */37);
       return buffer_add_char(buf, /* "%" */37);
     }
@@ -5553,25 +5506,20 @@ function bprint_char_set(buf, char_set) {
           if (switcher > 48 || switcher < 0) {
             if (switcher >= 210) {
               return print_char(buf, 255);
-            }
-            else {
+            } else {
               return print_second(set$1, i$1 + 1 | 0);
             }
-          }
-          else if (switcher > 47 || switcher < 1) {
+          } else if (switcher > 47 || switcher < 1) {
             return print_out(set$1, i$1 + 1 | 0);
-          }
-          else {
+          } else {
             return print_second(set$1, i$1 + 1 | 0);
           }
-        }
-        else {
+        } else {
           _i = i + 1 | 0;
           continue ;
           
         }
-      }
-      else {
+      } else {
         return 0;
       }
     };
@@ -5585,21 +5533,17 @@ function bprint_char_set(buf, char_set) {
         if (switcher >= 210) {
           print_char(buf, 254);
           return print_char(buf, 255);
-        }
-        else {
+        } else {
           exit = 1;
         }
-      }
-      else if (switcher > 47 || switcher < 1) {
+      } else if (switcher > 47 || switcher < 1) {
         if (is_in_char_set(set, Pervasives.char_of_int(i + 1 | 0))) {
           exit = 1;
-        }
-        else {
+        } else {
           print_char(buf, i - 1 | 0);
           return print_out(set, i + 1 | 0);
         }
-      }
-      else {
+      } else {
         exit = 1;
       }
       if (exit === 1) {
@@ -5615,27 +5559,23 @@ function bprint_char_set(buf, char_set) {
               print_char(buf, j - 1 | 0);
               if (j < 256) {
                 return print_out(set$1, j + 1 | 0);
-              }
-              else {
+              } else {
                 return 0;
               }
-            }
-            else {
+            } else {
               _j = j + 1 | 0;
               continue ;
               
             }
           };
-        }
-        else {
+        } else {
           print_char(buf, i - 1 | 0);
           print_char(buf, i);
           return print_out(set, i + 2 | 0);
         }
       }
       
-    }
-    else {
+    } else {
       print_char(buf, i - 1 | 0);
       return print_out(set, i + 1 | 0);
     }
@@ -5646,8 +5586,7 @@ function bprint_char_set(buf, char_set) {
       var match_001 = Char.chr(c + 1 | 0);
       if (is_in_char_set(set, c)) {
         return 1 - (is_in_char_set(set, match_000) && is_in_char_set(set, match_001));
-      }
-      else {
+      } else {
         return /* false */0;
       }
     };
@@ -5657,8 +5596,7 @@ function bprint_char_set(buf, char_set) {
     print_out(set, 1);
     if (is_alone(/* "-" */45)) {
       return buffer_add_char(buf, /* "-" */45);
-    }
-    else {
+    } else {
       return 0;
     }
   };
@@ -5682,8 +5620,7 @@ function bprint_padty(buf, padty) {
 function bprint_ignored_flag(buf, ign_flag) {
   if (ign_flag) {
     return buffer_add_char(buf, /* "_" */95);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -5691,8 +5628,7 @@ function bprint_ignored_flag(buf, ign_flag) {
 function bprint_pad_opt(buf, pad_opt) {
   if (pad_opt) {
     return buffer_add_string(buf, "" + pad_opt[0]);
-  }
-  else {
+  } else {
     return /* () */0;
   }
 }
@@ -5700,13 +5636,11 @@ function bprint_pad_opt(buf, pad_opt) {
 function bprint_padding(buf, pad) {
   if (typeof pad === "number") {
     return /* () */0;
-  }
-  else {
+  } else {
     bprint_padty(buf, pad[0]);
     if (pad.tag) {
       return buffer_add_char(buf, /* "*" */42);
-    }
-    else {
+    } else {
       return buffer_add_string(buf, "" + pad[1]);
     }
   }
@@ -5716,12 +5650,10 @@ function bprint_precision(buf, prec) {
   if (typeof prec === "number") {
     if (prec !== 0) {
       return buffer_add_string(buf, ".*");
-    }
-    else {
+    } else {
       return /* () */0;
     }
-  }
-  else {
+  } else {
     buffer_add_char(buf, /* "." */46);
     return buffer_add_string(buf, "" + prec[0]);
   }
@@ -5822,8 +5754,7 @@ function string_of_formatting_lit(formatting_lit) {
           return "@%";
       
     }
-  }
-  else {
+  } else {
     switch (formatting_lit.tag | 0) {
       case 0 : 
       case 1 : 
@@ -5842,8 +5773,7 @@ function string_of_formatting_gen(formatting_gen) {
 function bprint_char_literal(buf, chr) {
   if (chr !== 37) {
     return buffer_add_char(buf, chr);
-  }
-  else {
+  } else {
     return buffer_add_string(buf, "%%");
   }
 }
@@ -5860,8 +5790,7 @@ function bprint_fmtty(buf, _fmtty) {
     var fmtty = _fmtty;
     if (typeof fmtty === "number") {
       return /* () */0;
-    }
-    else {
+    } else {
       switch (fmtty.tag | 0) {
         case 0 : 
             buffer_add_string(buf, "%c");
@@ -5936,8 +5865,7 @@ function bprint_fmtty(buf, _fmtty) {
 function int_of_custom_arity(param) {
   if (param) {
     return 1 + int_of_custom_arity(param[0]) | 0;
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -5950,8 +5878,7 @@ function bprint_fmt(buf, fmt) {
     var fmt$1 = _fmt;
     if (typeof fmt$1 === "number") {
       return /* () */0;
-    }
-    else {
+    } else {
       switch (fmt$1.tag | 0) {
         case 0 : 
             buffer_add_char(buf, /* "%" */37);
@@ -6133,8 +6060,7 @@ function string_of_fmt(fmt) {
 function symm(param) {
   if (typeof param === "number") {
     return /* End_of_fmtty */0;
-  }
-  else {
+  } else {
     switch (param.tag | 0) {
       case 0 : 
           return /* Char_ty */Block.__(0, [symm(param[0])]);
@@ -6194,8 +6120,7 @@ function fmtty_rel_det(param) {
               return /* Refl */0;
             }
           ];
-  }
-  else {
+  } else {
     switch (param.tag | 0) {
       case 0 : 
           var match = fmtty_rel_det(param[0]);
@@ -6489,12 +6414,10 @@ function trans(ty1, ty2) {
                 23
               ]
             ];
-      }
-      else {
+      } else {
         return /* End_of_fmtty */0;
       }
-    }
-    else {
+    } else {
       switch (ty2.tag | 0) {
         case 8 : 
             exit = 6;
@@ -6528,14 +6451,12 @@ function trans(ty1, ty2) {
               ];
       }
     }
-  }
-  else {
+  } else {
     switch (ty1.tag | 0) {
       case 0 : 
           if (typeof ty2 === "number") {
             exit = 8;
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 0 : 
                   return /* Char_ty */Block.__(0, [trans(ty1[0], ty2[0])]);
@@ -6567,8 +6488,7 @@ function trans(ty1, ty2) {
       case 1 : 
           if (typeof ty2 === "number") {
             exit = 8;
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 1 : 
                   return /* String_ty */Block.__(1, [trans(ty1[0], ty2[0])]);
@@ -6600,8 +6520,7 @@ function trans(ty1, ty2) {
       case 2 : 
           if (typeof ty2 === "number") {
             exit = 8;
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 2 : 
                   return /* Int_ty */Block.__(2, [trans(ty1[0], ty2[0])]);
@@ -6633,8 +6552,7 @@ function trans(ty1, ty2) {
       case 3 : 
           if (typeof ty2 === "number") {
             exit = 8;
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 3 : 
                   return /* Int32_ty */Block.__(3, [trans(ty1[0], ty2[0])]);
@@ -6666,8 +6584,7 @@ function trans(ty1, ty2) {
       case 4 : 
           if (typeof ty2 === "number") {
             exit = 8;
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 4 : 
                   return /* Nativeint_ty */Block.__(4, [trans(ty1[0], ty2[0])]);
@@ -6699,8 +6616,7 @@ function trans(ty1, ty2) {
       case 5 : 
           if (typeof ty2 === "number") {
             exit = 8;
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 5 : 
                   return /* Int64_ty */Block.__(5, [trans(ty1[0], ty2[0])]);
@@ -6732,8 +6648,7 @@ function trans(ty1, ty2) {
       case 6 : 
           if (typeof ty2 === "number") {
             exit = 8;
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 6 : 
                   return /* Float_ty */Block.__(6, [trans(ty1[0], ty2[0])]);
@@ -6765,8 +6680,7 @@ function trans(ty1, ty2) {
       case 7 : 
           if (typeof ty2 === "number") {
             exit = 8;
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 7 : 
                   return /* Bool_ty */Block.__(7, [trans(ty1[0], ty2[0])]);
@@ -6805,8 +6719,7 @@ function trans(ty1, ty2) {
                     26
                   ]
                 ];
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 8 : 
                   return /* Format_arg_ty */Block.__(8, [
@@ -6850,8 +6763,7 @@ function trans(ty1, ty2) {
                     28
                   ]
                 ];
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 8 : 
                   exit = 6;
@@ -6903,11 +6815,9 @@ function trans(ty1, ty2) {
                     21
                   ]
                 ];
-          }
-          else if (ty2.tag === 10) {
+          } else if (ty2.tag === 10) {
             return /* Alpha_ty */Block.__(10, [trans(ty1[0], ty2[0])]);
-          }
-          else {
+          } else {
             throw [
                   Caml_builtin_exceptions.assert_failure,
                   [
@@ -6928,8 +6838,7 @@ function trans(ty1, ty2) {
                     21
                   ]
                 ];
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 10 : 
                   exit = 1;
@@ -6958,8 +6867,7 @@ function trans(ty1, ty2) {
                     19
                   ]
                 ];
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 10 : 
                   exit = 1;
@@ -6991,8 +6899,7 @@ function trans(ty1, ty2) {
                     22
                   ]
                 ];
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 10 : 
                   exit = 1;
@@ -7027,8 +6934,7 @@ function trans(ty1, ty2) {
                     30
                   ]
                 ];
-          }
-          else {
+          } else {
             switch (ty2.tag | 0) {
               case 10 : 
                   exit = 1;
@@ -7143,14 +7049,19 @@ function fmtty_of_formatting_gen(formatting_gen) {
 function fmtty_of_fmt(_fmtty) {
   while(true) {
     var fmtty = _fmtty;
+    var exit = 0;
     if (typeof fmtty === "number") {
-      return /* End_of_fmtty */0;
-    }
-    else {
+      if (fmtty) {
+        return /* Char_ty */Block.__(0, [fmtty_of_fmt(fmtty[0])]);
+      } else {
+        return /* End_of_fmtty */0;
+      }
+    } else {
       switch (fmtty.tag | 0) {
         case 2 : 
         case 3 : 
-            return fmtty_of_padding_fmtty(fmtty[0], /* String_ty */Block.__(1, [fmtty_of_fmt(fmtty[1])]));
+            exit = 1;
+            break;
         case 4 : 
             var ty_rest = fmtty_of_fmt(fmtty[3]);
             var prec_ty = fmtty_of_precision_fmtty(fmtty[2], /* Int_ty */Block.__(2, [ty_rest]));
@@ -7205,56 +7116,37 @@ function fmtty_of_fmt(_fmtty) {
             return /* String_ty */Block.__(1, [fmtty_of_fmt(fmtty[2])]);
         case 21 : 
             return /* Int_ty */Block.__(2, [fmtty_of_fmt(fmtty[1])]);
-        case 0 : 
-        case 1 : 
-        case 22 : 
-            return /* Char_ty */Block.__(0, [fmtty_of_fmt(fmtty[0])]);
         case 23 : 
             var ign = fmtty[0];
             var fmt = fmtty[1];
             if (typeof ign === "number") {
-              switch (ign) {
-                case 3 : 
-                    return /* Ignored_reader_ty */Block.__(14, [fmtty_of_fmt(fmt)]);
-                case 0 : 
-                case 1 : 
-                case 2 : 
-                case 4 : 
-                    return fmtty_of_fmt(fmt);
-                
-              }
-            }
-            else {
-              switch (ign.tag | 0) {
-                case 8 : 
-                    return CamlinternalFormatBasics.concat_fmtty(ign[1], fmtty_of_fmt(fmt));
-                case 0 : 
-                case 1 : 
-                case 2 : 
-                case 3 : 
-                case 4 : 
-                case 5 : 
-                case 6 : 
-                case 7 : 
-                case 9 : 
-                case 10 : 
-                    return fmtty_of_fmt(fmt);
-                
+              if (ign === 3) {
+                return /* Ignored_reader_ty */Block.__(14, [fmtty_of_fmt(fmt)]);
+              } else {
+                return fmtty_of_fmt(fmt);
               }
+            } else if (ign.tag === 8) {
+              return CamlinternalFormatBasics.concat_fmtty(ign[1], fmtty_of_fmt(fmt));
+            } else {
+              return fmtty_of_fmt(fmt);
             }
         case 24 : 
             return fmtty_of_custom(fmtty[0], fmtty_of_fmt(fmtty[2]));
-        
+        default:
+          return /* Char_ty */Block.__(0, [fmtty_of_fmt(fmtty[0])]);
       }
     }
+    if (exit === 1) {
+      return fmtty_of_padding_fmtty(fmtty[0], /* String_ty */Block.__(1, [fmtty_of_fmt(fmtty[1])]));
+    }
+    
   };
 }
 
 function fmtty_of_custom(arity, fmtty) {
   if (arity) {
     return /* Any_ty */Block.__(12, [fmtty_of_custom(arity[0], fmtty)]);
-  }
-  else {
+  } else {
     return fmtty;
   }
 }
@@ -7262,8 +7154,7 @@ function fmtty_of_custom(arity, fmtty) {
 function fmtty_of_padding_fmtty(pad, fmtty) {
   if (typeof pad === "number" || !pad.tag) {
     return fmtty;
-  }
-  else {
+  } else {
     return /* Int_ty */Block.__(2, [fmtty]);
   }
 }
@@ -7271,8 +7162,7 @@ function fmtty_of_padding_fmtty(pad, fmtty) {
 function fmtty_of_precision_fmtty(prec, fmtty) {
   if (typeof prec === "number" && prec !== 0) {
     return /* Int_ty */Block.__(2, [fmtty]);
-  }
-  else {
+  } else {
     return fmtty;
   }
 }
@@ -7285,22 +7175,18 @@ function type_padding(pad, fmtty) {
             /* No_padding */0,
             fmtty
           ];
-  }
-  else if (pad.tag) {
+  } else if (pad.tag) {
     if (typeof fmtty === "number") {
       throw Type_mismatch;
-    }
-    else if (fmtty.tag === 2) {
+    } else if (fmtty.tag === 2) {
       return /* Padding_fmtty_EBB */[
               /* Arg_padding */Block.__(1, [pad[0]]),
               fmtty[0]
             ];
-    }
-    else {
+    } else {
       throw Type_mismatch;
     }
-  }
-  else {
+  } else {
     return /* Padding_fmtty_EBB */[
             /* Lit_padding */Block.__(0, [
                 pad[0],
@@ -7318,27 +7204,23 @@ function type_padprec(pad, prec, fmtty) {
       var match$1 = match[1];
       if (typeof match$1 === "number") {
         throw Type_mismatch;
-      }
-      else if (match$1.tag === 2) {
+      } else if (match$1.tag === 2) {
         return /* Padprec_fmtty_EBB */[
                 match[0],
                 /* Arg_precision */1,
                 match$1[0]
               ];
-      }
-      else {
+      } else {
         throw Type_mismatch;
       }
-    }
-    else {
+    } else {
       return /* Padprec_fmtty_EBB */[
               match[0],
               /* No_precision */0,
               match[1]
             ];
     }
-  }
-  else {
+  } else {
     return /* Padprec_fmtty_EBB */[
             match[0],
             /* Lit_precision */[prec[0]],
@@ -7364,17 +7246,14 @@ function type_format_gen(fmt, fmtty) {
             /* End_of_format */0,
             fmtty
           ];
-  }
-  else {
+  } else {
     switch (fmt.tag | 0) {
       case 0 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag) {
+          } else if (fmtty.tag) {
             throw Type_mismatch;
-          }
-          else {
+          } else {
             var match = type_format_gen(fmt[0], fmtty[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Char */Block.__(0, [match[0]]),
@@ -7385,11 +7264,9 @@ function type_format_gen(fmt, fmtty) {
       case 1 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag) {
+          } else if (fmtty.tag) {
             throw Type_mismatch;
-          }
-          else {
+          } else {
             var match$1 = type_format_gen(fmt[0], fmtty[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Caml_char */Block.__(1, [match$1[0]]),
@@ -7402,8 +7279,7 @@ function type_format_gen(fmt, fmtty) {
           var match$3 = match$2[1];
           if (typeof match$3 === "number") {
             throw Type_mismatch;
-          }
-          else if (match$3.tag === 1) {
+          } else if (match$3.tag === 1) {
             var match$4 = type_format_gen(fmt[1], match$3[0]);
             return /* Fmt_fmtty_EBB */[
                     /* String */Block.__(2, [
@@ -7412,8 +7288,7 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$4[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
@@ -7422,8 +7297,7 @@ function type_format_gen(fmt, fmtty) {
           var match$6 = match$5[1];
           if (typeof match$6 === "number") {
             throw Type_mismatch;
-          }
-          else if (match$6.tag === 1) {
+          } else if (match$6.tag === 1) {
             var match$7 = type_format_gen(fmt[1], match$6[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Caml_string */Block.__(3, [
@@ -7432,8 +7306,7 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$7[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
@@ -7442,8 +7315,7 @@ function type_format_gen(fmt, fmtty) {
           var match$9 = match$8[2];
           if (typeof match$9 === "number") {
             throw Type_mismatch;
-          }
-          else if (match$9.tag === 2) {
+          } else if (match$9.tag === 2) {
             var match$10 = type_format_gen(fmt[3], match$9[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Int */Block.__(4, [
@@ -7454,8 +7326,7 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$10[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
@@ -7464,8 +7335,7 @@ function type_format_gen(fmt, fmtty) {
           var match$12 = match$11[2];
           if (typeof match$12 === "number") {
             throw Type_mismatch;
-          }
-          else if (match$12.tag === 3) {
+          } else if (match$12.tag === 3) {
             var match$13 = type_format_gen(fmt[3], match$12[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Int32 */Block.__(5, [
@@ -7476,8 +7346,7 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$13[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
@@ -7486,8 +7355,7 @@ function type_format_gen(fmt, fmtty) {
           var match$15 = match$14[2];
           if (typeof match$15 === "number") {
             throw Type_mismatch;
-          }
-          else if (match$15.tag === 4) {
+          } else if (match$15.tag === 4) {
             var match$16 = type_format_gen(fmt[3], match$15[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Nativeint */Block.__(6, [
@@ -7498,8 +7366,7 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$16[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
@@ -7508,8 +7375,7 @@ function type_format_gen(fmt, fmtty) {
           var match$18 = match$17[2];
           if (typeof match$18 === "number") {
             throw Type_mismatch;
-          }
-          else if (match$18.tag === 5) {
+          } else if (match$18.tag === 5) {
             var match$19 = type_format_gen(fmt[3], match$18[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Int64 */Block.__(7, [
@@ -7520,8 +7386,7 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$19[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
@@ -7530,8 +7395,7 @@ function type_format_gen(fmt, fmtty) {
           var match$21 = match$20[2];
           if (typeof match$21 === "number") {
             throw Type_mismatch;
-          }
-          else if (match$21.tag === 6) {
+          } else if (match$21.tag === 6) {
             var match$22 = type_format_gen(fmt[3], match$21[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Float */Block.__(8, [
@@ -7542,23 +7406,20 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$22[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 9 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 7) {
+          } else if (fmtty.tag === 7) {
             var match$23 = type_format_gen(fmt[0], fmtty[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Bool */Block.__(9, [match$23[0]]),
                     match$23[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
@@ -7589,8 +7450,7 @@ function type_format_gen(fmt, fmtty) {
       case 13 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 8) {
+          } else if (fmtty.tag === 8) {
             var sub_fmtty$prime = fmtty[0];
             if (Caml_obj.caml_notequal(/* Fmtty_EBB */[fmt[1]], /* Fmtty_EBB */[sub_fmtty$prime])) {
               throw Type_mismatch;
@@ -7604,16 +7464,14 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$27[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 14 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 9) {
+          } else if (fmtty.tag === 9) {
             var sub_fmtty1 = fmtty[0];
             if (Caml_obj.caml_notequal(/* Fmtty_EBB */[CamlinternalFormatBasics.erase_rel(fmt[1])], /* Fmtty_EBB */[CamlinternalFormatBasics.erase_rel(sub_fmtty1)])) {
               throw Type_mismatch;
@@ -7627,38 +7485,33 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$28[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 15 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 10) {
+          } else if (fmtty.tag === 10) {
             var match$29 = type_format_gen(fmt[0], fmtty[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Alpha */Block.__(15, [match$29[0]]),
                     match$29[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 16 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 11) {
+          } else if (fmtty.tag === 11) {
             var match$30 = type_format_gen(fmt[0], fmtty[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Theta */Block.__(16, [match$30[0]]),
                     match$30[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
@@ -7689,8 +7542,7 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$34[1]
                   ];
-          }
-          else {
+          } else {
             var match$35 = formatting_gen[0];
             var match$36 = type_format_gen(match$35[0], fmtty0);
             var match$37 = type_format_gen(fmt0, match$36[1]);
@@ -7708,23 +7560,20 @@ function type_format_gen(fmt, fmtty) {
       case 19 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 13) {
+          } else if (fmtty.tag === 13) {
             var match$38 = type_format_gen(fmt[0], fmtty[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Reader */Block.__(19, [match$38[0]]),
                     match$38[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 20 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 1) {
+          } else if (fmtty.tag === 1) {
             var match$39 = type_format_gen(fmt[2], fmtty[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Scan_char_set */Block.__(20, [
@@ -7734,16 +7583,14 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$39[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 21 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 2) {
+          } else if (fmtty.tag === 2) {
             var match$40 = type_format_gen(fmt[1], fmtty[0]);
             return /* Fmt_fmtty_EBB */[
                     /* Scan_get_counter */Block.__(21, [
@@ -7752,8 +7599,7 @@ function type_format_gen(fmt, fmtty) {
                       ]),
                     match$40[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
@@ -7762,34 +7608,25 @@ function type_format_gen(fmt, fmtty) {
           var fmt$1 = fmt[1];
           var fmtty$1 = fmtty;
           if (typeof ign === "number") {
-            switch (ign) {
-              case 3 : 
-                  if (typeof fmtty$1 === "number") {
-                    throw Type_mismatch;
-                  }
-                  else if (fmtty$1.tag === 14) {
-                    var match$41 = type_format_gen(fmt$1, fmtty$1[0]);
-                    return /* Fmt_fmtty_EBB */[
-                            /* Ignored_param */Block.__(23, [
-                                /* Ignored_reader */3,
-                                match$41[0]
-                              ]),
-                            match$41[1]
-                          ];
-                  }
-                  else {
-                    throw Type_mismatch;
-                  }
-                  break;
-              case 0 : 
-              case 1 : 
-              case 2 : 
-              case 4 : 
-                  return type_ignored_param_one(ign, fmt$1, fmtty$1);
-              
+            if (ign === 3) {
+              if (typeof fmtty$1 === "number") {
+                throw Type_mismatch;
+              } else if (fmtty$1.tag === 14) {
+                var match$41 = type_format_gen(fmt$1, fmtty$1[0]);
+                return /* Fmt_fmtty_EBB */[
+                        /* Ignored_param */Block.__(23, [
+                            /* Ignored_reader */3,
+                            match$41[0]
+                          ]),
+                        match$41[1]
+                      ];
+              } else {
+                throw Type_mismatch;
+              }
+            } else {
+              return type_ignored_param_one(ign, fmt$1, fmtty$1);
             }
-          }
-          else {
+          } else {
             switch (ign.tag | 0) {
               case 7 : 
                   return type_ignored_param_one(/* Ignored_format_arg */Block.__(7, [
@@ -7809,17 +7646,8 @@ function type_format_gen(fmt, fmtty) {
                             ]),
                           match$43[1]
                         ];
-              case 0 : 
-              case 1 : 
-              case 2 : 
-              case 3 : 
-              case 4 : 
-              case 5 : 
-              case 6 : 
-              case 9 : 
-              case 10 : 
-                  return type_ignored_param_one(ign, fmt$1, fmtty$1);
-              
+              default:
+                return type_ignored_param_one(ign, fmt$1, fmtty$1);
             }
           }
       case 22 : 
@@ -7836,17 +7664,14 @@ function type_ignored_format_substitution(sub_fmtty, fmt, fmtty) {
             /* End_of_fmtty */0,
             type_format_gen(fmt, fmtty)
           ];
-  }
-  else {
+  } else {
     switch (sub_fmtty.tag | 0) {
       case 0 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag) {
+          } else if (fmtty.tag) {
             throw Type_mismatch;
-          }
-          else {
+          } else {
             var match = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* Char_ty */Block.__(0, [match[0]]),
@@ -7857,113 +7682,98 @@ function type_ignored_format_substitution(sub_fmtty, fmt, fmtty) {
       case 1 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 1) {
+          } else if (fmtty.tag === 1) {
             var match$1 = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* String_ty */Block.__(1, [match$1[0]]),
                     match$1[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 2 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 2) {
+          } else if (fmtty.tag === 2) {
             var match$2 = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* Int_ty */Block.__(2, [match$2[0]]),
                     match$2[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 3 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 3) {
+          } else if (fmtty.tag === 3) {
             var match$3 = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* Int32_ty */Block.__(3, [match$3[0]]),
                     match$3[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 4 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 4) {
+          } else if (fmtty.tag === 4) {
             var match$4 = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* Nativeint_ty */Block.__(4, [match$4[0]]),
                     match$4[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 5 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 5) {
+          } else if (fmtty.tag === 5) {
             var match$5 = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* Int64_ty */Block.__(5, [match$5[0]]),
                     match$5[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 6 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 6) {
+          } else if (fmtty.tag === 6) {
             var match$6 = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* Float_ty */Block.__(6, [match$6[0]]),
                     match$6[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 7 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 7) {
+          } else if (fmtty.tag === 7) {
             var match$7 = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* Bool_ty */Block.__(7, [match$7[0]]),
                     match$7[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 8 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 8) {
+          } else if (fmtty.tag === 8) {
             var sub2_fmtty$prime = fmtty[0];
             if (Caml_obj.caml_notequal(/* Fmtty_EBB */[sub_fmtty[0]], /* Fmtty_EBB */[sub2_fmtty$prime])) {
               throw Type_mismatch;
@@ -7976,16 +7786,14 @@ function type_ignored_format_substitution(sub_fmtty, fmt, fmtty) {
                       ]),
                     match$8[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 9 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 9) {
+          } else if (fmtty.tag === 9) {
             var sub2_fmtty$prime$1 = fmtty[1];
             var sub1_fmtty$prime = fmtty[0];
             if (Caml_obj.caml_notequal(/* Fmtty_EBB */[CamlinternalFormatBasics.erase_rel(sub_fmtty[0])], /* Fmtty_EBB */[CamlinternalFormatBasics.erase_rel(sub1_fmtty$prime)])) {
@@ -8007,38 +7815,33 @@ function type_ignored_format_substitution(sub_fmtty, fmt, fmtty) {
                       ]),
                     match$10[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 10 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 10) {
+          } else if (fmtty.tag === 10) {
             var match$11 = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* Alpha_ty */Block.__(10, [match$11[0]]),
                     match$11[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 11 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 11) {
+          } else if (fmtty.tag === 11) {
             var match$12 = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* Theta_ty */Block.__(11, [match$12[0]]),
                     match$12[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
@@ -8047,30 +7850,26 @@ function type_ignored_format_substitution(sub_fmtty, fmt, fmtty) {
       case 13 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 13) {
+          } else if (fmtty.tag === 13) {
             var match$13 = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* Reader_ty */Block.__(13, [match$13[0]]),
                     match$13[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
       case 14 : 
           if (typeof fmtty === "number") {
             throw Type_mismatch;
-          }
-          else if (fmtty.tag === 14) {
+          } else if (fmtty.tag === 14) {
             var match$14 = type_ignored_format_substitution(sub_fmtty[0], fmt, fmtty[0]);
             return /* Fmtty_fmt_EBB */[
                     /* Ignored_reader_ty */Block.__(14, [match$14[0]]),
                     match$14[1]
                   ];
-          }
-          else {
+          } else {
             throw Type_mismatch;
           }
           break;
@@ -8083,8 +7882,7 @@ function type_format(fmt, fmtty) {
   var match = type_format_gen(fmt, fmtty);
   if (typeof match[1] === "number") {
     return match[0];
-  }
-  else {
+  } else {
     throw Type_mismatch;
   }
 }
@@ -8097,12 +7895,11 @@ function fix_padding(padty, width, str) {
   var len = str.length;
   var match_000 = Pervasives.abs(width);
   var match_001 = width < 0 ? /* Left */0 : padty;
-  var padty$1 = match_001;
   var width$1 = match_000;
   if (width$1 <= len) {
     return str;
-  }
-  else {
+  } else {
+    var padty$1 = match_001;
     var res = Bytes.make(width$1, padty$1 === /* Zeros */2 ? /* "0" */48 : /* " " */32);
     switch (padty$1) {
       case 0 : 
@@ -8115,12 +7912,10 @@ function fix_padding(padty, width, str) {
           if (len > 0 && (Caml_string.get(str, 0) === /* "+" */43 || Caml_string.get(str, 0) === /* "-" */45 || Caml_string.get(str, 0) === /* " " */32)) {
             res[0] = Caml_string.get(str, 0);
             $$String.blit(str, 1, res, (width$1 - len | 0) + 1 | 0, len - 1 | 0);
-          }
-          else if (len > 1 && Caml_string.get(str, 0) === /* "0" */48 && (Caml_string.get(str, 1) === /* "x" */120 || Caml_string.get(str, 1) === /* "X" */88)) {
+          } else if (len > 1 && Caml_string.get(str, 0) === /* "0" */48 && (Caml_string.get(str, 1) === /* "x" */120 || Caml_string.get(str, 1) === /* "X" */88)) {
             res[1] = Caml_string.get(str, 1);
             $$String.blit(str, 2, res, (width$1 - len | 0) + 2 | 0, len - 2 | 0);
-          }
-          else {
+          } else {
             $$String.blit(str, 0, res, width$1 - len | 0, len);
           }
           break;
@@ -8139,19 +7934,15 @@ function fix_int_precision(prec, str) {
     if (c >= 71) {
       if (c > 102 || c < 97) {
         return str;
-      }
-      else {
+      } else {
         exit = 2;
       }
-    }
-    else if (c >= 65) {
+    } else if (c >= 65) {
       exit = 2;
-    }
-    else {
+    } else {
       return str;
     }
-  }
-  else if (c !== 32) {
+  } else if (c !== 32) {
     if (c >= 43) {
       switch (c - 43 | 0) {
         case 0 : 
@@ -8168,8 +7959,7 @@ function fix_int_precision(prec, str) {
               res[1] = Caml_string.get(str, 1);
               $$String.blit(str, 2, res, (prec$1 - len | 0) + 4 | 0, len - 2 | 0);
               return Caml_string.bytes_to_string(res);
-            }
-            else {
+            } else {
               exit = 2;
             }
             break;
@@ -8186,12 +7976,10 @@ function fix_int_precision(prec, str) {
             break;
         
       }
-    }
-    else {
+    } else {
       return str;
     }
-  }
-  else {
+  } else {
     exit = 1;
   }
   switch (exit) {
@@ -8201,8 +7989,7 @@ function fix_int_precision(prec, str) {
           res$1[0] = c;
           $$String.blit(str, 1, res$1, (prec$1 - len | 0) + 2 | 0, len - 1 | 0);
           return Caml_string.bytes_to_string(res$1);
-        }
-        else {
+        } else {
           return str;
         }
         break;
@@ -8211,8 +7998,7 @@ function fix_int_precision(prec, str) {
           var res$2 = Bytes.make(prec$1, /* "0" */48);
           $$String.blit(str, 0, res$2, prec$1 - len | 0, len);
           return Caml_string.bytes_to_string(res$2);
-        }
-        else {
+        } else {
           return str;
         }
         break;
@@ -8222,9 +8008,9 @@ function fix_int_precision(prec, str) {
 
 function string_to_caml_string(str) {
   return $$String.concat($$String.escaped(str), /* :: */[
-              '"',
+              "\"",
               /* :: */[
-                '"',
+                "\"",
                 /* [] */0
               ]
             ]);
@@ -8390,8 +8176,7 @@ function format_of_aconv(iconv, c) {
 function format_of_fconv(fconv, prec) {
   if (fconv === /* Float_F */15) {
     return "%.12g";
-  }
-  else {
+  } else {
     var prec$1 = Pervasives.abs(prec);
     var symb = char_of_fconv(fconv);
     var buf = /* record */[
@@ -8428,16 +8213,14 @@ function convert_float(fconv, prec, x) {
   var str = Caml_format.caml_format_float(format_of_fconv(fconv, prec$1), x);
   if (fconv !== /* Float_F */15) {
     return str;
-  }
-  else {
+  } else {
     var len = str.length;
     var is_valid = function (_i) {
       while(true) {
         var i = _i;
         if (i === len) {
           return /* false */0;
-        }
-        else {
+        } else {
           var match = Caml_string.get(str, i);
           var switcher = match - 46 | 0;
           if (switcher > 23 || switcher < 0) {
@@ -8445,15 +8228,12 @@ function convert_float(fconv, prec, x) {
               _i = i + 1 | 0;
               continue ;
               
-            }
-            else {
+            } else {
               return /* true */1;
             }
-          }
-          else if (switcher > 22 || switcher < 1) {
+          } else if (switcher > 22 || switcher < 1) {
             return /* true */1;
-          }
-          else {
+          } else {
             _i = i + 1 | 0;
             continue ;
             
@@ -8465,18 +8245,14 @@ function convert_float(fconv, prec, x) {
     if (match !== 3) {
       if (match >= 4) {
         return "nan";
-      }
-      else if (is_valid(0)) {
+      } else if (is_valid(0)) {
         return str;
-      }
-      else {
+      } else {
         return str + ".";
       }
-    }
-    else if (x < 0.0) {
+    } else if (x < 0.0) {
       return "neg_infinity";
-    }
-    else {
+    } else {
       return "infinity";
     }
   }
@@ -8508,8 +8284,7 @@ function make_printf(_k, o, _acc, _fmt) {
     var k = _k;
     if (typeof fmt === "number") {
       return Curry._2(k, o, acc);
-    }
-    else {
+    } else {
       switch (fmt.tag | 0) {
         case 0 : 
             var rest = fmt[0];
@@ -8568,8 +8343,7 @@ function make_printf(_k, o, _acc, _fmt) {
                                 ]), fmt$1);
                   }
                   }(k$1,o$1,acc$1,fmt$1,fconv));
-                }
-                else {
+                } else {
                   return (function(k$1,o$1,acc$1,fmt$1,fconv){
                   return function (x) {
                     var str = convert_float(fconv, 6, x);
@@ -8580,8 +8354,7 @@ function make_printf(_k, o, _acc, _fmt) {
                   }
                   }(k$1,o$1,acc$1,fmt$1,fconv));
                 }
-              }
-              else {
+              } else {
                 var p = prec[0];
                 return (function(k$1,o$1,acc$1,fmt$1,fconv,p){
                 return function (x) {
@@ -8593,8 +8366,7 @@ function make_printf(_k, o, _acc, _fmt) {
                 }
                 }(k$1,o$1,acc$1,fmt$1,fconv,p));
               }
-            }
-            else if (pad.tag) {
+            } else if (pad.tag) {
               var padty = pad[0];
               if (typeof prec === "number") {
                 if (prec !== 0) {
@@ -8607,8 +8379,7 @@ function make_printf(_k, o, _acc, _fmt) {
                                 ]), fmt$1);
                   }
                   }(k$1,o$1,acc$1,fmt$1,fconv,padty));
-                }
-                else {
+                } else {
                   return (function(k$1,o$1,acc$1,fmt$1,fconv,padty){
                   return function (w, x) {
                     var str = convert_float(fconv, 6, x);
@@ -8620,8 +8391,7 @@ function make_printf(_k, o, _acc, _fmt) {
                   }
                   }(k$1,o$1,acc$1,fmt$1,fconv,padty));
                 }
-              }
-              else {
+              } else {
                 var p$1 = prec[0];
                 return (function(k$1,o$1,acc$1,fmt$1,fconv,padty,p$1){
                 return function (w, x) {
@@ -8633,8 +8403,7 @@ function make_printf(_k, o, _acc, _fmt) {
                 }
                 }(k$1,o$1,acc$1,fmt$1,fconv,padty,p$1));
               }
-            }
-            else {
+            } else {
               var w = pad[1];
               var padty$1 = pad[0];
               if (typeof prec === "number") {
@@ -8648,8 +8417,7 @@ function make_printf(_k, o, _acc, _fmt) {
                                 ]), fmt$1);
                   }
                   }(k$1,o$1,acc$1,fmt$1,fconv,padty$1,w));
-                }
-                else {
+                } else {
                   return (function(k$1,o$1,acc$1,fmt$1,fconv,padty$1,w){
                   return function (x) {
                     var str = convert_float(fconv, 6, x);
@@ -8661,8 +8429,7 @@ function make_printf(_k, o, _acc, _fmt) {
                   }
                   }(k$1,o$1,acc$1,fmt$1,fconv,padty$1,w));
                 }
-              }
-              else {
+              } else {
                 var p$2 = prec[0];
                 return (function(k$1,o$1,acc$1,fmt$1,fconv,padty$1,w,p$2){
                 return function (x) {
@@ -8768,8 +8535,7 @@ function make_printf(_k, o, _acc, _fmt) {
               _k = k$prime;
               continue ;
               
-            }
-            else {
+            } else {
               var rest$8 = fmt[1];
               var k$prime$1 = (function(k,acc,rest$8){
               return function k$prime$1(koc, kacc) {
@@ -8836,41 +8602,22 @@ function make_printf(_k, o, _acc, _fmt) {
             var ign = fmt[0];
             var fmt$2 = fmt[1];
             if (typeof ign === "number") {
-              switch (ign) {
-                case 3 : 
-                    throw [
-                          Caml_builtin_exceptions.assert_failure,
-                          [
-                            "camlinternalFormat.ml",
-                            1517,
-                            39
-                          ]
-                        ];
-                case 0 : 
-                case 1 : 
-                case 2 : 
-                case 4 : 
-                    return make_invalid_arg(k$2, o$2, acc$2, fmt$2);
-                
-              }
-            }
-            else {
-              switch (ign.tag | 0) {
-                case 8 : 
-                    return make_from_fmtty(k$2, o$2, acc$2, ign[1], fmt$2);
-                case 0 : 
-                case 1 : 
-                case 2 : 
-                case 3 : 
-                case 4 : 
-                case 5 : 
-                case 6 : 
-                case 7 : 
-                case 9 : 
-                case 10 : 
-                    return make_invalid_arg(k$2, o$2, acc$2, fmt$2);
-                
+              if (ign === 3) {
+                throw [
+                      Caml_builtin_exceptions.assert_failure,
+                      [
+                        "camlinternalFormat.ml",
+                        1517,
+                        39
+                      ]
+                    ];
+              } else {
+                return make_invalid_arg(k$2, o$2, acc$2, fmt$2);
               }
+            } else if (ign.tag === 8) {
+              return make_from_fmtty(k$2, o$2, acc$2, ign[1], fmt$2);
+            } else {
+              return make_invalid_arg(k$2, o$2, acc$2, fmt$2);
             }
         case 24 : 
             return make_custom(k, o, acc, fmt[2], fmt[0], Curry._1(fmt[1], /* () */0));
@@ -8883,8 +8630,7 @@ function make_printf(_k, o, _acc, _fmt) {
 function make_from_fmtty(k, o, acc, fmtty, fmt) {
   if (typeof fmtty === "number") {
     return make_invalid_arg(k, o, acc, fmt);
-  }
-  else {
+  } else {
     switch (fmtty.tag | 0) {
       case 0 : 
           var rest = fmtty[0];
@@ -8992,8 +8738,7 @@ function make_string_padding(k, o, acc, fmt, pad, trans) {
         ]);
       return make_printf(k, o, new_acc, fmt);
     };
-  }
-  else if (pad.tag) {
+  } else if (pad.tag) {
     var padty = pad[0];
     return function (w, x) {
       var new_acc_001 = fix_padding(padty, w, Curry._1(trans, x));
@@ -9003,8 +8748,7 @@ function make_string_padding(k, o, acc, fmt, pad, trans) {
         ]);
       return make_printf(k, o, new_acc, fmt);
     };
-  }
-  else {
+  } else {
     var width = pad[1];
     var padty$1 = pad[0];
     return function (x) {
@@ -9029,8 +8773,7 @@ function make_int_padding_precision(k, o, acc, fmt, pad, prec, trans, iconv) {
                         str
                       ]), fmt);
         };
-      }
-      else {
+      } else {
         return function (x) {
           var str = Curry._2(trans, iconv, x);
           return make_printf(k, o, /* Acc_data_string */Block.__(4, [
@@ -9039,8 +8782,7 @@ function make_int_padding_precision(k, o, acc, fmt, pad, prec, trans, iconv) {
                       ]), fmt);
         };
       }
-    }
-    else {
+    } else {
       var p = prec[0];
       return function (x) {
         var str = fix_int_precision(p, Curry._2(trans, iconv, x));
@@ -9050,8 +8792,7 @@ function make_int_padding_precision(k, o, acc, fmt, pad, prec, trans, iconv) {
                     ]), fmt);
       };
     }
-  }
-  else if (pad.tag) {
+  } else if (pad.tag) {
     var padty = pad[0];
     if (typeof prec === "number") {
       if (prec !== 0) {
@@ -9062,8 +8803,7 @@ function make_int_padding_precision(k, o, acc, fmt, pad, prec, trans, iconv) {
                         str
                       ]), fmt);
         };
-      }
-      else {
+      } else {
         return function (w, x) {
           var str = fix_padding(padty, w, Curry._2(trans, iconv, x));
           return make_printf(k, o, /* Acc_data_string */Block.__(4, [
@@ -9072,8 +8812,7 @@ function make_int_padding_precision(k, o, acc, fmt, pad, prec, trans, iconv) {
                       ]), fmt);
         };
       }
-    }
-    else {
+    } else {
       var p$1 = prec[0];
       return function (w, x) {
         var str = fix_padding(padty, w, fix_int_precision(p$1, Curry._2(trans, iconv, x)));
@@ -9083,8 +8822,7 @@ function make_int_padding_precision(k, o, acc, fmt, pad, prec, trans, iconv) {
                     ]), fmt);
       };
     }
-  }
-  else {
+  } else {
     var w = pad[1];
     var padty$1 = pad[0];
     if (typeof prec === "number") {
@@ -9096,8 +8834,7 @@ function make_int_padding_precision(k, o, acc, fmt, pad, prec, trans, iconv) {
                         str
                       ]), fmt);
         };
-      }
-      else {
+      } else {
         return function (x) {
           var str = fix_padding(padty$1, w, Curry._2(trans, iconv, x));
           return make_printf(k, o, /* Acc_data_string */Block.__(4, [
@@ -9106,8 +8843,7 @@ function make_int_padding_precision(k, o, acc, fmt, pad, prec, trans, iconv) {
                       ]), fmt);
         };
       }
-    }
-    else {
+    } else {
       var p$2 = prec[0];
       return function (x) {
         var str = fix_padding(padty$1, w, fix_int_precision(p$2, Curry._2(trans, iconv, x)));
@@ -9126,8 +8862,7 @@ function make_custom(k, o, acc, rest, arity, f) {
     return function (x) {
       return make_custom(k, o, acc, rest, arity$1, Curry._1(f, x));
     };
-  }
-  else {
+  } else {
     return make_printf(k, o, /* Acc_data_string */Block.__(4, [
                   acc,
                   f
@@ -9141,8 +8876,7 @@ function output_acc(o, _acc) {
     var exit = 0;
     if (typeof acc === "number") {
       return /* () */0;
-    }
-    else {
+    } else {
       switch (acc.tag | 0) {
         case 0 : 
             var s = string_of_formatting_lit(acc[1]);
@@ -9157,8 +8891,7 @@ function output_acc(o, _acc) {
               _acc = match[0];
               continue ;
               
-            }
-            else {
+            } else {
               Pervasives.output_string(o, "@{");
               _acc = match[0];
               continue ;
@@ -9206,8 +8939,7 @@ function bufput_acc(b, _acc) {
     var exit = 0;
     if (typeof acc === "number") {
       return /* () */0;
-    }
-    else {
+    } else {
       switch (acc.tag | 0) {
         case 0 : 
             var s = string_of_formatting_lit(acc[1]);
@@ -9222,8 +8954,7 @@ function bufput_acc(b, _acc) {
               _acc = match[0];
               continue ;
               
-            }
-            else {
+            } else {
               Buffer.add_string(b, "@{");
               _acc = match[0];
               continue ;
@@ -9271,8 +9002,7 @@ function strput_acc(b, _acc) {
     var exit = 0;
     if (typeof acc === "number") {
       return /* () */0;
-    }
-    else {
+    } else {
       switch (acc.tag | 0) {
         case 0 : 
             var s = string_of_formatting_lit(acc[1]);
@@ -9287,8 +9017,7 @@ function strput_acc(b, _acc) {
               _acc = match[0];
               continue ;
               
-            }
-            else {
+            } else {
               Buffer.add_string(b, "@{");
               _acc = match[0];
               continue ;
@@ -9349,8 +9078,7 @@ function open_box_of_string(str) {
             0,
             /* Pp_box */4
           ];
-  }
-  else {
+  } else {
     var len = str.length;
     var invalid_box = function () {
       return Curry._1(failwith_message(/* Format */[
@@ -9369,20 +9097,17 @@ function open_box_of_string(str) {
         var i = _i;
         if (i === len) {
           return i;
-        }
-        else {
+        } else {
           var match = Caml_string.get(str, i);
           if (match !== 9) {
             if (match !== 32) {
               return i;
-            }
-            else {
+            } else {
               _i = i + 1 | 0;
               continue ;
               
             }
-          }
-          else {
+          } else {
             _i = i + 1 | 0;
             continue ;
             
@@ -9395,13 +9120,11 @@ function open_box_of_string(str) {
         var j = _j;
         if (j === len) {
           return j;
-        }
-        else {
+        } else {
           var match = Caml_string.get(str, j);
           if (match > 122 || match < 97) {
             return j;
-          }
-          else {
+          } else {
             _j = j + 1 | 0;
             continue ;
             
@@ -9414,23 +9137,19 @@ function open_box_of_string(str) {
         var j = _j;
         if (j === len) {
           return j;
-        }
-        else {
+        } else {
           var match = Caml_string.get(str, j);
           if (match >= 48) {
             if (match >= 58) {
               return j;
-            }
-            else {
+            } else {
               _j = j + 1 | 0;
               continue ;
               
             }
-          }
-          else if (match !== 45) {
+          } else if (match !== 45) {
             return j;
-          }
-          else {
+          } else {
             _j = j + 1 | 0;
             continue ;
             
@@ -9446,16 +9165,15 @@ function open_box_of_string(str) {
     var indent;
     if (nstart === nend) {
       indent = 0;
-    }
-    else {
+    } else {
       try {
         indent = Caml_format.caml_int_of_string($$String.sub(str, nstart, nend - nstart | 0));
       }
-      catch (exn){
+      catch (raw_exn){
+        var exn = Js_exn.internalToOCamlException(raw_exn);
         if (exn[0] === Caml_builtin_exceptions.failure) {
           indent = invalid_box(/* () */0);
-        }
-        else {
+        } else {
           throw exn;
         }
       }
@@ -9498,14 +9216,12 @@ function make_padding_fmt_ebb(pad, fmt) {
             /* No_padding */0,
             fmt
           ];
-  }
-  else if (pad.tag) {
+  } else if (pad.tag) {
     return /* Padding_fmt_EBB */[
             /* Arg_padding */Block.__(1, [pad[0]]),
             fmt
           ];
-  }
-  else {
+  } else {
     return /* Padding_fmt_EBB */[
             /* Lit_padding */Block.__(0, [
                 pad[0],
@@ -9523,15 +9239,13 @@ function make_precision_fmt_ebb(prec, fmt) {
               /* Arg_precision */1,
               fmt
             ];
-    }
-    else {
+    } else {
       return /* Precision_fmt_EBB */[
               /* No_precision */0,
               fmt
             ];
     }
-  }
-  else {
+  } else {
     return /* Precision_fmt_EBB */[
             /* Lit_precision */[prec[0]],
             fmt
@@ -9549,15 +9263,13 @@ function make_padprec_fmt_ebb(pad, prec, fmt) {
             prec$1,
             fmt$prime
           ];
-  }
-  else if (pad.tag) {
+  } else if (pad.tag) {
     return /* Padprec_fmt_EBB */[
             /* Arg_padding */Block.__(1, [pad[0]]),
             prec$1,
             fmt$prime
           ];
-  }
-  else {
+  } else {
     return /* Padprec_fmt_EBB */[
             /* Lit_padding */Block.__(0, [
                 pad[0],
@@ -9665,62 +9377,48 @@ function fmt_ebb_of_string(legacy_behavior, str) {
       if (plus !== 0) {
         if (sharp !== 0) {
           exit$1 = 2;
-        }
-        else if (space !== 0) {
+        } else if (space !== 0) {
           exit = 1;
-        }
-        else if (symb !== 100) {
+        } else if (symb !== 100) {
           if (symb !== 105) {
             exit = 1;
-          }
-          else {
+          } else {
             return /* Int_pi */4;
           }
-        }
-        else {
+        } else {
           return /* Int_pd */1;
         }
-      }
-      else if (sharp !== 0) {
+      } else if (sharp !== 0) {
         if (space !== 0) {
           exit$1 = 2;
-        }
-        else if (symb !== 88) {
+        } else if (symb !== 88) {
           if (symb !== 111) {
             if (symb !== 120) {
               exit$1 = 2;
-            }
-            else {
+            } else {
               return /* Int_Cx */7;
             }
-          }
-          else {
+          } else {
             return /* Int_Co */11;
           }
-        }
-        else {
+        } else {
           return /* Int_CX */9;
         }
-      }
-      else if (space !== 0) {
+      } else if (space !== 0) {
         if (symb !== 100) {
           if (symb !== 105) {
             exit = 1;
-          }
-          else {
+          } else {
             return /* Int_si */5;
           }
-        }
-        else {
+        } else {
           return /* Int_sd */2;
         }
-      }
-      else {
+      } else {
         var switcher = symb - 88 | 0;
         if (switcher > 32 || switcher < 0) {
           exit = 1;
-        }
-        else {
+        } else {
           switch (switcher) {
             case 0 : 
                 return /* Int_X */8;
@@ -9772,22 +9470,19 @@ function fmt_ebb_of_string(legacy_behavior, str) {
         var switcher$1 = symb - 88 | 0;
         if (switcher$1 > 32 || switcher$1 < 0) {
           exit = 1;
-        }
-        else {
+        } else {
           switch (switcher$1) {
             case 0 : 
                 if (legacy_behavior$1) {
                   return /* Int_CX */9;
-                }
-                else {
+                } else {
                   exit = 1;
                 }
                 break;
             case 23 : 
                 if (legacy_behavior$1) {
                   return /* Int_Co */11;
-                }
-                else {
+                } else {
                   exit = 1;
                 }
                 break;
@@ -9828,8 +9523,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
             case 32 : 
                 if (legacy_behavior$1) {
                   return /* Int_Cx */7;
-                }
-                else {
+                } else {
                   exit = 1;
                 }
                 break;
@@ -9841,8 +9535,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
             _sharp = /* false */0;
             continue ;
             
-          }
-          else {
+          } else {
             return incompatible_flag(pct_ind, str_ind, symb, "'#'");
           }
         }
@@ -9855,31 +9548,25 @@ function fmt_ebb_of_string(legacy_behavior, str) {
               _space = /* false */0;
               continue ;
               
-            }
-            else {
+            } else {
               return incompatible_flag(pct_ind, str_ind, /* " " */32, "'+'");
             }
-          }
-          else if (legacy_behavior$1) {
+          } else if (legacy_behavior$1) {
             _plus = /* false */0;
             continue ;
             
-          }
-          else {
+          } else {
             return incompatible_flag(pct_ind, str_ind, symb, "'+'");
           }
-        }
-        else if (space !== 0) {
+        } else if (space !== 0) {
           if (legacy_behavior$1) {
             _space = /* false */0;
             continue ;
             
-          }
-          else {
+          } else {
             return incompatible_flag(pct_ind, str_ind, symb, "' '");
           }
-        }
-        else {
+        } else {
           throw [
                 Caml_builtin_exceptions.assert_failure,
                 [
@@ -9942,8 +9629,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                 str_ind,
                 acc
               ];
-      }
-      else {
+      } else {
         var new_acc = Caml_int32.imul(acc, 10) + (c - /* "0" */48 | 0) | 0;
         if (new_acc > Sys.max_string_length) {
           return Curry._3(failwith_message(/* Format */[
@@ -9972,8 +9658,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                             ]),
                           "invalid format %S: integer %d is greater than the limit %d"
                         ]), str, new_acc, Sys.max_string_length);
-        }
-        else {
+        } else {
           _acc = new_acc;
           _str_ind = str_ind + 1 | 0;
           continue ;
@@ -9994,30 +9679,25 @@ function fmt_ebb_of_string(legacy_behavior, str) {
       if (typeof prec === "number") {
         if (prec !== 0) {
           exit = 1;
-        }
-        else {
+        } else {
           return parse_conv(/* No_padding */0);
         }
-      }
-      else {
+      } else {
         exit = 1;
       }
       if (exit === 1) {
         if (minus !== 0) {
           if (typeof prec === "number") {
             return parse_conv(/* Arg_padding */Block.__(1, [/* Left */0]));
-          }
-          else {
+          } else {
             return parse_conv(/* Lit_padding */Block.__(0, [
                           /* Left */0,
                           prec[0]
                         ]));
           }
-        }
-        else if (typeof prec === "number") {
+        } else if (typeof prec === "number") {
           return parse_conv(/* Arg_padding */Block.__(1, [/* Right */1]));
-        }
-        else {
+        } else {
           return parse_conv(/* Lit_padding */Block.__(0, [
                         /* Right */1,
                         prec[0]
@@ -10025,8 +9705,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
         }
       }
       
-    }
-    else {
+    } else {
       return parse_conv(pad);
     }
   };
@@ -10037,8 +9716,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
     var symb = Caml_string.get(str, str_ind);
     if (symb !== 46) {
       return parse_conversion(pct_ind, str_ind + 1 | 0, end_ind, plus, sharp, space, ign, pad, /* No_precision */0, pad, symb);
-    }
-    else {
+    } else {
       var pct_ind$1 = pct_ind;
       var str_ind$1 = str_ind + 1 | 0;
       var end_ind$1 = end_ind;
@@ -10061,12 +9739,10 @@ function fmt_ebb_of_string(legacy_behavior, str) {
       if (symb$1 >= 48) {
         if (symb$1 >= 58) {
           exit = 1;
-        }
-        else {
+        } else {
           return parse_literal(minus$1, str_ind$1);
         }
-      }
-      else if (symb$1 >= 42) {
+      } else if (symb$1 >= 42) {
         switch (symb$1 - 42 | 0) {
           case 0 : 
               return parse_after_precision(pct_ind$1, str_ind$1 + 1 | 0, end_ind$1, minus$1, plus$1, sharp$1, space$1, ign$1, pad$1, /* Arg_precision */1);
@@ -10081,23 +9757,20 @@ function fmt_ebb_of_string(legacy_behavior, str) {
               break;
           
         }
-      }
-      else {
+      } else {
         exit = 1;
       }
       if (exit$1 === 2) {
         if (legacy_behavior$1) {
           return parse_literal(minus$1 || +(symb$1 === /* "-" */45), str_ind$1 + 1 | 0);
-        }
-        else {
+        } else {
           exit = 1;
         }
       }
       if (exit === 1) {
         if (legacy_behavior$1) {
           return parse_after_precision(pct_ind$1, str_ind$1, end_ind$1, minus$1, plus$1, sharp$1, space$1, ign$1, pad$1, /* Lit_precision */[0]);
-        }
-        else {
+        } else {
           return invalid_format_without(str_ind$1 - 1 | 0, /* "." */46, "precision");
         }
       }
@@ -10109,21 +9782,18 @@ function fmt_ebb_of_string(legacy_behavior, str) {
       var str_ind = _str_ind;
       if (str_ind === end_ind) {
         return add_literal(lit_start, str_ind, /* End_of_format */0);
-      }
-      else {
+      } else {
         var match = Caml_string.get(str, str_ind);
         if (match !== 37) {
           if (match !== 64) {
             _str_ind = str_ind + 1 | 0;
             continue ;
             
-          }
-          else {
+          } else {
             var match$1 = parse_after_at(str_ind + 1 | 0, end_ind);
             return add_literal(lit_start, str_ind, match$1[0]);
           }
-        }
-        else {
+        } else {
           var match$2 = parse_format(str_ind, end_ind);
           return add_literal(lit_start, str_ind, match$2[0]);
         }
@@ -10140,8 +9810,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
     var match = Caml_string.get(str, str_ind);
     if (match !== 95) {
       return parse_flags(pct_ind$1, str_ind, end_ind$1, /* false */0);
-    }
-    else {
+    } else {
       return parse_flags(pct_ind$1, str_ind + 1 | 0, end_ind$1, /* true */1);
     }
   };
@@ -10151,8 +9820,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                   /* "@" */64,
                   /* End_of_format */0
                 ])];
-    }
-    else {
+    } else {
       var c = Caml_string.get(str, str_ind);
       var exit = 0;
       if (c >= 65) {
@@ -10160,8 +9828,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
           var switcher = c - 123 | 0;
           if (switcher > 2 || switcher < 0) {
             exit = 1;
-          }
-          else {
+          } else {
             switch (switcher) {
               case 0 : 
                   return parse_tag(/* true */1, str_ind + 1 | 0, end_ind);
@@ -10178,8 +9845,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
               
             }
           }
-        }
-        else if (c >= 91) {
+        } else if (c >= 91) {
           switch (c - 91 | 0) {
             case 0 : 
                 return parse_tag(/* false */0, str_ind + 1 | 0, end_ind);
@@ -10195,12 +9861,10 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                           ])];
             
           }
-        }
-        else {
+        } else {
           exit = 1;
         }
-      }
-      else if (c !== 10) {
+      } else if (c !== 10) {
         if (c >= 32) {
           switch (c - 32 | 0) {
             case 0 : 
@@ -10222,8 +9886,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                               /* Escaped_percent */6,
                               match$3[0]
                             ])];
-                }
-                else {
+                } else {
                   var match$4 = parse_literal(str_ind, str_ind, end_ind);
                   return /* Fmt_EBB */[/* Char_literal */Block.__(12, [
                               /* "@" */64,
@@ -10263,15 +9926,12 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                   if (match$8 >= 48) {
                     if (match$8 >= 58) {
                       throw Caml_builtin_exceptions.not_found;
-                    }
-                    else {
+                    } else {
                       exit$1 = 1;
                     }
-                  }
-                  else if (match$8 !== 45) {
+                  } else if (match$8 !== 45) {
                     throw Caml_builtin_exceptions.not_found;
-                  }
-                  else {
+                  } else {
                     exit$1 = 1;
                   }
                   if (exit$1 === 1) {
@@ -10283,8 +9943,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                     if (switcher$1 > 12 || switcher$1 < 0) {
                       if (switcher$1 !== 17) {
                         throw Caml_builtin_exceptions.not_found;
-                      }
-                      else {
+                      } else {
                         var s = $$String.sub(str, str_ind$1 - 2 | 0, (str_ind_3 - str_ind$1 | 0) + 3 | 0);
                         match$7 = /* tuple */[
                           str_ind_3 + 1 | 0,
@@ -10295,11 +9954,9 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                             ])
                         ];
                       }
-                    }
-                    else if (switcher$1 === 2 || switcher$1 === 1) {
+                    } else if (switcher$1 === 2 || switcher$1 === 1) {
                       throw Caml_builtin_exceptions.not_found;
-                    }
-                    else {
+                    } else {
                       var match$11 = parse_integer(str_ind_3, end_ind$1);
                       var str_ind_5 = parse_spaces(match$11[0], end_ind$1);
                       if (Caml_string.get(str, str_ind_5) !== /* ">" */62) {
@@ -10318,7 +9975,8 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                   }
                   
                 }
-                catch (exn){
+                catch (raw_exn){
+                  var exn = Js_exn.internalToOCamlException(raw_exn);
                   if (exn === Caml_builtin_exceptions.not_found) {
                     match$7 = /* tuple */[
                       str_ind$1,
@@ -10328,8 +9986,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                           0
                         ])
                     ];
-                  }
-                  else if (exn[0] === Caml_builtin_exceptions.failure) {
+                  } else if (exn[0] === Caml_builtin_exceptions.failure) {
                     match$7 = /* tuple */[
                       str_ind$1,
                       /* Break */Block.__(0, [
@@ -10338,8 +9995,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                           0
                         ])
                     ];
-                  }
-                  else {
+                  } else {
                     throw exn;
                   }
                 }
@@ -10360,15 +10016,12 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                   if (match$14 >= 48) {
                     if (match$14 >= 58) {
                       match$13 = /* None */0;
-                    }
-                    else {
+                    } else {
                       exit$2 = 1;
                     }
-                  }
-                  else if (match$14 !== 45) {
+                  } else if (match$14 !== 45) {
                     match$13 = /* None */0;
-                  }
-                  else {
+                  } else {
                     exit$2 = 1;
                   }
                   if (exit$2 === 1) {
@@ -10388,14 +10041,13 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                   }
                   
                 }
-                catch (exn$1){
+                catch (raw_exn$1){
+                  var exn$1 = Js_exn.internalToOCamlException(raw_exn$1);
                   if (exn$1 === Caml_builtin_exceptions.not_found) {
                     match$13 = /* None */0;
-                  }
-                  else if (exn$1[0] === Caml_builtin_exceptions.failure) {
+                  } else if (exn$1[0] === Caml_builtin_exceptions.failure) {
                     match$13 = /* None */0;
-                  }
-                  else {
+                  } else {
                     throw exn$1;
                   }
                 }
@@ -10407,8 +10059,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                               match$16[1],
                               match$17[0]
                             ])];
-                }
-                else {
+                } else {
                   var match$18 = parse_literal(str_ind$2, str_ind$2, end_ind$2);
                   return /* Fmt_EBB */[/* Formatting_lit */Block.__(17, [
                               /* Scan_indic */Block.__(2, [/* "<" */60]),
@@ -10458,12 +10109,10 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                           ])];
             
           }
-        }
-        else {
+        } else {
           exit = 1;
         }
-      }
-      else {
+      } else {
         var beg_ind$8 = str_ind + 1 | 0;
         var match$21 = parse_literal(beg_ind$8, beg_ind$8, end_ind);
         return /* Fmt_EBB */[/* Formatting_lit */Block.__(17, [
@@ -10490,15 +10139,13 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                     $$String.sub(str, lit_start, size),
                     fmt
                   ])];
-      }
-      else {
+      } else {
         return /* Fmt_EBB */[/* Char_literal */Block.__(12, [
                     Caml_string.get(str, lit_start),
                     fmt
                   ])];
       }
-    }
-    else {
+    } else {
       return /* Fmt_EBB */[fmt];
     }
   };
@@ -10512,8 +10159,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
         _str_ind = str_ind + 1 | 0;
         continue ;
         
-      }
-      else {
+      } else {
         return str_ind;
       }
     };
@@ -10533,12 +10179,10 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                 11
               ]
             ];
-      }
-      else {
+      } else {
         return parse_positive(str_ind, end_ind, 0);
       }
-    }
-    else if (match !== 45) {
+    } else if (match !== 45) {
       throw [
             Caml_builtin_exceptions.assert_failure,
             [
@@ -10547,16 +10191,14 @@ function fmt_ebb_of_string(legacy_behavior, str) {
               11
             ]
           ];
-    }
-    else {
+    } else {
       if ((str_ind + 1 | 0) === end_ind) {
         invalid_format_message(end_ind, "unexpected end of format");
       }
       var c = Caml_string.get(str, str_ind + 1 | 0);
       if (c > 57 || c < 48) {
         return expected_character(str_ind + 1 | 0, "digit", c);
-      }
-      else {
+      } else {
         var match$1 = parse_positive(str_ind + 1 | 0, end_ind, 0);
         return /* tuple */[
                 match$1[0],
@@ -10575,19 +10217,16 @@ function fmt_ebb_of_string(legacy_behavior, str) {
             _space = /* false */0;
             continue ;
             
-          }
-          else {
+          } else {
             return incompatible_flag(pct_ind, str_ind, /* " " */32, "'+'");
           }
-        }
-        else {
+        } else {
           var exit = 0;
           if (symb >= 72) {
             var switcher = symb - 101 | 0;
             if (switcher > 2 || switcher < 0) {
               exit = 1;
-            }
-            else {
+            } else {
               switch (switcher) {
                 case 0 : 
                     return /* Float_pe */4;
@@ -10598,8 +10237,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                 
               }
             }
-          }
-          else if (symb >= 69) {
+          } else if (symb >= 69) {
             switch (symb - 69 | 0) {
               case 0 : 
                   return /* Float_pE */7;
@@ -10610,8 +10248,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                   return /* Float_pG */13;
               
             }
-          }
-          else {
+          } else {
             exit = 1;
           }
           if (exit === 1) {
@@ -10619,22 +10256,19 @@ function fmt_ebb_of_string(legacy_behavior, str) {
               _plus = /* false */0;
               continue ;
               
-            }
-            else {
+            } else {
               return incompatible_flag(pct_ind, str_ind, symb, "'+'");
             }
           }
           
         }
-      }
-      else if (space !== 0) {
+      } else if (space !== 0) {
         var exit$1 = 0;
         if (symb >= 72) {
           var switcher$1 = symb - 101 | 0;
           if (switcher$1 > 2 || switcher$1 < 0) {
             exit$1 = 1;
-          }
-          else {
+          } else {
             switch (switcher$1) {
               case 0 : 
                   return /* Float_se */5;
@@ -10645,8 +10279,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
               
             }
           }
-        }
-        else if (symb >= 69) {
+        } else if (symb >= 69) {
           switch (symb - 69 | 0) {
             case 0 : 
                 return /* Float_sE */8;
@@ -10657,8 +10290,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                 return /* Float_sG */14;
             
           }
-        }
-        else {
+        } else {
           exit$1 = 1;
         }
         if (exit$1 === 1) {
@@ -10666,14 +10298,12 @@ function fmt_ebb_of_string(legacy_behavior, str) {
             _space = /* false */0;
             continue ;
             
-          }
-          else {
+          } else {
             return incompatible_flag(pct_ind, str_ind, symb, "' '");
           }
         }
         
-      }
-      else if (symb >= 72) {
+      } else if (symb >= 72) {
         var switcher$2 = symb - 101 | 0;
         if (switcher$2 > 2 || switcher$2 < 0) {
           throw [
@@ -10684,8 +10314,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                   25
                 ]
               ];
-        }
-        else {
+        } else {
           switch (switcher$2) {
             case 0 : 
                 return /* Float_e */3;
@@ -10696,8 +10325,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
             
           }
         }
-      }
-      else if (symb >= 69) {
+      } else if (symb >= 69) {
         switch (symb - 69 | 0) {
           case 0 : 
               return /* Float_E */6;
@@ -10707,8 +10335,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
               return /* Float_G */12;
           
         }
-      }
-      else {
+      } else {
         throw [
               Caml_builtin_exceptions.assert_failure,
               [
@@ -10730,11 +10357,11 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                       /* Caml_string */Block.__(3, [
                           /* No_padding */0,
                           /* String_literal */Block.__(11, [
-                              ': unclosed sub-format, expected "',
+                              ": unclosed sub-format, expected \"",
                               /* Char_literal */Block.__(12, [
                                   /* "%" */37,
                                   /* Char */Block.__(0, [/* String_literal */Block.__(11, [
-                                          '" at character number ',
+                                          "\" at character number ",
                                           /* Int */Block.__(4, [
                                               /* Int_d */0,
                                               /* No_padding */0,
@@ -10746,7 +10373,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                             ])
                         ])
                     ]),
-                  'invalid format %S: unclosed sub-format, expected "%%%c" at character number %d'
+                  "invalid format %S: unclosed sub-format, expected \"%%%c\" at character number %d"
                 ]), str, c, end_ind);
       }
       var match = Caml_string.get(str, str_ind);
@@ -10754,23 +10381,20 @@ function fmt_ebb_of_string(legacy_behavior, str) {
         _str_ind = str_ind + 1 | 0;
         continue ;
         
-      }
-      else {
+      } else {
         if ((str_ind + 1 | 0) === end_ind) {
           invalid_format_message(end_ind, "unexpected end of format");
         }
         if (Caml_string.get(str, str_ind + 1 | 0) === c) {
           return str_ind;
-        }
-        else {
+        } else {
           var match$1 = Caml_string.get(str, str_ind + 1 | 0);
           var exit = 0;
           if (match$1 >= 95) {
             if (match$1 >= 123) {
               if (match$1 >= 126) {
                 exit = 1;
-              }
-              else {
+              } else {
                 switch (match$1 - 123 | 0) {
                   case 0 : 
                       var sub_end = search_subformat_end(str_ind + 2 | 0, end_ind, /* "}" */125);
@@ -10784,11 +10408,9 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                   
                 }
               }
-            }
-            else if (match$1 >= 96) {
+            } else if (match$1 >= 96) {
               exit = 1;
-            }
-            else {
+            } else {
               if ((str_ind + 2 | 0) === end_ind) {
                 invalid_format_message(end_ind, "unexpected end of format");
               }
@@ -10798,31 +10420,26 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                   _str_ind = str_ind + 3 | 0;
                   continue ;
                   
-                }
-                else {
+                } else {
                   var sub_end$1 = search_subformat_end(str_ind + 3 | 0, end_ind, /* "}" */125);
                   _str_ind = sub_end$1 + 2 | 0;
                   continue ;
                   
                 }
-              }
-              else {
+              } else {
                 var sub_end$2 = search_subformat_end(str_ind + 3 | 0, end_ind, /* ")" */41);
                 _str_ind = sub_end$2 + 2 | 0;
                 continue ;
                 
               }
             }
-          }
-          else if (match$1 !== 40) {
+          } else if (match$1 !== 40) {
             if (match$1 !== 41) {
               exit = 1;
-            }
-            else {
+            } else {
               return expected_character(str_ind + 1 | 0, "character '}'", /* ")" */41);
             }
-          }
-          else {
+          } else {
             var sub_end$3 = search_subformat_end(str_ind + 2 | 0, end_ind, /* ")" */41);
             _str_ind = sub_end$3 + 2 | 0;
             continue ;
@@ -10848,49 +10465,40 @@ function fmt_ebb_of_string(legacy_behavior, str) {
     var check_no_0 = function (symb, pad) {
       if (typeof pad === "number") {
         return pad;
-      }
-      else if (pad.tag) {
+      } else if (pad.tag) {
         if (pad[0] >= 2) {
           if (legacy_behavior$1) {
             return /* Arg_padding */Block.__(1, [/* Right */1]);
-          }
-          else {
+          } else {
             return incompatible_flag(pct_ind, str_ind, symb, "0");
           }
-        }
-        else {
+        } else {
           return pad;
         }
-      }
-      else if (pad[0] >= 2) {
+      } else if (pad[0] >= 2) {
         if (legacy_behavior$1) {
           return /* Lit_padding */Block.__(0, [
                     /* Right */1,
                     pad[1]
                   ]);
-        }
-        else {
+        } else {
           return incompatible_flag(pct_ind, str_ind, symb, "0");
         }
-      }
-      else {
+      } else {
         return pad;
       }
     };
     var opt_of_pad = function (c, pad) {
       if (typeof pad === "number") {
         return /* None */0;
-      }
-      else if (pad.tag) {
+      } else if (pad.tag) {
         return incompatible_flag(pct_ind, str_ind, c, "'*'");
-      }
-      else {
+      } else {
         switch (pad[0]) {
           case 0 : 
               if (legacy_behavior$1) {
                 return /* Some */[pad[1]];
-              }
-              else {
+              } else {
                 return incompatible_flag(pct_ind, str_ind, c, "'-'");
               }
           case 1 : 
@@ -10898,8 +10506,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
           case 2 : 
               if (legacy_behavior$1) {
                 return /* Some */[pad[1]];
-              }
-              else {
+              } else {
                 return incompatible_flag(pct_ind, str_ind, c, "'0'");
               }
           
@@ -10911,12 +10518,10 @@ function fmt_ebb_of_string(legacy_behavior, str) {
       if (typeof prec === "number") {
         if (prec !== 0) {
           return incompatible_flag(pct_ind, str_ind, /* "_" */95, "'*'");
-        }
-        else {
+        } else {
           return /* None */0;
         }
-      }
-      else {
+      } else {
         return /* Some */[prec[0]];
       }
     };
@@ -10926,8 +10531,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
     var exit$2 = 0;
     if (symb >= 124) {
       exit$1 = 6;
-    }
-    else {
+    } else {
       switch (symb) {
         case 33 : 
             var match = parse_literal(str_ind, str_ind, end_ind);
@@ -10951,8 +10555,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                     ignored,
                     fmt_rest
                   ])];
-            }
-            else {
+            } else {
               pad_used = /* true */1;
               fmt_result = /* Fmt_EBB */[/* Format_subst */Block.__(14, [
                     opt_of_pad(/* "(" */40, pad),
@@ -10985,8 +10588,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                     ignored$1,
                     fmt_rest$2
                   ])];
-            }
-            else {
+            } else {
               fmt_result = /* Fmt_EBB */[/* Scan_get_counter */Block.__(21, [
                     /* Token_counter */2,
                     fmt_rest$2
@@ -11005,8 +10607,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                     ignored$2,
                     fmt_rest$3
                   ])];
-            }
-            else {
+            } else {
               var match$6 = make_padding_fmt_ebb(pad$1, fmt_rest$3);
               fmt_result = /* Fmt_EBB */[/* Caml_string */Block.__(3, [
                     match$6[0],
@@ -11031,8 +10632,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                     ignored$3,
                     fmt_rest$4
                   ])];
-            }
-            else {
+            } else {
               pad_used = /* true */1;
               fmt_result = /* Fmt_EBB */[/* Scan_char_set */Block.__(20, [
                     opt_of_pad(/* "[" */91, pad),
@@ -11063,8 +10663,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                             /* Ignored_char */0,
                             fmt_rest
                           ])];
-              }
-              else {
+              } else {
                 return /* Fmt_EBB */[/* Char */Block.__(0, [fmt_rest])];
               }
             };
@@ -11074,8 +10673,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                             /* Ignored_scan_next_char */4,
                             fmt_rest
                           ])];
-              }
-              else {
+              } else {
                 return /* Fmt_EBB */[/* Scan_next_char */Block.__(22, [fmt_rest])];
               }
             };
@@ -11122,8 +10720,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                     ignored$4,
                     fmt_rest$7
                   ])];
-            }
-            else {
+            } else {
               var match$14 = make_padding_fmt_ebb(pad$2, fmt_rest$7);
               fmt_result = /* Fmt_EBB */[/* String */Block.__(2, [
                     match$14[0],
@@ -11250,8 +10847,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                     ignored$5,
                     fmt_rest$8
                   ])];
-            }
-            else {
+            } else {
               pad_used = /* true */1;
               fmt_result = /* Fmt_EBB */[/* Format_arg */Block.__(13, [
                     opt_of_pad(/* "{" */123, pad),
@@ -11282,16 +10878,14 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                   ignored$6,
                   fmt_rest$9
                 ])];
-          }
-          else {
+          } else {
             pad_used = /* true */1;
             prec_used[0] = /* true */1;
             var pad$3;
             var exit$3 = 0;
             if (typeof prec === "number" && prec === 0) {
               pad$3 = pad;
-            }
-            else {
+            } else {
               exit$3 = 9;
             }
             if (exit$3 === 9) {
@@ -11330,15 +10924,13 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                     ignored$7,
                     fmt_rest$10
                   ])];
-            }
-            else {
+            } else {
               fmt_result = /* Fmt_EBB */[/* Scan_get_counter */Block.__(21, [
                     counter,
                     fmt_rest$10
                   ])];
             }
-          }
-          else {
+          } else {
             exit$1 = 6;
           }
           break;
@@ -11363,8 +10955,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                   ignored$8,
                   fmt_rest$11
                 ])];
-          }
-          else {
+          } else {
             pad_used = /* true */1;
             var match$22 = make_padprec_fmt_ebb(pad, (prec_used[0] = /* true */1, prec), fmt_rest$11);
             fmt_result = /* Fmt_EBB */[/* Float */Block.__(8, [
@@ -11426,8 +11017,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
           if (symb >= 108) {
             if (symb >= 111) {
               exit = 1;
-            }
-            else {
+            } else {
               switch (symb - 108 | 0) {
                 case 0 : 
                     plus_used = /* true */1;
@@ -11448,8 +11038,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                             ignored$9,
                             fmt_rest$13
                           ])];
-                    }
-                    else {
+                    } else {
                       pad_used = /* true */1;
                       var match$26 = make_padprec_fmt_ebb(pad, (prec_used[0] = /* true */1, prec), fmt_rest$13);
                       fmt_result = /* Fmt_EBB */[/* Int32 */Block.__(5, [
@@ -11482,8 +11071,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                             ignored$10,
                             fmt_rest$14
                           ])];
-                    }
-                    else {
+                    } else {
                       pad_used = /* true */1;
                       var match$28 = make_padprec_fmt_ebb(pad, (prec_used[0] = /* true */1, prec), fmt_rest$14);
                       fmt_result = /* Fmt_EBB */[/* Nativeint */Block.__(6, [
@@ -11497,11 +11085,9 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                 
               }
             }
-          }
-          else if (symb !== 76) {
+          } else if (symb !== 76) {
             exit = 1;
-          }
-          else {
+          } else {
             plus_used = /* true */1;
             sharp_used = /* true */1;
             space_used = /* true */1;
@@ -11520,8 +11106,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                     ignored$11,
                     fmt_rest$15
                   ])];
-            }
-            else {
+            } else {
               pad_used = /* true */1;
               var match$30 = make_padprec_fmt_ebb(pad, (prec_used[0] = /* true */1, prec), fmt_rest$15);
               fmt_result = /* Fmt_EBB */[/* Int64 */Block.__(7, [
@@ -11548,7 +11133,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                                 /* No_padding */0,
                                 /* No_precision */0,
                                 /* String_literal */Block.__(11, [
-                                    ', invalid conversion "',
+                                    ", invalid conversion \"",
                                     /* Char_literal */Block.__(12, [
                                         /* "%" */37,
                                         /* Char */Block.__(0, [/* Char_literal */Block.__(12, [
@@ -11561,7 +11146,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                           ])
                       ])
                   ]),
-                'invalid format %S: at character number %d, invalid conversion "%%%c"'
+                "invalid format %S: at character number %d, invalid conversion \"%%%c\""
               ]), str, str_ind - 1 | 0, symb);
     }
     if (!legacy_behavior$1) {
@@ -11591,29 +11176,24 @@ function fmt_ebb_of_string(legacy_behavior, str) {
         if (symb !== 44) {
           if (symb !== 64) {
             exit$4 = 1;
-          }
-          else if (!legacy_behavior$1) {
+          } else if (!legacy_behavior$1) {
             exit$4 = 1;
           }
           
-        }
-        else if (!legacy_behavior$1) {
+        } else if (!legacy_behavior$1) {
           exit$4 = 1;
         }
         
-      }
-      else if (symb !== 33) {
+      } else if (symb !== 33) {
         if (symb >= 37) {
           if (!legacy_behavior$1) {
             exit$4 = 1;
           }
           
-        }
-        else {
+        } else {
           exit$4 = 1;
         }
-      }
-      else if (!legacy_behavior$1) {
+      } else if (!legacy_behavior$1) {
         exit$4 = 1;
       }
       if (exit$4 === 1) {
@@ -11667,8 +11247,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
       var switcher = match - 32 | 0;
       if (switcher > 16 || switcher < 0) {
         exit = 1;
-      }
-      else {
+      } else {
         switch (switcher) {
           case 0 : 
               set_flag(str_ind$1, space);
@@ -11732,19 +11311,16 @@ function fmt_ebb_of_string(legacy_behavior, str) {
         if (match$1 >= 48) {
           if (match$1 >= 58) {
             exit$1 = 1;
-          }
-          else {
+          } else {
             var match$2 = parse_positive(str_ind$2, end_ind$1, 0);
             return parse_after_padding(pct_ind$1, match$2[0], end_ind$1, minus$1, plus$1, sharp$1, space$1, ign$1, /* Lit_padding */Block.__(0, [
                           padty,
                           match$2[1]
                         ]));
           }
-        }
-        else if (match$1 !== 42) {
+        } else if (match$1 !== 42) {
           exit$1 = 1;
-        }
-        else {
+        } else {
           return parse_after_padding(pct_ind$1, str_ind$2 + 1 | 0, end_ind$1, minus$1, plus$1, sharp$1, space$1, ign$1, /* Arg_padding */Block.__(1, [padty]));
         }
         if (exit$1 === 1) {
@@ -11773,8 +11349,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
     var switcher = symb - 88 | 0;
     if (switcher > 32 || switcher < 0) {
       return /* false */0;
-    }
-    else {
+    } else {
       switch (switcher) {
         case 1 : 
         case 2 : 
@@ -11820,8 +11395,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
     if (symb >= 108) {
       if (symb >= 111) {
         exit = 1;
-      }
-      else {
+      } else {
         switch (symb - 108 | 0) {
           case 0 : 
               return /* Line_counter */0;
@@ -11833,11 +11407,9 @@ function fmt_ebb_of_string(legacy_behavior, str) {
           
         }
       }
-    }
-    else if (symb !== 76) {
+    } else if (symb !== 76) {
       exit = 1;
-    }
-    else {
+    } else {
       return /* Token_counter */2;
     }
     if (exit === 1) {
@@ -11915,17 +11487,14 @@ function fmt_ebb_of_string(legacy_behavior, str) {
           if (c$prime !== 64) {
             if (c$prime !== 93) {
               exit = 1;
-            }
-            else {
+            } else {
               add_in_char_set(char_set, c);
               return str_ind + 1 | 0;
             }
-          }
-          else {
+          } else {
             exit$1 = 2;
           }
-        }
-        else if (c$prime !== 37) {
+        } else if (c$prime !== 37) {
           if (c$prime >= 45) {
             var str_ind$1 = str_ind + 1 | 0;
             var end_ind$1 = end_ind;
@@ -11938,14 +11507,12 @@ function fmt_ebb_of_string(legacy_behavior, str) {
               if (c$prime$1 !== 93) {
                 add_range(c$1, c$prime$1);
                 return parse_char_set_content(str_ind$1 + 1 | 0, end_ind$1);
-              }
-              else {
+              } else {
                 add_in_char_set(char_set, c$1);
                 add_in_char_set(char_set, /* "-" */45);
                 return str_ind$1 + 1 | 0;
               }
-            }
-            else {
+            } else {
               if ((str_ind$1 + 1 | 0) === end_ind$1) {
                 invalid_format_message(end_ind$1, "unexpected end of format");
               }
@@ -11954,12 +11521,10 @@ function fmt_ebb_of_string(legacy_behavior, str) {
               if (c$prime$2 !== 37) {
                 if (c$prime$2 !== 64) {
                   return fail_single_percent(str_ind$1);
-                }
-                else {
+                } else {
                   exit$2 = 1;
                 }
-              }
-              else {
+              } else {
                 exit$2 = 1;
               }
               if (exit$2 === 1) {
@@ -11968,20 +11533,17 @@ function fmt_ebb_of_string(legacy_behavior, str) {
               }
               
             }
-          }
-          else {
+          } else {
             exit = 1;
           }
-        }
-        else {
+        } else {
           exit$1 = 2;
         }
         if (exit$1 === 2) {
           if (c === /* "%" */37) {
             add_in_char_set(char_set, c$prime);
             return parse_char_set_content(str_ind + 1 | 0, end_ind);
-          }
-          else {
+          } else {
             exit = 1;
           }
         }
@@ -12008,12 +11570,10 @@ function fmt_ebb_of_string(legacy_behavior, str) {
         if (c !== 45) {
           if (c !== 93) {
             return parse_char_set_after_char(str_ind + 1 | 0, end_ind, c);
-          }
-          else {
+          } else {
             return str_ind + 1 | 0;
           }
-        }
-        else {
+        } else {
           add_in_char_set(char_set, /* "-" */45);
           _str_ind = str_ind + 1 | 0;
           continue ;
@@ -12049,27 +11609,24 @@ function fmt_ebb_of_string(legacy_behavior, str) {
   var check_open_box = function (fmt) {
     if (typeof fmt === "number") {
       return /* () */0;
-    }
-    else if (fmt.tag === 11) {
+    } else if (fmt.tag === 11) {
       if (typeof fmt[1] === "number") {
         try {
           open_box_of_string(fmt[0]);
           return /* () */0;
         }
-        catch (exn){
+        catch (raw_exn){
+          var exn = Js_exn.internalToOCamlException(raw_exn);
           if (exn[0] === Caml_builtin_exceptions.failure) {
             return /* () */0;
-          }
-          else {
+          } else {
             throw exn;
           }
         }
-      }
-      else {
+      } else {
         return /* () */0;
       }
-    }
-    else {
+    } else {
       return /* () */0;
     }
   };
@@ -12081,8 +11638,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
       var match = Caml_string.get(str, str_ind);
       if (match !== 60) {
         throw Caml_builtin_exceptions.not_found;
-      }
-      else {
+      } else {
         var ind = $$String.index_from(str, str_ind + 1 | 0, /* ">" */62);
         if (ind >= end_ind) {
           throw Caml_builtin_exceptions.not_found;
@@ -12115,8 +11671,7 @@ function fmt_ebb_of_string(legacy_behavior, str) {
                     formatting$1,
                     match$3[0]
                   ])];
-      }
-      else {
+      } else {
         throw exn;
       }
     }
@@ -12150,8 +11705,7 @@ function format_of_string_fmtty(str, fmtty) {
                         ]),
                       "bad input: format type mismatch between %S and %S"
                     ]), str, string_of_fmtty(fmtty));
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -12183,8 +11737,7 @@ function format_of_string_format(str, param) {
                         ]),
                       "bad input: format type mismatch between %S and %S"
                     ]), str, param[1]);
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -12224,8 +11777,8 @@ exports.recast                         = recast;
 //////// start of caml_io.js ////////
 'use strict';
 
-var Curry                   = require("./curry");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Curry                   = require("./curry.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function $caret(prim, prim$1) {
   return prim + prim$1;
@@ -12239,12 +11792,10 @@ var stdout = /* record */[
     var v = s.length - 1 | 0;
     if (( (typeof process !== "undefined") && process.stdout && process.stdout.write)) {
       return ( process.stdout.write )(s);
-    }
-    else if (s[v] === "\n") {
+    } else if (s[v] === "\n") {
       console.log(s.slice(0, v));
       return /* () */0;
-    }
-    else {
+    } else {
       console.log(s);
       return /* () */0;
     }
@@ -12258,8 +11809,7 @@ var stderr = /* record */[
     if (s[v] === "\n") {
       console.log(s.slice(0, v));
       return /* () */0;
-    }
-    else {
+    } else {
       console.log(s);
       return /* () */0;
     }
@@ -12285,8 +11835,7 @@ function caml_ml_flush(oc) {
     Curry._2(oc[/* output */1], oc, oc[/* buffer */0]);
     oc[/* buffer */0] = "";
     return /* () */0;
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -12300,14 +11849,12 @@ function caml_ml_output(oc, str, offset, len) {
   var str$1 = offset === 0 && len === str.length ? str : str.slice(offset, len);
   if (( (typeof process !== "undefined") && process.stdout && process.stdout.write ) && oc === stdout) {
     return ( process.stdout.write )(str$1);
-  }
-  else {
+  } else {
     var id = str$1.lastIndexOf("\n");
     if (id < 0) {
       oc[/* buffer */0] = oc[/* buffer */0] + str$1;
       return /* () */0;
-    }
-    else {
+    } else {
       oc[/* buffer */0] = oc[/* buffer */0] + str$1.slice(0, id + 1 | 0);
       caml_ml_flush(oc);
       oc[/* buffer */0] = oc[/* buffer */0] + str$1.slice(id + 1 | 0);
@@ -12368,7 +11915,7 @@ exports.caml_ml_out_channels_list   = caml_ml_out_channels_list;
 //////// start of caml_lexer.js ////////
 'use strict';
 
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function fail() {
   throw [
@@ -12708,13 +12255,28 @@ exports.caml_new_lex_engine = caml_new_lex_engine;
   };
 
 
+  _registry['caml_missing_polyfill'] = function() {
+    let exports = {};
+//////// start of caml_missing_polyfill.js ////////
+'use strict';
+
+
+var not_implemented = (function (s){ throw new Error(s)});
+
+exports.not_implemented = not_implemented;
+/* not_implemented Not a pure module */
+//////// end of caml_missing_polyfill.js ////////
+    return exports;
+  };
+
+
   _registry['caml_obj'] = function() {
     let exports = {};
 //////// start of caml_obj.js ////////
 'use strict';
 
-var Block                   = require("./block");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Block                   = require("./block.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function caml_obj_dup(x) {
   var len = x.length;
@@ -12733,15 +12295,13 @@ function caml_obj_truncate(x, new_size) {
           Caml_builtin_exceptions.invalid_argument,
           "Obj.truncate"
         ];
-  }
-  else if (len !== new_size) {
+  } else if (len !== new_size) {
     for(var i = new_size ,i_finish = len - 1 | 0; i <= i_finish; ++i){
       x[i] = 0;
     }
     x.length = new_size;
     return /* () */0;
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -12759,8 +12319,7 @@ function caml_update_dummy(x, y) {
   if (y_tag !== 0) {
     x.tag = y_tag;
     return /* () */0;
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -12768,11 +12327,9 @@ function caml_update_dummy(x, y) {
 function caml_int_compare(x, y) {
   if (x < y) {
     return -1;
-  }
-  else if (x === y) {
+  } else if (x === y) {
     return 0;
-  }
-  else {
+  } else {
     return 1;
   }
 }
@@ -12781,136 +12338,132 @@ function caml_compare(_a, _b) {
   while(true) {
     var b = _b;
     var a = _a;
-    if (typeof a === "string") {
+    var a_type = typeof a;
+    var b_type = typeof b;
+    if (a_type === "string") {
       var x = a;
       var y = b;
       if (x < y) {
         return -1;
-      }
-      else if (x === y) {
-        return 0;
-      }
-      else {
-        return 1;
-      }
-    }
-    else if (typeof a === "number") {
-      return caml_int_compare(a, b);
-    }
-    else if (typeof a === "boolean" || typeof a === "null" || typeof a === "undefined") {
-      var x$1 = a;
-      var y$1 = b;
-      if (x$1 === y$1) {
+      } else if (x === y) {
         return 0;
-      }
-      else if (x$1 < y$1) {
-        return -1;
-      }
-      else {
+      } else {
         return 1;
       }
-    }
-    else {
-      var tag_a = a.tag | 0;
-      var tag_b = b.tag | 0;
-      if (tag_a === 250) {
-        _a = a[0];
-        continue ;
-        
-      }
-      else if (tag_b === 250) {
-        _b = b[0];
-        continue ;
-        
-      }
-      else if (tag_a === 248) {
-        return caml_int_compare(a[1], b[1]);
-      }
-      else if (tag_a === 251) {
-        throw [
-              Caml_builtin_exceptions.invalid_argument,
-              "equal: abstract value"
-            ];
-      }
-      else if (tag_a !== tag_b) {
-        if (tag_a < tag_b) {
+    } else {
+      var is_a_number = +(a_type === "number");
+      var is_b_number = +(b_type === "number");
+      if (is_a_number !== 0) {
+        if (is_b_number !== 0) {
+          return caml_int_compare(a, b);
+        } else {
           return -1;
         }
-        else {
+      } else if (is_b_number !== 0) {
+        return 1;
+      } else if (a_type === "boolean" || a_type === "null" || a_type === "undefined") {
+        var x$1 = a;
+        var y$1 = b;
+        if (x$1 === y$1) {
+          return 0;
+        } else if (x$1 < y$1) {
+          return -1;
+        } else {
           return 1;
         }
-      }
-      else {
-        var len_a = a.length;
-        var len_b = b.length;
-        if (len_a === len_b) {
-          var a$1 = a;
-          var b$1 = b;
-          var _i = 0;
-          var same_length = len_a;
-          while(true) {
-            var i = _i;
-            if (i === same_length) {
-              return 0;
-            }
-            else {
-              var res = caml_compare(a$1[i], b$1[i]);
-              if (res !== 0) {
-                return res;
-              }
-              else {
-                _i = i + 1 | 0;
-                continue ;
-                
-              }
-            }
-          };
-        }
-        else if (len_a < len_b) {
-          var a$2 = a;
-          var b$2 = b;
-          var _i$1 = 0;
-          var short_length = len_a;
-          while(true) {
-            var i$1 = _i$1;
-            if (i$1 === short_length) {
-              return -1;
-            }
-            else {
-              var res$1 = caml_compare(a$2[i$1], b$2[i$1]);
-              if (res$1 !== 0) {
-                return res$1;
-              }
-              else {
-                _i$1 = i$1 + 1 | 0;
-                continue ;
-                
+      } else if (a_type === "function" || b_type === "function") {
+        throw [
+              Caml_builtin_exceptions.invalid_argument,
+              "compare: functional value"
+            ];
+      } else {
+        var tag_a = a.tag | 0;
+        var tag_b = b.tag | 0;
+        if (tag_a === 250) {
+          _a = a[0];
+          continue ;
+          
+        } else if (tag_b === 250) {
+          _b = b[0];
+          continue ;
+          
+        } else if (tag_a === 248) {
+          return caml_int_compare(a[1], b[1]);
+        } else if (tag_a === 251) {
+          throw [
+                Caml_builtin_exceptions.invalid_argument,
+                "equal: abstract value"
+              ];
+        } else if (tag_a !== tag_b) {
+          if (tag_a < tag_b) {
+            return -1;
+          } else {
+            return 1;
+          }
+        } else {
+          var len_a = a.length;
+          var len_b = b.length;
+          if (len_a === len_b) {
+            var a$1 = a;
+            var b$1 = b;
+            var _i = 0;
+            var same_length = len_a;
+            while(true) {
+              var i = _i;
+              if (i === same_length) {
+                return 0;
+              } else {
+                var res = caml_compare(a$1[i], b$1[i]);
+                if (res !== 0) {
+                  return res;
+                } else {
+                  _i = i + 1 | 0;
+                  continue ;
+                  
+                }
               }
-            }
-          };
-        }
-        else {
-          var a$3 = a;
-          var b$3 = b;
-          var _i$2 = 0;
-          var short_length$1 = len_b;
-          while(true) {
-            var i$2 = _i$2;
-            if (i$2 === short_length$1) {
-              return 1;
-            }
-            else {
-              var res$2 = caml_compare(a$3[i$2], b$3[i$2]);
-              if (res$2 !== 0) {
-                return res$2;
+            };
+          } else if (len_a < len_b) {
+            var a$2 = a;
+            var b$2 = b;
+            var _i$1 = 0;
+            var short_length = len_a;
+            while(true) {
+              var i$1 = _i$1;
+              if (i$1 === short_length) {
+                return -1;
+              } else {
+                var res$1 = caml_compare(a$2[i$1], b$2[i$1]);
+                if (res$1 !== 0) {
+                  return res$1;
+                } else {
+                  _i$1 = i$1 + 1 | 0;
+                  continue ;
+                  
+                }
               }
-              else {
-                _i$2 = i$2 + 1 | 0;
-                continue ;
-                
+            };
+          } else {
+            var a$3 = a;
+            var b$3 = b;
+            var _i$2 = 0;
+            var short_length$1 = len_b;
+            while(true) {
+              var i$2 = _i$2;
+              if (i$2 === short_length$1) {
+                return 1;
+              } else {
+                var res$2 = caml_compare(a$3[i$2], b$3[i$2]);
+                if (res$2 !== 0) {
+                  return res$2;
+                } else {
+                  _i$2 = i$2 + 1 | 0;
+                  continue ;
+                  
+                }
               }
-            }
-          };
+            };
+          }
         }
       }
     }
@@ -12923,60 +12476,63 @@ function caml_equal(_a, _b) {
     var a = _a;
     if (a === b) {
       return /* true */1;
-    }
-    else if (typeof a === "string" || typeof a === "number" || typeof a === "boolean" || typeof a === "undefined" || typeof a === "null") {
-      return /* false */0;
-    }
-    else {
-      var tag_a = a.tag | 0;
-      var tag_b = b.tag | 0;
-      if (tag_a === 250) {
-        _a = a[0];
-        continue ;
-        
-      }
-      else if (tag_b === 250) {
-        _b = b[0];
-        continue ;
-        
-      }
-      else if (tag_a === 248) {
-        return +(a[1] === b[1]);
-      }
-      else if (tag_a === 251) {
-        throw [
-              Caml_builtin_exceptions.invalid_argument,
-              "equal: abstract value"
-            ];
-      }
-      else if (tag_a !== tag_b) {
+    } else {
+      var a_type = typeof a;
+      if (a_type === "string" || a_type === "number" || a_type === "boolean" || a_type === "undefined" || a_type === "null") {
         return /* false */0;
-      }
-      else {
-        var len_a = a.length;
-        var len_b = b.length;
-        if (len_a === len_b) {
-          var a$1 = a;
-          var b$1 = b;
-          var _i = 0;
-          var same_length = len_a;
-          while(true) {
-            var i = _i;
-            if (i === same_length) {
-              return /* true */1;
-            }
-            else if (caml_equal(a$1[i], b$1[i])) {
-              _i = i + 1 | 0;
-              continue ;
-              
-            }
-            else {
+      } else {
+        var b_type = typeof b;
+        if (a_type === "function" || b_type === "function") {
+          throw [
+                Caml_builtin_exceptions.invalid_argument,
+                "equal: functional value"
+              ];
+        } else if (b_type === "number" || b_type === "null" || b_type === "undefined") {
+          return /* false */0;
+        } else {
+          var tag_a = a.tag | 0;
+          var tag_b = b.tag | 0;
+          if (tag_a === 250) {
+            _a = a[0];
+            continue ;
+            
+          } else if (tag_b === 250) {
+            _b = b[0];
+            continue ;
+            
+          } else if (tag_a === 248) {
+            return +(a[1] === b[1]);
+          } else if (tag_a === 251) {
+            throw [
+                  Caml_builtin_exceptions.invalid_argument,
+                  "equal: abstract value"
+                ];
+          } else if (tag_a !== tag_b) {
+            return /* false */0;
+          } else {
+            var len_a = a.length;
+            var len_b = b.length;
+            if (len_a === len_b) {
+              var a$1 = a;
+              var b$1 = b;
+              var _i = 0;
+              var same_length = len_a;
+              while(true) {
+                var i = _i;
+                if (i === same_length) {
+                  return /* true */1;
+                } else if (caml_equal(a$1[i], b$1[i])) {
+                  _i = i + 1 | 0;
+                  continue ;
+                  
+                } else {
+                  return /* false */0;
+                }
+              };
+            } else {
               return /* false */0;
             }
-          };
-        }
-        else {
-          return /* false */0;
+          }
         }
       }
     }
@@ -13027,58 +12583,6 @@ exports.caml_lessequal         = caml_lessequal;
   };
 
 
-  _registry['caml_oo'] = function() {
-    let exports = {};
-//////// start of caml_oo.js ////////
-'use strict';
-
-var Caml_array              = require("./caml_array");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
-
-var caml_methods_cache = Caml_array.caml_make_vect(1000, 0);
-
-function caml_get_public_method(obj, tag, cacheid) {
-  var meths = obj[0];
-  var offs = caml_methods_cache[cacheid];
-  if (meths[offs] === tag) {
-    return meths[offs - 1 | 0];
-  }
-  else {
-    var aux = function (_i) {
-      while(true) {
-        var i = _i;
-        if (i < 3) {
-          throw [
-                Caml_builtin_exceptions.assert_failure,
-                [
-                  "caml_oo.ml",
-                  54,
-                  20
-                ]
-              ];
-        }
-        else if (meths[i] === tag) {
-          caml_methods_cache[cacheid] = i;
-          return i;
-        }
-        else {
-          _i = i - 2 | 0;
-          continue ;
-          
-        }
-      };
-    };
-    return meths[aux((meths[0] << 1) + 1 | 0) - 1 | 0];
-  }
-}
-
-exports.caml_get_public_method = caml_get_public_method;
-/* No side effect */
-//////// end of caml_oo.js ////////
-    return exports;
-  };
-
-
   _registry['caml_parser'] = function() {
     let exports = {};
 //////// start of caml_parser.js ////////
@@ -13448,7 +12952,7 @@ function caml_parse_engine(prim, prim$1, prim$2, prim$3) {
 }
 
 function caml_set_parser_trace(prim) {
-  return $$caml_set_parser_trace(prim);
+  return +$$caml_set_parser_trace(prim);
 }
 
 exports.caml_parse_engine     = caml_parse_engine;
@@ -13464,9 +12968,9 @@ exports.caml_set_parser_trace = caml_set_parser_trace;
 //////// start of caml_string.js ////////
 'use strict';
 
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
-function js_string_of_char(prim) {
+function string_of_char(prim) {
   return String.fromCharCode(prim);
 }
 
@@ -13476,8 +12980,7 @@ function caml_string_get(s, i) {
           Caml_builtin_exceptions.invalid_argument,
           "index out of bounds"
         ];
-  }
-  else {
+  } else {
     return s.charCodeAt(i);
   }
 }
@@ -13488,8 +12991,7 @@ function caml_create_string(len) {
           Caml_builtin_exceptions.invalid_argument,
           "String.create"
         ];
-  }
-  else {
+  } else {
     return new Array(len);
   }
 }
@@ -13497,11 +12999,9 @@ function caml_create_string(len) {
 function caml_string_compare(s1, s2) {
   if (s1 === s2) {
     return 0;
-  }
-  else if (s1 < s2) {
+  } else if (s1 < s2) {
     return -1;
-  }
-  else {
+  } else {
     return 1;
   }
 }
@@ -13512,8 +13012,7 @@ function caml_fill_string(s, i, l, c) {
       s[k] = c;
     }
     return /* () */0;
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -13526,8 +13025,7 @@ function caml_blit_string(s1, i1, s2, i2, len) {
         s2[i2 + i | 0] = s1.charCodeAt(i1 + i | 0);
       }
       return /* () */0;
-    }
-    else {
+    } else {
       for(var i$1 = 0 ,i_finish$1 = off1 - 1 | 0; i$1 <= i_finish$1; ++i$1){
         s2[i2 + i$1 | 0] = s1.charCodeAt(i1 + i$1 | 0);
       }
@@ -13536,8 +13034,7 @@ function caml_blit_string(s1, i1, s2, i2, len) {
       }
       return /* () */0;
     }
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -13557,8 +13054,7 @@ function caml_blit_bytes(s1, i1, s2, i2, len) {
           s1$1[i2$1 + j | 0] = s1$1[i1$1 + j | 0];
         }
         return /* () */0;
-      }
-      else if (i1$1 > i2$1) {
+      } else if (i1$1 > i2$1) {
         var range_a$1 = (s1$1.length - i1$1 | 0) - 1 | 0;
         var range_b$1 = len$1 - 1 | 0;
         var range$1 = range_a$1 > range_b$1 ? range_b$1 : range_a$1;
@@ -13566,20 +13062,17 @@ function caml_blit_bytes(s1, i1, s2, i2, len) {
           s1$1[i2$1 + k | 0] = s1$1[i1$1 + k | 0];
         }
         return /* () */0;
-      }
-      else {
+      } else {
         return 0;
       }
-    }
-    else {
+    } else {
       var off1 = s1.length - i1 | 0;
       if (len <= off1) {
         for(var i = 0 ,i_finish = len - 1 | 0; i <= i_finish; ++i){
           s2[i2 + i | 0] = s1[i1 + i | 0];
         }
         return /* () */0;
-      }
-      else {
+      } else {
         for(var i$1 = 0 ,i_finish$1 = off1 - 1 | 0; i$1 <= i_finish$1; ++i$1){
           s2[i2 + i$1 | 0] = s1[i1 + i$1 | 0];
         }
@@ -13589,8 +13082,7 @@ function caml_blit_bytes(s1, i1, s2, i2, len) {
         return /* () */0;
       }
     }
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -13612,8 +13104,7 @@ function bytes_to_string(a) {
   var s_len = len;
   if (i === 0 && len <= 4096 && len === bytes.length) {
     return String.fromCharCode.apply(null,bytes);
-  }
-  else {
+  } else {
     var offset = 0;
     while(s_len > 0) {
       var next = s_len < 1024 ? s_len : 1024;
@@ -13639,8 +13130,7 @@ function caml_string_of_char_array(chars) {
 function caml_is_printable(c) {
   if (c > 31) {
     return +(c < 127);
-  }
-  else {
+  } else {
     return /* false */0;
   }
 }
@@ -13659,8 +13149,7 @@ function get(s, i) {
           Caml_builtin_exceptions.invalid_argument,
           "index out of bounds"
         ];
-  }
-  else {
+  } else {
     return s.charCodeAt(i);
   }
 }
@@ -13677,7 +13166,7 @@ exports.caml_blit_string          = caml_blit_string;
 exports.caml_blit_bytes           = caml_blit_bytes;
 exports.caml_string_get16         = caml_string_get16;
 exports.caml_string_get32         = caml_string_get32;
-exports.js_string_of_char         = js_string_of_char;
+exports.string_of_char            = string_of_char;
 exports.get                       = get;
 /* No side effect */
 //////// end of caml_string.js ////////
@@ -13685,52 +13174,152 @@ exports.get                       = get;
   };
 
 
-  _registry['caml_utils'] = function() {
+  _registry['caml_sys'] = function() {
     let exports = {};
-//////// start of caml_utils.js ////////
+//////// start of caml_sys.js ////////
 'use strict';
 
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
-var repeat = ( (String.prototype.repeat && function (count,self){return self.repeat(count)}) ||
-                                                  function(count , self) {
-        if (self.length == 0 || count == 0) {
-            return '';
-        }
-        // Ensuring count is a 31-bit integer allows us to heavily optimize the
-        // main part. But anyway, most current (August 2014) browsers can't handle
-        // strings 1 << 28 chars or longer, so:
-        if (self.length * count >= 1 << 28) {
-            throw new RangeError('repeat count must not overflow maximum string size');
-        }
-        var rpt = '';
-        for (;;) {
-            if ((count & 1) == 1) {
-                rpt += self;
-            }
-            count >>>= 1;
-            if (count == 0) {
-                break;
-            }
-            self += self;
-        }
-        return rpt;
+function caml_sys_getenv(s) {
+  var match = typeof (process) === "undefined" ? undefined : (process);
+  if (match !== undefined) {
+    var match$1 = match.env[s];
+    if (match$1 !== undefined) {
+      return match$1;
+    } else {
+      throw Caml_builtin_exceptions.not_found;
     }
-);
+  } else {
+    throw Caml_builtin_exceptions.not_found;
+  }
+}
 
-exports.repeat = repeat;
-/* repeat Not a pure module */
-//////// end of caml_utils.js ////////
-    return exports;
-  };
+function caml_sys_time() {
+  var match = typeof (process) === "undefined" ? undefined : (process);
+  if (match !== undefined) {
+    return match.uptime();
+  } else {
+    return -1;
+  }
+}
 
+function caml_sys_random_seed() {
+  return /* array */[((Date.now() | 0) ^ 4294967295) * Math.random() | 0];
+}
 
-  _registry['char'] = function() {
-    let exports = {};
-//////// start of char.js ////////
-'use strict';
+function caml_sys_system_command() {
+  return 127;
+}
 
-var Caml_string             = require("./caml_string");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+function caml_sys_getcwd() {
+  var match = typeof (process) === "undefined" ? undefined : (process);
+  if (match !== undefined) {
+    return match.cwd();
+  } else {
+    return "/";
+  }
+}
+
+function caml_sys_get_argv() {
+  var match = typeof (process) === "undefined" ? undefined : (process);
+  if (match !== undefined) {
+    return /* tuple */[
+            match.argv[0],
+            match.argv
+          ];
+  } else {
+    return /* tuple */[
+            "",
+            /* array */[""]
+          ];
+  }
+}
+
+function caml_sys_exit(exit_code) {
+  var match = typeof (process) === "undefined" ? undefined : (process);
+  if (match !== undefined) {
+    return match.exit(exit_code);
+  } else {
+    return /* () */0;
+  }
+}
+
+function caml_sys_is_directory() {
+  throw [
+        Caml_builtin_exceptions.failure,
+        "caml_sys_is_directory not implemented"
+      ];
+}
+
+function caml_sys_file_exists() {
+  throw [
+        Caml_builtin_exceptions.failure,
+        "caml_sys_file_exists not implemented"
+      ];
+}
+
+exports.caml_sys_getenv         = caml_sys_getenv;
+exports.caml_sys_time           = caml_sys_time;
+exports.caml_sys_random_seed    = caml_sys_random_seed;
+exports.caml_sys_system_command = caml_sys_system_command;
+exports.caml_sys_getcwd         = caml_sys_getcwd;
+exports.caml_sys_get_argv       = caml_sys_get_argv;
+exports.caml_sys_exit           = caml_sys_exit;
+exports.caml_sys_is_directory   = caml_sys_is_directory;
+exports.caml_sys_file_exists    = caml_sys_file_exists;
+/* No side effect */
+//////// end of caml_sys.js ////////
+    return exports;
+  };
+
+
+  _registry['caml_utils'] = function() {
+    let exports = {};
+//////// start of caml_utils.js ////////
+'use strict';
+
+
+var repeat = ( (String.prototype.repeat && function (count,self){return self.repeat(count)}) ||
+                                                  function(count , self) {
+        if (self.length == 0 || count == 0) {
+            return '';
+        }
+        // Ensuring count is a 31-bit integer allows us to heavily optimize the
+        // main part. But anyway, most current (August 2014) browsers can't handle
+        // strings 1 << 28 chars or longer, so:
+        if (self.length * count >= 1 << 28) {
+            throw new RangeError('repeat count must not overflow maximum string size');
+        }
+        var rpt = '';
+        for (;;) {
+            if ((count & 1) == 1) {
+                rpt += self;
+            }
+            count >>>= 1;
+            if (count == 0) {
+                break;
+            }
+            self += self;
+        }
+        return rpt;
+    }
+);
+
+exports.repeat = repeat;
+/* repeat Not a pure module */
+//////// end of caml_utils.js ////////
+    return exports;
+  };
+
+
+  _registry['char'] = function() {
+    let exports = {};
+//////// start of char.js ////////
+'use strict';
+
+var Caml_string             = require("./caml_string.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function chr(n) {
   if (n < 0 || n > 255) {
@@ -13738,8 +13327,7 @@ function chr(n) {
           Caml_builtin_exceptions.invalid_argument,
           "Char.chr"
         ];
-  }
-  else {
+  } else {
     return n;
   }
 }
@@ -13749,23 +13337,18 @@ function escaped(c) {
   if (c >= 40) {
     if (c !== 92) {
       exit = c >= 127 ? 1 : 2;
-    }
-    else {
+    } else {
       return "\\\\";
     }
-  }
-  else if (c >= 32) {
+  } else if (c >= 32) {
     if (c >= 39) {
       return "\\'";
-    }
-    else {
+    } else {
       exit = 2;
     }
-  }
-  else if (c >= 14) {
+  } else if (c >= 14) {
     exit = 1;
-  }
-  else {
+  } else {
     switch (c) {
       case 8 : 
           return "\\b";
@@ -13809,8 +13392,7 @@ function escaped(c) {
 function lowercase(c) {
   if (c >= /* "A" */65 && c <= /* "Z" */90 || c >= /* "\192" */192 && c <= /* "\214" */214 || c >= /* "\216" */216 && c <= /* "\222" */222) {
     return c + 32 | 0;
-  }
-  else {
+  } else {
     return c;
   }
 }
@@ -13818,8 +13400,7 @@ function lowercase(c) {
 function uppercase(c) {
   if (c >= /* "a" */97 && c <= /* "z" */122 || c >= /* "\224" */224 && c <= /* "\246" */246 || c >= /* "\248" */248 && c <= /* "\254" */254) {
     return c - 32 | 0;
-  }
-  else {
+  } else {
     return c;
   }
 }
@@ -13844,8 +13425,7 @@ exports.compare   = compare;
 //////// start of curry.js ////////
 'use strict';
 
-var Caml_oo    = require("./caml_oo");
-var Caml_array = require("./caml_array");
+var Caml_array = require("./caml_array.js");
 
 function app(_f, _args) {
   while(true) {
@@ -13861,31 +13441,23 @@ function app(_f, _args) {
         _f = f.apply(null, Caml_array.caml_array_sub(args, 0, arity$1));
         continue ;
         
-      }
-      else {
+      } else {
         return (function(f,args){
         return function (x) {
           return app(f, args.concat(/* array */[x]));
         }
         }(f,args));
       }
-    }
-    else {
+    } else {
       return f.apply(null, args);
     }
   };
 }
 
-function js(label, cacheid, obj, args) {
-  var meth = Caml_oo.caml_get_public_method(obj, label, cacheid);
-  return app(meth, args);
-}
-
 function curry_1(o, a0, arity) {
   if (arity > 7 || arity < 0) {
     return app(o, /* array */[a0]);
-  }
-  else {
+  } else {
     switch (arity) {
       case 0 : 
       case 1 : 
@@ -13923,22 +13495,16 @@ function _1(o, a0) {
   var arity = o.length;
   if (arity === 1) {
     return o(a0);
-  }
-  else {
+  } else {
     return curry_1(o, a0, arity);
   }
 }
 
-function js1(label, cacheid, a0) {
-  return _1(Caml_oo.caml_get_public_method(a0, label, cacheid), a0);
-}
-
 function __1(o) {
   var arity = o.length;
   if (arity === 1) {
     return o;
-  }
-  else {
+  } else {
     return function (a0) {
       return _1(o, a0);
     };
@@ -13951,8 +13517,7 @@ function curry_2(o, a0, a1, arity) {
                 a0,
                 a1
               ]);
-  }
-  else {
+  } else {
     switch (arity) {
       case 0 : 
       case 1 : 
@@ -13988,22 +13553,16 @@ function _2(o, a0, a1) {
   var arity = o.length;
   if (arity === 2) {
     return o(a0, a1);
-  }
-  else {
+  } else {
     return curry_2(o, a0, a1, arity);
   }
 }
 
-function js2(label, cacheid, a0, a1) {
-  return _2(Caml_oo.caml_get_public_method(a0, label, cacheid), a0, a1);
-}
-
 function __2(o) {
   var arity = o.length;
   if (arity === 2) {
     return o;
-  }
-  else {
+  } else {
     return function (a0, a1) {
       return _2(o, a0, a1);
     };
@@ -14011,21 +13570,19 @@ function __2(o) {
 }
 
 function curry_3(o, a0, a1, a2, arity) {
+  var exit = 0;
   if (arity > 7 || arity < 0) {
     return app(o, /* array */[
                 a0,
                 a1,
                 a2
               ]);
-  }
-  else {
+  } else {
     switch (arity) {
       case 0 : 
       case 1 : 
-          return app(o(a0), /* array */[
-                      a1,
-                      a2
-                    ]);
+          exit = 1;
+          break;
       case 2 : 
           return app(o(a0, a1), /* array */[a2]);
       case 3 : 
@@ -14049,28 +13606,29 @@ function curry_3(o, a0, a1, a2, arity) {
       
     }
   }
+  if (exit === 1) {
+    return app(o(a0), /* array */[
+                a1,
+                a2
+              ]);
+  }
+  
 }
 
 function _3(o, a0, a1, a2) {
   var arity = o.length;
   if (arity === 3) {
     return o(a0, a1, a2);
-  }
-  else {
+  } else {
     return curry_3(o, a0, a1, a2, arity);
   }
 }
 
-function js3(label, cacheid, a0, a1, a2) {
-  return _3(Caml_oo.caml_get_public_method(a0, label, cacheid), a0, a1, a2);
-}
-
 function __3(o) {
   var arity = o.length;
   if (arity === 3) {
     return o;
-  }
-  else {
+  } else {
     return function (a0, a1, a2) {
       return _3(o, a0, a1, a2);
     };
@@ -14078,6 +13636,7 @@ function __3(o) {
 }
 
 function curry_4(o, a0, a1, a2, a3, arity) {
+  var exit = 0;
   if (arity > 7 || arity < 0) {
     return app(o, /* array */[
                 a0,
@@ -14085,16 +13644,12 @@ function curry_4(o, a0, a1, a2, a3, arity) {
                 a2,
                 a3
               ]);
-  }
-  else {
+  } else {
     switch (arity) {
       case 0 : 
       case 1 : 
-          return app(o(a0), /* array */[
-                      a1,
-                      a2,
-                      a3
-                    ]);
+          exit = 1;
+          break;
       case 2 : 
           return app(o(a0, a1), /* array */[
                       a2,
@@ -14119,28 +13674,30 @@ function curry_4(o, a0, a1, a2, a3, arity) {
       
     }
   }
+  if (exit === 1) {
+    return app(o(a0), /* array */[
+                a1,
+                a2,
+                a3
+              ]);
+  }
+  
 }
 
 function _4(o, a0, a1, a2, a3) {
   var arity = o.length;
   if (arity === 4) {
     return o(a0, a1, a2, a3);
-  }
-  else {
+  } else {
     return curry_4(o, a0, a1, a2, a3, arity);
   }
 }
 
-function js4(label, cacheid, a0, a1, a2, a3) {
-  return _4(Caml_oo.caml_get_public_method(a0, label, cacheid), a0, a1, a2, a3);
-}
-
 function __4(o) {
   var arity = o.length;
   if (arity === 4) {
     return o;
-  }
-  else {
+  } else {
     return function (a0, a1, a2, a3) {
       return _4(o, a0, a1, a2, a3);
     };
@@ -14148,6 +13705,7 @@ function __4(o) {
 }
 
 function curry_5(o, a0, a1, a2, a3, a4, arity) {
+  var exit = 0;
   if (arity > 7 || arity < 0) {
     return app(o, /* array */[
                 a0,
@@ -14156,17 +13714,12 @@ function curry_5(o, a0, a1, a2, a3, a4, arity) {
                 a3,
                 a4
               ]);
-  }
-  else {
+  } else {
     switch (arity) {
       case 0 : 
       case 1 : 
-          return app(o(a0), /* array */[
-                      a1,
-                      a2,
-                      a3,
-                      a4
-                    ]);
+          exit = 1;
+          break;
       case 2 : 
           return app(o(a0, a1), /* array */[
                       a2,
@@ -14193,28 +13746,31 @@ function curry_5(o, a0, a1, a2, a3, a4, arity) {
       
     }
   }
+  if (exit === 1) {
+    return app(o(a0), /* array */[
+                a1,
+                a2,
+                a3,
+                a4
+              ]);
+  }
+  
 }
 
 function _5(o, a0, a1, a2, a3, a4) {
   var arity = o.length;
   if (arity === 5) {
     return o(a0, a1, a2, a3, a4);
-  }
-  else {
+  } else {
     return curry_5(o, a0, a1, a2, a3, a4, arity);
   }
 }
 
-function js5(label, cacheid, a0, a1, a2, a3, a4) {
-  return _5(Caml_oo.caml_get_public_method(a0, label, cacheid), a0, a1, a2, a3, a4);
-}
-
 function __5(o) {
   var arity = o.length;
   if (arity === 5) {
     return o;
-  }
-  else {
+  } else {
     return function (a0, a1, a2, a3, a4) {
       return _5(o, a0, a1, a2, a3, a4);
     };
@@ -14222,6 +13778,7 @@ function __5(o) {
 }
 
 function curry_6(o, a0, a1, a2, a3, a4, a5, arity) {
+  var exit = 0;
   if (arity > 7 || arity < 0) {
     return app(o, /* array */[
                 a0,
@@ -14231,18 +13788,12 @@ function curry_6(o, a0, a1, a2, a3, a4, a5, arity) {
                 a4,
                 a5
               ]);
-  }
-  else {
+  } else {
     switch (arity) {
       case 0 : 
       case 1 : 
-          return app(o(a0), /* array */[
-                      a1,
-                      a2,
-                      a3,
-                      a4,
-                      a5
-                    ]);
+          exit = 1;
+          break;
       case 2 : 
           return app(o(a0, a1), /* array */[
                       a2,
@@ -14272,28 +13823,32 @@ function curry_6(o, a0, a1, a2, a3, a4, a5, arity) {
       
     }
   }
+  if (exit === 1) {
+    return app(o(a0), /* array */[
+                a1,
+                a2,
+                a3,
+                a4,
+                a5
+              ]);
+  }
+  
 }
 
 function _6(o, a0, a1, a2, a3, a4, a5) {
   var arity = o.length;
   if (arity === 6) {
     return o(a0, a1, a2, a3, a4, a5);
-  }
-  else {
+  } else {
     return curry_6(o, a0, a1, a2, a3, a4, a5, arity);
   }
 }
 
-function js6(label, cacheid, a0, a1, a2, a3, a4, a5) {
-  return _6(Caml_oo.caml_get_public_method(a0, label, cacheid), a0, a1, a2, a3, a4, a5);
-}
-
 function __6(o) {
   var arity = o.length;
   if (arity === 6) {
     return o;
-  }
-  else {
+  } else {
     return function (a0, a1, a2, a3, a4, a5) {
       return _6(o, a0, a1, a2, a3, a4, a5);
     };
@@ -14301,6 +13856,7 @@ function __6(o) {
 }
 
 function curry_7(o, a0, a1, a2, a3, a4, a5, a6, arity) {
+  var exit = 0;
   if (arity > 7 || arity < 0) {
     return app(o, /* array */[
                 a0,
@@ -14311,19 +13867,12 @@ function curry_7(o, a0, a1, a2, a3, a4, a5, a6, arity) {
                 a5,
                 a6
               ]);
-  }
-  else {
+  } else {
     switch (arity) {
       case 0 : 
       case 1 : 
-          return app(o(a0), /* array */[
-                      a1,
-                      a2,
-                      a3,
-                      a4,
-                      a5,
-                      a6
-                    ]);
+          exit = 1;
+          break;
       case 2 : 
           return app(o(a0, a1), /* array */[
                       a2,
@@ -14357,28 +13906,33 @@ function curry_7(o, a0, a1, a2, a3, a4, a5, a6, arity) {
       
     }
   }
+  if (exit === 1) {
+    return app(o(a0), /* array */[
+                a1,
+                a2,
+                a3,
+                a4,
+                a5,
+                a6
+              ]);
+  }
+  
 }
 
 function _7(o, a0, a1, a2, a3, a4, a5, a6) {
   var arity = o.length;
   if (arity === 7) {
     return o(a0, a1, a2, a3, a4, a5, a6);
-  }
-  else {
+  } else {
     return curry_7(o, a0, a1, a2, a3, a4, a5, a6, arity);
   }
 }
 
-function js7(label, cacheid, a0, a1, a2, a3, a4, a5, a6) {
-  return _7(Caml_oo.caml_get_public_method(a0, label, cacheid), a0, a1, a2, a3, a4, a5, a6);
-}
-
 function __7(o) {
   var arity = o.length;
   if (arity === 7) {
     return o;
-  }
-  else {
+  } else {
     return function (a0, a1, a2, a3, a4, a5, a6) {
       return _7(o, a0, a1, a2, a3, a4, a5, a6);
     };
@@ -14386,6 +13940,7 @@ function __7(o) {
 }
 
 function curry_8(o, a0, a1, a2, a3, a4, a5, a6, a7, arity) {
+  var exit = 0;
   if (arity > 7 || arity < 0) {
     return app(o, /* array */[
                 a0,
@@ -14397,20 +13952,12 @@ function curry_8(o, a0, a1, a2, a3, a4, a5, a6, a7, arity) {
                 a6,
                 a7
               ]);
-  }
-  else {
+  } else {
     switch (arity) {
       case 0 : 
       case 1 : 
-          return app(o(a0), /* array */[
-                      a1,
-                      a2,
-                      a3,
-                      a4,
-                      a5,
-                      a6,
-                      a7
-                    ]);
+          exit = 1;
+          break;
       case 2 : 
           return app(o(a0, a1), /* array */[
                       a2,
@@ -14451,28 +13998,34 @@ function curry_8(o, a0, a1, a2, a3, a4, a5, a6, a7, arity) {
       
     }
   }
+  if (exit === 1) {
+    return app(o(a0), /* array */[
+                a1,
+                a2,
+                a3,
+                a4,
+                a5,
+                a6,
+                a7
+              ]);
+  }
+  
 }
 
 function _8(o, a0, a1, a2, a3, a4, a5, a6, a7) {
   var arity = o.length;
   if (arity === 8) {
     return o(a0, a1, a2, a3, a4, a5, a6, a7);
-  }
-  else {
+  } else {
     return curry_8(o, a0, a1, a2, a3, a4, a5, a6, a7, arity);
   }
 }
 
-function js8(label, cacheid, a0, a1, a2, a3, a4, a5, a6, a7) {
-  return _8(Caml_oo.caml_get_public_method(a0, label, cacheid), a0, a1, a2, a3, a4, a5, a6, a7);
-}
-
 function __8(o) {
   var arity = o.length;
   if (arity === 8) {
     return o;
-  }
-  else {
+  } else {
     return function (a0, a1, a2, a3, a4, a5, a6, a7) {
       return _8(o, a0, a1, a2, a3, a4, a5, a6, a7);
     };
@@ -14480,38 +14033,29 @@ function __8(o) {
 }
 
 exports.app     = app;
-exports.js      = js;
 exports.curry_1 = curry_1;
 exports._1      = _1;
-exports.js1     = js1;
 exports.__1     = __1;
 exports.curry_2 = curry_2;
 exports._2      = _2;
-exports.js2     = js2;
 exports.__2     = __2;
 exports.curry_3 = curry_3;
 exports._3      = _3;
-exports.js3     = js3;
 exports.__3     = __3;
 exports.curry_4 = curry_4;
 exports._4      = _4;
-exports.js4     = js4;
 exports.__4     = __4;
 exports.curry_5 = curry_5;
 exports._5      = _5;
-exports.js5     = js5;
 exports.__5     = __5;
 exports.curry_6 = curry_6;
 exports._6      = _6;
-exports.js6     = js6;
 exports.__6     = __6;
 exports.curry_7 = curry_7;
 exports._7      = _7;
-exports.js7     = js7;
 exports.__7     = __7;
 exports.curry_8 = curry_8;
 exports._8      = _8;
-exports.js8     = js8;
 exports.__8     = __8;
 /* No side effect */
 //////// end of curry.js ////////
@@ -14522,26 +14066,27 @@ exports.__8     = __8;
   _registry['decode'] = function() {
     let exports = {};
 //////// start of decode.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var F32             = require("./f32");
-var F64             = require("./f64");
-var I32             = require("./i32");
-var Lib             = require("./lib");
-var List            = require("bs-platform/lib/js/list");
-var Block           = require("bs-platform/lib/js/block");
-var Curry           = require("bs-platform/lib/js/curry");
-var $$Error         = require("./error");
-var Encode          = require("./encode");
-var Printf          = require("bs-platform/lib/js/printf");
-var Source          = require("./source");
-var $$String        = require("bs-platform/lib/js/string");
-var Caml_obj        = require("bs-platform/lib/js/caml_obj");
-var Operators       = require("./operators");
-var Caml_int64      = require("bs-platform/lib/js/caml_int64");
-var Caml_string     = require("bs-platform/lib/js/caml_string");
-var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions");
+var F32             = require("./f32.js");
+var F64             = require("./f64.js");
+var I32             = require("./i32.js");
+var Lib             = require("./lib.js");
+var List            = require("bs-platform/lib/js/list.js");
+var Utf8            = require("./utf8.js");
+var Block           = require("bs-platform/lib/js/block.js");
+var Curry           = require("bs-platform/lib/js/curry.js");
+var $$Error         = require("./error.js");
+var Encode          = require("./encode.js");
+var Printf          = require("bs-platform/lib/js/printf.js");
+var Source          = require("./source.js");
+var $$String        = require("bs-platform/lib/js/string.js");
+var Caml_obj        = require("bs-platform/lib/js/caml_obj.js");
+var Operators       = require("./operators.js");
+var Caml_int64      = require("bs-platform/lib/js/caml_int64.js");
+var Caml_string     = require("bs-platform/lib/js/caml_string.js");
+var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions.js");
 
 var EOS = Caml_exceptions.create("Decode.EOS");
 
@@ -14560,8 +14105,7 @@ function eos(s) {
 function check(n, s) {
   if ((s[/* pos */2][0] + n | 0) > s[/* bytes */1].length) {
     throw EOS;
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -14579,8 +14123,7 @@ function read(s) {
 function peek(s) {
   if (eos(s)) {
     return /* None */0;
-  }
-  else {
+  } else {
     return /* Some */[read(s)];
   }
 }
@@ -14637,8 +14180,7 @@ function error(s, pos, msg) {
 function $$require(b, s, pos, msg) {
   if (b) {
     return 0;
-  }
-  else {
+  } else {
     return error(s, pos, msg);
   }
 }
@@ -14650,8 +14192,7 @@ function guard(f, s) {
   catch (exn){
     if (exn === EOS) {
       return error(s, s[/* bytes */1].length, "unexpected end of binary or function");
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -14701,8 +14242,7 @@ function vuN(n, s) {
   var x = Caml_int64.of_int32(b & 127);
   if (b & 128) {
     return Caml_int64.or_(x, Caml_int64.lsl_(vuN(n - 7 | 0, s), 7));
-  }
-  else {
+  } else {
     return x;
   }
 }
@@ -14715,14 +14255,12 @@ function vsN(n, s) {
   var x = Caml_int64.of_int32(b & 127);
   if (b & 128) {
     return Caml_int64.or_(x, Caml_int64.lsl_(vsN(n - 7 | 0, s), 7));
-  }
-  else if (b & 64) {
-    return /* int64 */[
-            /* hi */x[0] | /* hi */-1,
-            /* lo */((x[1] | /* lo */4294967168) >>> 0)
-          ];
-  }
-  else {
+  } else if (b & 64) {
+    return Caml_int64.or_(x, /* int64 */[
+                /* hi */-1,
+                /* lo */4294967168
+              ]);
+  } else {
     return x;
   }
 }
@@ -14752,8 +14290,7 @@ function len32(s) {
   var n = vuN(32, s)[1] | 0;
   if (n <= s[/* bytes */1].length) {
     return n;
-  }
-  else {
+  } else {
     return error(s, pos, "length out of bounds");
   }
 }
@@ -14776,8 +14313,7 @@ function list(f, n, s) {
             x,
             list(f, n - 1 | 0, s)
           ];
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -14785,8 +14321,7 @@ function list(f, n, s) {
 function opt(f, b, s) {
   if (b) {
     return /* Some */[Curry._1(f, s)];
-  }
-  else {
+  } else {
     return /* None */0;
   }
 }
@@ -14796,6 +14331,20 @@ function vec(f, s) {
   return list(f, n, s);
 }
 
+function name(s) {
+  var pos = s[/* pos */2][0];
+  try {
+    return Utf8.decode(string(s));
+  }
+  catch (exn){
+    if (exn === Utf8.Utf8) {
+      return error(s, pos, "invalid UTF-8 encoding");
+    } else {
+      throw exn;
+    }
+  }
+}
+
 function sized(f, s) {
   var size = len32(s);
   var start = s[/* pos */2][0];
@@ -14809,8 +14358,7 @@ function value_type(s) {
   var switcher = match + 4 | 0;
   if (switcher > 3 || switcher < 0) {
     return error(s, s[/* pos */2][0] - 1 | 0, "invalid value type");
-  }
-  else {
+  } else {
     switch (switcher) {
       case 0 : 
           return /* F64Type */3;
@@ -14829,8 +14377,7 @@ function elem_type(s) {
   var match = vsN(7, s)[1] | 0;
   if (match !== -16) {
     return error(s, s[/* pos */2][0] - 1 | 0, "invalid element type");
-  }
-  else {
+  } else {
     return /* AnyFuncType */0;
   }
 }
@@ -14843,15 +14390,13 @@ function stack_type(s) {
               value_type(s),
               /* [] */0
             ];
-    }
-    else {
+    } else {
       guard(function (param) {
             return skip(1, param);
           }, s);
       return /* [] */0;
     }
-  }
-  else {
+  } else {
     return /* :: */[
             value_type(s),
             /* [] */0
@@ -14863,8 +14408,7 @@ function func_type(s) {
   var match = vsN(7, s)[1] | 0;
   if (match !== -32) {
     return error(s, s[/* pos */2][0] - 1 | 0, "invalid function type");
-  }
-  else {
+  } else {
     var ins = vec(value_type, s);
     var out = vec(value_type, s);
     return /* FuncType */[
@@ -14903,12 +14447,10 @@ function mutability(s) {
   if (match !== 0) {
     if (match !== 1) {
       return error(s, s[/* pos */2][0] - 1 | 0, "invalid mutability");
-    }
-    else {
+    } else {
       return /* Mutable */1;
     }
-  }
-  else {
+  } else {
     return /* Immutable */0;
   }
 }
@@ -14941,8 +14483,7 @@ function instr(s) {
   var b = guard(get, s);
   if (b > 191 || b < 0) {
     return illegal(s, pos, b);
-  }
-  else {
+  } else {
     switch (b) {
       case 0 : 
           return Operators.unreachable;
@@ -14966,8 +14507,7 @@ function instr(s) {
             var es2 = List.rev(instr_block$prime(s, /* [] */0));
             expect(11, s, "END opcode expected");
             return Operators.if_(ts$2, es1, es2);
-          }
-          else {
+          } else {
             expect(11, s, "END opcode expected");
             return Operators.if_(ts$2, es1, /* [] */0);
           }
@@ -15379,16 +14919,13 @@ function instr_block$prime(s, _es) {
           ];
           continue ;
           
-        }
-        else {
+        } else {
           return es;
         }
-      }
-      else {
+      } else {
         return es;
       }
-    }
-    else {
+    } else {
       return es;
     }
   };
@@ -15409,8 +14946,7 @@ function id(s) {
   return Curry._2(Lib.Option[/* map */1], function (param) {
               if (param > 11 || param < 0) {
                 return error(s, s[/* pos */2][0], "invalid section id");
-              }
-              else {
+              } else {
                 switch (param) {
                   case 0 : 
                       return /* CustomSection */-808010220;
@@ -15447,8 +14983,7 @@ function section_with_size(tag, f, $$default, s) {
   if (match && Caml_obj.caml_equal(match[0], tag)) {
     guard(get, s);
     return sized(f, s);
-  }
-  else {
+  } else {
     return $$default;
   }
 }
@@ -15465,12 +15000,11 @@ function type_section(s) {
             }, /* [] */0, s);
 }
 
-function import_kind(s) {
+function import_desc(s) {
   var match = guard(get, s);
   if (match > 3 || match < 0) {
     return error(s, s[/* pos */2][0] - 1 | 0, "invalid import kind");
-  }
-  else {
+  } else {
     switch (match) {
       case 0 : 
           return /* FuncImport */Block.__(0, [at($$var, s)]);
@@ -15486,13 +15020,13 @@ function import_kind(s) {
 }
 
 function $$import(s) {
-  var module_name = string(s);
-  var item_name = string(s);
-  var ikind = at(import_kind, s);
+  var module_name = name(s);
+  var item_name = name(s);
+  var idesc = at(import_desc, s);
   return /* record */[
           /* module_name */module_name,
           /* item_name */item_name,
-          /* ikind */ikind
+          /* idesc */idesc
         ];
 }
 
@@ -15538,7 +15072,7 @@ function memory_section(s) {
             }, /* [] */0, s);
 }
 
-function global(s) {
+function $$global(s) {
   var gtype = global_type(s);
   var value = $$const(s);
   return /* record */[
@@ -15550,39 +15084,36 @@ function global(s) {
 function global_section(s) {
   return section(/* GlobalSection */-872313182, function (param) {
               return vec(function (param) {
-                          return at(global, param);
+                          return at($$global, param);
                         }, param);
             }, /* [] */0, s);
 }
 
-function export_kind(s) {
+function export_desc(s) {
   var match = guard(get, s);
   if (match > 3 || match < 0) {
     return error(s, s[/* pos */2][0] - 1 | 0, "invalid export kind");
-  }
-  else {
+  } else {
     switch (match) {
       case 0 : 
-          return /* FuncExport */0;
+          return /* FuncExport */Block.__(0, [at($$var, s)]);
       case 1 : 
-          return /* TableExport */1;
+          return /* TableExport */Block.__(1, [at($$var, s)]);
       case 2 : 
-          return /* MemoryExport */2;
+          return /* MemoryExport */Block.__(2, [at($$var, s)]);
       case 3 : 
-          return /* GlobalExport */3;
+          return /* GlobalExport */Block.__(3, [at($$var, s)]);
       
     }
   }
 }
 
 function $$export(s) {
-  var name = string(s);
-  var ekind = at(export_kind, s);
-  var item = at($$var, s);
+  var name$1 = name(s);
+  var edesc = at(export_desc, s);
   return /* record */[
-          /* name */name,
-          /* ekind */ekind,
-          /* item */item
+          /* name */name$1,
+          /* edesc */edesc
         ];
 }
 
@@ -15668,7 +15199,7 @@ function data_section(s) {
 
 function custom(size, s) {
   var start = s[/* pos */2][0];
-  string(s);
+  name(s);
   var partial_arg = size - (s[/* pos */2][0] - start | 0) | 0;
   var partial_arg$1 = function (param) {
     return skip(partial_arg, param);
@@ -15688,8 +15219,7 @@ function iterate(f, s) {
     if (Curry._1(f, s)) {
       continue ;
       
-    }
-    else {
+    } else {
       return 0;
     }
   };
@@ -15762,22 +15292,23 @@ exports.decode = decode;
   _registry['encode'] = function() {
     let exports = {};
 //////// start of encode.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var F32                     = require("./f32");
-var F64                     = require("./f64");
-var Lib                     = require("./lib");
-var Char                    = require("bs-platform/lib/js/char");
-var List                    = require("bs-platform/lib/js/list");
-var Bytes                   = require("bs-platform/lib/js/bytes");
-var Curry                   = require("bs-platform/lib/js/curry");
-var $$Error                 = require("./error");
-var Buffer                  = require("bs-platform/lib/js/buffer");
-var Source                  = require("./source");
-var Caml_obj                = require("bs-platform/lib/js/caml_obj");
-var Caml_int64              = require("bs-platform/lib/js/caml_int64");
-var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions");
+var F32                     = require("./f32.js");
+var F64                     = require("./f64.js");
+var Lib                     = require("./lib.js");
+var Char                    = require("bs-platform/lib/js/char.js");
+var List                    = require("bs-platform/lib/js/list.js");
+var Utf8                    = require("./utf8.js");
+var Bytes                   = require("bs-platform/lib/js/bytes.js");
+var Curry                   = require("bs-platform/lib/js/curry.js");
+var $$Error                 = require("./error.js");
+var Buffer                  = require("bs-platform/lib/js/buffer.js");
+var Source                  = require("./source.js");
+var Caml_obj                = require("bs-platform/lib/js/caml_obj.js");
+var Caml_int64              = require("bs-platform/lib/js/caml_int64.js");
+var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions.js");
 
 var Code = $$Error.Make(/* module */[]);
 
@@ -15818,7 +15349,10 @@ function encode(m) {
   var vu64 = function (_i) {
     while(true) {
       var i = _i;
-      var b = i[1] & /* lo */127 | 0;
+      var b = Caml_int64.and_(i, /* int64 */[
+              /* hi */0,
+              /* lo */127
+            ])[1] | 0;
       if (Caml_int64.le(/* int64 */[
               /* hi */0,
               /* lo */0
@@ -15827,8 +15361,7 @@ function encode(m) {
               /* lo */128
             ])) {
         return u8(b);
-      }
-      else {
+      } else {
         u8(b | 128);
         _i = Caml_int64.lsr_(i, 7);
         continue ;
@@ -15839,7 +15372,10 @@ function encode(m) {
   var vs64 = function (_i) {
     while(true) {
       var i = _i;
-      var b = i[1] & /* lo */127 | 0;
+      var b = Caml_int64.and_(i, /* int64 */[
+              /* hi */0,
+              /* lo */127
+            ])[1] | 0;
       if (Caml_int64.le(/* int64 */[
               /* hi */-1,
               /* lo */4294967232
@@ -15848,8 +15384,7 @@ function encode(m) {
               /* lo */64
             ])) {
         return u8(b);
-      }
-      else {
+      } else {
         u8(b | 128);
         _i = Caml_int64.asr_(i, 7);
         continue ;
@@ -15895,8 +15430,8 @@ function encode(m) {
       throw [
             Caml_builtin_exceptions.assert_failure,
             [
-              "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-              80,
+              "encode.ml",
+              81,
               6
             ]
           ];
@@ -15936,12 +15471,10 @@ function encode(m) {
     if (param) {
       if (param[1]) {
         return Curry._2(Code[/* error */2], Source.no_region, "cannot encode stack type with arity > 1 (yet)");
-      }
-      else {
+      } else {
         return value_type(param[0]);
       }
-    }
-    else {
+    } else {
       return vs64(/* int64 */[
                   /* hi */-1,
                   /* lo */4294967232
@@ -15977,8 +15510,7 @@ function encode(m) {
     var param$1 = param[1];
     if (param$1 !== 0) {
       return u8(1);
-    }
-    else {
+    } else {
       return u8(0);
     }
   };
@@ -16011,8 +15543,7 @@ function encode(m) {
             return u8(0);
         
       }
-    }
-    else {
+    } else {
       switch (match.tag | 0) {
         case 0 : 
             u8(2);
@@ -16078,8 +15609,7 @@ function encode(m) {
                           if (match$2[1] !== 0) {
                             u8(45);
                             return memop(mo);
-                          }
-                          else {
+                          } else {
                             u8(44);
                             return memop(mo);
                           }
@@ -16087,8 +15617,7 @@ function encode(m) {
                           if (match$2[1] !== 0) {
                             u8(47);
                             return memop(mo);
-                          }
-                          else {
+                          } else {
                             u8(46);
                             return memop(mo);
                           }
@@ -16096,15 +15625,14 @@ function encode(m) {
                           throw [
                                 Caml_builtin_exceptions.assert_failure,
                                 [
-                                  "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                                  182,
+                                  "encode.ml",
+                                  183,
                                   8
                                 ]
                               ];
                       
                     }
-                  }
-                  else {
+                  } else {
                     u8(40);
                     return memop(mo);
                   }
@@ -16118,8 +15646,7 @@ function encode(m) {
                           if (match$4[1] !== 0) {
                             u8(49);
                             return memop(mo);
-                          }
-                          else {
+                          } else {
                             u8(48);
                             return memop(mo);
                           }
@@ -16127,8 +15654,7 @@ function encode(m) {
                           if (match$4[1] !== 0) {
                             u8(51);
                             return memop(mo);
-                          }
-                          else {
+                          } else {
                             u8(50);
                             return memop(mo);
                           }
@@ -16136,15 +15662,13 @@ function encode(m) {
                           if (match$4[1] !== 0) {
                             u8(53);
                             return memop(mo);
-                          }
-                          else {
+                          } else {
                             u8(52);
                             return memop(mo);
                           }
                       
                     }
-                  }
-                  else {
+                  } else {
                     u8(41);
                     return memop(mo);
                   }
@@ -16154,13 +15678,12 @@ function encode(m) {
                     throw [
                           Caml_builtin_exceptions.assert_failure,
                           [
-                            "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                            196,
+                            "encode.ml",
+                            197,
                             8
                           ]
                         ];
-                  }
-                  else {
+                  } else {
                     u8(42);
                     return memop(mo);
                   }
@@ -16170,13 +15693,12 @@ function encode(m) {
                     throw [
                           Caml_builtin_exceptions.assert_failure,
                           [
-                            "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                            196,
+                            "encode.ml",
+                            197,
                             8
                           ]
                         ];
-                  }
-                  else {
+                  } else {
                     u8(43);
                     return memop(mo);
                   }
@@ -16201,15 +15723,14 @@ function encode(m) {
                           throw [
                                 Caml_builtin_exceptions.assert_failure,
                                 [
-                                  "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                                  204,
+                                  "encode.ml",
+                                  205,
                                   52
                                 ]
                               ];
                       
                     }
-                  }
-                  else {
+                  } else {
                     u8(54);
                     return memop(mo$1);
                   }
@@ -16229,8 +15750,7 @@ function encode(m) {
                           return memop(mo$1);
                       
                     }
-                  }
-                  else {
+                  } else {
                     u8(55);
                     return memop(mo$1);
                   }
@@ -16240,13 +15760,12 @@ function encode(m) {
                     throw [
                           Caml_builtin_exceptions.assert_failure,
                           [
-                            "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                            208,
+                            "encode.ml",
+                            209,
                             58
                           ]
                         ];
-                  }
-                  else {
+                  } else {
                     u8(56);
                     return memop(mo$1);
                   }
@@ -16256,13 +15775,12 @@ function encode(m) {
                     throw [
                           Caml_builtin_exceptions.assert_failure,
                           [
-                            "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                            208,
+                            "encode.ml",
+                            209,
                             58
                           ]
                         ];
-                  }
-                  else {
+                  } else {
                     u8(57);
                     return memop(mo$1);
                   }
@@ -16285,7 +15803,10 @@ function encode(m) {
               case 3 : 
                   u8(68);
                   var i = Curry._1(F64.to_bits, match$7[0]);
-                  u32(i[1] & /* lo */4294967295 | 0);
+                  u32(Caml_int64.and_(i, /* int64 */[
+                              /* hi */0,
+                              /* lo */4294967295
+                            ])[1] | 0);
                   return u32(Caml_int64.asr_(i, 32)[1] | 0);
               
             }
@@ -16300,8 +15821,8 @@ function encode(m) {
                   throw [
                         Caml_builtin_exceptions.assert_failure,
                         [
-                          "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                          220,
+                          "encode.ml",
+                          221,
                           24
                         ]
                       ];
@@ -16309,8 +15830,8 @@ function encode(m) {
                   throw [
                         Caml_builtin_exceptions.assert_failure,
                         [
-                          "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                          221,
+                          "encode.ml",
+                          222,
                           24
                         ]
                       ];
@@ -16596,8 +16117,8 @@ function encode(m) {
                         throw [
                               Caml_builtin_exceptions.assert_failure,
                               [
-                                "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                                331,
+                                "encode.ml",
+                                332,
                                 42
                               ]
                             ];
@@ -16605,8 +16126,8 @@ function encode(m) {
                         throw [
                               Caml_builtin_exceptions.assert_failure,
                               [
-                                "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                                332,
+                                "encode.ml",
+                                333,
                                 42
                               ]
                             ];
@@ -16635,8 +16156,8 @@ function encode(m) {
                         throw [
                               Caml_builtin_exceptions.assert_failure,
                               [
-                                "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                                342,
+                                "encode.ml",
+                                343,
                                 39
                               ]
                             ];
@@ -16667,8 +16188,8 @@ function encode(m) {
                         throw [
                               Caml_builtin_exceptions.assert_failure,
                               [
-                                "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                                353,
+                                "encode.ml",
+                                354,
                                 42
                               ]
                             ];
@@ -16695,8 +16216,8 @@ function encode(m) {
                         throw [
                               Caml_builtin_exceptions.assert_failure,
                               [
-                                "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/encode.ml",
-                                362,
+                                "encode.ml",
+                                363,
                                 41
                               ]
                             ];
@@ -16723,8 +16244,7 @@ function encode(m) {
       var p = Buffer.length(s[/* buf */0]);
       Curry._1(f, x);
       return patch_gap32(g, Buffer.length(s[/* buf */0]) - p | 0);
-    }
-    else {
+    } else {
       return 0;
     }
   };
@@ -16735,10 +16255,10 @@ function encode(m) {
   };
   var $$import = function (im) {
     var match = im[/* it */1];
-    string(match[/* module_name */0]);
-    string(match[/* item_name */1]);
-    var k = match[/* ikind */2];
-    var match$1 = k[/* it */1];
+    string(Utf8.encode(match[/* module_name */0]));
+    string(Utf8.encode(match[/* item_name */1]));
+    var d = match[/* idesc */2];
+    var match$1 = d[/* it */1];
     switch (match$1.tag | 0) {
       case 0 : 
           u8(0);
@@ -16786,36 +16306,37 @@ function encode(m) {
                 return vec(memory, param);
               }, mems, +(mems !== /* [] */0));
   };
-  var global = function (g) {
+  var $$global = function (g) {
     var match = g[/* it */1];
     global_type(match[/* gtype */0]);
     return $$const(match[/* value */1]);
   };
   var global_section = function (gs) {
     return section(6, function (param) {
-                return vec(global, param);
+                return vec($$global, param);
               }, gs, +(gs !== /* [] */0));
   };
-  var export_kind = function (k) {
-    var match = k[/* it */1];
-    switch (match) {
+  var $$export = function (ex) {
+    var match = ex[/* it */1];
+    string(Utf8.encode(match[/* name */0]));
+    var d = match[/* edesc */1];
+    var match$1 = d[/* it */1];
+    switch (match$1.tag | 0) {
       case 0 : 
-          return u8(0);
+          u8(0);
+          return vu32(match$1[0][/* it */1]);
       case 1 : 
-          return u8(1);
+          u8(1);
+          return vu32(match$1[0][/* it */1]);
       case 2 : 
-          return u8(2);
+          u8(2);
+          return vu32(match$1[0][/* it */1]);
       case 3 : 
-          return u8(3);
+          u8(3);
+          return vu32(match$1[0][/* it */1]);
       
     }
   };
-  var $$export = function (ex) {
-    var match = ex[/* it */1];
-    string(match[/* name */0]);
-    export_kind(match[/* ekind */1]);
-    return vu32(match[/* item */2][/* it */1]);
-  };
   var export_section = function (exs) {
     return section(7, function (param) {
                 return vec($$export, param);
@@ -16838,8 +16359,7 @@ function encode(m) {
                   ],
                   ts[1]
                 ];
-        }
-        else {
+        } else {
           return /* :: */[
                   /* tuple */[
                     t,
@@ -16848,8 +16368,7 @@ function encode(m) {
                   ts
                 ];
         }
-      }
-      else {
+      } else {
         return /* :: */[
                 /* tuple */[
                   t,
@@ -16900,7 +16419,7 @@ function encode(m) {
   };
   var module_ = function (m) {
     u32(1836278016);
-    u32(13);
+    u32(1);
     type_section(m[/* it */1][/* types */0]);
     import_section(m[/* it */1][/* imports */8]);
     func_section(m[/* it */1][/* funcs */4]);
@@ -16926,7 +16445,7 @@ function encode(m) {
   return Bytes.to_string(bs);
 }
 
-var version = 13;
+var version = 1;
 
 exports.Code    = Code$1;
 exports.version = version;
@@ -16940,11 +16459,11 @@ exports.encode  = encode;
   _registry['error'] = function() {
     let exports = {};
 //////// start of error.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Source          = require("./source");
-var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions");
+var Source          = require("./source.js");
+var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions.js");
 
 function Make() {
   var $$Error = Caml_exceptions.create("Error.Make(*).Error");
@@ -16976,16 +16495,16 @@ exports.Make = Make;
   _registry['f32'] = function() {
     let exports = {};
 //////// start of f32.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Block       = require("bs-platform/lib/js/block");
-var Curry       = require("bs-platform/lib/js/curry");
-var Float       = require("./float");
-var Int32       = require("bs-platform/lib/js/int32");
-var Printf      = require("bs-platform/lib/js/printf");
-var Caml_float  = require("bs-platform/lib/js/caml_float");
-var Caml_format = require("bs-platform/lib/js/caml_format");
+var Block       = require("bs-platform/lib/js/block.js");
+var Curry       = require("bs-platform/lib/js/curry.js");
+var Float       = require("./float.js");
+var Int32       = require("bs-platform/lib/js/int32.js");
+var Printf      = require("bs-platform/lib/js/printf.js");
+var Caml_float  = require("bs-platform/lib/js/caml_float.js");
+var Caml_format = require("bs-platform/lib/js/caml_format.js");
 
 function print_nan_significand_digits(a) {
   return Curry._1(Printf.sprintf(/* Format */[
@@ -17118,16 +16637,16 @@ exports.zero      = zero;
   _registry['f64'] = function() {
     let exports = {};
 //////// start of f64.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Block       = require("bs-platform/lib/js/block");
-var Curry       = require("bs-platform/lib/js/curry");
-var Float       = require("./float");
-var Int64       = require("bs-platform/lib/js/int64");
-var Printf      = require("bs-platform/lib/js/printf");
-var Caml_int64  = require("bs-platform/lib/js/caml_int64");
-var Caml_format = require("bs-platform/lib/js/caml_format");
+var Block       = require("bs-platform/lib/js/block.js");
+var Curry       = require("bs-platform/lib/js/curry.js");
+var Float       = require("./float.js");
+var Int64       = require("bs-platform/lib/js/int64.js");
+var Printf      = require("bs-platform/lib/js/printf.js");
+var Caml_int64  = require("bs-platform/lib/js/caml_int64.js");
+var Caml_format = require("bs-platform/lib/js/caml_format.js");
 
 var bare_nan = /* int64 */[
   /* hi */2146435072,
@@ -17283,16 +16802,16 @@ exports.zero      = zero;
   _registry['float'] = function() {
     let exports = {};
 //////// start of float.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Curry                   = require("bs-platform/lib/js/curry");
-var $$String                = require("bs-platform/lib/js/string");
-var Caml_obj                = require("bs-platform/lib/js/caml_obj");
-var Pervasives              = require("bs-platform/lib/js/pervasives");
-var Caml_format             = require("bs-platform/lib/js/caml_format");
-var Caml_string             = require("bs-platform/lib/js/caml_string");
-var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions");
+var Curry                   = require("bs-platform/lib/js/curry.js");
+var $$String                = require("bs-platform/lib/js/string.js");
+var Caml_obj                = require("bs-platform/lib/js/caml_obj.js");
+var Pervasives              = require("bs-platform/lib/js/pervasives.js");
+var Caml_format             = require("bs-platform/lib/js/caml_format.js");
+var Caml_string             = require("bs-platform/lib/js/caml_string.js");
+var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions.js");
 
 function Make(Rep) {
   var pos_nan = Rep[/* pos_nan */0];
@@ -17327,8 +16846,7 @@ function Make(Rep) {
     var t = Curry._2(op, xf, yf);
     if (t === t) {
       return Curry._1(of_float, t);
-    }
-    else {
+    } else {
       return determine_binary_nan(x, y);
     }
   };
@@ -17336,8 +16854,7 @@ function Make(Rep) {
     var t = Curry._1(op, Curry._1(to_float, x));
     if (t === t) {
       return Curry._1(of_float, t);
-    }
-    else {
+    } else {
       return determine_unary_nan(x);
     }
   };
@@ -17381,14 +16898,12 @@ function Make(Rep) {
     var xf = Curry._1(to_float, x);
     if (xf === 0.0) {
       return x;
-    }
-    else {
+    } else {
       var f = xf < 0.0 ? Math.ceil(xf) : Math.floor(xf);
       var result = Curry._1(of_float, f);
       if (is_nan(result)) {
         return determine_unary_nan(result);
-      }
-      else {
+      } else {
         return result;
       }
     }
@@ -17397,8 +16912,7 @@ function Make(Rep) {
     var xf = Curry._1(to_float, x);
     if (xf === 0.0) {
       return x;
-    }
-    else {
+    } else {
       var u = Math.ceil(xf);
       var d = Math.floor(xf);
       var um = Math.abs(xf - u);
@@ -17409,8 +16923,7 @@ function Make(Rep) {
       var result = Curry._1(of_float, f);
       if (is_nan(result)) {
         return determine_unary_nan(result);
-      }
-      else {
+      } else {
         return result;
       }
     }
@@ -17420,14 +16933,11 @@ function Make(Rep) {
     var yf = Curry._1(to_float, y);
     if (xf === yf) {
       return Curry._2(Rep[/* logor */7], x, y);
-    }
-    else if (xf < yf) {
+    } else if (xf < yf) {
       return x;
-    }
-    else if (xf > yf) {
+    } else if (xf > yf) {
       return y;
-    }
-    else {
+    } else {
       return determine_binary_nan(x, y);
     }
   };
@@ -17436,14 +16946,11 @@ function Make(Rep) {
     var yf = Curry._1(to_float, y);
     if (xf === yf) {
       return Curry._2(Rep[/* logand */6], x, y);
-    }
-    else if (xf > yf) {
+    } else if (xf > yf) {
       return x;
-    }
-    else if (xf < yf) {
+    } else if (xf < yf) {
       return y;
-    }
-    else {
+    } else {
       return determine_binary_nan(x, y);
     }
   };
@@ -17482,24 +16989,20 @@ function Make(Rep) {
               Caml_builtin_exceptions.failure,
               "nan payload must not be zero"
             ];
-      }
-      else if (Caml_obj.caml_notequal(Curry._2(Rep[/* logand */6], s, bare_nan), Rep[/* zero */11])) {
+      } else if (Caml_obj.caml_notequal(Curry._2(Rep[/* logand */6], s, bare_nan), Rep[/* zero */11])) {
         throw [
               Caml_builtin_exceptions.failure,
               "nan payload must not overlap with exponent bits"
             ];
-      }
-      else if (Caml_obj.caml_lessthan(s, Rep[/* zero */11])) {
+      } else if (Caml_obj.caml_lessthan(s, Rep[/* zero */11])) {
         throw [
               Caml_builtin_exceptions.failure,
               "nan payload must not overlap with sign bit"
             ];
-      }
-      else {
+      } else {
         return Curry._2(Rep[/* logor */7], s, bare_nan);
       }
-    }
-    else {
+    } else {
       return Curry._1(of_float, Caml_format.caml_float_of_string(x));
     }
   };
@@ -17507,11 +17010,9 @@ function Make(Rep) {
     var len = x.length;
     if (len > 0 && Caml_string.get(x, 0) === /* "-" */45) {
       return neg(of_signless_string($$String.sub(x, 1, len - 1 | 0), len - 1 | 0));
-    }
-    else if (len > 0 && Caml_string.get(x, 0) === /* "+" */43) {
+    } else if (len > 0 && Caml_string.get(x, 0) === /* "+" */43) {
       return of_signless_string($$String.sub(x, 1, len - 1 | 0), len - 1 | 0);
-    }
-    else {
+    } else {
       return of_signless_string(x, len);
     }
   };
@@ -17568,18 +17069,18 @@ exports.Make = Make;
 //////// start of format.js ////////
 'use strict';
 
-var Block                   = require("./block");
-var Bytes                   = require("./bytes");
-var Curry                   = require("./curry");
-var Buffer                  = require("./buffer");
-var $$String                = require("./string");
-var Caml_io                 = require("./caml_io");
-var Caml_obj                = require("./caml_obj");
-var Pervasives              = require("./pervasives");
-var Caml_string             = require("./caml_string");
-var Caml_exceptions         = require("./caml_exceptions");
-var CamlinternalFormat      = require("./camlinternalFormat");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Block                   = require("./block.js");
+var Bytes                   = require("./bytes.js");
+var Curry                   = require("./curry.js");
+var Buffer                  = require("./buffer.js");
+var $$String                = require("./string.js");
+var Caml_io                 = require("./caml_io.js");
+var Caml_obj                = require("./caml_obj.js");
+var Pervasives              = require("./pervasives.js");
+var Caml_string             = require("./caml_string.js");
+var Caml_exceptions         = require("./caml_exceptions.js");
+var CamlinternalFormat      = require("./camlinternalFormat.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function add_queue(x, q) {
   var c = /* Cons */[/* record */[
@@ -17591,8 +17092,7 @@ function add_queue(x, q) {
     q[/* insert */0] = c;
     match[0][/* tail */1] = c;
     return /* () */0;
-  }
-  else {
+  } else {
     q[/* insert */0] = c;
     q[/* body */1] = c;
     return /* () */0;
@@ -17605,8 +17105,7 @@ function peek_queue(param) {
   var match = param[/* body */1];
   if (match) {
     return match[0][/* head */0];
-  }
-  else {
+  } else {
     throw Empty_queue;
   }
 }
@@ -17622,8 +17121,7 @@ function take_queue(q) {
       q[/* insert */0] = /* Nil */0;
     }
     return x;
-  }
-  else {
+  } else {
     throw Empty_queue;
   }
 }
@@ -17666,15 +17164,12 @@ function pp_force_break_line(state) {
   if (match) {
     var match$1 = match[0];
     var width = match$1[1];
-    var bl_ty = match$1[0];
-    if (width > state[/* pp_space_left */8] && bl_ty !== 0 && bl_ty < 5) {
+    if (width > state[/* pp_space_left */8] && (match$1[0] - 1 >>> 0) <= 3) {
       return break_new_line(state, 0, width);
-    }
-    else {
+    } else {
       return 0;
     }
-  }
-  else {
+  } else {
     return Curry._1(state[/* pp_out_newline */18], /* () */0);
   }
 }
@@ -17694,15 +17189,13 @@ function format_pp_token(state, size, param) {
                           n,
                           ls
                         ];
-                }
-                else {
+                } else {
                   return /* :: */[
                           x,
                           add_tab(n, ls[1])
                         ];
                 }
-              }
-              else {
+              } else {
                 return /* :: */[
                         n,
                         /* [] */0
@@ -17711,8 +17204,7 @@ function format_pp_token(state, size, param) {
             };
             tabs[0] = add_tab(state[/* pp_margin */5] - state[/* pp_space_left */8] | 0, tabs[0]);
             return /* () */0;
-          }
-          else {
+          } else {
             return /* () */0;
           }
           break;
@@ -17721,8 +17213,7 @@ function format_pp_token(state, size, param) {
           if (match$1) {
             state[/* pp_format_stack */1] = match$1[1];
             return /* () */0;
-          }
-          else {
+          } else {
             return /* () */0;
           }
       case 2 : 
@@ -17730,16 +17221,14 @@ function format_pp_token(state, size, param) {
           if (match$2) {
             state[/* pp_tbox_stack */2] = match$2[1];
             return /* () */0;
-          }
-          else {
+          } else {
             return /* () */0;
           }
       case 3 : 
           var match$3 = state[/* pp_format_stack */1];
           if (match$3) {
             return break_new_line(state, 0, match$3[0][1]);
-          }
-          else {
+          } else {
             return Curry._1(state[/* pp_out_newline */18], /* () */0);
           }
       case 4 : 
@@ -17750,8 +17239,7 @@ function format_pp_token(state, size, param) {
             state$1[/* pp_left_total */11] = state$1[/* pp_left_total */11] - match$4[/* length */2] | 0;
             state$1[/* pp_space_left */8] = state$1[/* pp_space_left */8] + size$1 | 0;
             return /* () */0;
-          }
-          else {
+          } else {
             return 0;
           }
       case 5 : 
@@ -17761,15 +17249,13 @@ function format_pp_token(state, size, param) {
             pp_output_string(state, marker);
             state[/* pp_mark_stack */4] = match$5[1];
             return /* () */0;
-          }
-          else {
+          } else {
             return /* () */0;
           }
           break;
       
     }
-  }
-  else {
+  } else {
     switch (param.tag | 0) {
       case 0 : 
           state[/* pp_space_left */8] = state[/* pp_space_left */8] - size | 0;
@@ -17790,15 +17276,13 @@ function format_pp_token(state, size, param) {
               case 3 : 
                   if (size > state[/* pp_space_left */8]) {
                     return break_new_line(state, off, width);
-                  }
-                  else {
+                  } else {
                     return break_same_line(state, n);
                   }
               case 4 : 
                   if (state[/* pp_is_new_line */10] || !(size > state[/* pp_space_left */8] || state[/* pp_current_indent */9] > ((state[/* pp_margin */5] - width | 0) + off | 0))) {
                     return break_same_line(state, n);
-                  }
-                  else {
+                  } else {
                     return break_new_line(state, off, width);
                   }
               case 0 : 
@@ -17806,8 +17290,7 @@ function format_pp_token(state, size, param) {
                   return break_same_line(state, n);
               
             }
-          }
-          else {
+          } else {
             return /* () */0;
           }
           break;
@@ -17823,14 +17306,12 @@ function format_pp_token(state, size, param) {
                   var x = param[0];
                   if (Caml_obj.caml_greaterequal(x, n)) {
                     return x;
-                  }
-                  else {
+                  } else {
                     _param = param[1];
                     continue ;
                     
                   }
-                }
-                else {
+                } else {
                   throw Caml_builtin_exceptions.not_found;
                 }
               };
@@ -17844,24 +17325,20 @@ function format_pp_token(state, size, param) {
               catch (exn){
                 if (exn === Caml_builtin_exceptions.not_found) {
                   tab = match$9[0];
-                }
-                else {
+                } else {
                   throw exn;
                 }
               }
-            }
-            else {
+            } else {
               tab = insertion_point;
             }
             var offset = tab - insertion_point | 0;
             if (offset >= 0) {
               return break_same_line(state, offset + param[0] | 0);
-            }
-            else {
+            } else {
               return break_new_line(state, tab + param[1] | 0, state[/* pp_margin */5]);
             }
-          }
-          else {
+          } else {
             return /* () */0;
           }
           break;
@@ -17911,8 +17388,7 @@ function advance_left(state) {
       var size = match[/* elem_size */0];
       if (size < 0 && (state$1[/* pp_right_total */12] - state$1[/* pp_left_total */11] | 0) < state$1[/* pp_space_left */8]) {
         return 0;
-      }
-      else {
+      } else {
         take_queue(state$1[/* pp_queue */26]);
         format_pp_token(state$1, size < 0 ? 1000000010 : size, match[/* token */1]);
         state$1[/* pp_left_total */11] = match[/* length */2] + state$1[/* pp_left_total */11] | 0;
@@ -17924,8 +17400,7 @@ function advance_left(state) {
   catch (exn){
     if (exn === Empty_queue) {
       return /* () */0;
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -17970,14 +17445,12 @@ function set_size(state, ty) {
     if (match$1[0] < state[/* pp_left_total */11]) {
       state[/* pp_scan_stack */0] = scan_stack_bottom;
       return /* () */0;
-    }
-    else {
+    } else {
       var exit = 0;
       var $js = queue_elem[/* token */1];
       if (typeof $js === "number") {
         return /* () */0;
-      }
-      else {
+      } else {
         switch ($js.tag | 0) {
           case 1 : 
           case 2 : 
@@ -17986,8 +17459,7 @@ function set_size(state, ty) {
           case 3 : 
               if (ty) {
                 return 0;
-              }
-              else {
+              } else {
                 queue_elem[/* elem_size */0] = state[/* pp_right_total */12] + size | 0;
                 state[/* pp_scan_stack */0] = t;
                 return /* () */0;
@@ -18001,15 +17473,13 @@ function set_size(state, ty) {
           queue_elem[/* elem_size */0] = state[/* pp_right_total */12] + size | 0;
           state[/* pp_scan_stack */0] = t;
           return /* () */0;
-        }
-        else {
+        } else {
           return 0;
         }
       }
       
     }
-  }
-  else {
+  } else {
     return /* () */0;
   }
 }
@@ -18041,14 +17511,12 @@ function pp_open_box_gen(state, indent, br_ty) {
       /* length */0
     ];
     return scan_push(state, /* false */0, elem);
-  }
-  else if (state[/* pp_curr_depth */13] === state[/* pp_max_boxes */14]) {
+  } else if (state[/* pp_curr_depth */13] === state[/* pp_max_boxes */14]) {
     var state$1 = state;
     var s = state[/* pp_ellipsis */15];
     var len = s.length;
     return enqueue_string_as(state$1, len, s);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18066,8 +17534,7 @@ function pp_close_box(state, _) {
     }
     state[/* pp_curr_depth */13] = state[/* pp_curr_depth */13] - 1 | 0;
     return /* () */0;
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18086,8 +17553,7 @@ function pp_open_tag(state, tag_name) {
                 /* token : Pp_open_tag */Block.__(5, [tag_name]),
                 /* length */0
               ]);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18106,12 +17572,10 @@ function pp_close_tag(state, _) {
       Curry._1(state[/* pp_print_close_tag */25], match[0]);
       state[/* pp_tag_stack */3] = match[1];
       return /* () */0;
-    }
-    else {
+    } else {
       return /* () */0;
     }
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18185,8 +17649,7 @@ function pp_flush_queue(state, b) {
 function pp_print_as_size(state, size, s) {
   if (state[/* pp_curr_depth */13] < state[/* pp_max_boxes */14]) {
     return enqueue_string_as(state, size, s);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18250,8 +17713,7 @@ function pp_force_newline(state, _) {
                 /* token : Pp_newline */3,
                 /* length */0
               ]);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18263,8 +17725,7 @@ function pp_print_if_newline(state, _) {
                 /* token : Pp_if_newline */4,
                 /* length */0
               ]);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18280,8 +17741,7 @@ function pp_print_break(state, width, offset) {
       /* length */width
     ];
     return scan_push(state, /* true */1, elem);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18303,8 +17763,7 @@ function pp_open_tbox(state, _) {
       /* length */0
     ];
     return enqueue_advance(state, elem);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18320,12 +17779,10 @@ function pp_close_tbox(state, _) {
       enqueue_advance(state, elem);
       state[/* pp_curr_depth */13] = state[/* pp_curr_depth */13] - 1 | 0;
       return /* () */0;
-    }
-    else {
+    } else {
       return 0;
     }
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18341,8 +17798,7 @@ function pp_print_tbreak(state, width, offset) {
       /* length */width
     ];
     return scan_push(state, /* true */1, elem);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18359,8 +17815,7 @@ function pp_set_tab(state, _) {
       /* length */0
     ];
     return enqueue_advance(state, elem);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18380,12 +17835,10 @@ function pp_print_list(_$staropt$star, pp_v, ppf, _param) {
         _$staropt$star = /* Some */[pp_sep];
         continue ;
         
-      }
-      else {
+      } else {
         return Curry._2(pp_v, ppf, v);
       }
-    }
-    else {
+    } else {
       return /* () */0;
     }
   };
@@ -18406,21 +17859,18 @@ function pp_print_text(ppf, s) {
     if (match !== 10) {
       if (match !== 32) {
         right[0] = right[0] + 1 | 0;
-      }
-      else {
+      } else {
         flush(/* () */0);
         pp_print_break(ppf, 1, 0);
       }
-    }
-    else {
+    } else {
       flush(/* () */0);
       pp_force_newline(ppf, /* () */0);
     }
   };
   if (left[0] !== len) {
     return flush(/* () */0);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18429,8 +17879,7 @@ function pp_set_max_boxes(state, n) {
   if (n > 1) {
     state[/* pp_max_boxes */14] = n;
     return /* () */0;
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18455,8 +17904,7 @@ function pp_get_ellipsis_text(state, _) {
 function pp_limit(n) {
   if (n < 1000000010) {
     return n;
-  }
-  else {
+  } else {
     return 1000000009;
   }
 }
@@ -18469,8 +17917,7 @@ function pp_set_max_indent(state, n) {
     state$1[/* pp_min_space_left */6] = n$2;
     state$1[/* pp_max_indent */7] = state$1[/* pp_margin */5] - state$1[/* pp_min_space_left */6] | 0;
     return pp_rinit(state$1);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18485,8 +17932,7 @@ function pp_set_margin(state, n) {
     state[/* pp_margin */5] = n$1;
     var new_max_indent = state[/* pp_max_indent */7] <= state[/* pp_margin */5] ? state[/* pp_max_indent */7] : Pervasives.max(Pervasives.max(state[/* pp_margin */5] - state[/* pp_min_space_left */6] | 0, state[/* pp_margin */5] / 2 | 0), 1);
     return pp_set_max_indent(state, new_max_indent);
-  }
-  else {
+  } else {
     return 0;
   }
 }
@@ -18553,15 +17999,13 @@ function display_blanks(state, _n) {
     if (n > 0) {
       if (n <= 80) {
         return Curry._3(state[/* pp_out_string */16], blank_line, 0, n);
-      }
-      else {
+      } else {
         Curry._3(state[/* pp_out_string */16], blank_line, 0, 80);
         _n = n - 80 | 0;
         continue ;
         
       }
-    }
-    else {
+    } else {
       return 0;
     }
   };
@@ -18912,8 +18356,7 @@ function compute_tag(output, tag_acc) {
   var len = buf[/* position */1];
   if (len < 2) {
     return Buffer.contents(buf);
-  }
-  else {
+  } else {
     return Buffer.sub(buf, 1, len - 2 | 0);
   }
 }
@@ -18937,8 +18380,7 @@ function output_formatting_lit(ppf, fmting_lit) {
           return pp_print_char(ppf, /* "%" */37);
       
     }
-  }
-  else {
+  } else {
     switch (fmting_lit.tag | 0) {
       case 0 : 
           return pp_print_break(ppf, fmting_lit[1], fmting_lit[2]);
@@ -18962,8 +18404,7 @@ function output_acc(ppf, acc) {
   var c;
   if (typeof acc === "number") {
     return /* () */0;
-  }
-  else {
+  } else {
     switch (acc.tag | 0) {
       case 0 : 
           output_acc(ppf, acc[0]);
@@ -18975,8 +18416,7 @@ function output_acc(ppf, acc) {
           if (match.tag) {
             var match$1 = CamlinternalFormat.open_box_of_string(compute_tag(output_acc, match[0]));
             return pp_open_box_gen(ppf, match$1[0], match$1[1]);
-          }
-          else {
+          } else {
             return pp_open_tag(ppf, compute_tag(output_acc, match[0]));
           }
           break;
@@ -18985,22 +18425,18 @@ function output_acc(ppf, acc) {
           var exit$1 = 0;
           if (typeof p$3 === "number") {
             exit$1 = 3;
-          }
-          else if (p$3.tag) {
+          } else if (p$3.tag) {
             exit$1 = 3;
-          }
-          else {
+          } else {
             var match$2 = p$3[1];
             if (typeof match$2 === "number") {
               exit$1 = 3;
-            }
-            else if (match$2.tag === 1) {
+            } else if (match$2.tag === 1) {
               p = p$3[0];
               size = match$2[1];
               s = acc[1];
               exit = 1;
-            }
-            else {
+            } else {
               exit$1 = 3;
             }
           }
@@ -19014,22 +18450,18 @@ function output_acc(ppf, acc) {
           var exit$2 = 0;
           if (typeof p$4 === "number") {
             exit$2 = 3;
-          }
-          else if (p$4.tag) {
+          } else if (p$4.tag) {
             exit$2 = 3;
-          }
-          else {
+          } else {
             var match$3 = p$4[1];
             if (typeof match$3 === "number") {
               exit$2 = 3;
-            }
-            else if (match$3.tag === 1) {
+            } else if (match$3.tag === 1) {
               p$1 = p$4[0];
               size$1 = match$3[1];
               c = acc[1];
               exit = 2;
-            }
-            else {
+            } else {
               exit$2 = 3;
             }
           }
@@ -19043,22 +18475,18 @@ function output_acc(ppf, acc) {
           var exit$3 = 0;
           if (typeof p$5 === "number") {
             exit$3 = 3;
-          }
-          else if (p$5.tag) {
+          } else if (p$5.tag) {
             exit$3 = 3;
-          }
-          else {
+          } else {
             var match$4 = p$5[1];
             if (typeof match$4 === "number") {
               exit$3 = 3;
-            }
-            else if (match$4.tag === 1) {
+            } else if (match$4.tag === 1) {
               p = p$5[0];
               size = match$4[1];
               s = acc[1];
               exit = 1;
-            }
-            else {
+            } else {
               exit$3 = 3;
             }
           }
@@ -19072,22 +18500,18 @@ function output_acc(ppf, acc) {
           var exit$4 = 0;
           if (typeof p$6 === "number") {
             exit$4 = 3;
-          }
-          else if (p$6.tag) {
+          } else if (p$6.tag) {
             exit$4 = 3;
-          }
-          else {
+          } else {
             var match$5 = p$6[1];
             if (typeof match$5 === "number") {
               exit$4 = 3;
-            }
-            else if (match$5.tag === 1) {
+            } else if (match$5.tag === 1) {
               p$1 = p$6[0];
               size$1 = match$5[1];
               c = acc[1];
               exit = 2;
-            }
-            else {
+            } else {
               exit$4 = 3;
             }
           }
@@ -19132,8 +18556,7 @@ function strput_acc(ppf, acc) {
   var c;
   if (typeof acc === "number") {
     return /* () */0;
-  }
-  else {
+  } else {
     switch (acc.tag | 0) {
       case 0 : 
           strput_acc(ppf, acc[0]);
@@ -19145,8 +18568,7 @@ function strput_acc(ppf, acc) {
           if (match.tag) {
             var match$1 = CamlinternalFormat.open_box_of_string(compute_tag(strput_acc, match[0]));
             return pp_open_box_gen(ppf, match$1[0], match$1[1]);
-          }
-          else {
+          } else {
             return pp_open_tag(ppf, compute_tag(strput_acc, match[0]));
           }
           break;
@@ -19155,22 +18577,18 @@ function strput_acc(ppf, acc) {
           var exit$1 = 0;
           if (typeof p$3 === "number") {
             exit$1 = 3;
-          }
-          else if (p$3.tag) {
+          } else if (p$3.tag) {
             exit$1 = 3;
-          }
-          else {
+          } else {
             var match$2 = p$3[1];
             if (typeof match$2 === "number") {
               exit$1 = 3;
-            }
-            else if (match$2.tag === 1) {
+            } else if (match$2.tag === 1) {
               p = p$3[0];
               size = match$2[1];
               s = acc[1];
               exit = 1;
-            }
-            else {
+            } else {
               exit$1 = 3;
             }
           }
@@ -19184,22 +18602,18 @@ function strput_acc(ppf, acc) {
           var exit$2 = 0;
           if (typeof p$4 === "number") {
             exit$2 = 3;
-          }
-          else if (p$4.tag) {
+          } else if (p$4.tag) {
             exit$2 = 3;
-          }
-          else {
+          } else {
             var match$3 = p$4[1];
             if (typeof match$3 === "number") {
               exit$2 = 3;
-            }
-            else if (match$3.tag === 1) {
+            } else if (match$3.tag === 1) {
               p$1 = p$4[0];
               size$1 = match$3[1];
               c = acc[1];
               exit = 2;
-            }
-            else {
+            } else {
               exit$2 = 3;
             }
           }
@@ -19213,22 +18627,18 @@ function strput_acc(ppf, acc) {
           var exit$3 = 0;
           if (typeof p$5 === "number") {
             exit$3 = 3;
-          }
-          else if (p$5.tag) {
+          } else if (p$5.tag) {
             exit$3 = 3;
-          }
-          else {
+          } else {
             var match$4 = p$5[1];
             if (typeof match$4 === "number") {
               exit$3 = 3;
-            }
-            else if (match$4.tag === 1) {
+            } else if (match$4.tag === 1) {
               p = p$5[0];
               size = match$4[1];
               s = acc[1];
               exit = 1;
-            }
-            else {
+            } else {
               exit$3 = 3;
             }
           }
@@ -19242,22 +18652,18 @@ function strput_acc(ppf, acc) {
           var exit$4 = 0;
           if (typeof p$6 === "number") {
             exit$4 = 3;
-          }
-          else if (p$6.tag) {
+          } else if (p$6.tag) {
             exit$4 = 3;
-          }
-          else {
+          } else {
             var match$5 = p$6[1];
             if (typeof match$5 === "number") {
               exit$4 = 3;
-            }
-            else if (match$5.tag === 1) {
+            } else if (match$5.tag === 1) {
               p$1 = p$6[0];
               size$1 = match$5[1];
               c = acc[1];
               exit = 2;
-            }
-            else {
+            } else {
               exit$4 = 3;
             }
           }
@@ -19271,20 +18677,16 @@ function strput_acc(ppf, acc) {
           var exit$5 = 0;
           if (typeof p$7 === "number") {
             exit$5 = 3;
-          }
-          else if (p$7.tag) {
+          } else if (p$7.tag) {
             exit$5 = 3;
-          }
-          else {
+          } else {
             var match$6 = p$7[1];
             if (typeof match$6 === "number") {
               exit$5 = 3;
-            }
-            else if (match$6.tag === 1) {
+            } else if (match$6.tag === 1) {
               strput_acc(ppf, p$7[0]);
               return pp_print_as_size(ppf, match$6[1], Curry._1(acc[1], /* () */0));
-            }
-            else {
+            } else {
               exit$5 = 3;
             }
           }
@@ -19516,12 +18918,12 @@ exports.pp_get_all_formatter_output_functions = pp_get_all_formatter_output_func
   _registry['i32'] = function() {
     let exports = {};
 //////// start of i32.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Int        = require("./int");
-var Int32      = require("bs-platform/lib/js/int32");
-var Caml_int32 = require("bs-platform/lib/js/caml_int32");
+var Int        = require("./int.js");
+var Int32      = require("bs-platform/lib/js/int32.js");
+var Caml_int32 = require("bs-platform/lib/js/caml_int32.js");
 
 var include = Int.Make(/* module */[
       /* zero */Int32.zero,
@@ -19696,12 +19098,12 @@ exports.to_string_u = to_string_u;
   _registry['i64'] = function() {
     let exports = {};
 //////// start of i64.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Int        = require("./int");
-var Int64      = require("bs-platform/lib/js/int64");
-var Caml_int64 = require("bs-platform/lib/js/caml_int64");
+var Int        = require("./int.js");
+var Int64      = require("bs-platform/lib/js/int64.js");
+var Caml_int64 = require("bs-platform/lib/js/caml_int64.js");
 
 var include = Int.Make(/* module */[
       /* zero */Int64.zero,
@@ -19873,8 +19275,8 @@ exports.to_string_u = to_string_u;
 //////// start of int32.js ////////
 'use strict';
 
-var Caml_obj    = require("./caml_obj");
-var Caml_format = require("./caml_format");
+var Caml_obj    = require("./caml_obj.js");
+var Caml_format = require("./caml_format.js");
 
 function succ(n) {
   return n + 1 | 0;
@@ -19887,8 +19289,7 @@ function pred(n) {
 function abs(n) {
   if (n >= 0) {
     return n;
-  }
-  else {
+  } else {
     return -n | 0;
   }
 }
@@ -19935,8 +19336,8 @@ exports.compare   = compare;
 //////// start of int64.js ////////
 'use strict';
 
-var Caml_int64  = require("./caml_int64");
-var Caml_format = require("./caml_format");
+var Caml_int64  = require("./caml_int64.js");
+var Caml_format = require("./caml_format.js");
 
 function succ(n) {
   return Caml_int64.add(n, /* int64 */[
@@ -19958,17 +19359,16 @@ function abs(n) {
           /* lo */0
         ])) {
     return n;
-  }
-  else {
+  } else {
     return Caml_int64.neg(n);
   }
 }
 
 function lognot(n) {
-  return /* int64 */[
-          /* hi */n[0] ^ /* hi */-1,
-          /* lo */((n[1] ^ /* lo */4294967295) >>> 0)
-        ];
+  return Caml_int64.xor(n, /* int64 */[
+              /* hi */-1,
+              /* lo */4294967295
+            ]);
 }
 
 function to_string(n) {
@@ -20022,14 +19422,14 @@ exports.compare   = compare;
   _registry['int'] = function() {
     let exports = {};
 //////// start of int.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Curry         = require("bs-platform/lib/js/curry");
-var Caml_obj      = require("bs-platform/lib/js/caml_obj");
-var Pervasives    = require("bs-platform/lib/js/pervasives");
-var Caml_string   = require("bs-platform/lib/js/caml_string");
-var Numeric_error = require("./numeric_error");
+var Curry         = require("bs-platform/lib/js/curry.js");
+var Caml_obj      = require("bs-platform/lib/js/caml_obj.js");
+var Pervasives    = require("bs-platform/lib/js/pervasives.js");
+var Caml_string   = require("bs-platform/lib/js/caml_string.js");
+var Numeric_error = require("./numeric_error.js");
 
 function Make(Rep) {
   var cmp_u = function (x, op, y) {
@@ -20038,8 +19438,7 @@ function Make(Rep) {
   var divrem_u = function (n, d) {
     if (Caml_obj.caml_equal(d, Rep[/* zero */0])) {
       throw Numeric_error.IntegerDivideByZero;
-    }
-    else {
+    } else {
       var t = Curry._2(Rep[/* shift_right */16], d, Rep[/* bitwidth */21] - 1 | 0);
       var n$prime = Curry._2(Rep[/* logand */11], n, Curry._1(Rep[/* lognot */12], t));
       var q = Curry._2(Rep[/* shift_left */15], Curry._2(Rep[/* div */9], Curry._2(Rep[/* shift_right_logical */17], n$prime, 1), d), 1);
@@ -20049,8 +19448,7 @@ function Make(Rep) {
                 q,
                 r
               ];
-      }
-      else {
+      } else {
         return /* tuple */[
                 Curry._2(Rep[/* add */6], q, Rep[/* one */1]),
                 Curry._2(Rep[/* sub */7], r, d)
@@ -20073,11 +19471,9 @@ function Make(Rep) {
   var div_s = function (x, y) {
     if (Caml_obj.caml_equal(y, Rep[/* zero */0])) {
       throw Numeric_error.IntegerDivideByZero;
-    }
-    else if (Caml_obj.caml_equal(x, Rep[/* min_int */4]) && Caml_obj.caml_equal(y, Rep[/* minus_one */2])) {
+    } else if (Caml_obj.caml_equal(x, Rep[/* min_int */4]) && Caml_obj.caml_equal(y, Rep[/* minus_one */2])) {
       throw Numeric_error.IntegerOverflow;
-    }
-    else {
+    } else {
       return Curry._2(Rep[/* div */9], x, y);
     }
   };
@@ -20087,8 +19483,7 @@ function Make(Rep) {
   var rem_s = function (x, y) {
     if (Caml_obj.caml_equal(y, Rep[/* zero */0])) {
       throw Numeric_error.IntegerDivideByZero;
-    }
-    else {
+    } else {
       return Curry._2(Rep[/* rem */10], x, y);
     }
   };
@@ -20128,14 +19523,12 @@ function Make(Rep) {
         var acc = _acc;
         if (Caml_obj.caml_equal(n, Rep[/* zero */0])) {
           return Rep[/* bitwidth */21];
-        }
-        else if (Caml_obj.caml_equal(Curry._2(and_, n, Curry._2(Rep[/* shift_left */15], Rep[/* one */1], Rep[/* bitwidth */21] - 1 | 0)), Rep[/* zero */0])) {
+        } else if (Caml_obj.caml_equal(Curry._2(and_, n, Curry._2(Rep[/* shift_left */15], Rep[/* one */1], Rep[/* bitwidth */21] - 1 | 0)), Rep[/* zero */0])) {
           _n = Curry._2(Rep[/* shift_left */15], n, 1);
           _acc = 1 + acc | 0;
           continue ;
           
-        }
-        else {
+        } else {
           return acc;
         }
       };
@@ -20149,11 +19542,9 @@ function Make(Rep) {
         var acc = _acc;
         if (Caml_obj.caml_equal(n, Rep[/* zero */0])) {
           return Rep[/* bitwidth */21];
-        }
-        else if (Caml_obj.caml_equal(Curry._2(and_, n, Rep[/* one */1]), Rep[/* one */1])) {
+        } else if (Caml_obj.caml_equal(Curry._2(and_, n, Rep[/* one */1]), Rep[/* one */1])) {
           return acc;
-        }
-        else {
+        } else {
           _n = Curry._2(Rep[/* shift_right_logical */17], n, 1);
           _acc = 1 + acc | 0;
           continue ;
@@ -20171,8 +19562,7 @@ function Make(Rep) {
         var acc = _acc;
         if (Caml_obj.caml_equal(n, Rep[/* zero */0])) {
           return acc;
-        }
-        else {
+        } else {
           var acc$prime = Caml_obj.caml_equal(Curry._2(and_, n, Rep[/* one */1]), Rep[/* one */1]) ? acc + 1 | 0 : acc;
           _n = Curry._2(Rep[/* shift_right_logical */17], n, 1);
           _i = i - 1 | 0;
@@ -20213,24 +19603,21 @@ function Make(Rep) {
   var to_string_u = function (i) {
     if (Caml_obj.caml_greaterequal(i, Rep[/* zero */0])) {
       return Curry._1(to_string_s, i);
-    }
-    else {
+    } else {
       return Curry._1(to_string_s, div_u(i, ten)) + Curry._1(to_string_s, rem_u(i, ten));
     }
   };
   var $$require = function (b) {
     if (b) {
       return 0;
-    }
-    else {
+    } else {
       return Pervasives.failwith("of_string");
     }
   };
   var dec_digit = function (c) {
     if (c > 57 || c < 48) {
       return Pervasives.failwith("of_string");
-    }
-    else {
+    } else {
       return c - /* "0" */48 | 0;
     }
   };
@@ -20239,22 +19626,17 @@ function Make(Rep) {
       if (c >= 97) {
         if (c >= 103) {
           return Pervasives.failwith("of_string");
-        }
-        else {
+        } else {
           return (10 + c | 0) - /* "a" */97 | 0;
         }
-      }
-      else if (c >= 71) {
+      } else if (c >= 71) {
         return Pervasives.failwith("of_string");
-      }
-      else {
+      } else {
         return (10 + c | 0) - /* "A" */65 | 0;
       }
-    }
-    else if (c > 57 || c < 48) {
+    } else if (c > 57 || c < 48) {
       return Pervasives.failwith("of_string");
-    }
-    else {
+    } else {
       return c - /* "0" */48 | 0;
     }
   };
@@ -20273,8 +19655,7 @@ function Make(Rep) {
           var i$1 = _i;
           if (i$1 === len) {
             return num;
-          }
-          else {
+          } else {
             var digit = Curry._1(Rep[/* of_int */18], hex_digit(Caml_string.get(s, i$1)));
             $$require(le_u(num, shr_u(Rep[/* minus_one */2], Curry._1(Rep[/* of_int */18], 4))));
             _num = Curry._2(Rep[/* logor */13], Curry._2(Rep[/* shift_left */15], num, 4), digit);
@@ -20283,8 +19664,7 @@ function Make(Rep) {
             
           }
         };
-      }
-      else {
+      } else {
         var _i$1 = i;
         var _num$1 = Rep[/* zero */0];
         while(true) {
@@ -20292,8 +19672,7 @@ function Make(Rep) {
           var i$2 = _i$1;
           if (i$2 === len) {
             return num$1;
-          }
-          else {
+          } else {
             var digit$1 = Curry._1(Rep[/* of_int */18], dec_digit(Caml_string.get(s, i$2)));
             $$require(lt_u(num$1, max_upper) || Caml_obj.caml_equal(num$1, max_upper) && le_u(digit$1, max_lower));
             _num$1 = Curry._2(Rep[/* add */6], Curry._2(Rep[/* mul */8], num$1, ten), digit$1);
@@ -20309,8 +19688,7 @@ function Make(Rep) {
     var switcher = match - 43 | 0;
     if (switcher > 2 || switcher < 0) {
       return parse_int(0);
-    }
-    else {
+    } else {
       switch (switcher) {
         case 0 : 
             return parse_int(1);
@@ -20384,51 +19762,196 @@ exports.Make = Make;
   };
 
 
-  _registry['lexer'] = function() {
+  _registry['js_exn'] = function() {
     let exports = {};
-//////// start of lexer.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+//////// start of js_exn.js ////////
 'use strict';
 
-var F32                     = require("./f32");
-var F64                     = require("./f64");
-var I32                     = require("./i32");
-var I64                     = require("./i64");
-var Lib                     = require("./lib");
-var Char                    = require("bs-platform/lib/js/char");
-var Block                   = require("bs-platform/lib/js/block");
-var Curry                   = require("bs-platform/lib/js/curry");
-var Buffer                  = require("bs-platform/lib/js/buffer");
-var Lexing                  = require("bs-platform/lib/js/lexing");
-var Script                  = require("./script");
-var Source                  = require("./source");
-var $$String                = require("bs-platform/lib/js/string");
-var Operators               = require("./operators");
-var Caml_format             = require("bs-platform/lib/js/caml_format");
-var Caml_string             = require("bs-platform/lib/js/caml_string");
-var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions");
+var Caml_exceptions = require("./caml_exceptions.js");
 
-function convert_pos(pos) {
-  return /* record */[
-          /* file */pos[/* pos_fname */0],
-          /* line */pos[/* pos_lnum */1],
-          /* column */pos[/* pos_cnum */3] - pos[/* pos_bol */2] | 0
-        ];
+var $$Error = Caml_exceptions.create("Js_exn.Error");
+
+function internalToOCamlException(e) {
+  if (Caml_exceptions.isCamlExceptionOrOpenVariant(e)) {
+    return e;
+  } else {
+    return [
+            $$Error,
+            e
+          ];
+  }
 }
 
-function region(lexbuf) {
-  var left = convert_pos(Lexing.lexeme_start_p(lexbuf));
-  var right = convert_pos(Lexing.lexeme_end_p(lexbuf));
-  return /* record */[
-          /* left */left,
-          /* right */right
-        ];
+function raiseError(str) {
+  throw new Error(str);
 }
 
-function error(lexbuf, msg) {
-  throw [
-        Script.Syntax,
-        region(lexbuf),
+function raiseEvalError(str) {
+  throw new EvalError(str);
+}
+
+function raiseRangeError(str) {
+  throw new RangeError(str);
+}
+
+function raiseReferenceError(str) {
+  throw new RerferenceError(str);
+}
+
+function raiseSyntaxError(str) {
+  throw new SyntaxError(str);
+}
+
+function raiseTypeError(str) {
+  throw new TypeError(str);
+}
+
+function raiseUriError(str) {
+  throw new URIError(str);
+}
+
+exports.$$Error                  = $$Error;
+exports.internalToOCamlException = internalToOCamlException;
+exports.raiseError               = raiseError;
+exports.raiseEvalError           = raiseEvalError;
+exports.raiseRangeError          = raiseRangeError;
+exports.raiseReferenceError      = raiseReferenceError;
+exports.raiseSyntaxError         = raiseSyntaxError;
+exports.raiseTypeError           = raiseTypeError;
+exports.raiseUriError            = raiseUriError;
+/* No side effect */
+//////// end of js_exn.js ////////
+    return exports;
+  };
+
+
+  _registry['js'] = function() {
+    let exports = {};
+//////// start of js.js ////////
+'use strict';
+
+
+var Null = 0;
+
+var Undefined = 0;
+
+var Null_undefined = 0;
+
+var Exn = 0;
+
+var $$Array = 0;
+
+var $$String = 0;
+
+var $$Boolean = 0;
+
+var Re = 0;
+
+var Promise = 0;
+
+var $$Date = 0;
+
+var Dict = 0;
+
+var Global = 0;
+
+var Json = 0;
+
+var $$Math = 0;
+
+var Obj = 0;
+
+var Typed_array = 0;
+
+var Types = 0;
+
+var Float = 0;
+
+var Int = 0;
+
+var Option = 0;
+
+var Result = 0;
+
+var List = 0;
+
+var Vector = 0;
+
+exports.Null           = Null;
+exports.Undefined      = Undefined;
+exports.Null_undefined = Null_undefined;
+exports.Exn            = Exn;
+exports.$$Array        = $$Array;
+exports.$$String       = $$String;
+exports.$$Boolean      = $$Boolean;
+exports.Re             = Re;
+exports.Promise        = Promise;
+exports.$$Date         = $$Date;
+exports.Dict           = Dict;
+exports.Global         = Global;
+exports.Json           = Json;
+exports.$$Math         = $$Math;
+exports.Obj            = Obj;
+exports.Typed_array    = Typed_array;
+exports.Types          = Types;
+exports.Float          = Float;
+exports.Int            = Int;
+exports.Option         = Option;
+exports.Result         = Result;
+exports.List           = List;
+exports.Vector         = Vector;
+/* No side effect */
+//////// end of js.js ////////
+    return exports;
+  };
+
+
+  _registry['lexer'] = function() {
+    let exports = {};
+//////// start of lexer.js ////////
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
+'use strict';
+
+var F32                     = require("./f32.js");
+var F64                     = require("./f64.js");
+var I32                     = require("./i32.js");
+var I64                     = require("./i64.js");
+var Lib                     = require("./lib.js");
+var Char                    = require("bs-platform/lib/js/char.js");
+var Utf8                    = require("./utf8.js");
+var Block                   = require("bs-platform/lib/js/block.js");
+var Curry                   = require("bs-platform/lib/js/curry.js");
+var Buffer                  = require("bs-platform/lib/js/buffer.js");
+var Lexing                  = require("bs-platform/lib/js/lexing.js");
+var Script                  = require("./script.js");
+var Source                  = require("./source.js");
+var $$String                = require("bs-platform/lib/js/string.js");
+var Operators               = require("./operators.js");
+var Caml_format             = require("bs-platform/lib/js/caml_format.js");
+var Caml_string             = require("bs-platform/lib/js/caml_string.js");
+var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions.js");
+
+function convert_pos(pos) {
+  return /* record */[
+          /* file */pos[/* pos_fname */0],
+          /* line */pos[/* pos_lnum */1],
+          /* column */pos[/* pos_cnum */3] - pos[/* pos_bol */2] | 0
+        ];
+}
+
+function region(lexbuf) {
+  var left = convert_pos(Lexing.lexeme_start_p(lexbuf));
+  var right = convert_pos(Lexing.lexeme_end_p(lexbuf));
+  return /* record */[
+          /* left */left,
+          /* right */right
+        ];
+}
+
+function error(lexbuf, msg) {
+  throw [
+        Script.Syntax,
+        region(lexbuf),
         msg
       ];
 }
@@ -20438,50 +19961,69 @@ function error_nest(start, lexbuf, msg) {
   return error(lexbuf, msg);
 }
 
-function text(s) {
+function string(s) {
   var b = Buffer.create(s.length);
   var i = 1;
   while(i < (s.length - 1 | 0)) {
     var c;
     if (Caml_string.get(s, i) !== /* "\\" */92) {
       c = Caml_string.get(s, i);
-    }
-    else {
+    } else {
       i = i + 1 | 0;
-      var d = Caml_string.get(s, i);
+      var h = Caml_string.get(s, i);
       var exit = 0;
-      if (d >= 92) {
-        if (d !== 110) {
-          if (d !== 116) {
-            if (d >= 93) {
-              exit = 1;
-            }
-            else {
-              c = /* "\\" */92;
+      if (h >= 40) {
+        if (h >= 110) {
+          if (h >= 118) {
+            exit = 1;
+          } else {
+            switch (h - 110 | 0) {
+              case 0 : 
+                  c = /* "\n" */10;
+                  break;
+              case 4 : 
+                  c = /* "\r" */13;
+                  break;
+              case 1 : 
+              case 2 : 
+              case 3 : 
+              case 5 : 
+                  exit = 1;
+                  break;
+              case 6 : 
+                  c = /* "\t" */9;
+                  break;
+              case 7 : 
+                  var j = i + 2 | 0;
+                  i = $$String.index_from(s, j, /* "}" */125);
+                  var n = Caml_format.caml_int_of_string("0x" + $$String.sub(s, j, i - j | 0));
+                  var bs = Utf8.encode(/* :: */[
+                        n,
+                        /* [] */0
+                      ]);
+                  Buffer.add_substring(b, bs, 0, bs.length - 1 | 0);
+                  c = Caml_string.get(bs, bs.length - 1 | 0);
+                  break;
+              
             }
           }
-          else {
-            c = /* "\t" */9;
-          }
-        }
-        else {
-          c = /* "\n" */10;
-        }
-      }
-      else if (d !== 34) {
-        if (d !== 39) {
+        } else if (h !== 92) {
           exit = 1;
+        } else {
+          c = /* "\\" */92;
         }
-        else {
+      } else if (h !== 34) {
+        if (h >= 39) {
           c = /* "'" */39;
+        } else {
+          exit = 1;
         }
-      }
-      else {
+      } else {
         c = /* "\"" */34;
       }
       if (exit === 1) {
         i = i + 1 | 0;
-        c = Char.chr(Caml_format.caml_int_of_string("0x" + ($$String.make(1, d) + $$String.make(1, Caml_string.get(s, i)))));
+        c = Char.chr(Caml_format.caml_int_of_string("0x" + ($$String.make(1, h) + $$String.make(1, Caml_string.get(s, i)))));
       }
       
     }
@@ -20505,8 +20047,8 @@ function value_type(param) {
       throw [
             Caml_builtin_exceptions.assert_failure,
             [
-              "text/lexer.mll",
-              45,
+              "lexer.mll",
+              53,
               9
             ]
           ];
@@ -20523,8 +20065,8 @@ function intop(t, i32, i64) {
       throw [
             Caml_builtin_exceptions.assert_failure,
             [
-              "text/lexer.mll",
-              51,
+              "lexer.mll",
+              59,
               9
             ]
           ];
@@ -20541,8 +20083,8 @@ function floatop(t, f32, f64) {
       throw [
             Caml_builtin_exceptions.assert_failure,
             [
-              "text/lexer.mll",
-              57,
+              "lexer.mll",
+              65,
               9
             ]
           ];
@@ -20563,8 +20105,8 @@ function numop(t, i32, i64, f32, f64) {
       throw [
             Caml_builtin_exceptions.assert_failure,
             [
-              "text/lexer.mll",
-              65,
+              "lexer.mll",
+              73,
               9
             ]
           ];
@@ -20583,8 +20125,8 @@ function memsz(sz, m8, m16, m32) {
       throw [
             Caml_builtin_exceptions.assert_failure,
             [
-              "text/lexer.mll",
-              72,
+              "lexer.mll",
+              80,
               9
             ]
           ];
@@ -20597,13 +20139,12 @@ function ext(e, s, u) {
     throw [
           Caml_builtin_exceptions.assert_failure,
           [
-            "text/lexer.mll",
-            78,
+            "lexer.mll",
+            86,
             9
           ]
         ];
-  }
-  else {
+  } else {
     switch (switcher) {
       case 0 : 
           return s;
@@ -20611,8 +20152,8 @@ function ext(e, s, u) {
           throw [
                 Caml_builtin_exceptions.assert_failure,
                 [
-                  "text/lexer.mll",
-                  78,
+                  "lexer.mll",
+                  86,
                   9
                 ]
               ];
@@ -20626,11 +20167,11 @@ function ext(e, s, u) {
 var opt = Lib.Option[/* get */0];
 
 var __ocaml_lex_tables = /* record */[
-  /* lex_base */"\0\0o\xffp\xffq\xffr\xff\x01\0U\0\x07\0\x1b\0\x05\0o\0o\0t\0\x06\0j\0\x0e\0k\0y\0\x10\0y\0s\0\xb4\0\x01\x01z\0\xbe\0\xc5\0\x04\x01\x1a\x01\xfe\xff\x02\0s\xff\x13\0<\x01R\x01x\x01\"\0\x8f\x01\xd5\x01\x0e\x01\xee\x01/\x02>\x02U\x02\x96\x02\xa0\x02O\0D\0\xac\x02\xc2\x02\xe7\x02\0\x03&\x03L\x03z\0|\0~\0\x86\0|\0y\0\xfb\xff\x85\0\0\0\x0f\0\x87\0r\x03\x98\x03\xb1\0\xe8\xff\r\0\x10\0\xee\0\xad\0\xb6\0\xbb\0\xc2\0\x82\xff\xb4\0x\xff\0\0\x9c\x02\xb8\0\xbb\0\xf1\0\xca\0\xbf\0\xc2\0\xe3\0\xf2\0\xef\0\xe4\0\xf8\0\xeb\0\xf3\0*\x01\n\x01\xe6\0\xe8\0\xf5\0\xf7\0\xf7\0\xf5\xff\xd7\xff\xd6\xff\0\0\x01\0\x16\x01\x14\x01j\x01\x1c\0\x1a\0\x1b\x01\b\x01\xdb\xff\x19\x01\xb3\xff\xb4\xff'\x01\xb1\xff\xb2\xff3\x01\x1a\x01\x1e\x01\x1e\x01,\x01\xae\x01\x1f\0&\0\xda\xff\xcc\xffA\x01\xc3\xffV\x01\xc1\xff\xc2\xff3\x01A\x019\x01>\x01\xd5\xfff\x01h\x01\xcd\xff\xc6\xffa\x01\xcb\xffX\x01p\x01c\x01\xc9\xff\xca\xffc\x01w\x01t\x01\x84\x01r\x01\xc7\xff\xc8\xffu\x01\x85\x01y\x01|\x01{\x01\x89\x01{\x01\0\0\x90\x01*\0,\0\x97\xff\x8b\x01\xbf\xff\xc0\xff\xc5\xff\x86\x01\xc4\xff\x7f\x01\xb7\xff\xb5\xff\x9b\x01\x9c\x01\x89\x01\xaf\xff\xb0\xff\x9c\x01\xad\xff\xae\xff\xa3\x01\xa0\x01\xe3\x01\xaa\x01\xde\x01\xe1\x01\xa6\xff\xa8\x01\xba\x01\xc6\x01\xcb\x01\xb8\x01\xfd\x01\xff\x01\xcf\x01\t\x02\t\x02\f\x02\xa1\xff\x9f\xff\xda\x01\x0e\x02\x0e\x02\x11\x02\xa0\xff\x9e\xff\x18\x02~\x03\xd6\x01\xe6\x01\xdf\x01\xdb\x01\xd6\x01\xe8\x01\xe4\x01\xe7\x01\xe6\x01\xf4\x01\xe6\x01,\x02\xf6\x01'\x026\x02\x96\xff\xf8\x01\b\x02\n\x02\x15\x02\x1b\x02\b\x02M\x02O\x02&\x02]\x02_\x02\xa5\xff)\x02`\x02b\x02\xa4\xff&\x02*\x02)\x02\x86\xff.\x02\xf2\xff\xf8\xff\xf9\xff\xfa\xff\xd1\x03F\x04\xf7\xff9\x04\xa4\x047\x02r\x02u\x02z\x02\xb7\x03D\x02H\x029\x02F\x02K\x02>\x02E\x02Q\x02M\x02M\x02\xbd\x03\x97\x02T\x02x\x02F\x02t\x02^\x02R\x02g\x02\x8a\x02x\x02\xbd\x02\xbf\x02\x86\x02\xcf\x02\xca\x02\xd2\x02\x9d\xff\x9b\xff\xa4\x02\xdf\x02\xe2\x02\xef\x02\x9c\xff\x9a\xff\xaf\x02\xba\x02\xbd\x02\xb7\x02\xb8\xff\xba\x02\xd1\xff\xa9\xff\xaa\xff\xce\x02\xd7\x02\xdd\xff\xda\x02\xcb\x02\xcf\x02\xcd\x02\xdb\x02\xdc\xff\xd3\x02\xd2\xff\xbd\xff\xee\x02\xdc\x02\xd4\xff\xeb\x02\xdf\x02\xec\x02\xce\xff\t\x03\xfb\x02\xd3\xff\xbe\xff\0\x03\x02\x03\0\x03\xd0\xff\xfe\x02\x06\x03\x12\x03\xcf\xff\xfe\x02\t\x03\f\x03\xbc\xff\xba\xff\xb9\xff\f\x03\x05\x03\xbb\xff\x17\x03\x1f\x03/\x03f\x031\x03b\x03e\x03\xa3\xff\xac\xff\xa7\xff\xa8\xff1\x03-\x03(\x038\x03,\x03/\x03.\x03<\x038\x03\x8a\x03Q\x03\x88\x03\x8b\x03\x99\xff\x90\x03\x1f\x04Z\x03N\x03X\x03S\x03V\x03U\x03Q\x03a\x03\x98\x03l\x03\xad\x03\xb2\x03\xa2\xff}\x03y\x03t\x03\x84\x03}\x03\x84\x03\x83\x03\x92\x03\x8b\x03\xd1\x03\xa2\x03\xd6\x03\xd9\x03\x98\xff\xab\x03\x92\xff\x9c\x03\xa7\x03\x98\x03\xb3\x03\xaa\x03\xb2\x03\xbe\x03\xf4\xff\xbf\x03\xb9\x03\xeb\x03\x97\x04\xa2\x04\xac\x04\xb6\x04\xdc\x04\xc9\x03\xbd\x03\xbc\x03\xd9\x03\xc0\x04\xc1\x03\xc8\x03\xd6\x03\xce\x03\xce\x03\xd0\x03\xdf\x03\xd5\x03\xdc\x03\xd4\x03\xd2\x03\xf9\x03\x02\x04\x0f\x04\x80\xff\xfe\x03\x14\x04\n\x04\x0e\x04\x14\x04\x7f\xff\x13\x04\r\x04(\x04\x1f\x04\x1b\x04\x14\x04-\x04$\x04+\x041\x04~\xff*\x04.\x04*\x04.\x04?\x04?\x047\x04_\x04}\xff|\x04|\x04\x80\x04\x85\x04\x95\x04\x87\x04\x95\x04\x8f\x04{\xff\x9d\x04\x8f\x04z\xff\x99\x04\xa1\x04\x8e\x04\x91\x04\x91\x04\x9d\x04\x98\x04\x9a\x04y\xff\x9c\x04\xa6\x04\x97\x04\xf3\xff\xa1\x04\xba\x04\xc2\x04\x8c\xff\xb9\x04\xb8\x04\xb2\x04\x8a\xff\xba\x04\xc9\x04\xce\x04\xcd\x04\xc9\x04\xd5\x04\xd5\x04\xcc\x04\xd4\x04\xf1\xff\xc6\x04\xcc\x04\xcc\x04\xf0\xff\xe2\x04\x88\xff\xe5\x04\xd6\x04\xe4\x04\xdd\x04\xef\xff\xe0\x04\xe9\x04\xe5\x04\xeb\xff\xea\x04\xe1\x04\xe9\x04\xea\xff\xec\x04\xef\x04\xe1\x04\xee\xff\xe6\x04\x8e\xff\xe3\x04\xf0\x04\xf2\x04\xed\xff\xea\x04\xf3\x04\xe6\xff\x89\xff\xea\x04\xe8\x04\xe8\x04\x85\xff\xf6\x04\xf5\x04\xea\x04\xeb\x04\xef\x04\xf4\x04\xe9\xff\xf8\x04\xf1\x04\x8f\xff\xf3\x04\xf3\x04\x03\x05\xf9\x04\x83\xff\n\x05\xfd\x04\t\x05\n\x05\x02\x05\xe7\xff\x12\x05\x06\x05\x04\x05\x11\x05\x14\x05\n\x05\xe0\xff\x12\x05\x93\xff\f\x05\x14\x05\x8b\xff\b\x05\x1a\x05\x10\x05\x1e\x05\x19\x05\x1c\x05\f\x05\xe5\xff\x1a\x05\x16\x05\x14\x05\"\x05&\x05\x1c\x05\xe1\xff\x1a\x05(\x05*\x05 \x05\xde\xff\x1b\x05\x1a\x05\x91\xff&\x05 \x05\x1d\x05\x84\xff \x05'\x05(\x056\x05-\x05)\x054\x050\x05(\x056\x059\x05)\x05\xe3\xff,\x05:\x052\x05-\x05C\x056\x05@\x059\x058\x056\x050\x05\x95\xff;\x05<\x058\x05N\x05G\x05C\x05A\x05N\x05Q\x05H\x05\xe2\xffF\x05T\x05V\x05L\x05\xdf\xffB\x05[\x05N\x05W\x05P\x05O\x05M\x05G\x05\x94\xff_\x05a\x05W\x05\x8d\xffP\x05_\x05S\x05b\x05T\x05\x8c\x05\x9a\x05\xa4\x05\xae\x05\xb8\x05\xcf\x05\x82\x05~\x05\x80\x05w\xff\x83\x05\x95\x05\x8a\x05\x90\xff\x15\x06\xee\x05t\xffu\xff\x02\x06\xfb\xff\xfc\xff\xfd\xff\xce\x05\x01\0\xff\xff\xfe\xff",
-  /* lex_backtrk */"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x90\0\x02\0\x02\0\xff\xff\0\0\xff\xff\xff\xff\x04\0\xff\xff\x02\0\xff\xff\xff\xff\x02\0\xff\xff\x02\0\x04\0\xff\xff\x04\0\x04\0\xff\xff\xff\xff\xff\xff\x03\0\x03\0\xff\xff\x03\0\x03\0\x03\0\xff\xff\x04\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\0\xff\xff\xff\xff\xff\xff\x04\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\t\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\"\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff#\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffI\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\t\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\b\0\b\0\xff\xff\xff\xff\xff\xff\t\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffT\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\t\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'\0'\0\xff\xff'\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1b\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff~\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffx\0\xff\xff&\0&\0\xff\xff&\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\0\x04\0\xff\xff\xff\xff",
-  /* lex_default */"\x01\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\x01\x01\0\x01\0\0\xff\xff\0\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xa9\x02\0\0\0\0\xad\x02\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0",
-  /* lex_trans */'\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\x16\0\0\0\x06\0\0\0\0\0\0\0\x1d\0\x1c\0\xb2\x02\x19\0\0\0\x19\0O\0\xa5\0\x1b\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0>\0\x05\0\xa9\x02\x1e\0,\0?\0,\0\xd4\0N\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0&\0n\0&\0n\0\x7f\0(\0(\0(\0(\0(\0(\0(\0(\0(\0(\0\x7f\0\xa7\0\xa8\0t\0q\0\x14\0\x10\0\n\0\x11\0\x0e\0\x15\0\t\0\xa4\x02\x18\0z\x02#\x02\x0f\0\x13\0\x17\0\b\0\x07\0x\x02\r\0\x0b\0\f\0\x12\0\xa8\x02y\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\x11\x02\xf4\x01\xa8\x02\xa8\x02\x96\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\x95\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02<\0\xa8\x025\0\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02`\x02\xa8\x02D\x02\xa8\x02F\x022\x02\x18\x02\x05\x02\x19\x024\x02\xfe\x01<\x005\x02\x04\x02\xe8\x01\x96\x016\0\x97\x01\x17\x02E\x02_\x027\0\x95\x01\x06\x01\xe9\x01\xfa\0\x05\x01\xff\x018\x003\x02\xea\x019\0:\0E\0;\0=\0D\x000\0/\0/\0/\0/\0/\0/\0/\0/\0/\0@\0\x02\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfd\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xf6\0L\0\xfe\0C\0I\0J\0K\0M\0\x04\x01\xc1\0B\0F\0\xba\0.\0\xb1\0\xaf\0\xad\0 \0-\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0(\0(\0(\0(\0(\0(\0(\0(\0(\0(\0 \0\x1f\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\x006\0\xac\0\xb2\0\x97\0\x91\0\x8f\0\x86\0w\0\x8c\0\xff\0G\0\x1f\0f\0\x96\0e\0b\0H\0\xb3\0\x8b\0y\0x\0\x1f\0c\0d\0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0`\0j\0k\0a\0o\0p\0\x80\0p\0_\0\x1f\0\xfc\0\x1f\0"\0"\0"\0"\0"\0"\0"\0"\0"\0"\0s\0z\0r\0g\0{\0|\0!\0"\0"\0"\0"\0"\0"\0i\0v\0m\0u\0l\0h\0\x82\0\x83\0\x1f\0n\0\x87\0\x88\0\x81\0$\0\x89\0"\0"\0"\0"\0"\0"\0"\0"\0"\0"\0\x8a\0"\0"\0"\0"\0"\0"\0"\0"\0"\0"\0%\0"\0$\0$\0$\0$\0$\0$\0$\0$\0$\0$\0\x85\0\x8e\0\x84\0\x8d\0\x90\0\x92\0\x93\0$\0$\0$\0$\0)\0$\0\x95\0\xa9\0\x94\0"\0"\0"\0"\0%\0"\0~\0\x98\0}\0\x9d\0\x9a\0\x99\0\x9c\0\x7f\0\x9b\0#\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0$\0$\0$\0$\0)\0$\0\xa6\0\xab\0\xae\0\xb0\0\xb7\0\xb4\0\xb6\0\xaa\0\xb5\0#\0&\0\xfd\0&\0$\0\xbb\0\'\0\'\0\'\0\'\0\'\0\'\0\'\0\'\0\'\0\'\0\xb9\0\xbc\0\xb8\0\xbd\0\xbe\0\xbf\0\xc0\0"\0"\0"\0"\0%\0"\0$\0\xc2\0\'\0\'\0\'\0\'\0\'\0\'\0\'\0\'\0\'\0\'\0\xc3\0\xc4\0\xc5\0\xc7\0\xce\0\xc6\0\xc8\0"\0"\0"\0"\0%\0"\0\xc9\0"\0"\0"\0"\0%\0"\0\xcb\0\xcd\0\xcc\0\xca\0\xcf\0\xd1\0\xd3\0\xd2\0\xd0\0#\0\xd5\0\xaf\0\xd9\0\xda\0\xdb\0\xd8\0\x99\0\xdc\0\xe6\0"\0"\0"\0"\0%\0"\0\x96\0\xdd\0\xde\0\xdf\0\xe0\0\xe1\0\xe2\0\xe3\0\xe4\0#\0(\0(\0(\0(\0(\0(\0(\0(\0(\0(\0&\0\xe5\0&\0\xe7\0\xe8\0*\0*\0*\0*\0*\0*\0*\0*\0*\0*\0\xe9\0\xea\0\xeb\0\xed\0\xf2\0\xec\0\xee\0$\0$\0$\0$\0)\0$\0*\0*\0*\0*\0*\0*\0*\0*\0*\0*\0\xef\0\xf0\0\xf1\0\xf3\0\xf4\0\xf5\0\xf7\0$\0$\0$\0$\0)\0$\0\xf8\0\xf9\0\xfb\0$\0$\0$\0$\0)\0$\0\x93\x01v\x01\x07\x01\b\x01h\x01e\x01Z\x01T\x01f\x01#\0[\x01P\x01L\x01A\x01I\x01U\x01H\x01$\0$\0$\0$\0)\0$\0g\x011\x019\x01,\x01V\x01:\x018\x01\x1a\x01\x1b\x01#\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0 \0\x1c\x01/\0/\0/\0/\0/\0/\0/\0/\0/\0/\0\x18\x01c\0\x17\x01\x1d\x01\x19\x01\x1f\x01&\x01\x1e\x01 \x01!\x01 \0\x1f\0/\0/\0/\0/\0/\0/\0/\0/\0/\0/\0\x15\x01Z\0%\x01^\0X\0T\0#\x01R\0$\x01"\x01\x16\x01\x1f\0]\0Y\0S\0V\0[\0\'\x01W\0\\\0P\0\x1f\0)\x01Q\0U\0(\x01+\x012\x002\x002\x002\x002\x002\x002\x002\x002\x002\0*\x01-\x01.\x01/\x010\x012\x01\x1f\x002\x002\x002\x002\x002\x002\0$\x006\x012\x002\x002\x002\x002\x002\x002\x002\x002\x002\x001\x007\x01@\x01>\x01;\x01<\x01=\x012\x002\x002\x002\x003\x002\0?\x012\x002\x002\x002\x002\x002\0D\x01B\x01E\x01&\0F\x01&\0$\0C\x014\x004\x004\x004\x004\x004\x004\x004\x004\x004\0G\x012\x002\x002\x002\x003\x002\x002\x002\x002\x002\x003\x002\0K\x01J\x01M\x01#\0N\x01O\x01Q\x01R\x01S\x01Y\x01X\x01W\x01]\x01$\0\\\x014\x004\x004\x004\x004\x004\x004\x004\x004\x004\0^\x012\x002\x002\x002\x003\x002\x002\x002\x002\x002\x003\x002\0_\x01`\x01a\x01#\0b\x01c\x01d\x01i\x01j\x01k\x01l\x01m\x01n\x01o\x01p\x01A\0A\0A\0A\0A\0A\0A\0A\0A\0A\0q\x012\x002\x002\x002\x003\x002\0A\0A\0A\0A\0A\0A\0r\x01s\x01t\x01#\0u\x01w\x01\x85\x01{\x01[\x01|\x01}\x01~\x01\x7f\x01\x80\x01\x81\x01A\0A\0A\0A\0A\0A\0A\0A\0A\0A\0\x82\x01A\0A\0A\0A\0A\0A\0A\0A\0A\0A\0A\0A\0Z\0\x83\x01^\0X\0\xd6\0\x84\x01R\0\x86\x01\x87\x01\x88\x01\x89\x01]\0Y\0S\0V\0[\0\x8a\x01\xd7\0\\\0P\0\x03\x01\x8b\x01\x8c\x01U\0\x8d\x01\x03\x01A\0A\0A\0A\0A\0A\0\x8e\x01\x8f\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x90\x01\x91\x01\x92\x01\x94\x01\xa5\x01\x9d\x01\x98\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x10\x01\x99\x01\x14\x01\f\x01\x0b\x01\x0f\x01\n\x01\x9a\x01\x9b\x01\x9c\x013\x01\x13\x01\r\x01\x11\x01\x9e\x01\x9f\x01\xa0\x01\t\x01\x12\x01\x0e\x015\x01\x03\x01\xa6\x01\xa7\x01\xa8\x014\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xa9\x01\xdf\x01\xdc\x01\xd3\x01\xca\x01\xbf\x01\xb9\x01\x03\x01\xb1\x01\xb2\x01\xb3\x01\xb4\x01\xb5\x01\x03\x01\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfd\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xb6\x01\xb7\x01\xfe\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\xb8\x01\xba\x01\xbb\x01\xbc\x01\xbd\x01\xbe\x01\xc0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\x10\x01\xc1\x01\x14\x01z\x01\x0b\x01\x0f\x01\n\x01\xc2\x01\xc3\x01\xc4\x01\xc5\x01\x13\x01\r\x01\x11\x01\xc6\x01y\x01\xc7\x01x\x01\x12\x01\x0e\x01\xc8\x01\xc9\x01\xcb\x01\xcc\x01\xcd\x01\xce\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\xcf\x01\xd0\x01\xff\0\xd1\x01\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfd\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xd2\x01\xfc\0\xfe\0\xa2\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xff\xff\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xd4\x01\xd5\x01\xd6\x01\xd7\x01\xd8\x01\xd9\x01\xda\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xdb\x01\xdd\x01\xde\x01\xff\0\xe0\x01\xe1\x01\xe2\x01\xe3\x01\xe4\x01\xe5\x01\xe6\x01\xe7\x01\xf0\x01\xec\x01\xeb\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xed\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xfc\0\xa3\x01\xaa\x01\xee\x01\xef\x01\xf1\x01\xaf\x01\xf2\x01\xf3\x01\xf5\x01\xb0\x01\xf6\x01\xf7\x01\xf8\x01\xf9\x01\xac\x01\xae\x01\xab\x01\xad\x01\xfa\x01\xfb\x01\xfc\x01\xfd\x01\x02\x02\0\x02\x01\x02\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\x03\x02\t\x02\x06\x02\xfd\0\x07\x02\b\x02\x0b\x02\r\x02\f\x02\x0e\x02\x0f\x02\x10\x02\x12\x02\x15\x02\x14\x02\x16\x02\x1f\x02\n\x02\x1b\x02\x1a\x02\x1e\x02\x1d\x02 \x02!\x02\x13\x02"\x02$\x02-\x02*\x02\'\x02(\x02)\x02\x1c\x02+\x02,\x02.\x02/\x020\x02%\x02&\x021\x02A\x02?\x028\x026\x027\x029\x02:\x02;\x02<\x02=\x02>\x02@\x02B\x02C\x02[\x02X\x02H\x02L\x02I\x02J\x02K\x02M\x02S\x02O\x02G\x02P\x02N\x02Q\x02R\x02T\x02U\x02V\x02W\x02Y\x02Z\x02\\\x02]\x02^\x02l\x02a\x02b\x02c\x02d\x02e\x02f\x02g\x02h\x02i\x02j\x02k\x02m\x02n\x02o\x02p\x02q\x02r\x02\xfd\0s\x02t\x02u\x02v\x02w\x02\x91\x02\x88\x02{\x02|\x02}\x02\x83\x02\x7f\x02\x80\x02\x81\x02~\x02\x82\x02\x84\x02\x85\x02\x86\x02\x87\x02\x89\x02\x8a\x02\x8b\x02\x8c\x02\x8d\x02\x8e\x02\x8f\x02\x90\x02\x92\x02\x93\x02\x94\x02\xa0\x02\x97\x02\x98\x02\x99\x02\x9a\x02\x9b\x02\x9d\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\xa1\x02\xa2\x02\xa3\x02\xa5\x02\xa6\x02\xa7\x02\xaa\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\xb3\x02\0\0\0\0\xaf\x02\0\0\0\0\0\0\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\0\0\0\0\0\0\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x9e\x02\0\0\0\0\0\0\xb0\x02\0\0\0\0\0\0\0\0\0\0\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\xa8\x02\0\0\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xb1\x02\0\0\xa8\x02\xa8\x02\0\0\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\0\0\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\0\0\xa8\x02\0\0\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\0\0\xa8\x02\0\0\xa8\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xab\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xae\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0',
-  /* lex_check */"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xb1\x02\0\0\xff\xff\0\0N\0\xa4\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0=\0\0\0\x05\0\x1d\0\x1f\0>\0\x1f\0D\0E\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0#\0l\0#\0m\0}\0#\0#\0#\0#\0#\0#\0#\0#\0#\0#\0~\0\xa6\0\xa7\0g\0h\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x07\0\0\0\t\0\r\0\0\0\0\0\0\0\0\0\0\0\t\0\0\0\0\0\0\0\0\0\x06\0\t\0\x06\0\x06\0\x06\0\x06\0\x06\0\x0f\0\x12\0\x06\0\x06\0\b\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\b\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0-\0\x06\0.\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\n\0\x06\0\x0b\0\x06\0\x0b\0\f\0\x0e\0\x10\0\x0e\0\f\0\x11\0\x17\0\f\0\x10\0\x13\0\x14\x005\0\x14\0\x0e\0\x0b\0\n\x006\0\x14\0\x15\0\x13\0\x17\0\x15\0\x11\x007\0\f\0\x13\x008\x009\0\x18\0:\0<\0\x18\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0?\0\0\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0\x16\0B\0G\0\x16\0\x18\0H\0I\0J\0L\0\x15\0P\0\x18\0\x18\0Q\0\x19\0S\0T\0U\0\x1a\0\x19\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0&\0&\0&\0&\0&\0&\0&\0&\0&\0&\0\x1b\0\x1a\0\x1b\0\x1b\0\x1b\0\x1b\0\x1b\0\x1b\0\x1b\0\x1b\0\x1b\0\x1b\0F\0V\0R\0W\0X\0Y\0[\0\\\0Z\0\x16\0F\0\x1b\0_\0W\0`\0a\0F\0R\0Z\0\\\0\\\0\x1a\0b\0c\0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0^\0i\0j\0^\0n\0o\0x\0o\0^\0\x1b\0\x16\0 \0!\0!\0!\0!\0!\0!\0!\0!\0!\0!\0q\0y\0q\0]\0z\0{\0\x1b\0!\0!\0!\0!\0!\0!\0]\0t\0k\0t\0k\0]\0w\0\x81\0 \0k\0\x86\0\x87\0w\0\"\0\x88\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\x89\0!\0!\0!\0!\0!\0!\0\"\0\"\0\"\0\"\0\"\0\"\0$\0$\0$\0$\0$\0$\0$\0$\0$\0$\0\x83\0\x8b\0\x83\0\x8c\0\x8f\0\x91\0\x92\0$\0$\0$\0$\0$\0$\0\x93\0\x96\0\x93\0\"\0\"\0\"\0\"\0\"\0\"\0|\0\x97\0|\0\x98\0\x99\0\x97\0\x9a\0|\0\x9a\0\"\0\x9d\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0$\0$\0$\0$\0$\0$\0\xa5\0\xa9\0\xad\0\xaf\0\xb2\0\xb3\0\xb4\0\xa9\0\xb4\0$\0%\0\x16\0%\0%\0\xba\0%\0%\0%\0%\0%\0%\0%\0%\0%\0%\0\xb7\0\xbb\0\xb7\0\xbc\0\xbd\0\xbe\0\xbf\0%\0%\0%\0%\0%\0%\0'\0\xc1\0'\0'\0'\0'\0'\0'\0'\0'\0'\0'\0\xc2\0\xc3\0\xc4\0\xc5\0\xc6\0\xc5\0\xc7\0'\0'\0'\0'\0'\0'\0\xc8\0%\0%\0%\0%\0%\0%\0\xc9\0\xca\0\xcb\0\xc9\0\xce\0\xcf\0\xd0\0\xd1\0\xcf\0%\0\xd4\0\xd6\0\xd8\0\xd9\0\xda\0\xd7\0\xd8\0\xdb\0\xd6\0'\0'\0'\0'\0'\0'\0\xd7\0\xdc\0\xdd\0\xde\0\xdf\0\xe0\0\xe1\0\xe2\0\xe3\0'\0(\0(\0(\0(\0(\0(\0(\0(\0(\0(\0)\0\xe4\0)\0\xe6\0\xe7\0)\0)\0)\0)\0)\0)\0)\0)\0)\0)\0\xe8\0\xe9\0\xea\0\xeb\0\xec\0\xeb\0\xed\0)\0)\0)\0)\0)\0)\0*\0*\0*\0*\0*\0*\0*\0*\0*\0*\0\xee\0\xef\0\xf0\0\xf2\0\xf3\0\xf4\0\xf6\0*\0*\0*\0*\0*\0*\0\xf7\0\xf8\0\xfa\0)\0)\0)\0)\0)\0)\0\x04\x01\x05\x01\x06\x01\x07\x01\t\x01\x0b\x01\f\x01\r\x01\n\x01)\0\f\x01\x0e\x01\x0f\x01\x11\x01\x10\x01\r\x01\x10\x01*\0*\0*\0*\0*\0*\0\n\x01\x15\x01\x12\x01\x17\x01\r\x01\x12\x01\x12\x01\x19\x01\x1a\x01*\0+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0/\0\x1b\x01/\0/\0/\0/\0/\0/\0/\0/\0/\0/\0\x16\x01\x18\x01\x16\x01\x1c\x01\x18\x01\x1d\x01\x1e\x01\x1d\x01\x1f\x01 \x010\0/\x000\x000\x000\x000\x000\x000\x000\x000\x000\x000\0\x14\x01O\0\"\x01O\0O\0O\0!\x01O\0#\x01!\x01\x14\x010\0O\0O\0O\0O\0O\0&\x01O\0O\0O\0/\0'\x01O\0O\0'\x01(\x011\x001\x001\x001\x001\x001\x001\x001\x001\x001\0)\x01,\x01-\x01.\x01/\x011\x010\x001\x001\x001\x001\x001\x001\x002\x005\x012\x002\x002\x002\x002\x002\x002\x002\x002\x002\x000\x006\x018\x019\x01:\x01;\x01<\x012\x002\x002\x002\x002\x002\0>\x011\x001\x001\x001\x001\x001\0B\x01A\x01D\x013\0E\x013\x003\0A\x013\x003\x003\x003\x003\x003\x003\x003\x003\x003\0F\x012\x002\x002\x002\x002\x002\x003\x003\x003\x003\x003\x003\0H\x01I\x01L\x012\0M\x01N\x01P\x01Q\x01R\x01T\x01U\x01V\x01Z\x014\0[\x014\x004\x004\x004\x004\x004\x004\x004\x004\x004\0]\x013\x003\x003\x003\x003\x003\x004\x004\x004\x004\x004\x004\0^\x01_\x01`\x013\0a\x01b\x01c\x01h\x01i\x01j\x01k\x01l\x01m\x01n\x01o\x01@\0@\0@\0@\0@\0@\0@\0@\0@\0@\0p\x014\x004\x004\x004\x004\x004\0@\0@\0@\0@\0@\0@\0q\x01r\x01s\x014\0t\x01v\x01x\x01y\x01z\x01{\x01|\x01}\x01~\x01\x7f\x01\x80\x01A\0A\0A\0A\0A\0A\0A\0A\0A\0A\0\x81\x01@\0@\0@\0@\0@\0@\0A\0A\0A\0A\0A\0A\0\xd5\0\x82\x01\xd5\0\xd5\0\xd5\0\x83\x01\xd5\0\x85\x01\x86\x01\x87\x01\x88\x01\xd5\0\xd5\0\xd5\0\xd5\0\xd5\0\x89\x01\xd5\0\xd5\0\xd5\0\xff\0\x8a\x01\x8b\x01\xd5\0\x8c\x01\xff\0A\0A\0A\0A\0A\0A\0\x8d\x01\x8e\x01\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\x8f\x01\x90\x01\x91\x01\x93\x01\x95\x01\x96\x01\x97\x01\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\b\x01\x98\x01\b\x01\b\x01\b\x01\b\x01\b\x01\x99\x01\x9a\x01\x9b\x01\x13\x01\b\x01\b\x01\b\x01\x9d\x01\x9e\x01\x9f\x01\b\x01\b\x01\b\x01\x13\x01\xff\0\xa5\x01\xa6\x01\xa7\x01\x13\x01\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xa8\x01\xaa\x01\xab\x01\xac\x01\xad\x01\xae\x01\xaf\x01\xff\0\xb0\x01\xb1\x01\xb2\x01\xb3\x01\xb4\x01\xff\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\xb5\x01\xb6\x01\0\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xb7\x01\xb9\x01\xba\x01\xbb\x01\xbc\x01\xbd\x01\xbf\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01w\x01\xc0\x01w\x01w\x01w\x01w\x01w\x01\xc1\x01\xc2\x01\xc3\x01\xc4\x01w\x01w\x01w\x01\xc5\x01w\x01\xc6\x01w\x01w\x01w\x01\xc7\x01\xc8\x01\xca\x01\xcb\x01\xcc\x01\xcd\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\xce\x01\xcf\x01\0\x01\xd0\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\xd1\x01\0\x01\x03\x01\xa0\x01\xa0\x01\xa0\x01\xa0\x01\xa0\x01\xa0\x01\xa0\x01\xa0\x01\xa0\x01\xa0\x01\xff\0\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa1\x01\xa2\x01\xa2\x01\xa2\x01\xa2\x01\xa2\x01\xa2\x01\xa2\x01\xa2\x01\xa2\x01\xa2\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xd3\x01\xd4\x01\xd5\x01\xd6\x01\xd7\x01\xd8\x01\xd9\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xda\x01\xdc\x01\xdd\x01\x03\x01\xdf\x01\xe0\x01\xe1\x01\xe2\x01\xe3\x01\xe4\x01\xe5\x01\xe6\x01\xe8\x01\xe9\x01\xea\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xec\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xa3\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\x03\x01\xa2\x01\xa9\x01\xed\x01\xee\x01\xf0\x01\xa9\x01\xf1\x01\xf2\x01\xf4\x01\xa9\x01\xf5\x01\xf6\x01\xf7\x01\xf8\x01\xa9\x01\xa9\x01\xa9\x01\xa9\x01\xf9\x01\xfa\x01\xfb\x01\xfc\x01\xfe\x01\xff\x01\0\x02\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\xa4\x01\x02\x02\x04\x02\x05\x02\0\x01\x06\x02\x07\x02\t\x02\n\x02\x0b\x02\r\x02\x0e\x02\x0f\x02\x11\x02\x12\x02\x13\x02\x15\x02\x17\x02\t\x02\x18\x02\x19\x02\x1b\x02\x1c\x02\x1f\x02 \x02\x11\x02!\x02#\x02$\x02%\x02&\x02'\x02(\x02\x18\x02*\x02+\x02-\x02.\x02/\x02#\x02#\x020\x022\x023\x024\x025\x026\x028\x029\x02:\x02;\x02<\x02=\x02?\x02A\x02B\x02D\x02E\x02F\x02G\x02H\x02I\x02J\x02L\x02M\x02N\x02F\x02O\x02L\x02P\x02Q\x02S\x02T\x02U\x02V\x02X\x02Y\x02[\x02\\\x02]\x02_\x02`\x02a\x02b\x02c\x02d\x02e\x02f\x02g\x02h\x02i\x02j\x02l\x02m\x02n\x02o\x02p\x02q\x02\x03\x01r\x02s\x02t\x02u\x02v\x02x\x02y\x02z\x02{\x02|\x02}\x02~\x02\x7f\x02\x80\x02|\x02\x81\x02\x83\x02\x84\x02\x85\x02\x86\x02\x88\x02\x89\x02\x8a\x02\x8b\x02\x8c\x02\x8d\x02\x8e\x02\x8f\x02\x91\x02\x92\x02\x93\x02\x95\x02\x96\x02\x97\x02\x98\x02\x99\x02\x9a\x02\x9b\x02\x9b\x02\x9b\x02\x9b\x02\x9b\x02\x9b\x02\x9b\x02\x9b\x02\x9b\x02\x9b\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9c\x02\x9d\x02\x9d\x02\x9d\x02\x9d\x02\x9d\x02\x9d\x02\x9d\x02\x9d\x02\x9d\x02\x9d\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\xa0\x02\xa1\x02\xa2\x02\xa4\x02\xa5\x02\xa6\x02\xa9\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\xb0\x02\xff\xff\xff\xff\xac\x02\xff\xff\xff\xff\xff\xff\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\xff\xff\xff\xff\xff\xff\x9e\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\x9e\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9d\x02\xff\xff\xff\xff\xff\xff\xac\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\x9f\x02\xa8\x02\xff\xff\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xac\x02\xff\xff\xa8\x02\xa8\x02\xff\xff\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xff\xff\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xff\xff\xa8\x02\xff\xff\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xa8\x02\xff\xff\xa8\x02\xff\xff\xa8\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xac\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+  /* lex_base */"\0\0\x1d\0\xec\0,\x01\xb3\x01\xf3\x01\xab\x02\xb0\x02\xf1\0m\xffn\xffo\xff\x01\0\x91\x03\xbe\x01\xec\x02\x07\x04\f\x04\x11\x04\x16\x043\x04_\x04m\x04\x93\x04\x98\x04\x9d\x04\xa7\x04\xc8\x04\xcd\x04\xf0\x04r\x05j\x06t\x06\x84\x06\xc3\x06\xdd\x06\xfe\xff\x03\0p\xff\x12\x01\x13\x07U\x07\x9d\x07\x07\x02\xe6\x07o\x03\xa1\x05/\bP\b4\x07j\b\x84\b\x9e\b\xd7\b*\ts\tt\x03}\t\x95\x05\x1e\t\x97\t\xbe\t\x07\n\f\nN\nX\nh\ny\n\x85\n\x93\n\x9f\n\xad\n\xb9\n\xca\n\xee\n\xf3\n\x10\x0b\x1a\x0b*\x0b;\x0b\x81\x0b\x8c\x0b\x9b\x0b\xa9\x0b\xc3\x0b\xb5\x0b\xd2\x0b\xec\x0b\x0f\f\x1c\f9\fD\fS\f\x99\f\xb3\f\xbd\f\xc2\f\xcd\f\xf2\f\xf7\f\x03\r\x1d\r.\r>\rR\rt\r\x7f\r\x8e\r\xaf\r\xba\r\xd4\r\xde\r\xf8\r\x07\x0e\x12\x0e,\x0e6\x0e;\x0eF\x0e`\x0e\x83\x0e\x9d\x0e\xb7\x0e\xd9\x0e\xe3\x0e\xf3\x0e\x10\x0f\x1a\x0f;\x0f*\x0fU\x0f_\x0fd\x0fo\x0f\x89\x0f\x98\x0f\xb2\x0f\xbc\x0f\xde\x0f\xeb\x0f\xfb\x0f\x05\x10\x15\x10\x1f\x10/\x109\x10I\x10S\x10m\x10\x87\x10}\x10\x91\x10\xb7\x10\xc1\x10\xc6\x10\xe7\x10\x01\x11\x1b\x11(\x11N\x11X\x11u\x11\x83\x11\x92\x11\xa0\x11\xaf\x11\xba\x11\xd4\x11\xe2\x11\xee\x11\xfc\x11\x0b\x12\x16\x127\x12B\x12Q\x12\\\x12}\x12\x8b\x12\x9f\x12\xc3\x12\xcf\x12\xdd\x12\xec\x12\xf7\x12\x06\x13\x11\x132\x13=\x13L\x13W\x13f\x13\x80\x13\x8a\x13\x8f\x13\xb0\x13\xbe\x13\xd8\x13\xe5\x13\xff\x13\r\x14\x19\x14'\x14A\x14L\x14Q\x14[\x14\x8a\x14\x8f\x14\x94\x14\xbe\x14\xc8\x14\xe9\x14\xf4\x14+\x15:\x15[\x15`\x15e\x15\x88\x15\x94\x15\x99\x15\xbc\x15\xcd\x15\xdd\x15\xfa\x15\x07\x16\x17\x16:\x16?\x16D\x16a\x16n\x16\x99\x16\xa7\x16\xc8\x16\xe2\x16\xf2\x16\x03\x17%\x17*\x17G\x17R\x17t\x17\x82\x17\x8e\x17\x9c\x17\xab\x17\xb6\x17\xf8\xff\xf9\xff\xfa\xff\xd4\x17\0\0\xd6\0E\x18\x85\x18\xd3\x17\xa5\x18\xe5\x18\xa5\x19&\x1af\x1a\xa6\x1a\xe6\x1a&\x1bf\x1b\xa6\x1b\xe6\x1b&\x1c\xf7\xff\0\0_\x18\xe6\x1c\x98\x19\xd9\x1c\xde\x1d\f\x1d&\x1d\xe8\x1d\xf2\x1d\x13\x1e\x1f\x1eG\x1ea\x1el\x1e\x8d\x1e\x97\x1e\x9c\x1e\xa7\x1e\xcf\x1e\xf0\x1e\xfb\x1e\x1d\x1f(\x1fE\x1fP\x1fq\x1f{\x1f\x98\x1f\xa5\x1f\xbf\x1f\xcf\x1f\xe9\x1f\xf3\x1f\r \x19 = B L i u \x92 \xac \xa0 \xba \xd7 \xe2 \xe7 \n!\x16!'!7!K!Z!t!\x81!\x8e!\x9b!\xa8!\xd0!\xe0!\x03\"\b\"\x13\"7\"<\"]\"b\"q\"\x97\"\xa1\"\xa6\"\xcc\"\xd1\"\xdd\"\xee\"\b#\x12#8#E#R#b#\x88#\x92#\xb8#\xc9#\xd9#\xe3#\xf3#\0$\r$\x1a$A$N$[$k$u$\x92$\xac$\xc6$\xe3$\xe8$\x0b%\x17%\x1c%(%O%T%_%y%\x93%\xa1%\xb5%\xd7%\xe5%\f&\x1a&.&;&O&^&c&r&\x9e&\xad&\xd2&\xdd&\xe2&\x07'\x15')'='K'l'q'{'\x80'\xa1'\xa6'\xab'\xce'\xe2'\xf1'\x16(!(F(K(P(U(z(\x85(\x8a(\xad(\xb2(\xbe(\xe1(\xf1(\xfb(\x05)8)I)l)\x9f)\xd6)\xf0)B*\x8e)u*\x89*\xaa*\xaf*\xb9*\xd3*\xdf*\xe4*\x06+++6+P+Z+_+\x84+\x89+\x93+\xb4+\xb9+\xbe+\xdf+\xe9+\xf3+\x18,9,D,S,^,m,x,\x9a,\xa8,\xc2,\xce,\xe8,\xf2,\xf7,\x02-\x1f---N-]-h-\x82-\x8c-\xb1-\xb6-\xbb-\xd8-\xdd-\xfa-\b.\x14.1.<.K.e.o.t.\x95.\x9a.\xb7.\xbc.\xc1.\xe2.\xfc.\x06/\x16/:/I/N/o/~/\x83/\x92/\xbd/\xc7/\xcc/\xe9/\xf7/\x060\x0b0/0:0I0T0n0x0}0\xa10\xad0\xb20\xd40\xe10\xf10\xfb0\x0b1.181H1Y1m1|1\x961\xa21\xa71\xcd1\xdd1\xf71\xea1\x042\x11282H2R2u2\x862\xa82\xb22\xcc2\xd82\xe62\x003\f3\x1a343@3c3\x843\x8f3\xb13\xbb3\xd53\xe13\xef3\xfb3\t4\x154#424L4=4q4\x7f4\x8b4\x9c4\xbe4\xc94\xe34\xf44\x055\x1f5+595E5f5q5\x805\x9a5\xa65\xab5\xb75\xd15\xdb5\xe05\x046\x0f6\x14696G6V6[6\x7f6\x8a6\xa46\xb56\xc16\xe86\xf66\x137\"7?7Y7d7s7~7\xa07\xb17\xd97\xe57\xff7\r8!8.8H8T8n8{8\x958\xa18\xaf8\xbb8\xc98\xe38\xee8\xfd8\x0b90959A9h9\x859\xaa9\xb49\xb99\xc49\xde9\xe89\xf89\x05:\x12:\":/:Q:k:w:\x9a:\x9f:\xae:\xc2:\xd2:\xf7:\x1a;\x0b;\x1f;.;S;c;t;\x80;\xa3;\xad;\xb7;\xc7;\xe1;\xec;\t<\x14<\x19<#<=<H<b<p<\x8a<\x98<\xb2<\xc2<\xcf<\xdc<\xf6<\x13=#=[=u=\xc7=\x0e>\x97=\x13>V>[>x>}>\x82>\xa4>\xb1>\xc5>\xd9>\xe7>\xc8?I@r\xffs\xff\xd4?\x96\x02\x04@\xca@\x82\x19\xe3>\nAJA\x8aA\xcaA\nBJB\x8aB\xcaB\nCJC#?E?\x01D\x06D\x0bD\xbdD\x10DtE\x15D*F\xfa\xff\xabF\xc1\x04\xc1C\xebF\x96D\x1eE+G\xfb\xff\xfc\xff\xfd\xff\x05\0\x03\0\xff\xff\xfe\xffkG\xabG\xebG+HkH\xabH\xebH+IkI",
+  /* lex_backtrk */"\xff\xff\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\xff\xff\xff\xff\xff\xff\x94\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x94\0\x93\0\x93\0\x93\0\x02\0\x02\0\xff\xff\0\0\xff\xff\x93\0\x04\0\x93\0\x02\0\x93\0\x04\0\x04\0\x93\0\x04\0\x93\0\x93\0\x93\0\x03\0\x03\0\x93\0\x03\0\x93\0\x04\0\x93\0\x04\0\x93\0\x93\0\x93\0\x04\0\x93\0\x17\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x7f\0\x93\0\x89\0\t\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\n\0(\0)\0\x93\0\x93\0\x93\0\x93\0\"\0\x93\0\x93\0\x93\0\x93\0$\0\x93\0L\0K\0\x93\0N\0M\0\x93\0\x93\0\x93\0\x93\0\x93\0#\0\x93\0\x93\0%\x003\0\x93\0<\0\x93\0>\0=\0\x93\0\x93\0\x93\0\x93\0*\0\x93\0\x93\x002\x009\0\x93\x004\0\x93\0\x93\0\x93\x006\x005\0\x93\0\x93\0\x93\0\x93\0\x93\x008\x007\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0h\0\x93\0@\0?\0:\0\x93\0;\0I\0H\0J\0\x93\0\x93\0\x93\0P\0O\0\x93\0R\0Q\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0Y\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0^\0`\0\x93\0\x93\0\x93\0\x93\0_\0a\0\t\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0i\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0Z\0\x93\0\x93\0\x93\0[\0\x93\0\x93\0\x93\0x\0\x93\0\r\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\b\0\b\0\b\0\xff\xff\xff\xff\x93\0\x93\0\x93\0\t\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0b\0d\0\x93\0\x93\0\x93\0\x93\0c\0e\0\x93\0\x93\0\x93\0\x93\0G\0\x93\0.\0V\0U\0\x93\0\x93\0\"\0\x93\0\x93\0\x93\0\x93\0\x93\0#\0\x93\0-\0B\0T\0\x93\0+\0\x93\0\x93\0\x93\x001\0\x93\0\x93\0,\0A\0\x93\0\x93\0\x93\0/\0\x93\0\x93\0\x93\x000\0\x93\0\x93\0\x93\0C\0E\0F\0\x93\0\x93\0D\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\\\0S\0X\0W\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0f\0\t\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0]\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0g\0\x93\0m\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x0b\0\x93\0\x93\0\x93\0\x93\0'\0'\0\x93\0'\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x81\0\x93\0\x93\0\x93\0\x93\0\x93\0\x82\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x83\0\x93\0\x93\0\x93\0\x93\0\x84\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x85\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x86\0\x93\0\x93\0\x87\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x88\0\x93\0\x93\0\x93\0\f\0\x93\0\x93\0\x93\0t\0\x93\0\x93\0\x93\0z\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x0e\0\x93\0\x93\0\x93\0\x0f\0\x93\0v\0\x93\0\x13\0\x93\0\x93\0\x93\0\x10\0\x93\0\x93\0\x93\0\x14\0\x93\0\x93\0\x93\0\x15\0\x93\0\x93\0\x93\0{\0\x93\0\x93\0\x93\0\x11\0\x93\0q\0\x93\0\x93\0\x93\0\x12\0\x93\0\x93\0\x19\0u\0\x93\0\x93\0\x93\0y\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x16\0\x93\0\x93\0p\0\x93\0\x93\0\x93\0\x93\0~\0\x93\0\x93\0\x93\0\x93\0\x93\0\x18\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x1f\0\x93\0l\0\x93\0\x93\0s\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x1a\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x1e\0\x93\0\x93\0\x93\0\x93\0!\0\x93\0\x93\0n\0\x93\0\x93\0\x93\0}\0\x93\0\x93\0\x93\0\x1b\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x1c\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0j\0\x93\0\x93\0\x93\0\x80\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x1d\0\x93\0\x93\0\x93\0\x93\0 \0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0k\0\x93\0\x93\0\x93\0r\0\x93\0\x93\0\x93\0\x93\0\x93\0w\0\x93\0&\0&\0\x93\0&\0\x93\0\x93\0\x93\0\x8a\0\x93\0\x93\0\x93\0o\0\x93\0\x93\0\x93\0|\0\x8b\0\x8e\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\x93\0\xff\xff\xff\xff\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\xff\xff\xff\xff\xff\xff\x04\0\x04\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+  /* lex_default */"\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\0\0\0\0\xff\xff\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x04\x01\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\xff\xff\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\0\0\0\0\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\x04\x01\xff\xff\xff\xff\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\xce\x02\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\xf3\x02\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+  /* lex_trans */"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x0b\0\n\0\0\0\0\0\x0b\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x0b\0\0\0\x1e\0\0\0\r\0\0\0\xff\xff\xff\xff%\0$\0\xff\xff!\0\xf8\x02!\0\0\0\0\0#\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\0\0\f\0\xce\x02\xff\xff&\0\xff\xff\xf9\x02\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x1c\0\x18\0\x12\0\x19\0\x16\0\x1d\0\x11\0\0\0 \0\0\0\0\0\x17\0\x1b\0\x1f\0\x10\0\x0f\0\x0e\0\x15\0\x13\0\x14\0\x1a\0\0\0\0\0\0\0\0\0\0\0\x12\x01\0\0\0\0\0\0\0\0\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\0\0\0\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\b\0\x07\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x06\0\x05\0\x05\0\x04\0\x02\0\x02\0\x02\0\x03\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\x000\0\0\x000\0\0\0\0\0/\0/\0/\0/\0/\0/\0/\0/\0/\0/\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\0\0\xff\xff\0\0\0\0\0\0\0\0\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0.\0\xc9\x02.\0\0\0\0\0-\0-\0-\0-\0-\0-\0-\0-\0-\0-\0\0\0\xff\xff\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xe3\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\0\0\xff\xff\0\0\0\0\0\0\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\xe2\x02\0\0\0\0\xc5\x02\0\0\0\0\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\xe1\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff-\0-\0-\0-\0-\0-\0-\0-\0-\0-\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xcd\x02\xff\xff\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xff\xff\xff\xff\xcd\x02\xcd\x02\0\0\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xff\xff\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xff\xff\xcd\x02\0\0\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\0\0\xcd\x02\0\0\xcd\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xb7\x02\xff\xff\xff\xff\0\0\x9b\x02\x81\x02\0\0\xff\xff\0\0\xff\xff\xff\xff\x99\x02e\x02\xff\xffg\x02\xb6\x02\0\0\x9a\x02\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\x80\x02\xff\xff\xff\xff\0\0f\x02\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0S\x02\xff\xff\xff\xff\0\0U\x02\0\0\xff\xffV\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0T\x02\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0D\x02\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff9\x02\xff\xff:\x02\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\x008\x02\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\x1a\x02\0\0\0\0 \x022\x02\xff\xff\"\x02\0\0\0\0\xff\xff\xff\xff\0\0!\x02\0\0\xff\xff\0\0\0\0\x1b\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\x10\x02\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x01\0\0\0\0\x15\x01\0\0\0\0\0\0\0\0\xff\xff\0\0\x05\x02\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\x04\x02\0\0\xa6\x01\0\0\xa7\x01\0\0\x06\x02\0\0\0\0\xa5\x01\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\x14\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xfa\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\0\0\xff\xff\xfb\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xfc\0;\0\xff\xff-\0-\0-\0-\0-\0-\0-\0-\0-\0-\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xf9\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\x01\x01\0\x01\0\x01\xff\0\xfd\0\xfd\0\xfd\0\xfe\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfa\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xffB\0\0\0\0\0A\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\x004\x003\x003\x003\x003\x003\x003\x003\x003\x003\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x009\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xf7\0@\0\0\0\0\0\0\0\0\0\0\0\0\0?\0C\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff2\0\0\0\0\0\0\0(\x001\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0'\0\0\0\0\0(\0\0\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0'\0\0\0\0\0\0\0\0\0\0\0'\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff'\0(\0(\0(\0(\0(\0(\0(\0(\0(\0(\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff)\0\xff\xff\0\0'\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff'\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff*\0*\0*\0*\0*\0*\0*\0*\0*\0*\0\0\0\xff\xff\0\0\0\0\0\0\0\x009\0*\0*\0*\0*\0*\0*\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0*\0*\0*\0*\0*\0*\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0,\0\0\0*\0*\0*\0*\0*\0*\0*\0*\0*\0*\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff*\0*\0*\0*\0*\0*\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0+\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0*\0*\0*\0*\0*\0*\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0+\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0,\0,\0,\0,\0,\0,\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0+\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0,\0,\0,\0,\0,\0,\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff+\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0/\0/\0/\0/\0/\0/\0/\0/\0/\0/\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0/\0/\0/\0/\0/\0/\0/\0/\0/\0/\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0(\0\0\x003\x003\x003\x003\x003\x003\x003\x003\x003\x003\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0'\0\0\0\0\0(\0\0\x003\x003\x003\x003\x003\x003\x003\x003\x003\x003\x007\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0'\0\xff\xff\0\0\xff\xff\0\0\0\0'\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0'\0\0\0\0\0\0\x006\x006\x006\x006\x006\x006\x006\x006\x006\x006\0\0\0\xff\xff\0\0\0\0\0\x005\0\0\x006\x006\x006\x006\x006\x006\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff6\x006\x006\x006\x006\x006\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0<\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0,\0\xff\xff6\x006\x006\x006\x006\x006\x006\x006\x006\x006\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff6\x006\x006\x006\x006\x006\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0+\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff6\x006\x006\x006\x006\x006\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0+\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\x008\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0:\0\0\0\0\0>\0>\0>\0>\0>\0>\0>\0>\0>\0>\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0>\0>\0>\0>\0>\0>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0=\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff>\0>\0>\0>\0>\0>\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0>\0>\0>\0>\0>\0>\0>\0>\0>\0>\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff>\0>\0>\0>\0>\0>\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0>\0>\0>\0>\0>\0>\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xf3\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xd1\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xffK\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\x008\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xffD\0\xff\xff\0\0\xff\xff\0\0\0\0E\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0I\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0F\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0G\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0H\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0L\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0J\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0W\0\0\0[\0U\0Q\0\xff\xffO\0\0\0\xff\xff\0\0\0\0Z\0V\0P\0S\0X\0\0\0T\0Y\0M\0\xff\xff\0\0N\0R\0\0\0\xff\xff\xff\xff\xbe\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xb7\0\0\0\0\0\xff\xff\xaf\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xb0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xae\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xac\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xaa\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xa9\0\xff\xff\0\0\x8e\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\x94\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\x93\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\x89\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\x88\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\x83\0\xff\xff\0\0\xff\xff\0\0\0\0t\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0v\0u\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0d\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0f\0\xff\xff\0\0\0\0\0\0e\0\0\0\0\0]\0\0\0\0\0^\0\0\0\xff\xff\0\0\0\0\\\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xffc\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xffb\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff_\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0`\0\0\0\xff\xff\0\0\0\0\0\0a\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0q\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xffn\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0j\0\0\0i\0\0\0\0\0\xff\xff\xff\xffk\0\0\0\xff\xff\xff\xff\0\0g\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xffh\0\0\0\0\0\0\0k\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0k\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0l\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xffm\0\0\0m\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0p\0\xff\xffo\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0s\0\0\0r\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0}\0\0\0\0\0\0\0\0\0\x7f\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff~\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0w\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0{\0\0\0z\0\0\0x\0\0\0\xff\xff|\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0y\0|\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0|\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\x80\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\x82\0\0\0\x81\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\x85\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\x84\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\x86\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\x87\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\x8b\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\x8a\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\x8d\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\x90\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\x8f\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\x92\0\0\0\x91\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xa6\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\x95\0\xff\xff\0\0\xff\xff\x96\0\0\0\x97\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\x9a\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\x99\0\xff\xff\x98\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\x9b\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\x9c\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\x9d\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\x9e\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\x9f\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xa2\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xa0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa4\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xa1\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xa5\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xa3\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xa8\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xa7\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xab\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xad\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xb4\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xb1\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xb3\0\xff\xff\xb2\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xba\0\xb6\0\xff\xff\xb5\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xb8\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xb9\0\xbc\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xbb\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xbf\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xc0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xcb\0\xff\xff\xff\xff\xff\xff\xc1\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xc2\0\0\0\xff\xff\xff\xff\xc5\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xc4\0\0\0\xc3\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xc8\0\0\0\xff\xff\xc7\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xca\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xc6\0\xc9\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xce\0\xff\xff\0\0\xcd\0\xff\xff\xff\xff\xd0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xcf\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xcc\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xd2\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0W\0\0\0[\0U\0\xd3\0\xff\xffO\0\0\0\xff\xff\0\0\0\0Z\0V\0P\0S\0X\0\xff\xff\xd4\0Y\0M\0\0\0\xff\xff\xff\xffR\0\0\0\xff\xff\xac\0\0\0\0\0\0\0\0\0\0\0\0\0\xe3\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xd5\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\x93\0\0\0\xff\xff\xff\xff\xff\xff\xd6\0\0\0\0\0\0\0\x96\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xd7\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xd8\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xd9\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\xda\0\0\0\xff\xff\xdb\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xdf\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xdd\0\xdc\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xde\0\0\0\0\0\xff\xff\xff\xff\0\0\xe1\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xe2\0\xff\xff\xff\xff\0\0\0\0\xe0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xe4\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xe5\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xe7\0\xff\xff\0\0\0\0\0\0\xe6\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xe8\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xef\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xeb\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\xea\0\xff\xff\xe9\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xed\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xee\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xec\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xf1\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xf2\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xf0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xf4\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xf5\0\0\0\x11\x01\0\0\0\0\0\0\0\0\x11\x01\0\0\0\0\0\0\0\0\0\0\0\0\xf6\0\xff\xff\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\xf8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\x11\x01\0\0\0\0\0\0\0\0\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x11\x01\0\0\0\0\0\0\x11\x01\xff\xff\x11\x01\x0f\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xfa\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\0\0\0\0\xfb\0\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\0\0\0\0\xfc\0\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\0\0\0\0\xf9\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\x01\x01\0\x01\0\x01\xff\0\xfd\0\xfd\0\xfd\0\xfe\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfa\0\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xfa\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\xf9\0\0\0\0\0\xfb\0\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x86\x01\0\0\xfc\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\x04\x01\0\0\x17\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\xf9\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x02\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\x01\x01\0\x01\0\x01\xff\0\xfd\0\xfd\0\xfd\0\xfe\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfa\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\x18\x01\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xa3\x01\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0 \x01\xff\xff$\x01\x1c\x01\x1b\x01\x1f\x01\x1a\x01\xff\xff\0\0\0\0\0\0#\x01\x1d\x01!\x01\0\0\0\0\0\0\x19\x01\"\x01\x1e\x01\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0x\x01\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xffv\x01\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0w\x01\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xffu\x01\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xffj\x01\xff\xff\xff\xff\xff\xffk\x01\0\0\0\0d\x01\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0e\x01\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0f\x01\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xffY\x01`\x01X\x01\0\0\0\0\\\x01\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0Q\x01\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xffI\x01\0\0\0\0J\x01H\x01\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0C\x01\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0E\x01%\x01\xff\xff\0\0\xff\xffD\x01\xff\xff\0\0\xff\xff\0\0\0\0&\x01\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xffA\x01\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0(\x01\xff\xff'\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0<\x01\0\0\xff\xff\xff\xff\0\0`\0\0\0\xff\xff)\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0*\x01\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0+\x01\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff6\x01\0\0\xff\xff\0\0\0\0\0\0-\x01\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff,\x01\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff0\x01\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0/\x01\0\0.\x01\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\x003\x01\xff\xff\xff\xff2\x01\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff5\x01\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\x001\x01\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff4\x01\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\x009\x01\xff\xff\xff\xff8\x01\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0;\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\x007\x01\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0:\x01\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff=\x01>\x01\xff\xff\0\0?\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0@\x01\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xffB\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0F\x01\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0G\x01\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0P\x01\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0N\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xffK\x01\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0L\x01\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xffM\x01\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xffO\x01\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0R\x01\xff\xff\xff\xff\xff\xff\0\0\xff\xffS\x01\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0T\x01\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffU\x01\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xffV\x01\xff\xff\xff\xff\xff\xff\xff\xff\0\0W\x01\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff[\x01\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xffZ\x01\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff]\x01\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff^\x01\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0_\x01\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xffa\x01\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0c\x01b\x01\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0i\x01\xff\xff\xff\xff\0\0\xff\xff\0\0h\x01\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xffg\x01\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0m\x01\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xffl\x01\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0q\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xffn\x01\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xffp\x01\0\0\0\0\0\0\0\0o\x01\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0s\x01\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xffr\x01\0\0\xff\xff\xff\xff\0\0t\x01\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0y\x01\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xffz\x01\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff|\x01\0\0\xff\xff\0\0{\x01\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0}\x01\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0~\x01\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\x7f\x01\x82\x01\xff\xff\xff\xff\xff\xff\0\0\xff\xff\x80\x01\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\x81\x01\0\0\x84\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\x85\x01\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\x83\x01\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\x87\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff \x01\xff\xff$\x01\x8a\x01\x1b\x01\x1f\x01\x1a\x01\xff\xff\xff\xff\x95\x01\0\0#\x01\x1d\x01!\x01\xff\xff\x89\x01\xff\xff\x88\x01\"\x01\x1e\x01\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\x8b\x01\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xffk\x01\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\x8c\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\x8d\x01\0\0\0\0\xff\xff\0\0\x91\x01\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\x8e\x01\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\x8f\x01\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\x90\x01\xff\xff\0\0\0\0\x93\x01\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\x94\x01\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\x92\x01\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\x96\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\x97\x01\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\x98\x01\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\x99\x01\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\x9a\x01\xff\xff\xff\xff\x9b\x01\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\x9c\x01\xff\xff\0\0\xff\xff\0\0\x9f\x01\0\0\x9d\x01\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\x9e\x01\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xa1\x01\xff\xff\xff\xff\xa2\x01\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xa0\x01\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xa4\x01\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xad\x01\0\0\0\0\0\0\0\0\xb5\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xa9\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xa8\x01\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xaa\x01\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\xab\x01\xff\xff\0\0\xff\xff\xff\xff\xac\x01\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xae\x01\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xb0\x01\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xb2\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xaf\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xb6\x01\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xb3\x01\xff\xff\0\0\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xb7\x01\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xb8\x01\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xb9\x01\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xba\x01\0\0\0\0\0\0\xbe\x01\0\0\xff\xff\0\0\xbf\x01\0\0\0\0\xff\xff\0\0\xbc\x01\0\0\xbb\x01\xbd\x01\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xfb\x01\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd7\x01\xf8\x01\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xce\x01\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xc8\x01\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xc0\x01\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xc1\x01\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xc2\x01\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xc3\x01\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xc4\x01\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xc6\x01\xff\xff\0\0\xc5\x01\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xc7\x01\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xca\x01\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xc9\x01\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xcb\x01\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xcc\x01\xff\xff\0\0\0\0\0\0\xcd\x01\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xcf\x01\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xd0\x01\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xd1\x01\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xd2\x01\xff\xff\xff\xff\xff\xff\0\0\xd3\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xd4\x01\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xd5\x01\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd6\x01\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xd8\x01\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xd9\x01\xff\xff\0\0\0\0\xdc\x01\0\0\0\0\xda\x01\xdb\x01\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xdd\x01\0\0\xde\x01\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xeb\x01\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xdf\x01\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xe0\x01\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xe1\x01\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xe2\x01\xff\xff\xff\xff\0\0\0\0\xe3\x01\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xe4\x01\xff\xff\0\0\xe5\x01\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xe6\x01\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xe7\x01\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xe8\x01\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xe9\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xea\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xec\x01\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xed\x01\xff\xff\0\0\xee\x01\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xef\x01\0\0\xf0\x01\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xf1\x01\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xf3\x01\xf2\x01\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xf4\x01\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xf6\x01\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xf5\x01\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xf7\x01\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xf9\x01\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xfa\x01\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xfd\x01\0\0\xfc\x01\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xfe\x01\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\x02\xff\xff\0\0\0\0\x01\x02\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\x02\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\x03\x02\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\f\x02\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\b\x02\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\x07\x02\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\t\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\n\x02\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\x0b\x02\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\x0f\x02\r\x02\x0e\x02\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\x12\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\x11\x02\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\x13\x02\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\x14\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x02\xff\xff\0\0\x16\x02\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\x17\x02\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\x18\x02\0\0\xff\xff\x19\x02\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\x1e\x02\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\x1c\x02\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\x1d\x02\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\x1f\x02\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff.\x02&\x02\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff$\x02\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0#\x02\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0%\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0(\x02\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff*\x02\0\0\0\0'\x02\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0)\x02\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0+\x02\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff,\x02\xff\xff\xff\xff-\x02\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff/\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\x000\x02\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\x001\x02\0\0\xff\xff\0\x003\x02\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\x004\x02\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\x006\x02\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff5\x02\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\x007\x02\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff<\x02@\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff=\x02\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0;\x02\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff?\x02\xff\xff\xff\xff\xff\xff>\x02\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xffA\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0B\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0C\x02\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xffE\x02\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0F\x02G\x02\xff\xff\xff\xffN\x02\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0K\x02\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0H\x02\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xffI\x02\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0J\x02\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0L\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0M\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0O\x02\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xffQ\x02\0\0\xff\xffP\x02\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xffR\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xffb\x02\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff`\x02Y\x02\xff\xff\xff\xff\xff\xff\0\0W\x02\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xffX\x02\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xffZ\x02\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0[\x02\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff]\x02\\\x02\xff\xff^\x02\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0_\x02\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xffa\x02\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xffc\x02\0\0\0\0\0\0d\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0y\x02\xff\xff\0\0\0\0\0\0|\x02\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0i\x02m\x02\xff\xff\0\0\0\0\0\0\0\0\xff\xffh\x02\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0j\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xffk\x02\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0l\x02\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0n\x02\0\0\0\0\0\0\0\0o\x02\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0t\x02\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xffp\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xffq\x02\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0r\x02\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0s\x02\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0u\x02v\x02\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0w\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0x\x02\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xffz\x02\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0{\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0}\x02\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff~\x02\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\x7f\x02\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\x8d\x02\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\x82\x02\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\x83\x02\0\0\x84\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\x85\x02\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\x87\x02\0\0\0\0\0\0\0\0\x86\x02\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\x88\x02\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\x89\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\x8a\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\x8b\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\x8c\x02\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\x8e\x02\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\x8f\x02\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\x90\x02\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\x92\x02\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\x91\x02\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\x93\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\x94\x02\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\x95\x02\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\x96\x02\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\x97\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\x98\x02\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xb2\x02\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xa9\x02\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\x9d\x02\xff\xff\xff\xff\xff\xff\0\0\x9c\x02\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\x9e\x02\0\0\xff\xff\0\0\0\0\x9f\x02\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xa0\x02\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xa1\x02\xff\xff\0\0\xff\xff\xa4\x02\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa2\x02\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xa3\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xa6\x02\xa5\x02\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xa7\x02\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xa8\x02\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xaa\x02\0\0\xab\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xac\x02\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xad\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xae\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xaf\x02\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xb0\x02\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xb1\x02\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xb3\x02\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xb4\x02\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xb5\x02\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xc1\x02\0\0\xb8\x02\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xba\x02\xb9\x02\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\xbc\x02\0\0\0\0\xbe\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xbb\x02\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\xbf\x02\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\0\0\xff\xff\0\0\0\0\0\0\0\0\xc2\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc3\x02\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xc4\x02\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\xc7\x02\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xc6\x02\0\0\xff\xff\xff\xff\xff\xff\xc8\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xca\x02\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xcb\x02\0\0\0\0\0\0\0\0\xcc\x02\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xcd\x02\xff\xff\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xff\xff\xff\xff\xcd\x02\xcd\x02\0\0\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xff\xff\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xff\xff\xcd\x02\0\0\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\0\0\xcd\x02\xff\xff\xcd\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xcf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd6\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd5\x02\xd4\x02\xd4\x02\xd3\x02\xd1\x02\xd1\x02\xd1\x02\xd2\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd0\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\0\0\0\0\0\0\0\0\0\0\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xe5\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\xff\xff\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xe7\x02\xff\xff\xff\xff\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xe9\x02\xf5\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xf6\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xf7\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf1\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xf0\x02\xef\x02\xef\x02\xee\x02\xec\x02\xec\x02\xec\x02\xed\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xeb\x02\xf4\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\xf3\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
+  /* lex_check */"\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\xff\xff\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\xff\xff\0\0\xff\xff\0\0\xff\xff\x01\0\x01\0\0\0\0\0\x01\0\0\0\xf7\x02\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\f\0\x01\0%\0\x01\0\xf6\x02\xff\xff\xff\xff\xff\xff\xff\xff\x01\0\x01\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\0\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xfd\0\xff\xff\xff\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x02\0\x02\0\xff\xff\xff\xff\x02\0\b\0\b\0\xff\xff\xff\xff\b\0\xff\xff\0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\0\xff\xff\x02\0\xff\xff\xff\xff\b\0\xff\xff\b\0\x02\0\x02\0\xff\xff\xff\xff\xff\xff\b\0\b\0'\0'\0\x01\0\xff\xff'\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x02\0\xff\xff\xff\xff\xff\xff\xff\xff\b\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'\0\xff\xff'\0\x03\0\x03\0\xff\xff\xff\xff\x03\0'\0'\0\xff\xff'\0\xff\xff'\0\xff\xff\xff\xff'\0'\0'\0'\0'\0'\0'\0'\0'\0'\0\x03\0'\0\x03\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x03\0\x03\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xfe\0\xff\xff\x03\0\xff\xff\xff\xff\xff\xff\xff\xff\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x04\0\x04\0\xff\xff\xff\xff\x04\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\0\x0e\0\xff\xff\xff\xff\x0e\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\0\xff\xff\x04\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x04\0\x04\0\xff\xff\x0e\0\xff\xff\x0e\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\0\x0e\0\xff\xff\xff\xff\xff\xff\xff\xff\x02\0\xff\xff\x04\0\xff\xff\xff\xff\b\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0e\0\xff\xff\xff\xff\x05\0\x05\0\xff\xff\xff\xff\x05\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff+\0+\0'\0\x05\0+\0\x05\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\0\x05\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff+\0\xff\xff+\0\xff\xff\xff\xff\x03\0\xff\xff\x05\0+\0+\0\xff\xff+\0\x0e\0+\0\xff\xff\xff\xff+\0+\0+\0+\0+\0+\0+\0+\0+\0+\0\xff\xff+\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x04\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x04\0\x06\0\x06\0\xff\xff\xff\xff\x06\0\x07\0\x07\0\xff\xff\xff\xff\x07\0\x0e\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x06\0\xff\xff\x06\0\xff\xff\xff\xff\x07\0\xff\xff\x07\0\x06\0\x06\0\xff\xff\xff\xff\xff\xff\x07\0\x07\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x06\0\xff\xff\xff\xff\xff\xff\xff\xff\x07\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\0\xff\xff\x0f\0\x0f\0\xff\xff\xff\xff\x0f\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff+\0\xff\xff\xff\xff\xff\xff\xff\xff\x0f\0\xff\xff\x0f\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0f\0\x0f\0\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xd2\x02\xff\xff\x0f\0\xff\xff\xff\xff\xff\xff\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\xff\xff\xff\xff\x0f\0\xff\xff\xff\xff\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\x07\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff-\0-\0\xff\xff\xff\xff-\x008\x008\0\xff\xff\xff\xff8\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff-\0\xff\xff-\0\xff\xff\xff\xff8\0\xff\xff8\0-\0-\0\xff\xff\r\0\r\x008\x008\0\r\0-\0-\0-\0-\0-\0-\0-\0-\0-\0-\0\xff\xff-\0\x06\0\xff\xff\xff\xff\xff\xff8\0\x07\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\xff\xff\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\x0f\0\r\0\xff\xff\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\r\0\xff\xff\r\0\xff\xff\r\0\x10\0\x10\0\xff\xff\xff\xff\x10\0\x11\0\x11\0\xff\xff\xff\xff\x11\0\x12\0\x12\0\xff\xff\xff\xff\x12\0\x13\0\x13\0\xff\xff\xff\xff\x13\0\xff\xff\xff\xff\xff\xff\x10\0\xff\xff\x10\0\xff\xff\xff\xff\x11\0\xff\xff\x11\0\x10\0\x10\0\x12\0\xff\xff\x12\0\x11\0\x11\0\x13\0\xff\xff\x13\0\x12\0\x12\0\xff\xff\x14\0\x14\0\x13\0\x13\0\x14\0\xff\xff\x10\0\xff\xff\xff\xff\xff\xff\xff\xff\x11\0\xff\xff\xff\xff\xff\xff\xff\xff\x12\0\xff\xff\xff\xff\xff\xff\xff\xff\x13\0\xff\xff\x14\0\xff\xff\x14\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\0\x14\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\0\x15\0\xff\xff\xff\xff\x15\0\x10\0\x14\0-\0\xff\xff\x11\0\x12\0\xff\xff8\0\xff\xff\x16\0\x16\0\x11\0\x13\0\x16\0\x13\0\x10\0\xff\xff\x11\0\x15\0\xff\xff\x15\0\xff\xff\xff\xff\xff\xff\xff\xff\x12\0\x15\0\x15\0\xff\xff\x13\0\xff\xff\xff\xff\x16\0\xff\xff\x16\0\xff\xff\r\0\xff\xff\xff\xff\x14\0\x16\0\x16\0\xff\xff\x14\0\xff\xff\x15\0\x14\0\x17\0\x17\0\xff\xff\xff\xff\x17\0\x18\0\x18\0\xff\xff\xff\xff\x18\0\x19\0\x19\0\x16\0\xff\xff\x19\0\xff\xff\x14\0\xff\xff\xff\xff\xff\xff\x1a\0\x1a\0\xff\xff\x17\0\x1a\0\x17\0\xff\xff\xff\xff\x18\0\xff\xff\x18\0\x17\0\x17\0\x19\0\xff\xff\x19\0\x18\0\x18\0\xff\xff\xff\xff\x15\0\x19\0\x19\0\x1a\0\xff\xff\x1a\0\xff\xff\xff\xff\xff\xff\xff\xff\x17\0\x1a\0\x1a\0\x1b\0\x1b\0\x18\0\xff\xff\x1b\0\x1c\0\x1c\0\x19\0\x16\0\x1c\0\x16\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\0\xff\xff\xff\xff\x16\0\xff\xff\xff\xff\x1b\0\xff\xff\x1b\0\xff\xff\xff\xff\x1c\0\xff\xff\x1c\0\x1b\0\x1b\0\xff\xff\xff\xff\xff\xff\x1c\0\x1c\0\xff\xff\xff\xff\x1d\0\x1d\0\xff\xff\xff\xff\x1d\0\x19\0\xff\xff\xff\xff\x18\0\x17\0\x1b\0\x18\0\xff\xff\xff\xff\x10\0\x1c\0\xff\xff\x18\0\xff\xff\x11\0\xff\xff\xff\xff\x19\0\x1d\0\x12\0\x1d\0\xff\xff\xff\xff\x1a\0\x13\0\xff\xff\x1d\0\x1d\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1d\0\xff\xff\xff\xff\x1d\0\xff\xff\xff\xff\xff\xff\xff\xff\x1d\0\xff\xff\x1b\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\0\xff\xff\xff\xff\xff\xff\x1b\0\xff\xff\x1c\0\xff\xff\x1c\0\xff\xff\x1b\0\xff\xff\xff\xff\x1c\0\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xed\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1d\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\0\xff\xff\xff\xff\xff\xff\xff\xff\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\xff\xff\x17\0\x1e\0\xff\xff\xff\xff\xff\xff\x18\0\xff\xff\xff\xff\xff\xff\xff\xff\x19\0:\0:\0\xff\xff\xff\xff:\0\xff\xff\xff\xff\xff\xff\xff\xff\x1a\0\xff\xff\xff\xff.\0.\0\xff\xff\xff\xff.\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff:\0\xff\xff:\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff:\0:\0\xff\xff\xff\xff.\0\xff\xff.\0\xff\xff\xff\xff\xff\xff\xff\xff\x1b\0.\0.\0\xff\xff\xff\xff\x1c\0\x1e\0:\0:\0.\0.\0.\0.\0.\0.\0.\0.\0.\0.\0\xff\xff.\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1d\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1f\0\x1f\0\xff\xff\xff\xff\x1f\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff \0 \0\xff\xff\xff\xff \0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1f\0\xff\xff\x1f\0!\0!\0\xff\xff\xff\xff!\0\x1f\0\x1f\0 \0:\0 \0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff \0 \0\xff\xff\xff\xff\xff\xff.\0\xff\xff\xff\xff!\0\x1f\0!\0 \0\xff\xff\xff\xff \0\xff\xff!\0!\0\xff\xff \0\xff\xff\xff\xff\xff\xff\xff\xff!\0!\0!\0!\0!\0!\0!\0!\0!\0!\0\xff\xff!\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1f\0\"\0\"\0\xff\xff\xff\xff\"\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1f\0 \0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff \0 \0\"\0\xff\xff\"\0#\0#\0\xff\xff\xff\xff#\0\"\0\"\0!\0\xff\xff\xff\xff\xff\xff\"\0!\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0\"\0#\0\"\0#\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff#\0#\0\xff\xff\"\0\xff\xff\xff\xff#\0\xff\xff#\0#\0#\0#\0#\0#\0#\0#\0#\0#\0\xff\xff#\0\xff\xff\xff\xff\xff\xff(\0(\0\xff\xff\xff\xff(\0\xff\xff#\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\"\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff(\0\xff\xff(\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff(\0(\x001\x001\0\xff\xff\xff\xff1\0#\0(\0(\0(\0(\0(\0(\0(\0(\0(\0(\0\xff\xff(\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff1\0#\x001\0\xff\xff(\0\xff\xff\xff\xff\xff\xff1\x001\0)\0)\0\xff\xff\xff\xff)\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1f\0\xff\xff\xff\xff\xff\xff\xff\xff1\0\xff\xff\xff\xff\xff\xff\xff\xff \0)\0\xff\xff)\0(\0\xff\xff\xff\xff\xff\xff\xff\xff)\0)\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff!\0)\0)\0)\0)\0)\0)\0)\0)\0)\0)\0\xff\xff)\0\xff\xff\xff\xff\xff\xff\xff\xff1\0)\0)\0)\0)\0)\0)\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff*\0*\0\xff\xff\xff\xff*\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff)\0)\0)\0)\0)\0)\0\xff\xff*\0\xff\xff*\0\xff\xff\xff\xff\xff\xff\"\0\xff\xff*\0*\0\xff\xff\xff\xff\xff\xff\xff\xff*\0\xff\xff*\0*\0*\0*\0*\0*\0*\0*\0*\0*\0\xff\xff*\0\xff\xff\xff\xff\xff\xff\xff\xff#\0*\0*\0*\0*\0*\0*\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff*\0\xff\xff,\0,\0\xff\xff\xff\xff,\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff*\0*\0*\0*\0*\0*\0\xff\xff\xff\xff,\0\xff\xff,\0\xff\xff\xff\xff\xff\xff\xff\xff*\0,\0,\0\xff\xff\xff\xff\xff\xff(\0\xff\xff\xff\xff,\0,\0,\0,\0,\0,\0,\0,\0,\0,\0\xff\xff,\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff,\0,\0,\0,\0,\0,\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff1\0\xff\xff,\0\xff\xff/\0/\0\xff\xff\xff\xff/\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff,\0,\0,\0,\0,\0,\0\xff\xff\xff\xff/\0\xff\xff/\0\xff\xff\xff\xff\xff\xff)\0,\0/\0/\x000\x000\0\xff\xff\xff\xff0\0\xff\xff/\0/\0/\0/\0/\0/\0/\0/\0/\0/\0\xff\xff/\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff0\0\xff\xff0\x002\x002\0\xff\xff\xff\xff2\x000\x000\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff0\x000\x000\x000\x000\x000\x000\x000\x000\x000\x002\x000\x002\x003\x003\0\xff\xff\xff\xff3\x002\x002\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff*\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff3\x002\x003\x004\x004\0\xff\xff\xff\xff4\x003\x003\0\xff\xff\xff\xff\xff\xff\xff\xff3\0\xff\xff3\x003\x003\x003\x003\x003\x003\x003\x003\x003\x004\x003\x004\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff4\x004\0\xff\xff3\0\xff\xff\xff\xff4\0\xff\xff4\x004\x004\x004\x004\x004\x004\x004\x004\x004\x002\x004\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff5\x005\0\xff\xff4\x005\0\xff\xff,\0\xff\xff\xff\xff3\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff5\0\xff\xff5\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff5\x005\0\xff\xff\xff\xff4\0\xff\xff\xff\xff\xff\xff5\x005\x005\x005\x005\x005\x005\x005\x005\x005\0\xff\xff5\0\xff\xff\xff\xff\xff\xff4\0\xff\xff5\x005\x005\x005\x005\x005\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff;\0;\0\xff\xff\xff\xff;\0\xff\xff\xff\xff\xff\xff/\0\xff\xff\xff\xff\xff\xff6\x006\0\xff\xff\xff\xff6\x005\x005\x005\x005\x005\x005\0;\0\xff\xff;\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff;\0;\0\xff\xff\xff\xff6\0\xff\xff6\0\xff\xff;\0\xff\xff0\0\xff\xff6\x006\0\xff\xff\xff\xff\xff\xff\xff\xff6\0;\x006\x006\x006\x006\x006\x006\x006\x006\x006\x006\0\xff\xff6\0\xff\xff\xff\xff\xff\xff\xff\xff2\x006\x006\x006\x006\x006\x006\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff6\0\xff\xff7\x007\0\xff\xff\xff\xff7\0\xff\xff\xff\xff\xff\xff3\0\xff\xff9\x009\0\xff\xff\xff\xff9\x006\x006\x006\x006\x006\x006\0\xff\xff\xff\xff7\0\xff\xff7\0\xff\xff\xff\xff\xff\xff\xff\xff6\x007\x007\x009\x004\x009\0<\0<\0\xff\xff\xff\xff<\x009\x009\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff7\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff<\x009\0<\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff<\0<\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff=\0=\0\xff\xff\xff\xff=\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff<\0\xff\xff\xff\xff\xff\xff\xff\xff5\0\xff\xff7\0\xff\xff\xff\xff\xff\xff\xff\xff=\0\xff\xff=\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff=\0=\0\xff\xff\xff\xff\xff\xff9\0\xff\xff\xff\xff=\0=\0=\0=\0=\0=\0=\0=\0=\0=\0\xff\xff=\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff=\0=\0=\0=\0=\0=\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff<\0>\0>\0\xff\xff\xff\xff>\0?\0?\0\xff\xff\xff\xff?\0\xff\xff\xff\xff\xff\xff\xff\xff;\0=\0=\0=\0=\0=\0=\0\xff\xff\xff\xff>\0\xff\xff>\x006\0\xff\xff?\0\xff\xff?\0>\0>\0\xff\xff\xff\xff\xff\xff?\0?\0\xff\xff>\0>\0>\0>\0>\0>\0>\0>\0>\0>\0\xff\xff>\0\xff\xff\xff\xff\xff\xff\xff\xff?\0>\0>\0>\0>\0>\0>\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff@\0@\0\xff\xff\xff\xff@\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffA\0A\0\xff\xff\xff\xffA\0\xff\xff\xff\xff>\0>\0>\0>\0>\0>\0@\0\xff\xff@\0B\0B\x007\0\xff\xffB\0@\0@\0A\0\xff\xffA\0\xff\xff?\x009\0\xff\xff\xff\xffA\0A\0C\0C\0\xff\xff\xff\xffC\0\xff\xffB\0@\0B\0\xff\xffA\0\xff\xffD\0D\0B\0B\0D\0A\0\xff\xff\xff\xff\xff\xff<\0\xff\xffC\0B\0C\0E\0E\0\xff\xff\xff\xffE\0C\0C\0B\0\xff\xffD\0\xff\xffD\0F\0F\0\xff\xff\xff\xffF\0D\0D\0\xff\xff\xff\xff\xff\xff\xff\xffE\0C\0E\0G\0G\0\xff\xff\xff\xffG\0E\0E\0\xff\xff=\0F\0D\0F\0H\0H\0\xff\xff\xff\xffH\0F\0F\0\xff\xff\xff\xff\xff\xff\xff\xffG\0E\0G\0\xff\xff\xff\xff\xff\xffI\0I\0G\0G\0I\0\xff\xffH\0F\0H\0\xff\xff\xff\xff\xff\xffC\0\xff\xffH\0H\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffG\0C\0I\0\xff\xffI\0\xff\xff\xff\xffC\0\xff\xff\xff\xffI\0I\0H\0\xff\xff\xff\xffJ\0J\0\xff\xffD\0J\0K\0K\0\xff\xff\xff\xffK\0\xff\xffE\0\xff\xff\xff\xffI\0\xff\xff>\0\xff\xff\xff\xffF\0\xff\xff?\0\xff\xffJ\0\xff\xffJ\0\xff\xffG\0K\0\xff\xffK\0J\0J\0\xff\xffL\0L\0K\0K\0L\0\xff\xff\xff\xff\xff\xffK\0\xff\xffM\0M\0\xff\xff\xff\xffM\0\xff\xffJ\0\xff\xff\xff\xff\xff\xff\xff\xffK\0\xff\xffL\0\xff\xffL\0N\0N\0\xff\xff\xff\xffN\0L\0L\0M\0\xff\xffM\0\xff\xffI\0\xff\xff\xff\xff\xff\xffM\0M\0O\0O\0\xff\xff\xff\xffO\0\xff\xffN\0L\0N\0\xff\xff@\0\xff\xff\xff\xff\xff\xffN\0N\0\xff\xffM\0\xff\xff\xff\xffA\0\xff\xff\xff\xffO\0\xff\xffO\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffO\0O\0N\0\xff\xff\xff\xffB\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffL\0\xff\xffL\0L\0L\0O\0L\0\xff\xffC\0\xff\xff\xff\xffL\0L\0L\0L\0L\0\xff\xffL\0L\0L\0D\0\xff\xffL\0L\0\xff\xffP\0P\0M\0\xff\xffP\0\xff\xff\xff\xff\xff\xff\xff\xffE\0\xff\xffQ\0Q\0\xff\xff\xff\xffQ\0\xff\xff\xff\xffN\0\xff\xff\xff\xffF\0O\0P\0\xff\xffP\0R\0R\0\xff\xff\xff\xffR\0P\0P\0\xff\xffQ\0G\0Q\0O\0\xff\xff\xff\xffS\0S\0Q\0Q\0S\0\xff\xff\xff\xffH\0\xff\xffR\0P\0R\0U\0U\0\xff\xff\xff\xffU\0R\0R\0\xff\xff\xff\xffQ\0\xff\xffS\0I\0S\0T\0T\0\xff\xff\xff\xffT\0S\0S\0\xff\xff\xff\xffU\0R\0U\0\xff\xff\xff\xff\xff\xffV\0V\0U\0U\0V\0\xff\xff\xff\xff\xff\xffT\0S\0T\0P\0\xff\xff\xff\xff\xff\xff\xff\xffT\0T\0\xff\xffJ\0\xff\xffU\0\xff\xffV\0K\0V\0W\0W\0\xff\xff\xff\xffW\0V\0V\0\xff\xffQ\0T\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffR\0\xff\xffW\0V\0W\0\xff\xffL\0\xff\xff\xff\xff\xff\xffW\0W\0\xff\xff\xff\xffX\0X\0M\0S\0X\0\xff\xffU\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffY\0Y\0W\0T\0Y\0N\0\xff\xff\xff\xff\xff\xff\xff\xffX\0\xff\xffX\0T\0\xff\xff\xff\xff\xff\xff\xff\xffX\0X\0\xff\xff\xff\xffO\0Y\0\xff\xffY\0\xff\xff\xff\xff\xff\xffZ\0Z\0Y\0Y\0Z\0V\0\xff\xff\xff\xffX\0\xff\xff\xff\xff[\0[\0\xff\xffW\0[\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffY\0\xff\xffZ\0W\0Z\0\\\0\\\0\xff\xff\xff\xff\\\0Z\0Z\0\xff\xff[\0\xff\xff[\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff[\0[\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\\\0Z\0\\\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\\\0\\\0\xff\xffX\0[\0\xff\xffP\0\xff\xff\xff\xffY\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffQ\0\xff\xff\\\0\xff\xffY\0Y\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffR\0\xff\xff\xff\xffZ\0\xff\xff\xff\xff\xff\xff]\0]\0\xff\xff\xff\xff]\0\xff\xffZ\0S\0\xff\xff\xff\xff\xff\xffZ\0\xff\xff\xff\xff[\0\xff\xff\xff\xff[\0\xff\xffU\0\xff\xff\xff\xff[\0]\0\xff\xff]\0^\0^\0\xff\xff\xff\xff^\0]\0]\0T\0\xff\xff\xff\xff_\0_\0\xff\xff\xff\xff_\0`\0`\0\\\0\xff\xff`\0\xff\xff\xff\xffV\0^\0]\0^\0a\0a\0\xff\xff\xff\xffa\0^\0^\0_\0\xff\xff_\0\xff\xff\xff\xff`\0\xff\xff`\0_\0_\0\xff\xff\xff\xff\xff\xff`\0`\0W\0a\0^\0a\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffa\0a\0\xff\xff_\0\xff\xff\xff\xffb\0b\0`\0\xff\xffb\0c\0c\0\xff\xff\xff\xffc\0\xff\xff\xff\xff\xff\xffa\0\xff\xff\xff\xff\xff\xffd\0d\0\xff\xffX\0d\0\xff\xffb\0]\0b\0\xff\xff\xff\xffc\0\xff\xffc\0b\0b\0Y\0\xff\xff\xff\xffc\0c\0^\0\xff\xffd\0\xff\xffd\0e\0e\0\xff\xff\xff\xffe\0d\0d\0b\0\xff\xff\xff\xff_\0\xff\xffc\0\xff\xff\xff\xff\xff\xff`\0f\0f\0Z\0\xff\xfff\0\xff\xffe\0d\0e\0\xff\xff\xff\xff\xff\xff\xff\xff[\0e\0e\0g\0g\0\xff\xff\xff\xffg\0\xff\xff\xff\xfff\0\xff\xfff\0\xff\xff\xff\xff\\\0\xff\xff\xff\xfff\0f\0e\0\xff\xff\xff\xffh\0h\0\xff\xffg\0h\0g\0\xff\xffd\0\xff\xff\xff\xff\xff\xffg\0g\0\xff\xfff\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffh\0\xff\xffh\0\xff\xff\xff\xff\xff\xff\xff\xffg\0h\0h\0e\0i\0i\0\xff\xff\xff\xffi\0\xff\xffh\0\xff\xffh\0\xff\xff\xff\xffj\0j\0h\0\xff\xffj\0h\0\xff\xfff\0\xff\xff\xff\xff\xff\xff\xff\xffi\0\xff\xffi\0k\0k\0]\0\xff\xffk\0i\0i\0\xff\xffj\0\xff\xffj\0g\0\xff\xff\xff\xff\xff\xffi\0j\0j\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffk\0i\0k\0\xff\xff\xff\xff^\0\xff\xffj\0k\0k\0l\0l\0j\0\xff\xffl\0_\0\xff\xff\xff\xff\xff\xff\xff\xff`\0m\0m\0\xff\xff\xff\xffm\0\xff\xffk\0\xff\xff\xff\xff\xff\xffa\0\xff\xffl\0\xff\xffl\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffl\0l\0\xff\xffm\0\xff\xffm\0n\0n\0\xff\xff\xff\xffn\0m\0m\0\xff\xff\xff\xff\xff\xffo\0o\0\xff\xffl\0o\0\xff\xffk\0\xff\xff\xff\xff\xff\xff\xff\xffb\0\xff\xffn\0m\0n\0c\0\xff\xff\xff\xff\xff\xff\xff\xffn\0n\0o\0\xff\xffo\0p\0p\0d\0\xff\xffp\0o\0o\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffn\0q\0q\0\xff\xff\xff\xffq\0\xff\xff\xff\xff\xff\xffp\0o\0p\0r\0r\0e\0\xff\xffr\0p\0p\0l\0\xff\xffl\0\xff\xff\xff\xffq\0\xff\xffq\0\xff\xff\xff\xff\xff\xff\xff\xfff\0q\0q\0\xff\xffr\0p\0r\0s\0s\0\xff\xff\xff\xffs\0r\0r\0\xff\xff\xff\xffg\0t\0t\0\xff\xffq\0t\0u\0u\0\xff\xffn\0u\0n\0\xff\xff\xff\xffs\0r\0s\0v\0v\0\xff\xffh\0v\0s\0s\0t\0\xff\xfft\0\xff\xff\xff\xffu\0\xff\xffu\0t\0t\0\xff\xff\xff\xff\xff\xffu\0u\0\xff\xffv\0s\0v\0w\0w\0\xff\xff\xff\xffw\0v\0v\0\xff\xfft\0\xff\xff\xff\xffi\0\xff\xffu\0\xff\xff\xff\xff\xff\xffq\0\xff\xffq\0\xff\xff\xff\xffj\0w\0v\0w\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffw\0w\0\xff\xff\xff\xffx\0x\0k\0\xff\xffx\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffw\0\xff\xffu\0\xff\xff\xff\xff\xff\xff\xff\xfft\0x\0\xff\xffx\0y\0y\0t\0\xff\xffy\0x\0x\0\xff\xff\xff\xffl\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffv\0\xff\xff\xff\xff\xff\xff\xff\xffm\0\xff\xff\xff\xffy\0x\0y\0z\0z\0\xff\xff\xff\xffz\0y\0y\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffy\0\xff\xffy\0\xff\xffw\0\xff\xffn\0y\0\xff\xffz\0y\0z\0\xff\xff\xff\xff\xff\xff\xff\xffo\0z\0z\0\xff\xff{\0{\0\xff\xff\xff\xff{\0\xff\xffx\0z\0\xff\xff\xff\xff|\0|\0\xff\xff\xff\xff|\0\xff\xffz\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffp\0{\0\xff\xff{\0}\0}\0\xff\xff\xff\xff}\0{\0{\0|\0\xff\xff|\0\xff\xffq\0\xff\xff\xff\xff\xff\xff|\0|\0\xff\xff\xff\xff{\0\xff\xff\xff\xffr\0}\0{\0}\0\xff\xff\xff\xff\xff\xff~\0~\0}\0}\0~\0|\0\xff\xff\xff\xff\xff\xff\xff\xff\x7f\0\x7f\0\xff\xff\xff\xff\x7f\0\xff\xff\xff\xff\xff\xff\xff\xffs\0\xff\xff}\0\xff\xff~\0\xff\xff~\0\x81\0\x81\0\xff\xfft\0\x81\0~\0~\0\x7f\0u\0\x7f\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7f\0\x7f\0\x80\0\x80\0v\0\xff\xff\x80\0\xff\xff\x81\0~\0\x81\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x81\0\x81\0\xff\xff\x7f\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\0\xff\xff\x80\0\x82\0\x82\0w\0\xff\xff\x82\0\x80\0\x80\0\x81\0\xff\xff\xff\xff\x83\0\x83\0\xff\xff\xff\xff\x83\0\x84\0\x84\0~\0\xff\xff\x84\0\xff\xff\xff\xff\xff\xff\x82\0\x80\0\x82\0\x85\0\x85\0\xff\xff\xff\xff\x85\0\x82\0\x82\0\x83\0\xff\xff\x83\0\xff\xffx\0\x84\0\xff\xff\x84\0\x83\0\x83\0\xff\xff\xff\xff\xff\xff\x84\0\x84\0\xff\xff\x85\0\x82\0\x85\0\x86\0\x86\0\xff\xff\xff\xff\x86\0\x85\0\x85\0\xff\xff\x83\0\xff\xff\xff\xffy\0\xff\xff\x84\0\xff\xff\x87\0\x87\0\xff\xff\xff\xff\x87\0\xff\xff\xff\xff\xff\xff\x86\0\x85\0\x86\0\xff\xff\xff\xff\x80\0\xff\xff\x80\0\x86\0\x86\0\xff\xff\xff\xff\xff\xff\xff\xffz\0\x87\0\xff\xff\x87\0\x88\0\x88\0\xff\xff\xff\xff\x88\0\x87\0\x87\0\xff\xff\xff\xff\x86\0\x89\0\x89\0\x84\0\xff\xff\x89\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\0\xff\xff\xff\xff\x88\0\x87\0\x88\0\xff\xff\xff\xff\xff\xff\xff\xff{\0\x88\0\x88\0\x89\0\x85\0\x89\0\xff\xff\xff\xff\xff\xff\xff\xff|\0\x89\0\x89\0\xff\xff\x8a\0\x8a\0\xff\xff\xff\xff\x8a\0\xff\xff\x88\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff}\0\x8b\0\x8b\0\xff\xff\x89\0\x8b\0\xff\xff\xff\xff\xff\xff\xff\xff\x86\0\x8a\0\xff\xff\x8a\0\xff\xff\xff\xff\xff\xff\x8c\0\x8c\0\x8a\0\x8a\0\x8c\0\xff\xff\xff\xff\x8b\0\xff\xff\x8b\0\x8d\0\x8d\0~\0\xff\xff\x8d\0\x8b\0\x8b\0\xff\xff\x88\0\xff\xff\xff\xff\x8a\0\x7f\0\x8c\0\xff\xff\x8c\0\x8e\0\x8e\0\x89\0\xff\xff\x8e\0\x8c\0\x8c\0\x8d\0\x8b\0\x8d\0\x8f\0\x8f\0\x81\0\xff\xff\x8f\0\x8d\0\x8d\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8e\0\x8c\0\x8e\0\x90\0\x90\0\xff\xff\x80\0\x90\0\x8e\0\x8e\0\x8f\0\x8d\0\x8f\0\x91\0\x91\0\xff\xff\xff\xff\x91\0\x8f\0\x8f\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\0\x8e\0\x90\0\x92\0\x92\0\xff\xff\x82\0\x92\0\x90\0\x90\0\x91\0\x8f\0\x91\0\x93\0\x93\0\xff\xff\x83\0\x93\0\x91\0\x91\0\xff\xff\x84\0\xff\xff\xff\xff\x8c\0\xff\xff\x92\0\x90\0\x92\0\xff\xff\xff\xff\xff\xff\x85\0\xff\xff\x92\0\x92\0\x93\0\x91\0\x93\0\x94\0\x94\0\xff\xff\xff\xff\x94\0\x93\0\x93\0\xff\xff\x8f\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x92\0\xff\xff\x96\0\x96\0\xff\xff\x86\0\x96\0\x8e\0\xff\xff\x94\0\x93\0\x94\0\x95\0\x95\0\xff\xff\xff\xff\x95\0\x94\0\x94\0\xff\xff\x87\0\xff\xff\x97\0\x97\0\xff\xff\x96\0\x97\0\x96\0\xff\xff\xff\xff\x90\0\xff\xff\x90\0\x96\0\x96\0\x95\0\x94\0\x95\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x95\0\x95\0\x97\0\x88\0\x97\0\xff\xff\xff\xff\xff\xff\xff\xff\x96\0\x97\0\x97\0\xff\xff\x89\0\xff\xff\xff\xff\xff\xff\x98\0\x98\0\x95\0\xff\xff\x98\0\xff\xff\xff\xff\x93\0\xff\xff\xff\xff\x99\0\x99\0\x97\0\xff\xff\x99\0\x9a\0\x9a\0\xff\xff\xff\xff\x9a\0\xff\xff\xff\xff\x94\0\x98\0\xff\xff\x98\0\x94\0\xff\xff\x96\0\xff\xff\x8a\0\x98\0\x98\0\x99\0\xff\xff\x99\0\xff\xff\xff\xff\x9a\0\xff\xff\x9a\0\x99\0\x99\0\x8b\0\xff\xff\xff\xff\x9a\0\x9a\0\x9b\0\x9b\0\x98\0\xff\xff\x9b\0\x95\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\0\x99\0\xff\xff\xff\xff\xff\xff\xff\xff\x9a\0\xff\xff\xff\xff\x97\0\x8d\0\x97\0\x9b\0\xff\xff\x9b\0\x9c\0\x9c\0\xff\xff\xff\xff\x9c\0\x9b\0\x9b\0\xff\xff\xff\xff\xff\xff\xff\xff\x8e\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8f\0\xff\xff\x9c\0\x9b\0\x9c\0\x9d\0\x9d\0\xff\xff\xff\xff\x9d\0\x9c\0\x9c\0\xff\xff\xff\xff\xff\xff\xff\xff\x90\0\xff\xff\x9e\0\x9e\0\xff\xff\xff\xff\x9e\0\xff\xff\xff\xff\xff\xff\x91\0\x9a\0\x9d\0\x9c\0\x9d\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9d\0\x9d\0\xff\xff\xff\xff\xff\xff\x9e\0\x92\0\x9e\0\xff\xff\x9b\0\xff\xff\xff\xff\xff\xff\x9e\0\x9e\0\xff\xff\x93\0\xff\xff\xff\xff\x9d\0\x9f\0\x9f\0\xff\xff\xff\xff\x9f\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa0\0\xa0\0\x9e\0\xff\xff\xa0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x94\0\x9f\0\xff\xff\x9f\0\xff\xff\xff\xff\x9c\0\xff\xff\xff\xff\x9f\0\x9f\0\xa0\0\xff\xff\xa0\0\xff\xff\xff\xff\x96\0\xa1\0\xa1\0\xa0\0\xa0\0\xa1\0\xff\xff\xff\xff\xff\xff\xff\xff\x95\0\xff\xff\x9f\0\xff\xff\x9d\0\xa2\0\xa2\0\xff\xff\xff\xff\xa2\0\x97\0\xff\xff\xa0\0\xff\xff\xa1\0\xff\xff\xa1\0\xff\xff\xff\xff\x9e\0\xa3\0\xa3\0\xa1\0\xa1\0\xa3\0\xff\xff\xff\xff\xff\xff\xa2\0\xa1\0\xa2\0\xff\xff\xff\xff\xff\xff\xa4\0\xa4\0\xa2\0\xa2\0\xa4\0\xff\xff\xff\xff\xa1\0\xff\xff\xa3\0\x9f\0\xa3\0\xff\xff\xff\xff\x98\0\xa5\0\xa5\0\xa3\0\xa3\0\xa5\0\xff\xff\xa2\0\xff\xff\xa4\0\x99\0\xa4\0\xa6\0\xa6\0\xa3\0\x9a\0\xa6\0\xa4\0\xa4\0\xff\xff\xff\xff\xa0\0\xa3\0\xff\xff\xa5\0\xff\xff\xa5\0\xa4\0\xff\xff\xff\xff\xff\xff\xff\xff\xa5\0\xa5\0\xff\xff\xa6\0\xa4\0\xa6\0\xa7\0\xa7\0\xff\xff\xff\xff\xa7\0\xa6\0\xa6\0\xff\xff\xff\xff\xff\xff\x9b\0\xff\xff\xa2\0\xa5\0\xa8\0\xa8\0\xff\xff\xff\xff\xa8\0\xff\xff\xff\xff\xff\xff\xff\xff\xa7\0\xa6\0\xa7\0\xa9\0\xa9\0\xff\xff\xff\xff\xa9\0\xa7\0\xa7\0\xff\xff\xff\xff\xff\xff\x9c\0\xa8\0\xff\xff\xa8\0\xaa\0\xaa\0\xff\xff\xff\xff\xaa\0\xa8\0\xa8\0\xff\xff\xff\xff\xa9\0\xa7\0\xa9\0\xff\xff\xff\xff\xff\xff\xab\0\xab\0\xa9\0\xa9\0\xab\0\xff\xff\xff\xff\x9d\0\xaa\0\xa8\0\xaa\0\xac\0\xac\0\xff\xff\xff\xff\xac\0\xaa\0\xaa\0\xa6\0\xff\xff\x9e\0\xa9\0\xff\xff\xab\0\xa6\0\xab\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\0\xab\0\xff\xff\xac\0\xaa\0\xac\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xac\0\xac\0\xad\0\xad\0\xff\xff\xff\xff\xad\0\xff\xff\xab\0\xff\xff\xff\xff\xff\xff\xff\xff\xae\0\xae\0\xff\xff\x9f\0\xae\0\xff\xff\xac\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\0\xa0\0\xad\0\xaf\0\xaf\0\xff\xff\xff\xff\xaf\0\xad\0\xad\0\xff\xff\xae\0\xff\xff\xae\0\xb0\0\xb0\0\xff\xff\xff\xff\xb0\0\xae\0\xae\0\xff\xff\xff\xff\xaa\0\xff\xff\xff\xff\xaf\0\xad\0\xaf\0\xff\xff\xa1\0\xff\xff\xff\xff\xff\xff\xaf\0\xaf\0\xff\xff\xb0\0\xae\0\xb0\0\xff\xff\xff\xff\xff\xff\xff\xff\xa2\0\xb0\0\xb0\0\xb1\0\xb1\0\xff\xff\xff\xff\xb1\0\xff\xff\xaf\0\xff\xff\xff\xff\xff\xff\xac\0\xff\xff\xa3\0\xff\xff\xb2\0\xb2\0\xff\xff\xb0\0\xb2\0\xff\xff\xff\xff\xff\xff\xff\xff\xb1\0\xff\xff\xb1\0\xa4\0\xff\xff\xff\xff\xff\xff\xff\xff\xb1\0\xb1\0\xff\xff\xb3\0\xb3\0\xff\xff\xb2\0\xb3\0\xb2\0\xff\xff\xa5\0\xaf\0\xff\xff\xff\xff\xb2\0\xb2\0\xff\xff\xff\xff\xff\xff\xb1\0\xff\xff\xa6\0\xb0\0\xff\xff\xff\xff\xff\xff\xb3\0\xff\xff\xb3\0\xff\xff\xff\xff\xff\xff\xff\xff\xb2\0\xb3\0\xb3\0\xff\xff\xff\xff\xff\xff\xb4\0\xb4\0\xff\xff\xff\xff\xb4\0\xff\xff\xff\xff\xff\xff\xa7\0\xff\xff\xff\xff\xff\xff\xb5\0\xb5\0\xb3\0\xff\xff\xb5\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa8\0\xb4\0\xff\xff\xb4\0\xb6\0\xb6\0\xff\xff\xff\xff\xb6\0\xb4\0\xb4\0\xff\xff\xa9\0\xb5\0\xb1\0\xb5\0\xb1\0\xff\xff\xff\xff\xb7\0\xb7\0\xb5\0\xb5\0\xb7\0\xff\xff\xff\xff\xaa\0\xb6\0\xb4\0\xb6\0\xb8\0\xb8\0\xff\xff\xff\xff\xb8\0\xb6\0\xb6\0\xff\xff\xff\xff\xff\xff\xb5\0\xab\0\xb7\0\xff\xff\xb7\0\xb9\0\xb9\0\xff\xff\xff\xff\xb9\0\xb7\0\xb7\0\xac\0\xb8\0\xb6\0\xb8\0\xba\0\xba\0\xff\xff\xff\xff\xba\0\xb8\0\xb8\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb9\0\xb7\0\xb9\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb9\0\xb9\0\xff\xff\xba\0\xb8\0\xba\0\xff\xff\xb9\0\xb4\0\xad\0\xb4\0\xba\0\xba\0\xbb\0\xbb\0\xff\xff\xff\xff\xbb\0\xff\xff\xb9\0\xae\0\xff\xff\xff\xff\xff\xff\xbc\0\xbc\0\xff\xff\xff\xff\xbc\0\xff\xff\xba\0\xb7\0\xff\xff\xff\xff\xff\xff\xaf\0\xbb\0\xff\xff\xbb\0\xbd\0\xbd\0\xff\xff\xff\xff\xbd\0\xbb\0\xbb\0\xb0\0\xbc\0\xff\xff\xbc\0\xbe\0\xbe\0\xff\xff\xff\xff\xbe\0\xbc\0\xbc\0\xb8\0\xbb\0\xff\xff\xff\xff\xff\xff\xbd\0\xbb\0\xbd\0\xbf\0\xbf\0\xbc\0\xff\xff\xbf\0\xbd\0\xbd\0\xff\xff\xbe\0\xbc\0\xbe\0\xba\0\xff\xff\xff\xff\xb1\0\xff\xff\xbe\0\xbe\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbf\0\xbd\0\xbf\0\xc0\0\xc0\0\xb2\0\xff\xff\xc0\0\xbf\0\xbf\0\xff\xff\xff\xff\xbe\0\xc1\0\xc1\0\xff\xff\xff\xff\xc1\0\xc2\0\xc2\0\xff\xff\xff\xff\xc2\0\xff\xff\xff\xff\xb3\0\xc0\0\xbf\0\xc0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc0\0\xc0\0\xc1\0\xff\xff\xc1\0\xff\xff\xff\xff\xc2\0\xff\xff\xc2\0\xc1\0\xc1\0\xff\xff\xff\xff\xff\xff\xc2\0\xc2\0\xc3\0\xc3\0\xc0\0\xff\xff\xc3\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb4\0\xff\xff\xc1\0\xff\xff\xc4\0\xc4\0\xff\xff\xc2\0\xc4\0\xbe\0\xff\xff\xff\xff\xb5\0\xc3\0\xff\xff\xc3\0\xff\xff\xbf\0\xff\xff\xff\xff\xff\xff\xc3\0\xc3\0\xff\xff\xff\xff\xff\xff\xb6\0\xc4\0\xc3\0\xc4\0\xc5\0\xc5\0\xc0\0\xff\xff\xc5\0\xc4\0\xc4\0\xff\xff\xc1\0\xff\xff\xc3\0\xb7\0\xc4\0\xc6\0\xc6\0\xff\xff\xff\xff\xc6\0\xff\xff\xff\xff\xff\xff\xff\xff\xb8\0\xc5\0\xc4\0\xc5\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\0\xc5\0\xc2\0\xff\xff\xc2\0\xc6\0\xb9\0\xc6\0\xc7\0\xc7\0\xff\xff\xff\xff\xc7\0\xc6\0\xc6\0\xff\xff\xff\xff\xba\0\xff\xff\xc5\0\xff\xff\xff\xff\xc8\0\xc8\0\xc6\0\xff\xff\xc8\0\xc6\0\xff\xff\xff\xff\xff\xff\xc7\0\xc6\0\xc7\0\xc9\0\xc9\0\xff\xff\xff\xff\xc9\0\xc7\0\xc7\0\xff\xff\xff\xff\xff\xff\xff\xff\xc8\0\xff\xff\xc8\0\xca\0\xca\0\xbb\0\xc7\0\xca\0\xc8\0\xc8\0\xff\xff\xff\xff\xc9\0\xc7\0\xc9\0\xff\xff\xbc\0\xc5\0\xc8\0\xff\xff\xc9\0\xc9\0\xff\xff\xff\xff\xff\xff\xff\xff\xca\0\xc8\0\xca\0\xcb\0\xcb\0\xbd\0\xff\xff\xcb\0\xca\0\xca\0\xff\xff\xff\xff\xff\xff\xc9\0\xcc\0\xcc\0\xbe\0\xff\xff\xcc\0\xcd\0\xcd\0\xff\xff\xff\xff\xcd\0\xff\xff\xff\xff\xcb\0\xca\0\xcb\0\xce\0\xce\0\xbf\0\xff\xff\xce\0\xcb\0\xcb\0\xff\xff\xcc\0\xff\xff\xcc\0\xff\xff\xff\xff\xcd\0\xff\xff\xcd\0\xcc\0\xcc\0\xff\xff\xff\xff\xff\xff\xcd\0\xcd\0\xce\0\xcb\0\xce\0\xff\xff\xcc\0\xc0\0\xff\xff\xcc\0\xce\0\xce\0\xcd\0\xff\xff\xcc\0\xff\xff\xff\xff\xc1\0\xff\xff\xcd\0\xce\0\xff\xff\xc2\0\xff\xff\xff\xff\xff\xff\xcf\0\xcf\0\xff\xff\xce\0\xcf\0\xd0\0\xd0\0\xff\xff\xff\xff\xd0\0\xd1\0\xd1\0\xff\xff\xff\xff\xd1\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcb\0\xff\xff\xff\xff\xcf\0\xff\xff\xcf\0\xff\xff\xff\xff\xd0\0\xc3\0\xd0\0\xcf\0\xcf\0\xd1\0\xff\xff\xd1\0\xd0\0\xd0\0\xff\xff\xff\xff\xff\xff\xd1\0\xd1\0\xc4\0\xff\xff\xff\xff\xff\xff\xd1\0\xff\xff\xff\xff\xcf\0\xff\xff\xd2\0\xd2\0\xff\xff\xd0\0\xd2\0\xff\xff\xff\xff\xff\xff\xd1\0\xff\xff\xd3\0\xd3\0\xff\xff\xff\xff\xd3\0\xff\xff\xff\xff\xc5\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd2\0\xff\xff\xd2\0\xff\xff\xff\xff\xff\xff\xff\xff\xc6\0\xd2\0\xd2\0\xd3\0\xff\xff\xd3\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd3\0\xd3\0\xd4\0\xd4\0\xff\xff\xff\xff\xd4\0\xff\xff\xff\xff\xd2\0\xff\xff\xff\xff\xff\xff\xd5\0\xd5\0\xc7\0\xff\xff\xd5\0\xff\xff\xd3\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd4\0\xff\xff\xd4\0\xff\xff\xc8\0\xff\xff\xff\xff\xff\xff\xd4\0\xd4\0\xff\xff\xd5\0\xff\xff\xd5\0\xff\xff\xff\xff\xc9\0\xff\xff\xff\xff\xd5\0\xd5\0\xff\xff\xd2\0\xff\xff\xd2\0\xd2\0\xd2\0\xd4\0\xd2\0\xff\xff\xca\0\xff\xff\xff\xff\xd2\0\xd2\0\xd2\0\xd2\0\xd2\0\xd5\0\xd2\0\xd2\0\xd2\0\xff\xff\xd6\0\xd6\0\xd2\0\xff\xff\xd6\0\xd3\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd3\0\xcb\0\xff\xff\xd7\0\xd7\0\xff\xff\xff\xff\xd7\0\xff\xff\xff\xff\xff\xff\xd6\0\xcc\0\xd6\0\xd4\0\xff\xff\xff\xff\xcd\0\xff\xff\xd6\0\xd6\0\xff\xff\xff\xff\xff\xff\xd4\0\xff\xff\xd7\0\xce\0\xd7\0\xd5\0\xff\xff\xff\xff\xff\xff\xd5\0\xd7\0\xd7\0\xd8\0\xd8\0\xd6\0\xff\xff\xd8\0\xd9\0\xd9\0\xff\xff\xff\xff\xd9\0\xda\0\xda\0\xff\xff\xff\xff\xda\0\xff\xff\xff\xff\xd7\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd8\0\xff\xff\xd8\0\xff\xff\xff\xff\xd9\0\xff\xff\xd9\0\xd8\0\xd8\0\xda\0\xff\xff\xda\0\xd9\0\xd9\0\xcf\0\xff\xff\xff\xff\xda\0\xda\0\xd0\0\xff\xff\xdb\0\xdb\0\xff\xff\xd1\0\xdb\0\xd8\0\xff\xff\xff\xff\xd6\0\xff\xff\xd9\0\xff\xff\xdc\0\xdc\0\xff\xff\xda\0\xdc\0\xdd\0\xdd\0\xff\xff\xff\xff\xdd\0\xff\xff\xdb\0\xff\xff\xdb\0\xff\xff\xff\xff\xff\xff\xd7\0\xff\xff\xdb\0\xdb\0\xff\xff\xff\xff\xdc\0\xff\xff\xdc\0\xff\xff\xff\xff\xdd\0\xff\xff\xdd\0\xdc\0\xdc\0\xd2\0\xff\xff\xd8\0\xdd\0\xdd\0\xdb\0\xff\xff\xde\0\xde\0\xff\xff\xd3\0\xde\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xdc\0\xff\xff\xff\xff\xd9\0\xff\xff\xdd\0\xda\0\xdf\0\xdf\0\xff\xff\xff\xff\xdf\0\xff\xff\xde\0\xff\xff\xde\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xde\0\xde\0\xe0\0\xe0\0\xff\xff\xd4\0\xe0\0\xde\0\xff\xff\xdf\0\xff\xff\xdf\0\xff\xff\xff\xff\xff\xff\xff\xff\xd5\0\xdf\0\xdf\0\xde\0\xff\xff\xdc\0\xdb\0\xff\xff\xff\xff\xe0\0\xff\xff\xe0\0\xff\xff\xff\xff\xff\xff\xe1\0\xe1\0\xe0\0\xe0\0\xe1\0\xdf\0\xff\xff\xff\xff\xff\xff\xff\xff\xdd\0\xff\xff\xff\xff\xe2\0\xe2\0\xff\xff\xe0\0\xe2\0\xff\xff\xff\xff\xff\xff\xe0\0\xff\xff\xe1\0\xff\xff\xe1\0\xff\xff\xff\xff\xff\xff\xe3\0\xe3\0\xe1\0\xe1\0\xe3\0\xff\xff\xff\xff\xe2\0\xff\xff\xe2\0\xff\xff\xd6\0\xff\xff\xff\xff\xe1\0\xe2\0\xe2\0\xff\xff\xff\xff\xdf\0\xff\xff\xe1\0\xff\xff\xe3\0\xff\xff\xe3\0\xd7\0\xff\xff\xff\xff\xff\xff\xff\xff\xe3\0\xe3\0\xff\xff\xe2\0\xe4\0\xe4\0\xff\xff\xff\xff\xe4\0\xe5\0\xe5\0\xff\xff\xff\xff\xe5\0\xe6\0\xe6\0\xff\xff\xff\xff\xe6\0\xe3\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe4\0\xd8\0\xe4\0\xff\xff\xff\xff\xe5\0\xd9\0\xe5\0\xe4\0\xe4\0\xe6\0\xda\0\xe6\0\xe5\0\xe5\0\xff\xff\xe7\0\xe7\0\xe6\0\xe6\0\xe7\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe4\0\xff\xff\xe8\0\xe8\0\xff\xff\xe5\0\xe8\0\xff\xff\xff\xff\xff\xff\xe6\0\xff\xff\xe7\0\xff\xff\xe7\0\xff\xff\xff\xff\xff\xff\xff\xff\xdb\0\xe7\0\xe7\0\xe3\0\xff\xff\xff\xff\xe8\0\xff\xff\xe8\0\xff\xff\xff\xff\xff\xff\xdc\0\xff\xff\xe8\0\xe8\0\xff\xff\xdd\0\xff\xff\xff\xff\xe7\0\xff\xff\xff\xff\xe4\0\xff\xff\xff\xff\xe9\0\xe9\0\xff\xff\xff\xff\xe9\0\xff\xff\xe6\0\xe8\0\xff\xff\xff\xff\xff\xff\xe5\0\xff\xff\xff\xff\xea\0\xea\0\xff\xff\xff\xff\xea\0\xff\xff\xff\xff\xff\xff\xff\xff\xe9\0\xff\xff\xe9\0\xde\0\xff\xff\xff\xff\xff\xff\xe7\0\xe9\0\xe9\0\xff\xff\xff\xff\xff\xff\xff\xff\xea\0\xe9\0\xea\0\xff\xff\xff\xff\xff\xff\xdf\0\xff\xff\xea\0\xea\0\xeb\0\xeb\0\xff\xff\xe9\0\xeb\0\xea\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe0\0\xff\xff\xff\xff\xff\xff\xe8\0\xea\0\xe8\0\xff\xff\xff\xff\xff\xff\xff\xff\xeb\0\xff\xff\xeb\0\xec\0\xec\0\xff\xff\xff\xff\xec\0\xeb\0\xeb\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe1\0\xed\0\xed\0\xff\xff\xff\xff\xed\0\xff\xff\xff\xff\xec\0\xeb\0\xec\0\xff\xff\xff\xff\xe2\0\xff\xff\xff\xff\xec\0\xec\0\xee\0\xee\0\xff\xff\xff\xff\xee\0\xff\xff\xed\0\xff\xff\xed\0\xec\0\xff\xff\xe3\0\xff\xff\xff\xff\xed\0\xed\0\xff\xff\xec\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xee\0\xed\0\xee\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xee\0\xee\0\xed\0\xef\0\xef\0\xff\xff\xeb\0\xef\0\xf0\0\xf0\0\xff\xff\xff\xff\xf0\0\xff\xff\xff\xff\xe4\0\xff\xff\xff\xff\xff\xff\xee\0\xe5\0\xff\xff\xff\xff\xff\xff\xff\xff\xe6\0\xef\0\xff\xff\xef\0\xff\xff\xff\xff\xf0\0\xff\xff\xf0\0\xef\0\xef\0\xff\xff\xf1\0\xf1\0\xf0\0\xf0\0\xf1\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf2\0\xf2\0\xf0\0\xff\xff\xf2\0\xef\0\xe7\0\xff\xff\xff\xff\xff\xff\xf0\0\xff\xff\xf1\0\xff\xff\xf1\0\xff\xff\xff\xff\xff\xff\xff\xff\xe8\0\xf1\0\xf1\0\xff\xff\xf2\0\xff\xff\xf2\0\xff\xff\xff\xff\xff\xff\xff\xff\xf1\0\xf2\0\xf2\0\xff\xff\xf3\0\xf3\0\xff\xff\xff\xff\xf3\0\xf1\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf4\0\xf4\0\xf2\0\xef\0\xf4\0\xff\xff\xff\xff\xff\xff\xff\xff\xf3\0\xff\xff\xf3\0\xf5\0\xf5\0\xe9\0\xff\xff\xf5\0\xf3\0\xf3\0\xff\xff\xff\xff\xff\xff\xff\xff\xf4\0\xff\xff\xf4\0\xf6\0\xf6\0\xea\0\xff\xff\xf6\0\xf4\0\xf4\0\xff\xff\xff\xff\xf5\0\xf3\0\xf5\0\xff\xff\xff\xff\xff\xff\xf7\0\xf7\0\xf5\0\xf5\0\xf7\0\xff\xff\xff\xff\xff\xff\xf6\0\xf4\0\xf6\0\xf8\0\xf8\0\xff\xff\xff\xff\xf8\0\xf6\0\xf6\0\xff\xff\xff\xff\xeb\0\xf5\0\xff\xff\xf7\0\xff\xff\xf7\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\0\xf7\0\xff\xff\xf8\0\xf6\0\xf8\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf8\0\xf8\0\xff\xff\xff\xff\xec\0\xf3\0\xff\xff\xff\xff\xf7\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf8\0\xed\0\xff\xff\xf4\0\xff\xff\xfc\0\xff\xff\xff\xff\xff\xff\xff\xff\xfc\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\0\xee\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xf7\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xef\0\xff\xff\xff\xff\xff\xff\xff\xff\xf0\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfc\0\xff\xff\xff\xff\xff\xff\xff\xff\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xfc\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfc\0\xff\xff\xff\xff\xff\xff\xfc\0\xf1\0\xfc\0\xfc\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf2\0\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\x01\xff\xff\xf3\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf4\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf5\0\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\xff\xff\xff\xff\xff\xff\xf6\0\xff\xff\xff\xff\xff\xff\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf8\0\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\x10\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfc\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\xff\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\xff\xff\xff\xff\x04\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\x12\x01\xff\xff\xff\xff\x04\x01\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xd5\x02\xff\xff\xff\xff\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x04\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x05\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x06\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\x07\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\b\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\t\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\n\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\x0b\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\f\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\r\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\xff\xff\xff\xff\x11\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\xff\xff\xff\xff\x15\x01\x15\x01\xff\xff\xff\xff\x15\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x15\x01\xff\xff\x15\x01\x16\x01\x16\x01\xff\xff\xff\xff\x16\x01\x15\x01\x15\x01\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x13\x01\x15\x01\xff\xff\x11\x01\xff\xff\xff\xff\xff\xff\x16\x01\x15\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x01\xff\xff\x16\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\xff\xff\xff\xff\xff\xff\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x11\x01\x14\x01\x14\x01\xff\xff\xff\xff\x14\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x01\x17\x01\xff\xff\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x01\x18\x01\xff\xff\x14\x01\x18\x01\x14\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x01\x14\x01\x17\x01\xff\xff\x17\x01\xff\xff\x15\x01\xff\xff\xff\xff\xff\xff\x17\x01\x17\x01\x18\x01\xff\xff\x18\x01\xff\xff\x17\x01\xff\xff\xff\xff\x14\x01\x18\x01\x18\x01\x19\x01\x19\x01\xff\xff\xff\xff\x19\x01\xff\xff\xff\xff\x17\x01\xff\xff\xff\xff\x16\x01\xff\xff\x1a\x01\x1a\x01\xff\xff\xff\xff\x1a\x01\x18\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x19\x01\xff\xff\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x19\x01\x19\x01\xff\xff\xff\xff\x1a\x01\xff\xff\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1a\x01\xff\xff\xff\xff\xff\xff\x14\x01\xff\xff\x19\x01\xff\xff\x1b\x01\x1b\x01\xff\xff\x18\x01\x1b\x01\x18\x01\x18\x01\x18\x01\x18\x01\x18\x01\x1a\x01\xff\xff\xff\xff\xff\xff\x18\x01\x18\x01\x18\x01\xff\xff\xff\xff\xff\xff\x18\x01\x18\x01\x18\x01\x1b\x01\xff\xff\x1b\x01\x1c\x01\x1c\x01\xff\xff\xff\xff\x1c\x01\x1b\x01\x1b\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1d\x01\x1d\x01\xff\xff\x19\x01\x1d\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\x1b\x01\x1c\x01\x1a\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\x1c\x01\xff\xff\x1d\x01\xff\xff\x1d\x01\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x01\x1d\x01\x1d\x01\x1e\x01\x1e\x01\xff\xff\xff\xff\x1e\x01\xff\xff\x1c\x01\xff\xff\xff\xff\xff\xff\x1f\x01\x1f\x01\xff\xff\xff\xff\x1f\x01 \x01 \x01\x1d\x01\xff\xff \x01\xff\xff\xff\xff\xff\xff\x1e\x01\xff\xff\x1e\x01!\x01!\x01\xff\xff\xff\xff!\x01\x1e\x01\x1e\x01\x1f\x01\x1b\x01\x1f\x01\xff\xff\xff\xff \x01\xff\xff \x01\x1f\x01\x1f\x01\xff\xff\xff\xff\xff\xff \x01 \x01\x1c\x01!\x01\x1e\x01!\x01\x1c\x01\xff\xff\xff\xff\x1d\x01\xff\xff!\x01!\x01\xff\xff\x1f\x01\xff\xff\xff\xff\x1d\x01\xff\xff \x01\"\x01\"\x01\xff\xff\xff\xff\"\x01\xff\xff\x14\x01\xff\xff\xff\xff\x1d\x01!\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x17\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\"\x01\xff\xff\"\x01\x18\x01\xff\xff\xff\xff\xff\xff\xff\xff\"\x01\"\x01#\x01#\x01\xff\xff\xff\xff#\x01 \x01\x1e\x01 \x01\xff\xff\xff\xff\x1f\x01$\x01$\x01\xff\xff\xff\xff$\x01\xff\xff\"\x01\xff\xff!\x01\xff\xff\xff\xff\xff\xff#\x01\xff\xff#\x01\x19\x01\xff\xff\xff\xff\xff\xff\xff\xff#\x01#\x01\xff\xff$\x01\xff\xff$\x01\xff\xff\x1a\x01\xff\xff\xff\xff\xff\xff$\x01$\x01\xff\xff%\x01%\x01\xff\xff\xff\xff%\x01#\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff&\x01&\x01\xff\xff\xff\xff&\x01$\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff%\x01\xff\xff%\x01\"\x01\xff\xff\xff\xff\"\x01\"\x01%\x01%\x01\x1b\x01&\x01\xff\xff&\x01\xff\xff\xff\xff\xff\xff'\x01'\x01&\x01&\x01'\x01\xff\xff\xff\xff#\x01\xff\xff\xff\xff%\x01(\x01(\x01\xff\xff\xff\xff(\x01\xff\xff#\x01$\x01\x1c\x01\xff\xff&\x01#\x01'\x01\xff\xff'\x01\xff\xff\xff\xff$\x01\xff\xff\x1d\x01'\x01'\x01\xff\xff(\x01\xff\xff(\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff(\x01(\x01)\x01)\x01\xff\xff\xff\xff)\x01\xff\xff'\x01\xff\xff\xff\xff\xff\xff*\x01*\x01%\x01\xff\xff*\x01\xff\xff\xff\xff(\x01\xff\xff\x1e\x01\xff\xff\xff\xff\xff\xff)\x01\xff\xff)\x01\xff\xff\xff\xff&\x01\x1f\x01&\x01)\x01)\x01*\x01 \x01*\x01\xff\xff\xff\xff\xff\xff+\x01+\x01*\x01*\x01+\x01\xff\xff!\x01\xff\xff\xff\xff\xff\xff\xff\xff)\x01\xff\xff,\x01,\x01\xff\xff\xff\xff,\x01\xff\xff\xff\xff\xff\xff*\x01\xff\xff+\x01\xff\xff+\x01\xff\xff\xff\xff\xff\xff'\x01\xff\xff+\x01+\x01\xff\xff(\x01\xff\xff,\x01(\x01,\x01-\x01-\x01\xff\xff\xff\xff-\x01,\x01,\x01\"\x01\xff\xff\xff\xff\xff\xff+\x01\xff\xff\xff\xff)\x01\xff\xff.\x01.\x01\xff\xff\xff\xff.\x01\xff\xff\xff\xff-\x01,\x01-\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff-\x01-\x01\xff\xff\xff\xff\xff\xff\xff\xff*\x01\xff\xff.\x01#\x01.\x01/\x01/\x01\xff\xff\xff\xff/\x01.\x01.\x01\xff\xff-\x01$\x010\x010\x01.\x01\xff\xff0\x01\xff\xff\xff\xff\xff\xff,\x01\xff\xff\xff\xff\xff\xff\xff\xff/\x01.\x01/\x01+\x01\xff\xff\xff\xff\xff\xff\xff\xff/\x01/\x010\x01\xff\xff0\x011\x011\x01/\x01\xff\xff1\x010\x010\x01%\x01\xff\xff\xff\xff\xff\xff\xff\xff2\x012\x01/\x01\xff\xff2\x01\xff\xff&\x01\xff\xff\xff\xff\xff\xff\xff\xff1\x010\x011\x01\xff\xff\xff\xff-\x01\xff\xff-\x011\x011\x01\xff\xff\xff\xff2\x01\xff\xff2\x01\xff\xff\xff\xff\xff\xff\xff\xff1\x012\x012\x011\x01\xff\xff'\x013\x013\x011\x01\xff\xff3\x014\x014\x012\x01\xff\xff4\x01(\x01\xff\xff\xff\xff\xff\xff2\x015\x015\x01\xff\xff\xff\xff5\x01\xff\xff\xff\xff0\x013\x01\xff\xff3\x01\xff\xff\xff\xff4\x01\xff\xff4\x013\x013\x01\xff\xff\xff\xff\xff\xff4\x014\x015\x01\xff\xff5\x013\x01\xff\xff)\x016\x016\x015\x015\x016\x01\xff\xff3\x01\xff\xff\xff\xff*\x01\xff\xff4\x017\x017\x01\xff\xff\xff\xff7\x01\xff\xff\xff\xff\xff\xff\xff\xff5\x01\xff\xff6\x01\xff\xff6\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff6\x016\x01\xff\xff\xff\xff7\x01\xff\xff7\x01+\x01\xff\xff\xff\xff8\x018\x017\x017\x018\x01\xff\xff\xff\xff\xff\xff\xff\xff6\x01,\x01\xff\xff\xff\xff7\x01:\x01:\x017\x01\xff\xff:\x01\xff\xff\xff\xff7\x01\xff\xff8\x01\xff\xff8\x019\x019\x01\xff\xff\xff\xff9\x018\x018\x01\xff\xff\xff\xff\xff\xff-\x01:\x01\xff\xff:\x01;\x01;\x01\xff\xff8\x01;\x01:\x01:\x01\xff\xff\xff\xff9\x018\x019\x01.\x01\xff\xff\xff\xff6\x01\xff\xff9\x019\x01\xff\xff\xff\xff\xff\xff\xff\xff;\x01:\x01;\x01\xff\xff9\x01\xff\xff<\x01<\x01;\x01;\x01<\x01\xff\xff\xff\xff9\x01\xff\xff/\x01\xff\xff=\x01=\x01\xff\xff\xff\xff=\x01>\x01>\x01\xff\xff0\x01>\x01;\x01\xff\xff<\x01\xff\xff<\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff<\x01<\x01\xff\xff=\x01\xff\xff=\x01\xff\xff\xff\xff>\x01\xff\xff>\x01=\x01=\x01\xff\xff1\x01\xff\xff>\x01>\x01\xff\xff<\x01?\x01?\x01\xff\xff\xff\xff?\x01\xff\xff2\x01\xff\xff\xff\xff\xff\xff=\x01\xff\xff@\x01@\x01\xff\xff>\x01@\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff?\x01\xff\xff?\x01\xff\xff\xff\xff\xff\xffA\x01A\x01?\x01?\x01A\x01\xff\xff@\x01\xff\xff@\x01\xff\xff\xff\xff\xff\xff\xff\xff3\x01@\x01@\x01B\x01B\x014\x01\xff\xffB\x01?\x01\xff\xffA\x01\xff\xffA\x01<\x01=\x015\x01\xff\xff>\x01A\x01A\x01@\x01\xff\xff\xff\xffC\x01C\x01\xff\xffB\x01C\x01B\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffB\x01B\x01\xff\xffA\x01D\x01D\x01\xff\xff\xff\xffD\x01\xff\xff6\x01\xff\xffC\x01\xff\xffC\x01\xff\xff\xff\xff\xff\xff\xff\xffB\x01C\x01C\x017\x01\xff\xff\xff\xff?\x01\xff\xffD\x01\xff\xffD\x01E\x01E\x01\xff\xff\xff\xffE\x01D\x01D\x01\xff\xff\xff\xffC\x01\xff\xff\xff\xff\xff\xffF\x01F\x01\xff\xff\xff\xffF\x01\xff\xff\xff\xff\xff\xff8\x01A\x01E\x01D\x01E\x01G\x01G\x01\xff\xff\xff\xffG\x01E\x01E\x01\xff\xff\xff\xff:\x01F\x01\xff\xffF\x01H\x01H\x01\xff\xff\xff\xffH\x01F\x01F\x01\xff\xff9\x01\xff\xffG\x01E\x01G\x01I\x01I\x01\xff\xff\xff\xffI\x01G\x01G\x01\xff\xff\xff\xff;\x01H\x01F\x01H\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffH\x01H\x01\xff\xff\xff\xff\xff\xffI\x01G\x01I\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffI\x01I\x01\xff\xff\xff\xff\xff\xffE\x01H\x01<\x01\xff\xffJ\x01J\x01\xff\xff\xff\xffJ\x01\xff\xff\xff\xff\xff\xff\xff\xff=\x01I\x01\xff\xffF\x01\xff\xff>\x01\xff\xffK\x01K\x01\xff\xff\xff\xffK\x01\xff\xff\xff\xffJ\x01\xff\xffJ\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffJ\x01J\x01\xff\xff\xff\xff\xff\xffH\x01\xff\xff\xff\xffK\x01\xff\xffK\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffK\x01K\x01?\x01J\x01L\x01L\x01\xff\xff\xff\xffL\x01M\x01M\x01\xff\xff\xff\xffM\x01@\x01\xff\xff\xff\xff\xff\xffI\x01K\x01N\x01N\x01\xff\xff\xff\xffN\x01\xff\xff\xff\xffL\x01\xff\xffL\x01\xff\xffA\x01M\x01\xff\xffM\x01L\x01L\x01\xff\xff\xff\xff\xff\xffM\x01M\x01\xff\xffN\x01\xff\xffN\x01\xff\xffB\x01\xff\xff\xff\xff\xff\xffN\x01N\x01\xff\xffL\x01J\x01O\x01O\x01\xff\xffM\x01O\x01P\x01P\x01\xff\xff\xff\xffP\x01\xff\xffC\x01\xff\xff\xff\xffN\x01\xff\xff\xff\xff\xff\xffK\x01\xff\xff\xff\xff\xff\xff\xff\xffO\x01\xff\xffO\x01D\x01\xff\xffP\x01\xff\xffP\x01O\x01O\x01\xff\xff\xff\xff\xff\xffP\x01P\x01Q\x01Q\x01L\x01\xff\xffQ\x01R\x01R\x01\xff\xff\xff\xffR\x01\xff\xff\xff\xffO\x01\xff\xffE\x01\xff\xff\xff\xffP\x01\xff\xff\xff\xffS\x01S\x01\xff\xffQ\x01S\x01Q\x01\xff\xffF\x01R\x01\xff\xffR\x01Q\x01Q\x01N\x01\xff\xff\xff\xffR\x01R\x01\xff\xff\xff\xffG\x01\xff\xff\xff\xffS\x01\xff\xffS\x01\xff\xff\xff\xff\xff\xff\xff\xffQ\x01S\x01S\x01H\x01\xff\xffR\x01\xff\xff\xff\xffT\x01T\x01\xff\xff\xff\xffT\x01\xff\xff\xff\xff\xff\xffI\x01\xff\xffU\x01U\x01S\x01\xff\xffU\x01V\x01V\x01\xff\xff\xff\xffV\x01\xff\xff\xff\xff\xff\xffT\x01\xff\xffT\x01\xff\xff\xff\xff\xff\xff\xff\xffQ\x01T\x01T\x01U\x01\xff\xffU\x01Q\x01\xff\xffV\x01\xff\xffV\x01U\x01U\x01\xff\xff\xff\xff\xff\xffV\x01V\x01J\x01\xff\xffT\x01\xff\xffR\x01W\x01W\x01\xff\xff\xff\xffW\x01X\x01X\x01U\x01\xff\xffX\x01\xff\xffK\x01V\x01\xff\xff\xff\xff\xff\xff\xff\xffY\x01Y\x01\xff\xff\xff\xffY\x01\xff\xffW\x01\xff\xffW\x01\xff\xff\xff\xffX\x01\xff\xffX\x01W\x01W\x01\xff\xffZ\x01Z\x01X\x01X\x01Z\x01T\x01Y\x01\xff\xffY\x01\xff\xff\xff\xff\xff\xffL\x01\xff\xffY\x01Y\x01W\x01M\x01\xff\xff\xff\xff\xff\xffX\x01\xff\xffZ\x01\xff\xffZ\x01[\x01[\x01N\x01U\x01[\x01Z\x01Z\x01Y\x01\xff\xffV\x01\\\x01\\\x01\xff\xff\xff\xff\\\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff[\x01Z\x01[\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff[\x01[\x01\\\x01\xff\xff\\\x01X\x01\xff\xffO\x01\xff\xff\xff\xff\\\x01\\\x01P\x01\xff\xff\xff\xff\xff\xff\xff\xff]\x01]\x01[\x01\xff\xff]\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\\\x01^\x01^\x01Y\x01\xff\xff^\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff]\x01\xff\xff]\x01_\x01_\x01Q\x01\xff\xff_\x01]\x01]\x01R\x01\xff\xff\xff\xff^\x01\xff\xff^\x01\xff\xff\xff\xff\xff\xff`\x01`\x01^\x01^\x01`\x01\xff\xffS\x01_\x01]\x01_\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff_\x01_\x01\xff\xff\xff\xff\xff\xff\xff\xff^\x01\\\x01`\x01\xff\xff`\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff`\x01`\x01\xff\xff_\x01\xff\xff\xff\xff\xff\xffa\x01a\x01\xff\xff\xff\xffa\x01\xff\xffT\x01\xff\xff\xff\xff\xff\xffb\x01b\x01`\x01\xff\xffb\x01\xff\xffU\x01\xff\xff\xff\xff\xff\xff\xff\xffV\x01]\x01a\x01\xff\xffa\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffa\x01a\x01b\x01\xff\xffb\x01\xff\xff\xff\xff^\x01\xff\xff\xff\xffb\x01b\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffc\x01c\x01a\x01\xff\xffc\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffW\x01b\x01\xff\xff\xff\xff\xff\xffX\x01d\x01d\x01\xff\xff\xff\xffd\x01`\x01c\x01\xff\xffc\x01\xff\xff\xff\xffY\x01\xff\xff\xff\xffc\x01c\x01e\x01e\x01\xff\xff\xff\xffe\x01\xff\xff\xff\xffd\x01\xff\xffd\x01f\x01f\x01Z\x01\xff\xfff\x01d\x01d\x01c\x01\xff\xffb\x01a\x01\xff\xff\xff\xffe\x01\xff\xffe\x01g\x01g\x01\xff\xff\xff\xffg\x01e\x01e\x01f\x01d\x01f\x01\xff\xff\xff\xff[\x01h\x01h\x01f\x01f\x01h\x01\xff\xff\xff\xff\xff\xff\xff\xff\\\x01g\x01e\x01g\x01i\x01i\x01\xff\xff\xff\xffi\x01g\x01g\x01\xff\xfff\x01\xff\xffh\x01\xff\xffh\x01j\x01j\x01\xff\xff\xff\xffj\x01h\x01h\x01\xff\xff\xff\xff\xff\xffi\x01g\x01i\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffi\x01i\x01\xff\xff]\x01\xff\xffj\x01h\x01j\x01\xff\xff\xff\xff\xff\xff\xff\xffd\x01j\x01j\x01\xff\xff^\x01\xff\xffe\x01i\x01\xff\xffk\x01k\x01\xff\xff\xff\xffk\x01f\x01\xff\xff\xff\xff_\x01\xff\xff\xff\xffj\x01\xff\xffl\x01l\x01\xff\xff\xff\xffl\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffk\x01`\x01k\x01m\x01m\x01\xff\xff\xff\xffm\x01k\x01k\x01\xff\xff\xff\xff\xff\xffl\x01\xff\xffl\x01\xff\xff\xff\xff\xff\xffn\x01n\x01l\x01l\x01n\x01\xff\xff\xff\xffm\x01k\x01m\x01o\x01o\x01\xff\xff\xff\xffo\x01m\x01m\x01\xff\xff\xff\xffj\x01a\x01l\x01\xff\xffn\x01\xff\xffn\x01\xff\xff\xff\xff\xff\xff\xff\xffb\x01n\x01n\x01o\x01m\x01o\x01\xff\xff\xff\xff\xff\xffp\x01p\x01o\x01o\x01p\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffn\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffo\x01\xff\xffp\x01\xff\xffp\x01q\x01q\x01k\x01c\x01q\x01p\x01p\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffp\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffd\x01m\x01\xff\xffq\x01p\x01q\x01r\x01r\x01\xff\xff\xff\xffr\x01q\x01q\x01\xff\xff\xff\xff\xff\xffe\x01o\x01\xff\xff\xff\xff\xff\xff\xff\xffn\x01\xff\xff\xff\xff\xff\xfff\x01\xff\xff\xff\xffr\x01q\x01r\x01\xff\xff\xff\xff\xff\xffs\x01s\x01r\x01r\x01s\x01t\x01t\x01g\x01\xff\xfft\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffr\x01\xff\xff\xff\xff\xff\xffh\x01r\x01\xff\xffs\x01\xff\xffs\x01\xff\xff\xff\xfft\x01\xff\xfft\x01s\x01s\x01i\x01\xff\xff\xff\xfft\x01t\x01q\x01\xff\xffu\x01u\x01\xff\xffs\x01u\x01\xff\xffj\x01\xff\xff\xff\xff\xff\xffs\x01\xff\xffv\x01v\x01\xff\xfft\x01v\x01w\x01w\x01\xff\xff\xff\xffw\x01\xff\xffu\x01\xff\xffu\x01\xff\xff\xff\xff\xff\xffx\x01x\x01u\x01u\x01x\x01\xff\xffv\x01\xff\xffv\x01\xff\xff\xff\xffw\x01\xff\xffw\x01v\x01v\x01k\x01\xff\xff\xff\xffw\x01w\x01u\x01\xff\xffx\x01\xff\xffx\x01\xff\xff\xff\xff\xff\xffl\x01\xff\xffx\x01x\x01v\x01\xff\xff\xff\xff\xff\xff\xff\xffw\x01y\x01y\x01\xff\xffm\x01y\x01z\x01z\x01\xff\xff\xff\xffz\x01\xff\xffx\x01\xff\xff\xff\xff\xff\xff\xff\xff{\x01{\x01\xff\xffn\x01{\x01\xff\xff\xff\xffy\x01\xff\xffy\x01\xff\xff\xff\xffz\x01o\x01z\x01y\x01y\x01\xff\xff\xff\xff\xff\xffz\x01z\x01\xff\xff{\x01\xff\xff{\x01|\x01|\x01\xff\xff\xff\xff|\x01{\x01{\x01\xff\xffy\x01\xff\xff\xff\xff\xff\xff\xff\xffz\x01\xff\xffx\x01p\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff|\x01{\x01|\x01}\x01}\x01\xff\xff\xff\xff}\x01|\x01|\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff~\x01~\x01q\x01\xff\xff~\x01\xff\xff\xff\xff\xff\xff\xff\xff}\x01|\x01}\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff}\x01}\x01y\x01\x7f\x01\x7f\x01\xff\xff~\x01\x7f\x01~\x01{\x01\xff\xffr\x01\xff\xffz\x01~\x01~\x01\xff\xff\xff\xff\xff\xff}\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7f\x01\xff\xff\x7f\x01\xff\xff\xff\xff\xff\xff\xff\xff~\x01\x7f\x01\x7f\x01\xff\xff\x80\x01\x80\x01\xff\xffs\x01\x80\x01\xff\xff\xff\xff\xff\xfft\x01\xff\xff\xff\xff|\x01\xff\xff\xff\xff\x81\x01\x81\x01\x7f\x01\xff\xff\x81\x01\xff\xff\xff\xff\xff\xff\xff\xff\x80\x01\xff\xff\x80\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x80\x01\x80\x01\xff\xff\xff\xff}\x01\xff\xff\x81\x01\xff\xff\x81\x01\xff\xff\xff\xff\xff\xffu\x01\xff\xff\x81\x01\x81\x01\xff\xff\xff\xff\xff\xff\x80\x01~\x01\x81\x01\x82\x01\x82\x01v\x01\xff\xff\x82\x01\x7f\x01\xff\xffw\x01\xff\xff\xff\xff\xff\xff\x81\x01\xff\xff\xff\xff\x83\x01\x83\x01\xff\xff\xff\xff\x83\x01x\x01\xff\xff\xff\xff\xff\xff\x82\x01\xff\xff\x82\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x82\x01\x82\x01\xff\xff\x84\x01\x84\x01\xff\xff\x83\x01\x84\x01\x83\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x01\x83\x01\x85\x01\x85\x01\xff\xff\x82\x01\x85\x01\xff\xff\xff\xff\x80\x01\xff\xff\x83\x01\x84\x01y\x01\x84\x01\xff\xff\xff\xff\xff\xffz\x01\x83\x01\x84\x01\x84\x01\x86\x01\x86\x01\xff\xff\x85\x01\x86\x01\x85\x01\xff\xff{\x01\x84\x01\xff\xff\xff\xff\x85\x01\x85\x01\xff\xff\xff\xff\x87\x01\x87\x01\x84\x01\xff\xff\x87\x01\x88\x01\x88\x01\xff\xff\x86\x01\x88\x01\x86\x01\xff\xff\xff\xff\xff\xff\x82\x01\x85\x01\x86\x01\x86\x01|\x01\xff\xff\x89\x01\x89\x01\x86\x01\x87\x01\x89\x01\x87\x01\xff\xff\xff\xff\x88\x01\xff\xff\x88\x01\x87\x01\x87\x01\xff\xff\xff\xff\x86\x01\x88\x01\x88\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x89\x01}\x01\x89\x01\xff\xff\xff\xff\xff\xff\xff\xff\x87\x01\x89\x01\x89\x01\xff\xff\xff\xff\x88\x01\xff\xff\xff\xff~\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8a\x01\x8a\x01\xff\xff\xff\xff\x8a\x01\xff\xff\x89\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7f\x01\x8b\x01\x8b\x01\xff\xff\xff\xff\x8b\x01\xff\xff\xff\xff\xff\xff\x8a\x01\x87\x01\x8a\x01\x87\x01\x87\x01\x87\x01\x87\x01\x87\x01\x8a\x01\x8a\x01\x88\x01\xff\xff\x87\x01\x87\x01\x87\x01\x8b\x01\x87\x01\x8b\x01\x87\x01\x87\x01\x87\x01\xff\xff\xff\xff\x8b\x01\x8b\x01\x80\x01\xff\xff\x8a\x01\xff\xff\x8c\x01\x8c\x01\xff\xff\xff\xff\x8c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x89\x01\x81\x01\x8d\x01\x8d\x01\x8b\x01\xff\xff\x8d\x01\x8e\x01\x8e\x01\xff\xff\xff\xff\x8e\x01\xff\xff\xff\xff\x8c\x01\xff\xff\x8c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x8c\x01\x8c\x01\xff\xff\x8d\x01\xff\xff\x8d\x01\xff\xff\xff\xff\x8e\x01\xff\xff\x8e\x01\x8d\x01\x8d\x01\x8a\x01\xff\xff\xff\xff\x8e\x01\x8e\x01\x82\x01\x8c\x01\xff\xff\xff\xff\x8f\x01\x8f\x01\xff\xff\xff\xff\x8f\x01\xff\xff\xff\xff\xff\xff\x8d\x01\xff\xff\x83\x01\xff\xff\x8b\x01\x8e\x01\x90\x01\x90\x01\xff\xff\xff\xff\x90\x01\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x01\xff\xff\x8f\x01\xff\xff\xff\xff\xff\xff\xff\xff\x84\x01\x8f\x01\x8f\x01\xff\xff\x91\x01\x91\x01\xff\xff\x90\x01\x91\x01\x90\x01\xff\xff\xff\xff\xff\xff\x85\x01\xff\xff\x90\x01\x90\x01\x8c\x01\xff\xff\xff\xff\x8f\x01\xff\xff\x90\x01\xff\xff\x92\x01\x92\x01\xff\xff\x91\x01\x92\x01\x91\x01\x8d\x01\xff\xff\xff\xff\x86\x01\x90\x01\x91\x01\x91\x01\xff\xff\x93\x01\x93\x01\x8e\x01\xff\xff\x93\x01\xff\xff\xff\xff\xff\xff\xff\xff\x92\x01\x87\x01\x92\x01\xff\xff\xff\xff\xff\xff\x88\x01\x91\x01\x92\x01\x92\x01\xff\xff\xff\xff\xff\xff\xff\xff\x93\x01\x8f\x01\x93\x01\xff\xff\xff\xff\x92\x01\xff\xff\x89\x01\x93\x01\x93\x01\x94\x01\x94\x01\xff\xff\x92\x01\x94\x01\x95\x01\x95\x01\xff\xff\x93\x01\x95\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x01\x96\x01\x93\x01\xff\xff\x96\x01\x97\x01\x97\x01\xff\xff\x94\x01\x97\x01\x94\x01\x91\x01\xff\xff\x95\x01\xff\xff\x95\x01\x94\x01\x94\x01\xff\xff\xff\xff\xff\xff\x95\x01\x95\x01\x96\x01\xff\xff\x96\x01\x8a\x01\xff\xff\x97\x01\xff\xff\x97\x01\x96\x01\x96\x01\xff\xff\xff\xff\x94\x01\x97\x01\x97\x01\x98\x01\x98\x01\x95\x01\x8b\x01\x98\x01\x99\x01\x99\x01\xff\xff\xff\xff\x99\x01\x9a\x01\x9a\x01\x96\x01\xff\xff\x9a\x01\xff\xff\xff\xff\x97\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x98\x01\xff\xff\x98\x01\xff\xff\xff\xff\x99\x01\xff\xff\x99\x01\x98\x01\x98\x01\x9a\x01\xff\xff\x9a\x01\x99\x01\x99\x01\xff\xff\xff\xff\x8c\x01\x9a\x01\x9a\x01\xff\xff\xff\xff\x9b\x01\x9b\x01\xff\xff\x95\x01\x9b\x01\x98\x01\x8d\x01\xff\xff\xff\xff\xff\xff\x99\x01\x8e\x01\xff\xff\xff\xff\xff\xff\x9a\x01\xff\xff\xff\xff\x96\x01\xff\xff\x9c\x01\x9c\x01\xff\xff\x9b\x01\x9c\x01\x9b\x01\xff\xff\xff\xff\xff\xff\x97\x01\xff\xff\x9b\x01\x9b\x01\xff\xff\xff\xff\x9d\x01\x9d\x01\xff\xff\xff\xff\x9d\x01\xff\xff\xff\xff\xff\xff\x9c\x01\xff\xff\x9c\x01\xff\xff\x98\x01\x8f\x01\xff\xff\x9b\x01\x9c\x01\x9c\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9d\x01\xff\xff\x9d\x01\xff\xff\x90\x01\xff\xff\xff\xff\x99\x01\x9d\x01\x9d\x01\x9a\x01\xff\xff\x9c\x01\xff\xff\x9e\x01\x9e\x01\xff\xff\xff\xff\x9e\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x91\x01\x9f\x01\x9f\x01\x9d\x01\xff\xff\x9f\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9e\x01\xff\xff\x9e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x92\x01\x9e\x01\x9e\x01\x9b\x01\x9f\x01\xff\xff\x9f\x01\xff\xff\x9e\x01\xff\xff\x9c\x01\xff\xff\x9f\x01\x9f\x01\x93\x01\xff\xff\xff\xff\xff\xff\xa0\x01\xa0\x01\x9e\x01\xff\xff\xa0\x01\xa1\x01\xa1\x01\xff\xff\xff\xff\xa1\x01\xa2\x01\xa2\x01\xff\xff\x9f\x01\xa2\x01\xa3\x01\xa3\x01\xff\xff\xff\xff\xa3\x01\xff\xff\xff\xff\x9d\x01\xa0\x01\xff\xff\xa0\x01\xff\xff\xff\xff\xa1\x01\x94\x01\xa1\x01\xa0\x01\xa0\x01\xa2\x01\x95\x01\xa2\x01\xa1\x01\xa1\x01\xa3\x01\xff\xff\xa3\x01\xa2\x01\xa2\x01\xff\xff\x96\x01\xa0\x01\xa3\x01\xa3\x01\xa1\x01\x97\x01\xa0\x01\xff\xff\xa4\x01\xa4\x01\xff\xff\xa1\x01\xa4\x01\xff\xff\xff\xff\x9f\x01\xa2\x01\xff\xff\xff\xff\xa5\x01\xa5\x01\xa3\x01\xff\xff\xa5\x01\xa6\x01\xa6\x01\xff\xff\xff\xff\xa6\x01\xff\xff\xff\xff\xa4\x01\xff\xff\xa4\x01\xff\xff\xff\xff\xff\xff\xff\xff\x98\x01\xa4\x01\xa4\x01\xff\xff\xa5\x01\x99\x01\xa5\x01\xff\xff\xff\xff\xa6\x01\x9a\x01\xa6\x01\xa5\x01\xa5\x01\xff\xff\xff\xff\xff\xff\xa6\x01\xa6\x01\xff\xff\xa4\x01\xa7\x01\xa7\x01\xa3\x01\xff\xff\xa7\x01\xa8\x01\xa8\x01\xff\xff\xff\xff\xa8\x01\xa5\x01\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x01\xff\xff\xa9\x01\xa9\x01\xff\xff\xff\xff\xa9\x01\xff\xff\xa7\x01\x9b\x01\xa7\x01\xff\xff\xff\xff\xa8\x01\xff\xff\xa8\x01\xa7\x01\xa7\x01\xff\xff\xff\xff\xff\xff\xa8\x01\xa8\x01\xff\xff\xff\xff\xa9\x01\xff\xff\xa9\x01\xff\xff\x9c\x01\xff\xff\xff\xff\xff\xff\xa9\x01\xa9\x01\xa7\x01\xff\xff\xaa\x01\xaa\x01\xff\xff\xa8\x01\xaa\x01\xff\xff\xff\xff\x9d\x01\xff\xff\xa6\x01\xff\xff\xff\xff\xff\xff\xff\xff\xa5\x01\xa9\x01\xab\x01\xab\x01\xff\xff\xff\xff\xab\x01\xff\xff\xff\xff\xaa\x01\xff\xff\xaa\x01\xac\x01\xac\x01\xff\xff\xff\xff\xac\x01\xaa\x01\xaa\x01\xff\xff\xff\xff\xff\xff\xad\x01\xad\x01\xff\xff\xab\x01\xad\x01\xab\x01\xff\xff\xff\xff\x9e\x01\xff\xff\xa8\x01\xab\x01\xab\x01\xac\x01\xaa\x01\xac\x01\xff\xff\xff\xff\xff\xff\x9f\x01\xff\xff\xac\x01\xac\x01\xad\x01\xa7\x01\xad\x01\xff\xff\xff\xff\xff\xff\xff\xff\xab\x01\xad\x01\xad\x01\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x01\xff\xff\xff\xff\xac\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\x01\xae\x01\xae\x01\xff\xff\xff\xff\xae\x01\xa0\x01\xff\xff\xff\xff\xff\xff\xff\xff\xa1\x01\xff\xff\xff\xff\xff\xff\xaa\x01\xa2\x01\xff\xff\xaf\x01\xaf\x01\xab\x01\xa3\x01\xaf\x01\xff\xff\xae\x01\xff\xff\xae\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xae\x01\xae\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xaf\x01\xff\xff\xaf\x01\xad\x01\xff\xff\xff\xff\xff\xff\xff\xff\xaf\x01\xaf\x01\xae\x01\xff\xff\xb0\x01\xb0\x01\xff\xff\xff\xff\xb0\x01\xa4\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xaf\x01\xa5\x01\xaf\x01\xff\xff\xff\xff\xff\xff\xa6\x01\xff\xff\xb0\x01\xff\xff\xb0\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb0\x01\xb0\x01\xff\xff\xb5\x01\xb5\x01\xff\xff\xff\xff\xb5\x01\xb0\x01\xb0\x01\xb0\x01\xb0\x01\xb0\x01\xb0\x01\xb0\x01\xb0\x01\xb0\x01\xb0\x01\xae\x01\xb0\x01\xb1\x01\xb1\x01\xff\xff\xff\xff\xb1\x01\xa7\x01\xb5\x01\xff\xff\xb5\x01\xff\xff\xa8\x01\xff\xff\xff\xff\xff\xff\xb5\x01\xb5\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa9\x01\xb1\x01\xff\xff\xb1\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x01\xb1\x01\xb5\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xb1\x01\xff\xff\xb1\x01\xff\xff\xff\xff\xff\xff\xff\xff\xb2\x01\xb2\x01\xaa\x01\xff\xff\xb2\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xab\x01\xff\xff\xb5\x01\xff\xff\xff\xff\xb2\x01\xff\xff\xb2\x01\xb3\x01\xb3\x01\xac\x01\xff\xff\xb3\x01\xb2\x01\xb2\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\x01\xb2\x01\xb2\x01\xb2\x01\xb2\x01\xb2\x01\xb2\x01\xb2\x01\xb2\x01\xb2\x01\xb2\x01\xb3\x01\xb2\x01\xb3\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb3\x01\xb3\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xff\xff\xb3\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xff\xff\xae\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xaf\x01\xff\xff\xb4\x01\xb4\x01\xff\xff\xb2\x01\xb4\x01\xff\xff\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xb3\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb4\x01\xff\xff\xb4\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb4\x01\xb4\x01\xb0\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xff\xff\xb4\x01\xb6\x01\xb6\x01\xff\xff\xff\xff\xb6\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb5\x01\xff\xff\xff\xff\xff\xff\xb7\x01\xb7\x01\xff\xff\xb6\x01\xb7\x01\xb6\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x01\xb6\x01\xb1\x01\xff\xff\xff\xff\xff\xff\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb4\x01\xb7\x01\xff\xff\xb7\x01\xff\xff\xff\xff\xff\xff\xff\xff\xb6\x01\xb7\x01\xb7\x01\xb8\x01\xb8\x01\xff\xff\xff\xff\xb8\x01\xb9\x01\xb9\x01\xff\xff\xff\xff\xb9\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xba\x01\xba\x01\xb7\x01\xff\xff\xba\x01\xff\xff\xff\xff\xff\xff\xb8\x01\xff\xff\xb8\x01\xff\xff\xff\xff\xb9\x01\xff\xff\xb9\x01\xb8\x01\xb8\x01\xff\xff\xff\xff\xb2\x01\xb9\x01\xb9\x01\xba\x01\xff\xff\xba\x01\xbb\x01\xbb\x01\xff\xff\xff\xff\xbb\x01\xba\x01\xba\x01\xff\xff\xff\xff\xb8\x01\xff\xff\xb6\x01\xbc\x01\xbc\x01\xb9\x01\xff\xff\xbc\x01\xbd\x01\xbd\x01\xff\xff\xb3\x01\xbd\x01\xff\xff\xbb\x01\xba\x01\xbb\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbb\x01\xbb\x01\xb7\x01\xff\xff\xbc\x01\xff\xff\xbc\x01\xff\xff\xff\xff\xbd\x01\xff\xff\xbd\x01\xbc\x01\xbc\x01\xb8\x01\xff\xff\xff\xff\xbd\x01\xbd\x01\xbb\x01\xbe\x01\xbe\x01\xff\xff\xff\xff\xbe\x01\xb9\x01\xff\xff\xff\xff\xff\xff\xb9\x01\xff\xff\xbc\x01\xff\xff\xb9\x01\xff\xff\xff\xff\xbd\x01\xff\xff\xb9\x01\xff\xff\xb9\x01\xb9\x01\xff\xff\xbe\x01\xff\xff\xbe\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbe\x01\xbe\x01\xff\xff\xba\x01\xff\xff\xff\xff\xbf\x01\xbf\x01\xff\xff\xff\xff\xbf\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc0\x01\xc0\x01\xbe\x01\xb4\x01\xc0\x01\xbc\x01\xbb\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbf\x01\xff\xff\xbf\x01\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x01\xbf\x01\xbf\x01\xff\xff\xc0\x01\xff\xff\xc0\x01\xc1\x01\xc1\x01\xff\xff\xff\xff\xc1\x01\xc0\x01\xc0\x01\xff\xff\xff\xff\xff\xff\xc2\x01\xc2\x01\xff\xff\xbf\x01\xc2\x01\xc3\x01\xc3\x01\xff\xff\xff\xff\xc3\x01\xff\xff\xff\xff\xff\xff\xc1\x01\xc0\x01\xc1\x01\xff\xff\xbe\x01\xb6\x01\xff\xff\xff\xff\xc1\x01\xc1\x01\xc2\x01\xff\xff\xc2\x01\xff\xff\xff\xff\xc3\x01\xff\xff\xc3\x01\xc2\x01\xc2\x01\xff\xff\xff\xff\xff\xff\xc3\x01\xc3\x01\xb7\x01\xff\xff\xc1\x01\xbf\x01\xc4\x01\xc4\x01\xff\xff\xff\xff\xc4\x01\xc5\x01\xc5\x01\xff\xff\xc2\x01\xc5\x01\xff\xff\xff\xff\xff\xff\xc3\x01\xff\xff\xc6\x01\xc6\x01\xff\xff\xff\xff\xc6\x01\xff\xff\xc0\x01\xff\xff\xc4\x01\xff\xff\xc4\x01\xff\xff\xff\xff\xc5\x01\xb8\x01\xc5\x01\xc4\x01\xc4\x01\xff\xff\xb9\x01\xff\xff\xc5\x01\xc5\x01\xc6\x01\xff\xff\xc6\x01\xc1\x01\xff\xff\xff\xff\xba\x01\xff\xff\xc6\x01\xc6\x01\xc7\x01\xc7\x01\xc4\x01\xff\xff\xc7\x01\xc8\x01\xc8\x01\xc5\x01\xff\xff\xc8\x01\xc9\x01\xc9\x01\xc2\x01\xff\xff\xc9\x01\xff\xff\xff\xff\xc6\x01\xff\xff\xff\xff\xc3\x01\xff\xff\xbb\x01\xc7\x01\xff\xff\xc7\x01\xff\xff\xff\xff\xc8\x01\xff\xff\xc8\x01\xc7\x01\xc7\x01\xc9\x01\xbc\x01\xc9\x01\xc8\x01\xc8\x01\xff\xff\xbd\x01\xff\xff\xc9\x01\xc9\x01\xca\x01\xca\x01\xff\xff\xff\xff\xca\x01\xff\xff\xc5\x01\xc7\x01\xff\xff\xc4\x01\xcb\x01\xcb\x01\xc8\x01\xff\xff\xcb\x01\xc6\x01\xff\xff\xc9\x01\xff\xff\xff\xff\xcc\x01\xcc\x01\xff\xff\xca\x01\xcc\x01\xca\x01\xff\xff\xff\xff\xff\xff\xff\xff\xbe\x01\xca\x01\xca\x01\xcb\x01\xff\xff\xcb\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcb\x01\xcb\x01\xcc\x01\xff\xff\xcc\x01\xff\xff\xff\xff\xff\xff\xff\xff\xca\x01\xcc\x01\xcc\x01\xff\xff\xff\xff\xc9\x01\xff\xff\xcd\x01\xcd\x01\xff\xff\xcb\x01\xcd\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbf\x01\xff\xff\xff\xff\xcc\x01\xc8\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc0\x01\xff\xff\xcd\x01\xff\xff\xcd\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x01\xcd\x01\xce\x01\xce\x01\xff\xff\xff\xff\xce\x01\xff\xff\xff\xff\xff\xff\xff\xff\xca\x01\xff\xff\xcf\x01\xcf\x01\xff\xff\xc1\x01\xcf\x01\xcb\x01\xcd\x01\xff\xff\xff\xff\xff\xff\xcc\x01\xff\xff\xce\x01\xc2\x01\xce\x01\xd0\x01\xd0\x01\xff\xff\xc3\x01\xd0\x01\xce\x01\xce\x01\xff\xff\xcf\x01\xff\xff\xcf\x01\xd1\x01\xd1\x01\xff\xff\xff\xff\xd1\x01\xcf\x01\xcf\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd0\x01\xce\x01\xd0\x01\xd2\x01\xd2\x01\xff\xff\xff\xff\xd2\x01\xd0\x01\xd0\x01\xff\xff\xd1\x01\xcf\x01\xd1\x01\xd3\x01\xd3\x01\xff\xff\xc4\x01\xd3\x01\xd1\x01\xd1\x01\xff\xff\xc5\x01\xff\xff\xff\xff\xff\xff\xd2\x01\xd0\x01\xd2\x01\xff\xff\xff\xff\xff\xff\xc6\x01\xff\xff\xd2\x01\xd2\x01\xff\xff\xd3\x01\xd1\x01\xd3\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x01\xd3\x01\xff\xff\xd4\x01\xd4\x01\xce\x01\xff\xff\xd4\x01\xd2\x01\xff\xff\xff\xff\xff\xff\xff\xff\xcf\x01\xff\xff\xff\xff\xff\xff\xd5\x01\xd5\x01\xd3\x01\xc7\x01\xd5\x01\xff\xff\xff\xff\xff\xff\xc8\x01\xd4\x01\xff\xff\xd4\x01\xff\xff\xc9\x01\xff\xff\xff\xff\xd0\x01\xd4\x01\xd4\x01\xff\xff\xff\xff\xff\xff\xff\xff\xd5\x01\xd1\x01\xd5\x01\xd6\x01\xd6\x01\xff\xff\xd2\x01\xd6\x01\xd5\x01\xd5\x01\xff\xff\xff\xff\xff\xff\xd4\x01\xff\xff\xd7\x01\xd7\x01\xff\xff\xd3\x01\xd7\x01\xff\xff\xff\xff\xff\xff\xca\x01\xff\xff\xff\xff\xd6\x01\xd5\x01\xd6\x01\xff\xff\xff\xff\xff\xff\xff\xff\xcb\x01\xd6\x01\xd6\x01\xff\xff\xff\xff\xd7\x01\xff\xff\xd7\x01\xd8\x01\xd8\x01\xcc\x01\xff\xff\xd8\x01\xd7\x01\xd7\x01\xff\xff\xff\xff\xff\xff\xd9\x01\xd9\x01\xd6\x01\xff\xff\xd9\x01\xda\x01\xda\x01\xff\xff\xff\xff\xda\x01\xff\xff\xd4\x01\xff\xff\xd8\x01\xd7\x01\xd8\x01\xdb\x01\xdb\x01\xd5\x01\xff\xff\xdb\x01\xd8\x01\xd8\x01\xd9\x01\xff\xff\xd9\x01\xff\xff\xff\xff\xda\x01\xcd\x01\xda\x01\xd9\x01\xd9\x01\xff\xff\xff\xff\xff\xff\xda\x01\xda\x01\xff\xff\xdb\x01\xd8\x01\xdb\x01\xff\xff\xff\xff\xff\xff\xdc\x01\xdc\x01\xdb\x01\xdb\x01\xdc\x01\xd9\x01\xff\xff\xff\xff\xff\xff\xff\xff\xda\x01\xff\xff\xff\xff\xff\xff\xdd\x01\xdd\x01\xff\xff\xce\x01\xdd\x01\xff\xff\xff\xff\xdb\x01\xff\xff\xdc\x01\xff\xff\xdc\x01\xd7\x01\xff\xff\xcf\x01\xff\xff\xff\xff\xdc\x01\xdc\x01\xff\xff\xff\xff\xff\xff\xff\xff\xdd\x01\xff\xff\xdd\x01\xff\xff\xff\xff\xff\xff\xd0\x01\xff\xff\xdd\x01\xdd\x01\xde\x01\xde\x01\xff\xff\xdc\x01\xde\x01\xff\xff\xd8\x01\xd1\x01\xff\xff\xff\xff\xdb\x01\xff\xff\xff\xff\xd9\x01\xda\x01\xdf\x01\xdf\x01\xdd\x01\xff\xff\xdf\x01\xff\xff\xff\xff\xd2\x01\xde\x01\xff\xff\xde\x01\xe0\x01\xe0\x01\xff\xff\xff\xff\xe0\x01\xde\x01\xde\x01\xd3\x01\xff\xff\xff\xff\xff\xff\xff\xff\xdf\x01\xff\xff\xdf\x01\xdc\x01\xff\xff\xdc\x01\xff\xff\xff\xff\xdf\x01\xdf\x01\xff\xff\xe0\x01\xde\x01\xe0\x01\xe1\x01\xe1\x01\xff\xff\xff\xff\xe1\x01\xe0\x01\xe0\x01\xff\xff\xff\xff\xff\xff\xe2\x01\xe2\x01\xff\xff\xdf\x01\xe2\x01\xd4\x01\xff\xff\xff\xff\xff\xff\xff\xff\xdd\x01\xff\xff\xff\xff\xe1\x01\xe0\x01\xe1\x01\xff\xff\xff\xff\xff\xff\xd5\x01\xff\xff\xe1\x01\xe1\x01\xe2\x01\xff\xff\xe2\x01\xde\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe2\x01\xe2\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe3\x01\xe3\x01\xff\xff\xe1\x01\xe3\x01\xe4\x01\xe4\x01\xff\xff\xd6\x01\xe4\x01\xe5\x01\xe5\x01\xff\xff\xe2\x01\xe5\x01\xff\xff\xff\xff\xdf\x01\xff\xff\xff\xff\xd7\x01\xff\xff\xff\xff\xe3\x01\xff\xff\xe3\x01\xff\xff\xff\xff\xe4\x01\xe0\x01\xe4\x01\xe3\x01\xe3\x01\xe5\x01\xff\xff\xe5\x01\xe4\x01\xe4\x01\xff\xff\xe6\x01\xe6\x01\xe5\x01\xe5\x01\xe6\x01\xe7\x01\xe7\x01\xd8\x01\xff\xff\xe7\x01\xff\xff\xe3\x01\xff\xff\xff\xff\xff\xff\xe1\x01\xe4\x01\xd9\x01\xff\xff\xff\xff\xe2\x01\xe5\x01\xda\x01\xe6\x01\xff\xff\xe6\x01\xff\xff\xff\xff\xe7\x01\xff\xff\xe7\x01\xe6\x01\xe6\x01\xdb\x01\xe8\x01\xe8\x01\xe7\x01\xe7\x01\xe8\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe9\x01\xe9\x01\xe6\x01\xe3\x01\xe9\x01\xff\xff\xe4\x01\xe7\x01\xff\xff\xe8\x01\xff\xff\xe8\x01\xea\x01\xea\x01\xdc\x01\xff\xff\xea\x01\xe8\x01\xe8\x01\xff\xff\xff\xff\xff\xff\xe5\x01\xe9\x01\xff\xff\xe9\x01\xff\xff\xff\xff\xdd\x01\xff\xff\xff\xff\xe9\x01\xe9\x01\xff\xff\xff\xff\xea\x01\xe8\x01\xea\x01\xe6\x01\xff\xff\xff\xff\xeb\x01\xeb\x01\xea\x01\xea\x01\xeb\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe9\x01\xff\xff\xec\x01\xec\x01\xff\xff\xff\xff\xec\x01\xff\xff\xe7\x01\xff\xff\xff\xff\xde\x01\xea\x01\xff\xff\xeb\x01\xff\xff\xeb\x01\xed\x01\xed\x01\xff\xff\xff\xff\xed\x01\xeb\x01\xeb\x01\xe8\x01\xec\x01\xdf\x01\xec\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xec\x01\xec\x01\xff\xff\xff\xff\xe0\x01\xff\xff\xff\xff\xed\x01\xeb\x01\xed\x01\xee\x01\xee\x01\xff\xff\xff\xff\xee\x01\xed\x01\xed\x01\xff\xff\xe9\x01\xec\x01\xef\x01\xef\x01\xff\xff\xff\xff\xef\x01\xf0\x01\xf0\x01\xff\xff\xff\xff\xf0\x01\xe1\x01\xff\xff\xff\xff\xee\x01\xed\x01\xee\x01\xff\xff\xff\xff\xff\xff\xff\xff\xe2\x01\xee\x01\xee\x01\xef\x01\xff\xff\xef\x01\xff\xff\xff\xff\xf0\x01\xff\xff\xf0\x01\xef\x01\xef\x01\xff\xff\xeb\x01\xff\xff\xf0\x01\xf0\x01\xf1\x01\xf1\x01\xee\x01\xff\xff\xf1\x01\xf2\x01\xf2\x01\xff\xff\xff\xff\xf2\x01\xff\xff\xff\xff\xef\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf0\x01\xec\x01\xe3\x01\xff\xff\xed\x01\xff\xff\xf1\x01\xe4\x01\xf1\x01\xff\xff\xff\xff\xf2\x01\xe5\x01\xf2\x01\xf1\x01\xf1\x01\xff\xff\xf3\x01\xf3\x01\xf2\x01\xf2\x01\xf3\x01\xf4\x01\xf4\x01\xff\xff\xff\xff\xf4\x01\xf5\x01\xf5\x01\xff\xff\xff\xff\xf5\x01\xff\xff\xf1\x01\xff\xff\xee\x01\xff\xff\xef\x01\xf2\x01\xff\xff\xf3\x01\xe6\x01\xf3\x01\xff\xff\xff\xff\xf4\x01\xe7\x01\xf4\x01\xf3\x01\xf3\x01\xf5\x01\xff\xff\xf5\x01\xf4\x01\xf4\x01\xff\xff\xff\xff\xf0\x01\xf5\x01\xf5\x01\xf6\x01\xf6\x01\xff\xff\xff\xff\xf6\x01\xff\xff\xff\xff\xf3\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf4\x01\xff\xff\xff\xff\xe8\x01\xff\xff\xf5\x01\xf2\x01\xf1\x01\xff\xff\xff\xff\xff\xff\xf6\x01\xff\xff\xf6\x01\xf7\x01\xf7\x01\xff\xff\xe9\x01\xf7\x01\xf6\x01\xf6\x01\xff\xff\xff\xff\xff\xff\xf8\x01\xf8\x01\xff\xff\xff\xff\xf8\x01\xea\x01\xff\xff\xf3\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf7\x01\xf6\x01\xf7\x01\xf9\x01\xf9\x01\xff\xff\xf5\x01\xf9\x01\xf7\x01\xf7\x01\xf8\x01\xff\xff\xf8\x01\xff\xff\xf4\x01\xff\xff\xff\xff\xff\xff\xf8\x01\xf8\x01\xff\xff\xeb\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf9\x01\xf7\x01\xf9\x01\xff\xff\xff\xff\xff\xff\xec\x01\xff\xff\xf9\x01\xf9\x01\xff\xff\xf8\x01\xff\xff\xfa\x01\xfa\x01\xff\xff\xff\xff\xfa\x01\xff\xff\xff\xff\xff\xff\xed\x01\xff\xff\xff\xff\xff\xff\xff\xff\xf6\x01\xf9\x01\xfb\x01\xfb\x01\xff\xff\xff\xff\xfb\x01\xfc\x01\xfc\x01\xff\xff\xfa\x01\xfc\x01\xfa\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfa\x01\xfa\x01\xff\xff\xee\x01\xff\xff\xf8\x01\xff\xff\xfb\x01\xff\xff\xfb\x01\xff\xff\xff\xff\xfc\x01\xef\x01\xfc\x01\xfb\x01\xfb\x01\xff\xff\xf0\x01\xfa\x01\xfc\x01\xfc\x01\xfd\x01\xfd\x01\xff\xff\xff\xff\xfd\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfb\x01\xff\xff\xf9\x01\xfe\x01\xfe\x01\xfc\x01\xff\xff\xfe\x01\xff\x01\xff\x01\xff\xff\xfd\x01\xff\x01\xfd\x01\xff\xff\xff\xff\xff\xff\xf1\x01\xff\xff\xfd\x01\xfd\x01\xff\xff\xf2\x01\0\x02\0\x02\xff\xff\xfe\x01\0\x02\xfe\x01\xff\xff\xff\xff\xff\x01\xff\xff\xff\x01\xfe\x01\xfe\x01\xff\xff\xff\xff\xfd\x01\xff\x01\xff\x01\xff\xff\xff\xff\xfc\x01\xff\xff\xfb\x01\0\x02\xff\xff\0\x02\xff\xff\xff\xff\xf3\x01\xff\xff\xfe\x01\0\x02\0\x02\xf4\x01\xff\xff\xff\x01\xff\xff\xff\xff\xf5\x01\xff\xff\xff\xff\xff\xff\xff\xff\x01\x02\x01\x02\xff\xff\xff\xff\x01\x02\xff\xff\xff\xff\0\x02\xff\xff\xff\xff\x02\x02\x02\x02\xff\xff\xff\xff\x02\x02\x03\x02\x03\x02\xff\xff\xff\xff\x03\x02\xff\xff\xff\xff\xff\xff\x01\x02\xff\xff\x01\x02\xff\xff\xff\xff\xf6\x01\xff\xff\xfd\x01\x01\x02\x01\x02\x02\x02\xff\xff\x02\x02\xff\xff\xff\xff\x03\x02\xff\xff\x03\x02\x02\x02\x02\x02\xfe\x01\x04\x02\x04\x02\x03\x02\x03\x02\x04\x02\xff\x01\x01\x02\xff\xff\xff\xff\0\x02\xf7\x01\xff\xff\xff\xff\xff\xff\x05\x02\x05\x02\x02\x02\xff\xff\x05\x02\xff\xff\xf8\x01\x03\x02\xff\xff\x04\x02\xff\xff\x04\x02\xff\xff\xff\xff\xff\xff\x06\x02\x06\x02\x04\x02\x04\x02\x06\x02\x07\x02\x07\x02\xf9\x01\x05\x02\x07\x02\x05\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x05\x02\x05\x02\xff\xff\xff\xff\xff\xff\x04\x02\xff\xff\x06\x02\xff\xff\x06\x02\xff\xff\xff\xff\x07\x02\x01\x02\x07\x02\x06\x02\x06\x02\xff\xff\xff\xff\x05\x02\x07\x02\x07\x02\x02\x02\xff\xff\xff\xff\b\x02\b\x02\xfa\x01\xff\xff\b\x02\xff\xff\xff\xff\xff\xff\xff\xff\x06\x02\xff\xff\t\x02\t\x02\xff\xff\x07\x02\t\x02\xff\xff\xfb\x01\xff\xff\xff\xff\xff\xff\x04\x02\xfc\x01\b\x02\xff\xff\b\x02\n\x02\n\x02\xff\xff\xff\xff\n\x02\b\x02\b\x02\xff\xff\t\x02\xff\xff\t\x02\x0b\x02\x0b\x02\xff\xff\xff\xff\x0b\x02\t\x02\t\x02\x05\x02\xff\xff\xff\xff\xff\xff\xff\xff\n\x02\b\x02\n\x02\xff\xff\xff\xff\xff\xff\xfd\x01\xff\xff\n\x02\n\x02\xff\xff\x0b\x02\t\x02\x0b\x02\f\x02\f\x02\xff\xff\x06\x02\f\x02\x0b\x02\x0b\x02\xfe\x01\xff\xff\xff\xff\r\x02\r\x02\xff\x01\n\x02\r\x02\x0e\x02\x0e\x02\xff\xff\xff\xff\x0e\x02\xff\xff\xff\xff\xff\xff\f\x02\x0b\x02\f\x02\xff\xff\0\x02\xff\xff\xff\xff\xff\xff\f\x02\f\x02\r\x02\xff\xff\r\x02\xff\xff\xff\xff\x0e\x02\b\x02\x0e\x02\r\x02\r\x02\xff\xff\xff\xff\xff\xff\x0e\x02\x0e\x02\xff\xff\xff\xff\f\x02\x0f\x02\x0f\x02\t\x02\xff\xff\x0f\x02\xff\xff\xff\xff\xff\xff\xff\xff\r\x02\xff\xff\xff\xff\x10\x02\x10\x02\x0e\x02\xff\xff\x10\x02\x11\x02\x11\x02\x01\x02\xff\xff\x11\x02\xff\xff\x0f\x02\n\x02\x0f\x02\xff\xff\xff\xff\xff\xff\x02\x02\xff\xff\x0f\x02\x0f\x02\xff\xff\x03\x02\x10\x02\xff\xff\x10\x02\xff\xff\xff\xff\x11\x02\xff\xff\x11\x02\x10\x02\x10\x02\xff\xff\xff\xff\xff\xff\x11\x02\x11\x02\x0f\x02\x12\x02\x12\x02\xff\xff\xff\xff\x12\x02\x0e\x02\f\x02\r\x02\xff\xff\xff\xff\xff\xff\x10\x02\x04\x02\x13\x02\x13\x02\xff\xff\x11\x02\x13\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x12\x02\xff\xff\x12\x02\x05\x02\xff\xff\xff\xff\x14\x02\x14\x02\x12\x02\x12\x02\x14\x02\xff\xff\xff\xff\x13\x02\xff\xff\x13\x02\x15\x02\x15\x02\x06\x02\xff\xff\x15\x02\x13\x02\x13\x02\x07\x02\xff\xff\xff\xff\xff\xff\x12\x02\xff\xff\x14\x02\xff\xff\x14\x02\x16\x02\x16\x02\xff\xff\x11\x02\x16\x02\x14\x02\x14\x02\x15\x02\x13\x02\x15\x02\xff\xff\x10\x02\xff\xff\xff\xff\xff\xff\x15\x02\x15\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x02\x14\x02\x16\x02\xff\xff\b\x02\xff\xff\xff\xff\xff\xff\x16\x02\x16\x02\x12\x02\x15\x02\x17\x02\x17\x02\xff\xff\t\x02\x17\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x18\x02\x18\x02\xff\xff\x13\x02\x18\x02\x16\x02\xff\xff\xff\xff\n\x02\xff\xff\xff\xff\xff\xff\xff\xff\x17\x02\xff\xff\x17\x02\x19\x02\x19\x02\xff\xff\x0b\x02\x19\x02\x17\x02\x17\x02\x18\x02\x14\x02\x18\x02\xff\xff\x15\x02\xff\xff\xff\xff\xff\xff\x18\x02\x18\x02\x1a\x02\x1a\x02\xff\xff\xff\xff\x1a\x02\xff\xff\x19\x02\x17\x02\x19\x02\xff\xff\xff\xff\x16\x02\f\x02\xff\xff\x19\x02\x19\x02\xff\xff\x18\x02\xff\xff\xff\xff\x1b\x02\x1b\x02\r\x02\x1a\x02\x1b\x02\x1a\x02\xff\xff\x0e\x02\xff\xff\xff\xff\xff\xff\x1a\x02\x1a\x02\x19\x02\xff\xff\x1c\x02\x1c\x02\xff\xff\xff\xff\x1c\x02\xff\xff\xff\xff\xff\xff\x1b\x02\xff\xff\x1b\x02\xff\xff\xff\xff\xff\xff\xff\xff\x1a\x02\x1b\x02\x1b\x02\xff\xff\xff\xff\xff\xff\x17\x02\xff\xff\x1c\x02\x18\x02\x1c\x02\x1d\x02\x1d\x02\x0f\x02\xff\xff\x1d\x02\x1c\x02\x1c\x02\xff\xff\xff\xff\x1b\x02\xff\xff\xff\xff\x1e\x02\x1e\x02\x10\x02\xff\xff\x1e\x02\x1f\x02\x1f\x02\x11\x02\xff\xff\x1f\x02\xff\xff\x1d\x02\x1c\x02\x1d\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1d\x02\x1d\x02\xff\xff\xff\xff\x1e\x02\xff\xff\x1e\x02\xff\xff\xff\xff\x1f\x02\xff\xff\x1f\x02\x1e\x02\x1e\x02\xff\xff\x1a\x02\xff\xff\x1f\x02\x1f\x02\x1d\x02\xff\xff\xff\xff\x12\x02\xff\xff \x02 \x02\xff\xff\xff\xff \x02\xff\xff\x1b\x02\x1e\x02\xff\xff\xff\xff\xff\xff\x13\x02\x1f\x02\xff\xff\xff\xff\xff\xff!\x02!\x02\xff\xff\xff\xff!\x02\xff\xff\x1c\x02 \x02\xff\xff \x02\xff\xff\x14\x02\xff\xff#\x02#\x02 \x02 \x02#\x02\xff\xff\xff\xff\xff\xff\x15\x02\xff\xff!\x02\xff\xff!\x02\"\x02\"\x02\xff\xff\x1e\x02\"\x02!\x02!\x02\xff\xff \x02\xff\xff#\x02\x16\x02#\x02$\x02$\x02\xff\xff\xff\xff$\x02#\x02#\x02\xff\xff\xff\xff\xff\xff\"\x02!\x02\"\x02%\x02%\x02\xff\xff\xff\xff%\x02\"\x02\"\x02\xff\xff\xff\xff\xff\xff$\x02#\x02$\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff$\x02$\x02\x17\x02\xff\xff\xff\xff%\x02\"\x02%\x02\xff\xff\xff\xff\xff\xff\xff\xff\x18\x02%\x02%\x02 \x02!\x02\xff\xff\xff\xff$\x02\xff\xff&\x02&\x02\xff\xff\xff\xff&\x02\xff\xff\xff\xff\x19\x02\xff\xff\xff\xff\xff\xff%\x02#\x02\xff\xff\xff\xff\xff\xff'\x02'\x02\xff\xff\xff\xff'\x02\xff\xff\xff\xff&\x02\x1a\x02&\x02(\x02(\x02\xff\xff\xff\xff(\x02&\x02&\x02\xff\xff\xff\xff\xff\xff\xff\xff\"\x02\xff\xff'\x02\xff\xff'\x02\xff\xff\xff\xff\x1b\x02\xff\xff$\x02'\x02'\x02(\x02&\x02(\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff(\x02(\x02\x1c\x02\xff\xff)\x02)\x02\xff\xff\xff\xff)\x02'\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff(\x02\xff\xff*\x02*\x02\xff\xff\xff\xff*\x02\xff\xff)\x02\x1d\x02)\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff)\x02)\x02\xff\xff\xff\xff&\x02\x1e\x02\xff\xff\xff\xff\xff\xff*\x02\x1f\x02*\x02'\x02\xff\xff\xff\xff&\x02\xff\xff*\x02*\x02)\x02+\x02+\x02\xff\xff\xff\xff+\x02\xff\xff\xff\xff(\x02\xff\xff\xff\xff,\x02,\x02\xff\xff\xff\xff,\x02\xff\xff*\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff+\x02\xff\xff+\x02\xff\xff\xff\xff \x02\xff\xff\xff\xff+\x02+\x02,\x02\xff\xff,\x02-\x02-\x02\xff\xff\xff\xff-\x02,\x02,\x02\xff\xff!\x02\xff\xff\xff\xff\xff\xff.\x02.\x02+\x02\xff\xff.\x02\xff\xff\xff\xff*\x02\xff\xff#\x02\xff\xff-\x02,\x02-\x02/\x02/\x02\xff\xff\xff\xff/\x02-\x02-\x02\xff\xff\"\x02.\x02\xff\xff.\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff.\x02.\x02\xff\xff\xff\xff$\x02\xff\xff/\x02-\x02/\x020\x020\x02\xff\xff\xff\xff0\x02/\x02/\x02\xff\xff%\x02\xff\xff.\x02+\x021\x021\x02,\x02\xff\xff1\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff0\x02/\x020\x022\x022\x02\xff\xff\xff\xff2\x020\x020\x02\xff\xff\xff\xff1\x02\xff\xff1\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff1\x021\x02\xff\xff\xff\xff&\x02.\x022\x020\x022\x023\x023\x02\xff\xff\xff\xff3\x022\x022\x02\xff\xff\xff\xff\xff\xff1\x02'\x024\x024\x02\xff\xff\xff\xff4\x02\xff\xff\xff\xff\xff\xff\xff\xff(\x02\xff\xff3\x022\x023\x02\xff\xff/\x02\xff\xff\xff\xff\xff\xff3\x023\x02\xff\xff\xff\xff4\x02\xff\xff4\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff4\x024\x02\xff\xff\xff\xff5\x025\x02\xff\xff3\x025\x02\xff\xff\xff\xff\xff\xff\xff\xff)\x02\xff\xff\xff\xff\xff\xff0\x02\xff\xff4\x02\xff\xff2\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff5\x02\xff\xff5\x02*\x02\xff\xff\xff\xff2\x02\xff\xff5\x025\x026\x026\x02\xff\xff\xff\xff6\x02\xff\xff\xff\xff\xff\xff3\x02\xff\xff\xff\xff7\x027\x02\xff\xff\xff\xff7\x02\xff\xff5\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff6\x02\xff\xff6\x02\xff\xff+\x02\xff\xff\xff\xff\xff\xff6\x026\x02\xff\xff7\x024\x027\x02,\x02\xff\xff\xff\xff\xff\xff\xff\xff7\x027\x02\xff\xff8\x028\x02\xff\xff\xff\xff8\x026\x02\xff\xff\xff\xff\xff\xff\xff\xff9\x029\x02\xff\xff\xff\xff9\x02\xff\xff7\x02\xff\xff-\x02\xff\xff\xff\xff\xff\xff\xff\xff8\x02\xff\xff8\x02\xff\xff\xff\xff\xff\xff\xff\xff.\x028\x028\x029\x02\xff\xff9\x02:\x02:\x02\xff\xff\xff\xff:\x029\x029\x02\xff\xff/\x02\xff\xff\xff\xff\xff\xff;\x02;\x028\x02\xff\xff;\x02\xff\xff6\x02\xff\xff\xff\xff\xff\xff\xff\xff:\x029\x02:\x02<\x02<\x02\xff\xff\xff\xff<\x02:\x02:\x02\xff\xff0\x02;\x02\xff\xff;\x02=\x02=\x02\xff\xff\xff\xff=\x02;\x02;\x02\xff\xff1\x02\xff\xff\xff\xff<\x02:\x02<\x02>\x02>\x02\xff\xff\xff\xff>\x02<\x02<\x02\xff\xff2\x02=\x02;\x02=\x02?\x02?\x029\x028\x02?\x02=\x02=\x02\xff\xff\xff\xff\xff\xff\xff\xff>\x02<\x02>\x02@\x02@\x029\x02\xff\xff@\x02>\x02>\x02\xff\xff3\x02?\x02=\x02?\x02\xff\xff:\x02\xff\xffA\x02A\x02?\x02?\x02A\x024\x02\xff\xff\xff\xff@\x02>\x02@\x02C\x02C\x02\xff\xff\xff\xffC\x02@\x02@\x02\xff\xff\xff\xff\xff\xff?\x02\xff\xffA\x02\xff\xffA\x02B\x02B\x02\xff\xff\xff\xffB\x02A\x02A\x02<\x02C\x02@\x02C\x02=\x02\xff\xff\xff\xff5\x02\xff\xffC\x02C\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffB\x02A\x02B\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffB\x02B\x02\xff\xff\xff\xffC\x02\xff\xffD\x02D\x02\xff\xff\xff\xffD\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff6\x02\xff\xff\xff\xffB\x02E\x02E\x02\xff\xff\xff\xffE\x02\xff\xff\xff\xff7\x02\xff\xffD\x02@\x02D\x02F\x02F\x02\xff\xff\xff\xffF\x02D\x02D\x02\xff\xff\xff\xff\xff\xff\xff\xffE\x02\xff\xffE\x02\xff\xff\xff\xffA\x02G\x02G\x02E\x02E\x02G\x02\xff\xffF\x02D\x02F\x02\xff\xff\xff\xff\xff\xff8\x02\xff\xffF\x02F\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffE\x029\x02G\x02\xff\xffG\x02\xff\xffB\x02\xff\xff\xff\xff\xff\xffG\x02G\x02F\x02H\x02H\x02\xff\xff\xff\xffH\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffI\x02I\x02\xff\xff:\x02I\x02G\x02D\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffH\x02\xff\xffH\x02;\x02\xff\xff\xff\xffD\x02D\x02H\x02H\x02E\x02I\x02\xff\xffI\x02J\x02J\x02\xff\xff<\x02J\x02I\x02I\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffH\x02\xff\xff=\x02\xff\xffK\x02K\x02\xff\xffF\x02K\x02\xff\xffJ\x02I\x02J\x02\xff\xff\xff\xff\xff\xff>\x02\xff\xffJ\x02J\x02\xff\xffL\x02L\x02\xff\xffG\x02L\x02\xff\xffK\x02?\x02K\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffK\x02K\x02J\x02\xff\xff\xff\xff\xff\xff\xff\xff@\x02\xff\xffL\x02\xff\xffL\x02M\x02M\x02\xff\xff\xff\xffM\x02L\x02L\x02K\x02H\x02\xff\xffA\x02\xff\xffN\x02N\x02\xff\xffI\x02N\x02\xff\xff\xff\xff\xff\xff\xff\xffC\x02\xff\xffM\x02L\x02M\x02O\x02O\x02\xff\xff\xff\xffO\x02M\x02M\x02\xff\xff\xff\xffN\x02B\x02N\x02P\x02P\x02\xff\xff\xff\xffP\x02N\x02N\x02\xff\xff\xff\xff\xff\xff\xff\xffO\x02M\x02O\x02\xff\xff\xff\xff\xff\xff\xff\xffK\x02O\x02O\x02\xff\xff\xff\xffP\x02N\x02P\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffP\x02P\x02Q\x02Q\x02D\x02\xff\xffQ\x02O\x02\xff\xff\xff\xff\xff\xff\xff\xffL\x02R\x02R\x02\xff\xff\xff\xffR\x02E\x02P\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffQ\x02\xff\xffQ\x02S\x02S\x02F\x02\xff\xffS\x02Q\x02Q\x02\xff\xffR\x02\xff\xffR\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffR\x02R\x02\xff\xffG\x02\xff\xffN\x02\xff\xffS\x02Q\x02S\x02T\x02T\x02\xff\xff\xff\xffT\x02S\x02S\x02P\x02\xff\xffR\x02O\x02\xff\xffU\x02U\x02\xff\xff\xff\xffU\x02V\x02V\x02\xff\xff\xff\xffV\x02\xff\xffT\x02S\x02T\x02\xff\xffH\x02\xff\xffW\x02W\x02T\x02T\x02W\x02\xff\xffU\x02\xff\xffU\x02I\x02\xff\xffV\x02\xff\xffV\x02U\x02U\x02\xff\xff\xff\xff\xff\xffV\x02V\x02T\x02\xff\xffW\x02Q\x02W\x02X\x02X\x02\xff\xff\xff\xffX\x02W\x02W\x02U\x02S\x02J\x02Y\x02Y\x02V\x02\xff\xffY\x02Z\x02Z\x02\xff\xff\xff\xffZ\x02\xff\xff\xff\xff\xff\xffX\x02W\x02X\x02K\x02\xff\xff\xff\xff\xff\xff\xff\xffX\x02X\x02Y\x02\xff\xffY\x02\xff\xff\xff\xffZ\x02\xff\xffZ\x02Y\x02Y\x02L\x02\xff\xff\xff\xffZ\x02Z\x02T\x02U\x02X\x02[\x02[\x02\xff\xffV\x02[\x02\xff\xff\xff\xff\xff\xff\xff\xffY\x02\xff\xff\\\x02\\\x02\xff\xffZ\x02\\\x02]\x02]\x02M\x02\xff\xff]\x02\xff\xff\xff\xff[\x02W\x02[\x02\xff\xff\xff\xff\xff\xff\xff\xffN\x02[\x02[\x02\xff\xff\\\x02\xff\xff\\\x02\xff\xff\xff\xff]\x02\xff\xff]\x02\\\x02\\\x02O\x02Y\x02\xff\xff]\x02]\x02\xff\xff[\x02\xff\xff\xff\xff^\x02^\x02\xff\xffP\x02^\x02\xff\xff\xff\xff\xff\xff\\\x02\xff\xffZ\x02\xff\xff\xff\xff]\x02_\x02_\x02\xff\xff\xff\xff_\x02\xff\xff\xff\xff\xff\xff\xff\xff^\x02\xff\xff^\x02\xff\xff\xff\xff\xff\xff`\x02`\x02^\x02^\x02`\x02a\x02a\x02Q\x02_\x02a\x02_\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff_\x02_\x02R\x02\\\x02[\x02^\x02]\x02`\x02\xff\xff`\x02\xff\xff\xff\xffa\x02\xff\xffa\x02`\x02`\x02S\x02\xff\xff_\x02a\x02a\x02\xff\xff\xff\xff\xff\xffb\x02b\x02\xff\xff\xff\xffb\x02\xff\xff\xff\xff\xff\xff\xff\xff`\x02\xff\xffc\x02c\x02\xff\xffa\x02c\x02\xff\xff\xff\xffT\x02\xff\xff\xff\xff\xff\xff\xff\xffb\x02\xff\xffb\x02\xff\xff\xff\xff\xff\xff^\x02U\x02b\x02b\x02\xff\xffc\x02V\x02c\x02d\x02d\x02\xff\xff\xff\xffd\x02c\x02c\x02\xff\xff\xff\xff\xff\xffW\x02\xff\xff\xff\xffb\x02`\x02\xff\xff\xff\xffe\x02e\x02\xff\xff\xff\xffe\x02\xff\xffd\x02c\x02d\x02\xff\xff\xff\xff\xff\xfff\x02f\x02d\x02d\x02f\x02\xff\xff\xff\xffX\x02\xff\xff\xff\xff\xff\xffe\x02\xff\xffe\x02\xff\xff\xff\xff\xff\xffY\x02\xff\xffe\x02e\x02d\x02Z\x02f\x02\xff\xfff\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfff\x02f\x02b\x02\xff\xff\xff\xff\xff\xffc\x02e\x02g\x02g\x02\xff\xff\xff\xffg\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xfff\x02\xff\xff\xff\xffh\x02h\x02\xff\xff\xff\xffh\x02[\x02\xff\xff\xff\xff\xff\xffg\x02\xff\xffg\x02\xff\xff\xff\xff\xff\xff\xff\xff\\\x02g\x02g\x02\xff\xff\xff\xff]\x02\xff\xffh\x02\xff\xffh\x02\xff\xff\xff\xff\xff\xffi\x02i\x02h\x02h\x02i\x02\xff\xfff\x02g\x02\xff\xff\xff\xff\xff\xffe\x02\xff\xff\xff\xff\xff\xffj\x02j\x02\xff\xff\xff\xffj\x02\xff\xffh\x02\xff\xffi\x02\xff\xffi\x02\xff\xff\xff\xff\xff\xff^\x02\xff\xffi\x02i\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffj\x02\xff\xffj\x02\xff\xff\xff\xff_\x02k\x02k\x02j\x02j\x02k\x02\xff\xffi\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffg\x02h\x02`\x02\xff\xff\xff\xff\xff\xff\xff\xffa\x02g\x02j\x02\xff\xffk\x02\xff\xffk\x02l\x02l\x02\xff\xff\xff\xffl\x02k\x02k\x02\xff\xff\xff\xff\xff\xff\xff\xffm\x02m\x02\xff\xff\xff\xffm\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffi\x02l\x02k\x02l\x02n\x02n\x02\xff\xffb\x02n\x02l\x02l\x02\xff\xffm\x02j\x02m\x02o\x02o\x02\xff\xffc\x02o\x02m\x02m\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffn\x02l\x02n\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffn\x02n\x02\xff\xffo\x02m\x02o\x02\xff\xff\xff\xff\xff\xffd\x02\xff\xffo\x02o\x02\xff\xffp\x02p\x02\xff\xff\xff\xffp\x02n\x02\xff\xff\xff\xff\xff\xff\xff\xffk\x02\xff\xffe\x02\xff\xff\xff\xff\xff\xffo\x02q\x02q\x02\xff\xff\xff\xffq\x02\xff\xffp\x02f\x02p\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffp\x02p\x02\xff\xffm\x02\xff\xff\xff\xff\xff\xff\xff\xffm\x02q\x02\xff\xffq\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffq\x02q\x02p\x02\xff\xff\xff\xff\xff\xffn\x02\xff\xff\xff\xffr\x02r\x02\xff\xff\xff\xffr\x02\xff\xffg\x02\xff\xff\xff\xff\xff\xffq\x02o\x02s\x02s\x02\xff\xff\xff\xffs\x02\xff\xff\xff\xff\xff\xffh\x02\xff\xff\xff\xffr\x02\xff\xffr\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffr\x02r\x02p\x02\xff\xffs\x02\xff\xffs\x02t\x02t\x02\xff\xff\xff\xfft\x02s\x02s\x02\xff\xff\xff\xff\xff\xffq\x02i\x02r\x02\xff\xffu\x02u\x02\xff\xff\xff\xffu\x02\xff\xff\xff\xff\xff\xff\xff\xfft\x02s\x02t\x02j\x02\xff\xff\xff\xff\xff\xff\xff\xfft\x02t\x02\xff\xffv\x02v\x02\xff\xffu\x02v\x02u\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffu\x02u\x02w\x02w\x02\xff\xfft\x02w\x02\xff\xff\xff\xff\xff\xffk\x02\xff\xffv\x02\xff\xffv\x02\xff\xffr\x02\xff\xff\xff\xffu\x02v\x02v\x02\xff\xff\xff\xff\xff\xffw\x02\xff\xffw\x02x\x02x\x02\xff\xff\xff\xffx\x02w\x02w\x02\xff\xffl\x02\xff\xff\xff\xffv\x02y\x02y\x02\xff\xff\xff\xffy\x02\xff\xff\xff\xffm\x02\xff\xff\xff\xff\xff\xffx\x02w\x02x\x02\xff\xff\xff\xff\xff\xfft\x02u\x02x\x02x\x02\xff\xffn\x02y\x02\xff\xffy\x02z\x02z\x02\xff\xff\xff\xffz\x02y\x02y\x02o\x02\xff\xff\xff\xff\xff\xffv\x02x\x02{\x02{\x02\xff\xff\xff\xff{\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffz\x02y\x02z\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffz\x02z\x02\xff\xff\xff\xffw\x02{\x02\xff\xff{\x02|\x02|\x02p\x02\xff\xff|\x02{\x02{\x02\xff\xff\xff\xff\xff\xff\xff\xffz\x02}\x02}\x02\xff\xff\xff\xff}\x02\xff\xff\xff\xffq\x02\xff\xff\xff\xff\xff\xff|\x02{\x02|\x02~\x02~\x02\xff\xff\xff\xff~\x02|\x02|\x02\xff\xff\xff\xff}\x02\xff\xff}\x02\x7f\x02\x7f\x02y\x02\xff\xff\x7f\x02}\x02}\x02\xff\xff\xff\xff\xff\xff\xff\xff~\x02|\x02~\x02\x80\x02\x80\x02\xff\xff\xff\xff\x80\x02~\x02~\x02r\x02\xff\xff\x7f\x02}\x02\x7f\x02\xff\xff\xff\xff\xff\xff\xff\xffz\x02\x7f\x02\x7f\x02s\x02\xff\xff\xff\xff\xff\xff\x80\x02~\x02\x80\x02\x81\x02\x81\x02\xff\xff\xff\xff\x81\x02\x80\x02\x80\x02\xff\xff\xff\xff\xff\xff\x7f\x02\x82\x02\x82\x02\xff\xff\xff\xff\x82\x02\xff\xff\xff\xff|\x02t\x02\xff\xff\xff\xff\xff\xff\x81\x02\x80\x02\x81\x02\x83\x02\x83\x02\xff\xff\xff\xff\x83\x02\x81\x02\x81\x02u\x02\x82\x02\xff\xff\x82\x02}\x02\xff\xff\xff\xff\x84\x02\x84\x02\x82\x02\x82\x02\x84\x02\xff\xff\xff\xff\xff\xff\xff\xff\x83\x02\x81\x02\x83\x02\xff\xffv\x02\xff\xff~\x02\xff\xff\x83\x02\x83\x02\xff\xff\xff\xff\x82\x02\xff\xff\x84\x02\xff\xff\x84\x02w\x02\xff\xff\xff\xff\xff\xff\xff\xff\x84\x02\x84\x02\xff\xff\xff\xff\xff\xff\x83\x02\x85\x02\x85\x02\x80\x02\xff\xff\x85\x02\x86\x02\x86\x02\xff\xff\xff\xff\x86\x02\xff\xff\xff\xff\xff\xff\x84\x02\xff\xffx\x02\xff\xff\x87\x02\x87\x02\xff\xff\xff\xff\x87\x02\x81\x02\x85\x02\xff\xff\x85\x02\xff\xffy\x02\x86\x02\xff\xff\x86\x02\x85\x02\x85\x02\x82\x02\xff\xff\x83\x02\x86\x02\x86\x02\xff\xff\xff\xff\x87\x02\xff\xff\x87\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x87\x02\x87\x02\x85\x02\xff\xff\xff\xffz\x02\xff\xff\x86\x02\x88\x02\x88\x02\xff\xff\x84\x02\x88\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff{\x02\x87\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x88\x02\xff\xff\x88\x02\xff\xff\xff\xff\xff\xff\x89\x02\x89\x02\x88\x02\x88\x02\x89\x02\xff\xff\xff\xff|\x02\xff\xff\xff\xff\xff\xff\x86\x02\xff\xff\xff\xff\xff\xff\xff\xff\x85\x02\xff\xff\xff\xff}\x02\xff\xff\x88\x02\xff\xff\x89\x02\xff\xff\x89\x02\xff\xff\xff\xff\x87\x02\xff\xff\xff\xff\x89\x02\x89\x02~\x02\xff\xff\xff\xff\xff\xff\x8a\x02\x8a\x02\xff\xff\xff\xff\x8a\x02\xff\xff\xff\xff\xff\xff\x7f\x02\xff\xff\x8b\x02\x8b\x02\xff\xff\x89\x02\x8b\x02\x8c\x02\x8c\x02\xff\xff\xff\xff\x8c\x02\xff\xff\xff\xff\x80\x02\x8a\x02\xff\xff\x8a\x02\x8d\x02\x8d\x02\xff\xff\xff\xff\x8d\x02\x8a\x02\x8a\x02\x8b\x02\xff\xff\x8b\x02\xff\xff\xff\xff\x8c\x02\x88\x02\x8c\x02\x8b\x02\x8b\x02\xff\xff\xff\xff\xff\xff\x8c\x02\x8c\x02\x81\x02\x8d\x02\x8a\x02\x8d\x02\x8e\x02\x8e\x02\xff\xff\x89\x02\x8e\x02\x8d\x02\x8d\x02\x82\x02\x8b\x02\xff\xff\x8f\x02\x8f\x02\xff\xff\x8c\x02\x8f\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x83\x02\x8e\x02\x8d\x02\x8e\x02\x90\x02\x90\x02\xff\xff\xff\xff\x90\x02\x8e\x02\x8e\x02\x8f\x02\xff\xff\x8f\x02\x84\x02\xff\xff\x8a\x02\x91\x02\x91\x02\x8f\x02\x8f\x02\x91\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x90\x02\x8e\x02\x90\x02\x92\x02\x92\x02\xff\xff\xff\xff\x92\x02\x90\x02\x90\x02\xff\xff\x8f\x02\xff\xff\x91\x02\xff\xff\x91\x02\x8b\x02\xff\xff\xff\xff\x93\x02\x93\x02\x91\x02\x91\x02\x93\x02\x85\x02\xff\xff\x92\x02\x90\x02\x92\x02\x86\x02\x8d\x02\xff\xff\x94\x02\x94\x02\x92\x02\x92\x02\x94\x02\xff\xff\xff\xff\xff\xff\x91\x02\x87\x02\x93\x02\x8e\x02\x93\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x93\x02\x93\x02\xff\xff\x92\x02\xff\xff\x94\x02\xff\xff\x94\x02\xff\xff\xff\xff\xff\xff\xff\xff\x8f\x02\x94\x02\x94\x02\xff\xff\x95\x02\x95\x02\xff\xff\x93\x02\x95\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x91\x02\xff\xff\xff\xff\xff\xff\x88\x02\xff\xff\x94\x02\xff\xff\x90\x02\xff\xff\xff\xff\xff\xff\xff\xff\x95\x02\xff\xff\x95\x02\x96\x02\x96\x02\xff\xff\xff\xff\x96\x02\x95\x02\x95\x02\xff\xff\xff\xff\xff\xff\xff\xff\x92\x02\x97\x02\x97\x02\xff\xff\xff\xff\x97\x02\x89\x02\xff\xff\x93\x02\xff\xff\xff\xff\xff\xff\x96\x02\x95\x02\x96\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x96\x02\x96\x02\xff\xff\xff\xff\x97\x02\xff\xff\x97\x02\xff\xff\xff\xff\x94\x02\xff\xff\xff\xff\x97\x02\x97\x02\xff\xff\xff\xff\x98\x02\x98\x02\xff\xff\x96\x02\x98\x02\x99\x02\x99\x02\x8a\x02\xff\xff\x99\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x97\x02\xff\xff\x8b\x02\xff\xff\xff\xff\x9a\x02\x9a\x02\x8c\x02\x98\x02\x9a\x02\x98\x02\xff\xff\xff\xff\x99\x02\x95\x02\x99\x02\x98\x02\x98\x02\x8d\x02\xff\xff\xff\xff\x99\x02\x99\x02\xff\xff\xff\xff\x9b\x02\x9b\x02\xff\xff\x9a\x02\x9b\x02\x9a\x02\xff\xff\xff\xff\xff\xff\xff\xff\x98\x02\x9a\x02\x9a\x02\xff\xff\xff\xff\x99\x02\x9c\x02\x9c\x02\x96\x02\x8e\x02\x9c\x02\xff\xff\xff\xff\x9b\x02\xff\xff\x9b\x02\xff\xff\xff\xff\xff\xff\x8f\x02\x9a\x02\x9b\x02\x9b\x02\xff\xff\xff\xff\xff\xff\xff\xff\x97\x02\xff\xff\x9c\x02\xff\xff\x9c\x02\xff\xff\xff\xff\xff\xff\x90\x02\xff\xff\x9c\x02\x9c\x02\xff\xff\x9b\x02\xff\xff\xff\xff\x9d\x02\x9d\x02\xff\xff\xff\xff\x9d\x02\x91\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x9c\x02\x99\x02\xff\xff\xff\xff\xff\xff\x92\x02\xff\xff\x9f\x02\x9f\x02\xff\xff\x9d\x02\x9f\x02\x9d\x02\xff\xff\xff\xff\xff\xff\x9a\x02\xff\xff\x9d\x02\x9d\x02\xff\xff\x93\x02\x9e\x02\x9e\x02\xff\xff\xff\xff\x9e\x02\xa0\x02\xa0\x02\xff\xff\x9f\x02\xa0\x02\x9f\x02\xff\xff\x94\x02\xff\xff\x9c\x02\x9d\x02\x9f\x02\x9f\x02\xff\xff\x9b\x02\xa1\x02\xa1\x02\xff\xff\x9e\x02\xa1\x02\x9e\x02\xff\xff\xff\xff\xa0\x02\xff\xff\xa0\x02\x9e\x02\x9e\x02\xff\xff\xff\xff\x9f\x02\xa0\x02\xa0\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa1\x02\xff\xff\xa1\x02\x95\x02\xff\xff\xff\xff\xff\xff\x9e\x02\xa1\x02\xa1\x02\xff\xff\xff\xff\xa0\x02\xff\xff\xa2\x02\xa2\x02\x9d\x02\xff\xff\xa2\x02\xff\xff\xff\xff\x9d\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa1\x02\xff\xff\x96\x02\xa3\x02\xa3\x02\xff\xff\xff\xff\xa3\x02\xff\xff\xff\xff\xa2\x02\xff\xff\xa2\x02\xff\xff\x97\x02\xff\xff\xff\xff\x9f\x02\xa2\x02\xa2\x02\xa4\x02\xa4\x02\xff\xff\xff\xff\xa4\x02\xa0\x02\xa3\x02\xff\xff\xa3\x02\x9e\x02\xff\xff\xff\xff\xa5\x02\xa5\x02\xa3\x02\xa3\x02\xa5\x02\xa2\x02\xa1\x02\xff\xff\xff\xff\xff\xff\xff\xff\xa4\x02\xff\xff\xa4\x02\xff\xff\xff\xff\xff\xff\x98\x02\xff\xff\xa4\x02\xa4\x02\xa3\x02\x99\x02\xa5\x02\xff\xff\xa5\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa5\x02\xa5\x02\xff\xff\xff\xff\xa6\x02\xa6\x02\x9a\x02\xa4\x02\xa6\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa7\x02\xa7\x02\xff\xff\xff\xff\xa7\x02\xa5\x02\xff\xff\xff\xff\xff\xff\xa2\x02\xa8\x02\xa8\x02\x9b\x02\xa6\x02\xa8\x02\xa6\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x02\xa6\x02\xa7\x02\xff\xff\xa7\x02\xa9\x02\xa9\x02\x9c\x02\xff\xff\xa9\x02\xa7\x02\xa7\x02\xa8\x02\xff\xff\xa8\x02\xff\xff\xff\xff\xff\xff\xff\xff\xa6\x02\xa8\x02\xa8\x02\xff\xff\xa5\x02\xa4\x02\xff\xff\xff\xff\xff\xff\xa9\x02\xa7\x02\xa9\x02\xaa\x02\xaa\x02\xff\xff\xff\xff\xaa\x02\xa9\x02\xa9\x02\xff\xff\xa8\x02\xff\xff\xff\xff\xab\x02\xab\x02\x9d\x02\xff\xff\xab\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xaa\x02\xa9\x02\xaa\x02\xa6\x02\xff\xff\xff\xff\xff\xff\xff\xff\xaa\x02\xaa\x02\x9f\x02\xab\x02\xff\xff\xab\x02\xff\xff\xff\xff\xff\xff\xac\x02\xac\x02\xab\x02\xab\x02\xac\x02\xff\xff\xff\xff\xa7\x02\x9e\x02\xff\xff\xaa\x02\xad\x02\xad\x02\xa0\x02\xff\xff\xad\x02\xae\x02\xae\x02\xff\xff\xff\xff\xae\x02\xab\x02\xff\xff\xac\x02\xff\xff\xac\x02\xaf\x02\xaf\x02\xa1\x02\xff\xff\xaf\x02\xac\x02\xac\x02\xff\xff\xad\x02\xff\xff\xad\x02\xff\xff\xff\xff\xae\x02\xff\xff\xae\x02\xad\x02\xad\x02\xa9\x02\xff\xff\xaa\x02\xae\x02\xae\x02\xaf\x02\xac\x02\xaf\x02\xb0\x02\xb0\x02\xff\xff\xff\xff\xb0\x02\xaf\x02\xaf\x02\xff\xff\xff\xff\xad\x02\xff\xff\xb1\x02\xb1\x02\xa2\x02\xae\x02\xb1\x02\xff\xff\xff\xff\xff\xff\xab\x02\xff\xff\xff\xff\xff\xff\xb0\x02\xaf\x02\xb0\x02\xff\xff\xff\xff\xff\xff\xa3\x02\xff\xff\xb0\x02\xb0\x02\xff\xff\xb1\x02\xff\xff\xb1\x02\xb2\x02\xb2\x02\xff\xff\xac\x02\xb2\x02\xb1\x02\xb1\x02\xff\xff\xff\xff\xa4\x02\xff\xff\xff\xff\xff\xff\xb0\x02\xb3\x02\xb3\x02\xff\xff\xff\xff\xb3\x02\xff\xff\xff\xff\xa5\x02\xad\x02\xb2\x02\xb1\x02\xb2\x02\xff\xff\xff\xff\xff\xff\xae\x02\xff\xff\xb2\x02\xb2\x02\xff\xff\xff\xff\xff\xff\xff\xff\xb3\x02\xff\xff\xb3\x02\xb4\x02\xb4\x02\xaf\x02\xff\xff\xb4\x02\xb3\x02\xb3\x02\xff\xff\xff\xff\xff\xff\xb2\x02\xff\xff\xff\xff\xff\xff\xb5\x02\xb5\x02\xa6\x02\xff\xff\xb5\x02\xff\xff\xff\xff\xff\xff\xff\xff\xb4\x02\xb3\x02\xb4\x02\xa7\x02\xff\xff\xff\xff\xff\xff\xff\xff\xb4\x02\xb4\x02\xff\xff\xff\xff\xb0\x02\xa8\x02\xb5\x02\xff\xff\xb5\x02\xb6\x02\xb6\x02\xff\xff\xff\xff\xb6\x02\xb5\x02\xb5\x02\xff\xff\xff\xff\xb2\x02\xb4\x02\xff\xff\xa9\x02\xff\xff\xff\xff\xff\xff\xb7\x02\xb7\x02\xff\xff\xff\xff\xb7\x02\xff\xff\xb3\x02\xb6\x02\xb5\x02\xb6\x02\xff\xff\xff\xff\xff\xff\xb8\x02\xb8\x02\xb6\x02\xb6\x02\xb8\x02\xff\xff\xff\xff\xff\xff\xff\xff\xaa\x02\xb7\x02\xff\xff\xb7\x02\xb9\x02\xb9\x02\xff\xff\xff\xff\xb9\x02\xb7\x02\xb7\x02\xab\x02\xb6\x02\xff\xff\xb8\x02\xff\xff\xb8\x02\xff\xff\xff\xff\xff\xff\xff\xff\xb4\x02\xb8\x02\xb8\x02\xff\xff\xff\xff\xff\xff\xb9\x02\xb7\x02\xb9\x02\xba\x02\xba\x02\xff\xff\xff\xff\xba\x02\xb9\x02\xb9\x02\xff\xff\xff\xff\xff\xff\xac\x02\xb8\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xad\x02\xff\xff\xba\x02\xb9\x02\xba\x02\xae\x02\xff\xff\xff\xff\xbb\x02\xbb\x02\xba\x02\xba\x02\xbb\x02\xff\xff\xff\xff\xaf\x02\xff\xff\xff\xff\xb6\x02\xff\xff\xb7\x02\xff\xff\xff\xff\xff\xff\xbc\x02\xbc\x02\xff\xff\xff\xff\xbc\x02\xba\x02\xff\xff\xbb\x02\xff\xff\xbb\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbb\x02\xbb\x02\xb0\x02\xff\xff\xff\xff\xff\xff\xb9\x02\xb8\x02\xbc\x02\xff\xff\xbc\x02\xff\xff\xff\xff\xb1\x02\xff\xff\xff\xff\xbc\x02\xbc\x02\xff\xff\xbb\x02\xff\xff\xbb\x02\xff\xff\xff\xff\xbc\x02\xbc\x02\xbc\x02\xbc\x02\xbc\x02\xbc\x02\xbc\x02\xbc\x02\xbc\x02\xbc\x02\xff\xff\xbc\x02\xff\xff\xff\xff\xff\xff\xb2\x02\xff\xff\xbd\x02\xbd\x02\xff\xff\xff\xff\xbd\x02\xff\xff\xba\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb3\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x02\xff\xff\xbd\x02\xbe\x02\xbe\x02\xff\xff\xff\xff\xbe\x02\xbd\x02\xbd\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb4\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbd\x02\xbe\x02\xbd\x02\xbe\x02\xb5\x02\xff\xff\xff\xff\xff\xff\xff\xff\xbe\x02\xbe\x02\xff\xff\xc1\x02\xc1\x02\xff\xff\xff\xff\xc1\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xbe\x02\xff\xff\xbe\x02\xff\xff\xb6\x02\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x02\xff\xff\xc1\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x02\xc1\x02\xff\xff\xb7\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb8\x02\xbf\x02\xbf\x02\xc1\x02\xff\xff\xbf\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xb9\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbf\x02\xff\xff\xbf\x02\xff\xff\xff\xff\xff\xff\xbe\x02\xff\xff\xbf\x02\xbf\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xba\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xff\xff\xbf\x02\xff\xff\xff\xff\xff\xff\xff\xff\xc1\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbb\x02\xff\xff\xff\xff\xff\xff\xc0\x02\xc0\x02\xff\xff\xff\xff\xc0\x02\xc2\x02\xc2\x02\xff\xff\xff\xff\xc2\x02\xff\xff\xff\xff\xbc\x02\xff\xff\xff\xff\xff\xff\xff\xff\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xbf\x02\xc0\x02\xff\xff\xc0\x02\xff\xff\xff\xff\xc2\x02\xff\xff\xc2\x02\xc0\x02\xc0\x02\xff\xff\xff\xff\xff\xff\xc2\x02\xc2\x02\xff\xff\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xff\xff\xc0\x02\xff\xff\xff\xff\xff\xff\xff\xff\xc2\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xbd\x02\xff\xff\xff\xff\xff\xff\xc3\x02\xc3\x02\xff\xff\xff\xff\xc3\x02\xc4\x02\xc4\x02\xff\xff\xff\xff\xc4\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xc0\x02\xbe\x02\xc3\x02\xff\xff\xc3\x02\xff\xff\xff\xff\xc4\x02\xff\xff\xc4\x02\xc3\x02\xc3\x02\xff\xff\xc5\x02\xc5\x02\xc4\x02\xc4\x02\xc5\x02\xc6\x02\xc6\x02\xc2\x02\xff\xff\xc6\x02\xc7\x02\xc7\x02\xff\xff\xff\xff\xc7\x02\xff\xff\xc3\x02\xff\xff\xff\xff\xff\xff\xff\xff\xc4\x02\xc1\x02\xc5\x02\xff\xff\xc5\x02\xff\xff\xff\xff\xc6\x02\xff\xff\xc6\x02\xc5\x02\xc5\x02\xc7\x02\xff\xff\xc7\x02\xc6\x02\xc6\x02\xff\xff\xff\xff\xff\xff\xc7\x02\xc7\x02\xff\xff\xc8\x02\xc8\x02\xff\xff\xff\xff\xc8\x02\xff\xff\xc5\x02\xff\xff\xff\xff\xff\xff\xff\xff\xc6\x02\xff\xff\xc9\x02\xc9\x02\xff\xff\xc7\x02\xc9\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc8\x02\xff\xff\xc8\x02\xbf\x02\xff\xff\xff\xff\xc3\x02\xff\xff\xc8\x02\xc8\x02\xca\x02\xca\x02\xff\xff\xc9\x02\xca\x02\xc9\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x02\xc9\x02\xff\xff\xff\xff\xff\xff\xc6\x02\xc8\x02\xff\xff\xff\xff\xcb\x02\xcb\x02\xff\xff\xca\x02\xcb\x02\xca\x02\xff\xff\xff\xff\xc5\x02\xff\xff\xc9\x02\xca\x02\xca\x02\xc7\x02\xcc\x02\xcc\x02\xff\xff\xff\xff\xcc\x02\xff\xff\xff\xff\xff\xff\xff\xff\xcb\x02\xff\xff\xcb\x02\xff\xff\xff\xff\xff\xff\xff\xff\xca\x02\xcb\x02\xcb\x02\xff\xff\xff\xff\xff\xff\xff\xff\xcc\x02\xff\xff\xcc\x02\xff\xff\xff\xff\xff\xff\xff\xff\xc0\x02\xcc\x02\xcc\x02\xff\xff\xff\xff\xc2\x02\xcb\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x02\xff\xff\xcc\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe1\x02\xe1\x02\xff\xff\xff\xff\xe1\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x02\xff\xff\xff\xff\xff\xff\xff\xff\xcb\x02\xff\xff\xff\xff\xff\xff\xff\xff\xe1\x02\xff\xff\xe1\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe1\x02\xe1\x02\xff\xff\xe2\x02\xe2\x02\xff\xff\xff\xff\xe2\x02\xff\xff\xff\xff\xff\xff\xc3\x02\xff\xff\xff\xff\xff\xff\xff\xff\xc4\x02\xff\xff\xff\xff\xe1\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe2\x02\xff\xff\xe2\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe2\x02\xe2\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc5\x02\xff\xff\xff\xff\xff\xff\xff\xff\xc6\x02\xff\xff\xff\xff\xe2\x02\xff\xff\xc7\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xd6\x02\xff\xff\xc8\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xc9\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xca\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x02\xcd\x02\xff\xff\xff\xff\xcd\x02\xff\xff\xff\xff\xff\xff\xcb\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xcc\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xff\xff\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xe1\x02\xcd\x02\xff\xff\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xcd\x02\xff\xff\xcd\x02\xe2\x02\xcd\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xce\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd1\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xd3\x02\xff\xff\xff\xff\xff\xff\xff\xff\xcd\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xce\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd4\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd7\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd8\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xd9\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xda\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdb\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdc\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xdd\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xde\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xdf\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe0\x02\xe3\x02\xe3\x02\xff\xff\xff\xff\xe3\x02\xe4\x02\xe4\x02\xff\xff\xff\xff\xe4\x02\xe5\x02\xe5\x02\xff\xff\xff\xff\xe5\x02\xe7\x02\xe7\x02\xff\xff\xff\xff\xe7\x02\xe9\x02\xe9\x02\xff\xff\xe3\x02\xe9\x02\xe3\x02\xff\xff\xff\xff\xe4\x02\xff\xff\xe4\x02\xe3\x02\xe3\x02\xe5\x02\xff\xff\xe5\x02\xe4\x02\xe4\x02\xe7\x02\xff\xff\xe7\x02\xe5\x02\xe5\x02\xe9\x02\xff\xff\xe9\x02\xe7\x02\xe7\x02\xff\xff\xff\xff\xe3\x02\xe9\x02\xe9\x02\xff\xff\xff\xff\xe4\x02\xff\xff\xff\xff\xff\xff\xff\xff\xe5\x02\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x02\xff\xff\xff\xff\xff\xff\xff\xff\xe9\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xee\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe4\x02\xe6\x02\xe6\x02\xff\xff\xff\xff\xe6\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x02\xff\xff\xe6\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x02\xe6\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe3\x02\xff\xff\xff\xff\xff\xff\xff\xff\xe4\x02\xff\xff\xff\xff\xff\xff\xff\xff\xe5\x02\xff\xff\xff\xff\xff\xff\xff\xff\xe7\x02\xff\xff\xff\xff\xff\xff\xff\xff\xe9\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xf0\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe6\x02\xe8\x02\xe8\x02\xff\xff\xff\xff\xe8\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8\x02\xff\xff\xe8\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8\x02\xe8\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe6\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xf1\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xe8\x02\xea\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xea\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xea\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xe8\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xea\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xec\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xef\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xf2\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfa\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfb\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfc\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfd\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xfe\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\xff\x02\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x01\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\x02\x03\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
   /* lex_base_code */"",
   /* lex_backtrk_code */"",
   /* lex_default_code */"",
@@ -20645,13 +20186,12 @@ function token(lexbuf) {
   while(true) {
     var __ocaml_lex_state = ___ocaml_lex_state;
     var __ocaml_lex_state$1 = Lexing.engine(__ocaml_lex_tables, __ocaml_lex_state, lexbuf$1);
-    if (__ocaml_lex_state$1 > 144 || __ocaml_lex_state$1 < 0) {
+    if (__ocaml_lex_state$1 > 149 || __ocaml_lex_state$1 < 0) {
       Curry._1(lexbuf$1[/* refill_buff */0], lexbuf$1);
       ___ocaml_lex_state = __ocaml_lex_state$1;
       continue ;
       
-    }
-    else {
+    } else {
       switch (__ocaml_lex_state$1) {
         case 0 : 
             return /* LPAR */2;
@@ -20668,11 +20208,11 @@ function token(lexbuf) {
             return /* FLOAT */Block.__(2, [s$2]);
         case 5 : 
             var s$3 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_curr_pos */5]);
-            return /* TEXT */Block.__(3, [text(s$3)]);
+            return /* STRING */Block.__(3, [string(s$3)]);
         case 6 : 
-            return error(lexbuf$1, "unclosed text literal");
+            return error(lexbuf$1, "unclosed string literal");
         case 7 : 
-            return error(lexbuf$1, "illegal control character in text literal");
+            return error(lexbuf$1, "illegal control character in string literal");
         case 8 : 
             return error_nest(Lexing.lexeme_end_p(lexbuf$1), lexbuf$1, "illegal escape");
         case 9 : 
@@ -20935,97 +20475,97 @@ function token(lexbuf) {
             return /* BINARY */Block.__(12, [floatop(t$37, Operators.f32_copysign, Operators.f64_copysign)]);
         case 72 : 
             var t$38 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* TEST */Block.__(15, [intop(t$38, Operators.i32_eqz, Operators.i64_eqz)]);
+            return /* TEST */Block.__(13, [intop(t$38, Operators.i32_eqz, Operators.i64_eqz)]);
         case 73 : 
             var t$39 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [intop(t$39, Operators.i32_eq, Operators.i64_eq)]);
+            return /* COMPARE */Block.__(14, [intop(t$39, Operators.i32_eq, Operators.i64_eq)]);
         case 74 : 
             var t$40 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [intop(t$40, Operators.i32_ne, Operators.i64_ne)]);
+            return /* COMPARE */Block.__(14, [intop(t$40, Operators.i32_ne, Operators.i64_ne)]);
         case 75 : 
             var t$41 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [intop(t$41, Operators.i32_lt_s, Operators.i64_lt_s)]);
+            return /* COMPARE */Block.__(14, [intop(t$41, Operators.i32_lt_s, Operators.i64_lt_s)]);
         case 76 : 
             var t$42 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [intop(t$42, Operators.i32_lt_u, Operators.i64_lt_u)]);
+            return /* COMPARE */Block.__(14, [intop(t$42, Operators.i32_lt_u, Operators.i64_lt_u)]);
         case 77 : 
             var t$43 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [intop(t$43, Operators.i32_le_s, Operators.i64_le_s)]);
+            return /* COMPARE */Block.__(14, [intop(t$43, Operators.i32_le_s, Operators.i64_le_s)]);
         case 78 : 
             var t$44 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [intop(t$44, Operators.i32_le_u, Operators.i64_le_u)]);
+            return /* COMPARE */Block.__(14, [intop(t$44, Operators.i32_le_u, Operators.i64_le_u)]);
         case 79 : 
             var t$45 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [intop(t$45, Operators.i32_gt_s, Operators.i64_gt_s)]);
+            return /* COMPARE */Block.__(14, [intop(t$45, Operators.i32_gt_s, Operators.i64_gt_s)]);
         case 80 : 
             var t$46 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [intop(t$46, Operators.i32_gt_u, Operators.i64_gt_u)]);
+            return /* COMPARE */Block.__(14, [intop(t$46, Operators.i32_gt_u, Operators.i64_gt_u)]);
         case 81 : 
             var t$47 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [intop(t$47, Operators.i32_ge_s, Operators.i64_ge_s)]);
+            return /* COMPARE */Block.__(14, [intop(t$47, Operators.i32_ge_s, Operators.i64_ge_s)]);
         case 82 : 
             var t$48 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [intop(t$48, Operators.i32_ge_u, Operators.i64_ge_u)]);
+            return /* COMPARE */Block.__(14, [intop(t$48, Operators.i32_ge_u, Operators.i64_ge_u)]);
         case 83 : 
             var t$49 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [floatop(t$49, Operators.f32_eq, Operators.f64_eq)]);
+            return /* COMPARE */Block.__(14, [floatop(t$49, Operators.f32_eq, Operators.f64_eq)]);
         case 84 : 
             var t$50 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [floatop(t$50, Operators.f32_ne, Operators.f64_ne)]);
+            return /* COMPARE */Block.__(14, [floatop(t$50, Operators.f32_ne, Operators.f64_ne)]);
         case 85 : 
             var t$51 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [floatop(t$51, Operators.f32_lt, Operators.f64_lt)]);
+            return /* COMPARE */Block.__(14, [floatop(t$51, Operators.f32_lt, Operators.f64_lt)]);
         case 86 : 
             var t$52 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [floatop(t$52, Operators.f32_le, Operators.f64_le)]);
+            return /* COMPARE */Block.__(14, [floatop(t$52, Operators.f32_le, Operators.f64_le)]);
         case 87 : 
             var t$53 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [floatop(t$53, Operators.f32_gt, Operators.f64_gt)]);
+            return /* COMPARE */Block.__(14, [floatop(t$53, Operators.f32_gt, Operators.f64_gt)]);
         case 88 : 
             var t$54 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* COMPARE */Block.__(13, [floatop(t$54, Operators.f32_ge, Operators.f64_ge)]);
+            return /* COMPARE */Block.__(14, [floatop(t$54, Operators.f32_ge, Operators.f64_ge)]);
         case 89 : 
-            return /* CONVERT */Block.__(14, [Operators.i32_wrap_i64]);
+            return /* CONVERT */Block.__(15, [Operators.i32_wrap_i64]);
         case 90 : 
-            return /* CONVERT */Block.__(14, [Operators.i64_extend_s_i32]);
+            return /* CONVERT */Block.__(15, [Operators.i64_extend_s_i32]);
         case 91 : 
-            return /* CONVERT */Block.__(14, [Operators.i64_extend_u_i32]);
+            return /* CONVERT */Block.__(15, [Operators.i64_extend_u_i32]);
         case 92 : 
-            return /* CONVERT */Block.__(14, [Operators.f32_demote_f64]);
+            return /* CONVERT */Block.__(15, [Operators.f32_demote_f64]);
         case 93 : 
-            return /* CONVERT */Block.__(14, [Operators.f64_promote_f32]);
+            return /* CONVERT */Block.__(15, [Operators.f64_promote_f32]);
         case 94 : 
             var t$55 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* CONVERT */Block.__(14, [intop(t$55, Operators.i32_trunc_s_f32, Operators.i64_trunc_s_f32)]);
+            return /* CONVERT */Block.__(15, [intop(t$55, Operators.i32_trunc_s_f32, Operators.i64_trunc_s_f32)]);
         case 95 : 
             var t$56 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* CONVERT */Block.__(14, [intop(t$56, Operators.i32_trunc_u_f32, Operators.i64_trunc_u_f32)]);
+            return /* CONVERT */Block.__(15, [intop(t$56, Operators.i32_trunc_u_f32, Operators.i64_trunc_u_f32)]);
         case 96 : 
             var t$57 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* CONVERT */Block.__(14, [intop(t$57, Operators.i32_trunc_s_f64, Operators.i64_trunc_s_f64)]);
+            return /* CONVERT */Block.__(15, [intop(t$57, Operators.i32_trunc_s_f64, Operators.i64_trunc_s_f64)]);
         case 97 : 
             var t$58 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* CONVERT */Block.__(14, [intop(t$58, Operators.i32_trunc_u_f64, Operators.i64_trunc_u_f64)]);
+            return /* CONVERT */Block.__(15, [intop(t$58, Operators.i32_trunc_u_f64, Operators.i64_trunc_u_f64)]);
         case 98 : 
             var t$59 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* CONVERT */Block.__(14, [floatop(t$59, Operators.f32_convert_s_i32, Operators.f64_convert_s_i32)]);
+            return /* CONVERT */Block.__(15, [floatop(t$59, Operators.f32_convert_s_i32, Operators.f64_convert_s_i32)]);
         case 99 : 
             var t$60 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* CONVERT */Block.__(14, [floatop(t$60, Operators.f32_convert_u_i32, Operators.f64_convert_u_i32)]);
+            return /* CONVERT */Block.__(15, [floatop(t$60, Operators.f32_convert_u_i32, Operators.f64_convert_u_i32)]);
         case 100 : 
             var t$61 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* CONVERT */Block.__(14, [floatop(t$61, Operators.f32_convert_s_i64, Operators.f64_convert_s_i64)]);
+            return /* CONVERT */Block.__(15, [floatop(t$61, Operators.f32_convert_s_i64, Operators.f64_convert_s_i64)]);
         case 101 : 
             var t$62 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_start_pos */4] + 3 | 0);
-            return /* CONVERT */Block.__(14, [floatop(t$62, Operators.f32_convert_u_i64, Operators.f64_convert_u_i64)]);
+            return /* CONVERT */Block.__(15, [floatop(t$62, Operators.f32_convert_u_i64, Operators.f64_convert_u_i64)]);
         case 102 : 
-            return /* CONVERT */Block.__(14, [Operators.f32_reinterpret_i32]);
+            return /* CONVERT */Block.__(15, [Operators.f32_reinterpret_i32]);
         case 103 : 
-            return /* CONVERT */Block.__(14, [Operators.f64_reinterpret_i64]);
+            return /* CONVERT */Block.__(15, [Operators.f64_reinterpret_i64]);
         case 104 : 
-            return /* CONVERT */Block.__(14, [Operators.i32_reinterpret_f32]);
+            return /* CONVERT */Block.__(15, [Operators.i32_reinterpret_f32]);
         case 105 : 
-            return /* CONVERT */Block.__(14, [Operators.i64_reinterpret_f64]);
+            return /* CONVERT */Block.__(15, [Operators.i64_reinterpret_f64]);
         case 106 : 
             return /* CURRENT_MEMORY */25;
         case 107 : 
@@ -21045,66 +20585,75 @@ function token(lexbuf) {
         case 114 : 
             return /* GLOBAL */33;
         case 115 : 
-            return /* MODULE */34;
+            return /* TABLE */34;
         case 116 : 
-            return /* TABLE */35;
+            return /* MEMORY */36;
         case 117 : 
-            return /* MEMORY */37;
+            return /* ELEM */35;
         case 118 : 
-            return /* ELEM */36;
+            return /* DATA */37;
         case 119 : 
-            return /* DATA */38;
+            return /* OFFSET */38;
         case 120 : 
-            return /* OFFSET */39;
+            return /* IMPORT */39;
         case 121 : 
-            return /* IMPORT */40;
+            return /* EXPORT */40;
         case 122 : 
-            return /* EXPORT */41;
+            return /* MODULE */41;
         case 123 : 
-            return /* SCRIPT */42;
+            return /* BIN */42;
         case 124 : 
-            return /* REGISTER */43;
+            return /* QUOTE */43;
         case 125 : 
-            return /* INVOKE */44;
+            return /* SCRIPT */44;
         case 126 : 
-            return /* GET */45;
+            return /* REGISTER */45;
         case 127 : 
-            return /* ASSERT_MALFORMED */46;
+            return /* INVOKE */46;
         case 128 : 
-            return /* ASSERT_INVALID */47;
+            return /* GET */47;
         case 129 : 
-            return /* ASSERT_SOFT_INVALID */48;
+            return /* ASSERT_MALFORMED */48;
         case 130 : 
-            return /* ASSERT_UNLINKABLE */49;
+            return /* ASSERT_INVALID */49;
         case 131 : 
-            return /* ASSERT_RETURN */50;
+            return /* ASSERT_UNLINKABLE */51;
         case 132 : 
-            return /* ASSERT_RETURN_NAN */51;
+            return /* ASSERT_RETURN */52;
         case 133 : 
-            return /* ASSERT_TRAP */52;
+            return /* ASSERT_RETURN_CANONICAL_NAN */53;
         case 134 : 
-            return /* ASSERT_EXHAUSTION */53;
+            return /* ASSERT_RETURN_ARITHMETIC_NAN */54;
         case 135 : 
-            return /* INPUT */54;
+            return /* ASSERT_TRAP */55;
         case 136 : 
-            return /* OUTPUT */55;
+            return /* ASSERT_EXHAUSTION */56;
         case 137 : 
+            return /* INPUT */57;
+        case 138 : 
+            return /* OUTPUT */58;
+        case 139 : 
             var s$7 = Lexing.sub_lexeme(lexbuf$1, lexbuf$1[/* lex_start_pos */4], lexbuf$1[/* lex_curr_pos */5]);
             return /* VAR */Block.__(4, [s$7]);
-        case 140 : 
-            __ocaml_lex_comment_rec(Lexing.lexeme_start_p(lexbuf$1), lexbuf$1, 684);
-            return token(lexbuf$1);
-        case 141 : 
+        case 143 : 
+            __ocaml_lex_comment_rec(Lexing.lexeme_start_p(lexbuf$1), lexbuf$1, 746);
             return token(lexbuf$1);
-        case 139 : 
         case 142 : 
+        case 144 : 
+            return token(lexbuf$1);
+        case 141 : 
+        case 145 : 
             Lexing.new_line(lexbuf$1);
             return token(lexbuf$1);
-        case 138 : 
-        case 143 : 
-            return /* EOF */56;
-        case 144 : 
+        case 140 : 
+        case 146 : 
+            return /* EOF */59;
+        case 147 : 
             return error(lexbuf$1, "unknown operator");
+        case 148 : 
+            return error(lexbuf$1, "malformed operator");
+        case 149 : 
+            return error(lexbuf$1, "malformed UTF-8 encoding");
         
       }
     }
@@ -21115,30 +20664,31 @@ function __ocaml_lex_comment_rec(start, lexbuf, ___ocaml_lex_state) {
   while(true) {
     var __ocaml_lex_state = ___ocaml_lex_state;
     var __ocaml_lex_state$1 = Lexing.engine(__ocaml_lex_tables, __ocaml_lex_state, lexbuf);
-    if (__ocaml_lex_state$1 > 4 || __ocaml_lex_state$1 < 0) {
+    if (__ocaml_lex_state$1 > 5 || __ocaml_lex_state$1 < 0) {
       Curry._1(lexbuf[/* refill_buff */0], lexbuf);
       ___ocaml_lex_state = __ocaml_lex_state$1;
       continue ;
       
-    }
-    else {
+    } else {
       switch (__ocaml_lex_state$1) {
         case 0 : 
             return /* () */0;
         case 1 : 
-            __ocaml_lex_comment_rec(Lexing.lexeme_start_p(lexbuf), lexbuf, 684);
-            ___ocaml_lex_state = 684;
+            __ocaml_lex_comment_rec(Lexing.lexeme_start_p(lexbuf), lexbuf, 746);
+            ___ocaml_lex_state = 746;
             continue ;
             case 2 : 
             Lexing.new_line(lexbuf);
-            ___ocaml_lex_state = 684;
+            ___ocaml_lex_state = 746;
             continue ;
             case 3 : 
             return error_nest(start, lexbuf, "unclosed comment");
         case 4 : 
-            ___ocaml_lex_state = 684;
+            ___ocaml_lex_state = 746;
             continue ;
-            
+            case 5 : 
+            return error(lexbuf, "malformed UTF-8 encoding");
+        
       }
     }
   };
@@ -21157,14 +20707,15 @@ exports.token       = token;
 //////// start of lexing.js ////////
 'use strict';
 
-var Sys                     = require("./sys");
-var Bytes                   = require("./bytes");
-var Curry                   = require("./curry");
-var Caml_bytes              = require("./caml_bytes");
-var Caml_lexer              = require("./caml_lexer");
-var Pervasives              = require("./pervasives");
-var Caml_string             = require("./caml_string");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Sys                     = require("./sys.js");
+var Bytes                   = require("./bytes.js");
+var Curry                   = require("./curry.js");
+var Caml_array              = require("./caml_array.js");
+var Caml_bytes              = require("./caml_bytes.js");
+var Caml_lexer              = require("./caml_lexer.js");
+var Pervasives              = require("./pervasives.js");
+var Caml_string             = require("./caml_string.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function engine(tbl, state, buf) {
   var result = Caml_lexer.caml_lex_engine(tbl, state, buf);
@@ -21215,8 +20766,7 @@ function from_function(f) {
             if ((lexbuf[/* lex_buffer_len */2] + n | 0) > lexbuf[/* lex_buffer */1].length) {
               if (((lexbuf[/* lex_buffer_len */2] - lexbuf[/* lex_start_pos */4] | 0) + n | 0) <= lexbuf[/* lex_buffer */1].length) {
                 Bytes.blit(lexbuf[/* lex_buffer */1], lexbuf[/* lex_start_pos */4], lexbuf[/* lex_buffer */1], 0, lexbuf[/* lex_buffer_len */2] - lexbuf[/* lex_start_pos */4] | 0);
-              }
-              else {
+              } else {
                 var newlen = Pervasives.min((lexbuf[/* lex_buffer */1].length << 1), Sys.max_string_length);
                 if (((lexbuf[/* lex_buffer_len */2] - lexbuf[/* lex_start_pos */4] | 0) + n | 0) > newlen) {
                   throw [
@@ -21236,9 +20786,9 @@ function from_function(f) {
               lexbuf[/* lex_buffer_len */2] = lexbuf[/* lex_buffer_len */2] - s | 0;
               var t = lexbuf[/* lex_mem */9];
               for(var i = 0 ,i_finish = t.length - 1 | 0; i <= i_finish; ++i){
-                var v = t[i];
+                var v = Caml_array.caml_array_get(t, i);
                 if (v >= 0) {
-                  t[i] = v - s | 0;
+                  Caml_array.caml_array_set(t, i, v - s | 0);
                 }
                 
               }
@@ -21301,8 +20851,7 @@ function sub_lexeme_opt(lexbuf, i1, i2) {
   if (i1 >= 0) {
     var len = i2 - i1 | 0;
     return /* Some */[Bytes.sub_string(lexbuf[/* lex_buffer */1], i1, len)];
-  }
-  else {
+  } else {
     return /* None */0;
   }
 }
@@ -21314,8 +20863,7 @@ function sub_lexeme_char(lexbuf, i) {
 function sub_lexeme_char_opt(lexbuf, i) {
   if (i >= 0) {
     return /* Some */[Caml_bytes.get(lexbuf[/* lex_buffer */1], i)];
-  }
-  else {
+  } else {
     return /* None */0;
   }
 }
@@ -21399,19 +20947,23 @@ exports.new_engine          = new_engine;
   _registry['lib'] = function() {
     let exports = {};
 //////// start of lib.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var $$Array                 = require("bs-platform/lib/js/array");
-var Curry                   = require("bs-platform/lib/js/curry");
-var Int32                   = require("bs-platform/lib/js/int32");
-var $$String                = require("bs-platform/lib/js/string");
-var Bigarray                = require("bs-platform/lib/js/bigarray");
-var Caml_obj                = require("bs-platform/lib/js/caml_obj");
-var Caml_array              = require("bs-platform/lib/js/caml_array");
-var Caml_int64              = require("bs-platform/lib/js/caml_int64");
-var Pervasives              = require("bs-platform/lib/js/pervasives");
-var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions");
+var List                    = require("bs-platform/lib/js/list.js");
+var $$Array                 = require("bs-platform/lib/js/array.js");
+var Curry                   = require("bs-platform/lib/js/curry.js");
+var Int32                   = require("bs-platform/lib/js/int32.js");
+var Buffer                  = require("bs-platform/lib/js/buffer.js");
+var $$String                = require("bs-platform/lib/js/string.js");
+var Bigarray                = require("bs-platform/lib/js/bigarray.js");
+var Caml_obj                = require("bs-platform/lib/js/caml_obj.js");
+var Caml_array              = require("bs-platform/lib/js/caml_array.js");
+var Caml_int64              = require("bs-platform/lib/js/caml_int64.js");
+var Pervasives              = require("bs-platform/lib/js/pervasives.js");
+var Caml_string             = require("bs-platform/lib/js/caml_string.js");
+var Caml_missing_polyfill   = require("bs-platform/lib/js/caml_missing_polyfill.js");
+var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions.js");
 
 function repeat(_n, f, x) {
   while(true) {
@@ -21421,8 +20973,7 @@ function repeat(_n, f, x) {
       _n = n - 1 | 0;
       continue ;
       
-    }
-    else {
+    } else {
       return /* () */0;
     }
   };
@@ -21430,14 +20981,116 @@ function repeat(_n, f, x) {
 
 var Fun = /* module */[/* repeat */repeat];
 
+function log2(n) {
+  if (n <= 0) {
+    Pervasives.failwith("log2");
+  }
+  var _acc = 0;
+  var _n = n;
+  while(true) {
+    var n$1 = _n;
+    var acc = _acc;
+    if (n$1 === 1) {
+      return acc;
+    } else {
+      _n = (n$1 >>> 1);
+      _acc = acc + 1 | 0;
+      continue ;
+      
+    }
+  };
+}
+
+function is_power_of_two(n) {
+  if (n < 0) {
+    Pervasives.failwith("is_power_of_two");
+  }
+  if (n !== 0) {
+    return +((n & (n - 1 | 0)) === 0);
+  } else {
+    return /* false */0;
+  }
+}
+
+var Int = /* module */[
+  /* log2 */log2,
+  /* is_power_of_two */is_power_of_two
+];
+
+function implode(cs) {
+  var buf = Buffer.create(80);
+  List.iter(function (param) {
+        return Buffer.add_char(buf, param);
+      }, cs);
+  return Buffer.contents(buf);
+}
+
+function explode(s) {
+  var cs = /* [] */0;
+  for(var i = s.length - 1 | 0; i >= 0; --i){
+    cs = /* :: */[
+      Caml_string.get(s, i),
+      cs
+    ];
+  }
+  return cs;
+}
+
+function split(s, c) {
+  var len = s.length;
+  var loop = function (i) {
+    if (i > len) {
+      return /* [] */0;
+    } else {
+      var j;
+      try {
+        j = $$String.index_from(s, i, c);
+      }
+      catch (exn){
+        if (exn === Caml_builtin_exceptions.not_found) {
+          j = len;
+        } else {
+          throw exn;
+        }
+      }
+      return /* :: */[
+              $$String.sub(s, i, j - i | 0),
+              loop(j + 1 | 0)
+            ];
+    }
+  };
+  return loop(0);
+}
+
+function breakup(s, n) {
+  var loop = function (i) {
+    var len = Pervasives.min(n, s.length - i | 0);
+    if (len) {
+      return /* :: */[
+              $$String.sub(s, i, len),
+              loop(i + len | 0)
+            ];
+    } else {
+      return /* [] */0;
+    }
+  };
+  return loop(0);
+}
+
+var $$String$1 = /* module */[
+  /* implode */implode,
+  /* explode */explode,
+  /* split */split,
+  /* breakup */breakup
+];
+
 function make(n, x) {
   if (n) {
     return /* :: */[
             x,
             make(n - 1 | 0, x)
           ];
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -21445,8 +21098,7 @@ function make(n, x) {
 function table$prime(i, n, f) {
   if (i === n) {
     return /* [] */0;
-  }
-  else {
+  } else {
     return /* :: */[
             Curry._1(f, i),
             table$prime(i + 1 | 0, n, f)
@@ -21466,16 +21118,13 @@ function take(n, xs) {
                 xs[0],
                 take(n - 1 | 0, xs[1])
               ];
-      }
-      else {
+      } else {
         return Pervasives.failwith("take");
       }
-    }
-    else {
+    } else {
       return Pervasives.failwith("take");
     }
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -21491,16 +21140,13 @@ function drop(_n, _xs) {
           _n = n - 1 | 0;
           continue ;
           
-        }
-        else {
+        } else {
           return Pervasives.failwith("drop");
         }
-      }
-      else {
+      } else {
         return Pervasives.failwith("drop");
       }
-    }
-    else {
+    } else {
       return xs;
     }
   };
@@ -21515,12 +21161,10 @@ function last(_param) {
         _param = xs;
         continue ;
         
-      }
-      else {
+      } else {
         return param[0];
       }
-    }
-    else {
+    } else {
       return Pervasives.failwith("last");
     }
   };
@@ -21539,15 +21183,13 @@ function split_last(param) {
               ],
               match[1]
             ];
-    }
-    else {
+    } else {
       return /* tuple */[
               /* [] */0,
               x
             ];
     }
-  }
-  else {
+  } else {
     return Pervasives.failwith("split_last");
   }
 }
@@ -21562,15 +21204,13 @@ function index_of(x, xs) {
     if (xs$1) {
       if (Caml_obj.caml_equal(x$1, xs$1[0])) {
         return /* Some */[i];
-      }
-      else {
+      } else {
         _i = i + 1 | 0;
         _xs = xs$1[1];
         continue ;
         
       }
-    }
-    else {
+    } else {
       return /* None */0;
     }
   };
@@ -21588,12 +21228,10 @@ function length(xs) {
         _xs = xs$1[1];
         continue ;
         
-      }
-      else {
+      } else {
         return Pervasives.failwith("length");
       }
-    }
-    else {
+    } else {
       return n;
     }
   };
@@ -21610,19 +21248,15 @@ function nth(_xs, _n) {
           _xs = xs[1];
           continue ;
           
-        }
-        else {
+        } else {
           return Pervasives.failwith("nth");
         }
-      }
-      else {
+      } else {
         return Pervasives.failwith("nth");
       }
-    }
-    else if (xs) {
+    } else if (xs) {
       return xs[0];
-    }
-    else {
+    } else {
       return Pervasives.failwith("nth");
     }
   };
@@ -21636,16 +21270,13 @@ function take$1(n, xs) {
                 xs[0],
                 take$1(n - 1 | 0, xs[1])
               ];
-      }
-      else {
+      } else {
         return Pervasives.failwith("take");
       }
-    }
-    else {
+    } else {
       return Pervasives.failwith("take");
     }
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -21661,16 +21292,13 @@ function drop$1(_n, _xs) {
           _n = n - 1 | 0;
           continue ;
           
-        }
-        else {
+        } else {
           return Pervasives.failwith("drop");
         }
-      }
-      else {
+      } else {
         return Pervasives.failwith("drop");
       }
-    }
-    else {
+    } else {
       return xs;
     }
   };
@@ -21693,19 +21321,17 @@ function length$1(a) {
 function index_of_int32(i) {
   if (i < 0 || Caml_int64.gt(Caml_int64.of_int32(i), Caml_int64.of_int32(Pervasives.max_int))) {
     return -1;
-  }
-  else {
+  } else {
     return i;
   }
 }
 
 function get(a, i) {
-  return a[index_of_int32(i)];
+  return Caml_array.caml_array_get(a, index_of_int32(i));
 }
 
 function set(a, i, x) {
-  a[index_of_int32(i)] = x;
-  return /* () */0;
+  return Caml_array.caml_array_set(a, index_of_int32(i), x);
 }
 
 function blit(a1, i1, a2, i2, n) {
@@ -21726,34 +21352,25 @@ function create(kind, layout, n) {
 }
 
 function dim() {
-  return Caml_int64.of_int32(function () {
-                throw "caml_ba_dim_1 not implemented by bucklescript yet\n";
-              }());
+  return Caml_int64.of_int32(Caml_missing_polyfill.not_implemented("caml_ba_dim_1 not implemented by bucklescript yet\n"));
 }
 
 function get$1(_, _$1) {
-  return function () {
-            throw "caml_ba_get_1 not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_get_1 not implemented by bucklescript yet\n");
 }
 
 function set$1(_, _$1, _$2) {
-  return function () {
-            throw "caml_ba_set_1 not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_set_1 not implemented by bucklescript yet\n");
 }
 
 function sub(_, _$1, _$2) {
-  return function () {
-            throw "caml_ba_sub not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ba_sub not implemented by bucklescript yet\n");
 }
 
 function get$2(o, x) {
   if (o) {
     return o[0];
-  }
-  else {
+  } else {
     return x;
   }
 }
@@ -21761,8 +21378,7 @@ function get$2(o, x) {
 function map(f, param) {
   if (param) {
     return /* Some */[Curry._1(f, param[0])];
-  }
-  else {
+  } else {
     return /* None */0;
   }
 }
@@ -21770,8 +21386,7 @@ function map(f, param) {
 function app(f, param) {
   if (param) {
     return Curry._1(f, param[0]);
-  }
-  else {
+  } else {
     return /* () */0;
   }
 }
@@ -21782,63 +21397,7 @@ var Option = /* module */[
   /* app */app
 ];
 
-function log2(n) {
-  if (n <= 0) {
-    Pervasives.failwith("log2");
-  }
-  var _acc = 0;
-  var _n = n;
-  while(true) {
-    var n$1 = _n;
-    var acc = _acc;
-    if (n$1 === 1) {
-      return acc;
-    }
-    else {
-      _n = (n$1 >>> 1);
-      _acc = acc + 1 | 0;
-      continue ;
-      
-    }
-  };
-}
-
-function is_power_of_two(n) {
-  if (n < 0) {
-    Pervasives.failwith("is_power_of_two");
-  }
-  if (n !== 0) {
-    return +((n & (n - 1 | 0)) === 0);
-  }
-  else {
-    return /* false */0;
-  }
-}
-
-var Int = /* module */[
-  /* log2 */log2,
-  /* is_power_of_two */is_power_of_two
-];
-
-function breakup(s, n) {
-  var loop = function (i) {
-    var len = Pervasives.min(n, s.length - i | 0);
-    if (len) {
-      return /* :: */[
-              $$String.sub(s, i, len),
-              loop(i + len | 0)
-            ];
-    }
-    else {
-      return /* [] */0;
-    }
-  };
-  return loop(0);
-}
-
-var $$String$1 = /* module */[/* breakup */breakup];
-
-var List = [
+var List$1 = [
   make,
   table,
   take,
@@ -21872,7 +21431,7 @@ var Bigarray$1 = [[
   ]];
 
 exports.Fun      = Fun;
-exports.List     = List;
+exports.List     = List$1;
 exports.List32   = List32;
 exports.Array32  = Array32;
 exports.Bigarray = Bigarray$1;
@@ -21890,10 +21449,10 @@ exports.$$String = $$String$1;
 //////// start of list.js ////////
 'use strict';
 
-var Curry                   = require("./curry");
-var Caml_obj                = require("./caml_obj");
-var Pervasives              = require("./pervasives");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Curry                   = require("./curry.js");
+var Caml_obj                = require("./caml_obj.js");
+var Pervasives              = require("./pervasives.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function length(l) {
   var _len = 0;
@@ -21906,8 +21465,7 @@ function length(l) {
       _len = len + 1 | 0;
       continue ;
       
-    }
-    else {
+    } else {
       return len;
     }
   };
@@ -21916,8 +21474,7 @@ function length(l) {
 function hd(param) {
   if (param) {
     return param[0];
-  }
-  else {
+  } else {
     throw [
           Caml_builtin_exceptions.failure,
           "hd"
@@ -21928,8 +21485,7 @@ function hd(param) {
 function tl(param) {
   if (param) {
     return param[1];
-  }
-  else {
+  } else {
     throw [
           Caml_builtin_exceptions.failure,
           "tl"
@@ -21943,8 +21499,7 @@ function nth(l, n) {
           Caml_builtin_exceptions.invalid_argument,
           "List.nth"
         ];
-  }
-  else {
+  } else {
     var _l = l;
     var _n = n;
     while(true) {
@@ -21956,12 +21511,10 @@ function nth(l, n) {
           _l = l$1[1];
           continue ;
           
-        }
-        else {
+        } else {
           return l$1[0];
         }
-      }
-      else {
+      } else {
         throw [
               Caml_builtin_exceptions.failure,
               "nth"
@@ -21983,8 +21536,7 @@ function rev_append(_l1, _l2) {
       _l1 = l1[1];
       continue ;
       
-    }
-    else {
+    } else {
       return l2;
     }
   };
@@ -21997,8 +21549,7 @@ function rev(l) {
 function flatten(param) {
   if (param) {
     return Pervasives.$at(param[0], flatten(param[1]));
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -22010,8 +21561,7 @@ function map(f, param) {
             r,
             map(f, param[1])
           ];
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -22023,8 +21573,7 @@ function mapi(i, f, param) {
             r,
             mapi(i + 1 | 0, f, param[1])
           ];
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -22047,8 +21596,7 @@ function rev_map(f, l) {
       ];
       continue ;
       
-    }
-    else {
+    } else {
       return accu;
     }
   };
@@ -22062,8 +21610,7 @@ function iter(f, _param) {
       _param = param[1];
       continue ;
       
-    }
-    else {
+    } else {
       return /* () */0;
     }
   };
@@ -22082,8 +21629,7 @@ function iteri(f, l) {
       _i = i + 1 | 0;
       continue ;
       
-    }
-    else {
+    } else {
       return /* () */0;
     }
   };
@@ -22098,8 +21644,7 @@ function fold_left(f, _accu, _l) {
       _accu = Curry._2(f, accu, l[0]);
       continue ;
       
-    }
-    else {
+    } else {
       return accu;
     }
   };
@@ -22108,8 +21653,7 @@ function fold_left(f, _accu, _l) {
 function fold_right(f, l, accu) {
   if (l) {
     return Curry._2(f, l[0], fold_right(f, l[1], accu));
-  }
-  else {
+  } else {
     return accu;
   }
 }
@@ -22122,21 +21666,18 @@ function map2(f, l1, l2) {
               r,
               map2(f, l1[1], l2[1])
             ];
-    }
-    else {
+    } else {
       throw [
             Caml_builtin_exceptions.invalid_argument,
             "List.map2"
           ];
     }
-  }
-  else if (l2) {
+  } else if (l2) {
     throw [
           Caml_builtin_exceptions.invalid_argument,
           "List.map2"
         ];
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -22159,21 +21700,18 @@ function rev_map2(f, l1, l2) {
         ];
         continue ;
         
-      }
-      else {
+      } else {
         throw [
               Caml_builtin_exceptions.invalid_argument,
               "List.rev_map2"
             ];
       }
-    }
-    else if (l2$1) {
+    } else if (l2$1) {
       throw [
             Caml_builtin_exceptions.invalid_argument,
             "List.rev_map2"
           ];
-    }
-    else {
+    } else {
       return accu;
     }
   };
@@ -22190,21 +21728,18 @@ function iter2(f, _l1, _l2) {
         _l1 = l1[1];
         continue ;
         
-      }
-      else {
+      } else {
         throw [
               Caml_builtin_exceptions.invalid_argument,
               "List.iter2"
             ];
       }
-    }
-    else if (l2) {
+    } else if (l2) {
       throw [
             Caml_builtin_exceptions.invalid_argument,
             "List.iter2"
           ];
-    }
-    else {
+    } else {
       return /* () */0;
     }
   };
@@ -22222,21 +21757,18 @@ function fold_left2(f, _accu, _l1, _l2) {
         _accu = Curry._3(f, accu, l1[0], l2[0]);
         continue ;
         
-      }
-      else {
+      } else {
         throw [
               Caml_builtin_exceptions.invalid_argument,
               "List.fold_left2"
             ];
       }
-    }
-    else if (l2) {
+    } else if (l2) {
       throw [
             Caml_builtin_exceptions.invalid_argument,
             "List.fold_left2"
           ];
-    }
-    else {
+    } else {
       return accu;
     }
   };
@@ -22246,21 +21778,18 @@ function fold_right2(f, l1, l2, accu) {
   if (l1) {
     if (l2) {
       return Curry._3(f, l1[0], l2[0], fold_right2(f, l1[1], l2[1], accu));
-    }
-    else {
+    } else {
       throw [
             Caml_builtin_exceptions.invalid_argument,
             "List.fold_right2"
           ];
     }
-  }
-  else if (l2) {
+  } else if (l2) {
     throw [
           Caml_builtin_exceptions.invalid_argument,
           "List.fold_right2"
         ];
-  }
-  else {
+  } else {
     return accu;
   }
 }
@@ -22273,12 +21802,10 @@ function for_all(p, _param) {
         _param = param[1];
         continue ;
         
-      }
-      else {
+      } else {
         return /* false */0;
       }
-    }
-    else {
+    } else {
       return /* true */1;
     }
   };
@@ -22290,14 +21817,12 @@ function exists(p, _param) {
     if (param) {
       if (Curry._1(p, param[0])) {
         return /* true */1;
-      }
-      else {
+      } else {
         _param = param[1];
         continue ;
         
       }
-    }
-    else {
+    } else {
       return /* false */0;
     }
   };
@@ -22314,25 +21839,21 @@ function for_all2(p, _l1, _l2) {
           _l1 = l1[1];
           continue ;
           
-        }
-        else {
+        } else {
           return /* false */0;
         }
-      }
-      else {
+      } else {
         throw [
               Caml_builtin_exceptions.invalid_argument,
               "List.for_all2"
             ];
       }
-    }
-    else if (l2) {
+    } else if (l2) {
       throw [
             Caml_builtin_exceptions.invalid_argument,
             "List.for_all2"
           ];
-    }
-    else {
+    } else {
       return /* true */1;
     }
   };
@@ -22346,28 +21867,24 @@ function exists2(p, _l1, _l2) {
       if (l2) {
         if (Curry._2(p, l1[0], l2[0])) {
           return /* true */1;
-        }
-        else {
+        } else {
           _l2 = l2[1];
           _l1 = l1[1];
           continue ;
           
         }
-      }
-      else {
+      } else {
         throw [
               Caml_builtin_exceptions.invalid_argument,
               "List.exists2"
             ];
       }
-    }
-    else if (l2) {
+    } else if (l2) {
       throw [
             Caml_builtin_exceptions.invalid_argument,
             "List.exists2"
           ];
-    }
-    else {
+    } else {
       return /* false */0;
     }
   };
@@ -22381,12 +21898,10 @@ function mem(x, _param) {
         _param = param[1];
         continue ;
         
-      }
-      else {
+      } else {
         return /* true */1;
       }
-    }
-    else {
+    } else {
       return /* false */0;
     }
   };
@@ -22398,14 +21913,12 @@ function memq(x, _param) {
     if (param) {
       if (param[0] === x) {
         return /* true */1;
-      }
-      else {
+      } else {
         _param = param[1];
         continue ;
         
       }
-    }
-    else {
+    } else {
       return /* false */0;
     }
   };
@@ -22420,12 +21933,10 @@ function assoc(x, _param) {
         _param = param[1];
         continue ;
         
-      }
-      else {
+      } else {
         return match[1];
       }
-    }
-    else {
+    } else {
       throw Caml_builtin_exceptions.not_found;
     }
   };
@@ -22438,14 +21949,12 @@ function assq(x, _param) {
       var match = param[0];
       if (match[0] === x) {
         return match[1];
-      }
-      else {
+      } else {
         _param = param[1];
         continue ;
         
       }
-    }
-    else {
+    } else {
       throw Caml_builtin_exceptions.not_found;
     }
   };
@@ -22459,12 +21968,10 @@ function mem_assoc(x, _param) {
         _param = param[1];
         continue ;
         
-      }
-      else {
+      } else {
         return /* true */1;
       }
-    }
-    else {
+    } else {
       return /* false */0;
     }
   };
@@ -22476,14 +21983,12 @@ function mem_assq(x, _param) {
     if (param) {
       if (param[0][0] === x) {
         return /* true */1;
-      }
-      else {
+      } else {
         _param = param[1];
         continue ;
         
       }
-    }
-    else {
+    } else {
       return /* false */0;
     }
   };
@@ -22498,12 +22003,10 @@ function remove_assoc(x, param) {
               pair,
               remove_assoc(x, l)
             ];
-    }
-    else {
+    } else {
       return l;
     }
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -22514,15 +22017,13 @@ function remove_assq(x, param) {
     var pair = param[0];
     if (pair[0] === x) {
       return l;
-    }
-    else {
+    } else {
       return /* :: */[
               pair,
               remove_assq(x, l)
             ];
     }
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -22534,14 +22035,12 @@ function find(p, _param) {
       var x = param[0];
       if (Curry._1(p, x)) {
         return x;
-      }
-      else {
+      } else {
         _param = param[1];
         continue ;
         
       }
-    }
-    else {
+    } else {
       throw Caml_builtin_exceptions.not_found;
     }
   };
@@ -22565,14 +22064,12 @@ function find_all(p) {
           ];
           continue ;
           
-        }
-        else {
+        } else {
           _param = l;
           continue ;
           
         }
-      }
-      else {
+      } else {
         return rev_append(accu, /* [] */0);
       }
     };
@@ -22598,8 +22095,7 @@ function partition(p, l) {
         ];
         continue ;
         
-      }
-      else {
+      } else {
         _param = l$1;
         _no = /* :: */[
           x,
@@ -22608,8 +22104,7 @@ function partition(p, l) {
         continue ;
         
       }
-    }
-    else {
+    } else {
       return /* tuple */[
               rev_append(yes, /* [] */0),
               rev_append(no, /* [] */0)
@@ -22632,8 +22127,7 @@ function split(param) {
               match$1[1]
             ]
           ];
-  }
-  else {
+  } else {
     return /* tuple */[
             /* [] */0,
             /* [] */0
@@ -22651,21 +22145,18 @@ function combine(l1, l2) {
               ],
               combine(l1[1], l2[1])
             ];
-    }
-    else {
+    } else {
       throw [
             Caml_builtin_exceptions.invalid_argument,
             "List.combine"
           ];
     }
-  }
-  else if (l2) {
+  } else if (l2) {
     throw [
           Caml_builtin_exceptions.invalid_argument,
           "List.combine"
         ];
-  }
-  else {
+  } else {
     return /* [] */0;
   }
 }
@@ -22680,19 +22171,16 @@ function merge(cmp, l1, l2) {
                 h1,
                 merge(cmp, l1[1], l2)
               ];
-      }
-      else {
+      } else {
         return /* :: */[
                 h2,
                 merge(cmp, l1, l2[1])
               ];
       }
-    }
-    else {
+    } else {
       return l1;
     }
-  }
-  else {
+  } else {
     return l2;
   }
 }
@@ -22707,8 +22195,7 @@ function chop(_k, _l) {
         _k = k - 1 | 0;
         continue ;
         
-      }
-      else {
+      } else {
         throw [
               Caml_builtin_exceptions.assert_failure,
               [
@@ -22718,8 +22205,7 @@ function chop(_k, _l) {
               ]
             ];
       }
-    }
-    else {
+    } else {
       return l;
     }
   };
@@ -22731,8 +22217,7 @@ function stable_sort(cmp, l) {
     if (n !== 2) {
       if (n !== 3) {
         exit = 1;
-      }
-      else if (l) {
+      } else if (l) {
         var match = l[1];
         if (match) {
           var match$1 = match[1];
@@ -22752,8 +22237,7 @@ function stable_sort(cmp, l) {
                           ]
                         ]
                       ];
-              }
-              else if (Curry._2(cmp, x1, x3) <= 0) {
+              } else if (Curry._2(cmp, x1, x3) <= 0) {
                 return /* :: */[
                         x1,
                         /* :: */[
@@ -22764,8 +22248,7 @@ function stable_sort(cmp, l) {
                           ]
                         ]
                       ];
-              }
-              else {
+              } else {
                 return /* :: */[
                         x3,
                         /* :: */[
@@ -22777,8 +22260,7 @@ function stable_sort(cmp, l) {
                         ]
                       ];
               }
-            }
-            else if (Curry._2(cmp, x1, x3) <= 0) {
+            } else if (Curry._2(cmp, x1, x3) <= 0) {
               return /* :: */[
                       x2,
                       /* :: */[
@@ -22789,8 +22271,7 @@ function stable_sort(cmp, l) {
                         ]
                       ]
                     ];
-            }
-            else if (Curry._2(cmp, x2, x3) <= 0) {
+            } else if (Curry._2(cmp, x2, x3) <= 0) {
               return /* :: */[
                       x2,
                       /* :: */[
@@ -22801,8 +22282,7 @@ function stable_sort(cmp, l) {
                         ]
                       ]
                     ];
-            }
-            else {
+            } else {
               return /* :: */[
                       x3,
                       /* :: */[
@@ -22814,20 +22294,16 @@ function stable_sort(cmp, l) {
                       ]
                     ];
             }
-          }
-          else {
+          } else {
             exit = 1;
           }
-        }
-        else {
+        } else {
           exit = 1;
         }
-      }
-      else {
+      } else {
         exit = 1;
       }
-    }
-    else if (l) {
+    } else if (l) {
       var match$2 = l[1];
       if (match$2) {
         var x2$1 = match$2[0];
@@ -22840,8 +22316,7 @@ function stable_sort(cmp, l) {
                     /* [] */0
                   ]
                 ];
-        }
-        else {
+        } else {
           return /* :: */[
                   x2$1,
                   /* :: */[
@@ -22850,12 +22325,10 @@ function stable_sort(cmp, l) {
                   ]
                 ];
         }
-      }
-      else {
+      } else {
         exit = 1;
       }
-    }
-    else {
+    } else {
       exit = 1;
     }
     if (exit === 1) {
@@ -22883,8 +22356,7 @@ function stable_sort(cmp, l) {
               _l1 = l1[1];
               continue ;
               
-            }
-            else {
+            } else {
               _accu = /* :: */[
                 h2,
                 accu
@@ -22893,12 +22365,10 @@ function stable_sort(cmp, l) {
               continue ;
               
             }
-          }
-          else {
+          } else {
             return rev_append(l1, accu);
           }
-        }
-        else {
+        } else {
           return rev_append(l2$1, accu);
         }
       };
@@ -22910,8 +22380,7 @@ function stable_sort(cmp, l) {
     if (n !== 2) {
       if (n !== 3) {
         exit = 1;
-      }
-      else if (l) {
+      } else if (l) {
         var match = l[1];
         if (match) {
           var match$1 = match[1];
@@ -22931,8 +22400,7 @@ function stable_sort(cmp, l) {
                           ]
                         ]
                       ];
-              }
-              else if (Curry._2(cmp, x1, x3) > 0) {
+              } else if (Curry._2(cmp, x1, x3) > 0) {
                 return /* :: */[
                         x1,
                         /* :: */[
@@ -22943,8 +22411,7 @@ function stable_sort(cmp, l) {
                           ]
                         ]
                       ];
-              }
-              else {
+              } else {
                 return /* :: */[
                         x3,
                         /* :: */[
@@ -22956,8 +22423,7 @@ function stable_sort(cmp, l) {
                         ]
                       ];
               }
-            }
-            else if (Curry._2(cmp, x1, x3) > 0) {
+            } else if (Curry._2(cmp, x1, x3) > 0) {
               return /* :: */[
                       x2,
                       /* :: */[
@@ -22968,8 +22434,7 @@ function stable_sort(cmp, l) {
                         ]
                       ]
                     ];
-            }
-            else if (Curry._2(cmp, x2, x3) > 0) {
+            } else if (Curry._2(cmp, x2, x3) > 0) {
               return /* :: */[
                       x2,
                       /* :: */[
@@ -22980,8 +22445,7 @@ function stable_sort(cmp, l) {
                         ]
                       ]
                     ];
-            }
-            else {
+            } else {
               return /* :: */[
                       x3,
                       /* :: */[
@@ -22993,20 +22457,16 @@ function stable_sort(cmp, l) {
                       ]
                     ];
             }
-          }
-          else {
+          } else {
             exit = 1;
           }
-        }
-        else {
+        } else {
           exit = 1;
         }
-      }
-      else {
+      } else {
         exit = 1;
       }
-    }
-    else if (l) {
+    } else if (l) {
       var match$2 = l[1];
       if (match$2) {
         var x2$1 = match$2[0];
@@ -23019,8 +22479,7 @@ function stable_sort(cmp, l) {
                     /* [] */0
                   ]
                 ];
-        }
-        else {
+        } else {
           return /* :: */[
                   x2$1,
                   /* :: */[
@@ -23029,12 +22488,10 @@ function stable_sort(cmp, l) {
                   ]
                 ];
         }
-      }
-      else {
+      } else {
         exit = 1;
       }
-    }
-    else {
+    } else {
       exit = 1;
     }
     if (exit === 1) {
@@ -23062,8 +22519,7 @@ function stable_sort(cmp, l) {
               _l1 = l1[1];
               continue ;
               
-            }
-            else {
+            } else {
               _accu = /* :: */[
                 h2,
                 accu
@@ -23072,12 +22528,10 @@ function stable_sort(cmp, l) {
               continue ;
               
             }
-          }
-          else {
+          } else {
             return rev_append(l1, accu);
           }
-        }
-        else {
+        } else {
           return rev_append(l2$1, accu);
         }
       };
@@ -23087,8 +22541,7 @@ function stable_sort(cmp, l) {
   var len = length(l);
   if (len < 2) {
     return l;
-  }
-  else {
+  } else {
     return sort(len, l);
   }
 }
@@ -23099,8 +22552,7 @@ function sort_uniq(cmp, l) {
     if (n !== 2) {
       if (n !== 3) {
         exit = 1;
-      }
-      else if (l) {
+      } else if (l) {
         var match = l[1];
         if (match) {
           var match$1 = match[1];
@@ -23124,8 +22576,7 @@ function sort_uniq(cmp, l) {
                               ]
                             ]
                           ];
-                  }
-                  else {
+                  } else {
                     var c$2 = Curry._2(cmp, x1, x3);
                     if (c$2) {
                       if (c$2 < 0) {
@@ -23139,8 +22590,7 @@ function sort_uniq(cmp, l) {
                                   ]
                                 ]
                               ];
-                      }
-                      else {
+                      } else {
                         return /* :: */[
                                 x3,
                                 /* :: */[
@@ -23152,8 +22602,7 @@ function sort_uniq(cmp, l) {
                                 ]
                               ];
                       }
-                    }
-                    else {
+                    } else {
                       return /* :: */[
                               x1,
                               /* :: */[
@@ -23163,8 +22612,7 @@ function sort_uniq(cmp, l) {
                             ];
                     }
                   }
-                }
-                else {
+                } else {
                   return /* :: */[
                           x1,
                           /* :: */[
@@ -23173,8 +22621,7 @@ function sort_uniq(cmp, l) {
                           ]
                         ];
                 }
-              }
-              else {
+              } else {
                 var c$3 = Curry._2(cmp, x1, x3);
                 if (c$3) {
                   if (c$3 < 0) {
@@ -23188,8 +22635,7 @@ function sort_uniq(cmp, l) {
                               ]
                             ]
                           ];
-                  }
-                  else {
+                  } else {
                     var c$4 = Curry._2(cmp, x2, x3);
                     if (c$4) {
                       if (c$4 < 0) {
@@ -23203,8 +22649,7 @@ function sort_uniq(cmp, l) {
                                   ]
                                 ]
                               ];
-                      }
-                      else {
+                      } else {
                         return /* :: */[
                                 x3,
                                 /* :: */[
@@ -23216,8 +22661,7 @@ function sort_uniq(cmp, l) {
                                 ]
                               ];
                       }
-                    }
-                    else {
+                    } else {
                       return /* :: */[
                               x2,
                               /* :: */[
@@ -23227,8 +22671,7 @@ function sort_uniq(cmp, l) {
                             ];
                     }
                   }
-                }
-                else {
+                } else {
                   return /* :: */[
                           x2,
                           /* :: */[
@@ -23238,8 +22681,7 @@ function sort_uniq(cmp, l) {
                         ];
                 }
               }
-            }
-            else {
+            } else {
               var c$5 = Curry._2(cmp, x2, x3);
               if (c$5) {
                 if (c$5 < 0) {
@@ -23250,8 +22692,7 @@ function sort_uniq(cmp, l) {
                             /* [] */0
                           ]
                         ];
-                }
-                else {
+                } else {
                   return /* :: */[
                           x3,
                           /* :: */[
@@ -23260,28 +22701,23 @@ function sort_uniq(cmp, l) {
                           ]
                         ];
                 }
-              }
-              else {
+              } else {
                 return /* :: */[
                         x2,
                         /* [] */0
                       ];
               }
             }
-          }
-          else {
+          } else {
             exit = 1;
           }
-        }
-        else {
+        } else {
           exit = 1;
         }
-      }
-      else {
+      } else {
         exit = 1;
       }
-    }
-    else if (l) {
+    } else if (l) {
       var match$2 = l[1];
       if (match$2) {
         var x2$1 = match$2[0];
@@ -23296,8 +22732,7 @@ function sort_uniq(cmp, l) {
                       /* [] */0
                     ]
                   ];
-          }
-          else {
+          } else {
             return /* :: */[
                     x2$1,
                     /* :: */[
@@ -23306,19 +22741,16 @@ function sort_uniq(cmp, l) {
                     ]
                   ];
           }
-        }
-        else {
+        } else {
           return /* :: */[
                   x1$1,
                   /* [] */0
                 ];
         }
-      }
-      else {
+      } else {
         exit = 1;
       }
-    }
-    else {
+    } else {
       exit = 1;
     }
     if (exit === 1) {
@@ -23350,8 +22782,7 @@ function sort_uniq(cmp, l) {
                 _l1 = t1;
                 continue ;
                 
-              }
-              else {
+              } else {
                 _accu = /* :: */[
                   h2,
                   accu
@@ -23360,8 +22791,7 @@ function sort_uniq(cmp, l) {
                 continue ;
                 
               }
-            }
-            else {
+            } else {
               _accu = /* :: */[
                 h1,
                 accu
@@ -23371,12 +22801,10 @@ function sort_uniq(cmp, l) {
               continue ;
               
             }
-          }
-          else {
+          } else {
             return rev_append(l1, accu);
           }
-        }
-        else {
+        } else {
           return rev_append(l2$1, accu);
         }
       };
@@ -23388,8 +22816,7 @@ function sort_uniq(cmp, l) {
     if (n !== 2) {
       if (n !== 3) {
         exit = 1;
-      }
-      else if (l) {
+      } else if (l) {
         var match = l[1];
         if (match) {
           var match$1 = match[1];
@@ -23413,8 +22840,7 @@ function sort_uniq(cmp, l) {
                               ]
                             ]
                           ];
-                  }
-                  else {
+                  } else {
                     var c$2 = Curry._2(cmp, x1, x3);
                     if (c$2) {
                       if (c$2 > 0) {
@@ -23428,8 +22854,7 @@ function sort_uniq(cmp, l) {
                                   ]
                                 ]
                               ];
-                      }
-                      else {
+                      } else {
                         return /* :: */[
                                 x3,
                                 /* :: */[
@@ -23441,8 +22866,7 @@ function sort_uniq(cmp, l) {
                                 ]
                               ];
                       }
-                    }
-                    else {
+                    } else {
                       return /* :: */[
                               x1,
                               /* :: */[
@@ -23452,8 +22876,7 @@ function sort_uniq(cmp, l) {
                             ];
                     }
                   }
-                }
-                else {
+                } else {
                   return /* :: */[
                           x1,
                           /* :: */[
@@ -23462,8 +22885,7 @@ function sort_uniq(cmp, l) {
                           ]
                         ];
                 }
-              }
-              else {
+              } else {
                 var c$3 = Curry._2(cmp, x1, x3);
                 if (c$3) {
                   if (c$3 > 0) {
@@ -23477,8 +22899,7 @@ function sort_uniq(cmp, l) {
                               ]
                             ]
                           ];
-                  }
-                  else {
+                  } else {
                     var c$4 = Curry._2(cmp, x2, x3);
                     if (c$4) {
                       if (c$4 > 0) {
@@ -23492,8 +22913,7 @@ function sort_uniq(cmp, l) {
                                   ]
                                 ]
                               ];
-                      }
-                      else {
+                      } else {
                         return /* :: */[
                                 x3,
                                 /* :: */[
@@ -23505,8 +22925,7 @@ function sort_uniq(cmp, l) {
                                 ]
                               ];
                       }
-                    }
-                    else {
+                    } else {
                       return /* :: */[
                               x2,
                               /* :: */[
@@ -23516,8 +22935,7 @@ function sort_uniq(cmp, l) {
                             ];
                     }
                   }
-                }
-                else {
+                } else {
                   return /* :: */[
                           x2,
                           /* :: */[
@@ -23527,8 +22945,7 @@ function sort_uniq(cmp, l) {
                         ];
                 }
               }
-            }
-            else {
+            } else {
               var c$5 = Curry._2(cmp, x2, x3);
               if (c$5) {
                 if (c$5 > 0) {
@@ -23539,8 +22956,7 @@ function sort_uniq(cmp, l) {
                             /* [] */0
                           ]
                         ];
-                }
-                else {
+                } else {
                   return /* :: */[
                           x3,
                           /* :: */[
@@ -23549,28 +22965,23 @@ function sort_uniq(cmp, l) {
                           ]
                         ];
                 }
-              }
-              else {
+              } else {
                 return /* :: */[
                         x2,
                         /* [] */0
                       ];
               }
             }
-          }
-          else {
+          } else {
             exit = 1;
           }
-        }
-        else {
+        } else {
           exit = 1;
         }
-      }
-      else {
+      } else {
         exit = 1;
       }
-    }
-    else if (l) {
+    } else if (l) {
       var match$2 = l[1];
       if (match$2) {
         var x2$1 = match$2[0];
@@ -23585,8 +22996,7 @@ function sort_uniq(cmp, l) {
                       /* [] */0
                     ]
                   ];
-          }
-          else {
+          } else {
             return /* :: */[
                     x2$1,
                     /* :: */[
@@ -23595,19 +23005,16 @@ function sort_uniq(cmp, l) {
                     ]
                   ];
           }
-        }
-        else {
+        } else {
           return /* :: */[
                   x1$1,
                   /* [] */0
                 ];
         }
-      }
-      else {
+      } else {
         exit = 1;
       }
-    }
-    else {
+    } else {
       exit = 1;
     }
     if (exit === 1) {
@@ -23639,8 +23046,7 @@ function sort_uniq(cmp, l) {
                 _l1 = t1;
                 continue ;
                 
-              }
-              else {
+              } else {
                 _accu = /* :: */[
                   h2,
                   accu
@@ -23649,8 +23055,7 @@ function sort_uniq(cmp, l) {
                 continue ;
                 
               }
-            }
-            else {
+            } else {
               _accu = /* :: */[
                 h1,
                 accu
@@ -23660,12 +23065,10 @@ function sort_uniq(cmp, l) {
               continue ;
               
             }
-          }
-          else {
+          } else {
             return rev_append(l1, accu);
           }
-        }
-        else {
+        } else {
           return rev_append(l2$1, accu);
         }
       };
@@ -23675,8 +23078,7 @@ function sort_uniq(cmp, l) {
   var len = length(l);
   if (len < 2) {
     return l;
-  }
-  else {
+  } else {
     return sort(len, l);
   }
 }
@@ -23746,15 +23148,14 @@ exports.merge        = merge;
 //////// start of map.js ////////
 'use strict';
 
-var Curry                   = require("./curry");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Curry                   = require("./curry.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
 function Make(funarg) {
   var height = function (param) {
     if (param) {
       return param[4];
-    }
-    else {
+    } else {
       return 0;
     }
   };
@@ -23789,25 +23190,21 @@ function Make(funarg) {
         var ll = l[0];
         if (height(ll) >= height(lr)) {
           return create(ll, lv, ld, create(lr, x, d, r));
-        }
-        else if (lr) {
+        } else if (lr) {
           return create(create(ll, lv, ld, lr[0]), lr[1], lr[2], create(lr[3], x, d, r));
-        }
-        else {
+        } else {
           throw [
                 Caml_builtin_exceptions.invalid_argument,
                 "Map.bal"
               ];
         }
-      }
-      else {
+      } else {
         throw [
               Caml_builtin_exceptions.invalid_argument,
               "Map.bal"
             ];
       }
-    }
-    else if (hr > (hl + 2 | 0)) {
+    } else if (hr > (hl + 2 | 0)) {
       if (r) {
         var rr = r[3];
         var rd = r[2];
@@ -23815,25 +23212,21 @@ function Make(funarg) {
         var rl = r[0];
         if (height(rr) >= height(rl)) {
           return create(create(l, x, d, rl), rv, rd, rr);
-        }
-        else if (rl) {
+        } else if (rl) {
           return create(create(l, x, d, rl[0]), rl[1], rl[2], create(rl[3], rv, rd, rr));
-        }
-        else {
+        } else {
           throw [
                 Caml_builtin_exceptions.invalid_argument,
                 "Map.bal"
               ];
         }
-      }
-      else {
+      } else {
         throw [
               Caml_builtin_exceptions.invalid_argument,
               "Map.bal"
             ];
       }
-    }
-    else {
+    } else {
       return /* Node */[
               l,
               x,
@@ -23846,8 +23239,7 @@ function Make(funarg) {
   var is_empty = function (param) {
     if (param) {
       return /* false */0;
-    }
-    else {
+    } else {
       return /* true */1;
     }
   };
@@ -23861,12 +23253,10 @@ function Make(funarg) {
       if (c) {
         if (c < 0) {
           return bal(add(x, data, l), v, d, r);
-        }
-        else {
+        } else {
           return bal(l, v, d, add(x, data, r));
         }
-      }
-      else {
+      } else {
         return /* Node */[
                 l,
                 x,
@@ -23875,8 +23265,7 @@ function Make(funarg) {
                 param[4]
               ];
       }
-    }
-    else {
+    } else {
       return /* Node */[
               /* Empty */0,
               x,
@@ -23895,12 +23284,10 @@ function Make(funarg) {
           _param = c < 0 ? param[0] : param[3];
           continue ;
           
-        }
-        else {
+        } else {
           return param[2];
         }
-      }
-      else {
+      } else {
         throw Caml_builtin_exceptions.not_found;
       }
     };
@@ -23914,12 +23301,10 @@ function Make(funarg) {
           _param = c < 0 ? param[0] : param[3];
           continue ;
           
-        }
-        else {
+        } else {
           return /* true */1;
         }
-      }
-      else {
+      } else {
         return /* false */0;
       }
     };
@@ -23933,15 +23318,13 @@ function Make(funarg) {
           _param = l;
           continue ;
           
-        }
-        else {
+        } else {
           return /* tuple */[
                   param[1],
                   param[2]
                 ];
         }
-      }
-      else {
+      } else {
         throw Caml_builtin_exceptions.not_found;
       }
     };
@@ -23955,15 +23338,13 @@ function Make(funarg) {
           _param = r;
           continue ;
           
-        }
-        else {
+        } else {
           return /* tuple */[
                   param[1],
                   param[2]
                 ];
         }
-      }
-      else {
+      } else {
         throw Caml_builtin_exceptions.not_found;
       }
     };
@@ -23973,12 +23354,10 @@ function Make(funarg) {
       var l = param[0];
       if (l) {
         return bal(remove_min_binding(l), param[1], param[2], param[3]);
-      }
-      else {
+      } else {
         return param[3];
       }
-    }
-    else {
+    } else {
       throw [
             Caml_builtin_exceptions.invalid_argument,
             "Map.remove_min_elt"
@@ -23995,29 +23374,24 @@ function Make(funarg) {
       if (c) {
         if (c < 0) {
           return bal(remove(x, l), v, d, r);
-        }
-        else {
+        } else {
           return bal(l, v, d, remove(x, r));
         }
-      }
-      else {
+      } else {
         var t1 = l;
         var t2 = r;
         if (t1) {
           if (t2) {
             var match = min_binding(t2);
             return bal(t1, match[0], match[1], remove_min_binding(t2));
-          }
-          else {
+          } else {
             return t1;
           }
-        }
-        else {
+        } else {
           return t2;
         }
       }
-    }
-    else {
+    } else {
       return /* Empty */0;
     }
   };
@@ -24030,8 +23404,7 @@ function Make(funarg) {
         _param = param[3];
         continue ;
         
-      }
-      else {
+      } else {
         return /* () */0;
       }
     };
@@ -24048,8 +23421,7 @@ function Make(funarg) {
               r$prime,
               param[4]
             ];
-    }
-    else {
+    } else {
       return /* Empty */0;
     }
   };
@@ -24066,8 +23438,7 @@ function Make(funarg) {
               r$prime,
               param[4]
             ];
-    }
-    else {
+    } else {
       return /* Empty */0;
     }
   };
@@ -24080,8 +23451,7 @@ function Make(funarg) {
         _m = m[3];
         continue ;
         
-      }
-      else {
+      } else {
         return accu;
       }
     };
@@ -24095,16 +23465,13 @@ function Make(funarg) {
             _param = param[3];
             continue ;
             
-          }
-          else {
+          } else {
             return /* false */0;
           }
-        }
-        else {
+        } else {
           return /* false */0;
         }
-      }
-      else {
+      } else {
         return /* true */1;
       }
     };
@@ -24115,17 +23482,14 @@ function Make(funarg) {
       if (param) {
         if (Curry._2(p, param[1], param[2])) {
           return /* true */1;
-        }
-        else if (exists(p, param[0])) {
+        } else if (exists(p, param[0])) {
           return /* true */1;
-        }
-        else {
+        } else {
           _param = param[3];
           continue ;
           
         }
-      }
-      else {
+      } else {
         return /* false */0;
       }
     };
@@ -24133,16 +23497,14 @@ function Make(funarg) {
   var add_min_binding = function (k, v, param) {
     if (param) {
       return bal(add_min_binding(k, v, param[0]), param[1], param[2], param[3]);
-    }
-    else {
+    } else {
       return singleton(k, v);
     }
   };
   var add_max_binding = function (k, v, param) {
     if (param) {
       return bal(param[0], param[1], param[2], add_max_binding(k, v, param[3]));
-    }
-    else {
+    } else {
       return singleton(k, v);
     }
   };
@@ -24153,19 +23515,15 @@ function Make(funarg) {
         var lh = l[4];
         if (lh > (rh + 2 | 0)) {
           return bal(l[0], l[1], l[2], join(l[3], v, d, r));
-        }
-        else if (rh > (lh + 2 | 0)) {
+        } else if (rh > (lh + 2 | 0)) {
           return bal(join(l, v, d, r[0]), r[1], r[2], r[3]);
-        }
-        else {
+        } else {
           return create(l, v, d, r);
         }
-      }
-      else {
+      } else {
         return add_max_binding(v, d, l);
       }
-    }
-    else {
+    } else {
       return add_min_binding(v, d, r);
     }
   };
@@ -24174,20 +23532,17 @@ function Make(funarg) {
       if (t2) {
         var match = min_binding(t2);
         return join(t1, match[0], match[1], remove_min_binding(t2));
-      }
-      else {
+      } else {
         return t1;
       }
-    }
-    else {
+    } else {
       return t2;
     }
   };
   var concat_or_join = function (t1, v, d, t2) {
     if (d) {
       return join(t1, v, d[0], t2);
-    }
-    else {
+    } else {
       return concat(t1, t2);
     }
   };
@@ -24206,8 +23561,7 @@ function Make(funarg) {
                   match[1],
                   join(match[2], v, d, r)
                 ];
-        }
-        else {
+        } else {
           var match$1 = split(x, r);
           return /* tuple */[
                   join(l, v, d, match$1[0]),
@@ -24215,16 +23569,14 @@ function Make(funarg) {
                   match$1[2]
                 ];
         }
-      }
-      else {
+      } else {
         return /* tuple */[
                 l,
                 /* Some */[d],
                 r
               ];
       }
-    }
-    else {
+    } else {
       return /* tuple */[
               /* Empty */0,
               /* None */0,
@@ -24239,15 +23591,12 @@ function Make(funarg) {
       if (s1[4] >= height(s2)) {
         var match = split(v1, s2);
         return concat_or_join(merge(f, s1[0], match[0]), v1, Curry._3(f, v1, /* Some */[s1[2]], match[1]), merge(f, s1[3], match[2]));
-      }
-      else {
+      } else {
         exit = 1;
       }
-    }
-    else if (s2) {
+    } else if (s2) {
       exit = 1;
-    }
-    else {
+    } else {
       return /* Empty */0;
     }
     if (exit === 1) {
@@ -24255,8 +23604,7 @@ function Make(funarg) {
         var v2 = s2[1];
         var match$1 = split(v2, s1);
         return concat_or_join(merge(f, match$1[0], s2[0]), v2, Curry._3(f, v2, match$1[1], /* Some */[s2[2]]), merge(f, match$1[2], s2[3]));
-      }
-      else {
+      } else {
         throw [
               Caml_builtin_exceptions.assert_failure,
               [
@@ -24278,12 +23626,10 @@ function Make(funarg) {
       var r$prime = filter(p, param[3]);
       if (pvd) {
         return join(l$prime, v, d, r$prime);
-      }
-      else {
+      } else {
         return concat(l$prime, r$prime);
       }
-    }
-    else {
+    } else {
       return /* Empty */0;
     }
   };
@@ -24303,15 +23649,13 @@ function Make(funarg) {
                 join(lt, v, d, rt),
                 concat(lf, rf)
               ];
-      }
-      else {
+      } else {
         return /* tuple */[
                 concat(lt, rt),
                 join(lf, v, d, rf)
               ];
       }
-    }
-    else {
+    } else {
       return /* tuple */[
               /* Empty */0,
               /* Empty */0
@@ -24332,8 +23676,7 @@ function Make(funarg) {
         _m = m[0];
         continue ;
         
-      }
-      else {
+      } else {
         return e;
       }
     };
@@ -24349,28 +23692,23 @@ function Make(funarg) {
           var c = Curry._2(funarg[/* compare */0], e1[0], e2[0]);
           if (c !== 0) {
             return c;
-          }
-          else {
+          } else {
             var c$1 = Curry._2(cmp, e1[1], e2[1]);
             if (c$1 !== 0) {
               return c$1;
-            }
-            else {
+            } else {
               _e2 = cons_enum(e2[2], e2[3]);
               _e1 = cons_enum(e1[2], e1[3]);
               continue ;
               
             }
           }
-        }
-        else {
+        } else {
           return 1;
         }
-      }
-      else if (e2) {
+      } else if (e2) {
         return -1;
-      }
-      else {
+      } else {
         return 0;
       }
     };
@@ -24385,25 +23723,20 @@ function Make(funarg) {
         if (e2) {
           if (Curry._2(funarg[/* compare */0], e1[0], e2[0])) {
             return /* false */0;
-          }
-          else if (Curry._2(cmp, e1[1], e2[1])) {
+          } else if (Curry._2(cmp, e1[1], e2[1])) {
             _e2 = cons_enum(e2[2], e2[3]);
             _e1 = cons_enum(e1[2], e1[3]);
             continue ;
             
-          }
-          else {
+          } else {
             return /* false */0;
           }
-        }
-        else {
+        } else {
           return /* false */0;
         }
-      }
-      else if (e2) {
+      } else if (e2) {
         return /* false */0;
-      }
-      else {
+      } else {
         return /* true */1;
       }
     };
@@ -24411,8 +23744,7 @@ function Make(funarg) {
   var cardinal = function (param) {
     if (param) {
       return (cardinal(param[0]) + 1 | 0) + cardinal(param[3]) | 0;
-    }
-    else {
+    } else {
       return 0;
     }
   };
@@ -24431,8 +23763,7 @@ function Make(funarg) {
         ];
         continue ;
         
-      }
-      else {
+      } else {
         return accu;
       }
     };
@@ -24478,10 +23809,10 @@ exports.Make = Make;
   _registry['numeric_error'] = function() {
     let exports = {};
 //////// start of numeric_error.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions");
+var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions.js");
 
 var IntegerOverflow = Caml_exceptions.create("Numeric_error.IntegerOverflow");
 
@@ -24503,22 +23834,17 @@ exports.InvalidConversionToInteger = InvalidConversionToInteger;
 //////// start of obj.js ////////
 'use strict';
 
-var Marshal                 = require("./marshal");
-var Caml_builtin_exceptions = require("./caml_builtin_exceptions");
+var Marshal                 = require("./marshal.js");
+var Caml_array              = require("./caml_array.js");
+var Caml_missing_polyfill   = require("./caml_missing_polyfill.js");
+var Caml_builtin_exceptions = require("./caml_builtin_exceptions.js");
 
-function double_field(x, i) {
-  return x[i];
-}
+var double_field = Caml_array.caml_array_get;
 
-function set_double_field(x, i, v) {
-  x[i] = v;
-  return /* () */0;
-}
+var set_double_field = Caml_array.caml_array_set;
 
 function marshal() {
-  return function () {
-            throw "caml_output_value_to_string not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_output_value_to_string not implemented by bucklescript yet\n");
 }
 
 function unmarshal(str, pos) {
@@ -24533,14 +23859,12 @@ function extension_slot(x) {
   var name;
   if (slot.length !== undefined && slot.tag === 248) {
     name = slot[0];
-  }
-  else {
+  } else {
     throw Caml_builtin_exceptions.not_found;
   }
   if (name.tag === 252) {
     return slot;
-  }
-  else {
+  } else {
     throw Caml_builtin_exceptions.not_found;
   }
 }
@@ -24556,8 +23880,7 @@ function extension_name(x) {
             Caml_builtin_exceptions.invalid_argument,
             "Obj.extension_name"
           ];
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -24574,8 +23897,7 @@ function extension_id(x) {
             Caml_builtin_exceptions.invalid_argument,
             "Obj.extension_id"
           ];
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -24591,8 +23913,7 @@ function extension_slot$1(x) {
             Caml_builtin_exceptions.invalid_argument,
             "Obj.extension_slot"
           ];
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -24662,36 +23983,14 @@ exports.unmarshal                          = unmarshal;
   };
 
 
-  _registry['oo'] = function() {
-    let exports = {};
-//////// start of oo.js ////////
-'use strict';
-
-var CamlinternalOO = require("./camlinternalOO");
-
-var copy = CamlinternalOO.copy;
-
-var new_method = CamlinternalOO.public_method_label;
-
-var public_method_label = CamlinternalOO.public_method_label;
-
-exports.copy                = copy;
-exports.new_method          = new_method;
-exports.public_method_label = public_method_label;
-/* No side effect */
-//////// end of oo.js ////////
-    return exports;
-  };
-
-
   _registry['operators'] = function() {
     let exports = {};
 //////// start of operators.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Block  = require("bs-platform/lib/js/block");
-var Source = require("./source");
+var Block  = require("bs-platform/lib/js/block.js");
+var Source = require("./source.js");
 
 function i32_const(n) {
   return /* Const */Block.__(15, [Source.$at$at(/* I32 */Block.__(0, [n[/* it */1]]), n[/* at */0])]);
@@ -25450,16 +24749,17 @@ exports.grow_memory         = grow_memory;
   _registry['parse'] = function() {
     let exports = {};
 //////// start of parse.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Curry    = require("bs-platform/lib/js/curry");
-var Lexer    = require("./lexer");
-var Lexing   = require("bs-platform/lib/js/lexing");
-var Parser   = require("./parser");
-var Script   = require("./script");
-var Source   = require("./source");
-var Caml_obj = require("bs-platform/lib/js/caml_obj");
+var Curry    = require("bs-platform/lib/js/curry.js");
+var Lexer    = require("./lexer.js");
+var Js_exn   = require("bs-platform/lib/js/js_exn.js");
+var Lexing   = require("bs-platform/lib/js/lexing.js");
+var Parser   = require("./parser.js");
+var Script   = require("./script.js");
+var Source   = require("./source.js");
+var Caml_obj = require("bs-platform/lib/js/caml_obj.js");
 
 function parse$prime(name, lexbuf, start) {
   var init = lexbuf[/* lex_curr_p */11];
@@ -25472,7 +24772,8 @@ function parse$prime(name, lexbuf, start) {
   try {
     return Curry._2(start, Lexer.token, lexbuf);
   }
-  catch (exn){
+  catch (raw_exn){
+    var exn = Js_exn.internalToOCamlException(raw_exn);
     if (exn[0] === Script.Syntax) {
       var region = exn[1];
       var region$prime = Caml_obj.caml_notequal(region, Source.no_region) ? region : /* record */[
@@ -25484,8 +24785,7 @@ function parse$prime(name, lexbuf, start) {
             region$prime,
             exn[2]
           ];
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -25513,7 +24813,7 @@ function string_to_script(s) {
 }
 
 function string_to_module(s) {
-  return string_to(/* Module */0, s);
+  return string_to(/* Module */0, s)[1];
 }
 
 var Syntax = Script.Syntax;
@@ -25531,25 +24831,27 @@ exports.string_to_module = string_to_module;
   _registry['parser'] = function() {
     let exports = {};
 //////// start of parser.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Ast                     = require("./ast");
-var I32                     = require("./i32");
-var Lib                     = require("./lib");
-var $$Map                   = require("bs-platform/lib/js/map");
-var List                    = require("bs-platform/lib/js/list");
-var Block                   = require("bs-platform/lib/js/block");
-var Curry                   = require("bs-platform/lib/js/curry");
-var Script                  = require("./script");
-var Source                  = require("./source");
-var $$String                = require("bs-platform/lib/js/string");
-var Parsing                 = require("bs-platform/lib/js/parsing");
-var Caml_obj                = require("bs-platform/lib/js/caml_obj");
-var Operators               = require("./operators");
-var Pervasives              = require("bs-platform/lib/js/pervasives");
-var Caml_format             = require("bs-platform/lib/js/caml_format");
-var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions");
+var Ast                     = require("./ast.js");
+var I32                     = require("./i32.js");
+var Lib                     = require("./lib.js");
+var $$Map                   = require("bs-platform/lib/js/map.js");
+var List                    = require("bs-platform/lib/js/list.js");
+var Utf8                    = require("./utf8.js");
+var Block                   = require("bs-platform/lib/js/block.js");
+var Curry                   = require("bs-platform/lib/js/curry.js");
+var Js_exn                  = require("bs-platform/lib/js/js_exn.js");
+var Script                  = require("./script.js");
+var Source                  = require("./source.js");
+var $$String                = require("bs-platform/lib/js/string.js");
+var Parsing                 = require("bs-platform/lib/js/parsing.js");
+var Caml_obj                = require("bs-platform/lib/js/caml_obj.js");
+var Operators               = require("./operators.js");
+var Pervasives              = require("bs-platform/lib/js/pervasives.js");
+var Caml_format             = require("bs-platform/lib/js/caml_format.js");
+var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions.js");
 
 function parse_error(msg) {
   var msg$1 = msg === "syntax error" ? "unexpected token" : msg;
@@ -25587,15 +24889,15 @@ function literal(f, s) {
   try {
     return Curry._1(f, s);
   }
-  catch (exn){
+  catch (raw_exn){
+    var exn = Js_exn.internalToOCamlException(raw_exn);
     if (exn[0] === Caml_builtin_exceptions.failure) {
       throw [
             Script.Syntax,
             s[/* at */0],
             "constant out of range"
           ];
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -25606,23 +24908,22 @@ function nat(s, at) {
     var n = Caml_format.caml_int_of_string(s);
     if (n >= 0) {
       return n;
-    }
-    else {
+    } else {
       throw [
             Caml_builtin_exceptions.failure,
             ""
           ];
     }
   }
-  catch (exn){
+  catch (raw_exn){
+    var exn = Js_exn.internalToOCamlException(raw_exn);
     if (exn[0] === Caml_builtin_exceptions.failure) {
       throw [
             Script.Syntax,
             at,
             "integer constant out of range"
           ];
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -25632,15 +24933,15 @@ function nat32(s, at) {
   try {
     return Curry._1(I32.of_string_u, s);
   }
-  catch (exn){
+  catch (raw_exn){
+    var exn = Js_exn.internalToOCamlException(raw_exn);
     if (exn[0] === Caml_builtin_exceptions.failure) {
       throw [
             Script.Syntax,
             at,
             "i32 constant out of range"
           ];
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -25704,8 +25005,7 @@ function type_(c, x) {
             x[/* at */0],
             "unknown type " + x[/* it */1]
           ];
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -25722,8 +25022,7 @@ function lookup(category, space, x) {
             x[/* at */0],
             "unknown " + (category + (" " + x[/* it */1]))
           ];
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -25737,7 +25036,7 @@ function local(c, x) {
   return lookup("local", c[/* locals */4], x);
 }
 
-function global(c, x) {
+function $$global(c, x) {
   return lookup("global", c[/* globals */5], x);
 }
 
@@ -25760,8 +25059,7 @@ function label(c, x) {
             x[/* at */0],
             "unknown label " + x[/* it */1]
           ];
-    }
-    else {
+    } else {
       throw exn;
     }
   }
@@ -25783,18 +25081,17 @@ function bind(category, space, x) {
           "duplicate " + (category + (" " + x[/* it */1]))
         ];
   }
+  var i = space[/* count */1];
   space[/* map */0] = Curry._3(VarMap[/* add */3], x[/* it */1], space[/* count */1], space[/* map */0]);
   space[/* count */1] = space[/* count */1] + 1 | 0;
-  if (space[/* count */1]) {
-    return 0;
-  }
-  else {
+  if (!space[/* count */1]) {
     throw [
           Script.Syntax,
           x[/* at */0],
           "too many " + (category + " bindings")
         ];
   }
+  return i;
 }
 
 function bind_func(c, x) {
@@ -25818,6 +25115,7 @@ function bind_memory(c, x) {
 }
 
 function anon(category, space, n) {
+  var i = space[/* count */1];
   space[/* count */1] = space[/* count */1] + n | 0;
   if (Curry._2(I32.lt_u, space[/* count */1], n)) {
     throw [
@@ -25826,9 +25124,7 @@ function anon(category, space, n) {
           "too many " + (category + " bindings")
         ];
   }
-  else {
-    return 0;
-  }
+  return i;
 }
 
 function anon_func(c) {
@@ -25836,7 +25132,8 @@ function anon_func(c) {
 }
 
 function anon_locals(c, ts) {
-  return anon("local", c[/* locals */4], Curry._1(Lib.List32[/* length */0], ts));
+  anon("local", c[/* locals */4], Curry._1(Lib.List32[/* length */0], ts));
+  return /* () */0;
 }
 
 function anon_global(c) {
@@ -25864,30 +25161,29 @@ var empty_type = /* FuncType */[
   /* [] */0
 ];
 
-function explicit_sig(c, var_sem, ty, at) {
-  var x = Curry._2(var_sem, c, type_);
-  if (x[/* it */1] < Curry._1(Lib.List32[/* length */0], c[/* types */0][/* tlist */1]) && Caml_obj.caml_notequal(ty, empty_type) && Caml_obj.caml_notequal(ty, Curry._2(Lib.List32[/* nth */1], c[/* types */0][/* tlist */1], x[/* it */1]))) {
-    throw [
-          Script.Syntax,
-          at,
-          "signature mismatch"
-        ];
-  }
-  return x;
-}
-
 function inline_type(c, ty, at) {
   var match = Curry._2(Lib.List[/* index_of */6], ty, c[/* types */0][/* tlist */1]);
   if (match) {
     return Source.$at$at(match[0], at);
-  }
-  else {
+  } else {
     var i = Curry._1(Lib.List32[/* length */0], c[/* types */0][/* tlist */1]);
     anon_type(c, ty);
     return Source.$at$at(i, at);
   }
 }
 
+function inline_type_explicit(c, x, ty, at) {
+  if (Caml_obj.caml_notequal(ty, empty_type) && (x[/* it */1] >= Curry._1(Lib.List32[/* length */0], c[/* types */0][/* tlist */1]) || Caml_obj.caml_notequal(ty, Curry._2(Lib.List32[/* nth */1], c[/* types */0][/* tlist */1], x[/* it */1])))) {
+    throw [
+          Script.Syntax,
+          at,
+          "inline function type does not match explicit type"
+        ];
+  } else {
+    return x;
+  }
+}
+
 var yytransl_const = /* array */[
   263,
   264,
@@ -25913,7 +25209,6 @@ var yytransl_const = /* array */[
   284,
   285,
   286,
-  296,
   297,
   298,
   299,
@@ -25945,6 +25240,10 @@ var yytransl_const = /* array */[
   325,
   326,
   327,
+  328,
+  329,
+  330,
+  331,
   0,
   0
 ];
@@ -25965,7 +25264,7 @@ var yytransl_block = /* array */[
   293,
   294,
   295,
-  328,
+  296,
   0
 ];
 
@@ -25973,6 +25272,25 @@ var yyact = /* array */[
   function () {
     return Pervasives.failwith("parser");
   },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
+    var s = _1;
+    var at$1 = at(/* () */0);
+    try {
+      return Utf8.decode(s);
+    }
+    catch (exn){
+      if (exn === Utf8.Utf8) {
+        throw [
+              Script.Syntax,
+              at$1,
+              "invalid UTF-8 encoding"
+            ];
+      } else {
+        throw exn;
+      }
+    }
+  },
   function () {
     return "";
   },
@@ -26163,8 +25481,7 @@ var yyact = /* array */[
                     x[/* at */0],
                     "mismatching label"
                   ];
-            }
-            else {
+            } else {
               return 0;
             }
           }, xs);
@@ -26314,13 +25631,13 @@ var yyact = /* array */[
   function (__caml_parser_env) {
     var _2 = Parsing.peek_val(__caml_parser_env, 0);
     return function (c) {
-      return Operators.get_global(Curry._2(_2, c, global));
+      return Operators.get_global(Curry._2(_2, c, $$global));
     };
   },
   function (__caml_parser_env) {
     var _2 = Parsing.peek_val(__caml_parser_env, 0);
     return function (c) {
-      return Operators.set_global(Curry._2(_2, c, global));
+      return Operators.set_global(Curry._2(_2, c, $$global));
     };
   },
   function (__caml_parser_env) {
@@ -26428,6 +25745,13 @@ var yyact = /* array */[
       return Operators.if_(match[0], match[1], Curry._1(_6, c$prime));
     };
   },
+  function (__caml_parser_env) {
+    var _3 = Parsing.peek_val(__caml_parser_env, 1);
+    return /* :: */[
+            _3,
+            /* [] */0
+          ];
+  },
   function (__caml_parser_env) {
     var _1 = Parsing.peek_val(__caml_parser_env, 1);
     var _2 = Parsing.peek_val(__caml_parser_env, 0);
@@ -26438,6 +25762,15 @@ var yyact = /* array */[
             ];
     };
   },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (c) {
+      return /* tuple */[
+              /* [] */0,
+              Curry._1(_1, c)
+            ];
+    };
+  },
   function (__caml_parser_env) {
     var _2 = Parsing.peek_val(__caml_parser_env, 1);
     var at$1 = at(/* () */0);
@@ -26454,7 +25787,7 @@ var yyact = /* array */[
     var _2 = Parsing.peek_val(__caml_parser_env, 0);
     return function (c) {
       return /* tuple */[
-              Curry._1(_2, c)[1],
+              Curry._1(_2, c),
               Curry._1(_1, c)
             ];
     };
@@ -26484,83 +25817,82 @@ var yyact = /* array */[
     };
   },
   function (__caml_parser_env) {
-    var _2 = Parsing.peek_val(__caml_parser_env, 2);
-    var _3 = Parsing.peek_val(__caml_parser_env, 1);
-    var _4 = Parsing.peek_val(__caml_parser_env, 0);
+    var _2 = Parsing.peek_val(__caml_parser_env, 1);
+    var _3 = Parsing.peek_val(__caml_parser_env, 0);
     return function (c) {
       var c$prime = Curry._2(_2, c, /* [] */0);
-      var match = Curry._2(_4, c, c$prime);
+      var match = Curry._2(_3, c, c$prime);
+      var match$1 = match[1];
       return /* tuple */[
-              match[0],
-              Operators.if_(_3, match[1], match[2])
+              match$1[0],
+              Operators.if_(match[0], match$1[1], match$1[2])
             ];
     };
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 5);
-    var _7 = Parsing.peek_val(__caml_parser_env, 1);
-    return function (_, c$prime) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    var _2 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (c, c$prime) {
+      var match = Curry._2(_2, c, c$prime);
       return /* tuple */[
-              /* [] */0,
-              Curry._1(_3, c$prime),
-              Curry._1(_7, c$prime)
+              Pervasives.$at(_1, match[0]),
+              match[1]
             ];
     };
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 1);
-    return function (_, c$prime) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (c, c$prime) {
       return /* tuple */[
               /* [] */0,
-              Curry._1(_3, c$prime),
-              /* [] */0
+              Curry._2(_1, c, c$prime)
             ];
     };
   },
   function (__caml_parser_env) {
-    var _1 = Parsing.peek_val(__caml_parser_env, 8);
-    var _4 = Parsing.peek_val(__caml_parser_env, 5);
-    var _8 = Parsing.peek_val(__caml_parser_env, 1);
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    var _2 = Parsing.peek_val(__caml_parser_env, 0);
     return function (c, c$prime) {
+      var es = Curry._1(_1, c);
+      var match = Curry._2(_2, c, c$prime);
       return /* tuple */[
-              Curry._1(_1, c),
-              Curry._1(_4, c$prime),
-              Curry._1(_8, c$prime)
+              Pervasives.$at(es, match[0]),
+              match[1],
+              match[2]
             ];
     };
   },
   function (__caml_parser_env) {
-    var _1 = Parsing.peek_val(__caml_parser_env, 4);
-    var _4 = Parsing.peek_val(__caml_parser_env, 1);
-    return function (c, c$prime) {
+    var _3 = Parsing.peek_val(__caml_parser_env, 5);
+    var _7 = Parsing.peek_val(__caml_parser_env, 1);
+    return function (_, c$prime) {
       return /* tuple */[
-              Curry._1(_1, c),
-              Curry._1(_4, c$prime),
-              /* [] */0
+              /* [] */0,
+              Curry._1(_3, c$prime),
+              Curry._1(_7, c$prime)
             ];
     };
   },
   function (__caml_parser_env) {
-    var _1 = Parsing.peek_val(__caml_parser_env, 2);
-    var _2 = Parsing.peek_val(__caml_parser_env, 1);
-    var _3 = Parsing.peek_val(__caml_parser_env, 0);
-    return function (c, c$prime) {
+    var _3 = Parsing.peek_val(__caml_parser_env, 1);
+    return function (_, c$prime) {
       return /* tuple */[
-              Curry._1(_1, c),
-              Curry._1(_2, c$prime),
-              Curry._1(_3, c$prime)
+              /* [] */0,
+              Curry._1(_3, c$prime),
+              /* [] */0
             ];
     };
   },
-  function (__caml_parser_env) {
+  function () {
+    return function () {
+      return /* [] */0;
+    };
+  },
+  function (__caml_parser_env) {
     var _1 = Parsing.peek_val(__caml_parser_env, 1);
     var _2 = Parsing.peek_val(__caml_parser_env, 0);
-    return function (c, c$prime) {
-      return /* tuple */[
-              Curry._1(_1, c),
-              Curry._1(_2, c$prime),
-              /* [] */0
-            ];
+    return function (c) {
+      return Pervasives.$at(Curry._1(_1, c), Curry._1(_2, c));
     };
   },
   function () {
@@ -26575,10 +25907,83 @@ var yyact = /* array */[
       return Pervasives.$at(Curry._1(_1, c), Curry._1(_2, c));
     };
   },
-  function () {
-    return function () {
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
+    var at$1 = at(/* () */0);
+    return function (c) {
+      return Source.$at$at(Curry._1(_1, c), at$1);
+    };
+  },
+  function (__caml_parser_env) {
+    var _3 = Parsing.peek_val(__caml_parser_env, 2);
+    var _4 = Parsing.peek_val(__caml_parser_env, 1);
+    var at$1 = at(/* () */0);
+    return function (c) {
+      var x = Source.$at$at(Curry._3(_3, c, anon_func, bind_func), at$1);
+      return Curry._3(_4, c, x, at$1);
+    };
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    var _2 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (c, _, at) {
+      var t = inline_type_explicit(c, Curry._2(_1, c, type_), _2[0], at);
+      return /* tuple */[
+              function () {
+                var init = Curry._1(_2[1], enter_func(c));
+                return /* :: */[
+                        Source.$at$at(/* record */[
+                              /* ftype */t,
+                              /* locals */init[/* locals */1],
+                              /* body */init[/* body */2]
+                            ], at),
+                        /* [] */0
+                      ];
+              },
+              /* [] */0,
+              /* [] */0
+            ];
+    };
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (c, _, at) {
+      var t = inline_type(c, _1[0], at);
+      return /* tuple */[
+              function () {
+                var init = Curry._1(_1[1], enter_func(c));
+                return /* :: */[
+                        Source.$at$at(/* record */[
+                              /* ftype */t,
+                              /* locals */init[/* locals */1],
+                              /* body */init[/* body */2]
+                            ], at),
+                        /* [] */0
+                      ];
+              },
+              /* [] */0,
+              /* [] */0
+            ];
+    };
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 2);
+    var _2 = Parsing.peek_val(__caml_parser_env, 1);
+    var _3 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (c, _, at) {
+      var t = inline_type_explicit(c, Curry._2(_2, c, type_), _3, at);
       return /* tuple */[
-              0,
+              function () {
+                return /* [] */0;
+              },
+              /* :: */[
+                Source.$at$at(/* record */[
+                      /* module_name */_1[0],
+                      /* item_name */_1[1],
+                      /* idesc */Source.$at$at(/* FuncImport */Block.__(0, [t]), at)
+                    ], at),
+                /* [] */0
+              ],
               /* [] */0
             ];
     };
@@ -26586,20 +25991,37 @@ var yyact = /* array */[
   function (__caml_parser_env) {
     var _1 = Parsing.peek_val(__caml_parser_env, 1);
     var _2 = Parsing.peek_val(__caml_parser_env, 0);
-    return function (c) {
-      var es1 = Curry._1(_1, c);
-      var match = Curry._1(_2, c);
+    return function (c, _, at) {
+      var t = inline_type(c, _2, at);
       return /* tuple */[
-              match[0] + 1 | 0,
-              Pervasives.$at(es1, match[1])
+              function () {
+                return /* [] */0;
+              },
+              /* :: */[
+                Source.$at$at(/* record */[
+                      /* module_name */_1[0],
+                      /* item_name */_1[1],
+                      /* idesc */Source.$at$at(/* FuncImport */Block.__(0, [t]), at)
+                    ], at),
+                /* [] */0
+              ],
+              /* [] */0
             ];
     };
   },
   function (__caml_parser_env) {
-    var _1 = Parsing.peek_val(__caml_parser_env, 0);
-    var at$1 = at(/* () */0);
-    return function (c) {
-      return Source.$at$at(Curry._1(_1, c), at$1);
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    var _2 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (c, x, at) {
+      var match = Curry._3(_2, c, x, at);
+      return /* tuple */[
+              match[0],
+              match[1],
+              /* :: */[
+                Curry._2(_1, /* FuncExport */Block.__(0, [x]), c),
+                match[2]
+              ]
+            ];
     };
   },
   function (__caml_parser_env) {
@@ -26608,17 +26030,37 @@ var yyact = /* array */[
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 2);
     var _5 = Parsing.peek_val(__caml_parser_env, 0);
-    var match = _5[0];
-    return /* tuple */[
-            /* FuncType */[
-              match[0],
-              Pervasives.$at(_3, match[1])
+    return /* FuncType */[
+            Pervasives.$at(_3, _5[0]),
+            _5[1]
+          ];
+  },
+  function (__caml_parser_env) {
+    Parsing.peek_val(__caml_parser_env, 3);
+    var _4 = Parsing.peek_val(__caml_parser_env, 2);
+    var _6 = Parsing.peek_val(__caml_parser_env, 0);
+    return /* FuncType */[
+            /* :: */[
+              _4,
+              _6[0]
             ],
-            function (c) {
-              return Curry._1(_5[1], c);
-            }
+            _6[1]
+          ];
+  },
+  function () {
+    return empty_type;
+  },
+  function (__caml_parser_env) {
+    var _3 = Parsing.peek_val(__caml_parser_env, 2);
+    var _5 = Parsing.peek_val(__caml_parser_env, 0);
+    return /* FuncType */[
+            _5[0],
+            Pervasives.$at(_3, _5[1])
           ];
   },
+  function (__caml_parser_env) {
+    return Parsing.peek_val(__caml_parser_env, 0);
+  },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 2);
     var _5 = Parsing.peek_val(__caml_parser_env, 0);
@@ -26657,133 +26099,59 @@ var yyact = /* array */[
     var _1 = Parsing.peek_val(__caml_parser_env, 0);
     return /* tuple */[
             empty_type,
-            function (c) {
-              var c$prime = anon_label(c);
-              return /* record */[
-                      /* ftype */Source.$at$at(-1, at(/* () */0)),
-                      /* locals : [] */0,
-                      /* body */Curry._1(_1, c$prime)
-                    ];
-            }
+            _1
           ];
   },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 2);
     var _5 = Parsing.peek_val(__caml_parser_env, 0);
+    var match = _5[0];
     return /* tuple */[
-            _5[0],
-            function (c) {
-              anon_locals(c, _3);
-              var f = Curry._1(_5[1], c);
-              return /* record */[
-                      /* ftype */f[/* ftype */0],
-                      /* locals */Pervasives.$at(_3, f[/* locals */1]),
-                      /* body */f[/* body */2]
-                    ];
-            }
-          ];
-  },
-  function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 3);
-    var _4 = Parsing.peek_val(__caml_parser_env, 2);
-    var _6 = Parsing.peek_val(__caml_parser_env, 0);
-    return /* tuple */[
-            _6[0],
-            function (c) {
-              bind_local(c, _3);
-              var f = Curry._1(_6[1], c);
-              return /* record */[
-                      /* ftype */f[/* ftype */0],
-                      /* locals : :: */[
-                        _4,
-                        f[/* locals */1]
-                      ],
-                      /* body */f[/* body */2]
-                    ];
-            }
+            /* FuncType */[
+              match[0],
+              Pervasives.$at(_3, match[1])
+            ],
+            _5[1]
           ];
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 4);
-    var _4 = Parsing.peek_val(__caml_parser_env, 3);
-    var _5 = Parsing.peek_val(__caml_parser_env, 2);
-    var _6 = Parsing.peek_val(__caml_parser_env, 1);
-    var at$1 = at(/* () */0);
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
     return function (c) {
-      Curry._3(_3, c, anon_func, bind_func);
-      var t = explicit_sig(c, _5, _6[0], at$1);
-      return /* tuple */[
-              function () {
-                var init = Curry._1(_6[1], enter_func(c));
-                return Source.$at$at(/* record */[
-                            /* ftype */t,
-                            /* locals */init[/* locals */1],
-                            /* body */init[/* body */2]
-                          ], at$1);
-              },
-              Curry._3(_4, /* FuncExport */0, c[/* funcs */3][/* count */1], c)
+      var c$prime = anon_label(c);
+      return /* record */[
+              /* ftype */Source.$at$at(-1, at(/* () */0)),
+              /* locals : [] */0,
+              /* body */Curry._1(_1, c$prime)
             ];
     };
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 3);
-    var _4 = Parsing.peek_val(__caml_parser_env, 2);
-    var _5 = Parsing.peek_val(__caml_parser_env, 1);
-    var at$1 = at(/* () */0);
+    var _3 = Parsing.peek_val(__caml_parser_env, 2);
+    var _5 = Parsing.peek_val(__caml_parser_env, 0);
     return function (c) {
-      Curry._3(_3, c, anon_func, bind_func);
-      var t = explicit_sig(c, _4, _5[0], at$1);
-      return /* tuple */[
-              function () {
-                var init = Curry._1(_5[1], enter_func(c));
-                return Source.$at$at(/* record */[
-                            /* ftype */t,
-                            /* locals */init[/* locals */1],
-                            /* body */init[/* body */2]
-                          ], at$1);
-              },
-              /* [] */0
+      anon_locals(c, _3);
+      var f = Curry._1(_5, c);
+      return /* record */[
+              /* ftype */f[/* ftype */0],
+              /* locals */Pervasives.$at(_3, f[/* locals */1]),
+              /* body */f[/* body */2]
             ];
     };
   },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 3);
     var _4 = Parsing.peek_val(__caml_parser_env, 2);
-    var _5 = Parsing.peek_val(__caml_parser_env, 1);
-    var at$1 = at(/* () */0);
-    return function (c) {
-      Curry._3(_3, c, anon_func, bind_func);
-      var t = inline_type(c, _5[0], at$1);
-      return /* tuple */[
-              function () {
-                var init = Curry._1(_5[1], enter_func(c));
-                return Source.$at$at(/* record */[
-                            /* ftype */t,
-                            /* locals */init[/* locals */1],
-                            /* body */init[/* body */2]
-                          ], at$1);
-              },
-              Curry._3(_4, /* FuncExport */0, c[/* funcs */3][/* count */1], c)
-            ];
-    };
-  },
-  function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 2);
-    var _4 = Parsing.peek_val(__caml_parser_env, 1);
-    var at$1 = at(/* () */0);
+    var _6 = Parsing.peek_val(__caml_parser_env, 0);
     return function (c) {
-      Curry._3(_3, c, anon_func, bind_func);
-      var t = inline_type(c, _4[0], at$1);
-      return /* tuple */[
-              function () {
-                var init = Curry._1(_4[1], enter_func(c));
-                return Source.$at$at(/* record */[
-                            /* ftype */t,
-                            /* locals */init[/* locals */1],
-                            /* body */init[/* body */2]
-                          ], at$1);
-              },
-              /* [] */0
+      bind_local(c, _3);
+      var f = Curry._1(_6, c);
+      return /* record */[
+              /* ftype */f[/* ftype */0],
+              /* locals : :: */[
+                _4,
+                f[/* locals */1]
+              ],
+              /* body */f[/* body */2]
             ];
     };
   },
@@ -26823,55 +26191,96 @@ var yyact = /* array */[
     };
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 3);
-    var _4 = Parsing.peek_val(__caml_parser_env, 2);
-    var _5 = Parsing.peek_val(__caml_parser_env, 1);
+    var _3 = Parsing.peek_val(__caml_parser_env, 2);
+    var _4 = Parsing.peek_val(__caml_parser_env, 1);
     var at$1 = at(/* () */0);
     return function (c) {
-      Curry._3(_3, c, anon_table, bind_table);
+      var x = Source.$at$at(Curry._3(_3, c, anon_table, bind_table), at$1);
       return function () {
-        return /* tuple */[
-                Source.$at$at(/* record */[/* ttype */_5], at$1),
-                /* [] */0,
-                Curry._3(_4, /* TableExport */1, c[/* tables */1][/* count */1], c)
-              ];
+        return Curry._3(_4, c, x, at$1);
       };
     };
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 7);
-    var _4 = Parsing.peek_val(__caml_parser_env, 6);
-    var _5 = Parsing.peek_val(__caml_parser_env, 5);
-    var _8 = Parsing.peek_val(__caml_parser_env, 2);
-    var at$1 = at(/* () */0);
-    return function (c) {
-      var i = c[/* tables */1][/* count */1];
-      Curry._3(_3, c, anon_table, bind_table);
-      return function () {
-        var init = Curry._2(_8, c, func);
-        var size = List.length(init);
-        return /* tuple */[
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (_, _$1, at) {
+      return /* tuple */[
+              /* :: */[
+                Source.$at$at(/* record */[/* ttype */_1], at),
+                /* [] */0
+              ],
+              /* [] */0,
+              /* [] */0,
+              /* [] */0
+            ];
+    };
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    var _2 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (_, _$1, at) {
+      return /* tuple */[
+              /* [] */0,
+              /* [] */0,
+              /* :: */[
+                Source.$at$at(/* record */[
+                      /* module_name */_1[0],
+                      /* item_name */_1[1],
+                      /* idesc */Source.$at$at(/* TableImport */Block.__(1, [_2]), at)
+                    ], at),
+                /* [] */0
+              ],
+              /* [] */0
+            ];
+    };
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    var _2 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (c, x, at) {
+      var match = Curry._3(_2, c, x, at);
+      return /* tuple */[
+              match[0],
+              match[1],
+              match[2],
+              /* :: */[
+                Curry._2(_1, /* TableExport */Block.__(1, [x]), c),
+                match[3]
+              ]
+            ];
+    };
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 4);
+    var _4 = Parsing.peek_val(__caml_parser_env, 1);
+    return function (c, x, at) {
+      var init = Curry._2(_4, c, func);
+      var size = List.length(init);
+      return /* tuple */[
+              /* :: */[
                 Source.$at$at(/* record */[/* ttype : TableType */[
                         /* record */[
                           /* min */size,
                           /* max : Some */[size]
                         ],
-                        _5
-                      ]], at$1),
-                /* :: */[
-                  Source.$at$at(/* record */[
-                        /* index */Source.$at$at(i, at$1),
-                        /* offset */Source.$at$at(/* :: */[
-                              Source.$at$at(Operators.i32_const(Source.$at$at(0, at$1)), at$1),
-                              /* [] */0
-                            ], at$1),
-                        /* init */init
-                      ], at$1),
-                  /* [] */0
-                ],
-                Curry._3(_4, /* TableExport */1, c[/* tables */1][/* count */1], c)
-              ];
-      };
+                        _1
+                      ]], at),
+                /* [] */0
+              ],
+              /* :: */[
+                Source.$at$at(/* record */[
+                      /* index */x,
+                      /* offset */Source.$at$at(/* :: */[
+                            Source.$at$at(Operators.i32_const(Source.$at$at(0, at)), at),
+                            /* [] */0
+                          ], at),
+                      /* init */init
+                    ], at),
+                /* [] */0
+              ],
+              /* [] */0,
+              /* [] */0
+            ];
     };
   },
   function (__caml_parser_env) {
@@ -26900,113 +26309,154 @@ var yyact = /* array */[
     };
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 3);
-    var _4 = Parsing.peek_val(__caml_parser_env, 2);
-    var _5 = Parsing.peek_val(__caml_parser_env, 1);
+    var _3 = Parsing.peek_val(__caml_parser_env, 2);
+    var _4 = Parsing.peek_val(__caml_parser_env, 1);
     var at$1 = at(/* () */0);
     return function (c) {
-      Curry._3(_3, c, anon_memory, bind_memory);
+      var x = Source.$at$at(Curry._3(_3, c, anon_memory, bind_memory), at$1);
+      return function () {
+        return Curry._3(_4, c, x, at$1);
+      };
+    };
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (_, _$1, at) {
       return /* tuple */[
-              Source.$at$at(/* record */[/* mtype */_5], at$1),
+              /* :: */[
+                Source.$at$at(/* record */[/* mtype */_1], at),
+                /* [] */0
+              ],
               /* [] */0,
-              Curry._3(_4, /* MemoryExport */2, c[/* memories */2][/* count */1], c)
+              /* [] */0,
+              /* [] */0
             ];
     };
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 6);
-    var _4 = Parsing.peek_val(__caml_parser_env, 5);
-    var _7 = Parsing.peek_val(__caml_parser_env, 2);
-    var at$1 = at(/* () */0);
-    return function (c) {
-      var i = c[/* memories */2][/* count */1];
-      Curry._3(_3, c, anon_memory, bind_memory);
-      var size = (_7.length + 65535 | 0) / 65536 | 0;
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    var _2 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (_, _$1, at) {
       return /* tuple */[
-              Source.$at$at(/* record */[/* mtype : MemoryType */[/* record */[
-                        /* min */size,
-                        /* max : Some */[size]
-                      ]]], at$1),
+              /* [] */0,
+              /* [] */0,
               /* :: */[
                 Source.$at$at(/* record */[
-                      /* index */Source.$at$at(i, at$1),
-                      /* offset */Source.$at$at(/* :: */[
-                            Source.$at$at(Operators.i32_const(Source.$at$at(0, at$1)), at$1),
-                            /* [] */0
-                          ], at$1),
-                      /* init */_7
-                    ], at$1),
+                      /* module_name */_1[0],
+                      /* item_name */_1[1],
+                      /* idesc */Source.$at$at(/* MemoryImport */Block.__(2, [_2]), at)
+                    ], at),
                 /* [] */0
               ],
-              Curry._3(_4, /* MemoryExport */2, c[/* memories */2][/* count */1], c)
+              /* [] */0
             ];
     };
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 5);
-    var _6 = Parsing.peek_val(__caml_parser_env, 2);
-    var at$1 = at(/* () */0);
-    return function (c) {
-      var i = c[/* memories */2][/* count */1];
-      Curry._3(_3, c, anon_memory, bind_memory);
-      var size = (_6.length + 65535 | 0) / 65536 | 0;
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    var _2 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (c, x, at) {
+      var match = Curry._3(_2, c, x, at);
+      return /* tuple */[
+              match[0],
+              match[1],
+              match[2],
+              /* :: */[
+                Curry._2(_1, /* MemoryExport */Block.__(2, [x]), c),
+                match[3]
+              ]
+            ];
+    };
+  },
+  function (__caml_parser_env) {
+    var _3 = Parsing.peek_val(__caml_parser_env, 1);
+    return function (_, x, at) {
+      var size = (_3.length + 65535 | 0) / 65536 | 0;
       return /* tuple */[
-              Source.$at$at(/* record */[/* mtype : MemoryType */[/* record */[
-                        /* min */size,
-                        /* max : Some */[size]
-                      ]]], at$1),
+              /* :: */[
+                Source.$at$at(/* record */[/* mtype : MemoryType */[/* record */[
+                          /* min */size,
+                          /* max : Some */[size]
+                        ]]], at),
+                /* [] */0
+              ],
               /* :: */[
                 Source.$at$at(/* record */[
-                      /* index */Source.$at$at(i, at$1),
+                      /* index */x,
                       /* offset */Source.$at$at(/* :: */[
-                            Source.$at$at(Operators.i32_const(Source.$at$at(0, at$1)), at$1),
+                            Source.$at$at(Operators.i32_const(Source.$at$at(0, at)), at),
                             /* [] */0
-                          ], at$1),
-                      /* init */_6
-                    ], at$1),
+                          ], at),
+                      /* init */_3
+                    ], at),
                 /* [] */0
               ],
+              /* [] */0,
               /* [] */0
             ];
     };
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 4);
-    var _4 = Parsing.peek_val(__caml_parser_env, 3);
-    var _5 = Parsing.peek_val(__caml_parser_env, 2);
-    var _6 = Parsing.peek_val(__caml_parser_env, 1);
+    var _3 = Parsing.peek_val(__caml_parser_env, 2);
+    var _4 = Parsing.peek_val(__caml_parser_env, 1);
     var at$1 = at(/* () */0);
     return function (c) {
-      Curry._3(_3, c, anon_global, bind_global);
+      var x = Source.$at$at(Curry._3(_3, c, anon_global, bind_global), at$1);
+      return function () {
+        return Curry._3(_4, c, x, at$1);
+      };
+    };
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    var _2 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (c, _, at) {
       return /* tuple */[
-              function () {
-                return Source.$at$at(/* record */[
-                            /* gtype */_5,
-                            /* value */Curry._1(_6, c)
-                          ], at$1);
-              },
-              Curry._3(_4, /* GlobalExport */3, c[/* globals */5][/* count */1], c)
+              /* :: */[
+                Source.$at$at(/* record */[
+                      /* gtype */_1,
+                      /* value */Curry._1(_2, c)
+                    ], at),
+                /* [] */0
+              ],
+              /* [] */0,
+              /* [] */0
             ];
     };
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 3);
-    var _4 = Parsing.peek_val(__caml_parser_env, 2);
-    var _5 = Parsing.peek_val(__caml_parser_env, 1);
-    var at$1 = at(/* () */0);
-    return function (c) {
-      Curry._3(_3, c, anon_global, bind_global);
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    var _2 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (_, _$1, at) {
       return /* tuple */[
-              function () {
-                return Source.$at$at(/* record */[
-                            /* gtype */_4,
-                            /* value */Curry._1(_5, c)
-                          ], at$1);
-              },
+              /* [] */0,
+              /* :: */[
+                Source.$at$at(/* record */[
+                      /* module_name */_1[0],
+                      /* item_name */_1[1],
+                      /* idesc */Source.$at$at(/* GlobalImport */Block.__(3, [_2]), at)
+                    ], at),
+                /* [] */0
+              ],
               /* [] */0
             ];
     };
   },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    var _2 = Parsing.peek_val(__caml_parser_env, 0);
+    return function (c, x, at) {
+      var match = Curry._3(_2, c, x, at);
+      return /* tuple */[
+              match[0],
+              match[1],
+              /* :: */[
+                Curry._2(_1, /* GlobalExport */Block.__(3, [x]), c),
+                match[2]
+              ]
+            ];
+    };
+  },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 2);
     var _4 = Parsing.peek_val(__caml_parser_env, 1);
@@ -27058,78 +26508,7 @@ var yyact = /* array */[
       return Source.$at$at(/* record */[
                   /* module_name */_3,
                   /* item_name */_4,
-                  /* ikind */Source.$at$at(Curry._1(_5, c), at5)
-                ], at$1);
-    };
-  },
-  function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 3);
-    var _4 = Parsing.peek_val(__caml_parser_env, 2);
-    var _5 = Parsing.peek_val(__caml_parser_env, 1);
-    var at$1 = at(/* () */0);
-    return function (c) {
-      Curry._3(_3, c, anon_func, bind_func);
-      return Source.$at$at(/* record */[
-                  /* module_name */_4[0],
-                  /* item_name */_4[1],
-                  /* ikind */Source.$at$at(/* FuncImport */Block.__(0, [Curry._2(_5, c, type_)]), at$1)
-                ], at$1);
-    };
-  },
-  function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 3);
-    var _4 = Parsing.peek_val(__caml_parser_env, 2);
-    var _5 = Parsing.peek_val(__caml_parser_env, 1);
-    var at$1 = at(/* () */0);
-    var at5 = ati(5);
-    return function (c) {
-      Curry._3(_3, c, anon_func, bind_func);
-      return Source.$at$at(/* record */[
-                  /* module_name */_4[0],
-                  /* item_name */_4[1],
-                  /* ikind */Source.$at$at(/* FuncImport */Block.__(0, [inline_type(c, _5, at5)]), at$1)
-                ], at$1);
-    };
-  },
-  function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 3);
-    var _4 = Parsing.peek_val(__caml_parser_env, 2);
-    var _5 = Parsing.peek_val(__caml_parser_env, 1);
-    var at$1 = at(/* () */0);
-    return function (c) {
-      Curry._3(_3, c, anon_table, bind_table);
-      return Source.$at$at(/* record */[
-                  /* module_name */_4[0],
-                  /* item_name */_4[1],
-                  /* ikind */Source.$at$at(/* TableImport */Block.__(1, [_5]), at$1)
-                ], at$1);
-    };
-  },
-  function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 3);
-    var _4 = Parsing.peek_val(__caml_parser_env, 2);
-    var _5 = Parsing.peek_val(__caml_parser_env, 1);
-    var at$1 = at(/* () */0);
-    return function (c) {
-      Curry._3(_3, c, anon_memory, bind_memory);
-      return Source.$at$at(/* record */[
-                  /* module_name */_4[0],
-                  /* item_name */_4[1],
-                  /* ikind */Source.$at$at(/* MemoryImport */Block.__(2, [_5]), at$1)
-                ], at$1);
-    };
-  },
-  function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 3);
-    var _4 = Parsing.peek_val(__caml_parser_env, 2);
-    var _5 = Parsing.peek_val(__caml_parser_env, 1);
-    var at$1 = at(/* () */0);
-    return function (c) {
-      Curry._3(_3, c, anon_global, bind_global);
-      return Source.$at$at(/* record */[
-                  /* module_name */_4[0],
-                  /* item_name */_4[1],
-                  /* ikind */Source.$at$at(/* GlobalImport */Block.__(3, [_5]), at$1)
+                  /* idesc */Source.$at$at(Curry._1(_5, c), at5)
                 ], at$1);
     };
   },
@@ -27144,37 +26523,25 @@ var yyact = /* array */[
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 1);
     return function (c) {
-      return /* tuple */[
-              /* FuncExport */0,
-              Curry._2(_3, c, func)
-            ];
+      return /* FuncExport */Block.__(0, [Curry._2(_3, c, func)]);
     };
   },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 1);
     return function (c) {
-      return /* tuple */[
-              /* TableExport */1,
-              Curry._2(_3, c, table)
-            ];
+      return /* TableExport */Block.__(1, [Curry._2(_3, c, table)]);
     };
   },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 1);
     return function (c) {
-      return /* tuple */[
-              /* MemoryExport */2,
-              Curry._2(_3, c, memory)
-            ];
+      return /* MemoryExport */Block.__(2, [Curry._2(_3, c, memory)]);
     };
   },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 1);
     return function (c) {
-      return /* tuple */[
-              /* GlobalExport */3,
-              Curry._2(_3, c, global)
-            ];
+      return /* GlobalExport */Block.__(3, [Curry._2(_3, c, $$global)]);
     };
   },
   function (__caml_parser_env) {
@@ -27183,34 +26550,20 @@ var yyact = /* array */[
     var at$1 = at(/* () */0);
     var at4 = ati(4);
     return function (c) {
-      var match = Curry._1(_4, c);
       return Source.$at$at(/* record */[
                   /* name */_3,
-                  /* ekind */Source.$at$at(match[0], at4),
-                  /* item */match[1]
+                  /* edesc */Source.$at$at(Curry._1(_4, c), at4)
                 ], at$1);
     };
   },
-  function () {
-    return function (_, _$1, _$2) {
-      return /* [] */0;
-    };
-  },
-  function (__caml_parser_env) {
-    return Parsing.peek_val(__caml_parser_env, 0);
-  },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 1);
     var at$1 = at(/* () */0);
-    return function (k, count, _) {
-      return /* :: */[
-              Source.$at$at(/* record */[
-                    /* name */_3,
-                    /* ekind */Source.$at$at(k, at$1),
-                    /* item */Source.$at$at(count - 1 | 0, at$1)
-                  ], at$1),
-              /* [] */0
-            ];
+    return function (d, _) {
+      return Source.$at$at(/* record */[
+                  /* name */_3,
+                  /* edesc */Source.$at$at(d, at$1)
+                ], at$1);
     };
   },
   function (__caml_parser_env) {
@@ -27254,6 +26607,9 @@ var yyact = /* array */[
       return newrecord;
     };
   },
+  function (__caml_parser_env) {
+    return Parsing.peek_val(__caml_parser_env, 0);
+  },
   function (__caml_parser_env) {
     var _1 = Parsing.peek_val(__caml_parser_env, 1);
     var _2 = Parsing.peek_val(__caml_parser_env, 0);
@@ -27266,9 +26622,11 @@ var yyact = /* array */[
     var _1 = Parsing.peek_val(__caml_parser_env, 1);
     var _2 = Parsing.peek_val(__caml_parser_env, 0);
     return function (c) {
-      var match = Curry._1(_1, c);
+      var gf = Curry._1(_1, c);
       var m = Curry._1(_2, c);
-      if (m[/* imports */8] !== /* [] */0) {
+      var match = Curry._1(gf, /* () */0);
+      var globs = match[0];
+      if (globs !== /* [] */0 && m[/* imports */8] !== /* [] */0) {
         var at = List.hd(m[/* imports */8])[/* at */0];
         throw [
               Script.Syntax,
@@ -27277,11 +26635,9 @@ var yyact = /* array */[
             ];
       }
       var newrecord = m.slice();
-      newrecord[/* globals */1] = /* :: */[
-        Curry._1(match[0], /* () */0),
-        m[/* globals */1]
-      ];
-      newrecord[/* exports */9] = Pervasives.$at(match[1], m[/* exports */9]);
+      newrecord[/* globals */1] = Pervasives.$at(globs, m[/* globals */1]);
+      newrecord[/* imports */8] = Pervasives.$at(match[1], m[/* imports */8]);
+      newrecord[/* exports */9] = Pervasives.$at(match[2], m[/* exports */9]);
       return newrecord;
     };
   },
@@ -27289,10 +26645,11 @@ var yyact = /* array */[
     var _1 = Parsing.peek_val(__caml_parser_env, 1);
     var _2 = Parsing.peek_val(__caml_parser_env, 0);
     return function (c) {
-      var t = Curry._1(_1, c);
+      var tf = Curry._1(_1, c);
       var m = Curry._1(_2, c);
-      var match = Curry._1(t, /* () */0);
-      if (m[/* imports */8] !== /* [] */0) {
+      var match = Curry._1(tf, /* () */0);
+      var tabs = match[0];
+      if (tabs !== /* [] */0 && m[/* imports */8] !== /* [] */0) {
         var at = List.hd(m[/* imports */8])[/* at */0];
         throw [
               Script.Syntax,
@@ -27300,23 +26657,29 @@ var yyact = /* array */[
               "import after table definition"
             ];
       }
-      var newrecord = m.slice();
-      newrecord[/* tables */2] = /* :: */[
-        match[0],
-        m[/* tables */2]
-      ];
-      newrecord[/* elems */6] = Pervasives.$at(match[1], m[/* elems */6]);
-      newrecord[/* exports */9] = Pervasives.$at(match[2], m[/* exports */9]);
-      return newrecord;
+      return /* record */[
+              /* types */m[/* types */0],
+              /* globals */m[/* globals */1],
+              /* tables */Pervasives.$at(tabs, m[/* tables */2]),
+              /* memories */m[/* memories */3],
+              /* funcs */m[/* funcs */4],
+              /* start */m[/* start */5],
+              /* elems */Pervasives.$at(match[1], m[/* elems */6]),
+              /* data */m[/* data */7],
+              /* imports */Pervasives.$at(match[2], m[/* imports */8]),
+              /* exports */Pervasives.$at(match[3], m[/* exports */9])
+            ];
     };
   },
   function (__caml_parser_env) {
     var _1 = Parsing.peek_val(__caml_parser_env, 1);
     var _2 = Parsing.peek_val(__caml_parser_env, 0);
     return function (c) {
-      var match = Curry._1(_1, c);
+      var mf = Curry._1(_1, c);
       var m = Curry._1(_2, c);
-      if (m[/* imports */8] !== /* [] */0) {
+      var match = Curry._1(mf, /* () */0);
+      var mems = match[0];
+      if (mems !== /* [] */0 && m[/* imports */8] !== /* [] */0) {
         var at = List.hd(m[/* imports */8])[/* at */0];
         throw [
               Script.Syntax,
@@ -27324,14 +26687,18 @@ var yyact = /* array */[
               "import after memory definition"
             ];
       }
-      var newrecord = m.slice();
-      newrecord[/* memories */3] = /* :: */[
-        match[0],
-        m[/* memories */3]
-      ];
-      newrecord[/* data */7] = Pervasives.$at(match[1], m[/* data */7]);
-      newrecord[/* exports */9] = Pervasives.$at(match[2], m[/* exports */9]);
-      return newrecord;
+      return /* record */[
+              /* types */m[/* types */0],
+              /* globals */m[/* globals */1],
+              /* tables */m[/* tables */2],
+              /* memories */Pervasives.$at(mems, m[/* memories */3]),
+              /* funcs */m[/* funcs */4],
+              /* start */m[/* start */5],
+              /* elems */m[/* elems */6],
+              /* data */Pervasives.$at(match[1], m[/* data */7]),
+              /* imports */Pervasives.$at(match[2], m[/* imports */8]),
+              /* exports */Pervasives.$at(match[3], m[/* exports */9])
+            ];
     };
   },
   function (__caml_parser_env) {
@@ -27340,8 +26707,8 @@ var yyact = /* array */[
     return function (c) {
       var match = Curry._1(_1, c);
       var m = Curry._1(_2, c);
-      var func = Curry._1(match[0], /* () */0);
-      if (m[/* imports */8] !== /* [] */0) {
+      var funcs = Curry._1(match[0], /* () */0);
+      if (funcs !== /* [] */0 && m[/* imports */8] !== /* [] */0) {
         var at = List.hd(m[/* imports */8])[/* at */0];
         throw [
               Script.Syntax,
@@ -27350,11 +26717,9 @@ var yyact = /* array */[
             ];
       }
       var newrecord = m.slice();
-      newrecord[/* funcs */4] = /* :: */[
-        func,
-        m[/* funcs */4]
-      ];
-      newrecord[/* exports */9] = Pervasives.$at(match[1], m[/* exports */9]);
+      newrecord[/* funcs */4] = Pervasives.$at(funcs, m[/* funcs */4]);
+      newrecord[/* imports */8] = Pervasives.$at(match[1], m[/* imports */8]);
+      newrecord[/* exports */9] = Pervasives.$at(match[2], m[/* exports */9]);
       return newrecord;
     };
   },
@@ -27397,8 +26762,7 @@ var yyact = /* array */[
               x[/* at */0],
               "multiple start sections"
             ];
-      }
-      else {
+      } else {
         var newrecord = m.slice();
         newrecord[/* start */5] = /* Some */[x];
         return newrecord;
@@ -27432,6 +26796,13 @@ var yyact = /* array */[
       return newrecord;
     };
   },
+  function () {
+    return /* None */0;
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
+    return /* Some */[Source.$at$at(_1, at(/* () */0))];
+  },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 2);
     var _4 = Parsing.peek_val(__caml_parser_env, 1);
@@ -27440,24 +26811,45 @@ var yyact = /* array */[
             Source.$at$at(/* Textual */Block.__(0, [Source.$at$at(Curry._1(_4, empty_context(/* () */0)), at(/* () */0))]), at(/* () */0))
           ];
   },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
+    return Source.$at$at(/* Textual */Block.__(0, [Source.$at$at(Curry._1(_1, empty_context(/* () */0)), at(/* () */0))]), at(/* () */0));
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
+    return Source.$at$at(/* Textual */Block.__(0, [Source.$at$at(Curry._1(_1, empty_context(/* () */0)), at(/* () */0))]), at(/* () */0));
+  },
+  function () {
+    return /* None */0;
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 0);
+    return /* Some */[Source.$at$at(_1, at(/* () */0))];
+  },
+  function (__caml_parser_env) {
+    return Parsing.peek_val(__caml_parser_env, 0);
+  },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 3);
-    var _4 = Parsing.peek_val(__caml_parser_env, 2);
     var _5 = Parsing.peek_val(__caml_parser_env, 1);
     return /* tuple */[
             _3,
             Source.$at$at(/* Encoded */Block.__(1, [
                     "binary",
-                    _4 + _5
+                    _5
                   ]), at(/* () */0))
           ];
   },
-  function () {
-    return /* None */0;
-  },
   function (__caml_parser_env) {
-    var _1 = Parsing.peek_val(__caml_parser_env, 0);
-    return /* Some */[Source.$at$at(_1, at(/* () */0))];
+    var _3 = Parsing.peek_val(__caml_parser_env, 3);
+    var _5 = Parsing.peek_val(__caml_parser_env, 1);
+    return /* tuple */[
+            _3,
+            Source.$at$at(/* Quoted */Block.__(2, [
+                    "quote",
+                    _5
+                  ]), at(/* () */0))
+          ];
   },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 3);
@@ -27496,7 +26888,7 @@ var yyact = /* array */[
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 2);
     var _4 = Parsing.peek_val(__caml_parser_env, 1);
-    return Source.$at$at(/* AssertSoftInvalid */Block.__(2, [
+    return Source.$at$at(/* AssertUnlinkable */Block.__(2, [
                   _3[1],
                   _4
                 ]), at(/* () */0));
@@ -27504,7 +26896,7 @@ var yyact = /* array */[
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 2);
     var _4 = Parsing.peek_val(__caml_parser_env, 1);
-    return Source.$at$at(/* AssertUnlinkable */Block.__(3, [
+    return Source.$at$at(/* AssertUninstantiable */Block.__(3, [
                   _3[1],
                   _4
                 ]), at(/* () */0));
@@ -27512,22 +26904,18 @@ var yyact = /* array */[
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 2);
     var _4 = Parsing.peek_val(__caml_parser_env, 1);
-    return Source.$at$at(/* AssertUninstantiable */Block.__(4, [
-                  _3[1],
+    return Source.$at$at(/* AssertReturn */Block.__(4, [
+                  _3,
                   _4
                 ]), at(/* () */0));
   },
   function (__caml_parser_env) {
-    var _3 = Parsing.peek_val(__caml_parser_env, 2);
-    var _4 = Parsing.peek_val(__caml_parser_env, 1);
-    return Source.$at$at(/* AssertReturn */Block.__(5, [
-                  _3,
-                  _4
-                ]), at(/* () */0));
+    var _3 = Parsing.peek_val(__caml_parser_env, 1);
+    return Source.$at$at(/* AssertReturnCanonicalNaN */Block.__(5, [_3]), at(/* () */0));
   },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 1);
-    return Source.$at$at(/* AssertReturnNaN */Block.__(6, [_3]), at(/* () */0));
+    return Source.$at$at(/* AssertReturnArithmeticNaN */Block.__(6, [_3]), at(/* () */0));
   },
   function (__caml_parser_env) {
     var _3 = Parsing.peek_val(__caml_parser_env, 2);
@@ -27633,6 +27021,16 @@ var yyact = /* array */[
   function (__caml_parser_env) {
     return Parsing.peek_val(__caml_parser_env, 1);
   },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    return /* :: */[
+            Source.$at$at(/* Module */Block.__(0, [
+                    /* None */0,
+                    _1
+                  ]), at(/* () */0)),
+            /* [] */0
+          ];
+  },
   function (__caml_parser_env) {
     var _1 = Parsing.peek_val(__caml_parser_env, 0);
     return /* :: */[
@@ -27641,7 +27039,14 @@ var yyact = /* array */[
           ];
   },
   function (__caml_parser_env) {
-    return Parsing.peek_val(__caml_parser_env, 1)[1];
+    return Parsing.peek_val(__caml_parser_env, 1);
+  },
+  function (__caml_parser_env) {
+    var _1 = Parsing.peek_val(__caml_parser_env, 1);
+    return /* tuple */[
+            /* None */0,
+            _1
+          ];
   },
   function (__caml_parser_env) {
     throw [
@@ -27667,19 +27072,19 @@ var yytables = /* record */[
   /* actions */yyact,
   /* transl_const */yytransl_const,
   /* transl_block */yytransl_block,
-  /* lhs */'\xff\xff\x04\0\x04\0\x05\0\x05\0\x06\0\x07\0\x07\0\b\0\t\0\t\0\t\0\t\0\x0b\0\r\0\f\0\f\0\x0e\0\x10\0\x10\0\x10\0\x0f\0\x0f\0\x11\0\x11\0\x12\0\x12\0\n\0\x13\0\x13\0\x14\0\x14\0\x15\0\x15\0\x16\0\x16\0\x17\0\x17\0\x17\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x19\0\x19\0\x19\0\x19\0\x1b\0\x1a\0\x1d\0\x1d\0\x1d\0\x1d\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1c\0\x1c\0\x1e\0\x1e\0 \0!\0!\0!\0!\0"\0"\0"\0#\0#\0#\0#\0%\0%\0&\0&\0\'\0\'\0)\0)\0*\0*\0*\0+\0+\0,\0,\0,\0,\0,\0-\0-\0-\0-\0-\0-\0.\0/\0/\0/\0/\x000\0(\0(\0$\x001\x001\x002\x003\x003\x003\x003\x003\x003\x003\x003\x003\x003\x003\x004\x004\x005\x005\x006\x006\x008\x008\x008\x008\x008\x008\x008\x008\x008\x009\x009\x009\x009\x009\0;\0;\0:\0:\0:\0:\0<\x007\x007\0\x01\0\x02\0\x03\0\0\0\0\0\0\0',
-  /* len */"\x02\0\0\0\x02\0\0\0\x02\0\x01\0\x01\0\x04\0\x04\0\0\0\x05\0\x05\0\x06\0\x02\0\x01\0\x01\0\x02\0\x04\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\x02\0\0\0\x01\0\x01\0\0\0\x01\0\0\0\x01\0\0\0\x01\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x02\0\x02\0\x03\0\x01\0\x02\0\x02\0\x01\0\x01\0\x02\0\x02\0\x02\0\x02\0\x02\0\x03\0\x03\0\x01\0\x01\0\x02\0\x01\0\x01\0\x01\0\x01\0\x01\0\x05\0\x05\0\x05\0\b\0\x02\0\x03\0\x02\0\x03\0\x03\0\x04\0\b\0\x04\0\t\0\x05\0\x03\0\x02\0\0\0\x02\0\0\0\x02\0\x01\0\x01\0\x05\0\x05\0\x06\0\x01\0\x05\0\x06\0\x07\0\x06\0\x06\0\x05\0\x04\0\x01\0\x06\0\x05\0\x06\0\n\0\x06\0\x05\0\x06\0\t\0\b\0\x07\0\x06\0\x05\0\x05\0\x05\0\x05\0\x05\0\x06\0\x06\0\x06\0\x06\0\x06\0\x06\0\x05\0\x04\0\x04\0\x04\0\x04\0\x05\0\0\0\x01\0\x04\0\x04\0\x05\0\x04\0\0\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x05\0\x06\0\0\0\x01\0\x06\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x04\0\x05\0\x05\0\x01\0\x01\0\x01\0\x05\0\x01\0\0\0\x02\0\x05\0\x05\0\x05\0\x04\0\x04\0\0\0\x02\0\x02\0\x01\0\x02\0\x02\0\x02\0\x02\0",
-  /* defred */"\0\0\0\0\0\0\0\0\0\0\0\0\xaf\0\xa0\0\x9e\0\x9f\0\0\0\xa2\0\0\0\xb0\0\xad\0\0\0\xb1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xa4\0\xac\0\xae\0\x92\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x9b\0\0\0\0\0\0\0\0\0\0\0\xa8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\0\x8a\0\x87\0\x8b\0\x88\0\x86\0\x8d\0\x8e\0\x85\0\x8c\0\x8f\0\xa5\0\xa1\0\0\0\x94\0\x95\0\x96\0\x97\0\x98\0\0\0\x9a\0\xab\0\x99\0\x9c\0\x9d\0\xa6\0\xa7\0\x02\0\x90\0\x1b\0\x1a\0\0\0\x15\0\x16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0a\0\0\0\0\0\0\0\x01\0\0\0\0\0\x93\0\x12\0\x13\0\x14\0\0\0\0\0(\0/\0\0\0\0\x000\0\0\0\0\0\0\0\0\0\0\0\0\0,\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0=\0>\0<\0?\0'\x008\x009\0;\0\0\0\0\0$\0%\0&\0Y\0\0\0U\0\0\0\0\0\x83\0\0\0\x81\0\0\0\x06\0\0\0\0\0\0\0\0\0\0\0\x7f\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\0\0\0\0\0\0\0\0\xa9\0\0\0\0\0\0\0\0\0\0\0\0\0\x1d\0\0\0\0\0\0\0)\0*\0\0\0-\0.\x001\x002\x003\x004\x005\0!\0\0\0\0\0:\0\0\0\0\0\0\0Q\0_\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x82\0\0\0T\0\0\0\0\0\0\0\0\0\0\0\x05\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0F\0E\0\0\0\x18\0c\0\x01\0\0\0\x0e\0\0\0\0\0\0\0g\0\0\0\0\0\0\0\0\0\0\0\0\0}\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0+\0#\x006\x007\0]\0\0\0^\0\0\0\0\0t\0s\0\b\0\0\0l\0\0\0w\0\x10\0\0\0d\0\r\0u\0G\0\0\0H\0`\0S\0b\0\0\0\x01\0h\0v\0f\0\0\0\0\0\0\0\0\0r\0\0\0\0\0\0\0\0\0\x11\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\x80\0D\0\0\0\0\0\0\0\0\0\\\0\0\0\0\0\0\0\x07\0k\0\0\0\0\0\0\0I\0\0\0\0\0\0\0\0\0\0\0\0\0y\0|\0z\0{\0W\0\0\0\0\0V\0Z\0\0\0x\0\x1f\0@\0B\0\0\0A\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0j\0\0\0\0\0\0\0\0\0\0\0\0\0X\0[\0\0\0\x0b\0\0\0\n\0\0\0\0\0\0\0N\0i\0n\0m\0q\0o\0p\0\0\0\f\0e\0\0\0\0\0C\0\0\0\0\0\0\0\0\0\0\0\0\0J\0\0\0L\0",
-  /* dgoto */'\x04\0\x06\0\r\0\x10\0V\x001\x01\f\x01\xc4\0\x85\0\xff\0\x7f\0\r\x01\x0e\x01\x1d\x01\xb4\0\xd2\0\x96\0\xd3\0\x80\0\xe5\0\x88\x01\xf3\x007\x01\xb5\0\xb6\0\xb7\0\xb8\x002\x01\xb9\0\xd0\0\x15\x01u\x01\x06\x01\xba\0\xbb\x009\0\xbc\0\x8c\0:\0;\0\xc9\0<\0=\0>\0"\x01?\0\xbd\0\xdc\0@\0A\0B\0C\0\x07\0%\0\b\0M\0\t\0\n\0\x0b\0\f\0N\0',
-  /* sindex */'\xd4\0\x17\xff\x17\xff.\xff\0\0a\xff\0\0\0\0\0\0\0\0\x17\xff\0\0@\0\0\0\0\0"\xff\0\0l\0i\xffi\xffw\xffi\xffi\xff.\xff.\xff.\xff.\xffp\xffp\xff~\xffp\xffi\xffi\xff\0\0\0\0\0\0\0\0\xab\xff\x17\xffi\xff\x92\xff\xac\xff\xc9\xff\xd9\xff\xf6\xff\xf9\xff\f\xff\xa1\xff\xaf\xff\xfc\xfe\xfb\xff\xfe\xff\x15\0\x1c\x001\xff\0\0\x17\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\xb1\xff\xb6\xff\x11\0\xa1\xff-\x007\0=\0?\0D\0/\0J\0\xa1\xff\0\0K\0S\0d\0e\0n\0\0\0[\xffR\0\xb7\xff\xc6\xffR\0R\0\x8f\xffR\0\x8f\xffv\0w\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0y\0\0\0\0\0\0\0\0\0\0\0\x0b\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x02\0\0\0\0z\0V\0\x8a\0\x95\0\xe9\xff\x97\0W\x03\x98\0\0\0\xb7\xff\x99\0\x98\0\0\0\x9b\0\xa1\0\0\0\0\0\0\0\0\0\xbb\0\xd4\x02\0\0\0\0R\0R\0\0\0R\0\xb7\xff\xb7\xff\xb7\xff\xb7\xff\xb7\xff\0\0\xb7\xff\xb7\xff\xb7\xff\xb7\xff\xb7\xff\xa5\0\xa5\0\x0b\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0<\x02b\x02\0\0\0\0\0\0\0\0\xbd\0\0\0\x88\x02\xbf\0\0\0\xc7\0\0\0\xd7\0\0\0\r\xffb\x02\xed\xff\xed\xff\xcd\xff\0\0u\xff\xea\0R\0R\0R\0b\x02\xe3\0\xe4\0\xb7\xff\xb7\xff\xec\0\x98\xff\xfe\0\xea\0\xea\0\0\0\x7f\xff\b\x01\xfe\xfe\t\x01\0\0\xb7\xff\x12\0\xe7\0\x12\0\x0e\x01\x10\x01\0\0\xe7\0\xe7\0\xe7\0\0\0\0\0\xb7\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xfa\0\xfa\0\0\x001\x03#\x01\xef\x03\0\0\0\0\x0b\x03<\x02-\x01\xe7\xff.\x01/\x01\x99\xff0\x01\0\0<\x01\0\0I\x01U\x01b\x02T\x01^\x01\0\0W\x01o\x01[\x01y\x01\xe7\0\xe7\0\xe7\0z\x01\xe3\0\0\0\0\0{\x01\0\0\0\0\0\0P\x01\0\0\x82\x01\x84\x01\xa9\xff\0\0d\xff\x85\x01\xb7\xff\xb7\xff\xb7\xff\xb7\xff\0\0\x95\x01\xe7\0\x9f\x01b\x01\xa0\x01\xa1\x01\xa6\x01\xaa\x01\xab\x01b\x02\xb7\x01\xe6\xff\xc1\x01\0\0\0\0\0\0\0\0\0\0\xc6\x01\0\0\x12\0\xe7\0\0\0\0\0\0\0\xc7\x01\0\0\xc8\x01\0\0\0\0\x80\x01\0\0\0\0\0\0\0\0\xcf\x01\0\0\0\0\0\0\0\0\xad\xff\0\0\0\0\0\0\0\0R\0R\0R\0R\0\0\0\xd0\x01\xd1\x01\xe1\x01\xeb\x01\0\0\0\0<\x02\xec\x01\xae\x02\xae\x02\xed\x01\xee\x01\0\0\0\0R\0R\0R\0R\0\0\0\xf6\x01\xf4\x01\xf7\x01\0\0\0\0\xb7\xff}\x03\b\x02\0\0\x11\x02\xbb\xff\xbf\0\xed\xff\xea\0\xea\0\0\0\0\0\0\0\0\0\0\0<\x02\xa3\x03\0\0\0\0\xae\x02\0\0\0\0\0\0\0\0b\x02\0\0\xc7\0\x12\x02\xc7\0\x13\x02b\x02\xc9\x03\xe3\0\0\0\x14\x02\x1a\x02\x1c\x02\x1d\x02-\x027\x02\0\0\0\x004\x02\0\0\xc7\0\0\x009\x02:\x02b\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0R\0\0\0\0\0\x17\x02@\x02\0\x005\x02C\x02b\x02L\x02]\x02b\x02\0\0^\x02\0\0',
-  /* rindex */"\0\0M\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0O\xff\x14\0\0\0w\0w\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0w\0\xc2\xff\0\0\0\0\0\0\0\0_\x02`\x02f\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0h\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0_\x02_\x02_\x02_\x02_\x02_\x02_\x02_\x02_\x02_\x02\0\0\0\0\0\0h\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0h\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0~\x01\0\0\0\0\xf2\xffh\xff\0\0)\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83\xff\0\0\0\0\0\0y\x02k\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0M\0\x16\0\0\0M\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x9a\0\x9a\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i\x02t\xff\0\0\0\0\0\0\0\0\0\0\0\0i\x02\x83\x02\0\0\x83\x02\0\0\0\0\0\0\0\0i\x02\0\0\0\0\0\0\0\0\0\0\0\0s\0\xf3\xffs\0i\x02\x84\x02\0\0y\x02\xc0\0\0\0\0\0\x8e\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86\x02\x86\x02\x86\x02\0\0\0\0\0\0\xa4\x01X\x01\xa4\x01\0\0\0\0\xc0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xe6\0\xe6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i\x02\0\0\xf7\xff\0\0\0\0\0\0\0\0\0\0\xca\x01\x89\x02\xca\x01\0\0\x84\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\f\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0t\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x86\x02\x86\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0<\0\xf2\xff\x95\x02\x95\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0i\x02\0\0i\x02i\x02\0\0\0\0\0\0\0\x002\x012\x01\xf0\x012\x01\0\0\0\0\0\0\0\0\0\0\0\0y\x02\0\0\0\0\0\0\0\0\0\0\x83\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i\x02\0\0\0\0\0\0i\x02\0\0\0\0\0\0\0\0\x8a\x02\0\0\x83\x02\0\0\x83\x02\0\0i\x02\0\0\xaf\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x83\x02\0\0\0\0\0\0i\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\x002\x01\0\0\0\0\x8f\x02\0\0\0\0\0\0\x9f\x02i\x02\0\0\0\0i\x02\0\0\0\0\0\0",
-  /* gindex */"\0\0\0\0\0\0\0\0x\xffD\xff\xa5\x02Q\xff.\x03F\xff\xa7\xffG\xffH\xff3\xffL\xff\xbc\xff\n\x03P\xff\xb2\xff\x80\xff\xbd\xfe\f\x03\xc4\x02\0\0\x82\xff\0\0\xa6\xffV\xffN\xff\0\0\xa8\x02\0\0B\xffR\xff\xca\xfe\0\0\xca\xff\xb5\xff\0\0\0\x002\x03\0\0\0\0\0\0\0\0\0\0\xe3\xff\0\0\0\0\0\0\0\0\xac\0t\0\x96\0\xbe\0\xf0\xff\0\0\xbc\x03\0\0!\0\0\0",
-  /* tablesize */1335,
-  /* table */'\x86\0\xa3\0\x8b\0\xf9\0\x8b\0\x02\x01\xf7\0\xd9\0\xfc\0\0\x01\x1e\x01\xcf\0\x87\0\x88\0\xfd\0\x8d\0\x13\x01\x0f\x01\x05\x01\x8f\0\x83\0\x04\x01\b\x01\t\x01\x8a\0\xcf\0\x8e\0\xe6\0\x05\x01\xe7\0\x1c\x01\x1c\x01\x05\0\x17\x01\x18\x01*\x01,\x01-\x01\x89\x01\x8a\x01\x8b\x01#\x01\x19\0!\0\x83\x01\x84\x01\x12\0$\x01\x8b\0%\x01\x19\0&\x01\x8b\0T\0n\0\x0f\0\x15\0\x16\x005\x01U\x003\x014\x01v\0\xd1\0"\0\xe4\0\xe4\0\xd8\0\xe4\0\xe2\0\xe3\0D\0\x15\0\x16\0C\x01\x10\x01\x11\x01\x12\x01:\x01\x9b\x01\x1f\x01\xc5\0\xc8\0\x91\0\x12\0K\x01\x05\x01\xd5\0\x91\0\x91\0\xe8\0\xe9\0\xea\0\xeb\0\xec\0|\0\xed\0\xee\0\xef\0\xf0\0\xf1\0}\0J\x01\xaf\x01L\x01\x19\0\xc6\0\xca\0#\0_\x01$\0\x19\0\xd7\0\x19\0\xe4\0\xe4\0\xe4\0\x14\x01\n\x01\x11\0\xcf\0.\0\xcf\0\'\0\x0b\x01\xcf\0P\0g\x01m\x01o\x01P\0|\0~\0P\0+\x011\0.\x01 \x01~\0*\0+\0,\0-\0U\x01\x81\x002\0P\x01\x12\0\x82\0V\x01F\0W\x01\x89\0X\x01(\x01\x13\0\x14\0\x15\0\x16\0\x17\0\x18\0\x19\0\x1a\0\x1b\0\x1c\0\x1d\0\x1e\0\x1f\0 \0&\0L\0(\0)\0|\0\x99\x017\0G\0|\0\x80\x01T\x018\x005\x006\0v\x01\x81\0O\0\x14\x01k\0\x82\0E\0\x95\x01|\0l\0\x98\x01\x8f\x01\x1c\x01\x96\x01\x94\x01\x91\0<\x01=\x01w\x01\x97\x01~\0\x91\0H\0\x1a\x01\x84\0\xe2\0\xe3\0\x9d\x01\x9a\x01\x9f\x01\x01\0\x02\0\x03\0\x9c\x01/\x000\x003\x004\0I\0\xa1\x01Z\x01[\x01\\\x01]\x01n\x01\xab\x01a\0b\0c\0d\0e\0f\0g\0h\0i\0j\0\xc2\0\xae\x01t\x01\xc3\0\xc2\0i\x01\xcf\0\x07\x01j\x01\x19\0\x1c\0J\0\x19\0\x1c\0K\0\x0f\0P\0\xb4\x01\x0f\0Q\0\xb7\x01\xcf\0\xe2\0\xe3\0x\x01y\x01z\x01{\x01\xa3\0\x93\0\x94\0\x95\0\x87\x01\x87\x01\x87\x01\x87\x01\xcf\0\xde\0<\x01=\x01~\0)\x01R\0\x92\x01m\0\x1c\0\x91\0\x91\0\x1c\0S\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\x008\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0o\0\xa3\x01\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0p\0W\0X\0Y\0\x19\0\x19\0q\0Z\0r\0[\0\\\0]\0^\0s\0_\0`\0\x87\x01t\0\x1c\0u\0w\0\x1c\0~\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0x\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0y\0z\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0{\0\x1c\0\x90\0\x91\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\xbf\0\x1c\0\x92\0\xbe\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\xc0\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x1c\0\x84\0\xda\0\xc7\0\x89\0\xd4\0 \0 \0 \0 \0 \0 \0 \0\xdb\0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0 \0\x1c\0 \0 \0 \0 \0 \0 \0 \0 \0 \0\xdd\0\xf2\0\xfa\0\xfe\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x01\x01\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x03\x01 \0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\x17\0\n\x01\xf8\0)\x01\x16\x01"\0"\0"\0"\0"\0"\0"\0\x19\x01"\0"\0"\0"\0"\0"\0"\0"\0"\0"\0"\0"\0"\0"\0"\0"\0\x1b\x01\x17\0"\0"\0"\0"\0"\0"\0"\0"\0!\x01/\x01\'\x010\x01\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\x006\x01\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\x009\x01"\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0;\x01>\x01?\x01@\x01\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0A\x01\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0B\x01\x03\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x04\x01D\x01E\x01F\x01\x03\0\x0b\x01\x03\0\x03\0\x03\0\x03\0\x03\0a\x01\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0G\x01\x1e\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0I\x01M\x01O\x01Q\x01\x19\0\x19\0\x19\0\x19\0\x19\0R\x01\x19\0S\x01Y\x01\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0^\x01\x03\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0`\x01b\x01c\x01d\x01\x03\0e\x01\x03\0\x03\0\x03\0\x03\0\x03\0r\x01f\x01\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0h\x01\x19\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0k\x01l\x01p\x01q\x01\x03\0\x03\0\x03\0\x03\0\x03\0s\x01\x03\0|\x01}\x01\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0~\x01\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x7f\x01\x81\x01\x85\x01\x86\x01\x1e\0\x8d\x01\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x8c\x01\x8e\x01\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x91\x01\x03\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x1e\0\x93\x01\x9e\x01\xa0\x01\xa4\x01\x97\0\xb0\x01\x98\0\x99\0\x9a\0\xa5\x01\x9b\0\xa6\x01\xa7\x01\x9c\0\x9d\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\xa8\x01\x1e\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\xa9\x01\xaa\x01\xac\x01\xad\x01\xf6\0\xb2\x01\x98\0\x99\0\x9a\0\xb1\x01\x9b\0\xb3\x01\xa3\0\x9c\0\x9d\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\xb5\x01\xb3\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\xb6\x01\xb8\x01\x84\0\xa3\0\xf8\0~\0\x98\0\x99\0\x9a\0\x91\0\x9b\0\xaa\0P\0\x9c\0\x9d\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\x17\0\xb3\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\t\0R\0\x7f\0\x03\0\xfb\0\x03\0\x98\0\x99\0\x9a\0\x19\0\x9b\0P\0K\0\x9c\0\x9d\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0M\0\xb3\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0H\x01\xc1\0\xf5\0\xf4\0\x82\x018\x01\x98\0\x99\0\x9a\0N\x01\x9b\0\x0e\0\xd6\0\x9c\0\x9d\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\0\0\xb3\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\0\0\0\0\0\0\0\0\0\0\0\0\x98\0\x99\0\xcb\0\0\0\xcc\0\0\0\0\0\x9c\0\xcd\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\0\0\xb3\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\0\0\0\0\xde\0\xdf\0\xe0\0\xe1\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xe2\0\xe3\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x98\0\x99\0\xcb\0\0\0\xcc\0\0\0\xb3\0\x9c\0\xcd\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\0\0\0\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\0\0\0\0\xde\0\xdf\0\xe0\0\xe1\0\x98\0\x99\0\xcb\0\0\0\xcc\0\0\0\0\0\x9c\0\xcd\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\0\0\xb3\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\0\0\0\0\0\0\xdf\0\xe0\0\xe1\0\x98\0\x99\0\xcb\0\0\0\xcc\0\0\0\0\0\x9c\0\xcd\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\0\0\xb3\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\0\0\0\0\0\0\0\0\0\0\0\0\x98\0\x99\0\xcb\0\0\0\xcc\0\x90\x01\xce\0\x9c\0\xcd\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\0\0\xb3\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\0\0\0\0\0\0\0\0\0\0\0\0\x98\0\x99\0\xcb\0\0\0\xcc\0\0\0\0\0\x9c\0\xcd\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\0\0\xb3\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\0\0\0\0\0\0\0\0\0\0\xe1\0\x98\0\x99\0\xcb\0\0\0\xcc\0\xa2\x01\0\0\x9c\0\xcd\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\0\0\xb3\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\0\0\0\0\0\0\0\0\0\0\0\0\x98\0\x99\0\xcb\0\0\0\xcc\0\0\0\0\0\x9c\0\xcd\0\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\xa3\0\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\xa9\0\xaa\0\0\0\xb3\0\xab\0\xac\0\xad\0\xae\0\xaf\0\xb0\0\xb1\0\xb2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xb3\0',
-  /* check */"Y\0\0\0\\\0\xb5\0^\0\xbf\0\xb4\0\x8f\0\xbc\0\xbd\0\xd7\0\x89\0Z\0[\0\xbc\0]\0\xce\0\xca\0\xc4\0^\0X\0\b\x01\xc5\0\xc6\0\\\0\x97\0^\0\x9b\0\xce\0\x9d\0\xd6\0\xd7\0\t\x01\xd1\0\xd2\0\xdf\0\xe0\0\xe1\0i\x01j\x01k\x01+\x01\x01\x01\n\0b\x01c\x012\x011\x01\x8a\x003\x01\t\x015\x01\x8e\0\x04\x01F\0\t\x01<\x01=\x01\xea\0\n\x01\xe6\0\xe7\0N\0\x8a\0\0\0\x9a\0\x9b\0\x8e\0\x9d\x008\x019\x01&\0<\x01=\x01\b\x01\xcb\0\xcc\0\xcd\0\xfc\0\x85\x01\xd8\0\x87\0\x88\0\x04\x012\x01\x11\x01\b\x01\x8d\0\t\x01\n\x01\x9e\0\x9f\0\xa0\0\xa1\0\xa2\0\x04\x01\xa4\0\xa5\0\xa6\0\xa7\0\xa8\0\n\x01\x10\x01\xaa\x01\x12\x01\x01\x01\x87\0\x88\0\0\0)\x01\x05\x01\x07\x01\x8d\0\t\x01\xcb\0\xcc\0\xcd\0\xcf\0\x01\x01\x03\0\xf6\0\t\x01\xf8\0\x04\x01\x07\x01\xfb\0\n\x011\x01<\x01=\x01\x0e\x01\x04\x01\x01\x01\x11\x01\xdf\0\t\x01\xe1\0\n\x01\x07\x01\x17\0\x18\0\x19\0\x1a\0+\x01\x01\x01\x1d\0\x1a\x012\x01\x05\x011\x01\x04\x013\x01\t\x015\x01\xde\0:\x01;\x01<\x01=\x01>\x01?\x01@\x01A\x01B\x01C\x01D\x01E\x01F\x01G\x01\x13\0\t\x01\x15\0\x16\0\x04\x01{\x01\x04\x01\x04\x01\x04\x01`\x01\n\x01\t\x01\x1f\0 \0\n\x01\x01\x01\n\x01\x14\x01\n\x01\x05\x01'\0x\x01\x04\x01\n\x01z\x01r\x01{\x01x\x01\n\x01\x04\x01.\x01/\x01Q\x01y\x01\x05\x01\n\x01\x04\x016\x01\t\x018\x019\x01\x8c\x01\x81\x01\x8e\x01\x01\0\x02\0\x03\0\x8a\x01\x1b\0\x1c\0\x1d\0\x1e\0\x04\x01\x90\x01#\x01$\x01%\x01&\x01<\x01\x9e\x019\0:\0;\0<\0=\0>\0?\0@\0A\0B\0\x06\x01\xa2\x01K\x01\t\x01\x06\x01\x0e\x01s\x01\t\x01\x11\x01\x06\x01\x06\x01\x04\x01\t\x01\t\x01\x04\x01\x07\x01\x04\x01\xb2\x01\n\x01\x04\x01\xb5\x01\x82\x018\x019\x01U\x01V\x01W\x01X\x01\n\x01\x01\x01\x02\x01\x03\x01h\x01i\x01j\x01k\x01\x91\x01-\x01.\x01/\x01\x05\x01\x06\x01\x04\x01t\x01\n\x01\x06\x01\t\x01\n\x01\t\x01\x04\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\t\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\x92\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\n\x01+\x01,\x01-\x01\t\x01\n\x01\n\x011\x01\n\x013\x014\x015\x016\x01\n\x018\x019\x01\xaa\x01#\x01\x06\x01\n\x01\n\x01\t\x01\x05\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\n\x01H\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\n\x01\x06\x01\x04\x01\x04\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01+\x01\x0f\x01\n\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\t\x01\x04\x01\t\x01\t\x01\t\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\t\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01H\x01\"\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\n\x01!\x01\n\x01\t\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\t\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\x01\x01\t\x01\x06\x01\n\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\n\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\t\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\t\x01\x04\x01\n\x01\x04\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\"\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\n\x01\n\x01\n\x01\n\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\x06\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\b\x01\n\x01\x01\x01\t\x01\t\x01\x07\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\x06\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\n\x01\n\x01\n\x016\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\n\x01\x0f\x01\n\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\n\x01\n\x01\n\x01\x06\x01\t\x01\x04\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x014\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\x0e\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\x0e\x01\n\x01\n\x01\n\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\t\x01\x0f\x01\n\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\n\x01\n\x01\n\x01\n\x01\t\x01\x06\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\n\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\t\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\n\x01\n\x01\n\x01\n\x01\t\x01\t\x01\x0b\x01\f\x01\r\x01\n\x01\x0f\x01\n\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\n\x01\x0e\x01\n\x01\n\x01\t\x01\x11\x01\x0b\x01\f\x01\r\x01\n\x01\x0f\x01\t\x01\0\0\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\x11\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\n\x01\n\x01\n\x01\n\x01\t\x01\x01\x01\x0b\x01\f\x01\r\x01\n\x01\x0f\x01\n\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\n\x01\n\x01\x01\x01\n\x01\t\x01\t\x01\x0b\x01\f\x01\r\x01\x01\x01\x0f\x01\x0e\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01H\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\x0e\x01\x86\0\xab\0\xaa\0\t\x01\xf4\0\x0b\x01\f\x01\r\x01\x14\x01\x0f\x01\x02\0\x8d\0\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xffH\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\xff\xff\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xffH\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\xff\xff\xff\xff-\x01.\x01/\x010\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff8\x019\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\xff\xffH\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xff\xff\xff#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\xff\xff\xff\xff-\x01.\x01/\x010\x01\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\xff\xff\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xffH\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\xff\xff\xff\xff\xff\xff.\x01/\x010\x01\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\xff\xff\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xffH\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\x10\x017\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xffH\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\xff\xff\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xffH\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff0\x01\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\x10\x01\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xffH\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\xff\xff\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xffH\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xffH\x01",
+  /* lhs */"\xff\xff\x04\0\x05\0\x05\0\x06\0\x06\0\x07\0\b\0\b\0\t\0\n\0\n\0\n\0\n\0\f\0\x0e\0\r\0\r\0\x0f\0\x11\0\x11\0\x11\0\x10\0\x10\0\x12\0\x12\0\x13\0\x13\0\x0b\0\x14\0\x14\0\x15\0\x15\0\x16\0\x16\0\x17\0\x17\0\x18\0\x18\0\x18\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x19\0\x1a\0\x1a\0\x1a\0\x1a\0\x1e\0\x1c\0\x1c\0\x1b\0\x1f\0\x1f\0\x1f\0\x1f\0!\0!\0\"\0\"\0\"\0\x1d\0\x1d\0 \0 \0#\0$\0%\0%\0%\0%\0%\0(\0(\0(\0*\0*\0&\0&\0&\0+\0+\0,\0,\0,\0-\0-\0.\0.\0/\x000\x000\x000\x000\x001\x001\x002\x003\x003\x003\x003\x004\x005\x005\x005\x006\x006\x006\x006\x006\x007\0'\x008\x008\x008\x008\x009\0)\0:\0:\0;\0<\0<\0=\0=\0=\0=\0=\0=\0=\0=\0=\0=\0>\0>\0?\0@\0A\0B\0B\0C\0C\0C\0D\0D\0F\0F\0F\0F\0F\0F\0F\0F\0F\0G\0G\0G\0G\0G\0I\0I\0H\0H\0H\0H\0J\0E\0E\0\x01\0\x01\0\x02\0\x03\0\x03\0\0\0\0\0\0\0",
+  /* len */"\x02\0\x01\0\0\0\x02\0\0\0\x02\0\x01\0\x01\0\x04\0\x04\0\0\0\x05\0\x05\0\x06\0\x02\0\x01\0\x01\0\x02\0\x04\0\x01\0\x01\0\x01\0\x01\0\x01\0\0\0\x02\0\0\0\x01\0\x01\0\0\0\x01\0\0\0\x01\0\0\0\x01\0\0\0\x01\0\x01\0\x01\0\x01\0\x01\0\x01\0\x02\0\x02\0\x03\0\x01\0\x02\0\x02\0\x01\0\x01\0\x02\0\x02\0\x02\0\x02\0\x02\0\x03\0\x03\0\x01\0\x01\0\x02\0\x01\0\x01\0\x01\0\x01\0\x01\0\x05\0\x05\0\x05\0\b\0\x04\0\x02\0\x01\0\x03\0\x02\0\x03\0\x03\0\x03\0\x02\0\x01\0\x02\0\b\0\x04\0\0\0\x02\0\0\0\x02\0\x01\0\x05\0\x02\0\x01\0\x03\0\x02\0\x02\0\x01\0\x05\0\x06\0\0\0\x05\0\x01\0\x05\0\x06\0\x01\0\x05\0\x01\0\x05\0\x06\0\x04\0\x01\0\x06\0\x05\0\x05\0\x01\0\x02\0\x02\0\x05\0\x06\0\x05\0\x05\0\x01\0\x02\0\x02\0\x04\0\x05\0\x02\0\x02\0\x02\0\x05\0\x05\0\x05\0\x05\0\x05\0\x06\0\x05\0\x04\0\x04\0\x04\0\x04\0\x05\0\x04\0\x04\0\x05\0\x04\0\0\0\x01\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\x02\0\0\0\x01\0\x05\0\x01\0\x01\0\0\0\x01\0\x01\0\x06\0\x06\0\x06\0\x05\0\x05\0\x05\0\x05\0\x05\0\x05\0\x04\0\x04\0\x05\0\x05\0\x01\0\x01\0\x01\0\x05\0\x01\0\0\0\x02\0\x05\0\x05\0\x05\0\x04\0\x04\0\0\0\x02\0\x02\0\x02\0\x01\0\x02\0\x02\0\x02\0\x02\0\x02\0",
+  /* defred */"\0\0\0\0\0\0\0\0\0\0\0\0\xc2\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x9e\0\xa1\0\0\0\xb1\0\xaf\0\xb0\0\0\0\xb3\0\0\0\0\0\xc3\0\xbf\0\0\0\xc4\0\x9d\0\x8f\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x94\0\x95\0\x92\0\x96\0\x93\0\x91\0\x98\0\x99\0\x90\0\x97\0\xbe\0\xb5\0\xbd\0\0\0\xc0\0\xc1\0\x1c\0\x1b\0\0\0\x16\0\x17\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0k\0\0\0\0\0\0\0\x02\0\x01\0\0\0\0\0\x9b\0\0\0\xa0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0)\x000\0\0\0\0\x001\0\0\0\0\0\0\0\0\0\0\0\0\0-\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0>\0?\0<\0=\0@\0(\x009\0:\0\0\0\0\0%\0&\0'\0g\0\0\0Y\0\0\0\0\0b\0e\0\x8d\0\0\0\x8b\0\0\0\x07\0\0\0\0\0\0\0\0\0\0\0\0\0\x06\0\0\0\0\0o\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x0f\0v\0\0\0\0\0\0\0\x02\0\0\0\0\0\0\0\0\0\x02\0\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xab\0\xac\0\0\0\0\0\0\0\0\0\0\0\xb9\0\0\0\0\0\0\0\0\0\0\0\0\0\x1e\0\0\0\0\0\0\0*\0+\0\0\0.\0/\x002\x003\x004\x005\x006\0\"\0\0\0\0\0\x13\0\x14\0\x15\0;\0\0\0X\0\0\0S\0W\0\0\0\0\0[\0]\0\\\0\0\0\0\0\x8c\0\0\0V\0{\0\0\0|\0}\0z\0\x11\0\0\0\x0e\0p\0q\0n\0\0\0\0\0\0\0\0\0\0\0I\0H\0\0\0\x19\0m\0\x02\0w\0x\0u\0\0\0\x03\0t\0\0\0\0\0\0\0\0\0\0\0\0\0\x89\0\0\0\0\0\x9c\0\xb6\0\xb2\0\0\0\xa5\0\xa6\0\xa7\0\xa8\0\0\0\xaa\0\xbc\0\xa9\0\xad\0\xae\0\xb7\0\xb8\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0G\0\0\0\0\0\0\0,\0$\x007\x008\0\0\0\0\0\0\0Z\0\0\0\0\0\t\0\0\0\0\0J\0\0\0\0\0\0\0L\0N\0K\0j\0U\0l\0\0\0s\0\0\0\0\0\0\0\0\0\x83\0\0\0\0\0\0\0\0\0\xa2\0\xa3\0\xa4\0\0\0\x12\0\x05\0\0\0\0\0\0\0\0\0\0\0\0\0\x8a\0\0\0\0\0F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\b\0\0\0\0\0\0\0O\0M\0y\0\0\0\0\0\0\0\0\0\x85\0\x88\0\x86\0\x87\0\xba\0c\0\0\0\0\0f\0\0\0h\0\0\0\x84\0\0\0 \0A\0C\0\0\0B\0\0\0\0\0\0\0\0\0\0\0\0\0r\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0d\0i\0E\0\0\0^\0\0\0\0\0a\0\f\0\0\0\x0b\0\0\0\x7f\0~\0\x82\0\x80\0\x81\0\0\0_\0\r\0\0\0D\0\0\0\0\0P\0",
+  /* dgoto */"\x04\0\x06\0\x1b\0\x1e\0`\0\xc4\0>\x01\xae\0\xa7\0T\0\x03\x01N\0\xaf\0\xb0\0\xbf\0\x95\0\xbb\0\xf7\0\xbc\0O\0\xe4\0\xa0\x01\xf2\0M\x01\x96\0\x97\0\x98\0\x99\0F\x01\x9a\0H\x01\xb9\0\x17\x01\\\x01]\x01\x07\x01\x07\0\x9b\0\x9c\0\x9d\0\xff\0\x9e\0\0\x01\x9f\0\xa0\0[\0\b\0\t\0\xb3\0\n\0\x0b\0\xc2\0\f\0\xaa\0$\x01\r\0\xc7\0\x0e\0\x0f\0\x10\0\xca\0 \0c\0\x12\0\"\0\x13\0e\0\x14\0\x15\0\xd3\0\x16\0\x17\0\x18\0\x19\0\xd4\0",
+  /* sindex */"%\x01\x1c\xff#\xff%\xff\0\0\x9b\x03\0\0@\xff@\xff@\xff@\xff@\xff@\xff@\xff@\xff@\xff@\xff\0\0\0\0Q\0\0\0\0\0\0\0#\xff\0\0[\0\x91\xff\0\0\0\0y\xff\0\0\0\0\0\0x\0\x87\0\x87\xff\x9f\xff\xaf\xff\x87\xff\x87\xff9\xff\x87\xff9\xff\xa5\xff\xa5\xff\x93\xff\xb0\xff\xa5\xff\x93\xff\x93\xff\xb6\xff\xb6\xff\xb6\xff\xc3\xff\xc3\xff\xc3\xff\xcb\xff\xc3\xff\xb0\xff\xb0\xff\xb1\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x93\xff\0\0\0\0\0\0\0\0\xa9\x02\0\0\0\0\xde\xff\xd0\xff\xf6\xff\xe6\xff7\xff\x94\xff\x8d\0\xeb\xff\0\0\x9f\xff/\xff\xeb\xff\0\0\0\0\xa5\xff \0\0\0\x14\xff\0\0#\xff\x93\xff\xa5\xff\xa5\xff\xcf\xff\x18\x007\0<\0\xc5\xff&\x008\0H\0\xb2\xffO\0S\0Z\0\\\0H\xff@\xffP\0\0\0\0\0\x87\xff\x87\xff\0\0\x87\xff\x9f\xff\x9f\xff\x9f\xff\x9f\xff\x9f\xff\0\0\x9f\xff\x9f\xff\x9f\xff\x9f\xff\x9f\xff3\x003\0*\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xcc\x02\xef\x02\0\0\0\0\0\0\0\0K\0\0\0X\0\xa9\x02\0\0\0\0\0\0h\0\0\0r\0\0\0,\xff\xef\x02\xea\xff7\xffs\0q\0\0\0\xa8\xffy\0\0\0|\0\x83\0\x94\xff{\0\x87\xff\x87\xff\x87\xff\xef\x02}\0\x80\0\x9f\xff\x9f\xff\x81\0\xe5\xff\0\0\0\0\x83\0/\xff\x82\0\0\0\x84\xff~\x006\xff\x84\0\0\0\0\0\x85\0\x86\0\x88\0&\0\x89\0\x8a\0\x8b\0\x8c\0j\0\x91\0&\0\0\0\0\0\x93\0\xa4\0\xa5\0\xaf\0\xb0\0\0\0\x9f\xff+\0\xb5\0+\0\xa5\xff\xa5\xff\0\0\x12\x03\x12\x03\x12\x03\0\0\0\0\x9f\xff\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0o\0o\0\0\0\0\0\0\0\0\0\xb3\0\0\0\x9a\x03\0\0\0\0\x05\0\x8e\0\0\0\0\0\0\0\x0f\0\xb2\0\0\0\xb7\0\0\0\0\0\xbb\0\0\0\0\0\0\0\0\0\xa0\0\0\0\0\0\0\0\0\0\x12\x03\xb8\0\x12\x03\xcb\0}\0\0\0\0\0\xd5\0\0\0\0\0\0\0\0\0\0\0\0\0\x95\xff\0\0\0\0X\xff\xd6\0\x9f\xff\x9f\xff\x9f\xff\x9f\xff\0\0\xf9\xff\xfd\xff\0\0\0\0\0\0\xd7\0\0\0\0\0\0\0\0\0*\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xde\0\xb5\0\xe0\0\xe5\0\xf1\0\xf2\0\0\x01\xa5\xff\xfd\0F\x01\xfa\0\0\0\xef\x02\xfa\xff\xfb\0\0\0\0\0\0\0\0\0+\0\xb5\0\x19\0\0\0+\0\xb5\0\0\0\x05\x01\x9f\xff\0\0$\x01\b\x01\xb8\0\0\0\0\0\0\0\0\0\0\0\0\0\x02\0\0\0\x87\xff\x87\xff\x87\xff\x87\xff\0\0\x18\x01\x19\x01#\x01+\x01\0\0\0\0\0\0;\x01\0\0\0\0\xcc\x02<\x015\x03X\x03L\x01M\x01\0\0\f\x01\x87\xff\0\0\x87\xff\x87\xff\x87\xff]\x01(\x01^\x01h\x01J\x01i\x01\0\0j\x01\xef\x02y\x03\0\0\0\0\0\0l\x01\xea\xff\x83\0\x83\0\0\0\0\0\0\0\0\0\0\0\0\0\xcc\x02\xda\0\0\0\x01\x01\0\0X\x03\0\0t\x01\0\0\0\0\0\0\xef\x02\0\0\x8e\0\x85\x01\x98\x01h\0\xa8\x01h\0\0\0\xa9\x01\n\0\xba\x01\xcb\x01\xcc\x01\xdd\x01\xee\x01\0\0\0\0\0\0\xeb\x01\0\0\x8e\0\xd4\x01\0\0\0\0h\0\0\0\x01\x02\0\0\0\0\0\0\0\0\0\0\x87\xff\0\0\0\0\n\x02\0\0\xef\x02\x12\x02\0\0",
+  /* rindex */"\0\0+\x03\0\0-\x03\0\0\0\0\0\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\x03\0\0\0\0\0\0\0\0\0\0\0\0\0\x04\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x1d\x02\0\0\0\0\x1a\0\xa1\xff\0\x000\xff\0\0\0\0\0\0\x12\xffA\0\0\0*\x02*\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0:\x02\x06\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0C\0\0\0\0\0\0\0\0\x005\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0F\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0G\x02\0\0W\x02X\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0g\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0G\x02\0\0\0\0\0\0@\x02\xfa\x01\0\0@\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0n\x01n\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x005\x02N\xff\0\0\0\0\0\0\0\0\0\0\0\0i\x025\x02\0\0\0\0\0\0j\x02\0\0\0\0\0\0\0\x005\x02\0\0\0\0\0\0\x1b\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0c\x02%\xffc\x025\x02z\x02\0\0F\x02\x91\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0g\x02\0\0\0\0\0\0\0\0\0\0\0\0g\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0{\x02{\x02{\x02\0\0\0\0\0\0<\x02\x13\0<\x02\0\0\0\0\x91\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\xb4\x01\xb4\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x005\x02\0\x005\x02\0\0z\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0{\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0N\xff\0\0\0\0\0\0\0\0\0\0\0\0{\x02{\x02\0\0\0\0{\x02{\x02\0\0\0\0F\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0E\0\x1a\0\x8f\x02\x8f\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x005\x02\0\x005\x025\x02\0\0\0\0\0\0\0\0\xd7\x01\0\0\xd7\x01\x86\x02\xd7\x01\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x005\x02\0\0\0\0\0\0\0\0j\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x005\x02\0\0\0\0\0\0\0\x005\x02\0\0\0\0\0\0\0\0\0\0<\x02\0\0i\x02\0\0i\x02j\x02\0\0j\x02\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0i\x02\0\0\0\0\0\0j\x02\0\0\x8c\x02\0\0\0\0\0\0\0\0\0\0\xd7\x01\0\0\0\0\0\0\0\x005\x02\0\0\0\0",
+  /* gindex */"\0\0\0\0\0\0\0\0\xdc\xffj\xffC\xff\xe7\x02h\xffR\x03\xf5\xfe\xdb\xff^\xff\xa6\xffR\xffq\xff\xed\xfft\x02_\xff\xe0\xff\xc9\xff\xb8\xfe(\x03\xc4\x02\0\0\xa9\xff\0\0\xe2\xffe\xffo\xff\x05\xff\0\0\xa3\x02_\x02p\x02\x14\x03\0\x008\x03x\xff\xc8\xff\x16\xff\xd3\xff4\x02h\x02\xaa\xfe\x01\0\0\0\0\0*\x03\0\0\0\0,\x03\0\0E\x03\0\0\0\0\0\0\0\0\0\0\0\0\xb9\0\xf8\x03\xf7\xff\xfa\x03\0\0\0\0\x16\x01\xc7\0\xe1\0\x96\xff\0\0\xfd\x03\0\0\xfc\xff\0\0",
+  /* tablesize */1254,
+  /* table */"U\0\xb8\0\xbe\0\x8e\0\xb4\0\xfb\0V\0W\0a\0\\\0Z\0f\0Z\0\xf9\0\xfe\0\x0f\x01\t\x01R\0\x1d\x01H\0R\x01Y\0\x06\x01]\0[\x01\x19\x01\x1a\x01\x9a\0\x9a\0<\0\xa8\0\xb1\0\x9b\x01\xb8\0@\x01A\x01\xc0\0\x05\0\x06\x01g\0h\0\xa9\0\xb2\0^\0\x1a\0 \x01\x1d\0\xc1\0\xab\0\x1a\0*\x01+\x01\x05\x01\xa1\x01\xa2\x01\xa3\x01\xbd\0\x1a\0P\0Z\0\xc5\0\xa5\0Q\0Z\0\xa6\0w\0X\0\xcd\0\xce\0\xe5\0\xb3\x01\xe6\0K\x01<\0I\x01J\x01\xdb\0\x9a\0\x9a\0\xc8\0\xc9\0G\0\xdc\0G\x01G\x01G\x01\xe3\0\xe3\0R\0\xe3\0\xba\0I\0R\0\xcc\0\xc3\0R\0[\x01\xcb\0%\x01/\x01\xe1\0\xe2\0\xbe\0\xbe\0&\x01'\x016\x01(\x01\xe7\0\xe8\0\xe9\0\xea\0\xeb\0\xa8\0\xec\0\xed\0\xee\0\xef\0\xf0\0X\x01K\0^\x01\xb1\0\xc7\x01\xa9\0\x12\x01\x13\x01\x14\x01r\x01G\x01\xad\x01G\x01d\x01\xb2\0b\x01L\0!\x01\xc0\0e\x01f\x01M\0g\x01\"\x01\xe3\0\xe3\0\xe3\0\x80\x01\x82\x01\xc1\0\xab\0\x83\x01\x85\x01b\0!\x01\x16\x01\xac\0\xba\x01\xad\0\xbc\x01c\x01P\0\xb8\0\x1a\0\xb8\0Q\0#\0$\0%\0\x1a\0_\0\x1a\0&\0'\0(\0)\0*\0\xc5\x01+\0,\0J\0M\0d\0\x87\x01|\x01S\0?\x01\xb6\x01B\x01\x1f\0C\x01D\x01i\0=\0>\0?\0@\0A\0B\0C\0D\0E\0F\0<\x01-\0m\0\xc4\x01.\0/\x000\x001\x002\x003\0q\x004\x005\x006\x007\x008\x009\0:\0;\0#\0$\0%\0\xe1\0\xe2\0\xb1\x01&\0'\0(\0)\0*\0\xa1\0+\0,\0\x96\x01-\0\xb0\x01\xb8\0S\0\xa5\x000\x001\0\b\x01X\0Z\x01\xaf\x01\xab\x01\x16\x01j\0k\0l\0\xa2\0!\x01\xae\x01r\0\xa3\0!\x01\xb8\0m\x010\x001\0!\x01n\x01}\x01-\0\x9f\0~\x01\x8c\x01\x8e\0\xb4\0\xb2\x01\x9f\0\xb5\x01i\x01j\x01k\x01l\x01n\0o\0p\0s\0t\0\x1c\x01\xcf\0\xe1\0\xe2\0x\x01\x1a\0R\0\x10\0\x1a\0R\0\x10\0\x01\0\x02\0\x03\0\xc6\0\x81\x01\xf4\0\xf5\0\xf6\0\x84\x01\xd2\0M\0=\x01\xb8\0\xdd\0O\x01P\x01\xbe\0\xc9\x01\xdd\0S\x01T\x01\xd0\0Z\x01Z\x01S\x01T\x01\xd1\0\xb8\0\xd5\0\xb8\0\x8d\x01\x8e\x01\x8f\x01\x90\x01O\x01P\x01\x9f\0\x9f\0\x9a\0\x9a\0\x1a\0\x1a\0u\0v\0\xd6\0\xd7\0\xf1\0\xfc\0\x9f\x01\xd8\0\x9f\x01\x9f\x01\x9f\x01y\0z\0\xb4\0\xd9\0\xb5\0\xda\0\xfd\0}\0\xb6\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\x02\x01\f\x01\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0\x04\x01\x0b\x01\xdd\0\xde\0\xdf\0\xe0\0\r\x01\xac\0\xab\0\x11\x01\xfa\0#\x01\xe1\0\xe2\0\x18\x01\x1b\x01\x1f\x014\x01)\x01,\x01-\x01L\x01.\x010\x011\x012\x013\x01Q\x01y\0z\0\xb4\x005\x01\xb5\x007\x01\x9f\x01}\0\xb6\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\x008\x019\x01\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0:\x01;\x01=\x01U\x01V\x01y\0z\0\xb4\0Y\x01\xb5\0\x05\x01\xb7\0}\0\xb6\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0W\x01_\x01\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0a\x01h\x01o\x01\xde\0\xdf\0\xe0\0y\0z\0\xb4\0q\x01\xb5\0s\x01t\x01}\0\xb6\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0u\x01v\x01\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0w\x01y\x01{\x01\x7f\x01\xdf\0\xe0\0y\0z\0\xb4\0\x86\x01\xb5\0\x89\x01\x9e\x01}\0\xb6\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\x91\x01\x92\x01\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0\x93\x01\xa5\x01y\0z\0\xb4\0\xe0\0\xb5\0\x88\x01\x94\x01}\0\xb6\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\x95\x01\x97\x01\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0\xa8\x01y\0z\0\xb4\0z\x01\xb5\0\x9c\x01\x9d\x01}\0\xb6\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\xa4\x01\xa6\x01\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0\xa7\x01\xa9\x01\xaa\x01\xac\x01z\x01!\0!\0!\0!\0!\0!\0!\0\xb4\x01!\0!\0!\0!\0!\0!\0!\0!\0!\0!\0!\0!\0!\0!\0!\0!\0\xb7\x01!\0!\0!\0!\0!\0!\0!\0!\0!\0!\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\xb8\x01\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\xbb\x01\xbd\x01\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0\x18\0#\0#\0#\0#\0#\0#\0#\0\xbe\x01#\0#\0#\0#\0#\0#\0#\0#\0#\0#\0#\0#\0#\0#\0#\0#\0\xbf\x01\xc0\x01#\0#\0#\0#\0#\0#\0#\0#\0#\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\xc1\x01\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\xc2\x01\xc3\x01\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1d\0P\x01\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\xc6\x01\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\xc8\x01\xca\x01\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\xb4\0\x1a\0\x8e\0\x9a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x9f\0R\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1a\0\x1d\0R\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x18\0\x8e\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\xb4\0\x9a\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\xbb\0\x1d\0`\0\n\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0T\0\x04\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1d\0\x1f\0\x1a\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0Q\0\x0e\x01\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\xa4\0p\x01\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0\x1f\0x\0\xf3\0y\0z\0{\0N\x01|\0`\x01\x8b\x01}\0~\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\x8a\x01\x15\x01\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0\xf8\0\x01\x01y\0z\0{\0\xb9\x01|\0\x10\x01\x99\x01}\0~\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\x1e\x01\n\x01\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0\xfa\0\x11\0y\0z\0{\0!\0|\0\x1c\0\0\0}\0~\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\0\0\0\0\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0E\x01\0\0y\0z\0{\0\0\0|\0\0\0\0\0}\0~\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\0\0\0\0\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0\x98\x01\0\0y\0z\0{\0\0\0|\0\0\0\0\0}\0~\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\0\0\0\0\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0\x9a\x01\0\0y\0z\0{\0\0\0|\0\0\0\0\0}\0~\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\0\0\0\0\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0y\0z\0\xb4\0\0\0\xb5\0\x88\x01\0\0}\0\xb6\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\0\0\0\0\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0y\0z\0\xb4\0\0\0\xb5\0\0\0\0\0}\0\xb6\0\x7f\0\x80\0\x81\0\x82\0\x83\0\x84\0\x85\0\x86\0\x87\0\x88\0\x89\0\x8a\0\x8b\0\0\0\0\0\x8c\0\x8d\0\x8e\0\x8f\0\x90\0\x91\0\x92\0\x93\0\x94\0\0\0#\0$\0%\0\0\0\0\0\0\0&\0'\0(\0)\0*\0\0\0+\0,\0-\0\0\0\0\0.\0/\x000\x001\x002\x003\0\0\x004\x005\x006\x007\x008\x009\0:\0;\0",
+  /* check */"%\0X\0\\\0\0\0\0\0\x96\0&\0'\0,\0)\0(\0/\0*\0\x95\0\x9d\0\xb1\0\xa8\0$\0\xc0\0\x17\0\xfe\0(\0\xa7\0*\0\x13\x01\xba\0\xbb\0\t\x01\n\x01\t\x01V\0W\0v\x01x\0\xdf\0\xe0\0\\\0\t\x01\xb7\x000\x001\0V\0W\0*\0\t\x01\xc3\0\t\x01\\\0\x01\x01\x01\x01\xc8\0\xc9\0\b\x01}\x01~\x01\x7f\x01\t\x01\t\x01\x01\x01Y\0`\0\x06\x01\x05\x01]\0\t\x01J\0\t\x01g\0h\0|\0\x9c\x01~\0\xe9\0\t\x01\xe5\0\xe6\0\x04\x01;\x01<\x01;\x01<\x01\0\0\n\x01\xe4\0\xe5\0\xe6\0{\0|\0\n\x01~\0Y\0\0\0\x0e\x01f\0]\0\x11\x01[\x01e\0,\x01\xcd\x008\x019\x01\xc0\0\xc1\x002\x013\x01\xd4\x005\x01\x7f\0\x80\0\x81\0\x82\0\x83\0\xa9\0\x85\0\x86\0\x87\0\x88\0\x89\0\x12\x01\0\0\x14\x01\xb2\0\xc3\x01\xa9\0\xb4\0\xb5\0\xb6\0=\x01\x12\x01\x8d\x01\x14\x01,\x01\xb2\0\x1c\x01\0\0\x04\x01\xc1\x002\x013\x01\x05\x015\x01\n\x01\xb4\0\xb5\0\xb6\0O\x01P\x01\xc1\0\x01\x01S\x01T\x01\x05\x01\x04\x01\xb8\0\x07\x01\xa7\x01\t\x01\xa9\x01\n\x01\x01\x01\xf8\0\x01\x01\xfa\0\x05\x01,\x01-\x01.\x01\x07\x01\x04\x01\t\x012\x013\x014\x015\x016\x01\xbb\x018\x019\x01:\x01\x05\x01\x05\x01W\x01H\x01\t\x01\xde\0\xa4\x01\xe0\0\x03\0\xe1\0\xe2\0\t\x01\x07\0\b\0\t\0\n\0\x0b\0\f\0\r\0\x0e\0\x0f\0\x10\0\xdd\0:\x01\t\x01\xb7\x01=\x01>\x01?\x01@\x01A\x01B\x01\t\x01D\x01E\x01F\x01G\x01H\x01I\x01J\x01K\x01,\x01-\x01.\x018\x019\x01\x90\x012\x013\x014\x015\x016\x01\n\x018\x019\x01s\x01:\x01\x8f\x01E\x01\t\x01\x06\x01?\x01@\x01\t\x01\t\x01\x13\x01\x8e\x01\x88\x01\x16\x012\x003\x004\0,\x01\x04\x01\x8d\x018\0\n\x01\x04\x01Y\x01\n\x01?\x01@\x01\x04\x01\n\x01\x0e\x01:\x01\x04\x01\x11\x01\n\x01\n\x01\n\x01\x97\x01\n\x01\xa2\x01%\x01&\x01'\x01(\x015\x006\x007\x008\x009\x006\x01\x04\x018\x019\x01C\x01\x06\x01\x0e\x01\x07\x01\t\x01\x11\x01\n\x01\x01\0\x02\0\x03\0\t\x01O\x01\x01\x01\x02\x01\x03\x01S\x01\t\x01\x05\x01\x06\x01\x89\x01.\x01/\x010\x01\x90\x01\xc8\x01.\x01/\x010\x01\x04\x01Z\x01[\x01/\x010\x01\x04\x01\x98\x01\n\x01\x9a\x01d\x01e\x01f\x01g\x01/\x010\x01\t\x01\n\x01\t\x01\n\x01\t\x01\n\x01:\0;\0\n\x01\x04\x01!\x01\n\x01{\x01\x04\x01}\x01~\x01\x7f\x01\x0b\x01\f\x01\r\x01\x04\x01\x0f\x01\x04\x01\t\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\t\x01\x01\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\n\x01\n\x01.\x01/\x010\x011\x01\t\x01\x07\x01\x01\x01\n\x01\t\x01\t\x018\x019\x01\n\x01\n\x01\n\x01#\x01\n\x01\n\x01\n\x01\"\x01\n\x01\n\x01\n\x01\n\x01\n\x01\t\x01\x0b\x01\f\x01\r\x01\n\x01\x0f\x01\n\x01\xc3\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\n\x01\n\x01\x06\x01\n\x01\x06\x01\x0b\x01\f\x01\r\x01\t\x01\x0f\x01\b\x017\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x014\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\n\x01\n\x01\n\x01/\x010\x011\x01\x0b\x01\f\x01\r\x01\n\x01\x0f\x01\n\x01\x06\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\x06\x01\n\x01\x0e\x01\x0e\x010\x011\x01\x0b\x01\f\x01\r\x01\n\x01\x0f\x01\t\x01\x06\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\n\x01\x06\x01\x0b\x01\f\x01\r\x011\x01\x0f\x01\x10\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\x06\x01\x0b\x01\f\x01\r\x010\x01\x0f\x01\n\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\n\x01\n\x01\n\x01\t\x010\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\n\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\"\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\t\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\n\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\n\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\x0e\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x010\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\t\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\x11\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\0\0\x0f\x01\0\0\x04\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\x04\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\x0e\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\n\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\n\x01\x0b\x01\f\x01\r\x01\n\x01\x0f\x01\n\x01\n\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\n\x01\n\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\x01\x01\x0b\x01\f\x01\r\x01\x0e\x01\x0f\x01\n\x01\xb0\0\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01U\x004\x01#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\x8b\0\x0b\x01\f\x01\r\x01\xf3\0\x0f\x01\x16\x01[\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01Z\x01\xb7\0#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\x9e\0\x0b\x01\f\x01\r\x01\xa6\x01\x0f\x01\xb2\0u\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xc1\0\xa9\0#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\x01\0\x0b\x01\f\x01\r\x01\x03\0\x0f\x01\x02\0\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xff\xff\xff#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\xff\xff\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\xff\xff\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xff\xff\xff#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\xff\xff\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\xff\xff\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xff\xff\xff#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\t\x01\xff\xff\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\xff\xff\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xff\xff\xff#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\x10\x01\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xff\xff\xff#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\x0b\x01\f\x01\r\x01\xff\xff\x0f\x01\xff\xff\xff\xff\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01 \x01\xff\xff\xff\xff#\x01$\x01%\x01&\x01'\x01(\x01)\x01*\x01+\x01\xff\xff,\x01-\x01.\x01\xff\xff\xff\xff\xff\xff2\x013\x014\x015\x016\x01\xff\xff8\x019\x01:\x01\xff\xff\xff\xff=\x01>\x01?\x01@\x01A\x01B\x01\xff\xffD\x01E\x01F\x01G\x01H\x01I\x01J\x01K\x01",
   /* error_function */parse_error,
-  /* names_const */"ANYFUNC\0MUT\0LPAR\0RPAR\0NOP\0DROP\0BLOCK\0END\0IF\0THEN\0ELSE\0SELECT\0LOOP\0BR\0BR_IF\0BR_TABLE\0CALL\0CALL_INDIRECT\0RETURN\0GET_LOCAL\0SET_LOCAL\0TEE_LOCAL\0GET_GLOBAL\0SET_GLOBAL\0UNREACHABLE\0CURRENT_MEMORY\0GROW_MEMORY\0FUNC\0START\0TYPE\0PARAM\0RESULT\0LOCAL\0GLOBAL\0MODULE\0TABLE\0ELEM\0MEMORY\0DATA\0OFFSET\0IMPORT\0EXPORT\0SCRIPT\0REGISTER\0INVOKE\0GET\0ASSERT_MALFORMED\0ASSERT_INVALID\0ASSERT_SOFT_INVALID\0ASSERT_UNLINKABLE\0ASSERT_RETURN\0ASSERT_RETURN_NAN\0ASSERT_TRAP\0ASSERT_EXHAUSTION\0INPUT\0OUTPUT\0EOF\0",
-  /* names_block */"NAT\0INT\0FLOAT\0TEXT\0VAR\0VALUE_TYPE\0LOAD\0STORE\0OFFSET_EQ_NAT\0ALIGN_EQ_NAT\0CONST\0UNARY\0BINARY\0COMPARE\0CONVERT\0TEST\0"
+  /* names_const */"ANYFUNC\0MUT\0LPAR\0RPAR\0NOP\0DROP\0BLOCK\0END\0IF\0THEN\0ELSE\0SELECT\0LOOP\0BR\0BR_IF\0BR_TABLE\0CALL\0CALL_INDIRECT\0RETURN\0GET_LOCAL\0SET_LOCAL\0TEE_LOCAL\0GET_GLOBAL\0SET_GLOBAL\0UNREACHABLE\0CURRENT_MEMORY\0GROW_MEMORY\0FUNC\0START\0TYPE\0PARAM\0RESULT\0LOCAL\0GLOBAL\0TABLE\0ELEM\0MEMORY\0DATA\0OFFSET\0IMPORT\0EXPORT\0MODULE\0BIN\0QUOTE\0SCRIPT\0REGISTER\0INVOKE\0GET\0ASSERT_MALFORMED\0ASSERT_INVALID\0ASSERT_SOFT_INVALID\0ASSERT_UNLINKABLE\0ASSERT_RETURN\0ASSERT_RETURN_CANONICAL_NAN\0ASSERT_RETURN_ARITHMETIC_NAN\0ASSERT_TRAP\0ASSERT_EXHAUSTION\0INPUT\0OUTPUT\0EOF\0",
+  /* names_block */"NAT\0INT\0FLOAT\0STRING\0VAR\0VALUE_TYPE\0LOAD\0STORE\0OFFSET_EQ_NAT\0ALIGN_EQ_NAT\0CONST\0UNARY\0BINARY\0TEST\0COMPARE\0CONVERT\0"
 ];
 
 function script(lexfun, lexbuf) {
@@ -27708,13 +27113,14 @@ exports.module1 = module1;
 //////// start of parsing.js ////////
 'use strict';
 
-var $$Array         = require("./array");
-var Curry           = require("./curry");
-var Lexing          = require("./lexing");
-var Caml_obj        = require("./caml_obj");
-var Caml_array      = require("./caml_array");
-var Caml_parser     = require("./caml_parser");
-var Caml_exceptions = require("./caml_exceptions");
+var $$Array         = require("./array.js");
+var Curry           = require("./curry.js");
+var Js_exn          = require("./js_exn.js");
+var Lexing          = require("./lexing.js");
+var Caml_obj        = require("./caml_obj.js");
+var Caml_array      = require("./caml_array.js");
+var Caml_parser     = require("./caml_parser.js");
+var Caml_exceptions = require("./caml_exceptions.js");
 
 var YYexit = Caml_exceptions.create("Parsing.YYexit");
 
@@ -27811,7 +27217,7 @@ function yyparse(tables, start, lexer, lexbuf) {
             try {
               match$1 = /* tuple */[
                 /* Semantic_action_computed */4,
-                Curry._1(tables[/* actions */0][env[/* rule_number */12]], env)
+                Curry._1(Caml_array.caml_array_get(tables[/* actions */0], env[/* rule_number */12]), env)
               ];
             }
             catch (exn){
@@ -27820,8 +27226,7 @@ function yyparse(tables, start, lexer, lexbuf) {
                   /* Error_detected */5,
                   /* () */0
                 ];
-              }
-              else {
+              } else {
                 throw exn;
               }
             }
@@ -27837,7 +27242,8 @@ function yyparse(tables, start, lexer, lexbuf) {
       }
     };
   }
-  catch (exn$1){
+  catch (raw_exn){
+    var exn$1 = Js_exn.internalToOCamlException(raw_exn);
     var curr_char = env[/* curr_char */6];
     env[/* asp */10] = init_asp;
     env[/* sp */13] = init_sp;
@@ -27848,14 +27254,12 @@ function yyparse(tables, start, lexer, lexbuf) {
     env[/* errflag */15] = init_errflag;
     if (exn$1[0] === YYexit) {
       return exn$1[1];
-    }
-    else {
+    } else {
       current_lookahead_fun[0] = function (tok) {
         if (tok.length !== undefined) {
-          return +(tables[/* transl_block */2][tok.tag | 0] === curr_char);
-        }
-        else {
-          return +(tables[/* transl_const */1][tok] === curr_char);
+          return +(Caml_array.caml_array_get(tables[/* transl_block */2], tok.tag | 0) === curr_char);
+        } else {
+          return +(Caml_array.caml_array_get(tables[/* transl_const */1], tok) === curr_char);
         }
       };
       throw exn$1;
@@ -27864,7 +27268,7 @@ function yyparse(tables, start, lexer, lexbuf) {
 }
 
 function peek_val(env, n) {
-  return env[/* v_stack */1][env[/* asp */10] - n | 0];
+  return Caml_array.caml_array_get(env[/* v_stack */1], env[/* asp */10] - n | 0);
 }
 
 function symbol_start_pos() {
@@ -27872,15 +27276,13 @@ function symbol_start_pos() {
   while(true) {
     var i = _i;
     if (i <= 0) {
-      return env[/* symb_end_stack */3][env[/* asp */10]];
-    }
-    else {
-      var st = env[/* symb_start_stack */2][(env[/* asp */10] - i | 0) + 1 | 0];
-      var en = env[/* symb_end_stack */3][(env[/* asp */10] - i | 0) + 1 | 0];
+      return Caml_array.caml_array_get(env[/* symb_end_stack */3], env[/* asp */10]);
+    } else {
+      var st = Caml_array.caml_array_get(env[/* symb_start_stack */2], (env[/* asp */10] - i | 0) + 1 | 0);
+      var en = Caml_array.caml_array_get(env[/* symb_end_stack */3], (env[/* asp */10] - i | 0) + 1 | 0);
       if (Caml_obj.caml_notequal(st, en)) {
         return st;
-      }
-      else {
+      } else {
         _i = i - 1 | 0;
         continue ;
         
@@ -27890,15 +27292,15 @@ function symbol_start_pos() {
 }
 
 function symbol_end_pos() {
-  return env[/* symb_end_stack */3][env[/* asp */10]];
+  return Caml_array.caml_array_get(env[/* symb_end_stack */3], env[/* asp */10]);
 }
 
 function rhs_start_pos(n) {
-  return env[/* symb_start_stack */2][env[/* asp */10] - (env[/* rule_len */11] - n | 0) | 0];
+  return Caml_array.caml_array_get(env[/* symb_start_stack */2], env[/* asp */10] - (env[/* rule_len */11] - n | 0) | 0);
 }
 
 function rhs_end_pos(n) {
-  return env[/* symb_end_stack */3][env[/* asp */10] - (env[/* rule_len */11] - n | 0) | 0];
+  return Caml_array.caml_array_get(env[/* symb_end_stack */3], env[/* asp */10] - (env[/* rule_len */11] - n | 0) | 0);
 }
 
 function symbol_start() {
@@ -27954,14 +27356,16 @@ exports.parse_error          = parse_error;
 //////// start of pervasives.js ////////
 'use strict';
 
-var Curry                    = require("./curry");
-var Caml_io                  = require("./caml_io");
-var Caml_obj                 = require("./caml_obj");
-var Caml_format              = require("./caml_format");
-var Caml_string              = require("./caml_string");
-var Caml_exceptions          = require("./caml_exceptions");
-var Caml_builtin_exceptions  = require("./caml_builtin_exceptions");
-var CamlinternalFormatBasics = require("./camlinternalFormatBasics");
+var Curry                    = require("./curry.js");
+var Caml_io                  = require("./caml_io.js");
+var Caml_obj                 = require("./caml_obj.js");
+var Caml_sys                 = require("./caml_sys.js");
+var Caml_format              = require("./caml_format.js");
+var Caml_string              = require("./caml_string.js");
+var Caml_exceptions          = require("./caml_exceptions.js");
+var Caml_missing_polyfill    = require("./caml_missing_polyfill.js");
+var Caml_builtin_exceptions  = require("./caml_builtin_exceptions.js");
+var CamlinternalFormatBasics = require("./camlinternalFormatBasics.js");
 
 function failwith(s) {
   throw [
@@ -27982,8 +27386,7 @@ var Exit = Caml_exceptions.create("Pervasives.Exit");
 function min(x, y) {
   if (Caml_obj.caml_lessequal(x, y)) {
     return x;
-  }
-  else {
+  } else {
     return y;
   }
 }
@@ -27991,8 +27394,7 @@ function min(x, y) {
 function max(x, y) {
   if (Caml_obj.caml_greaterequal(x, y)) {
     return x;
-  }
-  else {
+  } else {
     return y;
   }
 }
@@ -28000,8 +27402,7 @@ function max(x, y) {
 function abs(x) {
   if (x >= 0) {
     return x;
-  }
-  else {
+  } else {
     return -x | 0;
   }
 }
@@ -28022,8 +27423,7 @@ function char_of_int(n) {
           Caml_builtin_exceptions.invalid_argument,
           "char_of_int"
         ];
-  }
-  else {
+  } else {
     return n;
   }
 }
@@ -28031,8 +27431,7 @@ function char_of_int(n) {
 function string_of_bool(b) {
   if (b) {
     return "true";
-  }
-  else {
+  } else {
     return "false";
   }
 }
@@ -28062,23 +27461,19 @@ function valid_float_lexem(s) {
     var i = _i;
     if (i >= l) {
       return $caret(s, ".");
-    }
-    else {
+    } else {
       var match = Caml_string.get(s, i);
       if (match >= 48) {
         if (match >= 58) {
           return s;
-        }
-        else {
+        } else {
           _i = i + 1 | 0;
           continue ;
           
         }
-      }
-      else if (match !== 45) {
+      } else if (match !== 45) {
         return s;
-      }
-      else {
+      } else {
         _i = i + 1 | 0;
         continue ;
         
@@ -28097,8 +27492,7 @@ function $at(l1, l2) {
             l1[0],
             $at(l1[1], l2)
           ];
-  }
-  else {
+  } else {
     return l2;
   }
 }
@@ -28110,9 +27504,7 @@ var stdout = Caml_io.stdout;
 var stderr = Caml_io.stderr;
 
 function open_out_gen(_, _$1, _$2) {
-  return Caml_io.caml_ml_open_descriptor_out(function () {
-                throw "caml_sys_open not implemented by bucklescript yet\n";
-              }());
+  return Caml_io.caml_ml_open_descriptor_out(Caml_missing_polyfill.not_implemented("caml_sys_open not implemented by bucklescript yet\n"));
 }
 
 function open_out(name) {
@@ -28161,8 +27553,7 @@ function flush_all() {
       _param = param[1];
       continue ;
       
-    }
-    else {
+    } else {
       return /* () */0;
     }
   };
@@ -28182,8 +27573,7 @@ function output(oc, s, ofs, len) {
           Caml_builtin_exceptions.invalid_argument,
           "output"
         ];
-  }
-  else {
+  } else {
     return Caml_io.caml_ml_output(oc, s, ofs, len);
   }
 }
@@ -28194,23 +27584,18 @@ function output_substring(oc, s, ofs, len) {
           Caml_builtin_exceptions.invalid_argument,
           "output_substring"
         ];
-  }
-  else {
+  } else {
     return Caml_io.caml_ml_output(oc, s, ofs, len);
   }
 }
 
 function output_value(_, _$1) {
-  return function () {
-            throw "caml_output_value not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_output_value not implemented by bucklescript yet\n");
 }
 
 function close_out(oc) {
   Caml_io.caml_ml_flush(oc);
-  return function () {
-            throw "caml_ml_close_channel not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_close_channel not implemented by bucklescript yet\n");
 }
 
 function close_out_noerr(oc) {
@@ -28221,9 +27606,7 @@ function close_out_noerr(oc) {
     
   }
   try {
-    return function () {
-              throw "caml_ml_close_channel not implemented by bucklescript yet\n";
-            }();
+    return Caml_missing_polyfill.not_implemented("caml_ml_close_channel not implemented by bucklescript yet\n");
   }
   catch (exn$1){
     return /* () */0;
@@ -28231,9 +27614,7 @@ function close_out_noerr(oc) {
 }
 
 function open_in_gen(_, _$1, _$2) {
-  return Caml_io.caml_ml_open_descriptor_in(function () {
-                throw "caml_sys_open not implemented by bucklescript yet\n";
-              }());
+  return Caml_io.caml_ml_open_descriptor_in(Caml_missing_polyfill.not_implemented("caml_sys_open not implemented by bucklescript yet\n"));
 }
 
 function open_in(name) {
@@ -28262,11 +27643,8 @@ function input(_, s, ofs, len) {
           Caml_builtin_exceptions.invalid_argument,
           "input"
         ];
-  }
-  else {
-    return function () {
-              throw "caml_ml_input not implemented by bucklescript yet\n";
-            }();
+  } else {
+    return Caml_missing_polyfill.not_implemented("caml_ml_input not implemented by bucklescript yet\n");
   }
 }
 
@@ -28276,18 +27654,14 @@ function unsafe_really_input(_, _$1, _ofs, _len) {
     var ofs = _ofs;
     if (len <= 0) {
       return /* () */0;
-    }
-    else {
-      var r = function () {
-          throw "caml_ml_input not implemented by bucklescript yet\n";
-        }();
+    } else {
+      var r = Caml_missing_polyfill.not_implemented("caml_ml_input not implemented by bucklescript yet\n");
       if (r) {
         _len = len - r | 0;
         _ofs = ofs + r | 0;
         continue ;
         
-      }
-      else {
+      } else {
         throw Caml_builtin_exceptions.end_of_file;
       }
     }
@@ -28300,8 +27674,7 @@ function really_input(ic, s, ofs, len) {
           Caml_builtin_exceptions.invalid_argument,
           "really_input"
         ];
-  }
-  else {
+  } else {
     return unsafe_really_input(ic, s, ofs, len);
   }
 }
@@ -28325,8 +27698,7 @@ function input_line(chan) {
         _pos = pos - len | 0;
         continue ;
         
-      }
-      else {
+      } else {
         return buf;
       }
     };
@@ -28335,15 +27707,11 @@ function input_line(chan) {
     while(true) {
       var len = _len;
       var accu = _accu;
-      var n = function () {
-          throw "caml_ml_input_scan_line not implemented by bucklescript yet\n";
-        }();
+      var n = Caml_missing_polyfill.not_implemented("caml_ml_input_scan_line not implemented by bucklescript yet\n");
       if (n) {
         if (n > 0) {
           var res = Caml_string.caml_create_string(n - 1 | 0);
-          (function () {
-                throw "caml_ml_input not implemented by bucklescript yet\n";
-              }());
+          Caml_missing_polyfill.not_implemented("caml_ml_input not implemented by bucklescript yet\n");
           Caml_io.caml_ml_input_char(chan);
           if (accu) {
             var len$1 = (len + n | 0) - 1 | 0;
@@ -28351,16 +27719,12 @@ function input_line(chan) {
                         res,
                         accu
                       ]);
-          }
-          else {
+          } else {
             return res;
           }
-        }
-        else {
+        } else {
           var beg = Caml_string.caml_create_string(-n | 0);
-          (function () {
-                throw "caml_ml_input not implemented by bucklescript yet\n";
-              }());
+          Caml_missing_polyfill.not_implemented("caml_ml_input not implemented by bucklescript yet\n");
           _len = len - n | 0;
           _accu = /* :: */[
             beg,
@@ -28369,11 +27733,9 @@ function input_line(chan) {
           continue ;
           
         }
-      }
-      else if (accu) {
+      } else if (accu) {
         return build_result(Caml_string.caml_create_string(len), len, accu);
-      }
-      else {
+      } else {
         throw Caml_builtin_exceptions.end_of_file;
       }
     };
@@ -28383,9 +27745,7 @@ function input_line(chan) {
 
 function close_in_noerr() {
   try {
-    return function () {
-              throw "caml_ml_close_channel not implemented by bucklescript yet\n";
-            }();
+    return Caml_missing_polyfill.not_implemented("caml_ml_close_channel not implemented by bucklescript yet\n");
   }
   catch (exn){
     return /* () */0;
@@ -28491,11 +27851,9 @@ function do_at_exit() {
   return Curry._1(exit_function[0], /* () */0);
 }
 
-function exit() {
+function exit(retcode) {
   do_at_exit(/* () */0);
-  return function () {
-            throw "caml_sys_exit not implemented by bucklescript yet\n";
-          }();
+  return Caml_sys.caml_sys_exit(retcode);
 }
 
 var max_int = 2147483647;
@@ -28519,33 +27877,23 @@ var output_char = Caml_io.caml_ml_output_char;
 var output_byte = Caml_io.caml_ml_output_char;
 
 function output_binary_int(_, _$1) {
-  return function () {
-            throw "caml_ml_output_int not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_output_int not implemented by bucklescript yet\n");
 }
 
 function seek_out(_, _$1) {
-  return function () {
-            throw "caml_ml_seek_out not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_seek_out not implemented by bucklescript yet\n");
 }
 
 function pos_out() {
-  return function () {
-            throw "caml_ml_pos_out not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_pos_out not implemented by bucklescript yet\n");
 }
 
 function out_channel_length() {
-  return function () {
-            throw "caml_ml_channel_size not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_channel_size not implemented by bucklescript yet\n");
 }
 
 function set_binary_mode_out(_, _$1) {
-  return function () {
-            throw "caml_ml_set_binary_mode not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_set_binary_mode not implemented by bucklescript yet\n");
 }
 
 var input_char = Caml_io.caml_ml_input_char;
@@ -28553,81 +27901,55 @@ var input_char = Caml_io.caml_ml_input_char;
 var input_byte = Caml_io.caml_ml_input_char;
 
 function input_binary_int() {
-  return function () {
-            throw "caml_ml_input_int not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_input_int not implemented by bucklescript yet\n");
 }
 
 function input_value() {
-  return function () {
-            throw "caml_input_value not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_input_value not implemented by bucklescript yet\n");
 }
 
 function seek_in(_, _$1) {
-  return function () {
-            throw "caml_ml_seek_in not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_seek_in not implemented by bucklescript yet\n");
 }
 
 function pos_in() {
-  return function () {
-            throw "caml_ml_pos_in not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_pos_in not implemented by bucklescript yet\n");
 }
 
 function in_channel_length() {
-  return function () {
-            throw "caml_ml_channel_size not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_channel_size not implemented by bucklescript yet\n");
 }
 
 function close_in() {
-  return function () {
-            throw "caml_ml_close_channel not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_close_channel not implemented by bucklescript yet\n");
 }
 
 function set_binary_mode_in(_, _$1) {
-  return function () {
-            throw "caml_ml_set_binary_mode not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_set_binary_mode not implemented by bucklescript yet\n");
 }
 
 function LargeFile_000(_, _$1) {
-  return function () {
-            throw "caml_ml_seek_out_64 not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_seek_out_64 not implemented by bucklescript yet\n");
 }
 
 function LargeFile_001() {
-  return function () {
-            throw "caml_ml_pos_out_64 not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_pos_out_64 not implemented by bucklescript yet\n");
 }
 
 function LargeFile_002() {
-  return function () {
-            throw "caml_ml_channel_size_64 not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_channel_size_64 not implemented by bucklescript yet\n");
 }
 
 function LargeFile_003(_, _$1) {
-  return function () {
-            throw "caml_ml_seek_in_64 not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_seek_in_64 not implemented by bucklescript yet\n");
 }
 
 function LargeFile_004() {
-  return function () {
-            throw "caml_ml_pos_in_64 not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_pos_in_64 not implemented by bucklescript yet\n");
 }
 
 function LargeFile_005() {
-  return function () {
-            throw "caml_ml_channel_size_64 not implemented by bucklescript yet\n";
-          }();
+  return Caml_missing_polyfill.not_implemented("caml_ml_channel_size_64 not implemented by bucklescript yet\n");
 }
 
 var LargeFile = [
@@ -28736,10 +28058,10 @@ exports.do_at_exit          = do_at_exit;
 //////// start of printf.js ////////
 'use strict';
 
-var Curry              = require("./curry");
-var Buffer             = require("./buffer");
-var Pervasives         = require("./pervasives");
-var CamlinternalFormat = require("./camlinternalFormat");
+var Curry              = require("./curry.js");
+var Buffer             = require("./buffer.js");
+var Pervasives         = require("./pervasives.js");
+var CamlinternalFormat = require("./camlinternalFormat.js");
 
 function kfprintf(k, o, param) {
   return CamlinternalFormat.make_printf(function (o, acc) {
@@ -28824,12 +28146,12 @@ exports.kprintf   = kprintf;
   _registry['print'] = function() {
     let exports = {};
 //////// start of print.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var List    = require("bs-platform/lib/js/list");
-var Sexpr   = require("./sexpr");
-var Arrange = require("./arrange");
+var List    = require("bs-platform/lib/js/list.js");
+var Sexpr   = require("./sexpr.js");
+var Arrange = require("./arrange.js");
 
 function instr(oc, width, e) {
   return Sexpr.output(oc, width, Arrange.instr(e));
@@ -28862,10 +28184,10 @@ exports.script  = script;
   _registry['script'] = function() {
     let exports = {};
 //////// start of script.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions");
+var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions.js");
 
 var Syntax = Caml_exceptions.create("Script.Syntax");
 
@@ -28879,14 +28201,14 @@ exports.Syntax = Syntax;
   _registry['sexpr'] = function() {
     let exports = {};
 //////// start of sexpr.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var List       = require("bs-platform/lib/js/list");
-var Block      = require("bs-platform/lib/js/block");
-var Curry      = require("bs-platform/lib/js/curry");
-var $$String   = require("bs-platform/lib/js/string");
-var Pervasives = require("bs-platform/lib/js/pervasives");
+var List       = require("bs-platform/lib/js/list.js");
+var Block      = require("bs-platform/lib/js/block.js");
+var Curry      = require("bs-platform/lib/js/curry.js");
+var $$String   = require("bs-platform/lib/js/string.js");
+var Pervasives = require("bs-platform/lib/js/pervasives.js");
 
 function $caret$plus(s, r) {
   return /* Concat */Block.__(1, [/* :: */[
@@ -28913,8 +28235,7 @@ function iter(f, param) {
     return List.iter(function (param) {
                 return iter(f, param);
               }, param[0]);
-  }
-  else {
+  } else {
     return Curry._1(f, param[0]);
   }
 }
@@ -28922,8 +28243,7 @@ function iter(f, param) {
 function concat(param) {
   if (param.tag) {
     return $$String.concat("", List.map(concat, param[0]));
-  }
-  else {
+  } else {
     return param[0];
   }
 }
@@ -28945,8 +28265,7 @@ function pp(off, width, param) {
         " ",
         ""
       ];
-    }
-    else {
+    } else {
       var indent = $$String.make(off, /* " " */32);
       match$1 = /* tuple */[
         "\n  " + indent,
@@ -28960,8 +28279,7 @@ function pp(off, width, param) {
                                       return $caret$plus(sep, r);
                                     }, rs)]), match$1[1]), ")")))
           ];
-  }
-  else {
+  } else {
     var s$1 = param[0];
     return /* tuple */[
             s$1.length,
@@ -28998,14 +28316,14 @@ exports.to_string = to_string;
   _registry['source'] = function() {
     let exports = {};
 //////// start of source.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Block      = require("bs-platform/lib/js/block");
-var Curry      = require("bs-platform/lib/js/curry");
-var Printf     = require("bs-platform/lib/js/printf");
-var Caml_obj   = require("bs-platform/lib/js/caml_obj");
-var Pervasives = require("bs-platform/lib/js/pervasives");
+var Block      = require("bs-platform/lib/js/block.js");
+var Curry      = require("bs-platform/lib/js/curry.js");
+var Printf     = require("bs-platform/lib/js/printf.js");
+var Caml_obj   = require("bs-platform/lib/js/caml_obj.js");
+var Pervasives = require("bs-platform/lib/js/pervasives.js");
 
 function $at$at(x, region) {
   return /* record */[
@@ -29039,8 +28357,7 @@ function string_of_pos(pos) {
                       ]),
                     "0x%x"
                   ]), pos[/* column */2]);
-  }
-  else {
+  } else {
     return Pervasives.string_of_int(pos[/* line */1]) + ("." + Pervasives.string_of_int(pos[/* column */2] + 1 | 0));
   }
 }
@@ -29067,10 +28384,10 @@ exports.$at$at           = $at$at;
 //////// start of string.js ////////
 'use strict';
 
-var List        = require("./list");
-var Bytes       = require("./bytes");
-var Caml_int32  = require("./caml_int32");
-var Caml_string = require("./caml_string");
+var List        = require("./list.js");
+var Bytes       = require("./bytes.js");
+var Caml_int32  = require("./caml_int32.js");
+var Caml_string = require("./caml_string.js");
 
 function make(n, c) {
   return Caml_string.bytes_to_string(Bytes.make(n, c));
@@ -29109,8 +28426,7 @@ function concat(sep, l) {
           return /* () */0;
         }, l[1]);
     return Caml_string.bytes_to_string(r);
-  }
-  else {
+  } else {
     return "";
   }
 }
@@ -29136,15 +28452,12 @@ function is_space(param) {
   if (switcher > 4 || switcher < 0) {
     if (switcher !== 23) {
       return /* false */0;
-    }
-    else {
+    } else {
       return /* true */1;
     }
-  }
-  else if (switcher !== 2) {
+  } else if (switcher !== 2) {
     return /* true */1;
-  }
-  else {
+  } else {
     return /* false */0;
   }
 }
@@ -29152,8 +28465,7 @@ function is_space(param) {
 function trim(s) {
   if (s === "" || !(is_space(s.charCodeAt(0)) || is_space(s.charCodeAt(s.length - 1 | 0)))) {
     return s;
-  }
-  else {
+  } else {
     return Caml_string.bytes_to_string(Bytes.trim(Caml_string.bytes_of_string(s)));
   }
 }
@@ -29164,31 +28476,26 @@ function escaped(s) {
       var i = _i;
       if (i >= s.length) {
         return /* false */0;
-      }
-      else {
+      } else {
         var match = s.charCodeAt(i);
         if (match >= 32) {
           var switcher = match - 34 | 0;
           if (switcher > 58 || switcher < 0) {
             if (switcher >= 93) {
               return /* true */1;
-            }
-            else {
+            } else {
               _i = i + 1 | 0;
               continue ;
               
             }
-          }
-          else if (switcher > 57 || switcher < 1) {
+          } else if (switcher > 57 || switcher < 1) {
             return /* true */1;
-          }
-          else {
+          } else {
             _i = i + 1 | 0;
             continue ;
             
           }
-        }
-        else {
+        } else {
           return /* true */1;
         }
       }
@@ -29196,8 +28503,7 @@ function escaped(s) {
   };
   if (needs_escape(0)) {
     return Caml_string.bytes_to_string(Bytes.escaped(Caml_string.bytes_of_string(s)));
-  }
-  else {
+  } else {
     return s;
   }
 }
@@ -29288,11 +28594,12 @@ exports.compare        = compare;
 //////// start of sys.js ////////
 'use strict';
 
-var Caml_exceptions = require("./caml_exceptions");
+var Caml_sys        = require("./caml_sys.js");
+var Caml_exceptions = require("./caml_exceptions.js");
 
 var is_js = /* true */1;
 
-var match_001 = /* array */[];
+var match = Caml_sys.caml_sys_get_argv(/* () */0);
 
 var big_endian = /* false */0;
 
@@ -29318,9 +28625,9 @@ function catch_break() {
   return /* () */0;
 }
 
-var argv = match_001;
+var argv = match[1];
 
-var executable_name = "cmd";
+var executable_name = match[0];
 
 var os_type = "Unix";
 
@@ -29416,23 +28723,106 @@ exports.ocaml_version     = ocaml_version;
   _registry['types'] = function() {
     let exports = {};
 //////// start of types.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var I32      = require("./i32");
-var List     = require("bs-platform/lib/js/list");
-var Curry    = require("bs-platform/lib/js/curry");
-var $$String = require("bs-platform/lib/js/string");
+var I32      = require("./i32.js");
+var List     = require("bs-platform/lib/js/list.js");
+var Curry    = require("bs-platform/lib/js/curry.js");
+var $$String = require("bs-platform/lib/js/string.js");
 
 function size(param) {
   if (param !== 1 && param < 3) {
     return 4;
-  }
-  else {
+  } else {
     return 8;
   }
 }
 
+function funcs(_param) {
+  while(true) {
+    var param = _param;
+    if (param) {
+      var match = param[0];
+      if (match.tag) {
+        _param = param[1];
+        continue ;
+        
+      } else {
+        return /* :: */[
+                match[0],
+                funcs(param[1])
+              ];
+      }
+    } else {
+      return /* [] */0;
+    }
+  };
+}
+
+function tables(_param) {
+  while(true) {
+    var param = _param;
+    if (param) {
+      var match = param[0];
+      if (match.tag === 1) {
+        return /* :: */[
+                match[0],
+                tables(param[1])
+              ];
+      } else {
+        _param = param[1];
+        continue ;
+        
+      }
+    } else {
+      return /* [] */0;
+    }
+  };
+}
+
+function memories(_param) {
+  while(true) {
+    var param = _param;
+    if (param) {
+      var match = param[0];
+      if (match.tag === 2) {
+        return /* :: */[
+                match[0],
+                memories(param[1])
+              ];
+      } else {
+        _param = param[1];
+        continue ;
+        
+      }
+    } else {
+      return /* [] */0;
+    }
+  };
+}
+
+function globals(_param) {
+  while(true) {
+    var param = _param;
+    if (param) {
+      var match = param[0];
+      if (match.tag === 3) {
+        return /* :: */[
+                match[0],
+                globals(param[1])
+              ];
+      } else {
+        _param = param[1];
+        continue ;
+        
+      }
+    } else {
+      return /* [] */0;
+    }
+  };
+}
+
 function string_of_value_type(param) {
   switch (param) {
     case 0 : 
@@ -29452,12 +28842,10 @@ function string_of_value_types(ts) {
   if (ts) {
     if (ts[1]) {
       exit = 1;
-    }
-    else {
+    } else {
       return string_of_value_type(ts[0]);
     }
-  }
-  else {
+  } else {
     exit = 1;
   }
   if (exit === 1) {
@@ -29489,8 +28877,7 @@ function string_of_global_type(param) {
   var t = param[0];
   if (param[1] !== 0) {
     return "(mut " + (string_of_value_type(t) + ")");
-  }
-  else {
+  } else {
     return string_of_value_type(t);
   }
 }
@@ -29504,6 +28891,10 @@ function string_of_func_type(param) {
 }
 
 exports.size                  = size;
+exports.funcs                 = funcs;
+exports.tables                = tables;
+exports.memories              = memories;
+exports.globals               = globals;
 exports.string_of_value_type  = string_of_value_type;
 exports.string_of_value_types = string_of_value_types;
 exports.string_of_elem_type   = string_of_elem_type;
@@ -29519,21 +28910,178 @@ exports.string_of_func_type   = string_of_func_type;
   };
 
 
+  _registry['utf8'] = function() {
+    let exports = {};
+//////// start of utf8.js ////////
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
+'use strict';
+
+var Lib             = require("./lib.js");
+var Char            = require("bs-platform/lib/js/char.js");
+var List            = require("bs-platform/lib/js/list.js");
+var Curry           = require("bs-platform/lib/js/curry.js");
+var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions.js");
+
+var Utf8 = Caml_exceptions.create("Utf8.Utf8");
+
+function con(n) {
+  return 128 | n & 63;
+}
+
+function encode$prime(param) {
+  if (param) {
+    var n = param[0];
+    if (n < 0) {
+      throw Utf8;
+    } else {
+      var ns = param[1];
+      if (n < 128) {
+        return /* :: */[
+                n,
+                encode$prime(ns)
+              ];
+      } else if (n < 2048) {
+        return /* :: */[
+                192 | (n >>> 6),
+                /* :: */[
+                  con(n),
+                  encode$prime(ns)
+                ]
+              ];
+      } else if (n < 65536) {
+        return /* :: */[
+                224 | (n >>> 12),
+                /* :: */[
+                  con((n >>> 6)),
+                  /* :: */[
+                    con(n),
+                    encode$prime(ns)
+                  ]
+                ]
+              ];
+      } else if (n < 1114112) {
+        return /* :: */[
+                240 | (n >>> 18),
+                /* :: */[
+                  con((n >>> 12)),
+                  /* :: */[
+                    con((n >>> 6)),
+                    /* :: */[
+                      con(n),
+                      encode$prime(ns)
+                    ]
+                  ]
+                ]
+              ];
+      } else {
+        throw Utf8;
+      }
+    }
+  } else {
+    return /* [] */0;
+  }
+}
+
+function encode(ns) {
+  return Curry._1(Lib.$$String[/* implode */0], List.map(Char.chr, encode$prime(ns)));
+}
+
+function con$1(b) {
+  if ((b & 192) === 128) {
+    return b & 63;
+  } else {
+    throw Utf8;
+  }
+}
+
+function code(min, n) {
+  if (n < min || 55296 <= n && n < 57344 || n >= 1114112) {
+    throw Utf8;
+  } else {
+    return n;
+  }
+}
+
+function decode$prime(param) {
+  if (param) {
+    var bs = param[1];
+    var b1 = param[0];
+    if (b1 < 128) {
+      return /* :: */[
+              code(0, b1),
+              decode$prime(bs)
+            ];
+    } else if (b1 < 192) {
+      throw Utf8;
+    } else if (bs) {
+      var bs$1 = bs[1];
+      var b2 = bs[0];
+      if (b1 < 224) {
+        return /* :: */[
+                code(128, ((b1 & 31) << 6) + con$1(b2) | 0),
+                decode$prime(bs$1)
+              ];
+      } else if (bs$1) {
+        var bs$2 = bs$1[1];
+        var b3 = bs$1[0];
+        if (b1 < 240) {
+          return /* :: */[
+                  code(2048, (((b1 & 15) << 12) + (con$1(b2) << 6) | 0) + con$1(b3) | 0),
+                  decode$prime(bs$2)
+                ];
+        } else if (bs$2) {
+          if (b1 < 248) {
+            return /* :: */[
+                    code(65536, ((((b1 & 7) << 18) + (con$1(b2) << 12) | 0) + (con$1(b3) << 6) | 0) + con$1(bs$2[0]) | 0),
+                    decode$prime(bs$2[1])
+                  ];
+          } else {
+            throw Utf8;
+          }
+        } else {
+          throw Utf8;
+        }
+      } else {
+        throw Utf8;
+      }
+    } else {
+      throw Utf8;
+    }
+  } else {
+    return /* [] */0;
+  }
+}
+
+function decode(s) {
+  return decode$prime(List.map(function (prim) {
+                  return prim;
+                }, Curry._1(Lib.$$String[/* explode */1], s)));
+}
+
+exports.Utf8   = Utf8;
+exports.decode = decode;
+exports.encode = encode;
+/* Lib Not a pure module */
+//////// end of utf8.js ////////
+    return exports;
+  };
+
+
   _registry['values'] = function() {
     let exports = {};
 //////// start of values.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var F32             = require("./f32");
-var F64             = require("./f64");
-var I32             = require("./i32");
-var I64             = require("./i64");
-var List            = require("bs-platform/lib/js/list");
-var Block           = require("bs-platform/lib/js/block");
-var Curry           = require("bs-platform/lib/js/curry");
-var $$String        = require("bs-platform/lib/js/string");
-var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions");
+var F32             = require("./f32.js");
+var F64             = require("./f64.js");
+var I32             = require("./i32.js");
+var I64             = require("./i64.js");
+var List            = require("bs-platform/lib/js/list.js");
+var Block           = require("bs-platform/lib/js/block.js");
+var Curry           = require("bs-platform/lib/js/curry.js");
+var $$String        = require("bs-platform/lib/js/string.js");
+var Caml_exceptions = require("bs-platform/lib/js/caml_exceptions.js");
 
 function type_of(param) {
   switch (param.tag | 0) {
@@ -29586,12 +29134,10 @@ function string_of_values(vs) {
   if (vs) {
     if (vs[1]) {
       exit = 1;
-    }
-    else {
+    } else {
       return string_of_value(vs[0]);
     }
-  }
-  else {
+  } else {
     exit = 1;
   }
   if (exit === 1) {
@@ -29612,8 +29158,7 @@ function of_value(param) {
           Value,
           /* I32Type */0
         ];
-  }
-  else {
+  } else {
     return param[0];
   }
 }
@@ -29630,8 +29175,7 @@ function to_value$1(i) {
 function of_value$1(param) {
   if (param.tag === 1) {
     return param[0];
-  }
-  else {
+  } else {
     throw [
           Value,
           /* I64Type */1
@@ -29651,8 +29195,7 @@ function to_value$2(i) {
 function of_value$2(param) {
   if (param.tag === 2) {
     return param[0];
-  }
-  else {
+  } else {
     throw [
           Value,
           /* F32Type */2
@@ -29672,8 +29215,7 @@ function to_value$3(i) {
 function of_value$3(param) {
   if (param.tag === 3) {
     return param[0];
-  }
-  else {
+  } else {
     throw [
           Value,
           /* F64Type */3
@@ -29705,25 +29247,34 @@ exports.F64Value         = F64Value;
   _registry['wasm'] = function() {
     let exports = {};
 //////// start of wasm.js ////////
-// Generated by BUCKLESCRIPT VERSION 1.4.3 , PLEASE EDIT WITH CARE
+// Generated by BUCKLESCRIPT VERSION 1.7.4, PLEASE EDIT WITH CARE
 'use strict';
 
-var Parse      = require("./parse");
-var Sexpr      = require("./sexpr");
-var Decode     = require("./decode");
-var Encode     = require("./encode");
-var Arrange    = require("./arrange");
-var Caml_int64 = require("bs-platform/lib/js/caml_int64");
-var Pervasives = require("bs-platform/lib/js/pervasives");
+var Parse                   = require("./parse.js");
+var Sexpr                   = require("./sexpr.js");
+var Decode                  = require("./decode.js");
+var Encode                  = require("./encode.js");
+var Arrange                 = require("./arrange.js");
+var Caml_builtin_exceptions = require("bs-platform/lib/js/caml_builtin_exceptions.js");
 
 function encode(s) {
   var def = Parse.string_to_module(s);
   var match = def[/* it */1];
-  if (match.tag) {
-    return match[1];
-  }
-  else {
-    return Encode.encode(match[0]);
+  switch (match.tag | 0) {
+    case 0 : 
+        return Encode.encode(match[0]);
+    case 1 : 
+        return match[1];
+    case 2 : 
+        throw [
+              Caml_builtin_exceptions.match_failure,
+              [
+                "/usr/local/google/home/rossberg/wasm/spec/interpreter/_build/jslib/src/wasm.ml",
+                3,
+                2
+              ]
+            ];
+    
   }
 }
 
@@ -29732,19 +29283,8 @@ function decode(s, width) {
   return Sexpr.to_string(width, Arrange.module_(m));
 }
 
-function f(x) {
-  Pervasives.print_string("f");
-  return x;
-}
-
-function g(x) {
-  return Caml_int64.or_(x, (Pervasives.print_string("f"), x));
-}
-
 exports.encode = encode;
 exports.decode = decode;
-exports.f      = f;
-exports.g      = g;
 /* Parse Not a pure module */
 //////// end of wasm.js ////////
     return exports;

From 3725d1a51ece93c22b353c2a6fbdb7466e25c215 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 13 Jun 2017 18:58:00 +0200
Subject: [PATCH 039/329] Rectify licensing (#496)

---
 LICENSE             | 206 ++------------------------------------------
 document/LICENSE    |  50 +++++++++++
 interpreter/LICENSE | 202 +++++++++++++++++++++++++++++++++++++++++++
 papers/LICENSE      |   1 +
 test/LICENSE        | 202 +++++++++++++++++++++++++++++++++++++++++++
 5 files changed, 461 insertions(+), 200 deletions(-)
 create mode 100644 document/LICENSE
 create mode 100644 interpreter/LICENSE
 create mode 100644 papers/LICENSE
 create mode 100644 test/LICENSE

diff --git a/LICENSE b/LICENSE
index 8f71f43fe..de2cac692 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,202 +1,8 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
+Please see the LICENSE file in each top-level directory for the terms applicable to that directory and its relative sub-directories.
 
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright {yyyy} {name of copyright owner}
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
+The relevant directories and licenses are:
 
+document/    - W3C Software and Document Notice and License
+interpreter/ - Apache License 2.0
+test/        - Apache License 2.0
+papers/      - Creative Commons Attribution 4.0 International License
diff --git a/document/LICENSE b/document/LICENSE
new file mode 100644
index 000000000..795b406e4
--- /dev/null
+++ b/document/LICENSE
@@ -0,0 +1,50 @@
+W3C SOFTWARE AND DOCUMENT NOTICE AND LICENSE
+
+This work is being provided by the copyright holders under the following
+license.
+
+
+LICENSE
+
+By obtaining and/or copying this work, you (the licensee) agree that you have
+read, understood, and will comply with the following terms and conditions.
+
+Permission to copy, modify, and distribute this work, with or without
+modification, for any purpose and without fee or royalty is hereby granted,
+provided that you include the following on ALL copies of the work or portions
+thereof, including modifications:
+
+* The full text of this NOTICE in a location viewable to users of the
+  redistributed or derivative work.
+
+* Any pre-existing intellectual property disclaimers, notices, or terms and
+  conditions. If none exist, the W3C Software and Document Short Notice
+  (https://www.w3.org/Consortium/Legal/copyright-software-short-notice) should
+  be included.
+
+* Notice of any changes or modifications, through a copyright statement on the
+  new code or document such as "This software or document includes material
+  copied from or derived from [title and URI of the W3C document]. Copyright © [YEAR] W3C® (MIT, ERCIM, Keio, Beihang)."
+
+
+DISCLAIMERS
+
+THIS WORK IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS
+OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO, WARRANTIES OF
+MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE
+SOFTWARE OR DOCUMENT WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS,
+TRADEMARKS OR OTHER RIGHTS.
+
+COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR DOCUMENT.
+
+The name and trademarks of copyright holders may NOT be used in advertising or
+publicity pertaining to the work without specific, written prior permission.
+Title to copyright in this work will at all times remain with copyright
+holders.
+
+
+NOTES
+
+This version:
+http://www.w3.org/Consortium/Legal/2015/copyright-software-and-document
diff --git a/interpreter/LICENSE b/interpreter/LICENSE
new file mode 100644
index 000000000..8f71f43fe
--- /dev/null
+++ b/interpreter/LICENSE
@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+
diff --git a/papers/LICENSE b/papers/LICENSE
new file mode 100644
index 000000000..4aee8d7c6
--- /dev/null
+++ b/papers/LICENSE
@@ -0,0 +1 @@
+This work is licensed under the Creative Commons Attribution 4.0 International License. To view a copy of this license, visit http://creativecommons.org/licenses/by/4.0/ or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
diff --git a/test/LICENSE b/test/LICENSE
new file mode 100644
index 000000000..8f71f43fe
--- /dev/null
+++ b/test/LICENSE
@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

From 645c6524371445bb8c3a85575ba8cb4810a175bc Mon Sep 17 00:00:00 2001
From: JF Bastien <github@jfbastien.com>
Date: Fri, 16 Jun 2017 15:52:25 -0700
Subject: [PATCH 040/329] Test harness: fix assert_invalid, improve error
 messages (#505)

assert_invalid uses module() and checks:
            assert_true(e instanceof WebAssembly.CompileError, "expected invalid failure:");

But module() catches and re-throws a plain Error, so instanceof cannot succeed.

While I'm here, improve the error messages a bit.
---
 test/harness/index.js | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/test/harness/index.js b/test/harness/index.js
index c5b450571..a3134b18e 100644
--- a/test/harness/index.js
+++ b/test/harness/index.js
@@ -111,14 +111,20 @@ function module(bytes, valid = true) {
     try {
         validated = WebAssembly.validate(buffer);
     } catch (e) {
-        throw new Error(`WebAssembly.validate throws: ${e}${e.stack}`);
+        throw new Error(`WebAssembly.validate throws ${typeof e}: ${e}${e.stack}`);
     }
 
     if (validated !== valid) {
         // Try to get a more precise error message from the WebAssembly.CompileError.
-        let err = '';
-        try { new WebAssembly.Module(buffer) } catch(e) { err = e.toString() }
-        throw new Error(`WebAssembly.validate error: ${err}\n`);
+        try {
+            new WebAssembly.Module(buffer);
+        } catch (e) {
+            if (e instanceof WebAssembly.CompileError)
+                throw new WebAssembly.CompileError(`WebAssembly.validate error: ${e.toString()}${e.stack}\n`);
+            else
+                throw new Error(`WebAssembly.validate throws ${typeof e}: ${e}${e.stack}`);
+        }
+        throw new Error(`WebAssembly.validate was expected to fail, but didn't`);
     }
 
     let module;
@@ -126,7 +132,7 @@ function module(bytes, valid = true) {
         module = new WebAssembly.Module(buffer);
     } catch(e) {
         if (valid)
-            throw new Error('WebAssembly.Module ctor unexpectedly throws');
+            throw new Error('WebAssembly.Module ctor unexpectedly throws ${typeof e}: ${e}${e.stack}');
         throw e;
     }
 

From 0798b0a790c99f5b17363ee875fb262f9bbc173e Mon Sep 17 00:00:00 2001
From: Michael Ferris <mike.ferris@hotmail.com>
Date: Mon, 19 Jun 2017 15:51:52 -0700
Subject: [PATCH 041/329] Test js-api: add memory.grow test (#507)

* Removed pushing `end` opcode on `.end()` since `.addBody()` now does it too.
Added test `Memory.prototype.grow(0)` with initial size 0

* Address CR Comments
---
 test/harness/wasm-module-builder.js |  5 ++---
 test/js-api/jsapi.js                | 11 +++++++++--
 2 files changed, 11 insertions(+), 5 deletions(-)

diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index 68fab8985..d9948eb1a 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -100,8 +100,8 @@ class WasmFunctionBuilder {
 
   addBody(body) {
     for (let b of body) {
-      if (typeof b != 'number')
-        throw new Error('invalid body (entries have to be numbers): ' + body);
+      if (typeof b !== 'number' || (b & (~0xFF)) !== 0 )
+        throw new Error('invalid body (entries have to be 8 bit numbers): ' + body);
     }
     this.body = body.slice();
     // Automatically add the end for the function block to the body.
@@ -115,7 +115,6 @@ class WasmFunctionBuilder {
   }
 
   end() {
-    this.body.push(kExprEnd);
     return this.module;
   }
 }
diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 9b4096a2e..8e0f1cec8 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -485,17 +485,24 @@ test(() => {
     var buf = mem.buffer;
     assert_equals(buf.byteLength, WasmPage);
     assert_equals(mem.grow(0), 1);
-    assert_equals(buf !== mem.buffer, true);
+    assert_not_equals(buf, mem.buffer)
     assert_equals(buf.byteLength, 0);
     buf = mem.buffer;
     assert_equals(buf.byteLength, WasmPage);
     assert_equals(mem.grow(1), 1);
-    assert_equals(buf !== mem.buffer, true);
+    assert_not_equals(buf, mem.buffer)
     assert_equals(buf.byteLength, 0);
     buf = mem.buffer;
     assert_equals(buf.byteLength, 2 * WasmPage);
     assertThrows(() => mem.grow(1), Error);
     assert_equals(buf, mem.buffer);
+    mem = new Memory({initial:0, maximum:1});
+    buf = mem.buffer;
+    assert_equals(buf.byteLength, 0);
+    assert_equals(mem.grow(0), 0);
+    assert_not_equals(buf, mem.buffer)
+    assert_equals(buf.byteLength, 0);
+    assert_equals(mem.buffer.byteLength, 0);
 }, "'WebAssembly.Memory.prototype.grow' method");
 
 test(() => {

From 800a85f0622c9830597305155020eae88f81a12e Mon Sep 17 00:00:00 2001
From: Michael Ferris <mike.ferris@hotmail.com>
Date: Tue, 20 Jun 2017 10:59:41 -0700
Subject: [PATCH 042/329] Add test in traps.wast (#510)

* Add test for dead-code with i32.div_s & i64.div_s (min_int, -1)

* Fix typo
---
 test/core/traps.wast | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/test/core/traps.wast b/test/core/traps.wast
index 32072b984..a9401408e 100644
--- a/test/core/traps.wast
+++ b/test/core/traps.wast
@@ -17,6 +17,8 @@
 (assert_trap (invoke "no_dce.i32.div_u" (i32.const 1) (i32.const 0)) "integer divide by zero")
 (assert_trap (invoke "no_dce.i64.div_s" (i64.const 1) (i64.const 0)) "integer divide by zero")
 (assert_trap (invoke "no_dce.i64.div_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
+(assert_trap (invoke "no_dce.i32.div_s" (i32.const 0x80000000) (i32.const -1)) "integer overflow")
+(assert_trap (invoke "no_dce.i64.div_s" (i64.const 0x8000000000000000) (i64.const -1)) "integer overflow")
 
 (module
   (func (export "no_dce.i32.rem_s") (param $x i32) (param $y i32)

From 0a2e341147ec825a1df4a3d0454174f5ce3d480a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?St=C3=A9phan=20Kochen?= <stephan@kochen.nl>
Date: Thu, 22 Jun 2017 08:58:34 +0200
Subject: [PATCH 043/329] Add missing parameter to 'if' type (#511)

---
 document/validation/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/validation/instructions.rst b/document/validation/instructions.rst
index 60d743677..087dd8611 100644
--- a/document/validation/instructions.rst
+++ b/document/validation/instructions.rst
@@ -526,7 +526,7 @@ Control Instructions
 * Under context :math:`C'`,
   the instruction sequence :math:`\instr_2^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \to [t^?]`.
 
-* Then the compound instruction is valid with type :math:`[] \to [t^?]`.
+* Then the compound instruction is valid with type :math:`[\I32] \to [t^?]`.
 
 .. math::
    \frac{

From aadd3a340c78e53078a7bb6c17cc30f105c2960c Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Mon, 26 Jun 2017 17:11:33 +0200
Subject: [PATCH 044/329] Remove expected output (#498)

---
 test/core/address.wast                        | 99 +++++++++++++++----
 test/core/expected-output/address.wast.log    | 38 -------
 test/core/expected-output/func_ptrs.wast.log  |  1 -
 .../if-label-scope.fail.wast.log              |  1 -
 test/core/expected-output/imports.wast.log    | 12 ---
 test/core/expected-output/names.wast.log      |  2 -
 test/core/expected-output/start.wast.log      |  2 -
 test/core/func_ptrs.wast                      |  1 +
 test/core/names.wast                          |  2 +-
 test/core/run.py                              |  5 +-
 10 files changed, 83 insertions(+), 80 deletions(-)
 delete mode 100644 test/core/expected-output/address.wast.log
 delete mode 100644 test/core/expected-output/func_ptrs.wast.log
 delete mode 100644 test/core/expected-output/if-label-scope.fail.wast.log
 delete mode 100644 test/core/expected-output/imports.wast.log
 delete mode 100644 test/core/expected-output/names.wast.log
 delete mode 100644 test/core/expected-output/start.wast.log

diff --git a/test/core/address.wast b/test/core/address.wast
index 47bd21bad..ee2a6bb39 100644
--- a/test/core/address.wast
+++ b/test/core/address.wast
@@ -1,25 +1,47 @@
 (module
-  (import "spectest" "print" (func $print (param i32)))
-
   (memory 1)
   (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz")
 
-  (func (export "good") (param $i i32)
-    (call $print (i32.load8_u offset=0 (get_local $i)))  ;; 97 'a'
-    (call $print (i32.load8_u offset=1 (get_local $i)))  ;; 98 'b'
-    (call $print (i32.load8_u offset=2 (get_local $i)))  ;; 99 'c'
-    (call $print (i32.load8_u offset=25 (get_local $i))) ;; 122 'z'
+  (func (export "good1") (param $i i32) (result i32)
+    (i32.load8_u offset=0 (get_local $i))  ;; 97 'a'
+  )
+  (func (export "good2") (param $i i32) (result i32)
+    (i32.load8_u offset=1 (get_local $i))  ;; 98 'b'
+  )
+  (func (export "good3") (param $i i32) (result i32)
+    (i32.load8_u offset=2 (get_local $i))  ;; 99 'c'
+  )
+  (func (export "good4") (param $i i32) (result i32)
+    (i32.load8_u offset=25 (get_local $i)) ;; 122 'z'
+  )
 
-    (call $print (i32.load16_u offset=0 (get_local $i)))          ;; 25185 'ab'
-    (call $print (i32.load16_u align=1 (get_local $i)))           ;; 25185 'ab'
-    (call $print (i32.load16_u offset=1 align=1 (get_local $i)))  ;; 25442 'bc'
-    (call $print (i32.load16_u offset=2 (get_local $i)))          ;; 25699 'cd'
-    (call $print (i32.load16_u offset=25 align=1 (get_local $i))) ;; 122 'z\0'
+  (func (export "good5") (param $i i32) (result i32)
+    (i32.load16_u offset=0 (get_local $i))          ;; 25185 'ab'
+  )
+  (func (export "good6") (param $i i32) (result i32)
+    (i32.load16_u align=1 (get_local $i))           ;; 25185 'ab'
+  )
+  (func (export "good7") (param $i i32) (result i32)
+    (i32.load16_u offset=1 align=1 (get_local $i))  ;; 25442 'bc'
+  )
+  (func (export "good8") (param $i i32) (result i32)
+    (i32.load16_u offset=2 (get_local $i))          ;; 25699 'cd'
+  )
+  (func (export "good9") (param $i i32) (result i32)
+    (i32.load16_u offset=25 align=1 (get_local $i)) ;; 122 'z\0'
+  )
 
-    (call $print (i32.load offset=0 (get_local $i)))          ;; 1684234849 'abcd'
-    (call $print (i32.load offset=1 align=1 (get_local $i)))  ;; 1701077858 'bcde'
-    (call $print (i32.load offset=2 align=2 (get_local $i)))  ;; 1717920867 'cdef'
-    (call $print (i32.load offset=25 align=1 (get_local $i))) ;; 122 'z\0\0\0'
+  (func (export "good10") (param $i i32) (result i32)
+    (i32.load offset=0 (get_local $i))          ;; 1684234849 'abcd'
+  )
+  (func (export "good11") (param $i i32) (result i32)
+    (i32.load offset=1 align=1 (get_local $i))  ;; 1701077858 'bcde'
+  )
+  (func (export "good12") (param $i i32) (result i32)
+    (i32.load offset=2 align=2 (get_local $i))  ;; 1717920867 'cdef'
+  )
+  (func (export "good13") (param $i i32) (result i32)
+    (i32.load offset=25 align=1 (get_local $i)) ;; 122 'z\0\0\0'
   )
 
   (func (export "bad") (param $i i32)
@@ -27,9 +49,48 @@
   )
 )
 
-(invoke "good" (i32.const 0))
-(invoke "good" (i32.const 65507))
-(assert_trap (invoke "good" (i32.const 65508)) "out of bounds memory access")
+(assert_return (invoke "good1" (i32.const 0)) (i32.const 97))
+(assert_return (invoke "good2" (i32.const 0)) (i32.const 98))
+(assert_return (invoke "good3" (i32.const 0)) (i32.const 99))
+(assert_return (invoke "good4" (i32.const 0)) (i32.const 122))
+(assert_return (invoke "good5" (i32.const 0)) (i32.const 25185))
+(assert_return (invoke "good6" (i32.const 0)) (i32.const 25185))
+(assert_return (invoke "good7" (i32.const 0)) (i32.const 25442))
+(assert_return (invoke "good8" (i32.const 0)) (i32.const 25699))
+(assert_return (invoke "good9" (i32.const 0)) (i32.const 122))
+(assert_return (invoke "good10" (i32.const 0)) (i32.const 1684234849))
+(assert_return (invoke "good11" (i32.const 0)) (i32.const 1701077858))
+(assert_return (invoke "good12" (i32.const 0)) (i32.const 1717920867))
+(assert_return (invoke "good13" (i32.const 0)) (i32.const 122))
+
+(assert_return (invoke "good1" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good2" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good3" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good4" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good5" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good6" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good7" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good8" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good9" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good10" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good11" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good12" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "good13" (i32.const 65507)) (i32.const 0))
+
+(assert_return (invoke "good1" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "good2" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "good3" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "good4" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "good5" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "good6" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "good7" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "good8" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "good9" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "good10" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "good11" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "good12" (i32.const 65508)) (i32.const 0))
+(assert_trap (invoke "good13" (i32.const 65508)) "out of bounds memory access")
+
 (assert_trap (invoke "bad" (i32.const 0)) "out of bounds memory access")
 (assert_trap (invoke "bad" (i32.const 1)) "out of bounds memory access")
 
diff --git a/test/core/expected-output/address.wast.log b/test/core/expected-output/address.wast.log
deleted file mode 100644
index c2e443367..000000000
--- a/test/core/expected-output/address.wast.log
+++ /dev/null
@@ -1,38 +0,0 @@
-97 : i32
-98 : i32
-99 : i32
-122 : i32
-25185 : i32
-25185 : i32
-25442 : i32
-25699 : i32
-122 : i32
-1684234849 : i32
-1701077858 : i32
-1717920867 : i32
-122 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
-0 : i32
diff --git a/test/core/expected-output/func_ptrs.wast.log b/test/core/expected-output/func_ptrs.wast.log
deleted file mode 100644
index 8f757d3c0..000000000
--- a/test/core/expected-output/func_ptrs.wast.log
+++ /dev/null
@@ -1 +0,0 @@
-83 : i32
diff --git a/test/core/expected-output/if-label-scope.fail.wast.log b/test/core/expected-output/if-label-scope.fail.wast.log
deleted file mode 100644
index a3e1d79e1..000000000
--- a/test/core/expected-output/if-label-scope.fail.wast.log
+++ /dev/null
@@ -1 +0,0 @@
-test/if-label-scope.fail.wast:1.26-1.28: syntax error: unknown label $l
diff --git a/test/core/expected-output/imports.wast.log b/test/core/expected-output/imports.wast.log
deleted file mode 100644
index d16cd93fb..000000000
--- a/test/core/expected-output/imports.wast.log
+++ /dev/null
@@ -1,12 +0,0 @@
-13 : i32
-14 : i32
-42. : f32
-13 : i32
-13 : i32
-13. : f32
-13 : i32
-25. : f64
-53. : f64
-24. : f64
-24. : f64
-24. : f64
diff --git a/test/core/expected-output/names.wast.log b/test/core/expected-output/names.wast.log
deleted file mode 100644
index b694f3033..000000000
--- a/test/core/expected-output/names.wast.log
+++ /dev/null
@@ -1,2 +0,0 @@
-42 : i32
-123 : i32
diff --git a/test/core/expected-output/start.wast.log b/test/core/expected-output/start.wast.log
deleted file mode 100644
index f74aa5848..000000000
--- a/test/core/expected-output/start.wast.log
+++ /dev/null
@@ -1,2 +0,0 @@
-1 : i32
-2 : i32
diff --git a/test/core/func_ptrs.wast b/test/core/func_ptrs.wast
index f7edd9f44..ef54c5da0 100644
--- a/test/core/func_ptrs.wast
+++ b/test/core/func_ptrs.wast
@@ -23,6 +23,7 @@
 
   (func (export "four") (type $U) (call $print (get_local 0)))
 )
+
 (assert_return (invoke "one") (i32.const 13))
 (assert_return (invoke "two" (i32.const 13)) (i32.const 14))
 (assert_return (invoke "three" (i32.const 13)) (i32.const 11))
diff --git a/test/core/names.wast b/test/core/names.wast
index b749b2329..b58e4d4c6 100644
--- a/test/core/names.wast
+++ b/test/core/names.wast
@@ -1084,4 +1084,4 @@
   (export "print32" (func 2))
 )
 
-(invoke "print32" (i32.const 42) (i32.const 123))
+(assert_return (invoke "print32" (i32.const 42) (i32.const 123)))
diff --git a/test/core/run.py b/test/core/run.py
index 39593515d..2897284a4 100755
--- a/test/core/run.py
+++ b/test/core/run.py
@@ -12,8 +12,7 @@
 
 ownDir = os.path.dirname(os.path.abspath(sys.argv[0]))
 inputDir = ownDir
-expectDir = "expected-output"
-outputDir = os.path.join(inputDir, "output")
+outputDir = os.path.join(inputDir, "_output")
 
 parser = argparse.ArgumentParser()
 parser.add_argument("--wasm", metavar="<wasm-command>", default=os.path.join(os.getcwd(), "wasm"))
@@ -51,13 +50,11 @@ def _compareFile(self, expectFile, actualFile):
   def _runTestFile(self, inputPath):
     dir, inputFile = os.path.split(inputPath)
     outputPath = os.path.join(outputDir, inputFile)
-    expectPath = os.path.join(dir, os.path.join(expectDir, inputFile))
 
     # Run original file
     expectedExitCode = 1 if ".fail." in inputFile else 0
     logPath = self._auxFile(outputPath + ".log")
     self._runCommand(('%s "%s"') % (wasmCommand, inputPath), logPath, expectedExitCode)
-    self._compareFile(expectPath + ".log", logPath)
 
     if expectedExitCode != 0:
       return

From 1c4910da1e4ffa1cd2f57843ea4bb292bf933054 Mon Sep 17 00:00:00 2001
From: Sergey Rubanov <chi187@gmail.com>
Date: Thu, 29 Jun 2017 13:28:58 +0300
Subject: [PATCH 045/329] [spec] Use official WebAssembly logo (#513)

Fixes #477.
---
 document/conf.py         |   5 +++--
 document/placeholder.jpg | Bin 57021 -> 0 bytes
 document/webassembly.png | Bin 0 -> 43955 bytes
 3 files changed, 3 insertions(+), 2 deletions(-)
 delete mode 100644 document/placeholder.jpg
 create mode 100644 document/webassembly.png

diff --git a/document/conf.py b/document/conf.py
index 5971bb4a1..5e47f8eaf 100644
--- a/document/conf.py
+++ b/document/conf.py
@@ -59,7 +59,7 @@
 title = u'WebAssembly Specification'
 copyright = u'2017, WebAssembly Community Group'
 author = u'WebAssembly Community Group'
-logo = 'placeholder.jpg'
+logo = 'webassembly.png'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -136,7 +136,8 @@
 #
 html_theme_options = {
   'logo': logo,
-  'description': '  ',
+  'logo_name': 'WebAssembly',
+  'description': 'WebAssembly Specification',
   'fixed_sidebar': True,
   'sidebar_width': '260px',
   'sidebar_collapse': True,
diff --git a/document/placeholder.jpg b/document/placeholder.jpg
deleted file mode 100644
index a88c892c030a75b6f4f30bc649fcd4b99fc365c5..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 57021
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

diff --git a/document/webassembly.png b/document/webassembly.png
new file mode 100644
index 0000000000000000000000000000000000000000..f9edc61098a6f6957903d4e67d92c81269c22e49
GIT binary patch
literal 43955
zcmeFZc{G&o|37}um@*~HAWMiQLRrfevJat1$`T=KvWG08v6OuYA-l@bD~Xh)#8@I_
zuk6cMLLpNsMD@F_+w1-Le1D&Fet-PV`Tp@e-_x8^n)|+%=kj>2*QMxF20Dy8_v}Ov
zgi-gn)@cNx?}dNx+rg9iqM#}8V~6K)b8iIcY=eI=CJA8y2qJ*!YN?;`A6^`L<0jZ%
zdt=hNX)$(hxw619n*a)pJStLklKDnk*yPaVx5^wP_Ue`5EN$U?nH7~4VmFW0eTz?j
zX78xXtQMCaPc~%P*^@>1l6WmA<XA$~1F+#U?-y33r3f<dPhpNuORW%s<f}H2TGX|&
zGqB(_^1Eu+pFC~^@%fl{0DdQX1j%9$<eRP*J^F3zHu&*V@D3fK)}WFFM<BVZy<i0V
z2t?1rAGC*(U@lqZ-)|k?1HZfkQs@yT@PWC$PUuGddSFFzNHAO-L6n8Sis(n}f360e
zCTaO>y+n=^761L0AY2UnBu6p*`!7f&IppC9^sC|4_Tb<DPWLZLyJE8qLFQAoCQK;G
z{WoV|7#VVfeoz|nt;_C%(FoZI?mj=zgoE#BssBzs_g{keU#8eSm03m?q3nl*ep{m8
z5ZZZtHUv@2+u~uZzYnbQuPCZywwPxD0?hXS!^jiI5ri80ANt^HRPy9{zAahrjRF$x
zsitE?D8^4^_-|tnwKkNzEHEd8AA^u}(61vmcOX<AbmNAtjr}h<1G&$q!?klB6g~tP
zFs$hUGE_XUMX_-kR9Xm>8s#-0J0b;cCA}r)T*bqX7JY~UlLH7@UEIwXiV|*%)I8=u
z_KKYZatLOFP%!PsQo`*Z(-UxS%KN7Xjlw7nRyzt;i}LgpM@B7B`JsCg!Z6@_CYb;8
zzrQP?%%6lC62U4_=Y}hGgAwQgQ3}!+Bm!;?#X-qWt9pV(a#k$x|2~+=uBXfQI|L{|
zpc*_4wdg4x`@sIk;Pe_{UZm&YxnXrJF)=_bx&(aD5Dq9_g%nfAFXT4Sk@uoV(n1Fq
z8%$!T@+^SmOt`Od6_7^`geo}-YL8ru!y(U%^)0kp3V=<K@o*#mOAc5>ac2Kvu%ZVf
zgf>VtoW`gb0tq6>XH?SOfXW_jVYo!Ye?Pd*25H}-<!JF2WL{g`%>l@pimJo^a|uB5
zc0{oPDutE-2@2{4I$P@m01iZ9JW&Y=r0s>fqLM-fbmXk|fSr~JaKGiF{}hUMB9so4
zO=V#S1J%c1TF3(6U>s#TvGfE&v3%dh)N~a}+V8&}k|&M=*CCH`wLkLd6T2gbl<`Xd
zZOSS-rW;HoPbh#f!swVI1|Km}N&#<QqvF{jAn)k?LcR<P`L;R4!Wsd}Y;AXOFD4_)
z8}hG8gd{b9zomErnqS|9g5^g^w+1uF++V!70C&dd`iElAWl{mDYbU{!5a?SFD-BP?
z=IhsktH%0pvHfr{$$fX|sH?kx8pEK}>LLz}VKV3%901*tsQC4FFe4|@9*hF{q@(JE
zf76t<BS=RsIwKX%INWdn%!oxfb-}YBClb&Z11J;*M7W8F&FKbfsAa1yQtSvCIOMJO
z1z>{ILKI?8!QTh&rd7p7?T6$^q7LwpZ>BmHDWZ--LAs#JTPVacQO;yT^Y>>&QN`f#
z1}hc#^vPK*-g98Rf1k!S?_xuw9OuwYQ9B*~1eS?AE50N^?1DhAOG6oWZ@zse!gUvw
zum=zaf-HNvV-f97(7{nG&`q!6*^xK{akt%s$TYC=xCWHx__UPfHY6@Ou@2}#9$Gqi
zmGvOP6@PB{FwsC9?r;m;VZeDi1Hu)K?y!vRkVTbIM6R0ZE77vRCUvM2a%~E@!GH`F
zvl1ANfIa>lSdJf<!<Ju5hir_aY{<R*UW+WA6o06-Wm>DKT23A<EzHTnkdJ+l=0uQk
z0t7+1E_OSjWU6mLYKeweIf<&{q~hx&4Dx(tzXXEV*g@Ibyp=eKP|Du*r4hU??Ev46
zx1JhgYt!3Af_DhwiUt+e=E5DwV3qRq5JxyH1s%o%M{#bALVbbj8#s!i7+RJa3Qsq$
zJ$z)hXV8O{GoqB81Ps}{&DH>7tU^O+RlBnfQZ)&K0i_C+dDZz$K(g0PU<8A5P|<^O
zz!V1W@jz1;L5=#kCvYg^hg4rHR)BfsC()%Dbe=x(K7!B;P?=Ss9`nivuyEa3@rMz{
z&}^B|4a#`?`y_z9^91Yxvj=yedlbf=8xG}0{DBflTX-7Ww)KLfpo^y*nrSmlhY+|z
zf)Kc}RGN0hbvt4;fA~gXIed&F<3}T4CPY;A*-slNr*u?K{05htU+zLS!xGDYE^<)3
z1lPXybH`A5)+^ql8aluA^k`fZzyQrM#Qp<2)FUU#m|?>}Uz#IAz5Rwur3wIj5RD##
z)j%MgkJ7I268Isi7h@sj7Dsf&mqvFXf&(=G&{t7ovh%#PJb~@0fShHU!3EF+ge#m>
z)6bXh^7M(rE{_5*dJ#o!+)HQRW4Dvt&%dM@fk;EKLj6I;C>*T%^a(4W7|Nkl4a%W)
zM#}O7L(i>E|4*%~V5}J`;K3lzhe~Ru?oG0v!Lumz8CNZsPFLmyCmlzp&Px%?IuI%A
zt!JovX#FH+D1wzTT=0xnLJ%np$i9?gnJ;}t!G96YwI8a5tCF-!csC{^`rNRWmL)WQ
zu0!ba=PAk+c#869gbQ?C1XQk~Yx@l)uu>PEK6wzO@EGV^$`M_8_qYyyM)|pO(NWAO
zO9qgxqA3xSu4C(jck$4AL{aMzJ^BFJna$<?Nj_*gFcu>=m&)oAnWXsEnSP>bypImO
zZyvGQi#gD!1R=+cN{>B&pU-CIlJgrH6J$vp-Tti8(<eaPafag@Q|Ow>=$fy8mlQq(
zf>AV;9^C^NlRAoy_Fbqu%ta==vd}=C*a=iwC&q|3l0s~Dl7GD(QU6^IS#v-~)9XlE
z^6jGJ&O8)wfo|0pjcVRrCi>51=qR5*xCtz9xzhvKWXM3VWu#2FIL|pEgSA;)?%UvF
zW%O~@1CVZTBUkRGU18hO`z#9dSw{k)dR<Nuu}H1HmTeBG%wR(&+$Cw1uEbj*RrzTq
z#HqVbezmA8s8x)KddiK+N#=FdK%<q?LFsf7UN@0Mc#<){<Zf7~0zw^ipb}<3pEyoG
z7#DP4`T!2fxfMz#pB@MdSa{v}?cYYYa^HZ_8RBr)`IkET_^57h<W`jJVT0exG}ORS
zim2m#v2LcXBu7Vi^RCaGIMo5LswRo9sZ*_?NO`mas7fty>p?6_A0|W(P7OrO=LIYH
zu7-X`v$A7seVAMVbaLZRw`$7~K4igsU_TJ&2th-UOa_LC=Gx@YBqkqyIMrVO1{h_Q
zzR=HjIBY8^Hyn%nc1x68%LZ0M>e1bTTnL1`OU`pe$Sg|3TKxn}<7t}wF3w&rtVT1i
z8NgGiYmI8R+>`|`>OTkqL{YkfOAF6ufDn!W@}LetPRQ09`yU<Ko>2<I5)=*D8U_r+
zY8HsL=pX1e{PsbzH&GW)y9|W;ypD<6hV_#311^Jn$x<+w<^r`uS>PqLxLL*SlDhQt
z$x753I~G2Sh1?^L{MZS80mlwgMBew6ZD|~_LUrh$1x&QB`y?g~xTJgtAbxboKy=9w
zapIJn_);G`h3j1(ldb=s&5k`_IS({Dshe1S`oy>O5c$O`;RE$8v>5;x!~=ExuC30y
z2A)fv#4Mgu5&ts5<^Br1qVk~(cOH$2dVX&BH9MtjW@C;YM&fdAbT>z^TZ&&_sM~`=
zzIT0}n>OaaEFM(gu94vR!*(9Y`iRwTFhdUY0)x44xyt-h<+hcJ2E2V)O#2P8Jc<db
z;Spah!k>pg+F1X@y82)~LW2d6qRmy5gt4{e@1H3aAHFa7NsoGh<tQAen4V7u`cdES
zJwFk0krAk33Hl}E%EIr!RefVb739nPeeTWQmjG2tC{>GXKmsG@hJk#%fzJi6g!{qE
zK@{&c*9>fH#$RM$qoPV6KmCL+%TZ=#Ku9)ds!aZMPOGKC#d!gQw4?dfAVb<!+->*}
zibE9@heEb?3ukd(foj0d&4WZ0QcD2|EdB#cGq{++izA5!dDqH8vPV%sd7hp=qu7!C
z7D{azr7!O7wDCuMZ%WV%{bB2-kKTYMBNSe(OESdImz+6^$j%Q6#Q_abYks@<UxSHT
z?wqm)RFQaY_<Vidt`jH3mk!^k-XcxPy#Z#wHir|4Q^w*;*Y;0+4Scb7iIuB*llI}@
zpH&7x3{D{$n3mKre&Uoq2y^UG1_8bsC$)lhLe$%wMm69Jc-JwlYhF`+_UspmskhUL
zet<sb=M7W8R0&?dih`tfEb53qZ1MEnD1b&(w7~yI@z=AM$xG7k+wwKy)a$Ds%asCn
zS{y*ggzEiiIS03vY-pod{k$$}^E~&(Rf&A?rUR`Hk(KYJT9#IiIOU7TogkZU@pOAG
z58>p92D^-g2IACa;ENjBZFT2cS7J9UP;KRg9Dxv7<kM~`J~uqaWl%JciL)|L1`cCB
z7M7jJFT&f&Z7oo|TU~@-KY0nJ0}C&Q*=cI%u&f0T=Rh-ol_31|NrSDz?GQWGKoeMh
z1w=u0o%d!1vLRo+MgpvqJ{pL9G@H-K-7UF)3Y872UF8Ad)Ip+q*+8u1tW6m-|Ecw8
zD3=;EYS51S;cR~X(XYrx0yrk=mK9AG@Q#)Z^9_prCb#B^2I+0asisxdEwtI%)h<BK
z+CJ!)$paS&UTm7D{@60LmZh24;^&GXh^azQQONiw?_JA96B%LB?Z$I+>vONKfQMFS
zdPRNl*|2!RUnwW}b#<4%f-l@i2_@CFFHaix{prH^(Die}2XC;=3Du!*w{N|DbB$=r
z2R6LKBv%ML9P{L;FSIFFv{^xsz<;WX^@NL+p~Dw5^Sfg4P)dv8C^IT!4Fw@rftS4<
z4zhxMnU6FSfGTX5QF>da9&s6zOaL9bcz-JZ1xw_`kV^zG`3IV6+LWraX`b=Z3qEkk
znO+*Va<--jih%I56FRTBce=kx;txqJOTY3;RQS5@tREyMl!CZP$v6rzO<{i;RTCRo
z65^8V^=e_rl;FjC2e=%B4Rv}_oYz`e`j?xWzvsL%o?Wfj{GG=D!{1i0N4$S1lunRZ
z#z24Rz1X94;f}<-Ujf~`VD}*ydy)ChUuS84gfAa{=K<(&zSVlym$2WKTT{?_b|TsV
ztTTTdvX3zTj*EIEUH5cv;_stbY>V9O%v1Z4RDXLvhD)JkIzqdA?WJenF<XVk-`|z~
z{9KTju)Fq6V*Q1~?_+-k3{rqSP#88H0bhuJMYF%c!(YuJ=k+(n8-4}Q{aL3cc+E5b
zr-BUbh44VGH0yeT9~tCpncxTd*$({^`uYFrYoRayM~e!5_HWY-{QLh;o9yp$Py&Bt
z_ZN521HjK#ha3FkuaTjt8<fdkkAgaED2o60DFb}+7bt(-=l`AVbM4xXMKg$So1}*C
zxffEk5#$7{<Kc$_>u&V(_t9TTY$4$<CjR$ZhegR#P`z*61^8=qfBny2xBE8${f)a&
z0)L~;|Ndz6SE_#_%-;y}H^TglFn=Qqkig&4{%>i&<qG~LTmK{3Qd=DByfC6yvzKaa
z&+IGUC*YT_yG@;5SI%{Rb+~=!$!sPnQ!5|u6}2k@K1tWxR$s|E=nJaZ&R)&^@T(%x
zI*gy*9|P{6p3#G6!SGX(3J<*D=aeWswS=Gi)Bo93tq|S|f*-OTJTOH+x8T_}`Z*}{
zAE5qS5EaN@8KPqN3!5$b_&?QBJ~c!kh{O+T66KKfX}v^SvV6{Iy+4|}E(95f{_>Ef
zJm2h2?K9ftSj1&E_~*f#2*u&Ij^4+HSd4%Kuz1T0s*I$a_fq@Zv;XMo`K+Z}>*(-2
zVzdvpY+)F3Q)BJ+y7|u1e6y>KXDg2i2`Q>wv;voS(!DEU2YwSUn??k6-VJAe-H8bm
zWOGQKkaYSrkuuC6SDh;^T4>IScmX#=y{zYBWqc=m8L#3^J2uH`juTsal6T`S7xhvK
z9+?8}iSpqw-v1@ZbB*p1n=EH&Wk)OZ(}PiZU7ITMGAlB2M~j~P=Gf=fb@g5MQcnl>
zH9r`qDnB}ua6bz9{krpjJ%K9ECHDs0^$CT$DO!E(a*>E=4j|ziiL|Vtg)}df(5IZP
z10j2?PV3R@A}#m8dJFahT1*o@NWSC~sVzm2;@Yx~lXp<{G3)0f{4XP7Cq1nQp|$vo
z_)S;&t~?;#WQr?hLKLae0UmVV%TJP(F-POF!S`tU4ieRggqw6AP^&qs+*BF=2zr=e
z@w#vr_a`<%+VsqxHFH8}H^0K0XQ5))%^zXQyO9x;76$_DwK|TLLJaFkjquE^_DM>v
zK37pU6#t?;Mi+;C5dmxkN`!pLj5VPush`!?c+?Ovv769R#WNR~+Lt0IWsx5(`;e7S
zKmaOKGL~%0euE}ysChvmY<XMPzM32&)~wSM@C7Bg5D*qIV98EDLC;H1z1lcoPbd!~
zVrjpyHrybNm{HubE7?md*(0y*CQuc~6HCR7tJpbau}&Vc&3UVjOe}FAV5D8J_BpNh
z<Ii<#c0$sqC9Xj+iag_Hvi9P7f7kcKkY<dn5zy*ksMT#^$8(>|s3y|Mb2fGZ#n!#t
zS-CB!8yQpqw2C#S%-0oZ(HlD308;5Z+KD#XNVsyvM?Um;Eg-o!{-g0L;anw_y!4!x
zr8yf{L#qL~G9E}+R&ci?P-Q+~=z~4sRILJ2J^f~B6mnWmv~$B*ia&q@!?1AxTf=R5
zmkw6|NBI{ji58~*c<XuMvq2;gYt>0=qYEllW9|x>H}eZ!=0V&}0h%wPNW4tUTIdv{
z4Xfj*O-k-{FI_`h1Aut(kmR;)(g4kD<^;?vac!@s2?s`hrIoYh<LZ)7?NN3C930~`
z7+*=u;kOhNeoVx6kZ8xKrD9kPM^&Gi7m`F|J`akpP-~8!v)yYmd>U(|H1vsB71+Ea
zuw%1cV<iTU{453}JBaq`iWWY}+s;`T6|~7IO06MJnDHc$C_6Xnn}WMm4U@qyO~IvZ
z0n@j77&W~&#PQE@qVb*S8y5Yiw2=C%h?pUiVjwH#5idziO^?XS5Adw+4^6N<?*^wd
z<@^ai4_t%;fJtoIK?ee1H^D}tY1!48<u~u7vED}`Rx>|!`Gy5OA95G4FPi{!+?m%z
z;z1(CGGb!zH8O_>@2}OzAo<o1Ke;cMbVUQE;*t!kL}P04PPL&CVptQZ-|irKj9E0K
zwpeTKX$l^HFN*9((~=;F_5!VcoG_M`Y#IwFR8ngLIZSz7+q1cS_h#-KP4M%~CTGQI
zjKr^KKIT^pF)UEpa8@`VABFYN2dpj7WE53vYDj`4Tt+PI`7arT&vtK!lxGY<oS2KT
zV7LAPt+pMqy&ZbQ@pdl_nF%cxD-KN8k$ejP<sMO>tJ3|k<WC~luv2kgB{rNzPE&$f
zYB81{&RFkfbhUF+(#PhjLblo}@g>6VbcEmGjI=29gG#I`H(5S~%o`?CEJMoz_VDFv
z!cpz+*)RHX_?1JoagZRY|D1f+j`Gjg30-6lwDj*aHaFNV5sg?U{X-`@t!jB8F_QUL
zbG7K_lOVMzBsE`lOpelG@g!+i5Sf*)O|feS_3#hP$oTtn8dZm|^U(bIr*(ZoJTZK2
z3U!b3ZV<PHd6uq-VN0J2L_l<*Y_B}wnWL932iSQwf1ZHhq&;Dp-G6>0-a8FDyK~JQ
z+j9W&{^srcCha87r!<PpP}7KSJNg0@o^6SIcb*`ohZ&AJgvv)zb|gK8L6r03*!|Bp
z^(@^>9O8Y`CkzM6h*)w6@J}}9C9=PS$DaT8PZZ)!;GNFCMI!rhMjVbt^7)};OgS*O
z7(OagP2Tz?!!Fu$w9Vh<x!3RP(|ZI%Yq16W)c{=y=rYaj*{abP2LhkBt9N`jem)~B
z&K4y~<L5yvSp|*>1|FVSn9#!`ALS_|w10O0i`PV(>$OvUY*pRMs%pXzK=oqSgPbqs
zJLMsm&Bq^;d7LXghh^0D@#V8Ydh!@9Zsv<MNi!zwvlSsmJ#e4<CbFYrca)PVW7~|Q
zB3T06sGFD%a4yaG=j$^U#o6sQ2Os01HcgRX;Izm*z{-nzb=$Z3^1k&<5cZYg|9BF3
z1Mg{WnU~-<yA+{w8hJ&uQDu~b!O&;wjP+Ukz-hU@X^;Bp;bHzXdsUx{E_|o5H|U-~
zJFT9CYBkESVn>O7T}HVwy_vKanc&Mwb@n08!ssTKI=^{JOHG(PPa%!sajXG|#u5|c
zff<GlW5oX-!$R`oD6l{|?rPmsb#503j@7Kk0lqHg0^qo}y`2Z4-U#=N64D^HD1cS8
zRcTElfnODcMAkPTZpOd|F4+_E{qM2;*l=)m-2Xyhsd!T4M#iVC;#|STrWky_xwRJ3
z15<}l1E5rFa{q2Zxs;G%f<qv+)7Z=p1D45wu5_uUq?K8se46V<9&jlteK6>0V^!bD
z_vQd>LHvz&mGjIQ+6oMD=KKJQ2wI#6!=izwyi&4pkgk6_GMWL21_+!Hl^ve7m2jze
zzb$0id8`s|W=6osc(7vBvVgWdfi)Wp8*1LfG8(f?4u-9a+OrSBIA#{Qvi;(pP3vf;
z9uc@-8fy+e6EWY2ge%pGPO!^Jb0FA^ZL6DnfJcV!LIHk_(FswAA#009d%A|&WlYqX
zrxoVZjbWb|0iO55B{EEpov!UMh@Az#=8E}syI3Z6LWE;{;%#glR61(rBP*#pMQcTF
zOmlRtAHbgbpq*3$G<md8<~Vjif*LQ|Bt6u}n12-Du;!SMq9_P0ZQ=^8^U*wN0O~LT
zQk57fzW@TMKOW;tHh8*{^Q8gFCjiNu3s=|b`F|Si>e&r~<VENW+?T!NyO?bSYN-Zx
zKi;0YN3O*uoDWGMQJP9?^Six8<@@MlU@%?1Nm9G)6<0ObocMmocu&K}CypScN&eL%
zZA@PMBBQ9L2}Q~OgCs0u_^>yPh;?rn?|b6-WB5Z43j3gH%ugt!jaNj0LLYVvqbQN8
zJ!%tS$FUGd^tNOA22(Ib82E$zS@|A`7s)1=^18rybI}}^AxcqtgsBr8vB$`0LSm#B
zTg`78=vi5u;4#RJn!1rX|D-5Npy(O@&%1(B#$@I-;8^6K2trcl@7)t?^4h8TC5@@$
zc<J1ZvM3~|4O62E)sYzMe$U?8XZVyBB|bo({-MHq(@Iuj5d5>oPHYc;F!3ct5UGO3
zwF+G8*Kd0gj6FLh&0YrXtv^IWCVY`9b@*;Y5c}gTb%wi5bkjgu_fSV$KG2uVF`!h-
zi>w&R4`_J_SEjQI)$~3JVC6bop4QR>#GkF|QrvrFTg|JGJwSAf5cI(S%c+)Pb|W$P
z8rhA;zMhIp+UMHB!9r62WK}2OZnsEa84;}9iQDZj{28zob0-h?f1&y@*PJ0>C{=K;
zdgaEj6er$1&s-h_DgL3yP6V4G#FVDzM~;UE8oZSZPm0D2{__^3wJqc!e1g&Mr!az>
zfWYqs!be8k`|UPwp+>Kn<0cJrL1`eYTdq!$<$jy-pSu9K(VJncZ6f{4T8hHJugzH?
zu2BF`pSur@>9*I;yBZTPtB>=xZxc!|syY};zCOgvXZsZp!3c@?<v>VEz2%w`7IoG5
zAa&3_b`%%ujiFxp&d6Q~WDXPG)m1TU^5f*C+s7QDhwvT;iBZk~amIS#P{Y^#_wd==
z1q7C3zT5Ivh{kxH2%BbUJ1~+?BHzY}l|&&n(6-AN^}bO-)|QIpG1j7N7uoIU`dIeA
z@)tET;MxYEZM$l6VA_BG<Ejs6cGSnnUAnT8<*Q`ojbV7`2Y3g0ziT4kt*S9){@%=e
zIXQb+_P9py#0~CQkuDiixTg0*v+V>XZIy&WMj*`H{8=%&(Op;kS+SJ_-jq#=Sn_Um
z0{N%_mb?T(uD#fLRDWOHUHo7a5i6&4A)340#OzU}%tis7YL%3tF4o2ZlFtXFpB>9S
zh%XdM(D6KB`=aY-=^xArvc)?eG`B~+jyy5=!I+=+Os=zj!^U@|-~a027Ydc-EKdgc
zKUx4Sow}2fTs%_K02H2JYhza*jWoP9dtg_DycjkNXXUf8Lw8I3zJt?NDTb`%EzQ{`
zq`<L$9@v8SG?Dh;5fK?=f`W<_wiE$D4c}m7Ib}984s3fC+p&$T0OyPA`B-MRN#hgr
z<t{-1eOYW>-&goea0iEDF4BPN9`asg4~mbx8|kTix~!vLxWrD|gtvWAg+Xo<6oF=U
zo5M<L$<_mPZK-|gpn!vc&<$kd08^uhVNv2MGKvZ6pM|y%<qtGQftGG#cV&9<)@KFh
zSu1v}jCdREuSyHvn?;!Fsau~B9+<-~wG;8(q`=RGQAj1B<9Nuln^A@^<>b4ir>=Im
zat!dNgL@61<%>*N#o(oQCQFANq}vU{lqcjZnFnkN-~+a~nmXV3KK9#Z<+*+XP`eW7
z9QS7z(qcfAxeiMQW3s9!5kb9+Yxi6CZ2lIOTn3lXa|Ddz{*0TO2V#*GT#dBh9XeN#
zo*`B3Z|6l~JUbef!It}Lr8f$ut9RAh|9PW4ToCyTQ`C`E5=(CE_y1bJMZU}3^`$cA
z^M_dczawVC_+p6e?c>=Q@w6)AU}Bs<s+7<7q7Z65RLe<oTt#h7Yy8piiw<&ojrA%8
zrS?}GC<bwiLSMEcTM*+3lhnbY3&6YpxyO2HZV|D2?)0?8&6qsK(|ER<g>MzLOF)H|
z_R}UYc+a}93A^8CS2g(sLnoxD2?q$knL>sR#R@2ME_s!PPTx`*0WnqMxcfy&?y)0)
z5<i&5E?u5vA`z-R2MwEJxqzHE<Ji^Bph;%o$qYfeF_d5^=I6P9?>kWzBE)<lkg^x0
zI_grZGj4&1+qo@+5A6)tG((@tVj8TtCb+|-NTA7!!Q&7SU%UNJ>gm8#-0Y5W3`o;G
zg&}Wpk9>5DT807PqhS*lLXt_8zQsr;O9iEb_8*54KL`(yyi89WbIDvFaRaL2K!ENq
zZM?AKhbDa)2;ZJp;WAZXVKmD+r;{K(kEb0dOqW#vF2aHe5ax%X^eS3#Y8bOmu7z2@
zlNaeows9cgzPx+7nj#47MDEEC@&0<G8fIHdD~j!d!f$kh-;|a_k#C3!dd5}U0BLwF
znei*YT0AV4HXh@fya{<{-wE%@Kbv5^`P+8sBm)zQI-4bi9u8=a)*R~o5>u7iul}-?
zYZ{sTDaSSSg+nCGL<<q4fQTv&Q_Usseas|6!XeLH-WDX>g<}wegPA|IV*$$CVJl)p
z9$0D$7a+Xi1`&JCB#$*$D0IRq?J<lAkfaR|Pe*|5s_{I=PXUj?uwL5eb$yy^+(gT!
zlaZmEU(qHQi)Kkr8V`+q8J0`)c|0JQBSN$ha_@-}jYS%aDJJiE7D3Tj!wATJq8^<P
zyDkQLFqMSynfBfqkf%<FQfhe-QP3tro-}PcW=U@Tf=h7VH7&IVm_O&h2;kZTadrdX
zY)=KC?0S!7kCQG5_buODUrHa_P%B0`msL2VLT_gG>wy-14FRsy{8qZcFg2FljOKru
zrI)SkNP=h@D1w_xCqkb>wEYCQ>`4H6H6YqxCbZO?V(@0kJOiaq8<*K^>Jg|`;Kcb1
zTPq?!F|O^O!V{1EXQO~QnUcwHF~am2-6%BV;V(6?Vu~mdvE2c|LG_;!b~kZw2Iw&{
zo_hn_*aGNOsaZV6Ya9am>?A%rElKQ3ro^@E;aRvs$;Q}-0(@PJEw+d5_YmKYw>08*
z#d~Wl6)m!l@lyKaR?vW;yoR)<iG|fDyR~C2dkRfSI5C@X!|<cr9iZ+hOx+8VCIsz8
zr2RXFd=@|`Up!Z<?PV}PFbwkhA@G|<ljufcz%TThKx?ep_1w$kUYm&)Ww&L|%L>L2
zyLEF8jN=ZQafEgV%1<YH?}!o3@|CfX&jWWquVkF*;r$OEUI1KD;(=UjNRaMChTw`?
zN_QdfV*HKSGuF?&LXL|b)5TWeF82PXaaIZwH|T?dlS>7sPABm3P6K!Kf+gNp*0MS4
z8rcG3%oo^x{;}M&$t--08Ud5w<)6}bs7MUk!AjY~MfQgL=Z`5kiAG#u$M8Re)vIE0
z4dqL-j=6EA%z`+ze=gw9y;Or_&`E$=vA6y<XgNQ3cQHk0_0xlz^J+7vNw|Fh&1`_d
zABblf90MF|CTmV2sMLZYssk)^l*bn%%&|W9AanZ)_d8&Chkka7m(#O@<vMGQzQ2Xe
ziGRJ-)j>3LZi5ndI}Iz(eKL>4X7{tlY5{q3w=02eo;-g373iIbL0`V~RVL6?Vr|8$
z_?HatOP~;t)8IdX>{f`(jibPL4+^6|*BB!2AzJJ&nL0s_Pn7H#$;HSny#{sCP6{7r
za8R1yurjf*9^lJLDdszkR6s70aNB=0?lp92qgRi4pAh8}#FX<w?Y%i9Vg~@_caSK+
zbzOwNU@ZpP;xV$fD)Jj<^^7B+2)!8gkKgU?WGY`<Ozbl)W6+_<xG4=gk)W*r04{bM
z3<Tb>ZMI4E+Vl?n4(+u{Vwl;dlO-S%(<hHF78eN0kI;!}!(nfT_=izQ8-CLjty@zB
z{e|Vvo2fQGW%^!CZ^NJ*&s5F=3F}Omuc)OZ+TnONEZxgS?%Mp?H6TJnIt0nTAq3nE
ziTEWE?C(2K<owk6jGJ{ru}CFuJ_G#sG#s!E*}4SNr=njnBGGFpDW<WkprBi(`pJwx
zTSuEtYn_<Dv)veG;BHVLq?1^N<q0(4+_1(8wg$Fi9pZz`e1msD$75@NlXcr5JE^WP
zid=H30H8cXbDhM2nZ;8rS;(s(HCF?^SOZ8>zNRF08L8_`<CLylPc7U{KrD=_L%cOb
zDYu|v>I*(EA3vc-?7F>holS~=vJMCemf@!ZlW_oZDj3>cfR_32;!9z`i?Z2u8SM>Y
zh|EaY6a)D~4oFnl>B@~#@JJcVAyw=N5m#6+4L~kJq6y5U=@sKxTQpsx>Y=L$_d?}@
zE-K6UvE^Z_q&nZAjFd0-1e+Jzz^^~zkaUn~tMP+KnpymDE&4LPL+AH=7G48%!t^W0
zu^po11n45zo_qa}dB$dUynW%<q%0^*7(h24RKFR&dO|s%+u02{OB4$$PsP-MxKhu&
zHrArZ?Tw3iIKDW2z=g~JSK-gqO1x^jnS44^Nd3bdi8U2!4b=%43h1gzJwkrMFa$b1
zcE)&`CIJ&<>Ty_6H_Q~2!E2pybLKcR4~#lQ_jPou;xPr)sC}hGZ1S(8lf2hO6Cx?V
z2zHLf(aG4UG71HF^HE4}AgAHowhtP66X<9!s33zXO>E@Fgn?R=vh6p>j`9y3tu0}D
zZ-iU>-JCTM`$uT|LHV;Smi*!0Iru?f`!l~jQJr_=4^1>O%i_=ZT?jvvdA)z%fs$V`
zo0U8-3K&1ItXWb0shlVq`5vI<l&aW(@sRH-te?%|DoXA9vzw06=AWa4d=rWlc;Z2f
z>bx$cu<^oQS2RaZUGF1$PBAqYzcQEFC$NL#_j#`)2`iWWXrHrW<`=}!q@fbuoLbHl
zKEV0S)|+ixMxp}K8gRe;7M21{JmVd0{`DY-gQ+>yJ|lz|=<zZ>NY#_q=6uJq7<@;9
zf$~O1rzG<G1hBkc6_SCLuR{l8@RU`$HcbD^jQy5NqD`uo<-3M-_;ki%nmBY2ei+Vv
z*O+mw-m5vjPbN>buJfe!TF$N_cQ4q$BB&@RUCzJe{v%q+2}gB<<RuO~etCsO{Wx%0
zby1kE2NTRIz03P6Kp$Odqacg#_roXdz)@~M1ZY~l;m9l&w>wBgRtR~jsug=%17r2I
z0xPq4XyHT9RZ{67D=m5TfR$vxiXm-%r4lr3KoW7~TPx$*zF-iLH=z9+>V2z;!3TY&
znCqSKP8QheWOX$yM((w}5~L@}*!X*BNZ8{fjuHTf^dz3JPSyI-vEfXsZMGIsZMyb*
z_TEz|%V_~@Wpl%A1BhWINTDI9Z+OFo44d`!J_<&kV%MaF=p|*;M+;=5M6hVI$Ui&w
z{0hq(P$c!YAj<#{2q!Y%ZG<aeCs3Z(er%aD*ag9Q;mVqyT@l6-hBSi+FO9fvo;#<C
zGE;oYRE*XIfgn2){N5yxJwd~e$_IJY%J?l39W+i}W>8rzsf&*;<olGSo5A<uwaRZZ
z&~-Tta`G)TN??2V9n^UxJ~h$5W4O_Bc;JO<H0Uv3Utf|^3S0&8ED5+!8YfiEKsk>S
zDNyZo*r^yiwV8>Ce;Mz98vpg7$%(|F?VjSm(SAD_y>~#K5RuP|o#6Rh8YPeox&aB)
z(e>uXngYC_4%xg8f}kZHNc;{Lz)nz0_RMn_Vav-?9(rqZBy@`w?(^R@>m=n{6`;vR
z;Ro8GL`wyqX8qo+(qN-9wbDAA?z@{1L7ny9xTEtO)W06k>&yu^5%CKmVV`#sC~e>r
z$WNHbFsbz}z8OHmp75$Mj*e;ynaCbE*LqKIXQR`u^p#I~-pMNFtF{TAJLIVu1^Ynj
zFb~#<$Q)1}WgF&aq2Q-1Q}*y>W)-J{SNBwgZBZCG!|1LWN5q3<lBx_@mW&k;`=H)d
z=Z19X1a+CMJU;01kZaWE_oFsYsIzJ+q~MV*NaG(%_9#H2doUZul2p5goE6^$4ihdo
zMh)#_CYGiHy?H>-|7Y*Qp-)l8QTY}-)oQ{n%i=6DTc%r$N(*bXI6{?=Tayr)64+LO
zP-Gp`9|HJ&pISOAm{anIKO_~$khv7O_Xdw=NE*pz3`g+;JV!NN4<&;HFZr~h?j3#i
zBxGWLQ2iz>Aa@hK0q26YI6`c#zrlVpbr)E=C5gn+Z-g5=8gO_gM}htKb=!vw9->5i
zW9O{nLD9m%kdNXgkp@WXE(xZVvs%<6+qzCa{^0^r!*2OBP*hY)Db0k{(w7Uu#iZVu
zz9%HIHahLhu7DYock+)VP^S+u=Qz|7gqh}E%{dSvW<X7YuE;CF(lUd!xfX-Bk+!mM
zHs}Mr@eUT1f5yoxg3*=Wzk@vWqR}S}M`-}!V$tDHf5kR=mu>R1im|*l<#JG7P?_0u
z)1w%?hG$Cc(CcLg-WUM5DbJe%5)K-wpbr6bRJJJ?iyXmK+Iii@YXJALmJWx|{&`ko
ziC@$qU@{Und+*m@zmC);+?IW3y60_!7<Qe;1JGLslL0kQ`D-a05HeB)L>`S{Z3vL*
z&Pp@Otp1(B9|S5JbL}tvt)Phxs-1eMcQJF^K2i3dG|Gsjh>UPW)ph<D{7=(2lj^LF
zVot%JpMYxVWzGy{saU<BCsH%`Fk+U*J(NxiI|Y()O;0P=R$C@)DQx~#)R?iP3yY5w
z&(lqa|86?;vl(<M9Pym5h)HZ7U5(dZ-wXjZBapcTzT<j#K(m^>{))f$f>;u2Xuy%S
zP0oH@t&n`?ZAk8ca!gF2W~6E@9U_uH1bpi8;OhkE;^$%$hruzH-bY<lNAYVi(TEz@
z9-M#KofdoIHg4E#w5xoNq1491yT{OQMOl|}6c+^yL^CCUC8>fLBJ2!qplx}CwK6$R
zq={xhUbzrZkqa6-cc4&|yNU4l0*EO^FcSvwgfFWTig|V{zKP@NtYY)02HpU}qG|$-
zn-VZAIY2|$%dEU<mkZ95a5gGmb->}69td6MEML{q+Tw}$_CsT#G{{T}1HH6p^d2-@
zr|~s=@ct2n4vh~_u@LL9RC%JJQk2S+jDV9zI&zB5)G4Va?bjJ<7!40^#5bQy17SeJ
z^T@h`>kcP5Yy>P>GAxy&bQ^n$h*+up(udaFVH;Xl*F5c4&-5!|jsK6=5(hwYTLUt6
z!Vpv<ESh59eO)UBGmW(n`2sDE0n2OCQTt*M7jcOh$IF%J%q13kYi}SC;C>Ui#!@Xx
zS9j(JUC=<#l_xMM12*|+T<f>s4locjfmmS8kd0%Dy;C4AY-rl#wpiR4<Z4O?l@&AN
zU*U8oHY5c1KCDEVV6ki|L2Q{J7Ieq%1_t(Lv9)%wH6T?xr9L_zRIL{r7mHK-?h2YE
z@o+%G1Gm4C0<{L+1>o!iB!nr_q7EacwR*CpgRh-#i<8~|rM5y@KGgQ%^%ZOG%bM`o
z1Wfa_phRkJ{FGs?Fd*+{bQ2|BY?CxRelT#@Ub|}UjO1rl(Ak7a8SdCMdl{U)pc4iy
zk4LqipNaQ;tNHfG`}&)1UvpM&SGaBEIoJL@TJw532lKGTQe2b<L^|*a_dG9#zqrkl
zcmGGcYa)+n<{2#(O>uW{vJ(a(b7WSV>A7XrOYuR;IF@)ICR=ameZVR~b22mUzN2f_
zC}m1M-VH*TVMQ}7<2F(at#`1_UE#p>@b2i5jx$2fmiHb)+eTcD2lbDrb}*|*#0r$^
z;?!h-<HVPJX4Vnd8R@u|J)Bv%-tlKJ$SsBS1s^>jBAG-E=-%ccW1%j#0Q!W|DDER*
z{03?J<Gi6Nw4%OIlzph<e7Rf7=|VmduE0N>RX=lKZ$pdaU9TLF-hxx;C|DHLl(3}4
z-caFpm(ri`*T`Ws{wL#>Yoht<oiX?(DOLNJp&g#EwLrxw9C+DWwVU8`M1QR0U6BWo
zW^v>D!Txg@{I62;K+?eiJ)QrPV)Nr9Tvid+rQ<mTi5{DeZq3(+m$q2YX|w}LWH6Y=
zig(w~dkt8j?M^jzz^H%_CkIh6#-?(ycPQ7j{z{vl=SH14<=pPlr)zgX3^NdAOs-k~
znO+ad4<q1Q5Mc`Dz0xZuUDxE;XG`nGwJU;qCp1lrv{=Gfcddlq>c40y3}Pa%iY5>w
z5Cih`X;wF5g1Yq)ANejvS3Bi`dHG!nXF8ZWnC;&T`Cis_e?=b#M~c>Js{TX7<}t|M
zE&vLwlL#6~webQ420-CxX8`a=!qO2RoPE%H3rVN-!r7=v3B<wNKqu9B|2dZ%=P7O}
z$yc5m_*$^qzJe}{q5mRtdzIqs5f^ElP!`}F$ZXUacC8U_7IkkG$#2)fxud&pSij3s
zUW)8Wu5)PF6A$iZM10WQ+JP1xyQ^_<#V-XQDrMr!wQ123x!X5Yc!o1707dKj?A$K`
z57y2|RYQOjsq{jDCvsbdI9{GAuJo4gGC$+yb+@+&<SG}g*oN4IxDMQPo74bZhkWSo
zsgX{E2p{&wB6fnz+zZ3o&yDV%be9=EAg|DJlSD}d_>Os+el*_Ol>7ilocw1-w>^oS
zFyb`~J?~i83C_!%$J4w@9<dbu;ocA}1nD%#Olyh4%Cxthb5hGm(DFVrG3=9!>p23T
zL(5DS-n;E)ci0<;mG`Txc{}<GW$s2%HmPL`7dp<8i{K6emah2LL*nu;oqAV0f>=#c
z*sE07J`0219o>rE3UI?Cg4lc~NcmH-u%x;$Hy+Eur69-Q!*`E;m%Rl}GD5i-X6dg@
z&U&t7j+EZIHLo@R<V|r&L|vkS-W^7o3AyT>u)E5$fg*-yZjU2BS2-3=lyV*Uu`eK;
z{*5Afi(r=i!7EUTKfsf%fL{VY6A}DusLN?*a<I4ac!yr8PHiGFOscfn-Ge=JeP_>p
z$lM`LzU*&PM{IJ;Z@=sp6nfSjHgZI=qQ7bLVjD<V2MAN3jht@*DK`bj8@wb>znFp_
zmX`~9(zxsM*2K&_TAT9N2?}|n&te|nKpma}s3k($A6Y($3+PkQpDF_YSaEH=ar<VB
zMP>38N3m=>RiC-aQps4#9>#ombZM)X94X23AqEnQRSxo9>oI>;#TpL`#cuqb4SdV#
zC>C^vpq{b*1s<zTNpyT31i99HGO$+#(C{)Ogf7;$$H`ca%xLe=!&Ik`$m^lLCf=iQ
z{DUET^uAtELN9Dkd4(Ik)YOPv9hb~{R9`%5xh3-1$ju=!aB*l1gaE`K1YE+oi~n2{
zm49@AeG(P^1<=P*p>uBwnHT$Le+cg)<9;BP5+JT-2zfkeNQ`n&WqcjIk>N0rc8;uS
zwcb`kanb(j1v*!brRz~cjj}E>a~0qmkR?;NH}o^aN+rmEa0<B|#G0coEw6sn{=KW?
z)p7KABAlCnQ-p|bKB=(kWc`iu=^VHvln-0tRB?llX`}gZaKQR%=wkiP`l;3E6_DLL
zmsSm8l39qwlXFqe(y-~t-q;C@COcm5o1Ez7PQ6l9=h$C8oy<_>vOH>%kZOxm<u4*p
z_FWUlBxz2{{lQ9Kf=NHleBVt87c@IX2wgGFv^?|{*3~H>>BY{&n#2FiR?F<&4v(8n
zC;1k?jHF#(_4g^Le!(4ZLbNlPw$XB_gOoPAJ=@GhMt;(DZspZ!eCIR9dD#D5W8*wB
zeKd;d2(p9j7O}1aqV}5-6??r2F5=nMnR8FT*?tcL#G<f-c8fP)KxBG2rE`D=s%E{+
zj0&lNft_|C)D`NDA8$cP{0#K}k?hT{nX&QJ##%kRkG$LBWDc3Dk7>*sv1ag@nff-?
z&x2-h4;^&-GwA~{cz4^fjYDsvK!CiLn#-}dpMN1w7j*CrJAo5Bv$v0L%I<j+Br*Gp
zdsh!ENodt6)_&jH?v&QV6T@bM+-JJ&N#AGF%~|C;N0*bi8DPwSt<g@9Gr_wf<OVMz
zViIftZtE2X4oO)4tJ7nZ!p}=VY{05H%lV(Jhjw3A`bR!@uOQ}$0f<=&>mN)d6klhI
zbZE$nKD{5M)-TrfAfuwIY5h{VD`TWD?-m{MdV7VRi-F$UVL67*fh(d;_MMNxX;IqC
zz<*Sqd+jY`$pj6*PLMhw*QVR^{Zly>z6MUUg2Mr0J!iAY#E?=$8(VGS!mG#d3Wa)x
z?C=~2E*Z;~_s137A1LHILts4uV4RUpyNfp|WWUs%d8Fs9as2(O%FhI9>T4ZO{^?Lp
z%Y94QIZHqGsK7bAxHq&2bu0~=ppU6H4oXQGr%r|^vo2X3x|PWv2IbR*0;UsJ&Qwje
zTcnrHX(3Nwx1%mnX>-~ObNSfo>L2ziw?GRl<CbOjNP<*eMZ)8RA{TJ3n+aM@$awS1
zX#Z5s1%-fPUMaaIo0XORoyWUC+qH35%OaKdeaD=zZpO-g-|l<}ue&e9X1<{<{)0%^
zS$4vc58DlOnPy#5fOZ|ZL5kEKGG9>BJCa?@2-2x1@Gg8^dMtZ|h~&)cCC9w=;f$Z!
z(dMiVj=mF4pU?Z%W1hSeW!p}?7#7?MP6p4xTlC}Ll#I#nOR095<HS*5RkfnpRhHoN
z&5_@czRNJ!#K#?607cu_=RkUgjK8_w<-d5osyq;bsa!TS?>KpoXclkI9X=FU8@FP-
zvUi2srV?7=)qpWaWxY6ufR`8TK3RQ8lwW&biIdxZ(@hJ_>;yXYEWv0L5ny-(9HfY&
zyv{z&0xr0`1mJS?(k$cC@?!Cr@mqtZ1>-<Z#0Nd3EA1V;C+spta{*;;4=f>R1ar_4
zv2{+r`=7f2gjYvux^sS?7XvqefWsDxei`7RgX9ulDl*I!svK!rKZwnjh2Yqqs$Aj!
z`gCru!^-Xnm)o|pz2I2o2yWq0hcj6S0D+w7SwT$tsn?Mr$T7M5u3KRJ<ixF)WA}(*
zFF~mzwIY>R`wE<@p4Kx=mRfaAfM|tomjBBc$#X1iM!48hJ7tUNFRi7G-kW*e=?8o!
zXjKWwA8NJjd{?Biai`4${CA_ru@~W8!Zi_2aa&PhlHIBG)@u{gCR?E5H<=6DOcYI=
z#=t$2SZDkA8{JHEFV#)~(kaoB*QV~w9EPFi=&OnL-Ipen^qV}G`jgF^F5IA2PCo)6
z<RVP@)<lF1#dgLo1U!CxawzC!c3mwIyRy53sWiRg+E36EOdcigMDNrneEDD~T&p8$
z`7kP99G;o12D~p{|D?1xhlkbn6uIJF%J)kpz{WuLFxnAb4FTmdIx#3U`0Diffv^W6
z*N0b*4o<`_ubHqDzC9ej2M*gi7)x(8y(UUklaMDcakp%G8EeL_H2_KjgZj4<3kQUb
z9Da;m{IIDH^W|`i>P{*HmxwMxzv?;lW<n&Y?9^&-bKF%);7L~bR1aKL`uVVNPx94@
zu9%mK?aRp0qnxcf5#lgMO!xdk1ja5gdv?t+dwowhb}jH<sc#g}+bTu5EBC)xie3T%
zg#&svePxLK)7GSl{)|8)kDBRg8b3s3+OuUO1NgUb&2CRWUH79okkiE}e+R@1@wwNP
zDW2GYhv#7g%?tnY%ToKMw~)N6xe}oL+JzfyVjrExRt-TzZ->nSG=f6*V-+G%Gmceb
zt?+)B%JzxxHlroGK^eqwh$y8=Gq=4#S4x6%(Tm>u#t6snnAaueuyQN$pNa40teoC#
zVe32jWe0@0y?*On-M(=r<#eVN;tK2Cnll{gA|xFDY?FIdRk`(}^-Bh?6ZV4BRPS*8
zcTK)YTBfCb;UlooIS8G;=Y3G}gFg1I>$JArgeMM~8{Y#Dw`HgD%^m`XaeH^9fdSm6
z1BXKv&{LI7+G?|)Rb7tYmwhB$XFJdOGVMvxa?q0rE}>_#`!i~vlxsIT#h5eUK-q+3
zuYI-BA=KraF44^r4OnCw5}a6n1Hyyselw@u*L&h$4g$O^#xl8PL&~*L%9o4SFTHj8
zBX0ScM@gaxU+IWj5F0;J&2lw4Vq*I<OI3bjc+<rKx~Q^(nP^h)mk<)pZ76=F7!<1O
zF-M)P9<K%c+PZexc>OUxs4C+lvI+tyQYQUwDw-=*^YN!4r$5KmKEH`O3+%3(h;@;9
zMgym+Amg)XhT3`h7;jth=v<c27YT5~e&|+iuweZLrsI3{^?Ff?S>VY_{parXMvp0M
z1a*E(wsb<|pntV|bG_G0S$fSc@|pZ$$Dy;I4kbzNziOhzq5+ipm_Jb2UF;i=`X68&
zt}uo3?0cgFl96{0#I5qr-jOdFSMyGe2x#~79m&(tEzbvCoFgsgO2EaYj3tT*^f@la
zq6OHmM=~H|Lo^q`^9pjpo%-j%MWWhJ?k0Z!w+Osrhh7u%l-<a<eup>NC{bl&xoKC@
z?g!=C_C`N6tF`Z{mI<GlnDt4*l|w&gvqQqY<!J3$e~=39KjNyM+u>|XXndaiX`69}
zslVhlePwf;ic=G~re@;;#6nK7QhB|tqk1<X<AVNU&WkCd$L*}X28SFI9QkeI?m4zA
zAT{Etf}=9!1vDWckpNpGmi8hZM$3FzYaZjgGL>J~etiB==XLKqn_KqWkoPOP*K`gR
z`GXuXC+Bs&0~6?%=yja2ePL{0$zRpJs?qZ4um9A)C3?CJ7g|#)`*G~rS;w1_6lP3N
z6kfL^{bEegdDhT98Y!jqEfWvMxi#rXy+Fs82Rq_Le&&DivSd~FwVli}WILaeO89h$
z%jx?ou9E#fNIE(6diQ|3W~Pd&`S<YaEVebCycQg?7F3e*NvQP(`?9aqM>^REIX99T
z{sKGZ6zfS)>T<^ChFoL{?zH;i8*}}d${UM*(P-*DPJ&Nk$b88IF1p^=8QI$w+tk_k
zL}Ctr?5ikU-@|ojb>pdE*umX@us!Zd0lN29tmKjn2gKgQdU3R>SkAX|cy)wCBO=$q
zgrrz{zTjTurtbGy`X}K(_1vxGPD_5dEHorUDA}j*xnvd5?}N;7cW}+eY>&$N#j!~{
zY9#E?d|r!?)cgEbPkgWEQa(?b4}DAl<Zb4Hj;f5>@1<Z>CJ);ZgEJOJ!kqF;ZR&DM
zmFdz)g$P`CCu`nDuGjxO%c{0R252i=Ch%tghR7`Iax~M(SC4o~@+!Ew`_9<CbRYA+
zh<L$g-~!^i;CzwHc|^^?2p60&!IURBd7$C4;nSc~BMxVDE6rZW?8W)g$>Q4b-kA6C
ziG)G6-lpK6-BA~ey>wQ=_^{$7-`lIp!RZl!L;ECuC8daazhn7n+o3<0sJYW>n0{wI
zpxoYJM|au9h|P@ydC%UNJWxJmB5YA$_0OYx$NU@AwH3a~-q82Xz@NJZ)~3z&SX*hG
zD&$v@{4_H)KF9r2=F)heZ4!=Kh~NWG>&{n7Dt=NuwF~M`9@SrM?IZKj#g$<R&0x<l
zH8&Dpq4P?tLiuh?;|ZU91hVG7H^|3Ul__)IwVRp_S4KWcpHVRGyTbh`T)Bj-NHR$I
z)$^VuoBo@#)r<MFtdvYBxluXq@EDbv`?8w<Xjk-gF9{XC?qL2iE>vK3MJq?6Q;o4;
zph9u|7dxi>0HB1rS9x<@XSs6c(((iC_0f_Pr{P4+WR2&u=_2yU0{dm}sv6;NlC#r_
z2)hOwaEbJQ@NeV1myI8xqvt9v>u%h^OLa}1d%pCIr7kMmWoKT8#VhmoJIvxC@NT4A
zT)bm^cTP`rHAS=7pvKB(Q%AU{HXv+I*b2tZnSAyl5Z)?HEKJ2L)6}>`?)egXaLBvp
zvw{Q}!(fe0Du>BvqwMuZaYUs54p7JFOMqN_U!qmI=@HF;3{-<c(w^`~CfabnW~n>T
z^RuS=aK}uVR!@!yR;5Bx@mgY`EYJ_S#hu=_iQ&s9Nq2^00xOgy`R+f=cmK-x;P&Kj
zlXQa?QVL83@oawcFfjPlZQh>;Z$~F6*4A+rlfC#Yo6^*SD`L3I#A{Z!qoz6<OTW+k
zVz5U{->b{bh6(oqjrJYU8{s6WX<OA9X;K0jodEDnAn-@uyd5pS6YP-_;&HOzXA4Jt
zi@Opj^7M<66PI^BaoM{Z&`2*EZsCu~dgNMqS`EK%v29X3f_89+jWf_b<yh_H(%g+J
zpB7yjKDSLa_nM{zF?W@w@b8OQP1sNCyE(iw{Wx*nfF0AtXvstFgM7OCw-;1zkLK~0
zbw0Vr<dgQvqIHKu?@Sax?YYtS>WWfLtLHU997i!EE=Ai=^|aH(K<R76V-Fsd@RTvz
zLneM`nrc$k8~JBBOAqL78Tu$Kx!J;LLjLHCud}Nv=_>QUN9xtLCE!#n?j>U#?<>*p
z;NJBXS05WANcRg5fBu&}*K;!k(+-pw8#7N_84*>y=ljt=U}|Q*T3=kFQ-IDFH-|4H
zsNIB+y}HuxPyb`O$Czy_{%X#hVLgnM(q@<Aod*x|9X(^-i+Mhrv~;{f7YkhuphREt
zs@Z|aXL_nZ{5yLryyt;a;b(e2ywfT0?2(_gx81wgfveotF%ZQGsE0oIb7%O?kUHP5
z$2yb#>2Oy%7V+Z;!PMe?;vT`sx&R|w33ti9(c6H54#0pk%7A(9BmVO;k&5F3HICvc
zK36lXnbdN=1)IMd?cows*KRdyz36#@9aFZO(gzuM4j7ORyqIRDSY}YsyIfdhQq-L8
zDbxGjq(+N1R1w>?yPn&SUjx6KjHE%YQZp$u(CPY#>T(HxU%j5QI?(sL8e^EM%Uz(Q
z!;eZTZ{o_1S~ezsrV!!kLK)&iiTx9JL#B#7GgrOtT3NLQ_?Emkk!qca5Wz}FEmoy?
zZy(sTC3{w7`z4))&VBL=w}#w`+j>6dzPR*2@xIk#M>pAUc3HY<t~69UAk3Wbu^~Wi
zS#xJU{Jd!WrnA8BO`M6S+~$}ZnDX)JovJ&I`3cnQ0!?5bqglY5%h``G{!9vzf46rc
zaawU$*iy69%?M}zt)4$pUK;v11*e+Op?S&}bcy=W#Q7$R=82P<$CtkRdR6%SS5xsX
zg_7Hsn6nQ>=Sx0cnh{bfJLYG3&2tIixC^8r_OjERe%4$oCCg{$*LQ2HD=g0p=qD1-
zb&ebd*G}xjMtP=2FUYP`Mw;p(t1x7Wk?t1rpOiD~_@~rR_{iCJCcclg+V{DiW5-<D
z-YQwMeex$L^MPHPy)GXyNVN6bZ*iY9@~Pf2<@~XZN{#!mx98u9#gO9`Bg+yfLW{9o
zPO2ne6p+t*B4H9w29<T09%LFzRn{J?<d5uki8=6WcxS6wP<tASy+WjA<l5B}!T2S2
zVS08oxJk0MA^-TEO@sCeXT5iF@O?V?^jYLx^Fqd~ENk#9OI!@o9NC)ew(J;BNhtJW
znO>!y`SD4|vnGz?DtFS&4K6)+Hg&ZkRRsHPSDb~}kO?j*8Hha=k|Vg0{{3#@u@>vq
zY1(9x$z0^J-lR;gk;nYlyZJZi*&HNFeD3TmBLUoz-cTiIB^(Za9=r1fahmiS-*uW+
zzcYL~X{JZ6Q-SGwm_<Ovo`L<3Z(I9cyNUB;hP3o`*nDcX(3}uDnte9r(jlRdM9r@+
zN|I(dTg@!ps&nE@rTXXgc4*Uoh9ST#lU_LZqVo-h%L)(PS=<#?oH-l#J-Foh`v|Gl
zCjV`7tYyM#h5)vR{B!$(o)az3Amk@pJg=DZVP;#QB3}@H+~j;Jz`1>$hQtrjoa*dC
z`*T6^C<J=p(DQ13@s8ssnCx!ZMotWAepGb6bGNGRke!$>F57U%Ue`}R2?Q-0#>`{E
z{w`Fdi}?G}PibMvdyK<olKy!JoRR6Q*K2K7dv+4pOT^O<F!%qo_vMdJf8YPl86y+2
zMfNpB^pX$>*=xw2tt6#vl?X{mlS0;{?AstqS&L9fBPGdBo2`*7Z77Mdeb0SXpTFVz
z!`qMM&hwso?&F;EIOm?{9cudi$^5X0JnttjQ_?(qYzuNqm6n%v(hkL@)jSuFzM#CW
z$z7vR&R@h!Rx>^mg)Fz^vy?Rhmp4S*{x7rRr1iefKl+;IPW#He<OhQzDJ@)02Ujtu
z#Eor3C_g%l<#XQc*wxEreIPinw`IAW<v_F)Y&SSKzAzPG(Pk5*w8qU!Y$lCAN2a;;
zQ#LNM3h4(#iJlJ(uq}18IVtzj&QeKZ*pW2QU`ML0$L3I^D>14p<Wy6S7@)qEKeafh
z4&ilz*K)%-&XZ}Mqu~9KruRvj?}s>D&rf=Tf^#xU6R1QK0FHi>$mhKIzN1X?M)myi
z!2b0MM2i^%(>~D1{RmC{oI1mnDJNIzF{JOihTQ%+uZ({@2)8^p=4k$~BdOQ0+~%u_
zTb=*m)>Y$o#P5GwU2E=Z0cP<5muZwj+JCzEhu=~1%jZmcIk}J8o^7LW<lHBIV*W&K
zS9(<~9$`Q}m_UlZh)|n0c<N+j|Fbp6ViWT0Wz75qdrj76T0ir;f(V@DRBcY2R?+$a
zM_$4sL6`vf#S#iy^nd-SBGns>xGy!-$J=VoFA5ZQt#(x$QE6_gpQwEWeaC2|d=!oC
zrJDW5EWLNz`wbV3dW!4Qu5DbNpIY#p_u-9w$zU)46z03S*7-IDMxlt7s}@A-j;LwT
znTj^B6Yn=DDqVBB^oQSuh%!$v1$+T2x3)a07_AqpO-14twAJktJ6?R;F7RaYEnXvu
z=$4mz&z1~y6$Qn(g>m+7^PW{C#+-LV{;mxk4|pH24ST_hbo1q?WA7xx&o#z)B!T?<
zPQQ7RwBl0`ehhnyV`j!BpHpp<%@?<Qn{Ey=Bo8ItI%aHNpS}IlMz%QSuMtD}a>R92
ze1z<#q6n_XU>(4rU}vL|Kb6VuVH#p>TQd?Xy=*j7yk+KMeP5mCNr*=U(!>#NpTR>1
zA-;R#+tnr(bWUSFW8f-F)fUgErbn{Xw;gWs04rH-Mbdb;*^b#OAE~n4Imp}joVhow
z@tUznursS*`b|jzSKp(eL1a7DLyi~S*@COZSwM~HNDdjFynY>(E-Qn>`e)U4wH>qP
zB?vy8dNypv{)wzH<<J0@@fwfR6DI>_bVjDa&bQv|){eaWVcI@CsQmONYuh!}DzR;h
z-2kTV`r>5=uG5eCGrYi7bysV-d~Dn|oUOFYaQ60xioU*tmb7lAxRl?7CWj1{nD7~n
z*AlcpBeM({V|OvPJ+CNvJGYkJ%-@zNa%*eb!gG!U-G>Zg5PJ<cmjh#84V`76;|NSp
zF7)k<{c;Z}nIgFxgLa+DxPQy;cSezDNn6OoxuJf+>|xFDv*&1MkjoI>pJeUdcw`5M
zcgf4RSEs3^Xk>9o+q{V=VO;#^f;^ESgv6CsJu75CuPFWEfvrbPrkFlim?EO~rMf3i
z;FgVnUteo?wGnrxqgmra(K1)nV>>utGo@EEtnsgEd3-dud3H%QqQJz8<aPAuSVVAs
z5AV_5#rLtux*rR~rmd-t9%0KPQ%w<O^53K=zYVh%R(hUuGhx;3n7y;s^W!~+Cy@5d
z66*vEVa<<c+2<B@6%f`FJbqS9G5oGt@m`4OZLyV(*wu#JC4x_q<WpWNTAKm@hfMOv
z&xd^Tsb9VpyH$O0B!R63mq<fEOd!W}&;?R>fQ_!d{-|%Qr2sfxnzR+E?OkmFaYvGy
zWf<flJ1b61$v9diCw%VyyvUXC)9a~g1xY1HhP$@#B47E@cB2sYt(rdE_*aM4O*I}p
zn7v_}v~9OQl5HjHJA*gTJHJLrNvvPUc~HpoTFqo+NWAtk5{p+w_JPlIP_sl7<Jc#!
zOq2cI)@^$fbW7<EMJD-++80m028-}RI`Q^*?Av!xz5BW3&4h@mJ6`*5u8~vg5n%6S
z?dA4zu_e_Xq69LIA$5DIp6yF!{jI3PvGZ=0q0d%MuFrc8uO0l}dc5y=Axl7F__MRM
z$$9TS@4HScv!LHa8tgtj-Cds`wAq`c@ZsPa+tiz-UPm~bwY-w=o7ma?wlbw}qvX8a
z07g-XZ%<H~yFu5a+2@^d?&4ciHh$(c@=-SX@!RW2<SeCakNvQSbM42@V9pw#b|>~Q
zlF3v*+?Kk(c)r^wnZ14+uh*qkIS0>JIWvDXVobS)Y!sEKeU_4~loHF4VTAB&#j7`C
zO~@WTm&JEQsEcXM9nHj7RpuO&$}A)5-V3)^O^W(t66Yh33Z*z*`t0>xn`8aZMk!y~
zyzBiTp~GIIr3FhGb=#!PUcHoKJ_#kDnqHoa^xl)1XV@g`Oo;Pw@Lh&%vYJP3o{r+N
zn#?-d4ZG^^j+XZF$q=wd!?c~oiz3Gf^ctieo;5SaY=mr^j~TDY(exy}C@b9SXq{;i
zx2qEJ!TR^>oO|<pEWifYAbJGvL<>k{QU1Emub_L6gCFZ%y;Ij66n2<$7*)248I>~Z
zz$5Lv`Fv5!C4uCFmn>wH?}}(Ho$wQG%lhn@Tb%ewcID7dxxjcsmly(bloSJ5h7A(L
zI*6;MUQKulWpNf5uUuIAX@Xv9-K&KV5gm~z*_*{5e%!Jvl3|GCOJ%WP8}Q8nt!K+>
zCVxNK7Tc<6tDvyVKCqLQ&}2WLQGJ>$c}!Yw7}%hFt09Xya%55YZ+oiM=A_?UF*r$r
zNZ_Laal0-&?Pgi%-V2(ceu=M|-a<|W*~T-pr`{(WdyZ~cG5g*LcQ%y23aNFMJ#%p^
znU94MZ^d)rHZw19PPD5c$oXDxWlH^7+Lb~%RDLC2|E2BSliGGumYfXsp9WK4+KF$X
zunrcgDUOwBDUYF?Yb&y!^yIUQXm-xcpMYcv95{GPj}7wXA9Aa7(re7mB$KB3kj?!_
zA7D{dZQJeNex&KJ><mwPQKFYDBs+WpHjF+Nh!OP#X#Vz#snweX1=4_;$o_<&TU7io
z&As`Db)h3&Yi-9m!4KCBU4mD&J32K|lm4!*tuAmZ!L;z+wz6ap`Q^~Vk{|D08rrik
zwof@*e@Wt>@mb0{v*5dVt>}EhA4J{V^p-|>Uj{3zyjHk3s5;TTA&<k7Wkg}l%aUy&
z*RK^~#-kokwaK{Ti3N_><r+&ClUb-$<?}74D;+vv2by@j!LGXBoU@^tt9Dg4M`hQA
z9Y~yf;X3)Dx~D?@3%<MFms#`bIY0O+ZFBd#h?iUXqm>B85uskzm=2%G(4&Gr|0m2#
zfh~D=oZWI?RGpm(X|&0k6&%_42`(bJOUigqwdGYvB54{i086H}te+?Bl0DcxSJ^hl
zPy!NdKd0P(TL27wb&SkJ%DJv>vXR*QZoqcY1s2t>``!~ugbzJB|6%U~na?S2^Fvl#
zf}hI6`|O9TNWsH}WNHV3tI%oP9vw6PxJap5w#tQ<EeXr}1njMpMv6JUR$u!jc(*?a
zE&zEp%$4*`XSE#er<pmu(gLU4+7P0jILSOZ7mzsWHM)0Y)8gdK9#wUbi7R}Ye6Hvf
z8*^jlkrKUz_00Mwm$0poZ%&B6edX=!eD3C3<xg(uxn#=?mZlQy5568&j5#WdE5tHd
zF7(u<&C$;lZ?b-^?r|j_jDIqC+Q*^Lz;#75rm)DK=Yle+R<>IJJl#s?-={A)Pt6Bz
z_+}>`rMv$~;+dabY%y-|qUwl(_m)Q=YOj(e)jYbiR)t(8aiOZ4<&`!_x-aK=&ZW(I
zJZeAV`F-g1HF9qY--@te>z%tF+=7n;uS$%TVvu21@o#_=Iw`Vo;q15c@*(f-&mBtl
zsK4A(8}4|<YjtmX{e;LhL+ldQ<MWYl`&RQ6Ml2&~u-J2CRjsp|iIR=|lJUkn;t@52
zr_%Jv24S-)0Y=;|!A7#qxir2jP1?cALpl(m&sGF5`&*!$qwwnWsCND0RJp<L`qS*;
z?04_8`=*}h4XVZwM-<}ruV3CFkBJHxkXOnDXeW~VK)tzddn%SRf-i9mO-<XUJ2K|t
zGWK1YoDWRj|ArQHuTPKXut<%JJmyljrV7VKr1p!x<Ojn`n(E^>EqEKG6jRIX{`(b}
zSJ1smsUPdCTGDu9!i7|OD=%`W+F<y+c*y6r+y3=?Z+hRl>60T3KSDfhO6pWcR=rh>
zShI<5dG0oK@YET0a8)^F-|vD`592B@`Ly}SWhvcEj2aEzB@;)&TBFXYn%46NcsvtT
z14i5CCY4=-(}aJhK8dD$fU8k3&EYdFe@42l422)b+J94UkCNH`pqYpM5s!MTCyzsf
z&V$32&Wpc-LO+Z7<LilAI-8zc9C^*qanqx3M}oH9oWdognPb$?V$;G%Ok+2*`xNa6
z!Nl1!>l*IVW$ei}kU77h$xNV-pj#Reh5bgpuU9UL=6ND@IZL|bH`FlPuH0`C+;ZZ4
zj(7Dw8}ZPWvX&b#MxXNBFo&x*jR!^XSk<?ENk?Qqgoq@_74sU=%I+L{n1QIL!40pC
z8Pm7SvCbSTQs)L-f^<+2uR;2l`oj~mQqR3S$67LH@?*{?=MVHl0VGF_1#?=V=Av+L
zw|m;Nztqg9jdsR}yX26H(!%cjCtux{Hdo{8U5(9OOr7YIM~}2in>c><!MBbL+^^id
z-+P1VPgWb`oaY~f7x}gc9w2mP1}Us99@L9KX1>>mTlH(j_iT63wAxP_`QKb=+($mx
z@*_|tvie9(=3>F~kAoo-m_L-9CgPEe6uZOtB-#0e0f$^2D^l@y9)t6<-%peu+G8^;
z3@;?tauBsqE$i0Zesdw6*!#Z5H`4o&ye4L)HgRe0vm9!CG36NJ@{)!KDl}2+k$Y6@
zfu-G5FG|x3>2Y#bnKHH5f3mkux=GgYZbSww?u<Jna3TiHUnv(_u)klxB)7Pu?#>g5
z$d^G^bF%lQE=<u%(!62}&8u4oSced8JKBdfU{j}TZQPyR);w}ATWe&QeDAi};Cx_F
zI&1?JEvUY8F0z{b#>l+hUL&U^mCdUt9V$)=zcNCf_4W)cP6u4Mj4BIaRTIf%nmBsq
zOGW#>sv3pm-8}p5E+)O8MLHK&b!Quy8O0K)S%7Czw0JLmqs{__WVvc---jiNR^fmA
zie^OOvLZ7OIS9gFd|SX1Vaw|yvEL|B>}@Z3UcJ9>z}H}(q=HFNv7)nr-;!g?je>-0
z@Pp*7WBe~5K{$syHh6fIf5W4N`{EItSAU6)oc=M^lDJ)eb7PgQ^QD8Ow*|1;t;9Bb
zs5;K_(`HXKJUY7d$V1g&5l-(wvo*U99km8Nese80eFA6?{@A^=;hr+nG<}LwNTY_B
z=!1e)XMPna&qRj_Qywm^H~H5K5dXYNoF#yW>7<s&UX!MsLpov0C8yPI(@u`4<LjQ5
z?{<S6<B4TvRcCfX3ORroJEI<j^`Sy;6&=?2Fyq@)iu~wY^ho!EM*Z{QcZ|4!ZxG-V
zQ@<Pma-CK*&2wBeXn_7oA&Txhd<qg}vSi(X>7CBwI}G;KVU69co3V+jfOY~x`)VlA
z<@i1rYM&3(`cRtuu53hKr<y)-R`Cay{^<nLy)VxsDFm#(&N$@Kj9nYkM#Ltnq@rk!
zZn-sWCOk*F4NufKJI_oVQZziTx(Z{cR(9q1qE#uV1`7qWE6S<lf2!&?w_<(T_a|lY
zqipImJaHwhW$!Erb5gi4h5%gJX?UXlbK(m7qkSUTSs8-@bKkA5<&v9s#bVT+k&g!C
z;r%?F{~>w#EM}Z(RUf}T*<t$rW|C~_h=K9UP|UbibLDQoJXcBX_}f_m2MF{z#g80o
zkZ;_Z3;SYIsc`M|Ej}a0e1*rux)1Miq^h4us3`Se^q>SXZ9fv%G?#q8PWdJKt<JiW
zPmFntW)4|rs&>U*U}TN_hq>T+an3<}plWbmK*{h7Du#aB1NDj1jS%*tax~?89$id}
z(j;QRQ-F4}zYpzGotoKx?%S2tf|BH9XORt)BM<It1pO+abV#{0z~IHkWBwl3!8AL0
zDrNhBzGNDdPVzG1-lMnn;g%WGom2d;tT%!S-*PtdGa2*Ak|uhf%4KJoTxgm1ZncY_
z^0yTioZJz?c2qv3kY<e0`NnLs0P0_n9qr9ieqGkcuU<@1M4TD78?TKoUcOLS5ezAG
zImV2YW$PlK_l@YCd@vNUu=42gld0<uD$R^DyAxMpG>y0`ESKO{Tz}e-I>nIo)jFg+
zdO}1(vb9rhSeMF$-a7p;N9P%Eu>Q}ro9uo{sK6BsAi_8wV0#nNfFGO*nB+KSyJzo9
zsC7=e6UQH@s@^d4XnyA>x3e)p&GHc3%eDf*Q6-~lS7YJ+Y++rB$jdW4dbYXbTjj}x
z%j%0d4R2U6r=1txA*gHu#J%ocT-lpYYi$>0Y2(;xzh*{y-6M<I3U3S>hqPA+Rhg?G
z>NxIzcrL2{ChGCjwWmObe#nJ?y76u$Vo5{#c9rY$es5_#Stul(Udx0zxrcPE81Zz*
zt$;0c(vZhVxjFE~%rn98Wouf=T<ycioQ;n<<j(O?`~a8D^Q@S+dN^0sQ|vepV9X=Y
zSoAv3B(u@wvE;a+9ZMETo^}?)*CD9;XfrP(4^_1>3TxS-q^-3}-|UETw(vMbBqZ4<
zR0t|ceODSK7Z;4|Xorx>igU^Isf1&#hUGoO%`0Z3klIPU;miz%7g(`hF;dj6xWRN!
z6CRm<7aU6@6`B5CSV?hz+8HNDoU~HFu-CQ>RD0GfRt=_UrA@?%ztFtIwY>e(^bW(W
z3_0Q!6Df?U^>YM#x9WQ+`D3bz;ank6gs5+dp|_UENwOs^z(7OC9A3DJG(R=r!{T3;
zb3I<+W$J}21EU>rGt-yEclAu1<aH}_-eHj-aqamjPAon%`AQA}P5mO5OcQYS@?|GH
zGHL-Dhn1DnvyppBO3h~;y)0EU1f}}4Kw4IJ5~!&8DAYD3FWFOc2ho@UM}48FoL`?b
zh(QAV@ixf0H4)FF6m4(eFq1<1+|(fGkonH(b%aznF~BCr3&}KZH0@`kx_Bsh9yGFh
zBUuTLuD$Zh=q`oFQVF3qKuCuXxJ$>4{`fxHLq)hGsN9P5_p|gMc~2K@E7I3D$2TY$
z(a$U{<KT2UdZ8S#2kpyJRNK^t1MAGRHW%a&AP=#|s1LTR6~#T`58Xx<yF;(;q_G|@
zExah*`~hC|@;QKNlx<;W{(b$WN3CW7^&9&r1vbD4f?Xn7(;3<@)8|MjkGRoadfNFR
zzyTO(Y$C|t|8S|ep<2>(qFm2wV^Lu*RIsp$H)?a>my=1oDAk?_W9g`<00Kmo)S`e!
zyvqvlqHFV$p%Sb@(e%DS7}BS+AvgWK>R!=(bdB)u(%cyJsFF__aw2SN#2uV@FQl;+
z74nWt5HW}L5Rq2H2v#KULzr7p32dlC3Y)#|CBu!;-$UELCuFDot~Hstye?L53N`y}
zL=QNO)%+Cr5@D`W4h!aD!W7$&`4=I!(Rodd=+HFqLr}U))y#i-U!D$Hoe+C4V&oH%
z5uFtPM>Rf63wd+cWawx9ivn#Vb(Y6G^__5>a<432s>0|20`pn;L)+?}sQR3TGS%62
zgn`%SppPpHEE%p7pa#H!cP}afPQ<2Ot6(?F<^aZ-#yZCb=bbQjMHWt*z&UXsxSUW8
zX0#(H>zOexHp#W?!HD|+2o?kubt{rjV46;xn#+JbL<x*OE1+=&%`bd*{_&C#x5g`~
zFPl-&yDN?90+>sHTdsi&5_|GZBmZRki4t)ODe8k*`&`~;IdE~WYT)>q>v6O+Ef`IF
zMRlHGj+bmIt{U1u(=s7UK0Xnh0khBq-0}>V(SyW{xaotZDNmJIV(jHCkP-aH1eHJl
z%#C5DkOLZHj2a_&{hb42ehcp7()53;<<Qw(XI>!yf{SUuh*vLA^|wUj;Hlr-`f!>l
z3+uNO0ZhP=5@5pfH~kz?h3z2b7chni*nT<Kh3jTWdA7WS4{9A5H#%I)3qpNaN0G<4
zgC8ZzWuQ3}+H{(gz}qqR+C*(>TPP!9qrYT`a>?kkVmV^7`TCc)S-c_aUx7xI56J$X
zZV?t`Mcm<sSBkhb(=RxZFkLI!Yu$1kIfowlD8A*Mzjb9%gMt2=UAg-}vST0_QeO+4
z{?~9lE|#Y4M(XRxB})h^<@<ZrWcKdatdpaNw*I>ew{Gg+r|1E-_PRx8Y@M-Fv743P
zU*nI-y|eiDIW(o+fkR6G)4Zq^@;`F@bzZH~tL5<Ry*qg7dxg;V>3xs4VKvc^7r}s{
z$8y9!pFWTy*0wEfX_1JW)Q-erOy!<ImconCSj*m8N+8$-x|xT*<4*ljZF8OIw6qXJ
zb~cvG=I6$A)xffdxMf94QPVwhN1QNMo))0dSO8=VJEw^vytqvdx@G-hc2bI>LTzGx
z$ub;GAN6(uFV13|rNeef;>Oxx{XqNRu%AHFEF1j4kGy`;$JCvRsGqf?sk;?f*s#R^
zg9fS>QqcqBWBC>6Q{gW~VPe}mH@5Q{!iLkoH!|if`Vn9KwG)OA#{i=B5|<7F8GVY`
zcWoXGv?4JA8*d?u>flu$R^$q%lR+V^i{GCc^DH(+^TCKS&Tx7uxe6<KrNpf(2pfVe
zzaLhcAB=y76I*Qj9}_u@)@}<&XRIhZPV=|v);htF?#7~gUK!YPrxzFck-8Q~9Z5dQ
zvDQ#Y!5;D3U4<{rLcrWd9=7GFfC>xzj4(7?$kUDLf*&h8S5RjJ&;QZP8Vc#p=jT0s
z(^KpGL(i}}dfi;=d=B@FVIGeyxaq%f>2f|Yg(!Wv4Pvn<Q}?#yq7{ZL_-b6@lBLk^
z<3qTOF!!GMhHb<qvFk{-H03Dl70PX=IaM|c2cx1Ued^MoI{bJ9>x_{mIv`u1KLQ)}
zoOvNDOqpJz(lzYA>D(UE=Lpbghh#NNzM$Yct+ZpHh+dOR)~L)Pdda_lPLKY@L+vXG
zq&@B#bC1H$!xldC-u@7LTt4A5B5U(Ca>V(hF}d+KK&TrbR2ve!<O7opX$27FuL#gI
zuQaf27Exbi=I;<Y3O~QS+{Sc#-ubU)8=-Mbo>60(o<Mfd23x{bwt|N&;LI3Pe|#^O
z%&@@C4~T!N!zzIhm7>>8D&)A-<lpC$NhQdyGAz7ZhA;mjbV#i3wW*~*79_*Xr8vjd
z#9ZaYOZYn^O@}deVTO599{1e8p`Pc(+Iw7q=ro=Kd<4VJN5NKd-g(pd!j5TWjCt+J
z)UkYLD;w$=ZDAF^Ry+nJB9gQCTrA%wBce*fopCB@zihHJF*I4EVJhX-5)VNU#SjKt
zlHsMiy2Fq2du=v1F+vi^WM_wq>m0f>ZCZ^Z_|P+g+b+t@$2M_(l0Tf2lwiZ7H#buG
zjO(#6k4rGvNj%yns<6ZK14fo=m)@pPbGU2gv!beNWxshyhscAWM`2vRreB~yJ)f3t
zKm9=BPnC<X44VA#U5XgW??<0Xb(ZF)-$78RFZjp=%cI|8dacqJ(~1N-c_|6nO>LkY
zl7t}R10Y{KGIYW(o@D=>Dju_`St*k062Rv1Y3|FBkhs(upHykW3q;>F%zIdtxs9kZ
zEQ{;@_?h2s0c@M?XxsDPRbHe>Z|7kVvF`Va1Xs3}gU~m}>v2tHa2p^r2~l95jC}54
z@if}Np_CdD)w@l__;|G5e-x5HwjShG8qgTxfNB!-)k(W9txQ|5uCccGCQJ<mnbVGU
z=Ejb5i9kQZ6&E!j2NcZdp5D$Mp-g8aPs@7T)@yy|wz%eBUrme=oQQinQNab)h^d!P
zi?&(x+Dr@6M9QUf%`Ox`bG8k@O%O?3=qVN&QB_pva}5=?++q?SvXvEgR*eVUT|EzA
z=8(J;NTDww!_W9BO`MKTQVhR$m8^{lRMNy=zG>mYqe=b|%=p$ehIIOeEcc(dmQfdf
z!B5;f*-)1Z=j)xSruSVHF$EMX5%Am3H|wwGzRT-9gHnFwAJFUIWYO^ELflu>9OD3P
z5u?v(-FW<qGsuv;Gd;+Nv%fLk6yz%G42$J=n{QI$rk_I+1$V?MXh%!wYBL91KP1h~
zIK$e+#RYA|frzb5KSW7G)CKdmAkV7V>u`@3O3Xj8`Zv~32&|<?A$YXAR<jJ=4wm>N
zuQ4v)0u7X@HJ9J)BHo|YS{WPWgj57Sp_xR1fT3kY^4~SWGR`;99wqi6!I1h{&VNG`
z=E~%NoH;#6t0Z?Pc%E{`8A#!SHxx<}op$DIPx2qXo-IXPzyWl{@$ir47wcinR_Nck
zZb-dP44Ij(`AdQrI=D!O&wFTYe}~g}21ht5r!i$-mXf$O7c^z#V?jLk_Vl_2bz@Kg
z(s>31rnu9V7iZYK-DQMNQlwnGZ>&k6P8vds81@2bTqC=HQ#%rr6!sb3ng<K;S-Rwn
zAOP`iJ1$jrgxwG6C~TZxK;05trPGd_eH}BW_Dw@x2Gv$)X~Hjj`=_4ADu{M1HvD3)
zi3D-r&63)XP~R{B?lJ#bCgk{Eoc1xAK{V>kiE9f&V>9e~*BR*o&uLYf(V-CUAE5-s
z@VTI*9ZQasq6cxbt7t$`E`+4C{wlz(;YFRx7j|gG9mW~;2i!OXIm>;rF3zymuf-W-
zkwWLgw#5W75m!oJGpdR*wt&hzB-uC#z9Efs1wp3-1+odButI5WU1xlv+gFsdE8fYP
zLUOVO*uynxqMLI&0nVAM@SwQ`si-!C#X<Eb;?NG$!8R72-|9k8jTce0)_^1NB>$-(
zR0E=~h5+#kY2E3+C~CN;*ZW|m5mL)R`M_R2U2TRFFhyg0&YmARN8re(kQQeh4!Ny7
z<IL({I1@Ej_NK<5E&k74{J`EZ$xZF*KF&7b{M?(PrLbP6da!PsR7r3mWh%T;Pc!cL
z{LDrCK+<Tw^xon;=)m1TiKp-oR05di`yqPQRYZJaQbb))3{CI7zRm`##E9J~ct%No
z@qqem75{H}Vly5lG}Cl6${T`M9)S+{7jp8-u${;Wj{IpH89?n?3{8YyNj5Y8UaNU%
zarMn4#RX;6#9wd)uzf{xmsR@qm|Xl~(I%wI;t_c+`ngOb75YeMTU|s5IM!;jnmF4k
zl++Zye_vJF+a<>gxvdMR&VYPTnyQ3{0mBG({89YiM+LpdWjJ86Mm<uI0`)gt4K?Z<
zTf?M|HpQohRnox`4*muBEu&ul8dk5>AwD}+cezC!LWwX!q*KQlg-tlJ)8C{~of62K
zb(q>+0Aw2&arhkStqZ*RFHydJsp2Y0q1&+Vr>0Oo$~;=L46zJaBmx2OiXj=oYa9n=
zaMf!k{qS+O>D;)-I}*s#Cpmn=3x9=qXf!2E`rsJvKkZ@8mP>X>*A}(fDS63dhyQ>(
zmaHs{Tq*;#F<>>{e4^JGa?`RxHBGn^$d>ll-B1xcy&u50YHN~20drci2IsKJ%tls7
zPNgHU*G3GYTkcHe0V(Qd1h9eTkgz==%U;WttZhWEBO<!yEZnG>4z=)5RoJVI-V3|s
zH724}dXI<mjVlebw}=(x{g}i%y><5!{yV%?6O4c!fDeK8(x+NC@&)XE(lw~<GTgK>
z%)ZlbyyzG6LwgF&^)c_l)s!|ksj?W>OmdQiRNaa5f`S$tO<fe&+(fOzA5-JoX!116
zP*+cNO%bRHsK(~Xr>lMBE4#Lh7Lpk!(dxlvTMC=H+W`4?TKSj=O%*y!F_hZqe?D#t
zKFDLyGEa`k>Ux9(gKUvk_F+=#`qd8P6~#7PF)PxZW`n&^uB*iOGK)DIqQxO=p)Rm8
zRzY#^-lIkbrY(p9G&i<wY~SbO+zqUEi{@qQwI0LREzd71b;3sy*^pM<teNfKypF_d
zZF<v)myo)9#yMXgTO0g@I?};ECx_>9%{#%tD`=>HgmdXsX{0AXtv00*x-w`RWr5iD
zuK64|&gE?p>*4JPnK+yTQmvL)TiK;NM%|4Mh?Js9iFI3-44$&Kurh!PFbI<yuz*Wv
z(`&8-C6h8xD3K6X=`MO+NtR1lC6f;ZxppDPHF(vB!?K$1Zr|9RK|w>-S8njl(qET0
zaot>02AI~^x74HJ@r|@BmoJ1M1d$Jr8!&6_Y1qbEqrC6BQ>*^7bENq6w-X|FQP0pY
zO3bhz&qan-SpQqGi-#QBE`sj|3jvQez8xIdJB0Y=7mZ3@Tt>PdRX2jH4JdcA+(&KA
z0-foxXSi(D%s>s=66JqFsdXEt&DI1O(b?qjJ<4ZiL+Up{pADdI6CMIyLXg<O`C1+v
zf|q<z9<O917Qk$2@6Z<_GNex~PoTnaALtKg`>)mQwnC7M?$8IffTLfFVcu%^OoQZ&
z+DqdP07bB<g%b=*1JBf@POE*??LuS8D~uF~qkkR(g$Cvsi7+obs|)irPk_|RcLkbd
z@#X*VX?V%Thh=EKfHBj(<w>vMrl;E|#Ss49VFQrLy@TerXUK~TL_{3aP-@s_YVZ#z
zsUn8dqoO|Uh<i({GT$Xd9YLZ`u7?;Yqv7tW^O&1LD%wPc8y3fTLDeJ#wS~=jq;Z)6
zZ`Ysf%qTp*23%bxjHuA(!_?YFuJTjpuknYBP)OGgdmCyh-Ml(R%tvuuni$hT4NHk^
z4+O`y9v^fV#Ui=O#?p7KP34Evmbp+h2N6XAo8YN_N@+tasSGvl`M_%e8sfulV!w03
zyVHP=t#i?X{pkJ2+fa!Qn?#siuMy~J0GNjQ++Ah|s5T*_1*6SngyfQabRM^Dow4qt
zg?EQa6Lr4j3RGO$Fya|w@yDj;RPdt$hyGwOjsz%*vX?j-{4FzHB&QsG!8xMxZ(bl3
zO1J|{ZsL@=EJfeOUN(xLaF=;=R)H?SZUq$`7{-Y|gLXyx2{^rQd<W<2Lr<uE#1i^$
z|9aQ0nu{pYWz?&N_=tu2rQ8SF1~yc7oNf{xB)odF`2`hx*IrkWeZ-K|^}V!kYw%Y(
zK|F+t&ESf>oHvcz@=W7Fbo)%Tx<dAOD^^wgO-5_-PvQFp%um_w0vj$SU`?U>wBaV^
zana9};+kG;71bMxw||QTsGY|LWXsAPjgrzu1By+hbdM8Q!76s5P67QCX~KC#plWw;
zKKEI^;Fk*Z`S|A$%QjJe8!$uAJb<geBf+!ekj@ks4!7{#>tRPHpztKIdJ9msvQ1ZD
zLMfFlWw$@8Qfy>5dBp{NMXX+O#pz?CR(i(?ueP=-u|8II%WXt_$3@VJR6=j$?zQ%*
zzg>?*Cp0A%#W8fMw2O#lOyYsq%Hdt`jXD!6Bm<}LtDvZmIRynywBIiBVoxf=-MMK=
zk4ML}qv3TEKp?KXQ=+IVOWEZMu@I?P(G~6nX_Wfnw=-|6*!=ByaIuhLWIuEFVzXpL
zdKP<7XBs+$4+S1PE<Di6CRLQvYsdr;v%FGtRc7!bDiG37!dBKdd<B?gSzX0NCc=9j
z%Iv|2nYe5dOB)Wp2=x<aTQb;y0#75AxTYE#xxS>45@|k%uLyqgA!+lJ;F9!eq0xil
z?aH@qi$_Q^k9~WK8Yf7WT$K<zl(;)pkR>vIMYSHbPAvCG<G^L=S>ICGWPV%=yKya;
z<A#_tIxJ{<8EvfE^_LJ4t1;%YY4*xYu7dNZc>=P>5C?ta%ADFy2_QFrl;2VVt@>|K
zv{M1ibp%diFiuY^(}sIbTj1Ki6In)>z=EaZh~RxhUn@#tN4skagUToLcvRb?r8H{f
zGM74kY3W2;W2{HO2!F{F&)@^KI4ABE$`Lg;w<^U@g-mX8NYUrTiw--L8vFjSW(v=b
zT}WL)R&bR$i-gAO;WJ75PzoNia=`=;5NOQZxgLo$YQ)W0426Q$wZze+=Ze5B6wxuh
zz-u}`uF7#qp}8N@L`_I!{i5_A!W%9I?9kOwx72LRqx*a=zS;!1MQ#r?4#TtF`o%oh
z9G%c!l=q<^JOSlk_EcZ4(v$-n!B<HS5%?V<B0M!9pSdWgQk28HF_LPLOQx~{)dRel
z2cj8Y4eM#o;h;`Vx4$fi)9P9~!laCH{e}AoJ+*rIqL4Lbu)IF<3fh4};3{<*@#5D8
z4QK_$8*wKh(T->W^Dv*e^GcY~nJP!jFy$SSAnL?+)O}&@eUdO4{48P8A2sZ`$P9g#
zRpIpX9cr9)x&{;#e2-=2=JpG}(Oe}vXCg9k$rGKM%O7L*=^c^_IoDuWO$)mDSuv&C
zU`ALwYUHBM!Yg%Gq1G|i0KF`K8f}Y|sP~N;Ln5ip$TgJg9Er$4O@OTS$l*&9mr<h>
z&d^$bTch=><Lj?X6)$Tr1HZlYY8GscNG=z0L)5;oZyZ&~BI#>3wy!TrP2N@8S2tCd
znv3U_Yc20Vt#9A}^bG{G6-!TCKq|Pe<<uBNsu3JBmMh9GfedW%zbN=6Jek2?P%73&
z#V7~pUTa@JElj^>Fv}suP>0ikm@6K=7TldUdksh>JOfESN;*Ud^jenzg@7C<SSb76
ze+0F&ce>XW;@MY<wBBc2a<$XVO|cm}7=dtxm>iFa`Y@Wu2rF_`_2wm%A_n1*J;qsc
zSqd{9%MH16%QNdLbJLuz0_0bL31kn{*iZirhQCZdUh=7dFGB^b?VBJiu1ip*%M<qw
zzqOt``^6N(28SEe-3jFR{yJMY@6{cJ%y*03`+xLI?*%T9`wqLZEgf}mmy{$#-T&N$
zF-Upovt*BW&;gV@R8hH{h7C=RnTU0VzGEtTP|^xoGCoJ>RXKCjP#1s7K!&xFnZbO7
z<I~#7d)r^%#xOQ{ilN?~JF8x#<kn-QXTS~aRQ73Ilp1~@?U4v;fV!!{J!7a7xemR@
zdM%P5bNAJD0m`EI(Yz7~*1|X_{2Ff2FUr@jcK|+nKK;O$kTgN{36vVxx;7y^Z8@fR
ztx4v~INO14fzgcLH=i4AMTb`O0J2BQf_c3#TWaLrXAS2FCxb=<cxSKKLQ};ov&SHV
z*}EN@k*bgjpoygI&^W-@+9AbYhbjWD&`yHsee_nOCu+9S-3A)3ryn27zpuA+cr|R<
z{ben5CPNU|esDMGIKqisgy8iINWR4`E(H%mpRxH%3$O&}f%aV@Xns?Dck%IU<u1IY
zTZO_gO~TFcr0n?W`E!g#m;GYAGf;Qejm>kVknoS;2JrT^9+9&0pEj88lF~g#&^&a&
zzkbH%&!;p+5ZHpTwYrG`uh~H0qtCN%4iA0w4{N5l2Hy`0k9SI6T6-+E;p)tLWt6c2
z1E1~>aE~W-R)8(!3d}dj5%;1hw`J0wLzQQzeF*MdhT{sKHr%VjJz4D}mI=(}9R;pp
zM+|uM8yCko%X}uIj^+ebr=%N^OP&u;olr%t0>lpZ7Qb%M+~?ep{eM2q8vE+YFr6{c
zR!X4p;ScCq90sZ9UsaOlj}2`crSO2p=_h*m;a5u*pC0p1L&b7N!F7{XGg_=PqvTyQ
ze}d2PQL!Po6zarl;aTR1NO*4r%oAEFK<ynak*aa9xsUiWI7>E0VzbPaGmN8uvrs)Y
zToZ>^$+WXgpKbW13+G&x2dHst>=+F8B>%$ID;+D#+2YEVrdOhg7)@?U@{+ppbUNxI
zU|)Rqb24Ss1&OHK38m_tL=9bHpAVU%g36TEZ}52CrENPO7oQrJRSEvEO+{TLK6>?=
z=jYs<#^a_`T#mFWoE}%r${pc6CW~S7l$|?7umjs-d|1Cs9V24v#_Na<p`W2{jsHnV
z{rlxiLs$;}N4*Ss#{amu|NX$G6!=H{PuK9@4|ZO@{O@--xxrxYzyCc9!~Ul;4ErB6
zFzkQkgkk^l8W{FJ=ZO6;pkUblCvh|WxSN=YpBnR@c#RdGB^-}UC(B_6*P{PWjLZ$o
I^j$*#AG7G|tN;K2

literal 0
HcmV?d00001


From 42b5dba99a0b995bbf99a31928b024877ee6cf78 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 29 Jun 2017 15:00:44 +0200
Subject: [PATCH 046/329] [spec] Fix cross references and anchors (#514)

This fixes all missing or duplicate xref labels.

It also massages the order of label definitions and index markup to address #508. Unfortunately, the underlying rules that Sphinx uses to assign label names are undocumented and less than obvious, so there may be other occurrences of this.

Another issue remains with the generated LaTeX: when several labels are defined without text inbetween, Sphinx's Latex generator will erroneously insert these labels multiple times, creating lots of warnings from Latex. All my attempts to work around this bug have failed.
---
 document/appendix/implementation.rst   | 24 +++----
 document/appendix/names.rst            |  2 +
 document/appendix/properties.rst       | 17 +++--
 document/binary/conventions.rst        |  4 +-
 document/binary/index.rst              |  2 +-
 document/binary/instructions.rst       | 17 +++--
 document/binary/modules.rst            | 73 +++++++++++----------
 document/binary/types.rst              | 21 +++---
 document/binary/values.rst             | 16 ++---
 document/execution/conventions.rst     |  4 +-
 document/execution/index.rst           |  2 +
 document/execution/instructions.rst    | 24 +++----
 document/execution/modules.rst         | 12 ++--
 document/execution/numerics.rst        | 80 ++++++++++++-----------
 document/execution/runtime.rst         | 64 +++++++++---------
 document/introduction/introduction.rst |  6 +-
 document/introduction/overview.rst     | 27 ++++++++
 document/math.def                      | 18 +++---
 document/mathdef.py                    |  2 +-
 document/syntax/conventions.rst        |  8 +--
 document/syntax/index.rst              |  2 +
 document/syntax/instructions.rst       | 29 +++++----
 document/syntax/modules.rst            | 42 ++++++------
 document/syntax/types.rst              | 22 +++----
 document/syntax/values.rst             | 23 +++----
 document/text/conventions.rst          | 16 ++---
 document/text/index.rst                |  2 +-
 document/text/instructions.rst         | 75 +++++----------------
 document/text/lexical.rst              | 15 +++--
 document/text/modules.rst              | 90 ++++++++++++++++++++------
 document/text/types.rst                | 22 +++----
 document/text/values.rst               | 34 +++++-----
 document/validation/conventions.rst    |  7 +-
 document/validation/index.rst          |  2 +
 document/validation/instructions.rst   | 22 +++----
 document/validation/modules.rst        | 26 ++++----
 36 files changed, 461 insertions(+), 391 deletions(-)

diff --git a/document/appendix/implementation.rst b/document/appendix/implementation.rst
index 2513fa113..a3175b9c8 100644
--- a/document/appendix/implementation.rst
+++ b/document/appendix/implementation.rst
@@ -1,5 +1,5 @@
-.. _impl:
 .. index:: ! implementation limitations, implementation
+.. _impl:
 
 Implementation Limitations
 --------------------------
@@ -24,8 +24,8 @@ However, it is expected that all implementations have "reasonably" large limits
 Syntactic Limits
 ~~~~~~~~~~~~~~~~
 
-.. _impl-syntax:
 .. index:: abstract syntax, module, type, function, table, memory, global, element, data, import, export, parameter, result, local, structured control instruction, instruction, name, Unicode, code point
+.. _impl-syntax:
 
 Structure
 .........
@@ -55,17 +55,17 @@ An implementation may impose restrictions on the following dimensions of a modul
 * the range of :ref:`code points <syntax-codepoint>` in a :ref:`name <syntax-name>`
 
 If the limits of an implementation are exceeded for a given module,
-then the implementation may reject the :ref:`validation <valid>`, compilation, or :ref:`instantiation <exec-instantiate>` of that module with an embedder-specific error.
+then the implementation may reject the :ref:`validation <valid>`, compilation, or :ref:`instantiation <instantiation>` of that module with an embedder-specific error.
 
 .. note::
-   The last item allows embedders that operate in limited environments without support for
+   The last item allows :ref:`embedders <embedder>` that operate in limited environments without support for
    `Unicode <http://www.unicode.org/versions/latest/>`_ to limit the
    names of :ref:`imports <syntax-import>` and :ref:`exports <syntax-export>`
    to common subsets like `ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_.
 
 
-.. _impl-binary:
 .. index:: binary format, module, section, function, code
+.. _impl-binary:
 
 Binary Format
 .............
@@ -74,12 +74,12 @@ For a module given in :ref:`binary format <binary>`, additional limitations may
 
 * the size of a :ref:`module <binary-module>`
 * the size of any :ref:`section <binary-section>`
-* the size of an individual :ref:`function's code <binary-func>`
+* the size of an individual function's :ref:`code <binary-code>`
 * the number of :ref:`sections <binary-section>`
 
 
-.. _impl-text:
 .. index:: text format, source text, token, identifier, character, unicode
+.. _impl-text:
 
 Text Format
 ...........
@@ -94,8 +94,8 @@ For a module given in :ref:`text format <text>`, additional limitations may be i
 * the range of literal :ref:`characters <text-char>` (code points) allowed in the :ref:`source text <source>`
 
 
-.. _impl-valid:
 .. index:: validation, function
+.. _impl-valid:
 
 Validation
 ~~~~~~~~~~
@@ -109,8 +109,8 @@ If a function turns out to be invalid, then the invocation, and every consecutiv
    The function must still be fully validated before execution of its body begins.
 
 
-.. _impl-exec:
 .. index:: execution, module instance, function instance, table instance, memory instance, global instance, allocation, frame, label, value
+.. _impl-exec:
 
 Execution
 ~~~~~~~~~
@@ -124,9 +124,9 @@ Restrictions on the following dimensions may be imposed during :ref:`execution <
 * the number of allocated :ref:`global instances <syntax-globalinst>`
 * the size of a :ref:`table instance <syntax-tableinst>`
 * the size of a :ref:`memory instance <syntax-meminst>`
-* the number of :ref:`frames <syntax-frame>` on the :ref:`stack <syntax-stack>`
-* the number of :ref:`labels <syntax-label>` on the :ref:`stack <syntax-stack>`
-* the number of :ref:`values <syntax-val>` on the :ref:`stack <syntax-stack>`
+* the number of :ref:`frames <syntax-frame>` on the :ref:`stack <stack>`
+* the number of :ref:`labels <syntax-label>` on the :ref:`stack <stack>`
+* the number of :ref:`values <syntax-val>` on the :ref:`stack <stack>`
 
 If the runtime limits of an implementation are exceeded during execution of a computation,
 then it may terminate that computation and report an embedder-specific error to the invoking code.
diff --git a/document/appendix/names.rst b/document/appendix/names.rst
index a203ce2de..6585c1109 100644
--- a/document/appendix/names.rst
+++ b/document/appendix/names.rst
@@ -1,3 +1,5 @@
+.. _binary-namesec:
+
 Name Section
 ------------
 
diff --git a/document/appendix/properties.rst b/document/appendix/properties.rst
index 5d0acdaaa..2a0c06e6d 100644
--- a/document/appendix/properties.rst
+++ b/document/appendix/properties.rst
@@ -1,8 +1,17 @@
 Formal Properties
 -----------------
 
-.. todo::
+.. _bijective:
 
-   * representation (bijection between abstract and binary)
-   * validation (progress, preservation)
-   * ...
+Representation
+~~~~~~~~~~~~~~
+
+.. todo:: bijection between abstract and binary
+
+
+.. _soundness:
+
+Validation
+~~~~~~~~~~
+
+.. todo:: progress, preservation
diff --git a/document/binary/conventions.rst b/document/binary/conventions.rst
index 32f951206..001677768 100644
--- a/document/binary/conventions.rst
+++ b/document/binary/conventions.rst
@@ -3,7 +3,7 @@
 Conventions
 -----------
 
-The binary format for WebAssembly :ref:`modules <modules>` is a dense linear *encoding* of their :ref:`abstract syntax <syntax-module>`.
+The binary format for WebAssembly :ref:`modules <module>` is a dense linear *encoding* of their :ref:`abstract syntax <syntax-module>`.
 [#compression]_
 
 The format is defined by an *attribute grammar* whose only terminal symbols are :ref:`bytes <syntax-byte>`.
@@ -25,10 +25,10 @@ Except for a few exceptions, the binary grammar closely mirrors the grammar of t
    However, such layers are outside the scope of the current specification.
 
 
-.. _binary-grammar:
 .. index:: grammar notation, notation, byte
    single: binary format; grammar
    pair: binary format; notation
+.. _binary-grammar:
 
 Grammar
 ~~~~~~~
diff --git a/document/binary/index.rst b/document/binary/index.rst
index 89a61d9c2..b47e6647a 100644
--- a/document/binary/index.rst
+++ b/document/binary/index.rst
@@ -1,4 +1,4 @@
-.. _binary-format:
+.. _binary:
 
 Binary Format
 =============
diff --git a/document/binary/instructions.rst b/document/binary/instructions.rst
index a1e0fd328..319a2f76c 100644
--- a/document/binary/instructions.rst
+++ b/document/binary/instructions.rst
@@ -1,5 +1,5 @@
-.. _binary-instr:
 .. index:: instruction, ! opcode
+.. _binary-instr:
 
 Instructions
 ------------
@@ -13,9 +13,9 @@ The only exception are :ref:`structured control instructions <binary-instr-contr
    Gaps in the byte code ranges encoding instructions are reserved for future extensions.
 
 
-.. _binary-instr-control:
 .. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, polymorphism
    pair: binary format; instruction
+.. _binary-instr-control:
 
 Control Instructions
 ~~~~~~~~~~~~~~~~~~~~
@@ -61,9 +61,9 @@ Control Instructions
    The |ELSE| opcode :math:`\hex{05}` in the encoding of an |IF| instruction can be omitted if the following instruction sequence is empty.
 
 
-.. _binary-instr-parametric:
 .. index:: value type, polymorphism
    pair: binary format; instruction
+.. _binary-instr-parametric:
 
 Parametric Instructions
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -81,14 +81,14 @@ Parametric Instructions
    \end{array}
 
 
-.. _binary-instr-variable:
 .. index:: variable instructions, local index, global index
    pair: binary format; instruction
+.. _binary-instr-variable:
 
 Variable Instructions
 ~~~~~~~~~~~~~~~~~~~~~
 
-:ref:`Variable instructions <syntax-instr-variable>` are represented by byte codes followed by the encoding of the respective :ref:`index <syntax-indices>`.
+:ref:`Variable instructions <syntax-instr-variable>` are represented by byte codes followed by the encoding of the respective :ref:`index <syntax-index>`.
 
 .. _binary-get_local:
 .. _binary-set_local:
@@ -107,10 +107,9 @@ Variable Instructions
    \end{array}
 
 
-.. _binary-instr-memory:
-.. _binary-memarg:
 .. index:: memory instruction, memory index
    pair: binary format; instruction
+.. _binary-instr-memory:
 
 Memory Instructions
 ~~~~~~~~~~~~~~~~~~~
@@ -161,9 +160,9 @@ Each variant of :ref:`memory instruction <syntax-instr-memory>` is encoded with
    In future versions of WebAssembly, the additional zero bytes occurring in the encoding of the |CURRENTMEMORY| and |GROWMEMORY| instructions may be used to index additional memories.
 
 
-.. _binary-instr-numeric:
 .. index:: numeric instruction
    pair: binary format; instruction
+.. _binary-instr-numeric:
 
 Numeric Instructions
 ~~~~~~~~~~~~~~~~~~~~
@@ -362,10 +361,10 @@ All other numeric instructions are plain opcodes without any immediates.
    \end{array}
 
 
-.. _binary-expr:
 .. index:: expression
    pair: binary format; expression
    single: expression; constant
+.. _binary-expr:
 
 Expressions
 ~~~~~~~~~~~
diff --git a/document/binary/modules.rst b/document/binary/modules.rst
index ebcfcbf2d..9d24b7203 100644
--- a/document/binary/modules.rst
+++ b/document/binary/modules.rst
@@ -9,14 +9,6 @@ except that :ref:`function definitions <syntax-func>` are split into two section
    This separation enables *parallel* and *streaming* compilation of the functions in a module.
 
 
-.. _binary-index:
-.. _binary-typeidx:
-.. _binary-funcidx:
-.. _binary-tableidx:
-.. _binary-memidx:
-.. _binary-globalidx:
-.. _binary-localidx:
-.. _binary-labelidx:
 .. index:: index, type index, function index, table index, memory index, global index, local index, label index
    pair: binary format; type index
    pair: binary format; function index
@@ -25,6 +17,14 @@ except that :ref:`function definitions <syntax-func>` are split into two section
    pair: binary format; global index
    pair: binary format; local index
    pair: binary format; label index
+.. _binary-typeidx:
+.. _binary-funcidx:
+.. _binary-tableidx:
+.. _binary-memidx:
+.. _binary-globalidx:
+.. _binary-localidx:
+.. _binary-labelidx:
+.. _binary-index:
 
 Indices
 ~~~~~~~
@@ -43,9 +43,9 @@ All :ref:`indices <syntax-index>` are encoded with their respective |U32| value.
    \end{array}
 
 
-.. _binary-section:
 .. index:: ! section
    pair: binary format; section
+.. _binary-section:
 
 Sections
 ~~~~~~~~
@@ -77,10 +77,10 @@ In these cases, the empty result :math:`\epsilon` is interpreted as the empty ve
    The module is malformed if the size does not match the length of the binary contents :math:`\B{B}`.
 
 
-.. _binary-customsec:
 .. index:: ! custom section
    pair: binary format; custom section
    single: section; custom
+.. _binary-customsec:
 
 Custom Section
 ~~~~~~~~~~~~~~
@@ -101,11 +101,11 @@ Their contents consist of a :ref:`name <syntax-name>` further identifying the cu
    If an implementation interprets the contents of a custom section, then errors in that contents, or the placement of the section, must not invalidate the module.
 
 
-.. _binary-typesec:
-.. _binary-type:
 .. index:: ! type section, type definition
    pair: binary format; type section
    pair: section; type
+.. _binary-typedef:
+.. _binary-typesec:
 
 Type Section
 ~~~~~~~~~~~~
@@ -120,11 +120,12 @@ It decodes into a vector of :ref:`function types <syntax-functype>` that represe
    \end{array}
 
 
-.. _binary-importsec:
-.. _binary-import:
 .. index:: ! import section, import, name, function type, table type, memory type, global type
    pair: binary format; import
    pair: section; import
+.. _binary-import:
+.. _binary-importdesc:
+.. _binary-importsec:
 
 Import Section
 ~~~~~~~~~~~~~~
@@ -147,11 +148,10 @@ It decodes into a vector of :ref:`imports <syntax-import>` that represent the |I
    \end{array}
 
 
-.. _binary-funcsec:
-.. _binary-func:
 .. index:: ! function section, function, type index, function type
    pair: binary format; function
    pair: section; function
+.. _binary-funcsec:
 
 Function Section
 ~~~~~~~~~~~~~~~~
@@ -167,11 +167,11 @@ The |LOCALS| and |BODY| fields of the respective functions are encoded separatel
    \end{array}
 
 
-.. _binary-tablesec:
-.. _binary-table:
 .. index:: ! table section, table, table type
    pair: binary format; table
    pair: section; table
+.. _binary-table:
+.. _binary-tablesec:
 
 Table Section
 ~~~~~~~~~~~~~
@@ -188,11 +188,11 @@ It decodes into a vector of :ref:`tables <syntax-table>` that represent the |TAB
    \end{array}
 
 
-.. _binary-memsec:
-.. _binary-mem:
 .. index:: ! memory section, memory, memory type
    pair: binary format; memory
    pair: section; memory
+.. _binary-mem:
+.. _binary-memsec:
 
 Memory Section
 ~~~~~~~~~~~~~~
@@ -209,11 +209,11 @@ It decodes into a vector of :ref:`memories <syntax-mem>` that represent the |MEM
    \end{array}
 
 
-.. _binary-globalsec:
-.. _binary-global:
 .. index:: ! global section, global, global type, expression
    pair: binary format; global
    pair: section; global
+.. _binary-global:
+.. _binary-globalsec:
 
 Global Section
 ~~~~~~~~~~~~~~
@@ -231,11 +231,12 @@ It decodes into a vector of :ref:`globals <syntax-global>` that represent the |G
    \end{array}
 
 
-.. _binary-exportsec:
-.. _binary-export:
 .. index:: ! export section, export, name, index, function index, table index, memory index, global index
    pair: binary format; export
    pair: section; export
+.. _binary-export:
+.. _binary-exportdesc:
+.. _binary-exportsec:
 
 Export Section
 ~~~~~~~~~~~~~~
@@ -258,12 +259,12 @@ It decodes into a vector of :ref:`exports <syntax-export>` that represent the |E
    \end{array}
 
 
-.. _binary-startsec:
-.. _binary-start:
 .. index:: ! start section, start function, function index
    pair: binary format; start function
    single: section; start
    single: start function; section
+.. _binary-start:
+.. _binary-startsec:
 
 Start Section
 ~~~~~~~~~~~~~
@@ -280,13 +281,13 @@ It decodes into an optional :ref:`start function <syntax-start>` that represents
    \end{array}
 
 
-.. _binary-elemsec:
-.. _binary-elem:
 .. index:: ! element section, element, table index, expression, function index
    pair: binary format; element
    pair: section; element
    single: table; element
    single: element; segment
+.. _binary-elem:
+.. _binary-elemsec:
 
 Element Section
 ~~~~~~~~~~~~~~~
@@ -304,12 +305,14 @@ It decodes into a vector of :ref:`element segments <syntax-elem>` that represent
    \end{array}
 
 
-.. _binary-codesec:
-.. _binary-local:
 .. index:: ! code section, function, local, type index, function type
    pair: binary format; function
    pair: binary format; local
    pair: section; code
+.. _binary-code:
+.. _binary-func:
+.. _binary-local:
+.. _binary-codesec:
 
 Code Section
 ~~~~~~~~~~~~
@@ -359,13 +362,13 @@ Any code for which the length of the resulting sequence is out of bounds of the
    The module is malformed if a size does not match the length of the respective function code.
 
 
-.. _binary-datasec:
-.. _binary-data:
 .. index:: ! data section, data, memory, memory index, expression, byte
    pair: binary format; data
    pair: section; data
    single: memory; data
    single: data; segment
+.. _binary-data:
+.. _binary-datasec:
 
 Data Section
 ~~~~~~~~~~~~
@@ -383,11 +386,11 @@ It decodes into a vector of :ref:`data segments <syntax-data>` that represent th
    \end{array}
 
 
-.. _binary-module:
-.. _binary-magic:
-.. _binary-version:
 .. index:: module, section, type definition, function type, function, table, memory, global, element, data, start function, import, export, context, version
    pair: binary format; module
+.. _binary-magic:
+.. _binary-version:
+.. _binary-module:
 
 Modules
 ~~~~~~~
diff --git a/document/binary/types.rst b/document/binary/types.rst
index e4b646ef5..14a98f645 100644
--- a/document/binary/types.rst
+++ b/document/binary/types.rst
@@ -1,13 +1,13 @@
-.. _binary-type:
 .. index:: type
    pair: binary format; type
+.. _binary-type:
 
 Types
 -----
 
-.. _binary-valtype:
 .. index:: value type
    pair: binary format; value type
+.. _binary-valtype:
 
 Value Types
 ~~~~~~~~~~~
@@ -28,10 +28,10 @@ Value Types
    Thus, the binary format for types corresponds to the encodings of small negative :math:`\xref{binary/values}{binary-sint}{\sX{}}` values, so that they can coexist with (positive) type indices.
 
 
-.. _binary-resulttype:
-.. _binary-blocktype:
 .. index:: result type, value type
    pair: binary format; result type
+.. _binary-blocktype:
+.. _binary-resulttype:
 
 Result Types
 ~~~~~~~~~~~~
@@ -49,9 +49,9 @@ The only :ref:`result types <syntax-resulttype>` occurring in the binary format
    In future versions of WebAssembly, this scheme may be extended to support multiple results or more general block types.
 
 
-.. _binary-functype:
 .. index:: function type, value type, result type
    pair: binary format; function type
+.. _binary-functype:
 
 Function Types
 ~~~~~~~~~~~~~~
@@ -66,9 +66,9 @@ Function Types
    \end{array}
 
 
-.. _binary-limits:
 .. index:: limits
    pair: binary format; limits
+.. _binary-limits:
 
 Limits
 ~~~~~~
@@ -83,9 +83,9 @@ Limits
    \end{array}
 
 
-.. _binary-memtype:
 .. index:: memory type, limits, page size
    pair: binary format; memory type
+.. _binary-memtype:
 
 Memory Types
 ~~~~~~~~~~~~
@@ -99,11 +99,11 @@ Memory Types
    \end{array}
 
 
-.. _binary-tabletype:
-.. _binary-elemtype:
 .. index:: table type, element type, limits
    pair: binary format; table type
    pair: binary format; element type
+.. _binary-elemtype:
+.. _binary-tabletype:
 
 Table Types
 ~~~~~~~~~~~
@@ -119,10 +119,11 @@ Table Types
    \end{array}
 
 
-.. _binary-globaltype:
 .. index:: global type, mutability, value type
    pair: binary format; global type
    pair: binary format; mutability
+.. _binary-mut:
+.. _binary-globaltype:
 
 Global Types
 ~~~~~~~~~~~~
diff --git a/document/binary/values.rst b/document/binary/values.rst
index 7d3766dc9..2c24c3fe3 100644
--- a/document/binary/values.rst
+++ b/document/binary/values.rst
@@ -1,14 +1,14 @@
-.. _binary-value:
 .. index:: value
    pair: binary format; value
+.. _binary-value:
 
 Values
 ------
 
 
-.. _binary-byte:
 .. index:: byte
    pair: binary format; byte
+.. _binary-byte:
 
 Bytes
 ~~~~~
@@ -24,14 +24,14 @@ Bytes
    \end{array}
 
 
-.. _binary-int:
-.. _binary-sint:
-.. _binary-uint:
 .. index:: integer, unsigned integer, signed integer, uninterpreted integer, LEB128
    pair: binary format; integer
    pair: binary format; unsigned integer
    pair: binary format; signed integer
    pair: binary format; uninterpreted integer
+.. _binary-sint:
+.. _binary-uint:
+.. _binary-int:
 
 Integers
 ~~~~~~~~
@@ -81,9 +81,9 @@ As an additional constraint, the total number of bytes encoding a value of type
    Similarly, both :math:`\hex{83}~\hex{3E}` and :math:`\hex{FF}~\hex{7B}` are malformed as |s8| encodings.
 
 
-.. _binary-float:
 .. index:: floating-point number
    pair: binary format; floating-point number
+.. _binary-float:
 
 Floating-Point
 ~~~~~~~~~~~~~~
@@ -99,9 +99,9 @@ Floating-Point
 Here, :math:`\F{reverse}(b^\ast)` denotes the byte sequence :math:`b^\ast` in reversed order.
 
 
-.. _binary-vec:
 .. index:: vector
    pair: binary format; vector
+.. _binary-vec:
 
 Vectors
 ~~~~~~~
@@ -115,9 +115,9 @@ Vectors
    \end{array}
 
 
-.. _binary-name:
 .. index:: name, byte, Unicode, UTF-8
    pair: binary format; name
+.. _binary-name:
 
 Names
 ~~~~~
diff --git a/document/execution/conventions.rst b/document/execution/conventions.rst
index 6ca70ee62..d7d381c41 100644
--- a/document/execution/conventions.rst
+++ b/document/execution/conventions.rst
@@ -3,7 +3,7 @@
 Conventions
 -----------
 
-WebAssembly code is *executed* when :ref:`instantiating <instantiation>` a module or :ref:`invoking <exec-invocation>` an :ref:`exported <syntax-export>` function on the resulting module :ref:`instance <syntax-moduleinst>`.
+WebAssembly code is *executed* when :ref:`instantiating <instantiation>` a module or :ref:`invoking <exec-call-export>` an :ref:`exported <syntax-export>` function on the resulting module :ref:`instance <syntax-moduleinst>`.
 
 Execution behavior is defined in terms of an *abstract machine* that models the *program state*.
 It includes a *stack*, which records operand values and control constructs, and an abstract *store* containing global state.
@@ -56,8 +56,8 @@ The following conventions are adopted in stating these rules.
 * In various places the rules contain *assertions* expressing crucial invariants about the program state, with indications why these are known to hold.
 
 
-.. _exec-notation:
 .. index:: ! reduction rules, ! configuration
+.. _exec-notation:
 
 Formal Notation
 ~~~~~~~~~~~~~~~
diff --git a/document/execution/index.rst b/document/execution/index.rst
index caa7046cf..d81812669 100644
--- a/document/execution/index.rst
+++ b/document/execution/index.rst
@@ -1,3 +1,5 @@
+.. _exec:
+
 Execution
 =========
 
diff --git a/document/execution/instructions.rst b/document/execution/instructions.rst
index 7145631dc..dae3d8fed 100644
--- a/document/execution/instructions.rst
+++ b/document/execution/instructions.rst
@@ -1,14 +1,14 @@
-.. _exec-instr:
 .. index:: instruction, function type, store
+.. _exec-instr:
 
 Instructions
 ------------
 
 
-.. _exec-instr-numeric:
 .. index:: numeric instruction
    pair: execution; instruction
    single: abstract syntax; instruction
+.. _exec-instr-numeric:
 
 Numeric Instructions
 ~~~~~~~~~~~~~~~~~~~~
@@ -165,10 +165,10 @@ The mapping of numeric instructions to their underlying operators is expressed b
    \end{array}
 
 
-.. _exec-instr-parametric:
 .. index:: parametric instructions
    pair: execution; instruction
    single: abstract syntax; instruction
+.. _exec-instr-parametric:
 
 Parametric Instructions
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -220,10 +220,10 @@ Parametric Instructions
    \end{array}
 
 
-.. _exec-instr-variable:
 .. index:: variable instructions, local index, global index, address, global address, global instance, store, frame
    pair: execution; instruction
    single: abstract syntax; instruction
+.. _exec-instr-variable:
 
 Variable Instructions
 ~~~~~~~~~~~~~~~~~~~~~
@@ -351,11 +351,11 @@ Variable Instructions
    \end{array}
 
 
-.. _exec-instr-memory:
-.. _exec-memarg:
 .. index:: memory instruction, memory index, store, frame, address, memory address, memory instance, store, frame, value type, width
    pair: execution; instruction
    single: abstract syntax; instruction
+.. _exec-memarg:
+.. _exec-instr-memory:
 
 Memory Instructions
 ~~~~~~~~~~~~~~~~~~~
@@ -604,11 +604,11 @@ Memory Instructions
    In practice, the choice depends on the resources available to the :ref:`embedder <embedder>`.
 
 
-.. _exec-instr-control:
-.. _exec-label:
 .. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, address, table address, table instance, store, frame
    pair: execution; instruction
    single: abstract syntax; instruction
+.. _exec-label:
+.. _exec-instr-control:
 
 Control Instructions
 ~~~~~~~~~~~~~~~~~~~~
@@ -911,8 +911,8 @@ Control Instructions
    \end{array}
 
 
-.. _exec-instr-seq:
 .. index:: instruction, instruction sequence
+.. _exec-instr-seq:
 
 Instruction Sequences
 ~~~~~~~~~~~~~~~~~~~~~
@@ -1093,17 +1093,17 @@ and it must still be well-typed.
 
 
 
-.. _exec-expr:
 .. index:: expression
    pair: execution; expression
    single: abstract syntax; expression
+.. _exec-expr:
 
 Expressions
 ~~~~~~~~~~~
 
-An :ref:`expression <syntax-expr>` is *evaluated* relative to a :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>` pointing to its containing :ref:`module instance <syntax-modinst>` :math:`\moduleinst`.
+An :ref:`expression <syntax-expr>` is *evaluated* relative to a :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>` pointing to its containing :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst`.
 
-1. :ref:`Jump <exec-jump>` to the start of the instruction sequence :math:`\instr^\ast` of the expression.
+1. Jump to the start of the instruction sequence :math:`\instr^\ast` of the expression.
 
 2. Execute of the instruction sequence.
 
diff --git a/document/execution/modules.rst b/document/execution/modules.rst
index 525dff326..0c9bb15da 100644
--- a/document/execution/modules.rst
+++ b/document/execution/modules.rst
@@ -429,9 +429,9 @@ Here, the notation :math:`\F{allocX}^\ast` is shorthand for multiple :ref:`alloc
    In an implementation, this recursion is easily unraveled by mutating one or the other in a secondary step.
 
 
-.. _instantiation:
-.. _exec-module:
 .. index:: ! instantiation, module, instance, store
+.. _exec-module:
+.. _instantiation:
 
 Instantiation
 ~~~~~~~~~~~~~
@@ -533,7 +533,7 @@ Instantiation may *fail* with an error.
 
        i. Assert: due to :ref:`validation <valid-elem>`, :math:`\moduleinst.\FUNCS[\funcidx_{ij}]` exists.
 
-       ii. Let :math:`\funcaddr_{ij}` be the :ref:`function address <func-addr>` :math:`\moduleinst.\FUNCS[\funcidx_{ij}]`.
+       ii. Let :math:`\funcaddr_{ij}` be the :ref:`function address <syntax-funcaddr>` :math:`\moduleinst.\FUNCS[\funcidx_{ij}]`.
 
        iii. Replace :math:`\tableinst_i.\ELEM[\X{eo}_i + j]` with :math:`\funcaddr_{ij}`.
 
@@ -551,7 +551,7 @@ Instantiation may *fail* with an error.
 
     a. Assert: due to :ref:`validation <valid-start>`, :math:`\moduleinst.\FUNCS[\module.\START]` exists.
 
-    b. Let :math:`\funcaddr` be the :ref:`function address <func-addr>` :math:`\moduleinst.\FUNCS[\module.\START]`.
+    b. Let :math:`\funcaddr` be the :ref:`function address <syntax-funcaddr>` :math:`\moduleinst.\FUNCS[\module.\START]`.
 
     c. :ref:`Invoke <exec-invoke>` the function instance at :math:`\funcaddr`.
 
@@ -607,9 +607,9 @@ Instantiation may *fail* with an error.
    it happens in individual steps that may be interleaved with other threads.
 
 
-.. _invocation:
-.. _exec-call-export:
 .. index:: ! invocation, module, instance, function, export, function address
+.. _exec-call-export:
+.. _invocation:
 
 Invocation
 ~~~~~~~~~~
diff --git a/document/execution/numerics.rst b/document/execution/numerics.rst
index 95fed94b6..02e0775e6 100644
--- a/document/execution/numerics.rst
+++ b/document/execution/numerics.rst
@@ -1,5 +1,5 @@
-.. _exec-numeric:
 .. _exec-op-partial:
+.. _exec-numeric:
 
 Numerics
 --------
@@ -47,6 +47,8 @@ Some definitions use *truncation* of rational values, with the usual mathematica
    \end{array}
 
 
+.. _aux-bits:
+
 Representations
 ~~~~~~~~~~~~~~~
 
@@ -79,9 +81,9 @@ Integers
 Boolean operators like :math:`\wedge`, :math:`\vee`, or :math:`\veebar` are lifted to bit sequences of equal length by applying them pointwise.
 
 
-.. _aux-fbits:
 .. _aux-fbias:
 .. _aux-fsign:
+.. _aux-fbits:
 
 Floating-Point
 ..............
@@ -101,8 +103,8 @@ Floating-Point
 
 where :math:`M = \significand(N)` and :math:`E = \exponent(N)`.
 
-.. _aux-bytes:
 .. _aux-littleendian:
+.. _aux-bytes:
 
 Storage
 .......
@@ -152,7 +154,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-add:
+.. _op-iadd:
 
 :math:`\iadd_N(i_1, i_2)`
 .........................
@@ -164,7 +166,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \iadd_N(i_1, i_2) &=& (i_1 + i_2) \mod 2^N
    \end{array}
 
-.. _op-sub:
+.. _op-isub:
 
 :math:`\isub_N(i_1, i_2)`
 .........................
@@ -176,7 +178,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \isub_N(i_1, i_2) &=& (i_1 - i_2 + 2^N) \mod 2^N
    \end{array}
 
-.. _op-mul:
+.. _op-imul:
 
 :math:`\imul_N(i_1, i_2)`
 .........................
@@ -188,7 +190,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \imul_N(i_1, i_2) &=& (i_1 \cdot i_2) \mod 2^N
    \end{array}
 
-.. _op-div_u:
+.. _op-idiv_u:
 
 :math:`\idivu_N(i_1, i_2)`
 ..........................
@@ -206,7 +208,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 .. note::
    This operator is :ref:`partial <exec-op-partial>`.
 
-.. _op-div_s:
+.. _op-idiv_s:
 
 :math:`\idivs_N(i_1, i_2)`
 ..........................
@@ -233,7 +235,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    In particular, the result of :math:`(-2^{N-1})/(-1) = +2^{N-1}` is not representable as an :math:`N`-bit signed integer.
 
 
-.. _op-rem_u:
+.. _op-irem_u:
 
 :math:`\iremu_N(i_1, i_2)`
 ..........................
@@ -254,7 +256,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    As long as :math:`i_2 \neq 0`,
    it holds that :math:`i_1 = i_2\cdot\idivu(i_1, i_2) + \iremu(i_1, i_2)`.
 
-.. _op-rem_s:
+.. _op-irem_s:
 
 :math:`\irems_N(i_1, i_2)`
 ..........................
@@ -280,7 +282,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    it holds that :math:`i_1 = i_2\cdot\idivs(i_1, i_2) + \irems(i_1, i_2)`.
 
 
-.. _op-and:
+.. _op-iand:
 
 :math:`\iand_N(i_1, i_2)`
 .........................
@@ -292,7 +294,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \iand_N(i_1, i_2) &=& \ibits_N^{-1}(\ibits_N(i_1) \wedge \ibits_N(i_2))
    \end{array}
 
-.. _op-or:
+.. _op-ior:
 
 :math:`\ior_N(i_1, i_2)`
 ........................
@@ -304,7 +306,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \ior_N(i_1, i_2) &=& \ibits_N^{-1}(\ibits_N(i_1) \vee \ibits_N(i_2))
    \end{array}
 
-.. _op-xor:
+.. _op-ixor:
 
 :math:`\ixor_N(i_1, i_2)`
 .........................
@@ -316,7 +318,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \ixor_N(i_1, i_2) &=& \ibits_N^{-1}(\ibits_N(i_1) \veebar \ibits_N(i_2))
    \end{array}
 
-.. _op-shl:
+.. _op-ishl:
 
 :math:`\ishl_N(i_1, i_2)`
 .........................
@@ -330,7 +332,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \ishl_N(i_1, i_2) &=& \ibits_N^{-1}(b_2^{N-k}~0^k) & (\ibits_N(i_1) = b_1^k~b_2^{N-k} \wedge k = i_2 \mod N)
    \end{array}
 
-.. _op-shr_u:
+.. _op-ishr_u:
 
 :math:`\ishru_N(i_1, i_2)`
 ..........................
@@ -344,7 +346,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \ishru_N(i_1, i_2) &=& \ibits_N^{-1}(0^k~b_1^{N-k}) & (\ibits_N(i_1) = b_1^{N-k}~b_2^k \wedge k = i_2 \mod N)
    \end{array}
 
-.. _op-shr_s:
+.. _op-ishr_s:
 
 :math:`\ishrs_N(i_1, i_2)`
 ..........................
@@ -358,7 +360,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \ishrs_N(i_1, i_2) &=& \ibits_N^{-1}(b_0^{k+1}~b_1^{N-k-1}) & (\ibits_N(i_1) = b_0~b_1^{N-k-1}~b_2^k \wedge k = i_2 \mod N)
    \end{array}
 
-.. _op-rotl:
+.. _op-irotl:
 
 :math:`\irotl_N(i_1, i_2)`
 ..........................
@@ -372,7 +374,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \irotl_N(i_1, i_2) &=& \ibits_N^{-1}(b_2^{N-k}~b_1^k) & (\ibits_N(i_1) = b_1^k~b_2^{N-k} \wedge k = i_2 \mod N)
    \end{array}
 
-.. _op-rotr:
+.. _op-irotr:
 
 :math:`\irotr_N(i_1, i_2)`
 ..........................
@@ -387,7 +389,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-clz:
+.. _op-iclz:
 
 :math:`\iclz_N(i)`
 ..................
@@ -400,7 +402,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-ctz:
+.. _op-ictz:
 
 :math:`\ictz_N(i)`
 ..................
@@ -413,7 +415,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-popcnt:
+.. _op-ipopcnt:
 
 :math:`\ipopcnt_N(i)`
 .....................
@@ -426,7 +428,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-eqz:
+.. _op-ieqz:
 
 :math:`\ieqz_N(i)`
 ..................
@@ -439,7 +441,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-eq:
+.. _op-ieq:
 
 :math:`\ieq_N(i_1, i_2)`
 ........................
@@ -452,7 +454,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-ne:
+.. _op-ine:
 
 :math:`\ine_N(i_1, i_2)`
 ........................
@@ -465,7 +467,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-lt_u:
+.. _op-ilt_u:
 
 :math:`\iltu_N(i_1, i_2)`
 .........................
@@ -478,7 +480,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-lt_s:
+.. _op-ilt_s:
 
 :math:`\ilts_N(i_1, i_2)`
 .........................
@@ -495,7 +497,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-gt_u:
+.. _op-igt_u:
 
 :math:`\igtu_N(i_1, i_2)`
 .........................
@@ -508,7 +510,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-gt_s:
+.. _op-igt_s:
 
 :math:`\igts_N(i_1, i_2)`
 .........................
@@ -525,7 +527,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-le_u:
+.. _op-ile_u:
 
 :math:`\ileu_N(i_1, i_2)`
 .........................
@@ -538,7 +540,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-le_s:
+.. _op-ile_s:
 
 :math:`\iles_N(i_1, i_2)`
 .........................
@@ -555,7 +557,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-ge_u:
+.. _op-ige_u:
 
 :math:`\igeu_N(i_1, i_2)`
 .........................
@@ -568,7 +570,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
-.. _op-ge_s:
+.. _op-ige_s:
 
 :math:`\iges_N(i_1, i_2)`
 .........................
@@ -682,7 +684,7 @@ where:
    \end{array}
 
 
-.. _aux-nan:
+.. _aux-nans:
 
 NaN Propagation
 ...............
@@ -1331,7 +1333,7 @@ This non-deterministic result is expressed by the following auxiliary function p
 Conversions
 ~~~~~~~~~~~
 
-.. _op-extendu:
+.. _op-extend_u:
 
 :math:`\extendu_{M,N}(i)`
 .........................
@@ -1347,7 +1349,7 @@ Conversions
    In the abstract syntax, unsigned extension just reinterprets the same value.
 
 
-.. _op-extends:
+.. _op-extend_s:
 
 :math:`\extends_{M,N}(i)`
 .........................
@@ -1375,7 +1377,7 @@ Conversions
    \end{array}
 
 
-.. _op-truncu:
+.. _op-trunc_u:
 
 :math:`\truncu_{M,N}(z)`
 ........................
@@ -1401,7 +1403,7 @@ Conversions
    It is not defined for NaNs, infinities, or values for which the result is out of range.
 
 
-.. _op-truncs:
+.. _op-trunc_s:
 
 :math:`\truncs_{M,N}(z)`
 ........................
@@ -1471,7 +1473,7 @@ Conversions
    \end{array}
 
 
-.. _op-convertu:
+.. _op-convert_u:
 
 :math:`\convertu_{M,N}(i)`
 ..........................
@@ -1484,7 +1486,7 @@ Conversions
    \end{array}
 
 
-.. _op-converts:
+.. _op-convert_s:
 
 :math:`\converts_{M,N}(i)`
 ..........................
diff --git a/document/execution/runtime.rst b/document/execution/runtime.rst
index e313d28f2..3d2c05e0a 100644
--- a/document/execution/runtime.rst
+++ b/document/execution/runtime.rst
@@ -1,13 +1,13 @@
-.. _syntax-runtime:
 .. index:: ! runtime
+.. _syntax-runtime:
 
 Runtime Structure
 -----------------
 
 
-.. _syntax-val:
 .. index:: ! value, constant
    pair: abstract syntax; value
+.. _syntax-val:
 
 Values
 ~~~~~~
@@ -28,10 +28,10 @@ It is convenient to reuse the same notation as for the |CONST| :ref:`instruction
    \end{array}
 
 
-.. _store:
-.. _syntax-store:
 .. index:: ! store, function instance, table instance, memory instance, global instance, module
    pair: abstract syntax; store
+.. _syntax-store:
+.. _store:
 
 Store
 ~~~~~
@@ -64,11 +64,6 @@ Convention
 * The meta variable :math:`S` ranges over stores where clear from context.
 
 
-.. _syntax-addr:
-.. _syntax-funcaddr:
-.. _syntax-tableaddr:
-.. _syntax-memaddr:
-.. _syntax-globaladdr:
 .. index:: ! address, store, function instance, table instance, memory instance, global instance
    pair: abstract syntax; function address
    pair: abstract syntax; table address
@@ -78,6 +73,11 @@ Convention
    pair: table; address
    pair: memory; address
    pair: global; address
+.. _syntax-funcaddr:
+.. _syntax-tableaddr:
+.. _syntax-memaddr:
+.. _syntax-globaladdr:
+.. _syntax-addr:
 
 Addresses
 ~~~~~~~~~
@@ -114,10 +114,10 @@ even where this identity is not observable from within WebAssembly code itself
 (such as for :ref:`function instances <syntax-funcinst>` or immutable :ref:`globals <syntax-global>`).
 
 
-.. _syntax-moduleinst:
 .. index:: ! instance, function type, function instance, table instance, memory instance, global instance, export instance, table address, memory address, global address, index
    pair: abstract syntax; module instance
    pair: module; instance
+.. _syntax-moduleinst:
 
 Module Instances
 ~~~~~~~~~~~~~~~~
@@ -145,11 +145,11 @@ Each component references runtime instances corresponding to respective declarat
 It is an invariant of the semantics that all :ref:`export instances <syntax-exportinst>` in a given module instance have different :ref:`names <syntax-name>`.
 
 
-.. _syntax-funcinst:
-.. _syntax-hostfunc:
 .. index:: ! function instance, module instance, function, closure
    pair: abstract syntax; function instance
    pair: function; instance
+.. _syntax-hostfunc:
+.. _syntax-funcinst:
 
 Function Instances
 ~~~~~~~~~~~~~~~~~~
@@ -176,11 +176,11 @@ a host function behaves non-deterministically.
    However, the :ref:`embedder <embedder>` might provide implicit or explicit means for distinguishing their :ref:`addresses <syntax-funcaddr>` when :ref:`exported <syntax-export>`, either directly or through an entry in a :ref:`table <syntax-table>`.
 
 
-.. _syntax-tableinst:
-.. _syntax-funcelem:
 .. index:: ! table instance, table, function address
    pair: abstract syntax; table instance
    pair: table; instance
+.. _syntax-funcelem:
+.. _syntax-tableinst:
 
 Table Instances
 ~~~~~~~~~~~~~~~
@@ -205,11 +205,11 @@ It is an invariant of the semantics that the length of the element vector never
    Other table elements may be added in future versions of WebAssembly.
 
 
-.. _syntax-meminst:
-.. _page-size:
 .. index:: ! memory instance, memory, byte, ! page size, memory type
    pair: abstract syntax; memory instance
    pair: memory; instance
+.. _page-size:
+.. _syntax-meminst:
 
 Memory Instances
 ~~~~~~~~~~~~~~~~
@@ -231,10 +231,10 @@ The bytes can be mutated through :ref:`memory instructions <syntax-instr-memory>
 It is an invariant of the semantics that the length of the byte vector, divided by page size, never exceeds the maximum size, if present.
 
 
-.. _syntax-globalinst:
 .. index:: ! global instance, value
    pair: abstract syntax; global instance
    pair: global; instance
+.. _syntax-globalinst:
 
 Global Instances
 ~~~~~~~~~~~~~~~~
@@ -251,10 +251,10 @@ It holds an individual :ref:`value <syntax-val>` and a flag indicating whether i
 The value of mutable globals can be mutated through specific instructions or by external means provided by the :ref:`embedder <embedder>`.
 
 
-.. _syntax-exportinst:
 .. index:: ! export instance, name, external value
    pair: abstract syntax; export instance
    pair: export; instance
+.. _syntax-exportinst:
 
 Export Instances
 ~~~~~~~~~~~~~~~~
@@ -269,10 +269,10 @@ It defines the export's :ref:`name <syntax-name>` and the :ref:`external value <
    \end{array}
 
 
-.. _syntax-externval:
 .. index:: ! external value, function address, table address, memory address, global address
    pair: abstract syntax; external value
    pair: external; value
+.. _syntax-externval:
 
 External Values
 ~~~~~~~~~~~~~~~
@@ -305,14 +305,14 @@ It filters out entries of a specific kind in an order-preserving fashion:
    \end{array}
 
 
-.. _stack:
-.. _frame:
-.. _label:
-.. _syntax-frame:
-.. _syntax-label:
 .. index:: ! stack, ! frame, ! label
    pair: abstract syntax; frame
    pair: abstract syntax; label
+.. _syntax-frame:
+.. _syntax-label:
+.. _frame:
+.. _label:
+.. _stack:
 
 Stack
 ~~~~~
@@ -397,11 +397,11 @@ Conventions
    This may be generalized in future versions.
 
 
-.. _syntax-instr-admin:
-.. _syntax-trap:
-.. _syntax-invoke:
 .. index:: ! administrative instructions, function, function instance, function address, label, frame, instruction, trap
    pair:: abstract syntax; administrative instruction
+.. _syntax-trap:
+.. _syntax-invoke:
+.. _syntax-instr-admin:
 
 Administrative Instructions
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -460,8 +460,8 @@ That way, the end of the inner instruction sequence is tracked when part of an o
       \end{array}
 
 
-.. _syntax-ctxt-label:
 .. index:: ! evaluation context
+.. _syntax-ctxt-block:
 
 Block Contexts
 ..............
@@ -490,8 +490,8 @@ This definition allows to index active labels surrounding a :ref:`branch <syntax
    The right label is identified through the :ref:`label index <syntax-labelidx>` :math:`l`, which corresponds to the number of surrounding |LABEL| instructions that must be hopped over -- which is exactly the count encoded in the index of a block context.
 
 
-.. _syntax-ctxt-eval:
 .. index:: ! evaluation context
+.. _syntax-ctxt-eval:
 
 Evaluation Contexts
 ...................
@@ -516,9 +516,13 @@ Finally, the following definition of *evaluation context* and associated structu
    \end{array}
 
 
-.. _syntax-instr-module:
 .. index:: ! module instructions, function, function instance, function address, label, frame, instruction, trap
    pair:: abstract syntax; meta instruction
+.. _syntax-instantiate:
+.. _syntax-init_table:
+.. _syntax-init_mem:
+.. _syntax-init_global:
+.. _syntax-moduleinstr:
 
 Module Instructions
 ...................
diff --git a/document/introduction/introduction.rst b/document/introduction/introduction.rst
index cd157a199..03f1d7f57 100644
--- a/document/introduction/introduction.rst
+++ b/document/introduction/introduction.rst
@@ -7,10 +7,12 @@ Its main goal is to enable high performance applications on the Web, but it does
 
 WebAssembly is an open standard developed by a `W3C Community Group <https://www.w3.org/community/webassembly/>`_ that includes representatives of all major browser vendors.
 
-This document describes version |release| of the :ref:`core <Scope>` WebAssembly standard.
+This document describes version |release| of the :ref:`core <scope>` WebAssembly standard.
 It is intended that it will be superseded by new incremental releases with additional features in the future.
 
 
+.. _goals:
+
 Design Goals
 ~~~~~~~~~~~~
 
@@ -56,6 +58,8 @@ WebAssembly code is also intended to be easy to inspect and debug, especially in
 .. [#memorysafe] No program can break WebAssembly's memory model. Of course, it cannot guarantee that an unsafe language compiling to WebAssembly does not corrupt its own memory layout, e.g. inside WebAssembly's linear memory.
 
 
+.. _scope:
+
 Scope
 ~~~~~
 
diff --git a/document/introduction/overview.rst b/document/introduction/overview.rst
index f0ab05d48..d2e2cf800 100644
--- a/document/introduction/overview.rst
+++ b/document/introduction/overview.rst
@@ -3,12 +3,17 @@ Overview
 
 .. index:: concepts, value, instruction, trap, function, table, memory, linear memory, module, !embedder
 
+
+.. _concepts:
+
 Concepts
 ~~~~~~~~
 
 WebAssembly encodes a low-level, assembly-like programming language.
 This language is structured around the following main concepts.
 
+.. _value:
+
 **Values**
   WebAssembly provides only four basic *value types*.
   These are integers and `IEEE-754 floating point <http://ieeexplore.ieee.org/document/4610935/>`_ numbers,
@@ -20,6 +25,8 @@ This language is structured around the following main concepts.
   Instead, integers are interpreted by respective operations
   as either unsigned or signed in 2’s complement representation.
 
+.. _instruction:
+
 **Instructions**
   The computational model of WebAssembly is based on a *stack machine*.
   Code consists of sequences of *instructions* that are executed in order.
@@ -31,6 +38,8 @@ This language is structured around the following main concepts.
   Control flow is *structured*, meaning it is expressed with well-nested constructs such as blocks, loops, and conditionals.
   Branches can only target such constructs.
 
+.. _trap:
+
 **Traps**
   Under some conditions, certain instructions may produce a *trap*,
   which immediately aborts excecution.
@@ -38,6 +47,8 @@ This language is structured around the following main concepts.
   but are reported to the outside environment,
   where they typically can be caught.
 
+.. _function:
+
 **Functions**
   Code is organized into separate *functions*.
   Each function takes a sequence of values as parameters
@@ -46,6 +57,8 @@ This language is structured around the following main concepts.
   resulting in an implicit call stack that cannot be accessed directly.
   Functions may also declare mutable *local variables* that are usable as virtual registers.
 
+.. _table:
+
 **Tables**
   A *table* is an array of opaque values of a particular *element type*.
   It allows programs to select such values indirectly through a dynamic index operand.
@@ -53,6 +66,8 @@ This language is structured around the following main concepts.
   Thereby, a program can call functions indirectly through a dynamic index into a table.
   For example, this allows emulating function pointers with table indices.
 
+.. _memory:
+
 **Linear Memory**
   A *linear memory* is a contiguous, mutable array of untyped bytes.
   Such a memory is created with an initial size but can be dynamically grown.
@@ -60,6 +75,8 @@ This language is structured around the following main concepts.
   Integer loads and stores can specify a *storage size* which is smaller than the size of the respective value type.
   A trap occurs if access is not within the bounds of the current memory size.
 
+.. _module:
+
 **Modules**
   A WebAssembly binary takes the form of a *module*
   that contains definitions for functions, tables, and linear memories,
@@ -70,6 +87,8 @@ This language is structured around the following main concepts.
   that takes the form of *segments* copied to given offsets.
   It can also define a *start function* that is automatically executed.
 
+.. _embedder:
+
 **Embedder**
   A WebAssembly implementation will typically be *embedded* into a *host* environment.
   This environment defines how loading of modules is initiated,
@@ -90,16 +109,24 @@ Semantic Phases
 Conceptually, the semantics of WebAssembly is divided into three phases.
 For each part of the language, the specification specifies each of them.
 
+.. _decoding:
+
 **Decoding**
   WebAssembly modules are distributed in a *binary format*.
   *Decoding* processes that format and converts it into an internal representation of a module.
   In this specification, this representation is modelled by *abstract syntax*, but a real implementation could compile directly to machine code instead.
 
+.. _validation:
+
 **Validation**
   A decoded module has to be *valid*.
   Validation checks a number of well-formedness conditions to guarantee that the module is meaningful and safe.
   In particular, it performs *type checking* of functions and the instruction sequences in their bodies, ensuring for example that the operand stack is used consistently.
 
+.. _execution:
+.. _instantiation:
+.. _invocation:
+
 **Execution**
   Finally, a valid module can be *executed*.
   Execution can be further divided into two phases:
diff --git a/document/math.def b/document/math.def
index 83dbee51a..334ec6473 100644
--- a/document/math.def
+++ b/document/math.def
@@ -327,7 +327,7 @@
 .. Modules, non-terminals
 
 .. |module| mathdef:: \xref{syntax/modules}{syntax-module}{\X{module}}
-.. |type| mathdef:: \xref{syntax/modules}{syntax-type}{\X{type}}
+.. |type| mathdef:: \xref{syntax/modules}{syntax-typedef}{\X{type}}
 .. |func| mathdef:: \xref{syntax/modules}{syntax-func}{\X{func}}
 .. |table| mathdef:: \xref{syntax/modules}{syntax-table}{\X{table}}
 .. |mem| mathdef:: \xref{syntax/modules}{syntax-mem}{\X{mem}}
@@ -358,9 +358,9 @@
 .. |Bexportsec| mathdef:: \xref{binary/modules}{binary-exportsec}{\B{exportsec}}
 .. |Belemsec| mathdef:: \xref{binary/modules}{binary-elemsec}{\B{elemsec}}
 .. |Bdatasec| mathdef:: \xref{binary/modules}{binary-datasec}{\B{datasec}}
-.. |Bstartsec| mathdef:: \xref{binary/modules}{binary-startseg}{\B{startsec}}
+.. |Bstartsec| mathdef:: \xref{binary/modules}{binary-startsec}{\B{startsec}}
 .. |Bcustom| mathdef:: \xref{binary/modules}{binary-customsec}{\B{custom}}
-.. |Btype| mathdef:: \xref{binary/modules}{binary-type}{\B{type}}
+.. |Btype| mathdef:: \xref{binary/modules}{binary-typedef}{\B{type}}
 .. |Bfunc| mathdef:: \xref{binary/modules}{binary-func}{\B{func}}
 .. |Btable| mathdef:: \xref{binary/modules}{binary-table}{\B{table}}
 .. |Bmem| mathdef:: \xref{binary/modules}{binary-mem}{\B{mem}}
@@ -382,7 +382,7 @@
 .. |Tmodule| mathdef:: \xref{text/modules}{text-module}{\T{module}}
 .. |Tmodulebody| mathdef:: \xref{text/modules}{text-modulebody}{\T{modulebody}}
 .. |Tmodulefield| mathdef:: \xref{text/modules}{text-modulefield}{\T{modulefield}}
-.. |Ttype| mathdef:: \xref{text/modules}{text-type}{\T{type}}
+.. |Ttype| mathdef:: \xref{text/modules}{text-typedef}{\T{type}}
 .. |Ttypeuse| mathdef:: \xref{text/modules}{text-typeuse}{\T{typeuse}}
 .. |Tfunc| mathdef:: \xref{text/modules}{text-func}{\T{func}}
 .. |Ttable| mathdef:: \xref{text/modules}{text-table}{\T{table}}
@@ -403,10 +403,10 @@
 
 .. Modules, meta functions
 
-.. |funcs| mathdef:: \xref{execution/runtime}{syntax-externtype}{\F{funcs}}
-.. |tables| mathdef:: \xref{execution/runtime}{syntax-externtype}{\F{tables}}
-.. |mems| mathdef:: \xref{execution/runtime}{syntax-externtype}{\F{mems}}
-.. |globals| mathdef:: \xref{execution/runtime}{syntax-externtype}{\F{globals}}
+.. |funcs| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{funcs}}
+.. |tables| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{tables}}
+.. |mems| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{mems}}
+.. |globals| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{globals}}
 
 
 .. Instructions, terminals
@@ -578,7 +578,7 @@
 .. |hostfunc| mathdef:: \xref{execution/runtime}{syntax-hostfunc}{\X{hostfunc}}
 
 .. |externval| mathdef:: \xref{execution/runtime}{syntax-externval}{\X{externval}}
-.. |externtype| mathdef:: \xref{execution/runtime}{syntax-externtype}{\X{externtype}}
+.. |externtype| mathdef:: \xref{syntax/types}{syntax-externtype}{\X{externtype}}
 .. |storagetype| mathdef:: \xref{execution/runtime}{syntax-storagetype}{\X{storagetype}}
 
 .. |store| mathdef:: \xref{execution/runtime}{syntax-store}{\X{store}}
diff --git a/document/mathdef.py b/document/mathdef.py
index 9dace4183..e4997ac4b 100644
--- a/document/mathdef.py
+++ b/document/mathdef.py
@@ -35,7 +35,7 @@ def ext_html_visit_displaymath(self, node):
 def latex_hyperlink(file, id):
   id = text_type(id).translate(tex_replace_map).\
     encode('ascii', 'backslashreplace').decode('ascii').\
-    replace('\\', '_').replace('-', '\\string-')
+    replace('_', '-').replace('\\', '_')
   return '\\hyperref[%s:%s]' % (file, id)
 
 def latex_transform_math_xref(node):
diff --git a/document/syntax/conventions.rst b/document/syntax/conventions.rst
index f35dc11d4..9d034ae0a 100644
--- a/document/syntax/conventions.rst
+++ b/document/syntax/conventions.rst
@@ -1,20 +1,19 @@
-.. _syntax:
 .. index:: ! abstract syntax
 
 Conventions
 -----------
 
 WebAssembly is a programming language that does not have a concrete textual syntax
-(other than the auxiliary :ref:`text format <text-format>`).
+(other than the auxiliary :ref:`text format <text>`).
 For conciseness, however, its structure is described in the form of an *abstract syntax*.
 All parts of this specification are defined in terms of this abstract syntax,
-including the decoding of the :ref:`binary format <binary-format>`.
+including the decoding of the :ref:`binary format <binary>`.
 
 
-.. _grammar:
 .. index:: ! grammar notation, notation
    single: abstract syntax; grammar
    pair: abstract syntax; notation
+.. _grammar:
 
 Grammar
 ~~~~~~~
@@ -38,6 +37,7 @@ The following conventions are adopted in defining grammar rules for abstract syn
 
 
 .. _syntax-record:
+.. _syntax-concat:
 
 Auxiliary Notation
 ~~~~~~~~~~~~~~~~~~
diff --git a/document/syntax/index.rst b/document/syntax/index.rst
index 0eb625b35..c8be21128 100644
--- a/document/syntax/index.rst
+++ b/document/syntax/index.rst
@@ -1,3 +1,5 @@
+.. _syntax:
+
 Structure
 =========
 
diff --git a/document/syntax/instructions.rst b/document/syntax/instructions.rst
index b90f77b8c..843700dc0 100644
--- a/document/syntax/instructions.rst
+++ b/document/syntax/instructions.rst
@@ -1,6 +1,6 @@
-.. _syntax-instr:
 .. index:: ! instruction, ! code, stack machine, operand, operand stack
    pair: abstract syntax; instruction
+.. _syntax-instr:
 
 Instructions
 ------------
@@ -23,13 +23,15 @@ Some instructions are :ref:`structured <syntax-instr-control>` in that they brac
 The following sections group instructions into a number of different categories.
 
 
+.. index:: ! numeric instruction
+   pair: abstract syntax; instruction
 .. _syntax-sx:
-.. _syntax-instr-numeric:
 .. _syntax-const:
 .. _syntax-unop:
 .. _syntax-binop:
 .. _syntax-testop:
 .. _syntax-relop:
+.. _syntax-cvtop:
 .. _syntax-iunop:
 .. _syntax-ibinop:
 .. _syntax-itestop:
@@ -38,8 +40,7 @@ The following sections group instructions into a number of different categories.
 .. _syntax-fbinop:
 .. _syntax-ftestop:
 .. _syntax-frelop:
-.. index:: ! numeric instruction
-   pair: abstract syntax; instruction
+.. _syntax-instr-numeric:
 
 Numeric Instructions
 ~~~~~~~~~~~~~~~~~~~~
@@ -165,9 +166,9 @@ Occasionally, it is convenient to group operators together according to the foll
    \end{array}
 
 
-.. _syntax-instr-parametric:
 .. index:: ! parametric instruction
    pair: abstract syntax; instruction
+.. _syntax-instr-parametric:
 
 Parametric Instructions
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -187,9 +188,9 @@ The |DROP| operator simply throws away a single operand.
 The |SELECT| operator selects one of its first two operands based on whether its third operand is zero or not.
 
 
-.. _syntax-instr-variable:
 .. index:: ! variable instruction, local, global, local index, global index
    pair: abstract syntax; instruction
+.. _syntax-instr-variable:
 
 Variable Instructions
 ~~~~~~~~~~~~~~~~~~~~~
@@ -211,12 +212,12 @@ These instructions get or set the values of variables, respectively.
 The |TEELOCAL| instruction is like |SETLOCAL| but also returns its argument.
 
 
-.. _syntax-instr-memory:
+.. index:: ! memory instruction, memory index
+   pair: abstract syntax; instruction
 .. _syntax-loadn:
 .. _syntax-storen:
 .. _syntax-memarg:
-.. index:: ! memory instruction, memory index
-   pair: abstract syntax; instruction
+.. _syntax-instr-memory:
 
 Memory Instructions
 ~~~~~~~~~~~~~~~~~~~
@@ -265,8 +266,8 @@ Both instructions operate in units of :ref:`page size <page-size>`.
    This restriction may be lifted in future versions.
 
 
-.. _syntax-instr-control:
-.. _syntax-instr-seq:
+.. index:: ! control instruction, ! structured control, ! label, ! block, ! branch, ! unwinding, result type, label index, function index, type index, vector
+   pair: abstract syntax; instruction
 .. _syntax-nop:
 .. _syntax-unreachable:
 .. _syntax-block:
@@ -279,8 +280,8 @@ Both instructions operate in units of :ref:`page size <page-size>`.
 .. _syntax-call:
 .. _syntax-call_indirect:
 .. _syntax-label:
-.. index:: ! control instruction, ! structured control, ! label, ! block, ! branch, ! unwinding, result type, label index, function index, type index, vector
-   pair: abstract syntax; instruction
+.. _syntax-instr-seq:
+.. _syntax-instr-control:
 
 Control Instructions
 ~~~~~~~~~~~~~~~~~~~~
@@ -350,10 +351,10 @@ the callee is dynamically checked against the :ref:`function type <syntax-functy
    This restriction may be lifted in future versions.
 
 
-.. _syntax-expr:
 .. index:: ! expression, constant
    pair: abstract syntax; expression
    single: expression; constant
+.. _syntax-expr:
 
 Expressions
 ~~~~~~~~~~~
diff --git a/document/syntax/modules.rst b/document/syntax/modules.rst
index ed3905910..a8451a660 100644
--- a/document/syntax/modules.rst
+++ b/document/syntax/modules.rst
@@ -1,6 +1,6 @@
-.. _syntax-module:
 .. index:: ! module, type definition, function type, function, table, memory, global, element, data, start function, import, export
    pair: abstract syntax; module
+.. _syntax-module:
 
 Modules
 -------
@@ -29,14 +29,6 @@ and provide initialization logic in the form of :ref:`data <syntax-data>` and :r
 Each of the vectors -- and thus the entire module -- may be empty.
 
 
-.. _syntax-index:
-.. _syntax-typeidx:
-.. _syntax-funcidx:
-.. _syntax-tableidx:
-.. _syntax-memidx:
-.. _syntax-globalidx:
-.. _syntax-localidx:
-.. _syntax-labelidx:
 .. index:: ! index, ! index space, ! type index, ! function index, ! table index, ! memory index, ! global index, ! local index, ! label index
    pair: abstract syntax; type index
    pair: abstract syntax; function index
@@ -52,6 +44,14 @@ Each of the vectors -- and thus the entire module -- may be empty.
    pair: global; index
    pair: local; index
    pair: label; index
+.. _syntax-typeidx:
+.. _syntax-funcidx:
+.. _syntax-tableidx:
+.. _syntax-memidx:
+.. _syntax-globalidx:
+.. _syntax-localidx:
+.. _syntax-labelidx:
+.. _syntax-index:
 
 Indices
 ~~~~~~~
@@ -86,9 +86,9 @@ Conventions
 * The meta variables :math:`x, y` ranges over indices in any of the other index spaces.
 
 
-.. _syntax-type:
 .. index:: ! type definition, type index
    pair: abstract syntax; type definition
+.. _syntax-typedef:
 
 Types
 ~~~~~
@@ -102,11 +102,11 @@ They are referenced by :ref:`type indices <syntax-typeidx>`.
    Future versions of WebAssembly may add additional forms of type definitions.
 
 
-.. _syntax-func:
-.. _syntax-local:
 .. index:: ! function, ! local, function index, local index, type index, value type, expression, import
    pair: abstract syntax; function
    pair: abstract syntax; local
+.. _syntax-local:
+.. _syntax-func:
 
 Functions
 ~~~~~~~~~
@@ -132,9 +132,9 @@ Functions are referenced through :ref:`function indices <syntax-funcidx>`,
 starting with the smallest index not referencing a function :ref:`import <syntax-import>`.
 
 
-.. _syntax-table:
 .. index:: ! table, table index, table type, limits, element, import
    pair: abstract syntax; table
+.. _syntax-table:
 
 Tables
 ~~~~~~
@@ -162,9 +162,9 @@ Most constructs implicitly reference table index :math:`0`.
    This restriction may be lifted in future versions.
 
 
-.. _syntax-mem:
 .. index:: ! memory, memory index, memory type, limits, page size, data, import
    pair: abstract syntax; memory
+.. _syntax-mem:
 
 Memories
 ~~~~~~~~
@@ -193,9 +193,9 @@ Most constructs implicitly reference memory index :math:`0`.
    This restriction may be lifted in future versions.
 
 
-.. _syntax-global:
 .. index:: ! global, global index, global type, mutability, expression
    pair: abstract syntax; global
+.. _syntax-global:
 
 Globals
 ~~~~~~~
@@ -216,11 +216,11 @@ Globals are referenced through :ref:`global indices <syntax-globalidx>`,
 starting with the smallest index not referencing a global :ref:`import <syntax-import>`.
 
 
-.. _syntax-elem:
 .. index:: ! element, table, table index, expression, function index, vector
    pair: abstract syntax; element
    single: table; element
    single: element; segment
+.. _syntax-elem:
 
 Element Segments
 ~~~~~~~~~~~~~~~~
@@ -241,11 +241,11 @@ The |OFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <sy
    Consequently, the only valid |tableidx| is :math:`0`.
 
 
-.. _syntax-data:
 .. index:: ! data, memory, memory index, expression, byte, vector
    pair: abstract syntax; data
    single: memory; data
    single: data; segment
+.. _syntax-data:
 
 Data Segments
 ~~~~~~~~~~~~~
@@ -266,9 +266,9 @@ The |OFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <sy
    Consequently, the only valid |memidx| is :math:`0`.
 
 
-.. _syntax-start:
 .. index:: ! start function, function index, table, memory, instantiation
    pair: abstract syntax; start function
+.. _syntax-start:
 
 Start Function
 ~~~~~~~~~~~~~~
@@ -282,13 +282,14 @@ The |START| component of a module optionally declares the :ref:`function index <
    \end{array}
 
 
-.. _syntax-export:
 .. index:: ! export, name, index, function index, table index, memory index, global index, function, table, memory, global, instantiation
    pair: abstract syntax; export
    single: function; export
    single: table; export
    single: memory; export
    single: global; export
+.. _syntax-exportdesc:
+.. _syntax-export:
 
 Exports
 ~~~~~~~
@@ -328,13 +329,14 @@ The following auxiliary notation is defined for sequences of exports, filtering
 * :math:`\globals(\export^\ast) = [\globalidx ~|~ \GLOBAL~\globalidx \in (\export.\DESC)^\ast]`
 
 
-.. _syntax-import:
 .. index:: ! import, name, function type, table type, memory type, global type, index, index space, type index, function index, table index, memory index, global index, function, table, memory, global, instantiation
    pair: abstract syntax; import
    single: function; import
    single: table; import
    single: memory; import
    single: global; import
+.. _syntax-importdesc:
+.. _syntax-import:
 
 Imports
 ~~~~~~~
diff --git a/document/syntax/types.rst b/document/syntax/types.rst
index 559fe2cf5..db07f0a52 100644
--- a/document/syntax/types.rst
+++ b/document/syntax/types.rst
@@ -1,15 +1,15 @@
-.. _syntax-type:
 .. index:: ! type
    pair: abstract syntax; type
+.. _syntax-type:
 
 Types
 -----
 
 
-.. _syntax-valtype:
 .. index:: ! value type
    pair: abstract syntax; value type
    pair: value; type
+.. _syntax-valtype:
 
 Value Types
 ~~~~~~~~~~~
@@ -37,10 +37,10 @@ Conventions
   (That is, :math:`|\I32| = |\F32| = 32` and :math:`|\I64| = |\F64| = 64`.)
 
 
-.. _syntax-resulttype:
 .. index:: ! result type, value type
    pair: abstract syntax; result type
    pair: result; type
+.. _syntax-resulttype:
 
 Result Types
 ~~~~~~~~~~~~
@@ -59,10 +59,10 @@ which is a sequence of values.
    However, this may be generalized to sequences of values in future versions.
 
 
-.. _syntax-functype:
 .. index:: ! function type, value type, result type
    pair: abstract syntax; function type
    pair: function; type
+.. _syntax-functype:
 
 Function Types
 ~~~~~~~~~~~~~~
@@ -82,11 +82,11 @@ mapping a vector of parameters to a vector of results.
    This restriction may be removed in future versions.
 
 
-.. _syntax-limits:
 .. index:: ! limits, memory type, table type
    pair: abstract syntax; limits
    single: memory; limits
    single: table; limits
+.. _syntax-limits:
 
 Limits
 ~~~~~~
@@ -102,11 +102,11 @@ Limits
 If no maximum is given, the respective storage can grow to any size.
 
 
-.. _syntax-memtype:
 .. index:: ! memory type, limits, page size
    pair: abstract syntax; memory type
    pair: memory; type
    pair: memory; limits
+.. _syntax-memtype:
 
 Memory Types
 ~~~~~~~~~~~~
@@ -123,14 +123,14 @@ The limits constrain the minimum and optionally the maximum size of a memory.
 The limits are given in units of :ref:`page size <page-size>`.
 
 
-.. _syntax-tabletype:
-.. _syntax-elemtype:
 .. index:: ! table type, ! element type, limits
    pair: abstract syntax; table type
    pair: abstract syntax; element type
    pair: table; type
    pair: table; limits
    pair: element; type
+.. _syntax-elemtype:
+.. _syntax-tabletype:
 
 Table Types
 ~~~~~~~~~~~
@@ -155,13 +155,13 @@ A table of that type thus contains references to functions of heterogeneous type
    In future versions of WebAssembly, additional element types may be introduced.
 
 
-.. _syntax-globaltype:
-.. _syntax-mut:
 .. index:: ! global type, ! mutability, value type
    pair: abstract syntax; global type
    pair: abstract syntax; mutability
    pair: global; type
    pair: global; mutability
+.. _syntax-mut:
+.. _syntax-globaltype:
 
 Global Types
 ~~~~~~~~~~~~
@@ -178,10 +178,10 @@ Global Types
    \end{array}
 
 
-.. _syntax-externtype:
 .. index:: ! external type, function type, table type, memory type, global type
    pair: abstract syntax; external type
    pair: external; type
+.. _syntax-externtype:
 
 External Types
 ~~~~~~~~~~~~~~
diff --git a/document/syntax/values.rst b/document/syntax/values.rst
index 2af3b48af..536b6fa74 100644
--- a/document/syntax/values.rst
+++ b/document/syntax/values.rst
@@ -1,14 +1,14 @@
-.. _syntax-value:
 .. index:: ! value
    pair: abstract syntax; value
+.. _syntax-value:
 
 Values
 ------
 
 
-.. _syntax-byte:
 .. index:: ! byte
    pair: abstract syntax; byte
+.. _syntax-byte:
 
 Bytes
 ~~~~~
@@ -31,9 +31,6 @@ Conventions
 * Bytes are sometimes interpreted as natural numbers :math:`n < 256`.
 
 
-.. _syntax-int:
-.. _syntax-sint:
-.. _syntax-uint:
 .. index:: ! integer, ! unsigned integer, ! signed integer, ! uninterpreted integer
    pair: abstract syntax; integer
    pair: abstract syntax; unsigned integer
@@ -42,6 +39,9 @@ Conventions
    single: integer; unsigned
    single: integer; signed
    single: integer; uninterpreted
+.. _syntax-sint:
+.. _syntax-uint:
+.. _syntax-int:
 
 Integers
 ~~~~~~~~
@@ -71,14 +71,14 @@ Conventions
 * Numbers may be denoted by simple arithmetics, as in the grammar above.
 
 
-.. _syntax-float:
-.. _syntax-nan:
-.. _syntax-payload:
 .. index:: ! floating-point number, ! NaN, payload, canonical NaN, arithmetic NaN
    pair: abstract syntax; floating-point number
    single: NaN; payload
    single: NaN; canonical
    single: NaN; arithmetic
+.. _syntax-nan:
+.. _syntax-payload:
+.. _syntax-float:
 
 Floating-Point
 ~~~~~~~~~~~~~~
@@ -138,9 +138,9 @@ Conventions
 * Floating-point numbers, in normal or subnormal form, are sometimes interpreted as rational numbers :math:`q \in \mathbb{Q}`.
 
 
-.. _syntax-vec:
 .. index:: ! vector
    pair: abstract syntax; vector
+.. _syntax-vec:
 
 Vectors
 ~~~~~~~
@@ -157,10 +157,11 @@ A vector can have at most :math:`2^{32}-1` elements.
    \end{array}
 
 
-.. _syntax-name:
-.. _syntax-utf8:
 .. index:: ! name, byte, Unicode, UTF-8, code point
    pair: abstract syntax; name
+.. _syntax-utf8:
+.. _syntax-codepoint:
+.. _syntax-name:
 
 Names
 ~~~~~
diff --git a/document/text/conventions.rst b/document/text/conventions.rst
index 94b2ebd9a..a4d9ac6b8 100644
--- a/document/text/conventions.rst
+++ b/document/text/conventions.rst
@@ -1,11 +1,11 @@
-.. index:: ! text format, Unicode, UTF-8, S-expression
+.. index:: ! text format, Unicode, UTF-8, S-expression, identifier
 
 Conventions
 -----------
 
-The textual format for WebAssembly :ref:`modules <modules>` is a rendering of their :ref:`abstract syntax <syntax-module>` into *S-expressions*.
+The textual format for WebAssembly :ref:`modules <module>` is a rendering of their :ref:`abstract syntax <syntax-module>` into *S-expressions*.
 
-Like the :ref:`binary format <binary-format>`, the text format is defined by an *attribute grammar*.
+Like the :ref:`binary format <binary>`, the text format is defined by an *attribute grammar*.
 A text string is a well-formed description of a module if and only if it is generated by the grammar.
 
 Each production of this grammar has at most one synthesized attribute: the abstract syntax that the respective character sequence expresses.
@@ -20,16 +20,16 @@ The recommended extension for source files containing WebAssembly modules in tex
 Files with this extension are assumed to be encoded in `Unicode UTF-8 <http://www.unicode.org/versions/latest/>`_.
 
 
-.. _text-grammar:
 .. index:: grammar notation, notation, Unicode
    single: text format; grammar
    pair: text format; notation
+.. _text-grammar:
 
 Grammar
 ~~~~~~~
 
 The following conventions are adopted in defining grammar rules for the text format.
-They mirror the conventions used for :ref:`abstract syntax <grammar>` and for the :ref:`binary format <binary-format>`.
+They mirror the conventions used for :ref:`abstract syntax <grammar>` and for the :ref:`binary format <binary>`.
 In order to distinguish symbols of the textual syntax from symbols of the abstract syntax, typewriter font is adopted for the former.
 
 * Terminal symbols are either literal strings of characters enclosed in quotes: :math:`\text{module}`;
@@ -82,8 +82,8 @@ In order to distinguish symbols of the textual syntax from symbols of the abstra
    The attribute of the complete production then is the abstract syntax for the limit, expressed in terms of the former values.
 
 
-.. _text-abbreviations:
 .. index:: ! abbreviations
+.. _text-abbreviations:
 
 Abbreviations
 ~~~~~~~~~~~~~
@@ -98,9 +98,9 @@ Abbreviations are defined by rewrite rules specifying their expansion into the c
 These expansions are assumed to be applied, recursively and in order of appearance, before applying the core grammar rules to construct the abstract syntax.
 
 
-.. _text-context:
-.. _text-context-wf:
 .. index:: ! identifier context, identifier, index, index space
+.. _text-context-wf:
+.. _text-context:
 
 Contexts
 ~~~~~~~~
diff --git a/document/text/index.rst b/document/text/index.rst
index 89889e5cf..c91b4b358 100644
--- a/document/text/index.rst
+++ b/document/text/index.rst
@@ -1,4 +1,4 @@
-.. _text-format:
+.. _text:
 
 Text Format
 ===========
diff --git a/document/text/instructions.rst b/document/text/instructions.rst
index ea2e70620..1ff511361 100644
--- a/document/text/instructions.rst
+++ b/document/text/instructions.rst
@@ -1,5 +1,5 @@
-.. _text-instr:
 .. index:: instruction
+.. _text-instr:
 
 Instructions
 ------------
@@ -18,61 +18,15 @@ Instructions are syntactically distinguished into *plain* and *structured* instr
 In addition, as a syntactic abbreviation, instructions can be written in :ref:`folded <text-foldedinstr>` form as S-expressions, to group them visually.
 
 
-.. _text-index:
-.. _text-typeidx:
-.. _text-funcidx:
-.. _text-tableidx:
-.. _text-memidx:
-.. _text-globalidx:
-.. _text-localidx:
-.. _text-labelidx:
-.. index:: index, type index, function index, table index, memory index, global index, local index, label index
-   pair: text format; type index
-   pair: text format; function index
-   pair: text format; table index
-   pair: text format; memory index
-   pair: text format; global index
-   pair: text format; local index
-   pair: text format; label index
-
-Indices
-~~~~~~~
-
-:ref:`Indices <syntax-index>` can be given either in raw numeric form or as symbolic :ref:`identifiers <text-id>` when bound by a respective construct.
-Such identifiers are looked up in the suitable space of the :ref:`identifier context <text-context>`.
-
-.. math::
-   \begin{array}{llcllllllll}
-   \production{type index} & \Ttypeidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\TYPES[x] = v) \\
-   \production{function index} & \Tfuncidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\FUNCS[x] = v) \\
-   \production{table index} & \Ttableidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\TABLES[x] = v) \\
-   \production{memory index} & \Tmemidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\MEMS[x] = v) \\
-   \production{global index} & \Tglobalidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\GLOBALS[x] = v) \\
-   \production{local index} & \Tlocalidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\LOCALS[x] = v) \\
-   \production{label index} & \Tlabelidx_I &::=&
-     l{:}\Tu32 &\Rightarrow& l &|&
-     v{:}\Tid &\Rightarrow& l & (I.\LABELS[l] = v) \\
-   \end{array}
-
-
-.. _text-label:
 .. index:: index, label index
    pair: text format; label index
+.. _text-label:
+
+Labels
+~~~~~~
 
 :ref:`Structured control instructions <text-instr-control>` can be annotated with a symbolic :ref:`label identifier <text-id>`.
-They are the only symbolic identifiers that can be bound locally in an instruction sequence.
+They are the only :ref:`symbolic identifiers <text-index>` that can be bound locally in an instruction sequence.
 The following grammar handles the corresponding update to the :ref:`identifier context <text-context>` by producing a context with an additional label entry.
 
 .. math::
@@ -89,9 +43,11 @@ The following grammar handles the corresponding update to the :ref:`identifier c
    mirroring the fact that control instructions are indexed relatively not absolutely.
 
 
-.. _text-instr-control:
 .. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, polymorphism
    pair: text format; instruction
+.. _text-blockinstr:
+.. _text-plaininstr:
+.. _text-instr-control:
 
 Control Instructions
 ~~~~~~~~~~~~~~~~~~~~
@@ -158,9 +114,9 @@ The :math:`\text{else}` keyword of an :math:`\text{if}` instruction can be omitt
    \end{array}
 
 
-.. _text-instr-parametric:
 .. index:: value type, polymorphism
    pair: text format; instruction
+.. _text-instr-parametric:
 
 Parametric Instructions
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -176,9 +132,9 @@ Parametric Instructions
    \end{array}
 
 
-.. _text-instr-variable:
 .. index:: variable instructions, local index, global index
    pair: text format; instruction
+.. _text-instr-variable:
 
 Variable Instructions
 ~~~~~~~~~~~~~~~~~~~~~
@@ -200,10 +156,9 @@ Variable Instructions
    \end{array}
 
 
-.. _text-instr-memory:
-.. _text-memarg:
 .. index:: memory instruction, memory index
    pair: text format; instruction
+.. _text-instr-memory:
 
 Memory Instructions
 ~~~~~~~~~~~~~~~~~~~
@@ -259,9 +214,9 @@ Lexically, an |Toffset| or |Talign| phrase is considered a single :ref:`keyword
    \end{array}
 
 
-.. _text-instr-numeric:
 .. index:: numeric instruction
    pair: text format; instruction
+.. _text-instr-numeric:
 
 Numeric Instructions
 ~~~~~~~~~~~~~~~~~~~~
@@ -454,8 +409,8 @@ Numeric Instructions
    \end{array}
 
 
-.. _text-foldedinstr:
 .. index:: ! folded instruction, S-expression
+.. _text-foldedinstr:
 
 Folded Instructions
 ~~~~~~~~~~~~~~~~~~~
@@ -486,10 +441,10 @@ Such a folded instruction can appear anywhere a regular instruction can.
    no additional syntactic or type-based checking is implied.
 
 
-.. _text-expr:
 .. index:: expression
    pair: text format; expression
    single: expression; constant
+.. _text-expr:
 
 Expressions
 ~~~~~~~~~~~
diff --git a/document/text/lexical.rst b/document/text/lexical.rst
index abf6466e6..800b21adc 100644
--- a/document/text/lexical.rst
+++ b/document/text/lexical.rst
@@ -1,13 +1,14 @@
-.. _text-lexical:
 .. index:: lexical format
+.. _text-lexical:
 
 Lexical Format
 --------------
 
 
-.. _text-char:
 .. index:: ! character, Unicode, ASCII, code point, ! source text
    pair: text format; character
+.. _source:
+.. _text-char:
 
 Characters
 ~~~~~~~~~~
@@ -26,10 +27,11 @@ Characters are assumed to be represented as valid `Unicode <http://www.unicode.o
    the rest of the grammar is formed exclusively from the characters supported by the `7-bit ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ subset of Unicode.
 
 
-.. _text-token:
-.. _text-keyword:
 .. index:: ! token, ! keyword, character, white space, comment, source text
    single: text format; token
+.. _text-keyword:
+.. _text-reserved:
+.. _text-token:
 
 Tokens
 ~~~~~~
@@ -55,9 +57,10 @@ That is, the next token always consists of the longest possible sequence of char
 Where necessary, tokens may be separated by :ref:`white space <text-space>`.
 
 
-.. _text-space:
 .. index:: ! white space, character, ASCII
    single: text format; white space
+.. _text-format:
+.. _text-space:
 
 White Space
 ~~~~~~~~~~~
@@ -76,9 +79,9 @@ The allowed formatting characters correspond to a subset of the `ASCII <http://w
 The only relevance of white space is to separate :ref:`tokens <text-token>`, it is ignored otherwise.
 
 
-.. _text-comment:
 .. index:: ! comment, character
    single: text format; comment
+.. _text-comment:
 
 Comments
 ~~~~~~~~
diff --git a/document/text/modules.rst b/document/text/modules.rst
index 8f769a6c5..bdb983774 100644
--- a/document/text/modules.rst
+++ b/document/text/modules.rst
@@ -2,9 +2,58 @@ Modules
 -------
 
 
-.. _text-type:
+.. index:: index, type index, function index, table index, memory index, global index, local index, label index
+   pair: text format; type index
+   pair: text format; function index
+   pair: text format; table index
+   pair: text format; memory index
+   pair: text format; global index
+   pair: text format; local index
+   pair: text format; label index
+.. _text-typeidx:
+.. _text-funcidx:
+.. _text-tableidx:
+.. _text-memidx:
+.. _text-globalidx:
+.. _text-localidx:
+.. _text-labelidx:
+.. _text-index:
+
+Indices
+~~~~~~~
+
+:ref:`Indices <syntax-index>` can be given either in raw numeric form or as symbolic :ref:`identifiers <text-id>` when bound by a respective construct.
+Such identifiers are looked up in the suitable space of the :ref:`identifier context <text-context>`.
+
+.. math::
+   \begin{array}{llcllllllll}
+   \production{type index} & \Ttypeidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\TYPES[x] = v) \\
+   \production{function index} & \Tfuncidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\FUNCS[x] = v) \\
+   \production{table index} & \Ttableidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\TABLES[x] = v) \\
+   \production{memory index} & \Tmemidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\MEMS[x] = v) \\
+   \production{global index} & \Tglobalidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\GLOBALS[x] = v) \\
+   \production{local index} & \Tlocalidx_I &::=&
+     x{:}\Tu32 &\Rightarrow& x &|&
+     v{:}\Tid &\Rightarrow& x & (I.\LOCALS[x] = v) \\
+   \production{label index} & \Tlabelidx_I &::=&
+     l{:}\Tu32 &\Rightarrow& l &|&
+     v{:}\Tid &\Rightarrow& l & (I.\LABELS[l] = v) \\
+   \end{array}
+
+
 .. index:: type definition, identifier
    pair: text format; type definition
+.. _text-typedef:
 
 Types
 ~~~~~
@@ -19,9 +68,9 @@ Type definitions can bind a symbolic :ref:`type identifier <text-id>`.
    \end{array}
 
 
-.. _text-typeuse:
 .. index:: type use
    pair: text format; type use
+.. _text-typeuse:
 
 Type Uses
 ~~~~~~~~~
@@ -91,9 +140,10 @@ is first inserted at the end of the module.
    Abbreviations are expanded in the order they appear, such that previously inserted type definitions are reused by consecutive expansions.
 
 
-.. _text-import:
 .. index:: import, name, function type, table type, memory type, global type
    pair: text format; import
+.. _text-importdesc:
+.. _text-import:
 
 Imports
 ~~~~~~~
@@ -124,11 +174,11 @@ As an abbreviation, imports may also be specified inline with :ref:`function <te
 
 
 
-.. _text-func:
-.. _text-local:
 .. index:: function, type index, function type, identifier, local
    pair: text format; function
    pair: text format; local
+.. _text-local:
+.. _text-func:
 
 Functions
 ~~~~~~~~~
@@ -159,11 +209,11 @@ The definition of the local :ref:`identifier context <text-context>` :math:`I''`
    The :ref:`well-formedness <text-context-wf>` condition on :math:`I''` ensures that parameters and locals do not contain duplicate identifiers.
 
 
-.. _text-func-abbrev:
 .. index:: import, name
    pair: text format; import
 .. index:: export, name, index, function index
    pair: text format; export
+.. _text-func-abbrev:
 
 Abbreviations
 .............
@@ -194,9 +244,9 @@ Moreover, functions can be defined as :ref:`imports <text-import>` or :ref:`expo
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export.
 
 
-.. _text-table:
 .. index:: table, table type, identifier
    pair: text format; table
+.. _text-table:
 
 Tables
 ~~~~~~
@@ -211,7 +261,6 @@ Table definitions can bind a symbolic :ref:`table identifier <text-id>`.
    \end{array}
 
 
-.. _text-table-abbrev:
 .. index:: import, name
    pair: text format; import
 .. index:: export, name, index, table index
@@ -220,6 +269,7 @@ Table definitions can bind a symbolic :ref:`table identifier <text-id>`.
    pair: text format; element
    single: table; element
    single: element; segment
+.. _text-table-abbrev:
 
 Abbreviations
 .............
@@ -253,9 +303,9 @@ Moreover, tables can be defined as :ref:`imports <text-import>` or :ref:`exports
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline elements segment.
 
 
-.. _text-mem:
 .. index:: memory, memory type, identifier
    pair: text format; memory
+.. _text-mem:
 
 Memories
 ~~~~~~~~
@@ -270,7 +320,6 @@ Memory definitions can bind a symbolic :ref:`memory identifier <text-id>`.
    \end{array}
 
 
-.. _text-mem-abbrev:
 .. index:: import, name
    pair: text format; import
 .. index:: export, name, index, memory index
@@ -279,6 +328,7 @@ Memory definitions can bind a symbolic :ref:`memory identifier <text-id>`.
    pair: text format; data
    single: memory; data
    single: data; segment
+.. _text-mem-abbrev:
 
 Abbreviations
 .............
@@ -313,9 +363,9 @@ Moreover, memories can be defined as :ref:`imports <text-import>` or :ref:`expor
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline data segment.
 
 
-.. _text-global:
 .. index:: global, global type, identifier, expression
    pair: text format; global
+.. _text-global:
 
 Globals
 ~~~~~~~
@@ -330,11 +380,11 @@ Global definitions can bind a symbolic :ref:`global identifier <text-id>`.
    \end{array}
 
 
-.. _text-global-abbrev:
 .. index:: import, name
    pair: text format; import
 .. index:: export, name, index, global index
    pair: text format; export
+.. _text-global-abbrev:
 
 Abbreviations
 .............
@@ -357,9 +407,10 @@ Globals can be defined as :ref:`imports <text-import>` or :ref:`exports <text-ex
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export.
 
 
-.. _text-export:
 .. index:: export, name, index, function index, table index, memory index, global index
    pair: text format; export
+.. _text-exportdesc:
+.. _text-export:
 
 Exports
 ~~~~~~~
@@ -389,9 +440,9 @@ Abbreviations
 As an abbreviation, exports may also be specified inline with :ref:`function <text-func>`, :ref:`table <text-table>`, :ref:`memory <text-mem>`, or :ref:`global <text-global>` definitions; see the respective sections.
 
 
-.. _text-start:
 .. index:: start function, function index
    pair: text format; start function
+.. _text-start:
 
 Start Function
 ~~~~~~~~~~~~~~
@@ -411,11 +462,11 @@ A :ref:`start function <syntax-start>` is defined in terms of its index.
 
 
 
-.. _text-elem:
 .. index:: element, table index, expression, function index
    pair: text format; element
    single: table; element
    single: element; segment
+.. _text-elem:
 
 Element Segments
 ~~~~~~~~~~~~~~~~
@@ -442,12 +493,12 @@ Abbreviations
 As an abbreviation, element segments may also be specified inline with :ref:`table <text-table>` definitions; see the respective section.
 
 
-.. _text-data:
-.. _text-datastring:
 .. index:: data, memory, memory index, expression, byte
    pair: text format; data
    single: memory; data
    single: data; segment
+.. _text-datastring:
+.. _text-data:
 
 Data Segments
 ~~~~~~~~~~~~~
@@ -477,12 +528,11 @@ Abbreviations
 As an abbreviation, data segments may also be specified inline with :ref:`memory <text-mem>` definitions; see the respective section.
 
 
-.. _text-module:
-.. _text-modulebody:
-.. _text-modulefield:
 .. index:: module, type definition, function type, function, table, memory, global, element, data, start function, import, export, identifier context, identifier, name section
    pair: text format; module
    single: section; name
+.. _text-modulefield:
+.. _text-module:
 
 Modules
 ~~~~~~~
diff --git a/document/text/types.rst b/document/text/types.rst
index 78b02183e..2eed74e78 100644
--- a/document/text/types.rst
+++ b/document/text/types.rst
@@ -1,13 +1,13 @@
-.. _text-type:
 .. index:: type
    pair: text format; type
+.. _text-type:
 
 Types
 -----
 
-.. _text-valtype:
 .. index:: value type
    pair: text format; value type
+.. _text-valtype:
 
 Value Types
 ~~~~~~~~~~~
@@ -22,9 +22,9 @@ Value Types
    \end{array}
 
 
-.. _text-resulttype:
 .. index:: result type, value type
    pair: text format; result type
+.. _text-resulttype:
 
 Result Types
 ~~~~~~~~~~~~
@@ -39,11 +39,11 @@ Result Types
    In future versions of WebAssembly, this scheme may be extended to support multiple results or more general result types.
 
 
-.. _text-functype:
-.. _text-param:
-.. _text-result:
 .. index:: function type, value type, result type
    pair: text format; function type
+.. _text-param:
+.. _text-result:
+.. _text-functype:
 
 Function Types
 ~~~~~~~~~~~~~~
@@ -77,9 +77,9 @@ Multiple anonymous parameters or results may be combined into a single declarati
    \end{array}
 
 
-.. _text-limits:
 .. index:: limits
    pair: text format; limits
+.. _text-limits:
 
 Limits
 ~~~~~~
@@ -92,9 +92,9 @@ Limits
     \end{array}
 
 
-.. _text-memtype:
 .. index:: memory type, limits, page size
    pair: text format; memory type
+.. _text-memtype:
 
 Memory Types
 ~~~~~~~~~~~~
@@ -106,11 +106,11 @@ Memory Types
    \end{array}
 
 
-.. _text-tabletype:
-.. _text-elemtype:
 .. index:: table type, element type, limits
    pair: text format; table type
    pair: text format; element type
+.. _text-elemtype:
+.. _text-tabletype:
 
 Table Types
 ~~~~~~~~~~~
@@ -127,10 +127,10 @@ Table Types
    Additional element types may be introduced in future versions of WebAssembly.
 
 
-.. _text-globaltype:
 .. index:: global type, mutability, value type
    pair: text format; global type
    pair: text format; mutability
+.. _text-globaltype:
 
 Global Types
 ~~~~~~~~~~~~
diff --git a/document/text/values.rst b/document/text/values.rst
index a07d99c07..aa041d0a1 100644
--- a/document/text/values.rst
+++ b/document/text/values.rst
@@ -1,6 +1,6 @@
-.. _text-value:
 .. index:: value
    pair: text format; value
+.. _text-value:
 
 Values
 ------
@@ -9,17 +9,19 @@ The grammar productions in this section define *lexical syntax*,
 hence no :ref:`white space <text-space>` is allowed.
 
 
-.. _text-sign:
-.. _text-digit:
-.. _text-hexdigit:
-.. _text-int:
-.. _text-sint:
-.. _text-uint:
 .. index:: integer, unsigned integer, signed integer, uninterpreted integer
    pair: text format; integer
    pair: text format; unsigned integer
    pair: text format; signed integer
    pair: text format; uninterpreted integer
+.. _text-sign:
+.. _text-digit:
+.. _text-hexdigit:
+.. _text-num:
+.. _text-hexnum:
+.. _text-sint:
+.. _text-uint:
+.. _text-int:
 
 Integers
 ~~~~~~~~
@@ -73,12 +75,12 @@ Moreover, their value must lie within the range of the respective type.
    \end{array}
 
 
+.. index:: floating-point number
+   pair: text format; floating-point number
 .. _text-frac:
 .. _text-hexfrac:
-.. _text-float:
 .. _text-hexfloat:
-.. index:: floating-point number
-   pair: text format; floating-point number
+.. _text-float:
 
 Floating-Point
 ~~~~~~~~~~~~~~
@@ -127,9 +129,9 @@ Furthermore, arbitrary NaN values may be expressed by providing an explicit payl
    \end{array}
 
 
-.. _text-vec:
 .. index:: vector
    pair: text format; vector
+.. _text-vec:
 
 Vectors
 ~~~~~~~
@@ -143,11 +145,11 @@ Vectors
    \end{array}
 
 
-.. _text-byte:
-.. _text-string:
 .. index:: ! string, byte, character, ASCII, Unicode, UTF-8
    pair: text format; byte
    pair: text format; string
+.. _text-byte:
+.. _text-string:
 
 Strings
 ~~~~~~~
@@ -184,9 +186,9 @@ except for hexadecimal escape sequences :math:`\text{\backslash}hh`, which repre
    \end{array}
 
 
-.. _text-name:
 .. index:: name, byte, character, code point
    pair: text format; name
+.. _text-name:
 
 Names
 ~~~~~
@@ -205,9 +207,9 @@ A name string must form a valid `UTF-8 <http://www.unicode.org/versions/latest/>
    strings that do not contain any uses of hexadecimal byte escapes are always valid names.
 
 
-.. _text-id:
 .. index:: ! identifiers
    pair: text format; identifiers
+.. _text-id:
 
 Identifiers
 ~~~~~~~~~~~
@@ -248,8 +250,6 @@ Symbolic *identifiers* that stand in lieu of indices start with :math:`\text{\$}
      \text{\tilde{~~}} \\
    \end{array}
 
-.. bla
-
 .. _text-id-fresh:
 
 Conventions
diff --git a/document/validation/conventions.rst b/document/validation/conventions.rst
index 72a808f7b..f0acf3418 100644
--- a/document/validation/conventions.rst
+++ b/document/validation/conventions.rst
@@ -1,4 +1,5 @@
 .. index:: ! validation, ! type system, function type, table type, memory type, globaltype, valtype, resulttype, index space
+.. _type-system:
 
 Conventions
 -----------
@@ -20,11 +21,11 @@ All rules are given in two *equivalent* forms:
 
 In both cases, the rules are formulated in a *declarative* manner.
 That is, they only formulate the constraints, they do not define an algorithm.
-A sound and complete algorithm for type-checking instruction sequences according to this specification is provided in the :ref:`appendix <checking>`.
+A sound and complete algorithm for type-checking instruction sequences according to this specification is provided in the :ref:`appendix <soundness>`.
 
 
-.. _context:
 .. index:: ! context, function type, table type, memory type, global type, value type, result type, index space
+.. _context:
 
 Contexts
 ~~~~~~~~
@@ -108,8 +109,8 @@ The following conventions are adopted in stating these rules.
   The formulation "Under context :math:`C'`, ... *statement* ..." is adopted to express that the following statement must apply under the assumptions embodied in the extended context.
 
 
-.. _valid-notation:
 .. index:: ! typing rules
+.. _valid-notation:
 
 Formal Notation
 ~~~~~~~~~~~~~~~
diff --git a/document/validation/index.rst b/document/validation/index.rst
index 3606f529f..0f39bfd5c 100644
--- a/document/validation/index.rst
+++ b/document/validation/index.rst
@@ -1,3 +1,5 @@
+.. _valid:
+
 Validation
 ==========
 
diff --git a/document/validation/instructions.rst b/document/validation/instructions.rst
index 087dd8611..1aa52473f 100644
--- a/document/validation/instructions.rst
+++ b/document/validation/instructions.rst
@@ -1,5 +1,5 @@
-.. _valid-instr:
 .. index:: instruction, function type, context
+.. _valid-instr:
 
 Instructions
 ------------
@@ -62,10 +62,10 @@ In both cases, the unconstrained types or type sequences can be chosen arbitrari
    is invalid, because there is no possible type to pick for the |UNREACHABLE| instruction that would make the sequence well-typed.
 
 
-.. _valid-instr-numeric:
 .. index:: numeric instruction
    pair: validation; instruction
    single: abstract syntax; instruction
+.. _valid-instr-numeric:
 
 Numeric Instructions
 ~~~~~~~~~~~~~~~~~~~~
@@ -154,10 +154,10 @@ Numeric Instructions
    }
 
 
-.. _valid-instr-parametric:
 .. index:: parametric instructions, value type, polymorphism
    pair: validation; instruction
    single: abstract syntax; instruction
+.. _valid-instr-parametric:
 
 Parametric Instructions
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -193,10 +193,10 @@ Parametric Instructions
    Both |DROP| and |SELECT| are :ref:`value-polymorphic <polymorphism>` instructions.
 
 
-.. _valid-instr-variable:
 .. index:: variable instructions, local index, global index
    pair: validation; instruction
    single: abstract syntax; instruction
+.. _valid-instr-variable:
 
 Variable Instructions
 ~~~~~~~~~~~~~~~~~~~~~
@@ -298,11 +298,11 @@ Variable Instructions
    }
 
 
-.. _valid-instr-memory:
-.. _valid-memarg:
 .. index:: memory instruction, memory index
    pair: validation; instruction
    single: abstract syntax; instruction
+.. _valid-memarg:
+.. _valid-instr-memory:
 
 Memory Instructions
 ~~~~~~~~~~~~~~~~~~~
@@ -425,11 +425,11 @@ Memory Instructions
    }
 
 
-.. _valid-instr-control:
-.. _valid-label:
 .. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, polymorphism
    pair: validation; instruction
    single: abstract syntax; instruction
+.. _valid-label:
+.. _valid-instr-control:
 
 Control Instructions
 ~~~~~~~~~~~~~~~~~~~~
@@ -681,8 +681,8 @@ Control Instructions
    }
 
 
-.. _valid-instr-seq:
 .. index:: instruction, instruction sequence
+.. _valid-instr-seq:
 
 Instruction Sequences
 ~~~~~~~~~~~~~~~~~~~~~
@@ -727,11 +727,11 @@ Non-empty Instruction Sequence: :math:`\instr^\ast~\instr_N`
    }
 
 
-.. _valid-expr:
 .. index:: expression
    pair: validation; expression
    single: abstract syntax; expression
    single: expression; constant
+.. _valid-expr:
 
 Expressions
 ~~~~~~~~~~~
@@ -755,8 +755,8 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
    }
 
 
-.. _valid-constant:
 .. index:: ! constant
+.. _valid-constant:
 
 Constant Expressions
 ....................
diff --git a/document/validation/modules.rst b/document/validation/modules.rst
index ee238344b..f6bcb5bed 100644
--- a/document/validation/modules.rst
+++ b/document/validation/modules.rst
@@ -8,10 +8,10 @@ To that end, each definition is classified with a suitable type.
 Auxiliary Rules
 ~~~~~~~~~~~~~~~
 
-.. _valid-functype:
 .. index:: function type
    pair: validation; function type
    single: abstract syntax; function type
+.. _valid-functype:
 
 Function Types :math:`[t_1^n] \to [t_2^m]`
 ..........................................
@@ -30,10 +30,10 @@ Function Types :math:`[t_1^n] \to [t_2^m]`
    This restriction may be removed in future versions of WebAssembly.
 
 
-.. _valid-limits:
 .. index:: limits
    pair: validation; limits
    single: abstract syntax; limits
+.. _valid-limits:
 
 Limits :math:`\{ \MIN~n, \MAX~m^? \}`
 .....................................
@@ -50,11 +50,11 @@ Limits :math:`\{ \MIN~n, \MAX~m^? \}`
    }
 
 
-.. _valid-func:
-.. _valid-local:
 .. index:: function, local, function index, local index, type index, function type, value type, expression, import
    pair: abstract syntax; function
    single: abstract syntax; function
+.. _valid-local:
+.. _valid-func:
 
 Functions
 ~~~~~~~~~
@@ -96,10 +96,10 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
    The restriction on the length of the result types :math:`t_2^\ast` may be lifted in future versions of WebAssembly.
 
 
-.. _valid-table:
 .. index:: table, table type, limits, element type
    pair: validation; table
    single: abstract syntax; table
+.. _valid-table:
 
 Tables
 ~~~~~~
@@ -122,10 +122,10 @@ Tables :math:`\table` are classified by :ref:`table types <syntax-tabletype>` of
    }
 
 
-.. _valid-mem:
 .. index:: memory, memory type, limits
    pair: validation; memory
    single: abstract syntax; memory
+.. _valid-mem:
 
 Memories
 ~~~~~~~~
@@ -148,10 +148,10 @@ Memories :math:`\mem` are classified by :ref:`memory types <syntax-memtype>` of
    }
 
 
-.. _valid-global:
 .. index:: global, global type, mutability, expression
    pair: validation; global
    single: abstract syntax; global
+.. _valid-global:
 
 Globals
 ~~~~~~~
@@ -178,12 +178,12 @@ Globals :math:`\global` are classified by :ref:`global types <syntax-globaltype>
    }
 
 
-.. _valid-elem:
 .. index:: element, table, table index, expression, function index
    pair: validation; element
    single: abstract syntax; element
    single: table; element
    single: element; segment
+.. _valid-elem:
 
 Element Segments
 ~~~~~~~~~~~~~~~~
@@ -223,12 +223,12 @@ Element segments :math:`\elem` are not classified by a type.
    }
 
 
-.. _valid-data:
 .. index:: data, memory, memory index, expression, byte
    pair: validation; data
    single: abstract syntax; data
    single: memory; data
    single: data; segment
+.. _valid-data:
 
 Data Segments
 ~~~~~~~~~~~~~
@@ -259,10 +259,10 @@ Data segments :math:`\data` are not classified by any type.
    }
 
 
-.. _valid-start:
 .. index:: start function, function index
    pair: validation; start function
    single: abstract syntax; start function
+.. _valid-start:
 
 Start Function
 ~~~~~~~~~~~~~~
@@ -287,10 +287,10 @@ Start function declarations :math:`\start` are not classified by any type.
    }
 
 
-.. _valid-export:
 .. index:: export, name, index, function index, table index, memory index, global index
    pair: validation; export
    single: abstract syntax; export
+.. _valid-export:
 
 Exports
 ~~~~~~~
@@ -378,10 +378,10 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
    }
 
 
-.. _valid-import:
 .. index:: import, name, function type, table type, memory type, global type
    pair: validation; import
    single: abstract syntax; import
+.. _valid-import:
 
 Imports
 ~~~~~~~
@@ -465,10 +465,10 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
    }
 
 
-.. _valid-module:
 .. index:: module, type definition, function type, function, table, memory, global, element, data, start function, import, export, context
    pair: validation; module
    single: abstract syntax; module
+.. _valid-module:
 
 Modules
 ~~~~~~~

From 0e7d632a3bde2a61c1a09f342822d75f7139e9af Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 29 Jun 2017 15:56:48 +0200
Subject: [PATCH 047/329] [spec] Various CSS tweaks (#515)

---
 document/custom.css | 18 +++++++++++++++++-
 1 file changed, 17 insertions(+), 1 deletion(-)

diff --git a/document/custom.css b/document/custom.css
index 9e8ba21fb..009fb6424 100644
--- a/document/custom.css
+++ b/document/custom.css
@@ -11,7 +11,13 @@ a.reference:hover {
   border-bottom: 1px dotted #004BAB;
 }
 
+body {
+  font-size: 15px;
+}
+
 div.document { width: 1000px; }
+div.bodywrapper { margin: 0 0 0 200px; }
+div.body { padding: 0 10px 0 10px; }
 div.footer { width: 1000px; }
 
 div.body h1 { font-size: 200%; }
@@ -22,6 +28,7 @@ div.body h4 { font-size: 110%; }
 div.note {
   border: 0px;
   font-size: 90%;
+  background-color: #FCF4FF;
 }
 
 div.admonition {
@@ -39,10 +46,19 @@ div.sphinxsidebar {
   z-index: 1;
   background: #FFF;
   margin-top: -30px;
-  width: 230px;
+  font-size: 13px;
+  width: 200px;
   height: 100%;
 }
 
+div.sphinxsidebarwrapper p.logo {
+  padding: 30px 40px 10px 0px;
+}
+
+div.sphinxsidebar h3 {
+  font-size: 0px;
+}
+
 div.sphinxsidebar a {
   border-bottom: 0px;
 }

From dd02465d27673082285d162d1bcd1ac31818f27f Mon Sep 17 00:00:00 2001
From: Junior Rojas <jrojasdavalos@gmail.com>
Date: Fri, 30 Jun 2017 03:08:00 -0600
Subject: [PATCH 048/329] [interpreter] Fix broken links in README (#516)

---
 interpreter/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 6426cdf92..19f88604e 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -347,9 +347,9 @@ Finally, "checked hard" mode (flag `-c`), will require `assert_soft_valid` asser
 
 ## Abstract Syntax
 
-The abstract WebAssembly syntax, as described above and in the [design doc](https://github.com/WebAssembly/design/blob/master/Semantics.md), is defined in [ast.ml](spec/ast.ml).
+The abstract WebAssembly syntax, as described above and in the [design doc](https://github.com/WebAssembly/design/blob/master/Semantics.md), is defined in [ast.ml](syntax/ast.ml).
 
-However, to simplify the implementation, this AST representation represents some of the inner structure of the operators more explicitly. The mapping from the operators as given in the design doc to their structured form is defined in [operators.ml](spec/operators.ml).
+However, to simplify the implementation, this AST representation represents some of the inner structure of the operators more explicitly. The mapping from the operators as given in the design doc to their structured form is defined in [operators.ml](syntax/operators.ml).
 
 
 ## Implementation

From 9992280177a06debb8d50654c89daa13bd82d3ad Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Fri, 30 Jun 2017 11:40:38 +0200
Subject: [PATCH 049/329] [spec] Move main spec into its own dir (#517)

---
 document/{ => core}/.gitignore                |   0
 document/{ => core}/LICENSE                   |   0
 document/{ => core}/Makefile                  |   2 +-
 document/{ => core}/README.md                 |   0
 document/{ => core}/appendix/algorithm.rst    |   0
 .../{ => core}/appendix/implementation.rst    |   0
 document/{ => core}/appendix/index.rst        |   0
 document/{ => core}/appendix/names.rst        |   0
 document/{ => core}/appendix/properties.rst   |   0
 document/{ => core}/binary/conventions.rst    |   0
 document/{ => core}/binary/index.rst          |   0
 document/{ => core}/binary/instructions.rst   |   0
 document/{ => core}/binary/modules.rst        |   0
 document/{ => core}/binary/types.rst          |   0
 document/{ => core}/binary/values.rst         |   0
 document/{ => core}/conf.py                   |   8 +-
 .../{execution => core/exec}/conventions.rst  |   0
 document/{execution => core/exec}/index.rst   |   0
 .../{execution => core/exec}/instructions.rst |   0
 document/{execution => core/exec}/modules.rst |   0
 .../{execution => core/exec}/numerics.rst     |   0
 document/{execution => core/exec}/runtime.rst |   0
 document/{ => core}/index.rst                 |   6 +-
 .../{introduction => core/intro}/index.rst    |   0
 .../intro}/introduction.rst                   |   0
 .../{introduction => core/intro}/overview.rst |   0
 document/{ => core}/make.bat                  |   0
 document/{ => core/static}/custom.css         |   2 +-
 document/{ => core/static}/webassembly.png    | Bin
 document/{ => core}/syntax/conventions.rst    |   0
 document/{ => core}/syntax/index.rst          |   0
 document/{ => core}/syntax/instrindex.rst     |   0
 document/{ => core}/syntax/instructions.rst   |   0
 document/{ => core}/syntax/modules.rst        |   0
 document/{ => core}/syntax/types.rst          |   0
 document/{ => core}/syntax/values.rst         |   0
 document/{ => core}/text/conventions.rst      |   0
 document/{ => core}/text/index.rst            |   0
 document/{ => core}/text/instructions.rst     |   0
 document/{ => core}/text/lexical.rst          |   0
 document/{ => core}/text/modules.rst          |   0
 document/{ => core}/text/types.rst            |   0
 document/{ => core}/text/values.rst           |   0
 document/{ => core/util}/deploy.sh            |   0
 document/{ => core/util}/math.def             | 226 +++++++++---------
 document/{ => core/util}/mathdef.py           |   0
 .../valid}/conventions.rst                    |   0
 document/{validation => core/valid}/index.rst |   0
 .../valid}/instructions.rst                   |   0
 .../{validation => core/valid}/modules.rst    |   0
 50 files changed, 122 insertions(+), 122 deletions(-)
 rename document/{ => core}/.gitignore (100%)
 rename document/{ => core}/LICENSE (100%)
 rename document/{ => core}/Makefile (99%)
 rename document/{ => core}/README.md (100%)
 rename document/{ => core}/appendix/algorithm.rst (100%)
 rename document/{ => core}/appendix/implementation.rst (100%)
 rename document/{ => core}/appendix/index.rst (100%)
 rename document/{ => core}/appendix/names.rst (100%)
 rename document/{ => core}/appendix/properties.rst (100%)
 rename document/{ => core}/binary/conventions.rst (100%)
 rename document/{ => core}/binary/index.rst (100%)
 rename document/{ => core}/binary/instructions.rst (100%)
 rename document/{ => core}/binary/modules.rst (100%)
 rename document/{ => core}/binary/types.rst (100%)
 rename document/{ => core}/binary/values.rst (100%)
 rename document/{ => core}/conf.py (98%)
 rename document/{execution => core/exec}/conventions.rst (100%)
 rename document/{execution => core/exec}/index.rst (100%)
 rename document/{execution => core/exec}/instructions.rst (100%)
 rename document/{execution => core/exec}/modules.rst (100%)
 rename document/{execution => core/exec}/numerics.rst (100%)
 rename document/{execution => core/exec}/runtime.rst (100%)
 rename document/{ => core}/index.rst (85%)
 rename document/{introduction => core/intro}/index.rst (100%)
 rename document/{introduction => core/intro}/introduction.rst (100%)
 rename document/{introduction => core/intro}/overview.rst (100%)
 rename document/{ => core}/make.bat (100%)
 rename document/{ => core/static}/custom.css (97%)
 rename document/{ => core/static}/webassembly.png (100%)
 rename document/{ => core}/syntax/conventions.rst (100%)
 rename document/{ => core}/syntax/index.rst (100%)
 rename document/{ => core}/syntax/instrindex.rst (100%)
 rename document/{ => core}/syntax/instructions.rst (100%)
 rename document/{ => core}/syntax/modules.rst (100%)
 rename document/{ => core}/syntax/types.rst (100%)
 rename document/{ => core}/syntax/values.rst (100%)
 rename document/{ => core}/text/conventions.rst (100%)
 rename document/{ => core}/text/index.rst (100%)
 rename document/{ => core}/text/instructions.rst (100%)
 rename document/{ => core}/text/lexical.rst (100%)
 rename document/{ => core}/text/modules.rst (100%)
 rename document/{ => core}/text/types.rst (100%)
 rename document/{ => core}/text/values.rst (100%)
 rename document/{ => core/util}/deploy.sh (100%)
 rename document/{ => core/util}/math.def (77%)
 rename document/{ => core/util}/mathdef.py (100%)
 rename document/{validation => core/valid}/conventions.rst (100%)
 rename document/{validation => core/valid}/index.rst (100%)
 rename document/{validation => core/valid}/instructions.rst (100%)
 rename document/{validation => core/valid}/modules.rst (100%)

diff --git a/document/.gitignore b/document/core/.gitignore
similarity index 100%
rename from document/.gitignore
rename to document/core/.gitignore
diff --git a/document/LICENSE b/document/core/LICENSE
similarity index 100%
rename from document/LICENSE
rename to document/core/LICENSE
diff --git a/document/Makefile b/document/core/Makefile
similarity index 99%
rename from document/Makefile
rename to document/core/Makefile
index 3c6e8b30c..8dbafcff9 100644
--- a/document/Makefile
+++ b/document/core/Makefile
@@ -69,7 +69,7 @@ publish: all deploy
 
 .PHONY: deploy
 deploy:
-	GIT_DEPLOY_DIR=$(BUILDDIR)/html sh deploy.sh
+	GIT_DEPLOY_DIR=$(BUILDDIR)/html sh util/deploy.sh
 
 .PHONY: all
 all:	pdf html
diff --git a/document/README.md b/document/core/README.md
similarity index 100%
rename from document/README.md
rename to document/core/README.md
diff --git a/document/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
similarity index 100%
rename from document/appendix/algorithm.rst
rename to document/core/appendix/algorithm.rst
diff --git a/document/appendix/implementation.rst b/document/core/appendix/implementation.rst
similarity index 100%
rename from document/appendix/implementation.rst
rename to document/core/appendix/implementation.rst
diff --git a/document/appendix/index.rst b/document/core/appendix/index.rst
similarity index 100%
rename from document/appendix/index.rst
rename to document/core/appendix/index.rst
diff --git a/document/appendix/names.rst b/document/core/appendix/names.rst
similarity index 100%
rename from document/appendix/names.rst
rename to document/core/appendix/names.rst
diff --git a/document/appendix/properties.rst b/document/core/appendix/properties.rst
similarity index 100%
rename from document/appendix/properties.rst
rename to document/core/appendix/properties.rst
diff --git a/document/binary/conventions.rst b/document/core/binary/conventions.rst
similarity index 100%
rename from document/binary/conventions.rst
rename to document/core/binary/conventions.rst
diff --git a/document/binary/index.rst b/document/core/binary/index.rst
similarity index 100%
rename from document/binary/index.rst
rename to document/core/binary/index.rst
diff --git a/document/binary/instructions.rst b/document/core/binary/instructions.rst
similarity index 100%
rename from document/binary/instructions.rst
rename to document/core/binary/instructions.rst
diff --git a/document/binary/modules.rst b/document/core/binary/modules.rst
similarity index 100%
rename from document/binary/modules.rst
rename to document/core/binary/modules.rst
diff --git a/document/binary/types.rst b/document/core/binary/types.rst
similarity index 100%
rename from document/binary/types.rst
rename to document/core/binary/types.rst
diff --git a/document/binary/values.rst b/document/core/binary/values.rst
similarity index 100%
rename from document/binary/values.rst
rename to document/core/binary/values.rst
diff --git a/document/conf.py b/document/core/conf.py
similarity index 98%
rename from document/conf.py
rename to document/core/conf.py
index 5e47f8eaf..8ea16cd72 100644
--- a/document/conf.py
+++ b/document/core/conf.py
@@ -18,7 +18,7 @@
 import os
 import sys
 pwd = os.path.abspath('.')
-sys.path.insert(0, pwd)
+sys.path.insert(0, pwd + '/util')
 
 # -- General configuration ------------------------------------------------
 
@@ -59,7 +59,7 @@
 title = u'WebAssembly Specification'
 copyright = u'2017, WebAssembly Community Group'
 author = u'WebAssembly Community Group'
-logo = 'webassembly.png'
+logo = 'static/webassembly.png'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -183,7 +183,7 @@
 # Add any paths that contain custom static files (such as style sheets) here,
 # relative to this directory. They are copied after the builtin static files,
 # so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static', 'custom.css']
+html_static_path = ['_static', 'static/custom.css']
 
 # Add any extra paths that contain custom files (such as robots.txt or
 # .htaccess) here, relative to this directory. These files are copied
@@ -473,5 +473,5 @@
 
 # Macros
 rst_prolog = """
-.. include:: /""" + pwd + """/math.def
+.. include:: /""" + pwd + """/util/math.def
 """
diff --git a/document/execution/conventions.rst b/document/core/exec/conventions.rst
similarity index 100%
rename from document/execution/conventions.rst
rename to document/core/exec/conventions.rst
diff --git a/document/execution/index.rst b/document/core/exec/index.rst
similarity index 100%
rename from document/execution/index.rst
rename to document/core/exec/index.rst
diff --git a/document/execution/instructions.rst b/document/core/exec/instructions.rst
similarity index 100%
rename from document/execution/instructions.rst
rename to document/core/exec/instructions.rst
diff --git a/document/execution/modules.rst b/document/core/exec/modules.rst
similarity index 100%
rename from document/execution/modules.rst
rename to document/core/exec/modules.rst
diff --git a/document/execution/numerics.rst b/document/core/exec/numerics.rst
similarity index 100%
rename from document/execution/numerics.rst
rename to document/core/exec/numerics.rst
diff --git a/document/execution/runtime.rst b/document/core/exec/runtime.rst
similarity index 100%
rename from document/execution/runtime.rst
rename to document/core/exec/runtime.rst
diff --git a/document/index.rst b/document/core/index.rst
similarity index 85%
rename from document/index.rst
rename to document/core/index.rst
index 2554ac250..124f2f8c6 100644
--- a/document/index.rst
+++ b/document/core/index.rst
@@ -8,10 +8,10 @@ WebAssembly Specification
 .. toctree::
    :maxdepth: 3
 
-   introduction/index
+   intro/index
    syntax/index
-   validation/index
-   execution/index
+   valid/index
+   exec/index
    binary/index
    text/index
    appendix/index
diff --git a/document/introduction/index.rst b/document/core/intro/index.rst
similarity index 100%
rename from document/introduction/index.rst
rename to document/core/intro/index.rst
diff --git a/document/introduction/introduction.rst b/document/core/intro/introduction.rst
similarity index 100%
rename from document/introduction/introduction.rst
rename to document/core/intro/introduction.rst
diff --git a/document/introduction/overview.rst b/document/core/intro/overview.rst
similarity index 100%
rename from document/introduction/overview.rst
rename to document/core/intro/overview.rst
diff --git a/document/make.bat b/document/core/make.bat
similarity index 100%
rename from document/make.bat
rename to document/core/make.bat
diff --git a/document/custom.css b/document/core/static/custom.css
similarity index 97%
rename from document/custom.css
rename to document/core/static/custom.css
index 009fb6424..101507942 100644
--- a/document/custom.css
+++ b/document/core/static/custom.css
@@ -28,7 +28,7 @@ div.body h4 { font-size: 110%; }
 div.note {
   border: 0px;
   font-size: 90%;
-  background-color: #FCF4FF;
+  background-color: #F4F6FF;
 }
 
 div.admonition {
diff --git a/document/webassembly.png b/document/core/static/webassembly.png
similarity index 100%
rename from document/webassembly.png
rename to document/core/static/webassembly.png
diff --git a/document/syntax/conventions.rst b/document/core/syntax/conventions.rst
similarity index 100%
rename from document/syntax/conventions.rst
rename to document/core/syntax/conventions.rst
diff --git a/document/syntax/index.rst b/document/core/syntax/index.rst
similarity index 100%
rename from document/syntax/index.rst
rename to document/core/syntax/index.rst
diff --git a/document/syntax/instrindex.rst b/document/core/syntax/instrindex.rst
similarity index 100%
rename from document/syntax/instrindex.rst
rename to document/core/syntax/instrindex.rst
diff --git a/document/syntax/instructions.rst b/document/core/syntax/instructions.rst
similarity index 100%
rename from document/syntax/instructions.rst
rename to document/core/syntax/instructions.rst
diff --git a/document/syntax/modules.rst b/document/core/syntax/modules.rst
similarity index 100%
rename from document/syntax/modules.rst
rename to document/core/syntax/modules.rst
diff --git a/document/syntax/types.rst b/document/core/syntax/types.rst
similarity index 100%
rename from document/syntax/types.rst
rename to document/core/syntax/types.rst
diff --git a/document/syntax/values.rst b/document/core/syntax/values.rst
similarity index 100%
rename from document/syntax/values.rst
rename to document/core/syntax/values.rst
diff --git a/document/text/conventions.rst b/document/core/text/conventions.rst
similarity index 100%
rename from document/text/conventions.rst
rename to document/core/text/conventions.rst
diff --git a/document/text/index.rst b/document/core/text/index.rst
similarity index 100%
rename from document/text/index.rst
rename to document/core/text/index.rst
diff --git a/document/text/instructions.rst b/document/core/text/instructions.rst
similarity index 100%
rename from document/text/instructions.rst
rename to document/core/text/instructions.rst
diff --git a/document/text/lexical.rst b/document/core/text/lexical.rst
similarity index 100%
rename from document/text/lexical.rst
rename to document/core/text/lexical.rst
diff --git a/document/text/modules.rst b/document/core/text/modules.rst
similarity index 100%
rename from document/text/modules.rst
rename to document/core/text/modules.rst
diff --git a/document/text/types.rst b/document/core/text/types.rst
similarity index 100%
rename from document/text/types.rst
rename to document/core/text/types.rst
diff --git a/document/text/values.rst b/document/core/text/values.rst
similarity index 100%
rename from document/text/values.rst
rename to document/core/text/values.rst
diff --git a/document/deploy.sh b/document/core/util/deploy.sh
similarity index 100%
rename from document/deploy.sh
rename to document/core/util/deploy.sh
diff --git a/document/math.def b/document/core/util/math.def
similarity index 77%
rename from document/math.def
rename to document/core/util/math.def
index 334ec6473..231e50404 100644
--- a/document/math.def
+++ b/document/core/util/math.def
@@ -196,8 +196,8 @@
 
 .. Types, terminals
 
-.. |I8| mathdef:: \xref{execution/runtime}{syntax-storagetype}{\K{i8}}
-.. |I16| mathdef:: \xref{execution/runtime}{syntax-storagetype}{\K{i16}}
+.. |I8| mathdef:: \xref{exec/runtime}{syntax-storagetype}{\K{i8}}
+.. |I16| mathdef:: \xref{exec/runtime}{syntax-storagetype}{\K{i16}}
 .. |I32| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i32}}
 .. |I64| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i64}}
 .. |F32| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f32}}
@@ -483,15 +483,15 @@
 .. |DEMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{demote}}
 .. |REINTERPRET| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{reinterpret}}
 
-.. |TRAP| mathdef:: \xref{execution/runtime}{syntax-instr-admin}{\K{trap}}
-.. |LABEL| mathdef:: \xref{execution/runtime}{syntax-instr-admin}{\K{label}}
-.. |FRAME| mathdef:: \xref{execution/runtime}{syntax-instr-admin}{\K{frame}}
+.. |TRAP| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{trap}}
+.. |LABEL| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{label}}
+.. |FRAME| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{frame}}
 
-.. |INVOKE| mathdef:: \xref{execution/runtime}{syntax-invoke}{\K{invoke}}
-.. |INSTANTIATE| mathdef:: \xref{execution/runtime}{syntax-instantiate}{\K{instantiate}}
-.. |INITGLOBAL| mathdef:: \xref{execution/runtime}{syntax-init_global}{\K{init\_global}}
-.. |INITTABLE| mathdef:: \xref{execution/runtime}{syntax-init_table}{\K{init\_table}}
-.. |INITMEM| mathdef:: \xref{execution/runtime}{syntax-init_mem}{\K{init\_mem}}
+.. |INVOKE| mathdef:: \xref{exec/runtime}{syntax-invoke}{\K{invoke}}
+.. |INSTANTIATE| mathdef:: \xref{exec/runtime}{syntax-instantiate}{\K{instantiate}}
+.. |INITGLOBAL| mathdef:: \xref{exec/runtime}{syntax-init_global}{\K{init\_global}}
+.. |INITTABLE| mathdef:: \xref{exec/runtime}{syntax-init_table}{\K{init\_table}}
+.. |INITMEM| mathdef:: \xref{exec/runtime}{syntax-init_mem}{\K{init\_mem}}
 
 
 .. Instructions, non-terminals
@@ -560,34 +560,34 @@
 
 .. Runtime, non-terminals
 
-.. |val| mathdef:: \xref{execution/runtime}{syntax-val}{\X{val}}
+.. |val| mathdef:: \xref{exec/runtime}{syntax-val}{\X{val}}
 
-.. |addr| mathdef:: \xref{execution/runtime}{syntax-addr}{\X{addr}}
-.. |funcaddr| mathdef:: \xref{execution/runtime}{syntax-funcaddr}{\X{funcaddr}}
-.. |tableaddr| mathdef:: \xref{execution/runtime}{syntax-tableaddr}{\X{tableaddr}}
-.. |memaddr| mathdef:: \xref{execution/runtime}{syntax-memaddr}{\X{memaddr}}
-.. |globaladdr| mathdef:: \xref{execution/runtime}{syntax-globaladdr}{\X{globaladdr}}
+.. |addr| mathdef:: \xref{exec/runtime}{syntax-addr}{\X{addr}}
+.. |funcaddr| mathdef:: \xref{exec/runtime}{syntax-funcaddr}{\X{funcaddr}}
+.. |tableaddr| mathdef:: \xref{exec/runtime}{syntax-tableaddr}{\X{tableaddr}}
+.. |memaddr| mathdef:: \xref{exec/runtime}{syntax-memaddr}{\X{memaddr}}
+.. |globaladdr| mathdef:: \xref{exec/runtime}{syntax-globaladdr}{\X{globaladdr}}
 
-.. |moduleinst| mathdef:: \xref{execution/runtime}{syntax-moduleinst}{\X{moduleinst}}
-.. |funcinst| mathdef:: \xref{execution/runtime}{syntax-funcinst}{\X{funcinst}}
-.. |tableinst| mathdef:: \xref{execution/runtime}{syntax-tableinst}{\X{tableinst}}
-.. |funcelem| mathdef:: \xref{execution/runtime}{syntax-funcelem}{\X{funcelem}}
-.. |meminst| mathdef:: \xref{execution/runtime}{syntax-meminst}{\X{meminst}}
-.. |globalinst| mathdef:: \xref{execution/runtime}{syntax-globalinst}{\X{globalinst}}
-.. |exportinst| mathdef:: \xref{execution/runtime}{syntax-exportinst}{\X{exportinst}}
-.. |hostfunc| mathdef:: \xref{execution/runtime}{syntax-hostfunc}{\X{hostfunc}}
+.. |moduleinst| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\X{moduleinst}}
+.. |funcinst| mathdef:: \xref{exec/runtime}{syntax-funcinst}{\X{funcinst}}
+.. |tableinst| mathdef:: \xref{exec/runtime}{syntax-tableinst}{\X{tableinst}}
+.. |funcelem| mathdef:: \xref{exec/runtime}{syntax-funcelem}{\X{funcelem}}
+.. |meminst| mathdef:: \xref{exec/runtime}{syntax-meminst}{\X{meminst}}
+.. |globalinst| mathdef:: \xref{exec/runtime}{syntax-globalinst}{\X{globalinst}}
+.. |exportinst| mathdef:: \xref{exec/runtime}{syntax-exportinst}{\X{exportinst}}
+.. |hostfunc| mathdef:: \xref{exec/runtime}{syntax-hostfunc}{\X{hostfunc}}
 
-.. |externval| mathdef:: \xref{execution/runtime}{syntax-externval}{\X{externval}}
+.. |externval| mathdef:: \xref{exec/runtime}{syntax-externval}{\X{externval}}
 .. |externtype| mathdef:: \xref{syntax/types}{syntax-externtype}{\X{externtype}}
-.. |storagetype| mathdef:: \xref{execution/runtime}{syntax-storagetype}{\X{storagetype}}
+.. |storagetype| mathdef:: \xref{exec/runtime}{syntax-storagetype}{\X{storagetype}}
 
-.. |store| mathdef:: \xref{execution/runtime}{syntax-store}{\X{store}}
-.. |frame| mathdef:: \xref{execution/runtime}{syntax-frame}{\X{frame}}
-.. |label| mathdef:: \xref{execution/runtime}{syntax-label}{\X{label}}
+.. |store| mathdef:: \xref{exec/runtime}{syntax-store}{\X{store}}
+.. |frame| mathdef:: \xref{exec/runtime}{syntax-frame}{\X{frame}}
+.. |label| mathdef:: \xref{exec/runtime}{syntax-label}{\X{label}}
 
-.. |XB| mathdef:: \xref{execution/runtime}{syntax-ctxt-block}{B}
+.. |XB| mathdef:: \xref{exec/runtime}{syntax-ctxt-block}{B}
 
-.. |moduleinstr| mathdef:: \xref{execution/runtime}{syntax-moduleinstr}{\X{moduleinstr}}
+.. |moduleinstr| mathdef:: \xref{exec/runtime}{syntax-moduleinstr}{\X{moduleinstr}}
 
 
 .. Execution, notation
@@ -595,28 +595,28 @@
 .. |stepto| mathdef:: \hookrightarrow
 .. |mod| mathdef:: \mathbin{\F{mod}}
 
-.. |allocfunc| mathdef:: \xref{execution/modules}{alloc-func}{\F{allocfunc}}
-.. |allochostfunc| mathdef:: \xref{execution/modules}{alloc-hostfunc}{\F{allochostfunc}}
-.. |alloctable| mathdef:: \xref{execution/modules}{alloc-table}{\F{alloctable}}
-.. |allocmem| mathdef:: \xref{execution/modules}{alloc-mem}{\F{allocmem}}
-.. |allocglobal| mathdef:: \xref{execution/modules}{alloc-global}{\F{allocglobal}}
-.. |allocmodule| mathdef:: \xref{execution/modules}{alloc-module}{\F{allocmodule}}
+.. |allocfunc| mathdef:: \xref{exec/modules}{alloc-func}{\F{allocfunc}}
+.. |allochostfunc| mathdef:: \xref{exec/modules}{alloc-hostfunc}{\F{allochostfunc}}
+.. |alloctable| mathdef:: \xref{exec/modules}{alloc-table}{\F{alloctable}}
+.. |allocmem| mathdef:: \xref{exec/modules}{alloc-mem}{\F{allocmem}}
+.. |allocglobal| mathdef:: \xref{exec/modules}{alloc-global}{\F{allocglobal}}
+.. |allocmodule| mathdef:: \xref{exec/modules}{alloc-module}{\F{allocmodule}}
 
 
 .. Numerics, meta functions
 
-.. |bits| mathdef:: \xref{execution/numerics}{aux-bits}{\F{bits}}
-.. |ibits| mathdef:: \xref{execution/numerics}{aux-ibits}{\F{ibits}}
-.. |fbits| mathdef:: \xref{execution/numerics}{aux-fbits}{\F{fbits}}
-.. |fsign| mathdef:: \xref{execution/numerics}{aux-fsign}{\F{fsign}}
-.. |fbias| mathdef:: \xref{execution/numerics}{aux-fbias}{\F{fbias}}
-.. |bytes| mathdef:: \xref{execution/numerics}{aux-bytes}{\F{bytes}}
-.. |littleendian| mathdef:: \xref{execution/numerics}{aux-littleendian}{\F{littleendian}}
-.. |signed| mathdef:: \xref{execution/numerics}{aux-signed}{\F{signed}}
-.. |bool| mathdef:: \xref{execution/numerics}{aux-bool}{\F{bool}}
-
-.. |ieee| mathdef:: \xref{execution/numerics}{aux-ieee}{\F{float}}
-.. |nans| mathdef:: \xref{execution/numerics}{aux-nans}{\F{nans}}
+.. |bits| mathdef:: \xref{exec/numerics}{aux-bits}{\F{bits}}
+.. |ibits| mathdef:: \xref{exec/numerics}{aux-ibits}{\F{ibits}}
+.. |fbits| mathdef:: \xref{exec/numerics}{aux-fbits}{\F{fbits}}
+.. |fsign| mathdef:: \xref{exec/numerics}{aux-fsign}{\F{fsign}}
+.. |fbias| mathdef:: \xref{exec/numerics}{aux-fbias}{\F{fbias}}
+.. |bytes| mathdef:: \xref{exec/numerics}{aux-bytes}{\F{bytes}}
+.. |littleendian| mathdef:: \xref{exec/numerics}{aux-littleendian}{\F{littleendian}}
+.. |signed| mathdef:: \xref{exec/numerics}{aux-signed}{\F{signed}}
+.. |bool| mathdef:: \xref{exec/numerics}{aux-bool}{\F{bool}}
+
+.. |ieee| mathdef:: \xref{exec/numerics}{aux-ieee}{\F{float}}
+.. |nans| mathdef:: \xref{exec/numerics}{aux-nans}{\F{nans}}
 .. |canon| mathdef:: \xref{syntax/values}{aux-canon}{\F{canon}}
 
 .. |significand| mathdef:: \xref{syntax/values}{aux-significand}{\F{signif}}
@@ -625,67 +625,67 @@
 
 .. Numerics, operators
 
-.. |iadd| mathdef:: \xref{execution/numerics}{op-iadd}{\F{iadd}}
-.. |isub| mathdef:: \xref{execution/numerics}{op-isub}{\F{isub}}
-.. |imul| mathdef:: \xref{execution/numerics}{op-imul}{\F{imul}}
-.. |idivu| mathdef:: \xref{execution/numerics}{op-idiv_u}{\F{idiv\_u}}
-.. |idivs| mathdef:: \xref{execution/numerics}{op-idiv_s}{\F{idiv\_s}}
-.. |iremu| mathdef:: \xref{execution/numerics}{op-irem_u}{\F{irem\_u}}
-.. |irems| mathdef:: \xref{execution/numerics}{op-irem_s}{\F{irem\_s}}
-.. |iand| mathdef:: \xref{execution/numerics}{op-iand}{\F{iand}}
-.. |ior| mathdef:: \xref{execution/numerics}{op-ior}{\F{ior}}
-.. |ixor| mathdef:: \xref{execution/numerics}{op-ixor}{\F{ixor}}
-.. |ishl| mathdef:: \xref{execution/numerics}{op-ishl}{\F{ishl}}
-.. |ishru| mathdef:: \xref{execution/numerics}{op-ishr_u}{\F{ishr\_u}}
-.. |ishrs| mathdef:: \xref{execution/numerics}{op-ishr_s}{\F{ishr\_s}}
-.. |irotl| mathdef:: \xref{execution/numerics}{op-irotl}{\F{irotl}}
-.. |irotr| mathdef:: \xref{execution/numerics}{op-irotr}{\F{irotr}}
-.. |iclz| mathdef:: \xref{execution/numerics}{op-iclz}{\F{iclz}}
-.. |ictz| mathdef:: \xref{execution/numerics}{op-ictz}{\F{ictz}}
-.. |ipopcnt| mathdef:: \xref{execution/numerics}{op-ipopcnt}{\F{ipopcnt}}
-.. |ieqz| mathdef:: \xref{execution/numerics}{op-ieqz}{\F{ieqz}}
-.. |ieq| mathdef:: \xref{execution/numerics}{op-ieq}{\F{ieq}}
-.. |ine| mathdef:: \xref{execution/numerics}{op-ine}{\F{ine}}
-.. |iltu| mathdef:: \xref{execution/numerics}{op-ilt_u}{\F{ilt\_u}}
-.. |ilts| mathdef:: \xref{execution/numerics}{op-ilt_s}{\F{ilt\_s}}
-.. |igtu| mathdef:: \xref{execution/numerics}{op-igt_u}{\F{igt\_u}}
-.. |igts| mathdef:: \xref{execution/numerics}{op-igt_s}{\F{igt\_s}}
-.. |ileu| mathdef:: \xref{execution/numerics}{op-ile_u}{\F{ile\_u}}
-.. |iles| mathdef:: \xref{execution/numerics}{op-ile_s}{\F{ile\_s}}
-.. |igeu| mathdef:: \xref{execution/numerics}{op-ige_u}{\F{ige\_u}}
-.. |iges| mathdef:: \xref{execution/numerics}{op-ige_s}{\F{ige\_s}}
-
-.. |fadd| mathdef:: \xref{execution/numerics}{op-fadd}{\F{fadd}}
-.. |fsub| mathdef:: \xref{execution/numerics}{op-fsub}{\F{fsub}}
-.. |fmul| mathdef:: \xref{execution/numerics}{op-fmul}{\F{fmul}}
-.. |fdiv| mathdef:: \xref{execution/numerics}{op-fdiv}{\F{fdiv}}
-.. |fmin| mathdef:: \xref{execution/numerics}{op-fmin}{\F{fmin}}
-.. |fmax| mathdef:: \xref{execution/numerics}{op-fmax}{\F{fmax}}
-.. |fcopysign| mathdef:: \xref{execution/numerics}{op-fcopysign}{\F{fcopysign}}
-.. |fabs| mathdef:: \xref{execution/numerics}{op-fabs}{\F{fabs}}
-.. |fneg| mathdef:: \xref{execution/numerics}{op-fneg}{\F{fneg}}
-.. |fsqrt| mathdef:: \xref{execution/numerics}{op-fsqrt}{\F{fsqrt}}
-.. |fceil| mathdef:: \xref{execution/numerics}{op-fceil}{\F{fceil}}
-.. |ffloor| mathdef:: \xref{execution/numerics}{op-ffloor}{\F{ffloor}}
-.. |ftrunc| mathdef:: \xref{execution/numerics}{op-ftrunc}{\F{ftrunc}}
-.. |fnearest| mathdef:: \xref{execution/numerics}{op-fnearest}{\F{fnearest}}
-.. |feq| mathdef:: \xref{execution/numerics}{op-feq}{\F{feq}}
-.. |fne| mathdef:: \xref{execution/numerics}{op-fne}{\F{fne}}
-.. |flt| mathdef:: \xref{execution/numerics}{op-flt}{\F{flt}}
-.. |fgt| mathdef:: \xref{execution/numerics}{op-fgt}{\F{fgt}}
-.. |fle| mathdef:: \xref{execution/numerics}{op-fle}{\F{fle}}
-.. |fge| mathdef:: \xref{execution/numerics}{op-fge}{\F{fge}}
-
-.. |extend| mathdef:: \xref{execution/numerics}{op-extend_u}{\F{extend}}
-.. |extendu| mathdef:: \xref{execution/numerics}{op-extend_u}{\F{extend\_u}}
-.. |extends| mathdef:: \xref{execution/numerics}{op-extend_s}{\F{extend\_s}}
-.. |wrap| mathdef:: \xref{execution/numerics}{op-wrap}{\F{wrap}}
-.. |truncu| mathdef:: \xref{execution/numerics}{op-trunc_u}{\F{trunc\_u}}
-.. |truncs| mathdef:: \xref{execution/numerics}{op-trunc_s}{\F{trunc\_s}}
-.. |promote| mathdef:: \xref{execution/numerics}{op-promote}{\F{promote}}
-.. |demote| mathdef:: \xref{execution/numerics}{op-demote}{\F{demote}}
-.. |convertu| mathdef:: \xref{execution/numerics}{op-convert_u}{\F{convert\_u}}
-.. |converts| mathdef:: \xref{execution/numerics}{op-convert_s}{\F{convert\_s}}
-.. |reinterpret| mathdef:: \xref{execution/numerics}{op-reinterpret}{\F{reinterpret}}
-
-.. |trunc| mathdef:: \xref{execution/numerics}{aux-trunc}{\F{trunc}}
+.. |iadd| mathdef:: \xref{exec/numerics}{op-iadd}{\F{iadd}}
+.. |isub| mathdef:: \xref{exec/numerics}{op-isub}{\F{isub}}
+.. |imul| mathdef:: \xref{exec/numerics}{op-imul}{\F{imul}}
+.. |idivu| mathdef:: \xref{exec/numerics}{op-idiv_u}{\F{idiv\_u}}
+.. |idivs| mathdef:: \xref{exec/numerics}{op-idiv_s}{\F{idiv\_s}}
+.. |iremu| mathdef:: \xref{exec/numerics}{op-irem_u}{\F{irem\_u}}
+.. |irems| mathdef:: \xref{exec/numerics}{op-irem_s}{\F{irem\_s}}
+.. |iand| mathdef:: \xref{exec/numerics}{op-iand}{\F{iand}}
+.. |ior| mathdef:: \xref{exec/numerics}{op-ior}{\F{ior}}
+.. |ixor| mathdef:: \xref{exec/numerics}{op-ixor}{\F{ixor}}
+.. |ishl| mathdef:: \xref{exec/numerics}{op-ishl}{\F{ishl}}
+.. |ishru| mathdef:: \xref{exec/numerics}{op-ishr_u}{\F{ishr\_u}}
+.. |ishrs| mathdef:: \xref{exec/numerics}{op-ishr_s}{\F{ishr\_s}}
+.. |irotl| mathdef:: \xref{exec/numerics}{op-irotl}{\F{irotl}}
+.. |irotr| mathdef:: \xref{exec/numerics}{op-irotr}{\F{irotr}}
+.. |iclz| mathdef:: \xref{exec/numerics}{op-iclz}{\F{iclz}}
+.. |ictz| mathdef:: \xref{exec/numerics}{op-ictz}{\F{ictz}}
+.. |ipopcnt| mathdef:: \xref{exec/numerics}{op-ipopcnt}{\F{ipopcnt}}
+.. |ieqz| mathdef:: \xref{exec/numerics}{op-ieqz}{\F{ieqz}}
+.. |ieq| mathdef:: \xref{exec/numerics}{op-ieq}{\F{ieq}}
+.. |ine| mathdef:: \xref{exec/numerics}{op-ine}{\F{ine}}
+.. |iltu| mathdef:: \xref{exec/numerics}{op-ilt_u}{\F{ilt\_u}}
+.. |ilts| mathdef:: \xref{exec/numerics}{op-ilt_s}{\F{ilt\_s}}
+.. |igtu| mathdef:: \xref{exec/numerics}{op-igt_u}{\F{igt\_u}}
+.. |igts| mathdef:: \xref{exec/numerics}{op-igt_s}{\F{igt\_s}}
+.. |ileu| mathdef:: \xref{exec/numerics}{op-ile_u}{\F{ile\_u}}
+.. |iles| mathdef:: \xref{exec/numerics}{op-ile_s}{\F{ile\_s}}
+.. |igeu| mathdef:: \xref{exec/numerics}{op-ige_u}{\F{ige\_u}}
+.. |iges| mathdef:: \xref{exec/numerics}{op-ige_s}{\F{ige\_s}}
+
+.. |fadd| mathdef:: \xref{exec/numerics}{op-fadd}{\F{fadd}}
+.. |fsub| mathdef:: \xref{exec/numerics}{op-fsub}{\F{fsub}}
+.. |fmul| mathdef:: \xref{exec/numerics}{op-fmul}{\F{fmul}}
+.. |fdiv| mathdef:: \xref{exec/numerics}{op-fdiv}{\F{fdiv}}
+.. |fmin| mathdef:: \xref{exec/numerics}{op-fmin}{\F{fmin}}
+.. |fmax| mathdef:: \xref{exec/numerics}{op-fmax}{\F{fmax}}
+.. |fcopysign| mathdef:: \xref{exec/numerics}{op-fcopysign}{\F{fcopysign}}
+.. |fabs| mathdef:: \xref{exec/numerics}{op-fabs}{\F{fabs}}
+.. |fneg| mathdef:: \xref{exec/numerics}{op-fneg}{\F{fneg}}
+.. |fsqrt| mathdef:: \xref{exec/numerics}{op-fsqrt}{\F{fsqrt}}
+.. |fceil| mathdef:: \xref{exec/numerics}{op-fceil}{\F{fceil}}
+.. |ffloor| mathdef:: \xref{exec/numerics}{op-ffloor}{\F{ffloor}}
+.. |ftrunc| mathdef:: \xref{exec/numerics}{op-ftrunc}{\F{ftrunc}}
+.. |fnearest| mathdef:: \xref{exec/numerics}{op-fnearest}{\F{fnearest}}
+.. |feq| mathdef:: \xref{exec/numerics}{op-feq}{\F{feq}}
+.. |fne| mathdef:: \xref{exec/numerics}{op-fne}{\F{fne}}
+.. |flt| mathdef:: \xref{exec/numerics}{op-flt}{\F{flt}}
+.. |fgt| mathdef:: \xref{exec/numerics}{op-fgt}{\F{fgt}}
+.. |fle| mathdef:: \xref{exec/numerics}{op-fle}{\F{fle}}
+.. |fge| mathdef:: \xref{exec/numerics}{op-fge}{\F{fge}}
+
+.. |extend| mathdef:: \xref{exec/numerics}{op-extend_u}{\F{extend}}
+.. |extendu| mathdef:: \xref{exec/numerics}{op-extend_u}{\F{extend\_u}}
+.. |extends| mathdef:: \xref{exec/numerics}{op-extend_s}{\F{extend\_s}}
+.. |wrap| mathdef:: \xref{exec/numerics}{op-wrap}{\F{wrap}}
+.. |truncu| mathdef:: \xref{exec/numerics}{op-trunc_u}{\F{trunc\_u}}
+.. |truncs| mathdef:: \xref{exec/numerics}{op-trunc_s}{\F{trunc\_s}}
+.. |promote| mathdef:: \xref{exec/numerics}{op-promote}{\F{promote}}
+.. |demote| mathdef:: \xref{exec/numerics}{op-demote}{\F{demote}}
+.. |convertu| mathdef:: \xref{exec/numerics}{op-convert_u}{\F{convert\_u}}
+.. |converts| mathdef:: \xref{exec/numerics}{op-convert_s}{\F{convert\_s}}
+.. |reinterpret| mathdef:: \xref{exec/numerics}{op-reinterpret}{\F{reinterpret}}
+
+.. |trunc| mathdef:: \xref{exec/numerics}{aux-trunc}{\F{trunc}}
diff --git a/document/mathdef.py b/document/core/util/mathdef.py
similarity index 100%
rename from document/mathdef.py
rename to document/core/util/mathdef.py
diff --git a/document/validation/conventions.rst b/document/core/valid/conventions.rst
similarity index 100%
rename from document/validation/conventions.rst
rename to document/core/valid/conventions.rst
diff --git a/document/validation/index.rst b/document/core/valid/index.rst
similarity index 100%
rename from document/validation/index.rst
rename to document/core/valid/index.rst
diff --git a/document/validation/instructions.rst b/document/core/valid/instructions.rst
similarity index 100%
rename from document/validation/instructions.rst
rename to document/core/valid/instructions.rst
diff --git a/document/validation/modules.rst b/document/core/valid/modules.rst
similarity index 100%
rename from document/validation/modules.rst
rename to document/core/valid/modules.rst

From 94aea9df37751e4fe7fde78db70595f12bf79010 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Fri, 30 Jun 2017 13:58:54 +0200
Subject: [PATCH 050/329] [spec] Clean up macros

---
 document/core/appendix/implementation.rst |   2 +-
 document/core/exec/conventions.rst        |   2 +-
 document/core/exec/instructions.rst       |   2 +-
 document/core/exec/modules.rst            |   7 +-
 document/core/exec/runtime.rst            |   4 +-
 document/core/intro/index.rst             |   2 +
 document/core/syntax/instructions.rst     |   1 -
 document/core/syntax/modules.rst          |   6 +-
 document/core/util/math.def               | 671 ++++++++++++----------
 document/core/valid/conventions.rst       |   2 +-
 10 files changed, 385 insertions(+), 314 deletions(-)

diff --git a/document/core/appendix/implementation.rst b/document/core/appendix/implementation.rst
index a3175b9c8..59378f818 100644
--- a/document/core/appendix/implementation.rst
+++ b/document/core/appendix/implementation.rst
@@ -55,7 +55,7 @@ An implementation may impose restrictions on the following dimensions of a modul
 * the range of :ref:`code points <syntax-codepoint>` in a :ref:`name <syntax-name>`
 
 If the limits of an implementation are exceeded for a given module,
-then the implementation may reject the :ref:`validation <valid>`, compilation, or :ref:`instantiation <instantiation>` of that module with an embedder-specific error.
+then the implementation may reject the :ref:`validation <valid>`, compilation, or :ref:`instantiation <exec-instantiation>` of that module with an embedder-specific error.
 
 .. note::
    The last item allows :ref:`embedders <embedder>` that operate in limited environments without support for
diff --git a/document/core/exec/conventions.rst b/document/core/exec/conventions.rst
index d7d381c41..12afc8004 100644
--- a/document/core/exec/conventions.rst
+++ b/document/core/exec/conventions.rst
@@ -3,7 +3,7 @@
 Conventions
 -----------
 
-WebAssembly code is *executed* when :ref:`instantiating <instantiation>` a module or :ref:`invoking <exec-call-export>` an :ref:`exported <syntax-export>` function on the resulting module :ref:`instance <syntax-moduleinst>`.
+WebAssembly code is *executed* when :ref:`instantiating <exec-instantiation>` a module or :ref:`invoking <exec-invocation>` an :ref:`exported <syntax-export>` function on the resulting module :ref:`instance <syntax-moduleinst>`.
 
 Execution behavior is defined in terms of an *abstract machine* that models the *program state*.
 It includes a *stack*, which records operand values and control constructs, and an abstract *store* containing global state.
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index dae3d8fed..eaad95faa 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1088,7 +1088,7 @@ and it must still be well-typed.
 .. todo:: Define more precisely?
 
 .. note::
-   A host function can call back into WebAssembly by :ref:`invoking <invocation>` a function :ref:`exported <syntax-export>` from a :ref:`module <syntax-module>`.
+   A host function can call back into WebAssembly by :ref:`invoking <exec-invocation>` a function :ref:`exported <syntax-export>` from a :ref:`module <syntax-module>`.
    However, the effects of any such call are subsumed by the non-deterministic behavior allowed for a host function.
 
 
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 0c9bb15da..b7cfc2969 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -431,7 +431,7 @@ Here, the notation :math:`\F{allocX}^\ast` is shorthand for multiple :ref:`alloc
 
 .. index:: ! instantiation, module, instance, store
 .. _exec-module:
-.. _instantiation:
+.. _exec-instantiation:
 
 Instantiation
 ~~~~~~~~~~~~~
@@ -608,13 +608,12 @@ Instantiation may *fail* with an error.
 
 
 .. index:: ! invocation, module, instance, function, export, function address
-.. _exec-call-export:
-.. _invocation:
+.. _exec-invocation:
 
 Invocation
 ~~~~~~~~~~
 
-Once a :ref:`module <syntax-module>` has been :ref:`instantiated <instantiation>`, any exported function can be *invoked* externally via its :ref:`function address <syntax-funcaddr>` :math:`\funcaddr` in the :ref:`store <syntax-store>` :math:`S` and an appropriate list :math:`\val^\ast` of argument :ref:`values <syntax-val>`.
+Once a :ref:`module <syntax-module>` has been :ref:`instantiated <exec-instantiation>`, any exported function can be *invoked* externally via its :ref:`function address <syntax-funcaddr>` :math:`\funcaddr` in the :ref:`store <syntax-store>` :math:`S` and an appropriate list :math:`\val^\ast` of argument :ref:`values <syntax-val>`.
 If successful, the invocation returns the function's result values :math:`\val_{\F{res}}^\ast`.
 
 The following steps are performed:
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 3d2c05e0a..7609fb3f1 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -123,7 +123,7 @@ Module Instances
 ~~~~~~~~~~~~~~~~
 
 A *module instance* is the runtime representation of a :ref:`module <syntax-module>`.
-It is created by :ref:`instantiating <instantiation>` a module,
+It is created by :ref:`instantiating <exec-instantiation>` a module,
 and collects runtime representations of all entities that are imported, defined, or exported by the module.
 
 .. math::
@@ -527,7 +527,7 @@ Finally, the following definition of *evaluation context* and associated structu
 Module Instructions
 ...................
 
-Module :ref:`instantiation <instantiation>` is a complex operation.
+Module :ref:`instantiation <exec-instantiation>` is a complex operation.
 It is hence expressed in terms of reduction into smaller steps expressed by a sequence of administrative *module instructions* that are a superset of ordinary instructions and defined as follow.
 
 .. math::
diff --git a/document/core/intro/index.rst b/document/core/intro/index.rst
index 68970fada..dbd9d03d3 100644
--- a/document/core/intro/index.rst
+++ b/document/core/intro/index.rst
@@ -1,3 +1,5 @@
+.. _intro:
+
 Introduction
 ============
 
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 843700dc0..e7266d8d3 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -279,7 +279,6 @@ Both instructions operate in units of :ref:`page size <page-size>`.
 .. _syntax-return:
 .. _syntax-call:
 .. _syntax-call_indirect:
-.. _syntax-label:
 .. _syntax-instr-seq:
 .. _syntax-instr-control:
 
diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index a8451a660..8ddd247bc 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -273,7 +273,7 @@ The |OFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <sy
 Start Function
 ~~~~~~~~~~~~~~
 
-The |START| component of a module optionally declares the :ref:`function index <syntax-funcidx>` of a *start function* that is automatically invoked when the module is :ref:`instantiated <instantiation>`, after tables and memories have been initialized.
+The |START| component of a module optionally declares the :ref:`function index <syntax-funcidx>` of a *start function* that is automatically invoked when the module is :ref:`instantiated <exec-instantiation>`, after tables and memories have been initialized.
 
 .. math::
    \begin{array}{llll}
@@ -294,7 +294,7 @@ The |START| component of a module optionally declares the :ref:`function index <
 Exports
 ~~~~~~~
 
-The |EXPORTS| component of a module defines a set of *exports* that become accessible to the host environment once the module has been :ref:`instantiated <instantiation>`.
+The |EXPORTS| component of a module defines a set of *exports* that become accessible to the host environment once the module has been :ref:`instantiated <exec-instantiation>`.
 
 .. math::
    \begin{array}{llll}
@@ -341,7 +341,7 @@ The following auxiliary notation is defined for sequences of exports, filtering
 Imports
 ~~~~~~~
 
-The |IMPORTS| component of a module defines a set of *imports* that are required for :ref:`instantiation <instantiation>`.
+The |IMPORTS| component of a module defines a set of *imports* that are required for :ref:`instantiation <exec-instantiation>`.
 
 .. math::
    \begin{array}{llll}
diff --git a/document/core/util/math.def b/document/core/util/math.def
index 231e50404..3ad7ab67e 100644
--- a/document/core/util/math.def
+++ b/document/core/util/math.def
@@ -1,4 +1,8 @@
-.. MATH
+.. MATH MACROS
+
+
+.. Generic Stuff
+.. -------------
 
 .. To comment out stuff
 
@@ -19,48 +23,35 @@
 .. |T| mathdef:: \mathtt
 
 
-.. Auxiliary definitions for grammars
-
-.. |production| mathdef:: \void
+.. Notation
 
-.. |concat| mathdef:: \xref{syntax/conventions}{syntax-concat}{\F{concat}}
-.. |with| mathdef:: \xref{syntax/conventions}{syntax-record}{\mathrel{\mbox{with}}}
-.. |compose| mathdef:: \xref{syntax/conventions}{syntax-record}{\oplus}
-.. |bigcompose| mathdef:: \xref{syntax/conventions}{syntax-record}{\bigoplus}
+.. |mod| mathdef:: \mathbin{\F{mod}}
 
+.. |iff| mathdef:: \mathop{\mbox{if}}
+.. |where| mathdef:: \mathrel{\mbox{where}}
 
-.. Lexical grammar, terminals
 
-.. |textl| mathdef:: \mbox{‘}
-.. |textr| mathdef:: \mbox{’}
-.. |text#1| mathdef:: \textl\mathtt{#1}\textr
 
-.. |Tcommentl| mathdef:: \text{{(}{;}}
-.. |Tcommentr| mathdef:: \text{{;}{)}}
-.. |Tcommentd| mathdef:: \text{{;}{;}}
+.. Grammar & Syntax Notation
+.. -------------------------
 
+.. Notation for grammars
 
-.. Lexical grammar, non-terminals
+.. |production| mathdef:: \void
 
-.. |Tchar| mathdef:: \xref{text/lexical}{text-char}{\T{char}}
-.. |Tspace| mathdef:: \xref{text/lexical}{text-space}{\T{space}}
-.. |Tformat| mathdef:: \xref{text/lexical}{text-format}{\T{format}}
 
-.. |Ttoken| mathdef:: \xref{text/lexical}{text-token}{\T{token}}
-.. |Tkeyword| mathdef:: \xref{text/lexical}{text-keyword}{\T{keyword}}
-.. |Treserved| mathdef:: \xref{text/lexical}{text-reserved}{\T{reserved}}
+.. Notation for Sequences & Records
 
-.. |Tcomment| mathdef:: \xref{text/lexical}{text-comment}{\T{comment}}
-.. |Tlinecomment| mathdef:: \xref{text/lexical}{text-comment}{\T{linecomment}}
-.. |Tblockcomment| mathdef:: \xref{text/lexical}{text-comment}{\T{blockcomment}}
-.. |Tlinechar| mathdef:: \xref{text/lexical}{text-comment}{\T{linechar}}
-.. |Tblockchar| mathdef:: \xref{text/lexical}{text-comment}{\T{blockchar}}
+.. |concat| mathdef:: \xref{syntax/conventions}{syntax-concat}{\F{concat}}
 
+.. |with| mathdef:: \xref{syntax/conventions}{syntax-record}{\mathrel{\mbox{with}}}
+.. |compose| mathdef:: \xref{syntax/conventions}{syntax-record}{\oplus}
+.. |bigcompose| mathdef:: \xref{syntax/conventions}{syntax-record}{\bigoplus}
 
-.. Lexical grammar, meta functions
 
-.. |utf8| mathdef:: \xref{syntax/values}{syntax-utf8}{\F{utf8}}
 
+.. Abstract Syntax
+.. ---------------
 
 .. Values, terminals
 
@@ -107,91 +98,13 @@
 .. |codepoint| mathdef:: \xref{syntax/values}{syntax-name}{\X{codepoint}}
 
 
-.. Values, binary non-terminals
-
-.. |Bbyte| mathdef:: \xref{binary/values}{binary-byte}{\B{byte}}
-
-.. |BuX#1| mathdef:: {\B{u}#1}
-.. |BsX#1| mathdef:: {\B{s}#1}
-.. |BiX#1| mathdef:: {\B{i}#1}
-.. |BfX#1| mathdef:: {\B{f}#1}
-
-.. |BuN| mathdef:: \xref{binary/values}{binary-int}{\BuX{N}}
-.. |Bu1| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{1}}}
-.. |Bu8| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{8}}}
-.. |Bu16| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{16}}}
-.. |Bu32| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{32}}}
-.. |Bu64| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{64}}}
-
-.. |BsN| mathdef:: \xref{binary/values}{binary-int}{\BsX{N}}
-.. |Bs32| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{32}}}
-.. |Bs64| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{64}}}
-
-.. |BiN| mathdef:: \xref{binary/values}{binary-int}{\BiX{N}}
-.. |Bi32| mathdef:: \xref{binary/values}{binary-int}{\BiX{\B{32}}}
-.. |Bi64| mathdef:: \xref{binary/values}{binary-int}{\BiX{\B{64}}}
-
-.. |BfN| mathdef:: \xref{binary/values}{binary-float}{\BfX{N}}
-.. |Bf32| mathdef:: \xref{binary/values}{binary-float}{\BfX{\B{32}}}
-.. |Bf64| mathdef:: \xref{binary/values}{binary-float}{\BfX{\B{64}}}
-
-.. |Bvec| mathdef:: \xref{binary/values}{binary-vec}{\B{vec}}
-.. |Bname| mathdef:: \xref{binary/values}{binary-name}{\B{name}}
-.. |Bcodepoint| mathdef:: \xref{binary/values}{binary-name}{\B{codepoint}}
-.. |Bcodeval| mathdef:: \xref{binary/values}{binary-name}{\B{codeval}}
-.. |Bcodecont| mathdef:: \xref{binary/values}{binary-name}{\B{cont}}
-
-
-.. Values, textual non-terminals
-
-.. |Tbyte| mathdef:: \xref{text/values}{text-byte}{\T{byte}}
-
-.. |Tsign| mathdef:: \xref{text/values}{text-sign}{\T{sign}}
-.. |Tdigit| mathdef:: \xref{text/values}{text-digit}{\T{digit}}
-.. |Thexdigit| mathdef:: \xref{text/values}{text-hexdigit}{\T{hexdigit}}
-.. |Tnum| mathdef:: \xref{text/values}{text-num}{\T{num}}
-.. |Thexnum| mathdef:: \xref{text/values}{text-hexnum}{\T{hexnum}}
-.. |Tfrac| mathdef:: \xref{text/values}{text-frac}{\T{frac}}
-.. |Thexfrac| mathdef:: \xref{text/values}{text-hexfrac}{\T{hexfrac}}
-.. |Tfloat| mathdef:: \xref{text/values}{text-float}{\T{float}}
-.. |Thexfloat| mathdef:: \xref{text/values}{text-hexfloat}{\T{hexfloat}}
-
-.. |TuX#1| mathdef:: {\T{u}#1}
-.. |TsX#1| mathdef:: {\T{s}#1}
-.. |TiX#1| mathdef:: {\T{i}#1}
-.. |TfX#1| mathdef:: {\T{f}#1}
-
-.. |TuN| mathdef:: \xref{text/values}{text-int}{\TuX{N}}
-.. |Tu1| mathdef:: \xref{text/values}{text-int}{\TuX{\T{1}}}
-.. |Tu8| mathdef:: \xref{text/values}{text-int}{\TuX{\T{8}}}
-.. |Tu16| mathdef:: \xref{text/values}{text-int}{\TuX{\T{16}}}
-.. |Tu32| mathdef:: \xref{text/values}{text-int}{\TuX{\T{32}}}
-.. |Tu64| mathdef:: \xref{text/values}{text-int}{\TuX{\T{64}}}
-
-.. |TsN| mathdef:: \xref{text/values}{text-int}{\TsX{N}}
-.. |Ts32| mathdef:: \xref{text/values}{text-int}{\TsX{\T{32}}}
-.. |Ts64| mathdef:: \xref{text/values}{text-int}{\TsX{\T{64}}}
-
-.. |TiN| mathdef:: \xref{text/values}{text-int}{\TiX{N}}
-.. |Ti32| mathdef:: \xref{text/values}{text-int}{\TiX{\T{32}}}
-.. |Ti64| mathdef:: \xref{text/values}{text-int}{\TiX{\T{64}}}
-
-.. |TfN| mathdef:: \xref{text/values}{text-float}{\TfX{N}}
-.. |TfNmag| mathdef:: \xref{text/values}{text-float}{\TfX{N}\T{mag}}
-.. |Tf32| mathdef:: \xref{text/values}{text-float}{\TfX{\T{32}}}
-.. |Tf64| mathdef:: \xref{text/values}{text-float}{\TfX{\T{64}}}
+.. Values, meta functions
 
-.. |Tvec| mathdef:: \xref{text/values}{text-vec}{\T{vec}}
-.. |Tstring| mathdef:: \xref{text/values}{text-string}{\T{string}}
-.. |Tstringelem| mathdef:: \xref{text/values}{text-string}{\T{stringelem}}
-.. |Tstringchar| mathdef:: \xref{text/values}{text-string}{\T{stringchar}}
-.. |Tname| mathdef:: \xref{text/values}{text-name}{\T{name}}
-.. |Tcodepoint| mathdef:: \xref{text/values}{text-name}{\T{codepoint}}
-.. |Tcodeval| mathdef:: \xref{text/values}{text-name}{\T{codeval}}
-.. |Tcodecont| mathdef:: \xref{text/values}{text-name}{\T{cont}}
+.. |canon| mathdef:: \xref{syntax/values}{aux-canon}{\F{canon}}
+.. |significand| mathdef:: \xref{syntax/values}{aux-significand}{\F{signif}}
+.. |exponent| mathdef:: \xref{syntax/values}{aux-exponent}{\F{expon}}
 
-.. |Tid| mathdef:: \xref{text/values}{text-id}{\T{id}}
-.. |Tidchar| mathdef:: \xref{text/values}{text-id}{\T{idchar}}
+.. |utf8| mathdef:: \xref{syntax/values}{syntax-utf8}{\F{utf8}}
 
 
 .. Types, terminals
@@ -223,38 +136,18 @@
 .. |limits| mathdef:: \xref{syntax/types}{syntax-limits}{\X{limits}}
 .. |mut| mathdef:: \xref{syntax/types}{syntax-mut}{\X{mut}}
 
-
-.. Types, binary non-terminals
-
-.. |Bvaltype| mathdef:: \xref{binary/types}{binary-valtype}{\B{valtype}}
-.. |Bresulttype| mathdef:: \xref{binary/types}{binary-resulttype}{\B{resulttype}}
-.. |Bblocktype| mathdef:: \xref{binary/types}{binary-blocktype}{\B{blocktype}}
-.. |Bfunctype| mathdef:: \xref{binary/types}{binary-functype}{\B{functype}}
-.. |Bglobaltype| mathdef:: \xref{binary/types}{binary-globaltype}{\B{globaltype}}
-.. |Btabletype| mathdef:: \xref{binary/types}{binary-tabletype}{\B{tabletype}}
-.. |Belemtype| mathdef:: \xref{binary/types}{binary-elemtype}{\B{elemtype}}
-.. |Bmemtype| mathdef:: \xref{binary/types}{binary-memtype}{\B{memtype}}
-.. |Blimits| mathdef:: \xref{binary/types}{binary-limits}{\B{limits}}
-.. |Bmut| mathdef:: \xref{binary/types}{binary-mut}{\B{mut}}
+.. |externtype| mathdef:: \xref{syntax/types}{syntax-externtype}{\X{externtype}}
 
 
-.. Types, textual non-terminals
+.. Types, meta functions
 
-.. |Tvaltype| mathdef:: \xref{text/types}{text-valtype}{\T{valtype}}
-.. |Tresulttype| mathdef:: \xref{text/types}{text-resulttype}{\T{resulttype}}
-.. |Tblocktype| mathdef:: \xref{text/types}{text-blocktype}{\T{blocktype}}
-.. |Tfunctype| mathdef:: \xref{text/types}{text-functype}{\T{functype}}
-.. |Tglobaltype| mathdef:: \xref{text/types}{text-globaltype}{\T{globaltype}}
-.. |Ttabletype| mathdef:: \xref{text/types}{text-tabletype}{\T{tabletype}}
-.. |Telemtype| mathdef:: \xref{text/types}{text-elemtype}{\T{elemtype}}
-.. |Tmemtype| mathdef:: \xref{text/types}{text-memtype}{\T{memtype}}
-.. |Texterntype| mathdef:: \xref{text/types}{text-externtype}{\T{externtype}}
-.. |Tlimits| mathdef:: \xref{text/types}{text-limits}{\T{limits}}
-.. |Tparam| mathdef:: \xref{text/types}{text-functype}{\T{param}}
-.. |Tresult| mathdef:: \xref{text/types}{text-functype}{\T{result}}
+.. |funcs| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{funcs}}
+.. |tables| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{tables}}
+.. |mems| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{mems}}
+.. |globals| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{globals}}
 
 
-.. Indices
+.. Indices, non-terminals
 
 .. |typeidx| mathdef:: \xref{syntax/modules}{syntax-typeidx}{\X{typeidx}}
 .. |funcidx| mathdef:: \xref{syntax/modules}{syntax-funcidx}{\X{funcidx}}
@@ -264,44 +157,9 @@
 .. |localidx| mathdef:: \xref{syntax/modules}{syntax-localidx}{\X{localidx}}
 .. |labelidx| mathdef:: \xref{syntax/modules}{syntax-labelidx}{\X{labelidx}}
 
-.. |Btypeidx| mathdef:: \xref{binary/modules}{binary-typeidx}{\B{typeidx}}
-.. |Bfuncidx| mathdef:: \xref{binary/modules}{binary-funcidx}{\B{funcidx}}
-.. |Btableidx| mathdef:: \xref{binary/modules}{binary-tableidx}{\B{tableidx}}
-.. |Bmemidx| mathdef:: \xref{binary/modules}{binary-memidx}{\B{memidx}}
-.. |Bglobalidx| mathdef:: \xref{binary/modules}{binary-globalidx}{\B{globalidx}}
-.. |Blocalidx| mathdef:: \xref{binary/modules}{binary-localidx}{\B{localidx}}
-.. |Blabelidx| mathdef:: \xref{binary/modules}{binary-labelidx}{\B{labelidx}}
-
-.. |Ttypeidx| mathdef:: \xref{text/modules}{text-typeidx}{\T{typeidx}}
-.. |Tfuncidx| mathdef:: \xref{text/modules}{text-funcidx}{\T{funcidx}}
-.. |Ttableidx| mathdef:: \xref{text/modules}{text-tableidx}{\T{tableidx}}
-.. |Tmemidx| mathdef:: \xref{text/modules}{text-memidx}{\T{memidx}}
-.. |Tglobalidx| mathdef:: \xref{text/modules}{text-globalidx}{\T{globalidx}}
-.. |Tlocalidx| mathdef:: \xref{text/modules}{text-localidx}{\T{localidx}}
-.. |Tlabelidx| mathdef:: \xref{text/modules}{text-labelidx}{\T{labelidx}}
-
-.. |Ttypebind| mathdef:: \xref{text/modules}{text-typebind}{\T{typebind}}
-.. |Tfuncbind| mathdef:: \xref{text/modules}{text-funcbind}{\T{funcbind}}
-.. |Ttablebind| mathdef:: \xref{text/modules}{text-tablebind}{\T{tablebind}}
-.. |Tmembind| mathdef:: \xref{text/modules}{text-membind}{\T{membind}}
-.. |Tglobalbind| mathdef:: \xref{text/modules}{text-globalbind}{\T{globalbind}}
-.. |Tlocalbind| mathdef:: \xref{text/modules}{text-localbind}{\T{localbind}}
-.. |Tlabelbind| mathdef:: \xref{text/modules}{text-labelbind}{\T{labelbind}}
-
 
 .. Modules, terminals
 
-.. |TYPES| mathdef:: \K{types}
-.. |FUNCS| mathdef:: \K{funcs}
-.. |TABLES| mathdef:: \K{tables}
-.. |MEMS| mathdef:: \K{mems}
-.. |GLOBALS| mathdef:: \K{globals}
-.. |LOCALS| mathdef:: \K{locals}
-.. |LABELS| mathdef:: \K{labels}
-.. |LRETURN| mathdef:: \K{return}
-.. |IMPORTS| mathdef:: \K{imports}
-.. |EXPORTS| mathdef:: \K{exports}
-
 .. |MODULE| mathdef:: \K{module}
 .. |TYPE| mathdef:: \K{type}
 .. |FUNC| mathdef:: \K{func}
@@ -316,13 +174,6 @@
 .. |START| mathdef:: \K{start}
 .. |CUSTOM| mathdef:: \K{custom}
 
-.. |INDEX| mathdef:: \K{index}
-.. |VALUE| mathdef:: \K{value}
-.. |INIT| mathdef:: \K{init}
-.. |BODY| mathdef:: \K{body}
-.. |NAME| mathdef:: \K{name}
-.. |DESC| mathdef:: \K{desc}
-
 
 .. Modules, non-terminals
 
@@ -341,74 +192,6 @@
 .. |start| mathdef:: \xref{syntax/modules}{syntax-start}{\X{start}}
 
 
-.. Modules, binary non-terminals
-
-.. |Bmagic| mathdef:: \xref{binary/modules}{binary-magic}{\B{magic}}
-.. |Bversion| mathdef:: \xref{binary/modules}{binary-version}{\B{version}}
-.. |Bmodule| mathdef:: \xref{binary/modules}{binary-module}{\B{module}}
-.. |Bsection| mathdef:: \xref{binary/modules}{binary-module}{\B{section}}
-.. |Bcustomsec| mathdef:: \xref{binary/modules}{binary-customsec}{\B{customsec}}
-.. |Btypesec| mathdef:: \xref{binary/modules}{binary-typesec}{\B{typesec}}
-.. |Bfuncsec| mathdef:: \xref{binary/modules}{binary-funcsec}{\B{funcsec}}
-.. |Bcodesec| mathdef:: \xref{binary/modules}{binary-codesec}{\B{codesec}}
-.. |Btablesec| mathdef:: \xref{binary/modules}{binary-tablesec}{\B{tablesec}}
-.. |Bmemsec| mathdef:: \xref{binary/modules}{binary-memsec}{\B{memsec}}
-.. |Bglobalsec| mathdef:: \xref{binary/modules}{binary-globalsec}{\B{globalsec}}
-.. |Bimportsec| mathdef:: \xref{binary/modules}{binary-importsec}{\B{importsec}}
-.. |Bexportsec| mathdef:: \xref{binary/modules}{binary-exportsec}{\B{exportsec}}
-.. |Belemsec| mathdef:: \xref{binary/modules}{binary-elemsec}{\B{elemsec}}
-.. |Bdatasec| mathdef:: \xref{binary/modules}{binary-datasec}{\B{datasec}}
-.. |Bstartsec| mathdef:: \xref{binary/modules}{binary-startsec}{\B{startsec}}
-.. |Bcustom| mathdef:: \xref{binary/modules}{binary-customsec}{\B{custom}}
-.. |Btype| mathdef:: \xref{binary/modules}{binary-typedef}{\B{type}}
-.. |Bfunc| mathdef:: \xref{binary/modules}{binary-func}{\B{func}}
-.. |Btable| mathdef:: \xref{binary/modules}{binary-table}{\B{table}}
-.. |Bmem| mathdef:: \xref{binary/modules}{binary-mem}{\B{mem}}
-.. |Bglobal| mathdef:: \xref{binary/modules}{binary-global}{\B{global}}
-.. |Bimport| mathdef:: \xref{binary/modules}{binary-import}{\B{import}}
-.. |Bexport| mathdef:: \xref{binary/modules}{binary-export}{\B{export}}
-.. |Bimportdesc| mathdef:: \xref{binary/modules}{binary-importdesc}{\B{importdesc}}
-.. |Bexportdesc| mathdef:: \xref{binary/modules}{binary-exportdesc}{\B{exportdesc}}
-.. |Belem| mathdef:: \xref{binary/modules}{binary-elem}{\B{elem}}
-.. |Bcode| mathdef:: \xref{binary/modules}{binary-code}{\B{code}}
-.. |Blocal| mathdef:: \xref{binary/modules}{binary-local}{\B{local}}
-.. |Blocals| mathdef:: \xref{binary/modules}{binary-local}{\B{locals}}
-.. |Bdata| mathdef:: \xref{binary/modules}{binary-data}{\B{data}}
-.. |Bstart| mathdef:: \xref{binary/modules}{binary-start}{\B{start}}
-
-
-.. Modules, textual non-terminals
-
-.. |Tmodule| mathdef:: \xref{text/modules}{text-module}{\T{module}}
-.. |Tmodulebody| mathdef:: \xref{text/modules}{text-modulebody}{\T{modulebody}}
-.. |Tmodulefield| mathdef:: \xref{text/modules}{text-modulefield}{\T{modulefield}}
-.. |Ttype| mathdef:: \xref{text/modules}{text-typedef}{\T{type}}
-.. |Ttypeuse| mathdef:: \xref{text/modules}{text-typeuse}{\T{typeuse}}
-.. |Tfunc| mathdef:: \xref{text/modules}{text-func}{\T{func}}
-.. |Ttable| mathdef:: \xref{text/modules}{text-table}{\T{table}}
-.. |Tmem| mathdef:: \xref{text/modules}{text-mem}{\T{mem}}
-.. |Tglobal| mathdef:: \xref{text/modules}{text-global}{\T{global}}
-.. |Timport| mathdef:: \xref{text/modules}{text-import}{\T{import}}
-.. |Texport| mathdef:: \xref{text/modules}{text-export}{\T{export}}
-.. |Timportdesc| mathdef:: \xref{text/modules}{text-importdesc}{\T{importdesc}}
-.. |Texportdesc| mathdef:: \xref{text/modules}{text-exportdesc}{\T{exportdesc}}
-.. |Telem| mathdef:: \xref{text/modules}{text-elem}{\T{elem}}
-.. |Tcode| mathdef:: \xref{text/modules}{text-code}{\T{code}}
-.. |Tlocal| mathdef:: \xref{text/modules}{text-local}{\T{local}}
-.. |Tlocals| mathdef:: \xref{text/modules}{text-local}{\T{locals}}
-.. |Tdata| mathdef:: \xref{text/modules}{text-data}{\T{data}}
-.. |Tdatastring| mathdef:: \xref{text/modules}{text-datastring}{\T{datastring}}
-.. |Tstart| mathdef:: \xref{text/modules}{text-start}{\T{start}}
-
-
-.. Modules, meta functions
-
-.. |funcs| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{funcs}}
-.. |tables| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{tables}}
-.. |mems| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{mems}}
-.. |globals| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{globals}}
-
-
 .. Instructions, terminals
 
 .. |OFFSET| mathdef:: \K{offset}
@@ -483,16 +266,6 @@
 .. |DEMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{demote}}
 .. |REINTERPRET| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{reinterpret}}
 
-.. |TRAP| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{trap}}
-.. |LABEL| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{label}}
-.. |FRAME| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{frame}}
-
-.. |INVOKE| mathdef:: \xref{exec/runtime}{syntax-invoke}{\K{invoke}}
-.. |INSTANTIATE| mathdef:: \xref{exec/runtime}{syntax-instantiate}{\K{instantiate}}
-.. |INITGLOBAL| mathdef:: \xref{exec/runtime}{syntax-init_global}{\K{init\_global}}
-.. |INITTABLE| mathdef:: \xref{exec/runtime}{syntax-init_table}{\K{init\_table}}
-.. |INITMEM| mathdef:: \xref{exec/runtime}{syntax-init_mem}{\K{init\_mem}}
-
 
 .. Instructions, non-terminals
 
@@ -519,7 +292,109 @@
 .. |expr| mathdef:: \xref{syntax/instructions}{syntax-expr}{\X{expr}}
 
 
-.. Instructions, binary non-terminals
+
+.. Binary Format
+.. -------------
+
+.. Values, non-terminals
+
+.. |Bbyte| mathdef:: \xref{binary/values}{binary-byte}{\B{byte}}
+
+.. |BuX#1| mathdef:: {\B{u}#1}
+.. |BsX#1| mathdef:: {\B{s}#1}
+.. |BiX#1| mathdef:: {\B{i}#1}
+.. |BfX#1| mathdef:: {\B{f}#1}
+
+.. |BuN| mathdef:: \xref{binary/values}{binary-int}{\BuX{N}}
+.. |Bu1| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{1}}}
+.. |Bu8| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{8}}}
+.. |Bu16| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{16}}}
+.. |Bu32| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{32}}}
+.. |Bu64| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{64}}}
+
+.. |BsN| mathdef:: \xref{binary/values}{binary-int}{\BsX{N}}
+.. |Bs32| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{32}}}
+.. |Bs64| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{64}}}
+
+.. |BiN| mathdef:: \xref{binary/values}{binary-int}{\BiX{N}}
+.. |Bi32| mathdef:: \xref{binary/values}{binary-int}{\BiX{\B{32}}}
+.. |Bi64| mathdef:: \xref{binary/values}{binary-int}{\BiX{\B{64}}}
+
+.. |BfN| mathdef:: \xref{binary/values}{binary-float}{\BfX{N}}
+.. |Bf32| mathdef:: \xref{binary/values}{binary-float}{\BfX{\B{32}}}
+.. |Bf64| mathdef:: \xref{binary/values}{binary-float}{\BfX{\B{64}}}
+
+.. |Bvec| mathdef:: \xref{binary/values}{binary-vec}{\B{vec}}
+.. |Bname| mathdef:: \xref{binary/values}{binary-name}{\B{name}}
+.. |Bcodepoint| mathdef:: \xref{binary/values}{binary-name}{\B{codepoint}}
+.. |Bcodeval| mathdef:: \xref{binary/values}{binary-name}{\B{codeval}}
+.. |Bcodecont| mathdef:: \xref{binary/values}{binary-name}{\B{cont}}
+
+
+.. Types, non-terminals
+
+.. |Bvaltype| mathdef:: \xref{binary/types}{binary-valtype}{\B{valtype}}
+.. |Bresulttype| mathdef:: \xref{binary/types}{binary-resulttype}{\B{resulttype}}
+.. |Bblocktype| mathdef:: \xref{binary/types}{binary-blocktype}{\B{blocktype}}
+.. |Bfunctype| mathdef:: \xref{binary/types}{binary-functype}{\B{functype}}
+.. |Bglobaltype| mathdef:: \xref{binary/types}{binary-globaltype}{\B{globaltype}}
+.. |Btabletype| mathdef:: \xref{binary/types}{binary-tabletype}{\B{tabletype}}
+.. |Belemtype| mathdef:: \xref{binary/types}{binary-elemtype}{\B{elemtype}}
+.. |Bmemtype| mathdef:: \xref{binary/types}{binary-memtype}{\B{memtype}}
+.. |Blimits| mathdef:: \xref{binary/types}{binary-limits}{\B{limits}}
+.. |Bmut| mathdef:: \xref{binary/types}{binary-mut}{\B{mut}}
+
+
+.. Indices, non-terminals
+
+.. |Btypeidx| mathdef:: \xref{binary/modules}{binary-typeidx}{\B{typeidx}}
+.. |Bfuncidx| mathdef:: \xref{binary/modules}{binary-funcidx}{\B{funcidx}}
+.. |Btableidx| mathdef:: \xref{binary/modules}{binary-tableidx}{\B{tableidx}}
+.. |Bmemidx| mathdef:: \xref{binary/modules}{binary-memidx}{\B{memidx}}
+.. |Bglobalidx| mathdef:: \xref{binary/modules}{binary-globalidx}{\B{globalidx}}
+.. |Blocalidx| mathdef:: \xref{binary/modules}{binary-localidx}{\B{localidx}}
+.. |Blabelidx| mathdef:: \xref{binary/modules}{binary-labelidx}{\B{labelidx}}
+
+
+.. Modules, non-terminals
+
+.. |Bmagic| mathdef:: \xref{binary/modules}{binary-magic}{\B{magic}}
+.. |Bversion| mathdef:: \xref{binary/modules}{binary-version}{\B{version}}
+.. |Bmodule| mathdef:: \xref{binary/modules}{binary-module}{\B{module}}
+
+.. |Bsection| mathdef:: \xref{binary/modules}{binary-module}{\B{section}}
+.. |Bcustomsec| mathdef:: \xref{binary/modules}{binary-customsec}{\B{customsec}}
+.. |Btypesec| mathdef:: \xref{binary/modules}{binary-typesec}{\B{typesec}}
+.. |Bfuncsec| mathdef:: \xref{binary/modules}{binary-funcsec}{\B{funcsec}}
+.. |Bcodesec| mathdef:: \xref{binary/modules}{binary-codesec}{\B{codesec}}
+.. |Btablesec| mathdef:: \xref{binary/modules}{binary-tablesec}{\B{tablesec}}
+.. |Bmemsec| mathdef:: \xref{binary/modules}{binary-memsec}{\B{memsec}}
+.. |Bglobalsec| mathdef:: \xref{binary/modules}{binary-globalsec}{\B{globalsec}}
+.. |Bimportsec| mathdef:: \xref{binary/modules}{binary-importsec}{\B{importsec}}
+.. |Bexportsec| mathdef:: \xref{binary/modules}{binary-exportsec}{\B{exportsec}}
+.. |Belemsec| mathdef:: \xref{binary/modules}{binary-elemsec}{\B{elemsec}}
+.. |Bdatasec| mathdef:: \xref{binary/modules}{binary-datasec}{\B{datasec}}
+.. |Bstartsec| mathdef:: \xref{binary/modules}{binary-startsec}{\B{startsec}}
+
+.. |Bcustom| mathdef:: \xref{binary/modules}{binary-customsec}{\B{custom}}
+.. |Btype| mathdef:: \xref{binary/modules}{binary-typedef}{\B{type}}
+.. |Bfunc| mathdef:: \xref{binary/modules}{binary-func}{\B{func}}
+.. |Btable| mathdef:: \xref{binary/modules}{binary-table}{\B{table}}
+.. |Bmem| mathdef:: \xref{binary/modules}{binary-mem}{\B{mem}}
+.. |Bglobal| mathdef:: \xref{binary/modules}{binary-global}{\B{global}}
+.. |Bimport| mathdef:: \xref{binary/modules}{binary-import}{\B{import}}
+.. |Bexport| mathdef:: \xref{binary/modules}{binary-export}{\B{export}}
+.. |Bimportdesc| mathdef:: \xref{binary/modules}{binary-importdesc}{\B{importdesc}}
+.. |Bexportdesc| mathdef:: \xref{binary/modules}{binary-exportdesc}{\B{exportdesc}}
+.. |Belem| mathdef:: \xref{binary/modules}{binary-elem}{\B{elem}}
+.. |Bcode| mathdef:: \xref{binary/modules}{binary-code}{\B{code}}
+.. |Blocal| mathdef:: \xref{binary/modules}{binary-local}{\B{local}}
+.. |Blocals| mathdef:: \xref{binary/modules}{binary-local}{\B{locals}}
+.. |Bdata| mathdef:: \xref{binary/modules}{binary-data}{\B{data}}
+.. |Bstart| mathdef:: \xref{binary/modules}{binary-start}{\B{start}}
+
+
+.. Instructions, non-terminals
 
 .. |Bmemarg| mathdef:: \xref{binary/instructions}{binary-memarg}{\B{memarg}}
 
@@ -527,7 +402,149 @@
 .. |Bexpr| mathdef:: \xref{binary/instructions}{binary-expr}{\B{expr}}
 
 
-.. Instructions, textual non-terminals
+
+.. Text Format
+.. -----------
+
+.. Lexical grammar, terminals
+
+.. |textl| mathdef:: \mbox{‘}
+.. |textr| mathdef:: \mbox{’}
+.. |text#1| mathdef:: \textl\mathtt{#1}\textr
+
+.. |Tcommentl| mathdef:: \text{{(}{;}}
+.. |Tcommentr| mathdef:: \text{{;}{)}}
+.. |Tcommentd| mathdef:: \text{{;}{;}}
+
+
+.. Lexical grammar, non-terminals
+
+.. |Tchar| mathdef:: \xref{text/lexical}{text-char}{\T{char}}
+.. |Tspace| mathdef:: \xref{text/lexical}{text-space}{\T{space}}
+.. |Tformat| mathdef:: \xref{text/lexical}{text-format}{\T{format}}
+
+.. |Ttoken| mathdef:: \xref{text/lexical}{text-token}{\T{token}}
+.. |Tkeyword| mathdef:: \xref{text/lexical}{text-keyword}{\T{keyword}}
+.. |Treserved| mathdef:: \xref{text/lexical}{text-reserved}{\T{reserved}}
+
+.. |Tcomment| mathdef:: \xref{text/lexical}{text-comment}{\T{comment}}
+.. |Tlinecomment| mathdef:: \xref{text/lexical}{text-comment}{\T{linecomment}}
+.. |Tblockcomment| mathdef:: \xref{text/lexical}{text-comment}{\T{blockcomment}}
+.. |Tlinechar| mathdef:: \xref{text/lexical}{text-comment}{\T{linechar}}
+.. |Tblockchar| mathdef:: \xref{text/lexical}{text-comment}{\T{blockchar}}
+
+
+.. Values, non-terminals
+
+.. |Tbyte| mathdef:: \xref{text/values}{text-byte}{\T{byte}}
+
+.. |Tsign| mathdef:: \xref{text/values}{text-sign}{\T{sign}}
+.. |Tdigit| mathdef:: \xref{text/values}{text-digit}{\T{digit}}
+.. |Thexdigit| mathdef:: \xref{text/values}{text-hexdigit}{\T{hexdigit}}
+.. |Tnum| mathdef:: \xref{text/values}{text-num}{\T{num}}
+.. |Thexnum| mathdef:: \xref{text/values}{text-hexnum}{\T{hexnum}}
+.. |Tfrac| mathdef:: \xref{text/values}{text-frac}{\T{frac}}
+.. |Thexfrac| mathdef:: \xref{text/values}{text-hexfrac}{\T{hexfrac}}
+.. |Tfloat| mathdef:: \xref{text/values}{text-float}{\T{float}}
+.. |Thexfloat| mathdef:: \xref{text/values}{text-hexfloat}{\T{hexfloat}}
+
+.. |TuX#1| mathdef:: {\T{u}#1}
+.. |TsX#1| mathdef:: {\T{s}#1}
+.. |TiX#1| mathdef:: {\T{i}#1}
+.. |TfX#1| mathdef:: {\T{f}#1}
+
+.. |TuN| mathdef:: \xref{text/values}{text-int}{\TuX{N}}
+.. |Tu1| mathdef:: \xref{text/values}{text-int}{\TuX{\T{1}}}
+.. |Tu8| mathdef:: \xref{text/values}{text-int}{\TuX{\T{8}}}
+.. |Tu16| mathdef:: \xref{text/values}{text-int}{\TuX{\T{16}}}
+.. |Tu32| mathdef:: \xref{text/values}{text-int}{\TuX{\T{32}}}
+.. |Tu64| mathdef:: \xref{text/values}{text-int}{\TuX{\T{64}}}
+
+.. |TsN| mathdef:: \xref{text/values}{text-int}{\TsX{N}}
+.. |Ts32| mathdef:: \xref{text/values}{text-int}{\TsX{\T{32}}}
+.. |Ts64| mathdef:: \xref{text/values}{text-int}{\TsX{\T{64}}}
+
+.. |TiN| mathdef:: \xref{text/values}{text-int}{\TiX{N}}
+.. |Ti32| mathdef:: \xref{text/values}{text-int}{\TiX{\T{32}}}
+.. |Ti64| mathdef:: \xref{text/values}{text-int}{\TiX{\T{64}}}
+
+.. |TfN| mathdef:: \xref{text/values}{text-float}{\TfX{N}}
+.. |TfNmag| mathdef:: \xref{text/values}{text-float}{\TfX{N}\T{mag}}
+.. |Tf32| mathdef:: \xref{text/values}{text-float}{\TfX{\T{32}}}
+.. |Tf64| mathdef:: \xref{text/values}{text-float}{\TfX{\T{64}}}
+
+.. |Tvec| mathdef:: \xref{text/values}{text-vec}{\T{vec}}
+.. |Tstring| mathdef:: \xref{text/values}{text-string}{\T{string}}
+.. |Tstringelem| mathdef:: \xref{text/values}{text-string}{\T{stringelem}}
+.. |Tstringchar| mathdef:: \xref{text/values}{text-string}{\T{stringchar}}
+.. |Tname| mathdef:: \xref{text/values}{text-name}{\T{name}}
+.. |Tcodepoint| mathdef:: \xref{text/values}{text-name}{\T{codepoint}}
+.. |Tcodeval| mathdef:: \xref{text/values}{text-name}{\T{codeval}}
+.. |Tcodecont| mathdef:: \xref{text/values}{text-name}{\T{cont}}
+
+.. |Tid| mathdef:: \xref{text/values}{text-id}{\T{id}}
+.. |Tidchar| mathdef:: \xref{text/values}{text-id}{\T{idchar}}
+
+
+.. Types, non-terminals
+
+.. |Tvaltype| mathdef:: \xref{text/types}{text-valtype}{\T{valtype}}
+.. |Tresulttype| mathdef:: \xref{text/types}{text-resulttype}{\T{resulttype}}
+.. |Tblocktype| mathdef:: \xref{text/types}{text-blocktype}{\T{blocktype}}
+.. |Tfunctype| mathdef:: \xref{text/types}{text-functype}{\T{functype}}
+.. |Tglobaltype| mathdef:: \xref{text/types}{text-globaltype}{\T{globaltype}}
+.. |Ttabletype| mathdef:: \xref{text/types}{text-tabletype}{\T{tabletype}}
+.. |Telemtype| mathdef:: \xref{text/types}{text-elemtype}{\T{elemtype}}
+.. |Tmemtype| mathdef:: \xref{text/types}{text-memtype}{\T{memtype}}
+.. |Tlimits| mathdef:: \xref{text/types}{text-limits}{\T{limits}}
+.. |Tparam| mathdef:: \xref{text/types}{text-functype}{\T{param}}
+.. |Tresult| mathdef:: \xref{text/types}{text-functype}{\T{result}}
+
+
+.. Indices, non-terminals
+
+.. |Ttypeidx| mathdef:: \xref{text/modules}{text-typeidx}{\T{typeidx}}
+.. |Tfuncidx| mathdef:: \xref{text/modules}{text-funcidx}{\T{funcidx}}
+.. |Ttableidx| mathdef:: \xref{text/modules}{text-tableidx}{\T{tableidx}}
+.. |Tmemidx| mathdef:: \xref{text/modules}{text-memidx}{\T{memidx}}
+.. |Tglobalidx| mathdef:: \xref{text/modules}{text-globalidx}{\T{globalidx}}
+.. |Tlocalidx| mathdef:: \xref{text/modules}{text-localidx}{\T{localidx}}
+.. |Tlabelidx| mathdef:: \xref{text/modules}{text-labelidx}{\T{labelidx}}
+
+.. |Ttypebind| mathdef:: \xref{text/modules}{text-typebind}{\T{typebind}}
+.. |Tfuncbind| mathdef:: \xref{text/modules}{text-funcbind}{\T{funcbind}}
+.. |Ttablebind| mathdef:: \xref{text/modules}{text-tablebind}{\T{tablebind}}
+.. |Tmembind| mathdef:: \xref{text/modules}{text-membind}{\T{membind}}
+.. |Tglobalbind| mathdef:: \xref{text/modules}{text-globalbind}{\T{globalbind}}
+.. |Tlocalbind| mathdef:: \xref{text/modules}{text-localbind}{\T{localbind}}
+.. |Tlabelbind| mathdef:: \xref{text/modules}{text-labelbind}{\T{labelbind}}
+
+
+.. Modules, non-terminals
+
+.. |Tmodule| mathdef:: \xref{text/modules}{text-module}{\T{module}}
+.. |Tmodulebody| mathdef:: \xref{text/modules}{text-modulebody}{\T{modulebody}}
+.. |Tmodulefield| mathdef:: \xref{text/modules}{text-modulefield}{\T{modulefield}}
+.. |Ttype| mathdef:: \xref{text/modules}{text-typedef}{\T{type}}
+.. |Ttypeuse| mathdef:: \xref{text/modules}{text-typeuse}{\T{typeuse}}
+.. |Tfunc| mathdef:: \xref{text/modules}{text-func}{\T{func}}
+.. |Ttable| mathdef:: \xref{text/modules}{text-table}{\T{table}}
+.. |Tmem| mathdef:: \xref{text/modules}{text-mem}{\T{mem}}
+.. |Tglobal| mathdef:: \xref{text/modules}{text-global}{\T{global}}
+.. |Timport| mathdef:: \xref{text/modules}{text-import}{\T{import}}
+.. |Texport| mathdef:: \xref{text/modules}{text-export}{\T{export}}
+.. |Timportdesc| mathdef:: \xref{text/modules}{text-importdesc}{\T{importdesc}}
+.. |Texportdesc| mathdef:: \xref{text/modules}{text-exportdesc}{\T{exportdesc}}
+.. |Telem| mathdef:: \xref{text/modules}{text-elem}{\T{elem}}
+.. |Tcode| mathdef:: \xref{text/modules}{text-code}{\T{code}}
+.. |Tlocal| mathdef:: \xref{text/modules}{text-local}{\T{local}}
+.. |Tlocals| mathdef:: \xref{text/modules}{text-local}{\T{locals}}
+.. |Tdata| mathdef:: \xref{text/modules}{text-data}{\T{data}}
+.. |Tdatastring| mathdef:: \xref{text/modules}{text-datastring}{\T{datastring}}
+.. |Tstart| mathdef:: \xref{text/modules}{text-start}{\T{start}}
+
+
+.. Instructions, non-terminals
 
 .. |Tmemarg| mathdef:: \xref{text/instructions}{text-memarg}{\T{memarg}}
 .. |Talign| mathdef:: \xref{text/instructions}{text-memarg}{\T{align}}
@@ -541,26 +558,60 @@
 .. |Texpr| mathdef:: \xref{text/instructions}{text-expr}{\T{expr}}
 
 
-.. Context, textual
+
+.. Parsing
+.. -------
+
+.. Contexts
 
 .. |TYPEDEFS| mathdef:: \K{typedefs}
 
 
-.. Contexts, meta functions
+.. Meta Functions
 
 .. |idfresh| mathdef:: ~\xref{text/values}{text-id-fresh}{\mbox{fresh}}
 .. |idcwellformed| mathdef:: ~\xref{text/conventions}{text-context-wf}{\mbox{well-formed}}
 
 
-.. Runtime, terminals
 
-.. |MUT| mathdef:: \K{mut}
-.. |HOST| mathdef:: \K{host}
 
+.. Validation
+.. ----------
 
-.. Runtime, non-terminals
+.. Contexts
 
-.. |val| mathdef:: \xref{exec/runtime}{syntax-val}{\X{val}}
+.. |TYPES| mathdef:: \K{types}
+.. |FUNCS| mathdef:: \K{funcs}
+.. |TABLES| mathdef:: \K{tables}
+.. |MEMS| mathdef:: \K{mems}
+.. |GLOBALS| mathdef:: \K{globals}
+.. |LOCALS| mathdef:: \K{locals}
+.. |LABELS| mathdef:: \K{labels}
+.. |LRETURN| mathdef:: \K{return}
+.. |IMPORTS| mathdef:: \K{imports}
+.. |EXPORTS| mathdef:: \K{exports}
+
+
+
+.. Execution
+.. ---------
+
+.. Notation
+
+.. |stepto| mathdef:: \hookrightarrow
+
+
+.. Allocation
+
+.. |allocfunc| mathdef:: \xref{exec/modules}{alloc-func}{\F{allocfunc}}
+.. |allochostfunc| mathdef:: \xref{exec/modules}{alloc-hostfunc}{\F{allochostfunc}}
+.. |alloctable| mathdef:: \xref{exec/modules}{alloc-table}{\F{alloctable}}
+.. |allocmem| mathdef:: \xref{exec/modules}{alloc-mem}{\F{allocmem}}
+.. |allocglobal| mathdef:: \xref{exec/modules}{alloc-global}{\F{allocglobal}}
+.. |allocmodule| mathdef:: \xref{exec/modules}{alloc-module}{\F{allocmodule}}
+
+
+.. Addresses, non-terminals
 
 .. |addr| mathdef:: \xref{exec/runtime}{syntax-addr}{\X{addr}}
 .. |funcaddr| mathdef:: \xref{exec/runtime}{syntax-funcaddr}{\X{funcaddr}}
@@ -568,6 +619,23 @@
 .. |memaddr| mathdef:: \xref{exec/runtime}{syntax-memaddr}{\X{memaddr}}
 .. |globaladdr| mathdef:: \xref{exec/runtime}{syntax-globaladdr}{\X{globaladdr}}
 
+
+.. Instances, terminals
+
+.. |VALUE| mathdef:: \K{value}
+.. |INIT| mathdef:: \K{init}
+.. |BODY| mathdef:: \K{body}
+.. |NAME| mathdef:: \K{name}
+.. |DESC| mathdef:: \K{desc}
+
+.. |MUT| mathdef:: \K{mut}
+.. |HOST| mathdef:: \K{host}
+
+
+.. Instances, non-terminals
+
+.. |externval| mathdef:: \xref{exec/runtime}{syntax-externval}{\X{externval}}
+
 .. |moduleinst| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\X{moduleinst}}
 .. |funcinst| mathdef:: \xref{exec/runtime}{syntax-funcinst}{\X{funcinst}}
 .. |tableinst| mathdef:: \xref{exec/runtime}{syntax-tableinst}{\X{tableinst}}
@@ -575,52 +643,40 @@
 .. |meminst| mathdef:: \xref{exec/runtime}{syntax-meminst}{\X{meminst}}
 .. |globalinst| mathdef:: \xref{exec/runtime}{syntax-globalinst}{\X{globalinst}}
 .. |exportinst| mathdef:: \xref{exec/runtime}{syntax-exportinst}{\X{exportinst}}
+
 .. |hostfunc| mathdef:: \xref{exec/runtime}{syntax-hostfunc}{\X{hostfunc}}
 
-.. |externval| mathdef:: \xref{exec/runtime}{syntax-externval}{\X{externval}}
-.. |externtype| mathdef:: \xref{syntax/types}{syntax-externtype}{\X{externtype}}
-.. |storagetype| mathdef:: \xref{exec/runtime}{syntax-storagetype}{\X{storagetype}}
 
-.. |store| mathdef:: \xref{exec/runtime}{syntax-store}{\X{store}}
-.. |frame| mathdef:: \xref{exec/runtime}{syntax-frame}{\X{frame}}
-.. |label| mathdef:: \xref{exec/runtime}{syntax-label}{\X{label}}
+.. Store & Stack, terminals
 
-.. |XB| mathdef:: \xref{exec/runtime}{syntax-ctxt-block}{B}
+.. |TRAP| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{trap}}
+.. |LABEL| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{label}}
+.. |FRAME| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{frame}}
 
-.. |moduleinstr| mathdef:: \xref{exec/runtime}{syntax-moduleinstr}{\X{moduleinstr}}
 
+.. Store & Stack, non-terminals
 
-.. Execution, notation
+.. |store| mathdef:: \xref{exec/runtime}{syntax-store}{\X{store}}
+.. |frame| mathdef:: \xref{exec/runtime}{syntax-frame}{\X{frame}}
+.. |label| mathdef:: \xref{exec/runtime}{syntax-label}{\X{label}}
 
-.. |stepto| mathdef:: \hookrightarrow
-.. |mod| mathdef:: \mathbin{\F{mod}}
 
-.. |allocfunc| mathdef:: \xref{exec/modules}{alloc-func}{\F{allocfunc}}
-.. |allochostfunc| mathdef:: \xref{exec/modules}{alloc-hostfunc}{\F{allochostfunc}}
-.. |alloctable| mathdef:: \xref{exec/modules}{alloc-table}{\F{alloctable}}
-.. |allocmem| mathdef:: \xref{exec/modules}{alloc-mem}{\F{allocmem}}
-.. |allocglobal| mathdef:: \xref{exec/modules}{alloc-global}{\F{allocglobal}}
-.. |allocmodule| mathdef:: \xref{exec/modules}{alloc-module}{\F{allocmodule}}
+.. Administrative Instructions, terminals
 
+.. |INVOKE| mathdef:: \xref{exec/runtime}{syntax-invoke}{\K{invoke}}
+.. |INSTANTIATE| mathdef:: \xref{exec/runtime}{syntax-instantiate}{\K{instantiate}}
+.. |INITGLOBAL| mathdef:: \xref{exec/runtime}{syntax-init_global}{\K{init\_global}}
+.. |INITTABLE| mathdef:: \xref{exec/runtime}{syntax-init_table}{\K{init\_table}}
+.. |INITMEM| mathdef:: \xref{exec/runtime}{syntax-init_mem}{\K{init\_mem}}
 
-.. Numerics, meta functions
 
-.. |bits| mathdef:: \xref{exec/numerics}{aux-bits}{\F{bits}}
-.. |ibits| mathdef:: \xref{exec/numerics}{aux-ibits}{\F{ibits}}
-.. |fbits| mathdef:: \xref{exec/numerics}{aux-fbits}{\F{fbits}}
-.. |fsign| mathdef:: \xref{exec/numerics}{aux-fsign}{\F{fsign}}
-.. |fbias| mathdef:: \xref{exec/numerics}{aux-fbias}{\F{fbias}}
-.. |bytes| mathdef:: \xref{exec/numerics}{aux-bytes}{\F{bytes}}
-.. |littleendian| mathdef:: \xref{exec/numerics}{aux-littleendian}{\F{littleendian}}
-.. |signed| mathdef:: \xref{exec/numerics}{aux-signed}{\F{signed}}
-.. |bool| mathdef:: \xref{exec/numerics}{aux-bool}{\F{bool}}
+.. Values & Administrative Instructions, non-terminals
 
-.. |ieee| mathdef:: \xref{exec/numerics}{aux-ieee}{\F{float}}
-.. |nans| mathdef:: \xref{exec/numerics}{aux-nans}{\F{nans}}
-.. |canon| mathdef:: \xref{syntax/values}{aux-canon}{\F{canon}}
+.. |val| mathdef:: \xref{exec/runtime}{syntax-val}{\X{val}}
 
-.. |significand| mathdef:: \xref{syntax/values}{aux-significand}{\F{signif}}
-.. |exponent| mathdef:: \xref{syntax/values}{aux-exponent}{\F{expon}}
+.. |moduleinstr| mathdef:: \xref{exec/runtime}{syntax-moduleinstr}{\X{moduleinstr}}
+
+.. |XB| mathdef:: \xref{exec/runtime}{syntax-ctxt-block}{B}
 
 
 .. Numerics, operators
@@ -688,4 +744,19 @@
 .. |converts| mathdef:: \xref{exec/numerics}{op-convert_s}{\F{convert\_s}}
 .. |reinterpret| mathdef:: \xref{exec/numerics}{op-reinterpret}{\F{reinterpret}}
 
+
+.. Numerics, meta functions
+
+.. |bits| mathdef:: \xref{exec/numerics}{aux-bits}{\F{bits}}
+.. |ibits| mathdef:: \xref{exec/numerics}{aux-ibits}{\F{ibits}}
+.. |fbits| mathdef:: \xref{exec/numerics}{aux-fbits}{\F{fbits}}
+.. |fsign| mathdef:: \xref{exec/numerics}{aux-fsign}{\F{fsign}}
+.. |fbias| mathdef:: \xref{exec/numerics}{aux-fbias}{\F{fbias}}
+.. |bytes| mathdef:: \xref{exec/numerics}{aux-bytes}{\F{bytes}}
+.. |littleendian| mathdef:: \xref{exec/numerics}{aux-littleendian}{\F{littleendian}}
+.. |signed| mathdef:: \xref{exec/numerics}{aux-signed}{\F{signed}}
+.. |bool| mathdef:: \xref{exec/numerics}{aux-bool}{\F{bool}}
+
+.. |ieee| mathdef:: \xref{exec/numerics}{aux-ieee}{\F{float}}
+.. |nans| mathdef:: \xref{exec/numerics}{aux-nans}{\F{nans}}
 .. |trunc| mathdef:: \xref{exec/numerics}{aux-trunc}{\F{trunc}}
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index f0acf3418..2511f0b29 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -5,7 +5,7 @@ Conventions
 -----------
 
 Validation checks that a WebAssembly module is well-formed.
-Only valid modules can be :ref:`instantiated <instantiation>`.
+Only valid modules can be :ref:`instantiated <exec-instantiation>`.
 
 Validity is defined by a *type system* over the :ref:`abstract syntax <syntax>` of both instructions and modules.
 For each piece of abstract syntax, there is a typing rule that specifies the constraints that apply to it.

From f5b713f6a9a566ad5e9e4a33eb9fc55e627f1476 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Mon, 3 Jul 2017 09:05:21 +0200
Subject: [PATCH 051/329] [interpreter/test] Fix symbolic forward references
 and change inline type expansion (#512)

Correctly handle forward references to type definitions, and add tests.
Tweak the expansion of inline function types by inserting type definitions at the end of the module.
1. The latter should hardly affect any existing programs, because it's only observable if a program 2. uses raw numeric type indices and forward-references later type definitions with them.
---
 interpreter/text/parser.mly | 122 +++++++++++++++---------------
 test/core/func.wast         | 147 +++++++++++++++++++++++-------------
 test/core/imports.wast      |   4 +
 3 files changed, 159 insertions(+), 114 deletions(-)

diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 6df18a5fc..934bc59d2 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -59,8 +59,8 @@ module VarMap = Map.Make(String)
 type space = {mutable map : int32 VarMap.t; mutable count : int32}
 let empty () = {map = VarMap.empty; count = 0l}
 
-type types = {mutable tmap : int32 VarMap.t; mutable tlist : type_ list}
-let empty_types () = {tmap = VarMap.empty; tlist = []}
+type types = {space : space; mutable list : type_ list}
+let empty_types () = {space = empty (); list = []}
 
 type context =
   { types : types; tables : space; memories : space;
@@ -74,14 +74,11 @@ let empty_context () =
 let enter_func (c : context) =
   {c with labels = VarMap.empty; locals = empty ()}
 
-let type_ (c : context) x =
-  try VarMap.find x.it c.types.tmap
-  with Not_found -> error x.at ("unknown type " ^ x.it)
-
 let lookup category space x =
   try VarMap.find x.it space.map
   with Not_found -> error x.at ("unknown " ^ category ^ " " ^ x.it)
 
+let type_ (c : context) x = lookup "type" c.types.space x
 let func (c : context) x = lookup "function" c.funcs x
 let local (c : context) x = lookup "local" c.locals x
 let global (c : context) x = lookup "global" c.globals x
@@ -91,15 +88,10 @@ let label (c : context) x =
   try VarMap.find x.it c.labels
   with Not_found -> error x.at ("unknown label " ^ x.it)
 
-let bind_type (c : context) x ty =
-  if VarMap.mem x.it c.types.tmap then
-    error x.at ("duplicate type " ^ x.it);
-  c.types.tmap <-
-    VarMap.add x.it (Lib.List32.length c.types.tlist) c.types.tmap;
-  c.types.tlist <- c.types.tlist @ [ty]
+let func_type (c : context) x =
+  try (Lib.List32.nth c.types.list x.it).it
+  with Failure _ -> error x.at ("unknown type " ^ Int32.to_string x.it)
 
-let anon_type (c : context) ty =
-  c.types.tlist <- c.types.tlist @ [ty]
 
 let bind category space x =
   if VarMap.mem x.it space.map then
@@ -111,6 +103,9 @@ let bind category space x =
     error x.at ("too many " ^ category ^ " bindings");
   i
 
+let bind_type (c : context) x ty =
+  c.types.list <- c.types.list @ [ty];
+  bind "type" c.types.space x
 let bind_func (c : context) x = bind "function" c.funcs x
 let bind_local (c : context) x = bind "local" c.locals x
 let bind_global (c : context) x = bind "global" c.globals x
@@ -126,6 +121,9 @@ let anon category space n =
     error no_region ("too many " ^ category ^ " bindings");
   i
 
+let anon_type (c : context) ty =
+  c.types.list <- c.types.list @ [ty];
+  anon "type" c.types.space 1l
 let anon_func (c : context) = anon "function" c.funcs 1l
 let anon_locals (c : context) ts =
   ignore (anon "local" c.locals (Lib.List32.length ts))
@@ -135,23 +133,15 @@ let anon_memory (c : context) = anon "memory" c.memories 1l
 let anon_label (c : context) =
   {c with labels = VarMap.map (Int32.add 1l) c.labels}
 
-let empty_type = FuncType ([], [])
-
-let inline_type (c : context) ty at =
-  match Lib.List.index_where (fun ty' -> ty'.it = ty) c.types.tlist with
+let inline_type (c : context) ft at =
+  match Lib.List.index_where (fun ty -> ty.it = ft) c.types.list with
   | Some i -> Int32.of_int i @@ at
-  | None ->
-    let i = Lib.List32.length c.types.tlist in ignore (anon_type c (ty @@ at)); i @@ at
-
-let inline_type_explicit (c : context) x ty at =
-  if
-    ty <> empty_type &&
-    (x.it >= Lib.List32.length c.types.tlist ||
-     ty <> (Lib.List32.nth c.types.tlist x.it).it)
-  then
-    error at "inline function type does not match explicit type"
-  else
-    x
+  | None -> anon_type c (ft @@ at) @@ at
+
+let inline_type_explicit (c : context) x ft at =
+  if ft <> FuncType ([], []) && ft <> func_type c x then
+    error at "inline function type does not match explicit type";
+  x
 
 %}
 
@@ -399,27 +389,27 @@ const_expr :
 func :
   | LPAR FUNC bind_var_opt func_fields RPAR
     { let at = at () in
-      fun c -> let x = $3 c anon_func bind_func @@ at in $4 c x at }
+      fun c -> let x = $3 c anon_func bind_func @@ at in fun () -> $4 c x at }
 
 func_fields :
   | type_use func_fields_body
     { fun c x at ->
       let t = inline_type_explicit c ($1 c type_) (fst $2) at in
-      (fun () -> [{(snd $2 (enter_func c)) with ftype = t} @@ at]), [], [] }
+      [{(snd $2 (enter_func c)) with ftype = t} @@ at], [], [] }
   | func_fields_body  /* Sugar */
     { fun c x at ->
       let t = inline_type c (fst $1) at in
-      (fun () -> [{(snd $1 (enter_func c)) with ftype = t} @@ at]), [], [] }
+      [{(snd $1 (enter_func c)) with ftype = t} @@ at], [], [] }
   | inline_import type_use func_fields_import  /* Sugar */
     { fun c x at ->
       let t = inline_type_explicit c ($2 c type_) $3 at in
-      (fun () -> []),
+      [],
       [{ module_name = fst $1; item_name = snd $1;
          idesc = FuncImport t @@ at } @@ at ], [] }
   | inline_import func_fields_import  /* Sugar */
     { fun c x at ->
       let t = inline_type c $2 at in
-      (fun () -> []),
+      [],
       [{ module_name = fst $1; item_name = snd $1;
          idesc = FuncImport t @@ at } @@ at ], [] }
   | inline_export func_fields  /* Sugar */
@@ -434,7 +424,7 @@ func_fields_import :  /* Sugar */
     { let FuncType (ins, out) = $6 in FuncType ($4 :: ins, out) }
 
 func_fields_import_result :  /* Sugar */
-  | /* empty */ { empty_type }
+  | /* empty */ { FuncType ([], []) }
   | LPAR RESULT value_type_list RPAR func_fields_import_result
     { let FuncType (ins, out) = $5 in FuncType (ins, $3 @ out) }
 
@@ -450,7 +440,7 @@ func_fields_body :
       fun c -> ignore (bind_local c $3); snd $6 c }
 
 func_result_body :
-  | func_body { empty_type, $1 }
+  | func_body { FuncType ([], []), $1 }
   | LPAR RESULT value_type_list RPAR func_result_body
     { let FuncType (ins, out) = fst $5 in
       FuncType (ins, $3 @ out), snd $5 }
@@ -562,22 +552,26 @@ global_fields :
 import_desc :
   | LPAR FUNC bind_var_opt type_use RPAR
     { fun c -> ignore ($3 c anon_func bind_func);
-      FuncImport ($4 c type_) }
+      fun () -> FuncImport ($4 c type_) }
   | LPAR FUNC bind_var_opt func_sig RPAR  /* Sugar */
     { let at4 = ati 4 in
       fun c -> ignore ($3 c anon_func bind_func);
-      FuncImport (inline_type c $4 at4) }
+      fun () -> FuncImport (inline_type c $4 at4) }
   | LPAR TABLE bind_var_opt table_sig RPAR
-    { fun c -> ignore ($3 c anon_table bind_table); TableImport $4 }
+    { fun c -> ignore ($3 c anon_table bind_table);
+      fun () -> TableImport $4 }
   | LPAR MEMORY bind_var_opt memory_sig RPAR
-    { fun c -> ignore ($3 c anon_memory bind_memory); MemoryImport $4 }
+    { fun c -> ignore ($3 c anon_memory bind_memory);
+      fun () -> MemoryImport $4 }
   | LPAR GLOBAL bind_var_opt global_type RPAR
-    { fun c -> ignore ($3 c anon_global bind_global); GlobalImport $4 }
+    { fun c -> ignore ($3 c anon_global bind_global);
+      fun () -> GlobalImport $4 }
 
 import :
   | LPAR IMPORT name name import_desc RPAR
     { let at = at () and at5 = ati 5 in
-      fun c -> {module_name = $3; item_name = $4; idesc = $5 c @@ at5} @@ at }
+      fun c -> let df = $5 c in
+      fun () -> {module_name = $3; item_name = $4; idesc = df () @@ at5} @@ at }
 
 inline_import :
   | LPAR IMPORT name name RPAR { $3, $4 }
@@ -615,55 +609,61 @@ start :
 
 module_fields :
   | /* empty */
-    { fun (c : context) -> {empty_module with types = c.types.tlist} }
+    { fun (c : context) () -> {empty_module with types = c.types.list} }
   | module_fields1 { $1 }
 
 module_fields1 :
   | type_def module_fields
-    { fun c -> $1 c; $2 c }
+    { fun c -> ignore ($1 c); $2 c }
   | global module_fields
-    { fun c -> let gf = $1 c in let m = $2 c in
-      let globs, ims, exs = gf () in
+    { fun c -> let gf = $1 c in let mf = $2 c in
+      fun () -> let globs, ims, exs = gf () in let m = mf () in
       if globs <> [] && m.imports <> [] then
         error (List.hd m.imports).at "import after global definition";
       { m with globals = globs @ m.globals;
         imports = ims @ m.imports; exports = exs @ m.exports } }
   | table module_fields
-    { fun c -> let tf = $1 c in let m = $2 c in
-      let tabs, elems, ims, exs = tf () in
+    { fun c -> let tf = $1 c in let mf = $2 c in
+      fun () -> let tabs, elems, ims, exs = tf () in let m = mf () in
       if tabs <> [] && m.imports <> [] then
         error (List.hd m.imports).at "import after table definition";
       { m with tables = tabs @ m.tables; elems = elems @ m.elems;
         imports = ims @ m.imports; exports = exs @ m.exports } }
   | memory module_fields
-    { fun c -> let mf = $1 c in let m = $2 c in
-      let mems, data, ims, exs = mf () in
+    { fun c -> let mmf = $1 c in let mf = $2 c in
+      fun () -> let mems, data, ims, exs = mmf () in let m = mf () in
       if mems <> [] && m.imports <> [] then
         error (List.hd m.imports).at "import after memory definition";
       { m with memories = mems @ m.memories; data = data @ m.data;
         imports = ims @ m.imports; exports = exs @ m.exports } }
   | func module_fields
-    { fun c -> let ff, ims, exs = $1 c in let m = $2 c in let funcs = ff () in
+    { fun c -> let ff = $1 c in let mf = $2 c in
+      fun () -> let funcs, ims, exs = ff () in let m = mf () in
       if funcs <> [] && m.imports <> [] then
         error (List.hd m.imports).at "import after function definition";
       { m with funcs = funcs @ m.funcs;
         imports = ims @ m.imports; exports = exs @ m.exports } }
   | elem module_fields
-    { fun c -> let m = $2 c in
+    { fun c -> let mf = $2 c in
+      fun () -> let m = mf () in
       {m with elems = $1 c :: m.elems} }
   | data module_fields
-    { fun c -> let m = $2 c in
+    { fun c -> let mf = $2 c in
+      fun () -> let m = mf () in
       {m with data = $1 c :: m.data} }
   | start module_fields
-    { fun c -> let m = $2 c in let x = $1 c in
+    { fun c -> let mf = $2 c in
+      fun () -> let m = mf () in let x = $1 c in
       match m.start with
       | Some _ -> error x.at "multiple start sections"
       | None -> {m with start = Some x} }
   | import module_fields
-    { fun c -> let i = $1 c in let m = $2 c in
-      {m with imports = i :: m.imports} }
+    { fun c -> let imf = $1 c in let mf = $2 c in
+      fun () -> let im = imf () in let m = mf () in
+      {m with imports = im :: m.imports} }
   | export module_fields
-    { fun c -> let m = $2 c in
+    { fun c -> let mf = $2 c in
+      fun () -> let m = mf () in
       {m with exports = $1 c :: m.exports} }
 
 module_var_opt :
@@ -672,13 +672,13 @@ module_var_opt :
 
 module_ :
   | LPAR MODULE module_var_opt module_fields RPAR
-    { $3, Textual ($4 (empty_context ()) @@ at ()) @@ at () }
+    { $3, Textual ($4 (empty_context ()) () @@ at ()) @@ at () }
 
 inline_module :  /* Sugar */
-  | module_fields { Textual ($1 (empty_context ()) @@ at ()) @@ at () }
+  | module_fields { Textual ($1 (empty_context ()) () @@ at ()) @@ at () }
 
 inline_module1 :  /* Sugar */
-  | module_fields1 { Textual ($1 (empty_context ()) @@ at ()) @@ at () }
+  | module_fields1 { Textual ($1 (empty_context ()) () @@ at ()) @@ at () }
 
 
 /* Scripts */
diff --git a/test/core/func.wast b/test/core/func.wast
index 87e50f59b..2dc4d547f 100644
--- a/test/core/func.wast
+++ b/test/core/func.wast
@@ -31,6 +31,7 @@
   (func (result i32) (unreachable))
 
   (func (type $sig))
+  (func (type $forward))  ;; forward reference
 
   (func $complex
     (param i32 f32) (param $x i64) (param) (param i32)
@@ -44,6 +45,7 @@
     (unreachable) (unreachable)
   )
 
+  (type $forward (func))
 
   ;; Typing of locals
 
@@ -149,59 +151,6 @@
   (func (export "init-local-i64") (result i64) (local i64) (get_local 0))
   (func (export "init-local-f32") (result f32) (local f32) (get_local 0))
   (func (export "init-local-f64") (result f64) (local f64) (get_local 0))
-
-
-  ;; Desugaring of implicit type signature
-  (func $empty-sig-1)  ;; should be assigned type $sig
-  (func $complex-sig-1 (param f64 i64 f64 i64 f64 i64 f32 i32))
-  (func $empty-sig-2)  ;; should be assigned type $sig
-  (func $complex-sig-2 (param f64 i64 f64 i64 f64 i64 f32 i32))
-  (func $complex-sig-3 (param f64 i64 f64 i64 f64 i64 f32 i32))
-
-  (type $empty-sig-duplicate (func))
-  (type $complex-sig-duplicate (func (param f64 i64 f64 i64 f64 i64 f32 i32)))
-  (table anyfunc
-    (elem
-      $complex-sig-3 $empty-sig-2 $complex-sig-1 $complex-sig-3 $empty-sig-1
-    )
-  )
-
-  (func (export "signature-explicit-reused")
-    (call_indirect $sig (i32.const 1))
-    (call_indirect $sig (i32.const 4))
-  )
-
-  (func (export "signature-implicit-reused")
-    ;; The implicit index 16 in this test depends on the function and
-    ;; type definitions, and may need adapting if they change.
-    (call_indirect 16
-      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
-      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
-      (i32.const 0)
-    )
-    (call_indirect 16
-      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
-      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
-      (i32.const 2)
-    )
-    (call_indirect 16
-      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
-      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
-      (i32.const 3)
-    )
-  )
-
-  (func (export "signature-explicit-duplicate")
-    (call_indirect $empty-sig-duplicate (i32.const 1))
-  )
-
-  (func (export "signature-implicit-duplicate")
-    (call_indirect $complex-sig-duplicate
-      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
-      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
-      (i32.const 0)
-    )
-  )
 )
 
 (assert_return (invoke "local-first-i32") (i32.const 0))
@@ -305,6 +254,98 @@
 (assert_return (invoke "init-local-f32") (f32.const 0))
 (assert_return (invoke "init-local-f64") (f64.const 0))
 
+
+;; Expansion of inline function types
+
+(module
+  (func $f (result f64) (f64.const 0))  ;; adds implicit type definition
+  (func $g (param i32))                 ;; reuses explicit type definition
+  (type $t (func (param i32)))
+
+  (func $i32->void (type 0))                ;; (param i32)
+  (func $void->f64 (type 1) (f64.const 0))  ;; (result f64)
+  (func $check
+    (call $i32->void (i32.const 0))
+    (drop (call $void->f64))
+  )
+)
+
+(assert_invalid
+  (module
+    (func $f (result f64) (f64.const 0))  ;; adds implicit type definition
+    (func $g (param i32))                 ;; reuses explicit type definition
+    (func $h (result f64) (f64.const 1))  ;; reuses implicit type definition
+    (type $t (func (param i32)))
+
+    (func (type 2))  ;; does not exist
+  )
+  "unknown type"
+)
+
+
+(module
+  (type $sig (func))
+
+  (func $empty-sig-1)  ;; should be assigned type $sig
+  (func $complex-sig-1 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $empty-sig-2)  ;; should be assigned type $sig
+  (func $complex-sig-2 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-3 (param f64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-4 (param i64 i64 f64 i64 f64 i64 f32 i32))
+  (func $complex-sig-5 (param i64 i64 f64 i64 f64 i64 f32 i32))
+
+  (type $empty-sig-duplicate (func))
+  (type $complex-sig-duplicate (func (param i64 i64 f64 i64 f64 i64 f32 i32)))
+  (table anyfunc
+    (elem
+      $complex-sig-3 $empty-sig-2 $complex-sig-1 $complex-sig-3 $empty-sig-1
+      $complex-sig-4 $complex-sig-5
+    )
+  )
+
+  (func (export "signature-explicit-reused")
+    (call_indirect $sig (i32.const 1))
+    (call_indirect $sig (i32.const 4))
+  )
+
+  (func (export "signature-implicit-reused")
+    ;; The implicit index 3 in this test depends on the function and
+    ;; type definitions, and may need adapting if they change.
+    (call_indirect 3
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 0)
+    )
+    (call_indirect 3
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 2)
+    )
+    (call_indirect 3
+      (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 3)
+    )
+  )
+
+  (func (export "signature-explicit-duplicate")
+    (call_indirect $empty-sig-duplicate (i32.const 1))
+  )
+
+  (func (export "signature-implicit-duplicate")
+    (call_indirect $complex-sig-duplicate
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 5)
+    )
+    (call_indirect $complex-sig-duplicate
+      (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
+      (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
+      (i32.const 6)
+    )
+  )
+)
+
 (assert_return (invoke "signature-explicit-reused"))
 (assert_return (invoke "signature-implicit-reused"))
 (assert_return (invoke "signature-explicit-duplicate"))
diff --git a/test/core/imports.wast b/test/core/imports.wast
index 69ccd0b5d..cb1a5fe2a 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -47,6 +47,10 @@
   (func (export "p5") (import "spectest" "print") (type 0))
   (func (export "p6") (import "spectest" "print") (type 0) (param i32) (result))
 
+  (import "spectest" "print" (func (type $forward)))
+  (func (import "spectest" "print") (type $forward))
+  (type $forward (func (param i32)))
+
   (table anyfunc (elem $print_i32 $print_f64))
 
   (func (export "print32") (param $i i32)

From 61ca0194358c89ba5c48b940898d826e1e4f2226 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Mon, 3 Jul 2017 11:25:29 +0200
Subject: [PATCH 052/329] Add assert_not_equals to README.md (#518)

---
 test/js-api/README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/js-api/README.md b/test/js-api/README.md
index 7a874741a..cc545909e 100644
--- a/test/js-api/README.md
+++ b/test/js-api/README.md
@@ -15,5 +15,5 @@ library.
   a try/catch and maybe asserts in case of failure.
 - A function `promise_test(function, description)` where `function` returns a
   `Promise` run by `promise_test`; a rejection means a failure here.
-- Assertion functions: `assert_equals(x, y)`, `assert_true(x)`,
-  `assert_false(x)`, `assert_unreached()`.
+- Assertion functions: `assert_equals(x, y)`, `assert_not_equals(x, y)`,
+  `assert_true(x)`, `assert_false(x)`, `assert_unreached()`.

From b8e3dc34dc161de1a09f391160722b6fd1314f13 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 6 Jul 2017 14:56:45 +0200
Subject: [PATCH 053/329] [spec] Clean-up pass over main body of spec (#519)

- Fix various layout issues
- Introduce yet more cross-references, especially to record definitions
- Move some definitions to more suitable sections
- Fix bugs and typos
- Misc wording tweaks and additions
---
 document/core/binary/conventions.rst  |  32 +-
 document/core/binary/instructions.rst |   4 +-
 document/core/binary/modules.rst      | 122 ++++----
 document/core/binary/types.rst        |   6 +-
 document/core/binary/values.rst       | 107 +++----
 document/core/conf.py                 |   1 +
 document/core/exec/conventions.rst    |  16 +-
 document/core/exec/instructions.rst   | 339 ++++++++++----------
 document/core/exec/modules.rst        | 424 +++++++++++++++-----------
 document/core/exec/numerics.rst       | 202 ++++++------
 document/core/exec/runtime.rst        | 171 ++++++-----
 document/core/intro/introduction.rst  |   4 +-
 document/core/intro/overview.rst      |  28 +-
 document/core/static/custom.css       |   6 +-
 document/core/syntax/conventions.rst  |  67 ++--
 document/core/syntax/instructions.rst | 112 +++----
 document/core/syntax/modules.rst      | 124 ++++----
 document/core/syntax/types.rst        |  65 ++--
 document/core/syntax/values.rst       |  80 ++---
 document/core/text/conventions.rst    |  61 ++--
 document/core/text/instructions.rst   |  29 +-
 document/core/text/lexical.rst        |  29 +-
 document/core/text/modules.rst        | 213 +++++++------
 document/core/text/types.rst          |   4 +-
 document/core/text/values.rst         |  81 +++--
 document/core/util/math.def           | 242 +++++++++++----
 document/core/valid/conventions.rst   |  38 +--
 document/core/valid/index.rst         |   1 +
 document/core/valid/instructions.rst  | 130 ++++----
 document/core/valid/modules.rst       | 331 +++++++++-----------
 document/core/valid/types.rst         |  57 ++++
 31 files changed, 1722 insertions(+), 1404 deletions(-)
 create mode 100644 document/core/valid/types.rst

diff --git a/document/core/binary/conventions.rst b/document/core/binary/conventions.rst
index 001677768..08e9db793 100644
--- a/document/core/binary/conventions.rst
+++ b/document/core/binary/conventions.rst
@@ -1,4 +1,4 @@
-.. index:: ! binary format
+.. index:: ! binary format, module, byte, file extension, abstract syntax
 
 Conventions
 -----------
@@ -18,7 +18,9 @@ Except for a few exceptions, the binary grammar closely mirrors the grammar of t
    Some phrases of abstract syntax have multiple possible encodings in the binary format.
    For example, numbers may be encoded as if they had optional leading zeros.
    Implementations of decoders must support all possible alternatives;
-   implementations of encoders can pick any one allowed encoding.
+   implementations of encoders can pick any allowed encoding.
+
+The recommended extension for files containing WebAssembly modules in binary format is ":math:`\T{.wasm}`".
 
 .. [#compression]
    Additional encoding layers -- for example, introducing compression -- may be defined on top of the basic representation defined here.
@@ -35,7 +37,7 @@ Grammar
 
 The following conventions are adopted in defining grammar rules for the binary format.
 They mirror the conventions used for :ref:`abstract syntax <grammar>`.
-In order to distinguish symbols of the binary syntax from symbols of the abstract syntax, typewriter font is adopted for the former.
+In order to distinguish symbols of the binary syntax from symbols of the abstract syntax, :math:`\mathtt{typewriter}` font is adopted for the former.
 
 * Terminal symbols are :ref:`bytes <syntax-byte>` expressed in hexadecimal notation: :math:`\hex{0F}`.
 
@@ -51,7 +53,7 @@ In order to distinguish symbols of the binary syntax from symbols of the abstrac
 
 * :math:`x{:}B` denotes the same language as the nonterminal :math:`B`, but also binds the variable :math:`x` to the attribute synthesized for :math:`B`.
 
-* Productions are written :math:`\B{name} ::= B \Rightarrow A`, where :math:`A` is the attribute that is synthesized for :math:`\B{name}`, usually from attribute variables bound in :math:`B`.
+* Productions are written :math:`\B{sym} ::= B_1 \Rightarrow A_1 ~|~ \dots ~|~ B_n \Rightarrow A_n`, where each :math:`A_i` is the attribute that is synthesized for :math:`\B{sym}` in the given case, usually from attribute variables bound in :math:`B_i`.
 
 * Some productions are augmented by side conditions in parentheses, which restrict the applicability of the production. They provide a shorthand for a combinatorial expansion of the production into many separate cases.
 
@@ -76,13 +78,13 @@ In order to distinguish symbols of the binary syntax from symbols of the abstrac
    .. math::
       \begin{array}{llclll}
       \production{limits} & \Blimits &::=&
-        \hex{00}~~n{:}\Bu32 &\Rightarrow& \{ \MIN~n, \MAX~\epsilon \} \\ &&|&
-        \hex{01}~~n{:}\Bu32~~m{:}\Bu32 &\Rightarrow& \{ \MIN~n, \MAX~m \} \\
+        \hex{00}~~n{:}\Bu32 &\Rightarrow& \{ \LMIN~n, \LMAX~\epsilon \} \\ &&|&
+        \hex{01}~~n{:}\Bu32~~m{:}\Bu32 &\Rightarrow& \{ \LMIN~n, \LMAX~m \} \\
       \end{array}
 
    That is, a limits pair is encoded as either the byte :math:`\hex{00}` followed by the encoding of a |U32| value,
    or the byte :math:`\hex{01}` followed by two such encodings. 
-   The variables :math:`n` and :math:`m` name the attributes of the respective |Bu32| nonterminals, which in this case are the actual :ref:`unsigned integers <syntax-uint>` they decode into.
+   The variables :math:`n` and :math:`m` name the attributes of the respective |Bu32| nonterminals, which in this case are the actual :ref:`unsigned integers <syntax-uint>` those decode into.
    The attribute of the complete production then is the abstract syntax for the limit, expressed in terms of the former values.
 
 
@@ -96,3 +98,19 @@ When dealing with binary encodings the following notation is also used:
 * :math:`\epsilon` denotes the empty byte sequence.
 
 * :math:`||B||` is the length of the byte sequence generated from the production :math:`B` in a derivation.
+
+
+.. index:: vector
+   pair: binary format; vector
+.. _binary-vec:
+
+Vectors
+~~~~~~~
+
+:ref:`Vectors <syntax-vec>` are encoded with their |Bu32| length followed by the encoding of their element sequence.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{vector} & \Bvec(\B{B}) &::=&
+     n{:}\Bu32~~(x{:}\B{B})^n &\Rightarrow& x^n \\
+   \end{array}
diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index 319a2f76c..e7d13ae9f 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -10,7 +10,7 @@ and is followed by the instruction's immediate arguments, where present.
 The only exception are :ref:`structured control instructions <binary-instr-control>`, which consist of several opcodes bracketing their nested instruction sequences.
 
 .. note::
-   Gaps in the byte code ranges encoding instructions are reserved for future extensions.
+   Gaps in the byte code ranges for encoding instructions are reserved for future extensions.
 
 
 .. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, polymorphism
@@ -20,7 +20,7 @@ The only exception are :ref:`structured control instructions <binary-instr-contr
 Control Instructions
 ~~~~~~~~~~~~~~~~~~~~
 
-:ref:`Control instructions <syntax-instr-control>` have varying encodings. For structured instructions, the nested instruction sequences are terminated with explicit opcodes for |END| and |ELSE|.
+:ref:`Control instructions <syntax-instr-control>` have varying encodings. For structured instructions, the instruction sequences forming nested blocks are terminated with explicit opcodes for |END| and |ELSE|.
 
 .. _binary-nop:
 .. _binary-unreachable:
diff --git a/document/core/binary/modules.rst b/document/core/binary/modules.rst
index 9d24b7203..5e40a1e84 100644
--- a/document/core/binary/modules.rst
+++ b/document/core/binary/modules.rst
@@ -29,7 +29,7 @@ except that :ref:`function definitions <syntax-func>` are split into two section
 Indices
 ~~~~~~~
 
-All :ref:`indices <syntax-index>` are encoded with their respective |U32| value.
+All :ref:`indices <syntax-index>` are encoded with their respective value.
 
 .. math::
    \begin{array}{llclll}
@@ -53,7 +53,7 @@ Sections
 Each section consists of
 
 * a one-byte section *id*,
-* the |U32| *size* of the contents in bytes,
+* the |U32| *size* of the contents, in bytes,
 * the actual *contents*, whose structure is depended on the section id.
 
 Every section is optional; an omitted section is equivalent to the section being present with empty contents.
@@ -64,7 +64,7 @@ The following parameterized grammar rule defines the generic structure of a sect
    \begin{array}{llclll@{\qquad}l}
    \production{section} & \Bsection_N(\B{B}) &::=&
      N{:}\Bbyte~~\X{size}{:}\Bu32~~\X{cont}{:}\B{B}
-       &\Rightarrow& \X{cont} & (\X{size} = ||\B{B}||) \\ &&|&
+       &\Rightarrow& \X{cont} & (\iff \X{size} = ||\B{B}||) \\ &&|&
      \epsilon &\Rightarrow& \epsilon
    \end{array}
 
@@ -76,6 +76,25 @@ In these cases, the empty result :math:`\epsilon` is interpreted as the empty ve
    the :math:`\X{size}` is not required for decoding, but can be used to skip sections when navigating through a binary.
    The module is malformed if the size does not match the length of the binary contents :math:`\B{B}`.
 
+The following section ids are used:
+
+==  ========================================
+Id  Section                                 
+==  ========================================
+ 0  :ref:`custom section <binary-customsec>`
+ 1  :ref:`type section <binary-typesec>`    
+ 2  :ref:`import section <binary-importsec>`
+ 3  :ref:`function section <binary-funcsec>`
+ 4  :ref:`table section <binary-tablesec>`  
+ 5  :ref:`memory section <binary-memsec>`   
+ 6  :ref:`global section <binary-globalsec>`
+ 7  :ref:`export section <binary-exportsec>`
+ 8  :ref:`start section <binary-startsec>`  
+ 9  :ref:`element section <binary-elemsec>` 
+10  :ref:`code section <binary-codesec>`    
+11  :ref:`data section <binary-datasec>`    
+==  ========================================
+
 
 .. index:: ! custom section
    pair: binary format; custom section
@@ -111,7 +130,7 @@ Type Section
 ~~~~~~~~~~~~
 
 The *type section* has the id 1.
-It decodes into a vector of :ref:`function types <syntax-functype>` that represent the |TYPES| component of a :ref:`module <syntax-module>`.
+It decodes into a vector of :ref:`function types <syntax-functype>` that represent the |MTYPES| component of a :ref:`module <syntax-module>`.
 
 .. math::
    \begin{array}{llclll}
@@ -131,7 +150,7 @@ Import Section
 ~~~~~~~~~~~~~~
 
 The *import section* has the id 2.
-It decodes into a vector of :ref:`imports <syntax-import>` that represent the |IMPORTS| component of a :ref:`module <syntax-module>`.
+It decodes into a vector of :ref:`imports <syntax-import>` that represent the |MIMPORTS| component of a :ref:`module <syntax-module>`.
 
 .. math::
    \begin{array}{llclll}
@@ -139,12 +158,12 @@ It decodes into a vector of :ref:`imports <syntax-import>` that represent the |I
      \X{im}^\ast{:}\Bsection_2(\Bvec(\Bimport)) &\Rightarrow& \X{im}^\ast \\
    \production{import} & \Bimport &::=&
      \X{mod}{:}\Bname~~\X{nm}{:}\Bname~~d{:}\Bimportdesc
-       &\Rightarrow& \{ \MODULE~\X{mod}, \NAME~\X{nm}, \DESC~d \} \\
+       &\Rightarrow& \{ \IMODULE~\X{mod}, \INAME~\X{nm}, \IDESC~d \} \\
    \production{import description} & \Bimportdesc &::=&
-     \hex{00}~~x{:}\Btypeidx &\Rightarrow& \FUNC~x \\ &&|&
-     \hex{01}~~\X{tt}{:}\Btabletype &\Rightarrow& \TABLE~\X{tt} \\ &&|&
-     \hex{02}~~\X{mt}{:}\Bmemtype &\Rightarrow& \MEM~\X{mt} \\ &&|&
-     \hex{03}~~\X{gt}{:}\Bglobaltype &\Rightarrow& \GLOBAL~\X{gt} \\
+     \hex{00}~~x{:}\Btypeidx &\Rightarrow& \IDFUNC~x \\ &&|&
+     \hex{01}~~\X{tt}{:}\Btabletype &\Rightarrow& \IDTABLE~\X{tt} \\ &&|&
+     \hex{02}~~\X{mt}{:}\Bmemtype &\Rightarrow& \IDMEM~\X{mt} \\ &&|&
+     \hex{03}~~\X{gt}{:}\Bglobaltype &\Rightarrow& \IDGLOBAL~\X{gt} \\
    \end{array}
 
 
@@ -157,8 +176,8 @@ Function Section
 ~~~~~~~~~~~~~~~~
 
 The *function section* has the id 3.
-It decodes into a vector of :ref:`type indices <syntax-typeidx>` that represent the |TYPE| fields of the :ref:`functions <syntax-func>` in the |FUNCS| component of a :ref:`module <syntax-module>`.
-The |LOCALS| and |BODY| fields of the respective functions are encoded separately in the :ref:`code section <binary-codesec>`.
+It decodes into a vector of :ref:`type indices <syntax-typeidx>` that represent the |FTYPE| fields of the :ref:`functions <syntax-func>` in the |MFUNCS| component of a :ref:`module <syntax-module>`.
+The |FLOCALS| and |FBODY| fields of the respective functions are encoded separately in the :ref:`code section <binary-codesec>`.
 
 .. math::
    \begin{array}{llclll}
@@ -177,14 +196,14 @@ Table Section
 ~~~~~~~~~~~~~
 
 The *table section* has the id 4.
-It decodes into a vector of :ref:`tables <syntax-table>` that represent the |TABLES| component of a :ref:`module <syntax-module>`.
+It decodes into a vector of :ref:`tables <syntax-table>` that represent the |MTABLES| component of a :ref:`module <syntax-module>`.
 
 .. math::
    \begin{array}{llclll}
    \production{table section} & \Btablesec &::=&
      \X{tab}^\ast{:}\Bsection_4(\Bvec(\Btable)) &\Rightarrow& \X{tab}^\ast \\
    \production{table} & \Btable &::=&
-     \X{tt}{:}\Btabletype &\Rightarrow& \{ \TYPE~\X{tt} \} \\
+     \X{tt}{:}\Btabletype &\Rightarrow& \{ \TTYPE~\X{tt} \} \\
    \end{array}
 
 
@@ -198,14 +217,14 @@ Memory Section
 ~~~~~~~~~~~~~~
 
 The *memory section* has the id 5.
-It decodes into a vector of :ref:`memories <syntax-mem>` that represent the |MEMS| component of a :ref:`module <syntax-module>`.
+It decodes into a vector of :ref:`memories <syntax-mem>` that represent the |MMEMS| component of a :ref:`module <syntax-module>`.
 
 .. math::
    \begin{array}{llclll}
    \production{memory section} & \Bmemsec &::=&
      \X{mem}^\ast{:}\Bsection_5(\Bvec(\Bmem)) &\Rightarrow& \X{mem}^\ast \\
    \production{memory} & \Bmem &::=&
-     \X{mt}{:}\Bmemtype &\Rightarrow& \{ \TYPE~\X{mt} \} \\
+     \X{mt}{:}\Bmemtype &\Rightarrow& \{ \MTYPE~\X{mt} \} \\
    \end{array}
 
 
@@ -219,7 +238,7 @@ Global Section
 ~~~~~~~~~~~~~~
 
 The *global section* has the id 6.
-It decodes into a vector of :ref:`globals <syntax-global>` that represent the |GLOBALS| component of a :ref:`module <syntax-module>`.
+It decodes into a vector of :ref:`globals <syntax-global>` that represent the |MGLOBALS| component of a :ref:`module <syntax-module>`.
 
 .. math::
    \begin{array}{llclll}
@@ -227,7 +246,7 @@ It decodes into a vector of :ref:`globals <syntax-global>` that represent the |G
      \X{glob}^\ast{:}\Bsection_6(\Bvec(\Bglobal)) &\Rightarrow& \X{glob}^\ast \\
    \production{global} & \Bglobal &::=&
      \X{gt}{:}\Bglobaltype~~e{:}\Bexpr
-       &\Rightarrow& \{ \TYPE~\X{gt}, \INIT~e \} \\
+       &\Rightarrow& \{ \GTYPE~\X{gt}, \GINIT~e \} \\
    \end{array}
 
 
@@ -242,7 +261,7 @@ Export Section
 ~~~~~~~~~~~~~~
 
 The *export section* has the id 7.
-It decodes into a vector of :ref:`exports <syntax-export>` that represent the |EXPORTS| component of a :ref:`module <syntax-module>`.
+It decodes into a vector of :ref:`exports <syntax-export>` that represent the |MEXPORTS| component of a :ref:`module <syntax-module>`.
 
 .. math::
    \begin{array}{llclll}
@@ -250,12 +269,12 @@ It decodes into a vector of :ref:`exports <syntax-export>` that represent the |E
      \X{ex}^\ast{:}\Bsection_7(\Bvec(\Bexport)) &\Rightarrow& \X{ex}^\ast \\
    \production{export} & \Bexport &::=&
      \X{nm}{:}\Bname~~d{:}\Bexportdesc
-       &\Rightarrow& \{ \NAME~\X{nm}, \DESC~d \} \\
+       &\Rightarrow& \{ \ENAME~\X{nm}, \EDESC~d \} \\
    \production{export description} & \Bexportdesc &::=&
-     \hex{00}~~x{:}\Bfuncidx &\Rightarrow& \FUNC~x \\ &&|&
-     \hex{01}~~x{:}\Btableidx &\Rightarrow& \TABLE~x \\ &&|&
-     \hex{02}~~x{:}\Bmemidx &\Rightarrow& \MEM~x \\ &&|&
-     \hex{03}~~x{:}\Bglobalidx &\Rightarrow& \GLOBAL~x \\
+     \hex{00}~~x{:}\Bfuncidx &\Rightarrow& \EDFUNC~x \\ &&|&
+     \hex{01}~~x{:}\Btableidx &\Rightarrow& \EDTABLE~x \\ &&|&
+     \hex{02}~~x{:}\Bmemidx &\Rightarrow& \EDMEM~x \\ &&|&
+     \hex{03}~~x{:}\Bglobalidx &\Rightarrow& \EDGLOBAL~x \\
    \end{array}
 
 
@@ -270,14 +289,14 @@ Start Section
 ~~~~~~~~~~~~~
 
 The *start section* has the id 8.
-It decodes into an optional :ref:`start function <syntax-start>` that represents the |START| component of a :ref:`module <syntax-module>`.
+It decodes into an optional :ref:`start function <syntax-start>` that represents the |MSTART| component of a :ref:`module <syntax-module>`.
 
 .. math::
    \begin{array}{llclll}
    \production{start section} & \Bstartsec &::=&
      \X{st}^?{:}\Bsection_8(\Bstart) &\Rightarrow& \X{st}^? \\
    \production{start function} & \Bstart &::=&
-     x{:}\Bfuncidx &\Rightarrow& \{ \FUNC~x \} \\
+     x{:}\Bfuncidx &\Rightarrow& \{ \SFUNC~x \} \\
    \end{array}
 
 
@@ -293,7 +312,7 @@ Element Section
 ~~~~~~~~~~~~~~~
 
 The *element section* has the id 9.
-It decodes into a vector of :ref:`element segments <syntax-elem>` that represent the |ELEM| component of a :ref:`module <syntax-module>`.
+It decodes into a vector of :ref:`element segments <syntax-elem>` that represent the |MELEM| component of a :ref:`module <syntax-module>`.
 
 .. math::
    \begin{array}{llclll}
@@ -301,7 +320,7 @@ It decodes into a vector of :ref:`element segments <syntax-elem>` that represent
      \X{seg}^\ast{:}\Bsection_9(\Bvec(\Belem)) &\Rightarrow& \X{seg} \\
    \production{element segment} & \Belem &::=&
      x{:}\Btableidx~~e{:}\Bexpr~~y^\ast{:}\Bvec(\Bfuncidx)
-       &\Rightarrow& \{ \TABLE~x, \OFFSET~e, \INIT~y^\ast \} \\
+       &\Rightarrow& \{ \ETABLE~x, \EOFFSET~e, \EINIT~y^\ast \} \\
    \end{array}
 
 
@@ -319,8 +338,8 @@ Code Section
 
 The *code section* has the id 10.
 It decodes into a vector of *code* entries that are pairs of :ref:`value type <syntax-valtype>` vectors and :ref:`expressions <syntax-expr>`.
-They represent the |LOCALS| and |BODY| field of the :ref:`functions <syntax-func>` in the |FUNCS| component of a :ref:`module <syntax-module>`.
-The |TYPE| fields of the respective functions are encoded separately in the :ref:`function section <binary-funcsec>`.
+They represent the |FLOCALS| and |FBODY| field of the :ref:`functions <syntax-func>` in the |MFUNCS| component of a :ref:`module <syntax-module>`.
+The |FTYPE| fields of the respective functions are encoded separately in the :ref:`function section <binary-funcsec>`.
 
 The encoding of each code entry consists of
 
@@ -344,21 +363,21 @@ denoting *count* locals of the same value type.
        &\Rightarrow& \X{code}^\ast \\
    \production{code} & \Bcode &::=&
      \X{size}{:}\Bu32~~\X{code}{:}\Bfunc
-       &\Rightarrow& \X{code} & (\X{size} = ||\Bfunc||) \\
+       &\Rightarrow& \X{code} & (\iff \X{size} = ||\Bfunc||) \\
    \production{function} & \Bfunc &::=&
      (t^\ast)^\ast{:}\Bvec(\Blocals)~~e{:}\Bexpr
        &\Rightarrow& \concat((t^\ast)^\ast), e^\ast
-         & (|\concat((t^\ast)^\ast)| < 2^{32}) \\
+         & (\iff |\concat((t^\ast)^\ast)| < 2^{32}) \\
    \production{locals} & \Blocals &::=&
      n{:}\Bu32~~t{:}\Bvaltype &\Rightarrow& t^n \\
    \end{array}
 
 Here, :math:`\X{code}` ranges over pairs :math:`(\valtype^\ast, \expr)`.
-The meta function :math:`\F{concat}((t^\ast)^\ast)` concatenates all sequences :math:`t_i^\ast` in :math:`(t^\ast)^\ast`.
+The meta function :math:`\concat((t^\ast)^\ast)` concatenates all sequences :math:`t_i^\ast` in :math:`(t^\ast)^\ast`.
 Any code for which the length of the resulting sequence is out of bounds of the maximum size of a :ref:`vector <syntax-vec>` is malformed.
 
 .. note::
-   The :math:`\X{size}` is not needed for decoding, but like with :ref:`sections <binary-section>`, can be used to skip functions when navigating through a binary.
+   Like with :ref:`sections <binary-section>`, the code :math:`\X{size}` is not needed for decoding, but can be used to skip functions when navigating through a binary.
    The module is malformed if a size does not match the length of the respective function code.
 
 
@@ -374,7 +393,7 @@ Data Section
 ~~~~~~~~~~~~
 
 The *data section* has the id 11.
-It decodes into a vector of :ref:`data segments <syntax-data>` that represent the |DATA| component of a :ref:`module <syntax-module>`.
+It decodes into a vector of :ref:`data segments <syntax-data>` that represent the |MDATA| component of a :ref:`module <syntax-module>`.
 
 .. math::
    \begin{array}{llclll}
@@ -382,7 +401,7 @@ It decodes into a vector of :ref:`data segments <syntax-data>` that represent th
      \X{seg}^\ast{:}\Bsection_{11}(\Bvec(\Bdata)) &\Rightarrow& \X{seg} \\
    \production{data segment} & \Bdata &::=&
      x{:}\Bmemidx~~e{:}\Bexpr~~b^\ast{:}\Bvec(\Bbyte)
-       &\Rightarrow& \{ \MEM~x, \OFFSET~e, \INIT~b^\ast \} \\
+       &\Rightarrow& \{ \DMEM~x, \DOFFSET~e, \DINIT~b^\ast \} \\
    \end{array}
 
 
@@ -438,26 +457,27 @@ The lengths of vectors produced by the (possibly empty) :ref:`function <binary-f
      \Bcustomsec^\ast
      \quad\Rightarrow\quad \{~
        \begin{array}[t]{@{}l@{}}
-       \TYPES~\functype^\ast, \\
-       \FUNCS~\func^n, \\
-       \TABLES~\table^\ast, \\
-       \MEMS~\mem^\ast, \\
-       \GLOBALS~\global^\ast, \\
-       \ELEM~\elem^\ast, \\
-       \DATA~\data^\ast, \\
-       \START~\start^?, \\
-       \IMPORTS~\import^\ast, \\
-       \EXPORTS~\export^\ast ~\} \\
+       \MTYPES~\functype^\ast, \\
+       \MFUNCS~\func^n, \\
+       \MTABLES~\table^\ast, \\
+       \MMEMS~\mem^\ast, \\
+       \MGLOBALS~\global^\ast, \\
+       \MELEM~\elem^\ast, \\
+       \MDATA~\data^\ast, \\
+       \MSTART~\start^?, \\
+       \MIMPORTS~\import^\ast, \\
+       \MEXPORTS~\export^\ast ~\} \\
       \end{array} \\
-   &&& (\begin{array}[t]{@{}l@{}}
-        \mbox{where for each $t_i^\ast, e_i$ in $\X{code}^n$,} \\
-        \func^n[i] = \{ \TYPE~\typeidx^n[i], \LOCALS~t_i^\ast, \BODY~e_i \} ) \\
-        \end{array}
    \end{array}
 
+where for each :math:`t_i^\ast, e_i` in :math:`\X{code}^n`,
+
+.. math::
+   \func^n[i] = \{ \FTYPE~\typeidx^n[i], \FLOCALS~t_i^\ast, \FBODY~e_i \} ) \\
+
 .. note::
    The version of the WebAssembly binary format may increase in the future
-   if backward-incompatible changes are made to the format.
+   if backward-incompatible changes have to be made to the format.
    However, such changes are expected to occur very infrequently, if ever.
    The binary format is intended to be forward-compatible,
    such that future extensions can be made without incrementing its version.
diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index 14a98f645..e5342259c 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -25,7 +25,7 @@ Value Types
 
 .. note::
    In future versions of WebAssembly, value types may include types denoted by :ref:`type indices <syntax-typeidx>`.
-   Thus, the binary format for types corresponds to the encodings of small negative :math:`\xref{binary/values}{binary-sint}{\sX{}}` values, so that they can coexist with (positive) type indices.
+   Thus, the binary format for types corresponds to the encodings of small negative :math:`\xref{binary/values}{binary-sint}{\sN}` values, so that they can coexist with (positive) type indices in the future.
 
 
 .. index:: result type, value type
@@ -78,8 +78,8 @@ Limits
 .. math::
    \begin{array}{llclll}
    \production{limits} & \Blimits &::=&
-     \hex{00}~~n{:}\Bu32 &\Rightarrow& \{ \MIN~n, \MAX~\epsilon \} \\ &&|&
-     \hex{01}~~n{:}\Bu32~~m{:}\Bu32 &\Rightarrow& \{ \MIN~n, \MAX~m \} \\
+     \hex{00}~~n{:}\Bu32 &\Rightarrow& \{ \LMIN~n, \LMAX~\epsilon \} \\ &&|&
+     \hex{01}~~n{:}\Bu32~~m{:}\Bu32 &\Rightarrow& \{ \LMIN~n, \LMAX~m \} \\
    \end{array}
 
 
diff --git a/document/core/binary/values.rst b/document/core/binary/values.rst
index 2c24c3fe3..4efce6ffb 100644
--- a/document/core/binary/values.rst
+++ b/document/core/binary/values.rst
@@ -24,7 +24,7 @@ Bytes
    \end{array}
 
 
-.. index:: integer, unsigned integer, signed integer, uninterpreted integer, LEB128
+.. index:: integer, unsigned integer, signed integer, uninterpreted integer, LEB128, two's complement
    pair: binary format; integer
    pair: binary format; unsigned integer
    pair: binary format; signed integer
@@ -44,21 +44,21 @@ As an additional constraint, the total number of bytes encoding a value of type
 .. math::
    \begin{array}{llclll@{\qquad}l}
    \production{unsigned integer} & \BuN &::=&
-     n{:}\Bbyte &\Rightarrow& n & (n < 2^7 \wedge n < 2^N) \\ &&|&
+     n{:}\Bbyte &\Rightarrow& n & (\iff n < 2^7 \wedge n < 2^N) \\ &&|&
      n{:}\Bbyte~~m{:}\BuX{(N\B{-7})} &\Rightarrow&
-       2^7\cdot m + (n-2^7) & (n \geq 2^7 \wedge N > 7) \\
+       2^7\cdot m + (n-2^7) & (\iff n \geq 2^7 \wedge N > 7) \\
    \end{array}
 
-:ref:`Signed integers <syntax-sint>` are encoded in `signed LEB128 <https://en.wikipedia.org/wiki/LEB128#Signed_LEB128>`_ format, which uses a 2's complement representation.
+:ref:`Signed integers <syntax-sint>` are encoded in `signed LEB128 <https://en.wikipedia.org/wiki/LEB128#Signed_LEB128>`_ format, which uses a two's complement representation.
 As an additional constraint, the total number of bytes encoding a value of type :math:`\sN` must not exceed :math:`\F{ceil}(N/7)` bytes.
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
    \production{signed integer} & \BsN &::=&
-     n{:}\Bbyte &\Rightarrow& n & (n < 2^6 \wedge n < 2^{N-1}) \\ &&|&
-     n{:}\Bbyte &\Rightarrow& n-2^7 & (2^6 \leq n < 2^7 \wedge n \geq 2^7-2^{N-1}) \\ &&|&
+     n{:}\Bbyte &\Rightarrow& n & (\iff n < 2^6 \wedge n < 2^{N-1}) \\ &&|&
+     n{:}\Bbyte &\Rightarrow& n-2^7 & (\iff 2^6 \leq n < 2^7 \wedge n \geq 2^7-2^{N-1}) \\ &&|&
      n{:}\Bbyte~~m{:}\BsX{(N\B{-7})} &\Rightarrow&
-       2^7\cdot m + (n-2^7) & (n \geq 2^7 \wedge N > 7) \\
+       2^7\cdot m + (n-2^7) & (\iff n \geq 2^7 \wedge N > 7) \\
    \end{array}
 
 :ref:`Uninterpreted integers <syntax-int>` are encoded as signed integers.
@@ -66,92 +66,77 @@ As an additional constraint, the total number of bytes encoding a value of type
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
    \production{uninterpreted integer} & \BiN &::=&
-     n{:}\BsN &\Rightarrow& i & (n = \signed_{\iN}(i))
+     n{:}\BsN &\Rightarrow& i & (\iff n = \signed_{\iN}(i))
    \end{array}
 
 .. note::
-   While the side conditions :math:`N > 7` in the productions for *non-terminating* bytes restrict the length of the :math:`\uX{}` and :math:`\sX{}` encodings,
-   "trailing zeros" are still allowed within these bounds.
+   The side conditions :math:`N > 7` in the productions for non-terminal bytes of the :math:`\uX{}` and :math:`\sX{}` encodings restrict the encoding's length.
+   However, "trailing zeros" are still allowed within these bounds.
    For example, :math:`\hex{03}` and :math:`\hex{83}~\hex{00}` are both well-formed encodings for the value :math:`3` as a |u8|.
    Similarly, either of :math:`\hex{7e}` and :math:`\hex{FE}~\hex{7F}` and :math:`\hex{FE}~\hex{FF}~\hex{7F}` are well-formed encodings of the value :math:`-2` as a |s16|.
 
-   The side conditions on the value :math:`n` of *terminating* bytes further enforce that
+   The side conditions on the value :math:`n` of terminal bytes further enforce that
    any unused bits in these bytes must be :math:`0` for positive values and :math:`1` for negative ones.
    For example, :math:`\hex{83}~\hex{10}` is malformed as a |u8| encoding.
    Similarly, both :math:`\hex{83}~\hex{3E}` and :math:`\hex{FF}~\hex{7B}` are malformed as |s8| encodings.
 
 
-.. index:: floating-point number
+.. index:: floating-point number, little endian
    pair: binary format; floating-point number
 .. _binary-float:
 
 Floating-Point
 ~~~~~~~~~~~~~~
 
-:ref:`Floating point <syntax-float>` values are encoded by their `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ bit pattern in `little endian <https://en.wikipedia.org/wiki/Endianness#Little-endian>`_ byte order:
+:ref:`Floating-point <syntax-float>` values are encoded directly by their `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ bit pattern in `little endian <https://en.wikipedia.org/wiki/Endianness#Little-endian>`_ byte order:
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{floating-point number} & \BfN &::=&
-     b^\ast{:\,}\Bbyte^{N/8} &\Rightarrow& \bytes_{\fN}^{-1}(\F{reverse}(b^\ast)) \\
+   \production{floating-point value} & \BfN &::=&
+     b^\ast{:\,}\Bbyte^{N/8} &\Rightarrow& \bytes_{\fN}^{-1}(b^\ast) \\
    \end{array}
 
-Here, :math:`\F{reverse}(b^\ast)` denotes the byte sequence :math:`b^\ast` in reversed order.
 
-
-.. index:: vector
-   pair: binary format; vector
-.. _binary-vec:
-
-Vectors
-~~~~~~~
-
-:ref:`Vectors <syntax-vec>` are encoded with their length followed by the encoding of their element sequence.
-
-.. math::
-   \begin{array}{llclll@{\qquad\qquad}l}
-   \production{vector} & \Bvec(\B{B}) &::=&
-     n{:}\Bu32~~(x{:}\B{B})^n &\Rightarrow& x^n \\
-   \end{array}
-
-
-.. index:: name, byte, Unicode, UTF-8
+.. index:: name, byte, Unicode, ! UTF-8
    pair: binary format; name
+.. _binary-utf8:
 .. _binary-name:
 
 Names
 ~~~~~
 
-:ref:`Names <syntax-name>` are encoded like a :ref:`vector <binary-vec>` of bytes containing the `Unicode <http://www.unicode.org/versions/latest/>`_ UTF-8 encoding of the name's code point sequence.
+:ref:`Names <syntax-name>` are encoded as a :ref:`vector <binary-vec>` of bytes containing the `Unicode <http://www.unicode.org/versions/latest/>`_ UTF-8 encoding of the name's code point sequence.
 
 .. math::
-   \begin{array}{llclll@{\qquad}l}
+   \begin{array}{llclllll}
    \production{name} & \Bname &::=&
-     n{:}\Bu32~~(\X{uc}{:}\Bcodepoint)^\ast &\Rightarrow& \X{uc}^\ast
-       & (|\Bcodepoint^\ast| = n) \\
-   \production{code point} & \Bcodepoint &::=&
-     \X{uv}{:}\Bcodeval_N &\Rightarrow& \X{uv}
-       & (\X{uv} \geq N \wedge (\X{uv} < \unicode{D800} \vee \unicode{E000} \leq \X{uv} < \unicode{110000})) \\
-   \production{code value} & \Bcodeval_N &::=&
-     b_1{:}\Bbyte &\Rightarrow&
-       b_1
-       & (b_1 < \hex{80} \wedge N = \unicode{00}) \\ &&|&
-     b_1{:}\Bbyte~~b_2{:}\Bcodecont &\Rightarrow&
-       2^6\cdot(b_1-\hex{c0}) + b_2
-       & (\hex{c0} \leq b_1 < \hex{e0} \wedge N = \unicode{80}) \\ &&|&
-     b_1{:}\Bbyte~~b_2{:}\Bcodecont~~b_3{:}\Bcodecont &\Rightarrow&
-       2^{12}\cdot(b_1-\hex{e0}) + 2^6\cdot b_2 + b_3
-       & (\hex{e0} \leq b_1 < \hex{f0} \wedge N = \unicode{800}) \\ &&|&
-     b_1{:}\Bbyte~~b_2{:}\Bcodecont~~b_3{:}\Bcodecont~~b_4{:}\Bcodecont
-       &\Rightarrow&
-       2^{18}\cdot(b_1-\hex{f0}) + 2^{12}\cdot b_2 + 2^6\cdot b_3 + b_4
-       & (\hex{f0} \leq b_1 < \hex{f8} \wedge N = \unicode{10000}) \\
-   \production{code continuation} & \Bcodecont &::=&
-     b{:}\Bbyte &\Rightarrow& b - \hex{80} & (b \geq \hex{80}) \\
+     b^\ast{:}\Bvec(\Bbyte) &\Rightarrow& \name
+       && (\iff \utf8(\name) = b^\ast) \\
    \end{array}
 
-.. note::
-   The :ref:`size <binary-notation>`, :math:`||\Bcodepoint^\ast||` denotes the number of bytes in the encoding of the sequence, not the number of code points.
+The auxiliary |utf8| function expressing this encoding is defined as follows:
 
-   The index :math:`N` to |Bcodeval| is the minimum value that a given byte sequence may decode into.
-   The respective side conditions on it exclude encodings using more than the minimal number of bytes to represent a code point.
+.. math::
+   \begin{array}{@{}lcl@{\qquad}l}
+   \utf8(c^\ast) &=& (\utf8(c))^\ast \\[1ex]
+   \utf8(c) &=& b &
+     (\begin{array}[t]{@{}c@{~}l@{}}
+      \iff & c < \unicode{80} \\
+      \wedge & c = b) \\
+      \end{array} \\
+   \utf8(c) &=& b_1~b_2 &
+     (\begin{array}[t]{@{}c@{~}l@{}}
+      \iff & \unicode{80} \leq c < \unicode{800} \\
+      \wedge & c = 2^6(b_1-\hex{C0})+(b_2-\hex{80})) \\
+      \end{array} \\
+   \utf8(c) &=& b_1~b_2~b_3 &
+     (\begin{array}[t]{@{}c@{~}l@{}}
+      \iff & \unicode{800} \leq c < \unicode{10000} \\
+      \wedge & c = 2^{12}(b_1-\hex{C0})+2^6(b_2-\hex{80})+(b_3-\hex{80})) \\
+      \end{array} \\
+   \utf8(c) &=& b_1~b_2~b_3~b_4 &
+     (\begin{array}[t]{@{}c@{~}l@{}}
+      \iff & \unicode{10000} \leq c < \unicode{110000} \\
+      \wedge & c = 2^{18}(b_1-\hex{C0})+2^{12}(b_2-\hex{80})+2^6(b_3-\hex{80})+(b_4-\hex{80})) \\
+      \end{array} \\
+   \end{array}
diff --git a/document/core/conf.py b/document/core/conf.py
index 8ea16cd72..9a0d4e80f 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -157,6 +157,7 @@
   ]
 }
 
+
 # Add any paths that contain custom themes here, relative to this directory.
 # html_theme_path = []
 
diff --git a/document/core/exec/conventions.rst b/document/core/exec/conventions.rst
index 12afc8004..d054e1919 100644
--- a/document/core/exec/conventions.rst
+++ b/document/core/exec/conventions.rst
@@ -20,8 +20,6 @@ As with :ref:`validation <validation>`, all rules are given in two *equivalent*
    so that understanding of the formal notation is *not* required to read this specification.
    The formalism offers a more concise description in notation that is used widely in programming languages semantics and is readily amenable to mathematical proof.
 
-:ref:`Store <store>`, :ref:`stack <stack>`, and other *runtime structure*, such as :ref:`module instances <syntax-moduleinst>`, are made precise in terms of additional auxiliary :ref:`syntax <syntax-runtime>`.
-
 
 .. _exec-notation-textual:
 
@@ -49,14 +47,14 @@ The following conventions are adopted in stating these rules.
 * The execution of an instruction may also end in a *jump* to a designated target,
   which defines the next instruction to execute.
 
-* Execution can *enter* and *exit* :ref:`instruction sequences <syntax-instr-seq>` in a block-like fashion.
+* Execution can *enter* and *exit* :ref:`instruction sequences <syntax-instr-seq>` that form :ref:`blocks <syntax-instr-control>`.
 
 * :ref:`Instruction sequences <syntax-instr-seq>` are implicitly executed in order, unless a trap or jump occurs.
 
-* In various places the rules contain *assertions* expressing crucial invariants about the program state, with indications why these are known to hold.
+* In various places the rules contain *assertions* expressing crucial invariants about the program state.
 
 
-.. index:: ! reduction rules, ! configuration
+.. index:: ! reduction rules, ! configuration, evaluation context
 .. _exec-notation:
 
 Formal Notation
@@ -87,7 +85,7 @@ In particular, :ref:`values <syntax-val>` are defined to coincide with |CONST| i
 and a sequence of |CONST| instructions can be interpreted as an operand "stack" that grows to the right.
 
 .. note::
-   For example, the :ref:`reduction rule <exec-binop>` for the :math:`\I32.\ADD` instruction could be given as follows:
+   For example, the :ref:`reduction rule <exec-binop>` for the :math:`\I32.\ADD` instruction can be given as follows:
 
    .. math::
       (\I32.\CONST~n_1)~(\I32.\CONST~n_2)~\I32.\ADD \quad\stepto\quad (\I32.\CONST~(n_1 + n_2) \mod 2^{32})
@@ -100,13 +98,13 @@ and a sequence of |CONST| instructions can be interpreted as an operand "stack"
    .. math::
       \NOP \quad\stepto\quad \epsilon
 
-:ref:`Labels <label>` and :ref:`frames <frame>` are similarly :ref:`defined to be part <syntax-instr-admin>` of an instruction sequence.
+:ref:`Labels <label>` and :ref:`frames <frame>` are similarly :ref:`defined <syntax-instr-admin>` to be part of an instruction sequence.
 
-The order of reduction is determined by the definition of an approporiate :ref:`evaluation context <syntax-ctxt-eval>`.
+The order of reduction is determined by the definition of an appropriate :ref:`evaluation context <syntax-ctxt-eval>`.
 
 Reduction *terminates* when no more reduction rules are applicable.
 :ref:`Soundness <soundness>` of the WebAssembly :ref:`type system <type-system>` guarantees that this is only the case when the original instruction sequence has either been reduced to a sequence of |CONST| instructions, which can be interpreted as the :ref:`values <syntax-val>` of the resulting operand stack,
-or if a trap occurred.
+or if a :ref:`trap <syntax-trap>` occurred.
 
 .. note::
    For example, the following instruction sequence,
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index eaad95faa..7d20577b1 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1,11 +1,13 @@
-.. index:: instruction, function type, store
+.. index:: instruction, function type, store, validation
 .. _exec-instr:
 
 Instructions
 ------------
 
+WebAssembly computation is performed by executing individual :ref:`instructions <syntax-instr>`.
 
-.. index:: numeric instruction
+
+.. index:: numeric instruction, determinism, trap, NaN, value, value type
    pair: execution; instruction
    single: abstract syntax; instruction
 .. _exec-instr-numeric:
@@ -14,9 +16,6 @@ Numeric Instructions
 ~~~~~~~~~~~~~~~~~~~~
 
 Numeric instructions are defined in terms of the basic :ref:`numeric operators <exec-numeric>`.
-Where these operators are partial, the corresponding instruction will :ref:`trap <trap>` when the result is not defined.
-Where these operators are non-deterministic, because they may return different :ref:`NaN <syntax-nan>` values, so are the corresponding instructions.
-
 The mapping of numeric instructions to their underlying operators is expressed by the following definition:
 
 .. math::
@@ -25,6 +24,9 @@ The mapping of numeric instructions to their underlying operators is expressed b
    \X{op}_{\K{f}N}(z) &=& \F{f}\X{op}_N(z) \\
    \end{array}
 
+Where the underlying operators are partial, the corresponding instruction will :ref:`trap <trap>` when the result is not defined.
+Where the underlying operators are non-deterministic, because they may return one of multiple possible :ref:`NaN <syntax-nan>` values, so are the corresponding instructions.
+
 
 .. _exec-const:
 
@@ -48,7 +50,7 @@ The mapping of numeric instructions to their underlying operators is expressed b
 
 3. If :math:`\unop_t(c_1)` is defined, then:
 
-   a. Let :math:`c` be the result of computing :math:`\unop_t(c_1)`.
+   a. Let :math:`c` be a possible result of computing :math:`\unop_t(c_1)`.
 
    b. Push the value :math:`t.\CONST~c` to the stack.
 
@@ -59,9 +61,9 @@ The mapping of numeric instructions to their underlying operators is expressed b
 .. math::
    \begin{array}{lcl@{\qquad}l}
    (t\K{.}\CONST~c_1)~t\K{.}\unop &\stepto& (t\K{.}\CONST~c)
-     & (\mbox{if}~c \in \unop_t(c_1)) \\
+     & (\iff c \in \unop_t(c_1)) \\
    (t\K{.}\CONST~c_1)~t\K{.}\unop &\stepto& \TRAP
-     & (\mbox{if}~\unop_{t_1,t_2}(c_1) = \{\})
+     & (\iff \unop_{t_1,t_2}(c_1) = \{\})
    \end{array}
 
 
@@ -78,7 +80,7 @@ The mapping of numeric instructions to their underlying operators is expressed b
 
 4. If :math:`\binop_t(c_1, c_2)` is defined, then:
 
-   a. Let :math:`c` be the result of computing :math:`\binop_t(c_1, c_2)`.
+   a. Let :math:`c` be a possible result of computing :math:`\binop_t(c_1, c_2)`.
 
    b. Push the value :math:`t.\CONST~c` to the stack.
 
@@ -89,9 +91,9 @@ The mapping of numeric instructions to their underlying operators is expressed b
 .. math::
    \begin{array}{lcl@{\qquad}l}
    (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\binop &\stepto& (t\K{.}\CONST~c)
-     & (\mbox{if}~c \in \binop_t(c_1,c_2)) \\
+     & (\iff c \in \binop_t(c_1,c_2)) \\
    (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\binop &\stepto& \TRAP
-     & (\mbox{if}~\binop_{t_1,t_2}(c_1) = \{\})
+     & (\iff \binop_{t_1,t_2}(c_1) = \{\})
    \end{array}
 
 
@@ -111,7 +113,7 @@ The mapping of numeric instructions to their underlying operators is expressed b
 .. math::
    \begin{array}{lcl@{\qquad}l}
    (t\K{.}\CONST~c_1)~t\K{.}\testop &\stepto& (\I32\K{.}\CONST~c)
-     & (\mbox{if}~c = \testop_t(c_1)) \\
+     & (\iff c = \testop_t(c_1)) \\
    \end{array}
 
 
@@ -133,7 +135,7 @@ The mapping of numeric instructions to their underlying operators is expressed b
 .. math::
    \begin{array}{lcl@{\qquad}l}
    (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\relop &\stepto& (\I32\K{.}\CONST~c)
-     & (\mbox{if}~c = \relop_t(c_1,c_2)) \\
+     & (\iff c = \relop_t(c_1,c_2)) \\
    \end{array}
 
 
@@ -148,7 +150,7 @@ The mapping of numeric instructions to their underlying operators is expressed b
 
 3. If :math:`\cvtop_{t_1,t_2}(c_1)` is defined:
 
-   a. Let :math:`c_2` be the result of computing :math:`\cvtop_{t_1,t_2}(c_1)`.
+   a. Let :math:`c_2` be a possible result of computing :math:`\cvtop_{t_1,t_2}(c_1)`.
 
    b. Push the value :math:`t_2.\CONST~c_2` to the stack.
 
@@ -159,13 +161,13 @@ The mapping of numeric instructions to their underlying operators is expressed b
 .. math::
    \begin{array}{lcl@{\qquad}l}
    (t\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& (t_2\K{.}\CONST~c_2)
-     & (\mbox{if}~c_2 \in \cvtop_{t_1,t_2}(c_1)) \\
+     & (\iff c_2 \in \cvtop_{t_1,t_2}(c_1)) \\
    (t\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& \TRAP
-     & (\mbox{if}~\cvtop_{t_1,t_2}(c_1) = \{\})
+     & (\iff \cvtop_{t_1,t_2}(c_1) = \{\})
    \end{array}
 
 
-.. index:: parametric instructions
+.. index:: parametric instructions, value
    pair: execution; instruction
    single: abstract syntax; instruction
 .. _exec-instr-parametric:
@@ -214,13 +216,13 @@ Parametric Instructions
 .. math::
    \begin{array}{lcl@{\qquad}l}
    \val_1~\val_2~(\I32\K{.}\CONST~c)~\SELECT &\stepto& \val_1
-     & (\mbox{if}~c \neq 0) \\
+     & (\iff c \neq 0) \\
    \val_1~\val_2~(\I32\K{.}\CONST~c)~\SELECT &\stepto& \val_2
-     & (\mbox{if}~c = 0) \\
+     & (\iff c = 0) \\
    \end{array}
 
 
-.. index:: variable instructions, local index, global index, address, global address, global instance, store, frame
+.. index:: variable instructions, local index, global index, address, global address, global instance, store, frame, value
    pair: execution; instruction
    single: abstract syntax; instruction
 .. _exec-instr-variable:
@@ -235,16 +237,16 @@ Variable Instructions
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-get_local>`, :math:`F.\LOCALS[x]` exists.
+2. Assert: due to :ref:`validation <valid-get_local>`, :math:`F.\ALOCALS[x]` exists.
 
-3. Let :math:`\val` be the value :math:`F.\LOCALS[x]`.
+3. Let :math:`\val` be the value :math:`F.\ALOCALS[x]`.
 
 4. Push the value :math:`\val` to the stack.
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
    F; (\GETLOCAL~x) &\stepto& F; \val
-     & (\mbox{if}~F.\LOCALS[x] = \val) \\
+     & (\iff F.\ALOCALS[x] = \val) \\
    \end{array}
 
 
@@ -255,18 +257,18 @@ Variable Instructions
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-set_local>`, :math:`F.\LOCALS[x]` exists.
+2. Assert: due to :ref:`validation <valid-set_local>`, :math:`F.\ALOCALS[x]` exists.
 
 3. Assert: due to :ref:`validation <valid-set_local>`, a value is on the top of the stack.
 
 4. Pop the value :math:`\val` from the stack.
 
-5. Replace :math:`F.\LOCALS[x]` with the value :math:`\val`.
+5. Replace :math:`F.\ALOCALS[x]` with the value :math:`\val`.
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
    F; \val~(\SETLOCAL~x) &\stepto& F'; \epsilon
-     & (\mbox{if}~F' = F \with \LOCALS[x] = \val) \\
+     & (\iff F' = F \with \ALOCALS[x] = \val) \\
    \end{array}
 
 
@@ -298,15 +300,15 @@ Variable Instructions
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-get_global>`, :math:`F.\MODULE.\GLOBALS[x]` exists.
+2. Assert: due to :ref:`validation <valid-get_global>`, :math:`F.\AMODULE.\MIGLOBALS[x]` exists.
 
-3. Let :math:`a` be the :ref:`global address <syntax-globaladdr>` :math:`F.\MODULE.\GLOBALS[x]`.
+3. Let :math:`a` be the :ref:`global address <syntax-globaladdr>` :math:`F.\AMODULE.\MIGLOBALS[x]`.
 
-4. Assert: due to :ref:`validation <valid-get_global>`, :math:`S.\GLOBALS[a]` exists.
+4. Assert: due to :ref:`validation <valid-get_global>`, :math:`S.\SGLOBALS[a]` exists.
 
-5. Let :math:`\X{glob}` be the :ref:`global instance <syntax-globalinst>` :math:`S.\GLOBALS[a]`.
+5. Let :math:`\X{glob}` be the :ref:`global instance <syntax-globalinst>` :math:`S.\SGLOBALS[a]`.
 
-6. Let :math:`\val` be the value :math:`\X{glob}.\VALUE`.
+6. Let :math:`\val` be the value :math:`\X{glob}.\GIVALUE`.
 
 7. Push the value :math:`\val` to the stack.
 
@@ -316,7 +318,7 @@ Variable Instructions
    S; F; (\GETGLOBAL~x) &\stepto& S; F; \val
    \end{array}
    \\ \qquad
-     (\mbox{if}~S.\GLOBALS[F.\MODULE.\GLOBALS[x]].\VALUE = \val) \\
+     (\iff S.\SGLOBALS[F.\AMODULE.\MIGLOBALS[x]].\GIVALUE = \val) \\
    \end{array}
 
 
@@ -327,19 +329,19 @@ Variable Instructions
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-set_global>`, :math:`F.\MODULE.\GLOBALS[x]` exists.
+2. Assert: due to :ref:`validation <valid-set_global>`, :math:`F.\AMODULE.\MIGLOBALS[x]` exists.
 
-3. Let :math:`a` be the :ref:`global address <syntax-globaladdr>` :math:`F.\MODULE.\GLOBALS[x]`.
+3. Let :math:`a` be the :ref:`global address <syntax-globaladdr>` :math:`F.\AMODULE.\MIGLOBALS[x]`.
 
-4. Assert: due to :ref:`validation <valid-set_global>`, :math:`S.\GLOBALS[a]` exists.
+4. Assert: due to :ref:`validation <valid-set_global>`, :math:`S.\SGLOBALS[a]` exists.
 
-5. Let :math:`\X{glob}` be the :ref:`global instance <syntax-globalinst>` :math:`S.\GLOBALS[a]`.
+5. Let :math:`\X{glob}` be the :ref:`global instance <syntax-globalinst>` :math:`S.\SGLOBALS[a]`.
 
 6. Assert: due to :ref:`validation <valid-set_global>`, a value is on the top of the stack.
 
 7. Pop the value :math:`\val` from the stack.
 
-8. Replace :math:`\X{glob}.\VALUE` with the value :math:`\val`.
+8. Replace :math:`\X{glob}.\GIVALUE` with the value :math:`\val`.
 
 .. math::
    \begin{array}{l}
@@ -347,11 +349,11 @@ Variable Instructions
    S; F; \val~(\SETGLOBAL~x) &\stepto& S'; F; \epsilon
    \end{array}
    \\ \qquad
-   (\mbox{if}~S' = S \with \GLOBALS[F.\MODULE.\GLOBALS[x]].\VALUE = \val) \\
+   (\iff S' = S \with \SGLOBALS[F.\AMODULE.\MIGLOBALS[x]].\GIVALUE = \val) \\
    \end{array}
 
 
-.. index:: memory instruction, memory index, store, frame, address, memory address, memory instance, store, frame, value type, width
+.. index:: memory instruction, memory index, store, frame, address, memory address, memory instance, store, frame, value, integer, limits, value type, bit width
    pair: execution; instruction
    single: abstract syntax; instruction
 .. _exec-memarg:
@@ -368,15 +370,15 @@ Memory Instructions
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-loadn>`, :math:`F.\MODULE.\MEMS[0]` exists.
+2. Assert: due to :ref:`validation <valid-loadn>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
 
-3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\MODULE.\MEMS[0]`.
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
 
-4. Assert: due to :ref:`validation <valid-loadn>`, :math:`S.\MEMS[a]` exists.
+4. Assert: due to :ref:`validation <valid-loadn>`, :math:`S.\SMEMS[a]` exists.
 
-5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\MEMS[a]`.
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
 
-6. Assert: due to :ref:`validation <valid-loadn>`, a value :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+6. Assert: due to :ref:`validation <valid-loadn>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
 7. Pop the value :math:`\I32.\CONST~i` from the stack.
 
@@ -384,13 +386,13 @@ Memory Instructions
 
 9. If :math:`N` is not part of the instruction, then:
 
-   a. Let :math:`N` be the :ref:`width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
+   a. Let :math:`N` be the :ref:`bit width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
 
-10. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\DATA`, then:
+10. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
 
     a. Trap.
 
-11. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\DATA[\X{ea}:N/8]`.
+11. Let :math:`b^\ast` be the byte sequence :math:`\X{mem}.\MIDATA[\X{ea} \slice N/8]`.
 
 12. If :math:`N` and :math:`\sx` are part of the instruction, then:
 
@@ -405,6 +407,7 @@ Memory Instructions
 14. Push the value :math:`t.\CONST~c` to the stack.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~i)~(t.\LOAD~\memarg) &\stepto& S; F; (t.\CONST~c)
@@ -412,9 +415,10 @@ Memory Instructions
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
-     \wedge & \X{ea} + |t|/8 \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
-     \wedge & \bytes_t(c) = S.\MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:|t|/8])
-     \end{array} \\
+     \wedge & \X{ea} + |t|/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & \bytes_t(c) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice |t|/8])
+     \end{array}
+   \\[1ex]
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~i)~(t.\LOAD{N}\K{\_}\sx~\memarg) &\stepto&
      S; F; (t.\CONST~\extend\F{\_}\sx_{N,|t|}(n))
@@ -422,14 +426,15 @@ Memory Instructions
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
-     \wedge & \X{ea} + N/8 \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
-     \wedge & \bytes_{\iN}(n) = S.\MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:N/8])
-     \end{array} \\
+     \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & \bytes_{\iN}(n) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8])
+     \end{array}
+   \\[1ex]
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~k)~(t.\LOAD({N}\K{\_}\sx)^?~\memarg) &\stepto& S; F; \TRAP
    \end{array}
    \\ \qquad
-     (\mbox{otherwise}) \\
+     (\otherwise) \\
    \end{array}
 
 .. note::
@@ -446,31 +451,31 @@ Memory Instructions
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-storen>`, :math:`F.\MODULE.\MEMS[0]` exists.
+2. Assert: due to :ref:`validation <valid-storen>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
 
-3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\MODULE.\MEMS[0]`.
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
 
-4. Assert: due to :ref:`validation <valid-storen>`, :math:`S.\MEMS[a]` exists.
+4. Assert: due to :ref:`validation <valid-storen>`, :math:`S.\SMEMS[a]` exists.
 
-5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\MEMS[a]`.
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
 
-6. Assert: due to :ref:`validation <valid-storen>`, a value :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+6. Assert: due to :ref:`validation <valid-storen>`, a value of :ref:`value type <syntax-valtype>` :math:`t` is on the top of the stack.
 
-7. Pop the value :math:`\I32.\CONST~i` from the stack.
+7. Pop the value :math:`t.\CONST~c` from the stack.
 
-8. Let :math:`\X{ea}` be :math:`i + \memarg.\OFFSET`.
+8. Assert: due to :ref:`validation <valid-storen>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
-9. If :math:`N` is not part of the instruction, then:
+9. Pop the value :math:`\I32.\CONST~i` from the stack.
 
-   a. Let :math:`N` be the :ref:`width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
+10. Let :math:`\X{ea}` be :math:`i + \memarg.\OFFSET`.
 
-10. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\DATA`, then:
+11. If :math:`N` is not part of the instruction, then:
 
-    a. Trap.
+    a. Let :math:`N` be the :ref:`bit width <syntax-valtype>` :math:`|t|` of :ref:`value type <syntax-valtype>` :math:`t`.
 
-11. Assert: due to :ref:`validation <valid-storen>`, a value of :ref:`value type <syntax-valtype>` :math:`t` is on the top of the stack.
+12. If :math:`\X{ea} + N/8` is larger than the length of :math:`\X{mem}.\MIDATA`, then:
 
-12. Pop the value :math:`t.\CONST~c` from the stack.
+    a. Trap.
 
 13. If :math:`N` is part of the instruction, then:
 
@@ -482,33 +487,36 @@ Memory Instructions
 
     a. Let :math:`b^\ast` be the byte sequence :math:`\bytes_t(c)`.
 
-15. Replace the bytes :math:`\X{mem}.\DATA[\X{ea}:N/8]` with :math:`b^\ast`.
+15. Replace the bytes :math:`\X{mem}.\MIDATA[\X{ea} \slice N/8]` with :math:`b^\ast`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~i)~(t.\STORE~\memarg) &\stepto& S'; F; \epsilon
+   S; F; (\I32.\CONST~i)~(t.\CONST~c)~(t.\STORE~\memarg) &\stepto& S'; F; \epsilon
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
-     \wedge & \X{ea} + |t|/8 \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
-     \wedge & S' = S \with \MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:|t|/8] = \bytes_t(c)
-     \end{array} \\
+     \wedge & \X{ea} + |t|/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & S' = S \with \MIMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice |t|/8] = \bytes_t(c)
+     \end{array}
+   \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~i)~(t.\STORE{N}~\memarg) &\stepto& S'; F; \epsilon
+   S; F; (\I32.\CONST~i)~(t.\CONST~c)~(t.\STORE{N}~\memarg) &\stepto& S'; F; \epsilon
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
-     \wedge & \X{ea} + N/8 \leq |S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| \\
-     \wedge & S' = S \with \MEMS[F.\MODULE.\MEMS[0]].\DATA[\X{ea}:N/8] = \bytes_{\iN}(\wrap_{|t|,N}(c))
-     \end{array} \\
+     \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
+     \wedge & S' = S \with \SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8] = \bytes_{\iN}(\wrap_{|t|,N}(c))
+     \end{array}
+   \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~k)~(t.\STORE{N}^?~\memarg) &\stepto& S; F; \TRAP
+   S; F; (\I32.\CONST~k)~(t.\CONST~c)~(t.\STORE{N}^?~\memarg) &\stepto& S; F; \TRAP
    \end{array}
    \\ \qquad
-     (\mbox{otherwise}) \\
+     (\otherwise) \\
    \end{array}
 
 
@@ -519,15 +527,15 @@ Memory Instructions
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-current_memory>`, :math:`F.\MODULE.\MEMS[0]` exists.
+2. Assert: due to :ref:`validation <valid-current_memory>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
 
-3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\MODULE.\MEMS[0]`.
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
 
-4. Assert: due to :ref:`validation <valid-current_memory>`, :math:`S.\MEMS[a]` exists.
+4. Assert: due to :ref:`validation <valid-current_memory>`, :math:`S.\SMEMS[a]` exists.
 
-5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\MEMS[a]`.
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
 
-6. Let :math:`\X{sz}` be the length of :math:`\X{mem}.\DATA` divided by the :ref:`page size <page-size>`.
+6. Let :math:`\X{sz}` be the length of :math:`\X{mem}.\MIDATA` divided by the :ref:`page size <page-size>`.
 
 7. Push the value :math:`\I32.\CONST~\X{sz}` to the stack.
 
@@ -537,7 +545,7 @@ Memory Instructions
    S; F; \CURRENTMEMORY &\stepto& S; F; (\I32.\CONST~\X{sz})
    \end{array}
    \\ \qquad
-     (\mbox{if}~|S.\MEMS[F.\MODULE.\MEMS[0]].\DATA| = \X{sz}\cdot64\,\F{Ki}) \\
+     (\iff |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| = \X{sz}\cdot64\,\F{Ki}) \\
    \end{array}
 
 
@@ -548,21 +556,21 @@ Memory Instructions
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-grow_memory>`, :math:`F.\MODULE.\MEMS[0]` exists.
+2. Assert: due to :ref:`validation <valid-grow_memory>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
 
-3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\MODULE.\MEMS[0]`.
+3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
 
-4. Assert: due to :ref:`validation <valid-grow_memory>`, :math:`S.\MEMS[a]` exists.
+4. Assert: due to :ref:`validation <valid-grow_memory>`, :math:`S.\SMEMS[a]` exists.
 
-5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\MEMS[a]`.
+5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
 
-6. Let :math:`\X{sz}` be the length of :math:`S.\MEMS[a]` divided by the :ref:`page size <page-size>`.
+6. Let :math:`\X{sz}` be the length of :math:`S.\SMEMS[a]` divided by the :ref:`page size <page-size>`.
 
 7. Assert: due to :ref:`validation <valid-grow_memory>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
 8. Pop the value :math:`\I32.\CONST~n` from the stack.
 
-9. If :math:`\X{mem}.\MAX` is not empty and :math:`\X{sz} + n` is larger than :math:`\X{mem}.\MAX`, then:
+9. If :math:`\X{mem}.\MIMAX` is not empty and :math:`\X{sz} + n` is larger than :math:`\X{mem}.\MIMAX`, then:
 
   a. Push the value :math:`\I32.\CONST~(-1)` to the stack.
 
@@ -570,7 +578,7 @@ Memory Instructions
 
     a. Let :math:`\X{len}` be :math:`n` multiplied with the :ref:`page size <page-size>`.
 
-    b. Append :math:`\X{len}` bytes with value :math:`\hex{00}` to :math:`S.\MEMS[a]`.
+    b. Append :math:`\X{len}` bytes with value :math:`\hex{00}` to :math:`S.\SMEMS[a]`.
 
     c. Push the value :math:`\I32.\CONST~\X{sz}` to the stack.
 
@@ -579,17 +587,19 @@ Memory Instructions
     a. Push the value :math:`\I32.\CONST~(-1)` to the stack.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~n)~\GROWMEMORY &\stepto& S'; F; (\I32.\CONST~\X{sz})
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & F.\MODULE.\MEMS[0] = a \\
-     \wedge & |S.\MEMS[a].\DATA| = \X{sz}\cdot64\,\F{Ki} \\
-     \wedge & (\X{sz} + n \leq S.\MEMS[a].\MAX \vee S.\MEMS[a].\MAX = \epsilon) \\
-     \wedge & S' = S \with \MEMS[a].\DATA = S.\MEMS[a].\DATA~(\hex{00})^{n\cdot64\,\F{Ki}}) \\
-     \end{array} \\
+     (\mbox{if} & F.\AMODULE.\MIMEMS[0] = a \\
+     \wedge & |S.\SMEMS[a].\MIDATA| = \X{sz}\cdot64\,\F{Ki} \\
+     \wedge & (\X{sz} + n \leq S.\SMEMS[a].\MIMAX \vee S.\SMEMS[a].\MIMAX = \epsilon) \\
+     \wedge & S' = S \with \SMEMS[a].\MIDATA = S.\SMEMS[a].\MIDATA~(\hex{00})^{n\cdot64\,\F{Ki}}) \\
+     \end{array}
+   \\[1ex]
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~n)~\GROWMEMORY &\stepto& S; F; (\I32.\CONST~{-1})
    \end{array}
@@ -648,9 +658,10 @@ Control Instructions
 
 2. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is the end of the block.
 
-3. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr^\ast` with label :math:`L`.
+3. :ref:`Enter <exec-instr-seq-enter>` the block :math:`\instr^\ast` with label :math:`L`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
    \BLOCK~[t^n]~\instr^\ast~\END &\stepto&
      \LABEL_n\{\epsilon\}~\instr^\ast~\END
@@ -664,9 +675,10 @@ Control Instructions
 
 1. Let :math:`L` be the label whose arity is :math:`0` and whose continuation is the start of the loop.
 
-2. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr^\ast` with label :math:`L`.
+2. :ref:`Enter <exec-instr-seq-enter>` the block :math:`\instr^\ast` with label :math:`L`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
    \LOOP~[t^?]~\instr^\ast~\END &\stepto&
      \LABEL_0\{\LOOP~[t^?]~\instr^\ast~\END\}~\instr^\ast~\END
@@ -688,20 +700,21 @@ Control Instructions
 
 5. If :math:`c` is non-zero, then:
 
-   a. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr_1^\ast` with label :math:`L`.
+   a. :ref:`Enter <exec-instr-seq-enter>` the block :math:`\instr_1^\ast` with label :math:`L`.
 
 6. Else:
 
-   a. :ref:`Enter <exec-instr-seq-enter>` the instruction sequence :math:`\instr_2^\ast` with label :math:`L`.
+   a. :ref:`Enter <exec-instr-seq-enter>` the block :math:`\instr_2^\ast` with label :math:`L`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
    (\I32.\CONST~c)~\IF~[t^n]~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
      \LABEL_n\{\epsilon\}~\instr_1^\ast~\END
-     & (\mbox{if}~c \neq 0) \\
+     & (\iff c \neq 0) \\
    (\I32.\CONST~c)~\IF~[t^n]~\instr_1^\ast~\ELSE~\instr_2^\ast~\END &\stepto&
      \LABEL_n\{\epsilon\}~\instr_2^\ast~\END
-     & (\mbox{if}~c = 0) \\
+     & (\iff c = 0) \\
    \end{array}
 
 
@@ -735,6 +748,7 @@ Control Instructions
 8. Jump to the continuation of :math:`L`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
    \LABEL_n\{\instr^\ast\}~\XB^l[\val^n~(\BR~l)]~\END &\stepto& \val^n~\instr^\ast
    \end{array}
@@ -758,11 +772,12 @@ Control Instructions
    a. Do nothing.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
    (\I32.\CONST~c)~(\BRIF~l) &\stepto& (\BR~l)
-     & (\mbox{if}~c \neq 0) \\
+     & (\iff c \neq 0) \\
    (\I32.\CONST~c)~(\BRIF~l) &\stepto& \epsilon
-     & (\mbox{if}~c = 0) \\
+     & (\iff c = 0) \\
    \end{array}
 
 
@@ -786,11 +801,12 @@ Control Instructions
    a. :ref:`Execute <exec-br>` the instruction :math:`(\BR~l_N)`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
    (\I32.\CONST~i)~(\BRTABLE~l^\ast~l_N) &\stepto& (\BR~l_i)
-     & (\mbox{if}~l^\ast[i] = l_i) \\
+     & (\iff l^\ast[i] = l_i) \\
    (\I32.\CONST~i)~(\BRTABLE~l^\ast~l_N) &\stepto& (\BR~l_N)
-     & (\mbox{if}~|l^\ast| \leq i) \\
+     & (\iff |l^\ast| \leq i) \\
    \end{array}
 
 
@@ -819,9 +835,10 @@ Control Instructions
 
 9. Push :math:`\val^n` to the stack.
 
-10. Jump to the instruction after the original call.
+10. Jump to the instruction after the original call that pushed the frame.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
    \FRAME_n\{F\}~\XB^k[\val^n~\RETURN]~\END &\stepto& \val^n
    \end{array}
@@ -834,16 +851,16 @@ Control Instructions
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-call>`, :math:`F.\MODULE.\FUNCS[x]` exists.
+2. Assert: due to :ref:`validation <valid-call>`, :math:`F.\AMODULE.\MIFUNCS[x]` exists.
 
-3. Let :math:`a` be the :ref:`function address <syntax-funcaddr>` :math:`F.\MODULE.\FUNCS[x]`.
+3. Let :math:`a` be the :ref:`function address <syntax-funcaddr>` :math:`F.\AMODULE.\MIFUNCS[x]`.
 
 4. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
    F; (\CALL~x) &\stepto& F; (\INVOKE~a)
-     & (\mbox{if}~F.\MODULE.\FUNCS[x] = a)
+     & (\iff F.\AMODULE.\MIFUNCS[x] = a)
    \end{array}
 
 
@@ -854,37 +871,37 @@ Control Instructions
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`F.\MODULE.\TABLES[0]` exists.
+2. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`F.\AMODULE.\MITABLES[0]` exists.
 
-3. Let :math:`\X{ta}` be the :ref:`table address <syntax-tableaddr>` :math:`F.\MODULE.\TABLES[0]`.
+3. Let :math:`\X{ta}` be the :ref:`table address <syntax-tableaddr>` :math:`F.\AMODULE.\MITABLES[0]`.
 
-4. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`S.\TABLES[\X{ta}]` exists.
+4. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`S.\STABLES[\X{ta}]` exists.
 
-5. Let :math:`\X{tab}` be the :ref:`table instance <syntax-tableinst>` :math:`S.\TABLES[\X{ta}]`.
+5. Let :math:`\X{tab}` be the :ref:`table instance <syntax-tableinst>` :math:`S.\STABLES[\X{ta}]`.
 
-6. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`F.\MODULE.\TYPES[x]` exists.
+6. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`F.\AMODULE.\MITYPES[x]` exists.
 
-7. Let :math:`\X{ft}_{\F{expect}}` be the :ref:`function type <syntax-functype>` :math:`F.\MODULE.\TYPES[x]`.
+7. Let :math:`\X{ft}_{\F{expect}}` be the :ref:`function type <syntax-functype>` :math:`F.\AMODULE.\MITYPES[x]`.
 
 8. Assert: due to :ref:`validation <valid-call_indirect>`, a value with :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
 9. Pop the value :math:`\I32.\CONST~i` from the stack.
 
-10. If :math:`i` is not smaller than the length of :math:`\X{tab}.\ELEM`, then:
+10. If :math:`i` is not smaller than the length of :math:`\X{tab}.\TIELEM`, then:
 
     a. Trap.
 
-11. If :math:`\X{tab}.\ELEM[i]` is uninitialized, then:
+11. If :math:`\X{tab}.\TIELEM[i]` is uninitialized, then:
 
     a. Trap.
 
-12. Let :math:`a` be the :ref:`function address <syntax-funcaddr>` :math:`\X{tab}.\ELEM[i]`.
+12. Let :math:`a` be the :ref:`function address <syntax-funcaddr>` :math:`\X{tab}.\TIELEM[i]`.
 
-13. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`S.\FUNCS[a]` exists.
+13. Assert: due to :ref:`validation <valid-call_indirect>`, :math:`S.\SFUNCS[a]` exists.
 
-14. Let :math:`\X{f}` be the :ref:`function instance <syntax-funcinst>` :math:`S.\FUNCS[a]`.
+14. Let :math:`\X{f}` be the :ref:`function instance <syntax-funcinst>` :math:`S.\SFUNCS[a]`.
 
-15. Let :math:`\X{ft}_{\F{actual}}` be the :ref:`function type <syntax-functype>` :math:`\X{f}.\TYPE`.
+15. Let :math:`\X{ft}_{\F{actual}}` be the :ref:`function type <syntax-functype>` :math:`\X{f}.\FITYPE`.
 
 16. If :math:`\X{ft}_{\F{actual}}` and :math:`\X{ft}_{\F{expect}}` differ, then:
 
@@ -893,32 +910,34 @@ Control Instructions
 17. :ref:`Invoke <exec-invoke>` the function instance at address :math:`a`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~i)~(\CALLINDIRECT~x) &\stepto& S; F; (\INVOKE~a)
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & S.\TABLES[F.\MODULE.\TABLES[0]].\ELEM[i] = a \\
-     \wedge & S.\FUNCS[a] = f \\
-     \wedge & F.\MODULE.\TYPES[x] = f.\TYPE)
-     \end{array} \\
+     (\mbox{if} & S.\STABLES[F.\AMODULE.\MITABLES[0]].\TIELEM[i] = a \\
+     \wedge & S.\SFUNCS[a] = f \\
+     \wedge & F.\AMODULE.\MITYPES[x] = f.\FITYPE)
+     \end{array}
+   \\[1ex]
    \begin{array}{lcl@{\qquad}l}
    S; F; (\I32.\CONST~i)~(\CALLINDIRECT~x) &\stepto& S; F; \TRAP
    \end{array}
    \\ \qquad
-     (\mbox{otherwise})
+     (\otherwise)
    \end{array}
 
 
-.. index:: instruction, instruction sequence
+.. index:: instruction, instruction sequence, block
 .. _exec-instr-seq:
 
-Instruction Sequences
-~~~~~~~~~~~~~~~~~~~~~
+Blocks
+~~~~~~
 
 The following auxiliary rules define the semantics of executing an :ref:`instruction sequence <syntax-instr-seq>`
-that is part of a :ref:`structured control instruction <exec-instr-control>`.
+that forms a :ref:`block <exec-instr-control>`.
 
 
 .. _exec-instr-seq-enter:
@@ -940,7 +959,7 @@ Entering :math:`\instr^\ast` with label :math:`L`
 Exiting :math:`\instr^\ast` with label :math:`L`
 ................................................
 
-When the end of a labelled instruction sequence is reached without a jump or trap aborting it, then the following steps are performed.
+When the end of a block is reached without a jump or trap aborting it, then the following steps are performed.
 
 1. Let :math:`n` be the arity of :math:`L`.
 
@@ -957,6 +976,7 @@ When the end of a labelled instruction sequence is reached without a jump or tra
 7. Jump to the position after the |END| of the :ref:`structured control instruction <syntax-instr-control>` associated with the label :math:`L`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
    \LABEL_n\{\instr^\ast\}~\val^n~\END &\stepto& \val^n
    \end{array}
@@ -966,7 +986,7 @@ When the end of a labelled instruction sequence is reached without a jump or tra
    Therefor, execution of a loop falls off the end, unless a backwards branch is performed explicitly.
 
 
-.. index:: ! invocation, function, function instance, label, frame
+.. index:: ! call, function, function instance, label, frame
 
 Function Calls
 ~~~~~~~~~~~~~~
@@ -981,15 +1001,15 @@ and returning from it.
 Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 .................................................................
 
-1. Assert: due to :ref:`validation <valid-call>`, :math:`S.\FUNCS[a]` exists.
+1. Assert: due to :ref:`validation <valid-call>`, :math:`S.\SFUNCS[a]` exists.
 
-2. Let :math:`f` be the :ref:`function instance <syntax-funcinst>`, :math:`S.\FUNCS[a]`.
+2. Let :math:`f` be the :ref:`function instance <syntax-funcinst>`, :math:`S.\SFUNCS[a]`.
 
-3. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`f.\TYPE`.
+3. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`f.\FITYPE`.
 
-4. Let :math:`t^\ast` be the list of :ref:`value types <syntax-valtype>` :math:`f.\CODE.\LOCALS`.
+4. Let :math:`t^\ast` be the list of :ref:`value types <syntax-valtype>` :math:`f.\FICODE.\FLOCALS`.
 
-5. Let :math:`\instr^\ast~\END` be the :ref:`expression <syntax-expr>` :math:`f.\CODE.\BODY`.
+5. Let :math:`\instr^\ast~\END` be the :ref:`expression <syntax-expr>` :math:`f.\FICODE.\FBODY`.
 
 6. Assert: due to :ref:`validation <valid-call>`, :math:`n` values are on the top of the stack.
 
@@ -997,23 +1017,24 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 
 8. Let :math:`\val_0^\ast` be the list of zero values of types :math:`t^\ast`.
 
-9. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \MODULE~f.\MODULE, \LOCALS~\val^n~\val_0^\ast \}`.
+9. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~f.\FIMODULE, \ALOCALS~\val^n~\val_0^\ast \}`.
 
 10. Push the activation of :math:`F` with arity :math:`m` to the stack.
 
 11. :ref:`Execute <exec-block>` the instruction :math:`\BLOCK~[t_2^m]~\instr^\ast~\END`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   \val^n~(\INVOKE~a) &\stepto& \FRAME_m\{F\}~\BLOCK~[t_2^m]~\instr^\ast~\END~\END
+   S; \val^n~(\INVOKE~a) &\stepto& S; \FRAME_m\{F\}~\BLOCK~[t_2^m]~\instr^\ast~\END~\END
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & S.\FUNCS[a] = f \\
-     \wedge & f.\CODE = \{ \TYPE~x, \LOCALS~t^k, \BODY~\instr^\ast~\END \} \\
-     \wedge & f.\TYPE = [t_1^n] \to [t_2^m] \\
-     \wedge & F = \{ \MODULE~f.\MODULE, ~\LOCALS~\val^n~(t.\CONST~0)^k \})
+     (\mbox{if} & S.\SFUNCS[a] = f \\
+     \wedge & f.\FITYPE = [t_1^n] \to [t_2^m] \\
+     \wedge & f.\FICODE = \{ \FTYPE~x, \FLOCALS~t^k, \FBODY~\instr^\ast~\END \} \\
+     \wedge & F = \{ \AMODULE~f.\FIMODULE, ~\ALOCALS~\val^n~(t.\CONST~0)^k \})
      \end{array} \\
    \end{array}
 
@@ -1023,7 +1044,7 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 Returning from a function
 .........................
 
-When the end of a funtion is reached without a jump (|RETURN|) or trap aborting it, then the following steps are performed.
+When the end of a funtion is reached without a jump (i.e., |RETURN|) or trap aborting it, then the following steps are performed.
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
@@ -1042,11 +1063,13 @@ When the end of a funtion is reached without a jump (|RETURN|) or trap aborting
 8. Jump to the instruction after the original call.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
    \FRAME_n\{F\}~\val^n~\END &\stepto& \val^n
    \end{array}
 
 
+.. index:: host function, store
 .. _exec-invoke-host:
 
 Host Functions
@@ -1054,28 +1077,30 @@ Host Functions
 
 Invoking a :ref:`host function <syntax-hostfunc>` has non-deterministic behavior.
 It may either terminate with a :ref:`trap <trap>` or return regularly.
-However, the latter case, it is assumed that it consumes and produces the right number and types of WebAssembly :ref:`values <syntax-val>` on the stack,
-according to its type.
-A host function may also modify the :ref:`store <syntax-store>` when invoked.
+However, in the latter case, it is assumed that it consumes and produces the right number and types of WebAssembly :ref:`values <syntax-val>` on the stack,
+according to its :ref:`function type <syntax-functype>`.
+A host function may also modify the :ref:`store <syntax-store>`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   S; \val^n~(\INVOKE~a) &\stepto& S'; {\val'\,}^m
+   S; \val_1^n~(\INVOKE~a) &\stepto& S'; \val_2^m
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & S.\FUNCS[a] = \{ \TYPE~[t_1^n] \to [t_2^m], \HOST~\dots \} \\
-     \wedge & \val^n = (t_1.\CONST~c_1)^n \\
-     \wedge & {\val'\,}^m = (t_2.\CONST~c_2)^m \\
+     (\mbox{if} & S.\SFUNCS[a] = \{ \FITYPE~[t_1^n] \to [t_2^m], \FIHOSTCODE~\dots \} \\
+     \wedge & \val_1^n = (t_1.\CONST~c_1)^n \\
+     \wedge & \val_2^m = (t_2.\CONST~c_2)^m \\
      \wedge & S' \succ S) \\
-     \end{array} \\
+     \end{array}
+   \\[1ex]
    \begin{array}{lcl@{\qquad}l}
    S; \val^n~(\INVOKE~a) &\stepto& S'; \TRAP
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & S.\FUNCS[a] = \{ \TYPE~\X{ft}, \HOST~\dots \} \\ 
+     (\mbox{if} & S.\SFUNCS[a] = \{ \FITYPE~\X{ft}, \FIHOSTCODE~\dots \} \\ 
      \wedge & S' \succ S) \\
      \end{array} \\
    \end{array}
@@ -1085,11 +1110,11 @@ Such a store must not contain fewer addresses than the original store,
 it must not differ in elements that are not mutable,
 and it must still be well-typed.
 
-.. todo:: Define more precisely?
+.. todo:: Define this relation more precisely.
 
 .. note::
    A host function can call back into WebAssembly by :ref:`invoking <exec-invocation>` a function :ref:`exported <syntax-export>` from a :ref:`module <syntax-module>`.
-   However, the effects of any such call are subsumed by the non-deterministic behavior allowed for a host function.
+   However, the effects of any such call are subsumed by the non-deterministic behavior allowed for the host function.
 
 
 
@@ -1101,7 +1126,7 @@ and it must still be well-typed.
 Expressions
 ~~~~~~~~~~~
 
-An :ref:`expression <syntax-expr>` is *evaluated* relative to a :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>` pointing to its containing :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst`.
+An :ref:`expression <syntax-expr>` is *evaluated* relative to a :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>` pointing to its containing :ref:`module instance <syntax-moduleinst>`.
 
 1. Jump to the start of the instruction sequence :math:`\instr^\ast` of the expression.
 
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index b7cfc2969..c29355d33 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -1,7 +1,12 @@
 Modules
 -------
 
+For modules, the execution semantics primarily defines :ref:`instantiation <exec-instantiation>`, which :ref:`allocates <alloc>` instances for a module and its contained definitions, inititializes :ref:`tables <syntax-table>` and :ref:`memories <syntax-mem>` from contained :ref:`element <syntax-elem>` and :ref:`data <syntax-data>` segments, and invokes the :ref:`start function <syntax-start>` if present. It also includes :ref:`invocation <exec-invocation>` of exported functions.
 
+Instantiation depends on a number of auxiliary notions for :ref:`type-checking imports <exec-import>` and :ref:`allocating <alloc>` instances.
+
+
+.. index:: external value, external type, validation, import, store
 .. _valid-externval:
 
 External Typing
@@ -11,67 +16,81 @@ For the purpose of checking :ref:`external values <syntax-externval>` against :r
 such values are classified by :ref:`external types <syntax-externtype>`.
 The following auxiliary typing rules specify this typing relation relative to a :ref:`store <syntax-store>` :math:`S` in which the external value lives.
 
-:math:`\FUNC~a`
-...............
 
-* The store entry :math:`S.\FUNCS[a]` must be a :ref:`function instance <syntax-funcinst>` :math:`\{\TYPE~\functype, \dots\}`.
+.. index:: function type, function address
+.. _valid-externval-func:
+
+:math:`\EVFUNC~a`
+.................
+
+* The store entry :math:`S.\SFUNCS[a]` must be a :ref:`function instance <syntax-funcinst>` :math:`\{\FITYPE~\functype, \dots\}`.
 
-* Then :math:`\FUNC~a` is valid with :ref:`external type <syntax-externtype>` :math:`\FUNC~\functype`.
+* Then :math:`\EVFUNC~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\functype`.
 
 .. math::
    \frac{
-     S.\FUNCS[a] = \{\TYPE~\functype, \dots\}
+     S.\SFUNCS[a] = \{\FITYPE~\functype, \dots\}
    }{
-     S \vdash \FUNC~a : \FUNC~\functype
+     S \vdash \EVFUNC~a : \ETFUNC~\functype
    }
 
 
-:math:`\TABLE~a`
-................
+.. index:: table type, table address, limits
+.. _valid-externval-table:
 
-* The store entry :math:`S.\TABLES[a]` must be a :ref:`table instance <syntax-tableinst>` :math:`\{\ELEM~(\X{fa}^?)^n, \MAX~m^?\}`.
+:math:`\EVTABLE~a`
+..................
 
-* Then :math:`\TABLE~a` is valid with :ref:`external type <syntax-externtype>` :math:`\TABLE~(\{\MIN~n, \MAX~m^?\}~\ANYFUNC)`.
+* The store entry :math:`S.\STABLES[a]` must be a :ref:`table instance <syntax-tableinst>` :math:`\{\TIELEM~(\X{fa}^?)^n, \TIMAX~m^?\}`.
+
+* Then :math:`\EVTABLE~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETTABLE~(\{\LMIN~n, \LMAX~m^?\}~\ANYFUNC)`.
 
 .. math::
    \frac{
-     S.\TABLES[a] = \{ \ELEM~(\X{fa}^?)^n, \MAX~m^? \}
+     S.\STABLES[a] = \{ \TIELEM~(\X{fa}^?)^n, \TIMAX~m^? \}
    }{
-     S \vdash \TABLE~a : \TABLE~(\{\MIN~n, \MAX~m^?\}~\ANYFUNC)
+     S \vdash \EVTABLE~a : \ETTABLE~(\{\LMIN~n, \LMAX~m^?\}~\ANYFUNC)
    }
 
 
-:math:`\MEM~a`
-..............
+.. index:: memory type, memory address, limits
+.. _valid-externval-mem:
+
+:math:`\EVMEM~a`
+................
 
-* The store entry :math:`S.\MEMS[a]` must be a :ref:`memory instance <syntax-meminst>` :math:`\{\DATA~b^{n\cdot64\,\F{Ki}}, \MAX~m^?\}`, for some :math:`n`.
+* The store entry :math:`S.\SMEMS[a]` must be a :ref:`memory instance <syntax-meminst>` :math:`\{\MIDATA~b^{n\cdot64\,\F{Ki}}, \MIMAX~m^?\}`, for some :math:`n`.
 
-* Then :math:`\MEM~a` is valid with :ref:`external type <syntax-externtype>` :math:`\MEM~(\{\MIN~n, \MAX~m^?\})`.
+* Then :math:`\EVMEM~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETMEM~(\{\LMIN~n, \LMAX~m^?\})`.
 
 .. math::
    \frac{
-     S.\MEMS[a] = \{ \DATA~b^{n\cdot64\,\F{Ki}}, \MAX~m^? \}
+     S.\SMEMS[a] = \{ \MIDATA~b^{n\cdot64\,\F{Ki}}, \MIMAX~m^? \}
    }{
-     S \vdash \MEM~a : \MEM~\{\MIN~n, \MAX~m^?\}
+     S \vdash \EVMEM~a : \ETMEM~\{\LMIN~n, \LMAX~m^?\}
    }
 
 
-:math:`\GLOBAL~a`
-.................
+.. index:: global type, global address, value type, mutability
+.. _valid-externval-global:
 
-* The store entry :math:`S.\GLOBALS[a]` must be a :ref:`global instance <syntax-globalinst>` :math:`\{\VALUE~(t.\CONST~c), \MUT~\mut\}`.
+:math:`\EVGLOBAL~a`
+...................
 
-* Then :math:`\GLOBAL~a` is valid with :ref:`external type <syntax-externtype>` :math:`\GLOBAL~(\mut~t)`.
+* The store entry :math:`S.\SGLOBALS[a]` must be a :ref:`global instance <syntax-globalinst>` :math:`\{\GIVALUE~(t.\CONST~c), \GIMUT~\mut\}`.
+
+* Then :math:`\EVGLOBAL~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~(\mut~t)`.
 
 .. math::
    \frac{
-     S.\GLOBALS[a] = \{ \VALUE~(t.\CONST~c), \MUT~\mut \}
+     S.\SGLOBALS[a] = \{ \GIVALUE~(t.\CONST~c), \GIMUT~\mut \}
    }{
-     S \vdash \GLOBAL~a : \GLOBAL~(\mut~t)
+     S \vdash \EVGLOBAL~a : \ETGLOBAL~(\mut~t)
    }
 
 
 
+.. index:: ! matching, external type
 .. _exec-import:
 .. _match-externtype:
 
@@ -82,14 +101,16 @@ When :ref:`instantiating <exec-module>` a module,
 :ref:`external values <syntax-externval>` must be provided whose :ref:`types <valid-externval>` are *matched* against the respective :ref:`external types <syntax-externtype>` classifying each import.
 In some cases, this allows for a simple form of subtyping, as defined below.
 
+
+.. index:: limits
 .. _match-limits:
 
 Limits
 ......
 
-:ref:`Limits <syntax-limits>` :math:`\{ \MIN~n_1, \MAX~m_1^? \}` match limits :math:`\{ \MIN~n_2, \MAX~m_2^? \}` if and only if:
+:ref:`Limits <syntax-limits>` :math:`\{ \LMIN~n_1, \LMAX~m_1^? \}` match limits :math:`\{ \LMIN~n_2, \LMAX~m_2^? \}` if and only if:
 
-* :math:`n_1` is not smaller than :math:`n_2`.
+* :math:`n_1` is larger than or equal to :math:`n_2`.
 
 * Either:
 
@@ -99,13 +120,14 @@ Limits
 
   * Both :math:`m_1^?` and :math:`m_2^?` are non-empty.
 
-  * :math:`m_1` is not larger than :math:`m_2`.
+  * :math:`m_1` is smaller than or equal to :math:`m_2`.
 
 .. math::
+   ~\\[-1ex]
    \frac{
      n_1 \geq n_2
    }{
-     \vdash \{ \MIN~n_1, \MAX~m_1^? \} \leq \{ \MIN~n_2, \MAX~\epsilon \}
+     \vdash \{ \LMIN~n_1, \LMAX~m_1^? \} \leq \{ \LMIN~n_2, \LMAX~\epsilon \}
    }
    \quad
    \frac{
@@ -113,28 +135,35 @@ Limits
      \qquad
      m_1 \leq m_2
    }{
-     \vdash \{ \MIN~n_1, \MAX~m_1 \} \leq \{ \MIN~n_2, \MAX~m_2 \}
+     \vdash \{ \LMIN~n_1, \LMAX~m_1 \} \leq \{ \LMIN~n_2, \LMAX~m_2 \}
    }
 
 
+.. index:: function type
+.. _match-functype:
+
 Functions
 .........
 
-An :ref:`external type <syntax-externtype>` :math:`\FUNC~\functype_1` matches :math:`\FUNC~\functype_2` if and only if:
+An :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\functype_1` matches :math:`\ETFUNC~\functype_2` if and only if:
 
 * Both :math:`\functype_1` and :math:`\functype_2` are the same.
 
 .. math::
+   ~\\[-1ex]
    \frac{
    }{
-     \vdash \FUNC~\functype \leq \FUNC~\functype
+     \vdash \ETFUNC~\functype \leq \ETFUNC~\functype
    }
 
 
+.. index:: table type, limits, element type
+.. _match-tabletype:
+
 Tables
 ......
 
-An :ref:`external type <syntax-externtype>` :math:`\TABLE~(\limits_1~\elemtype_1)` matches :math:`\TABLE~(\limits_2~\elemtype_2)` if and only if:
+An :ref:`external type <syntax-externtype>` :math:`\ETTABLE~(\limits_1~\elemtype_1)` matches :math:`\ETTABLE~(\limits_2~\elemtype_2)` if and only if:
 
 * Limits :math:`\limits_1` :ref:`match <match-limits>` :math:`\limits_2`.
 
@@ -144,14 +173,17 @@ An :ref:`external type <syntax-externtype>` :math:`\TABLE~(\limits_1~\elemtype_1
    \frac{
      \vdash \limits_1 \leq \limits_2
    }{
-     \vdash \TABLE~(\limits_1~\elemtype) \leq \TABLE~(\limits_2~\elemtype)
+     \vdash \ETTABLE~(\limits_1~\elemtype) \leq \ETTABLE~(\limits_2~\elemtype)
    }
 
 
+.. index:: memory type, limits
+.. _match-memtype:
+
 Memories
 ........
 
-An :ref:`external type <syntax-externtype>` :math:`\MEM~\limits_1` matches :math:`\MEM~\limits_2` if and only if:
+An :ref:`external type <syntax-externtype>` :math:`\ETMEM~\limits_1` matches :math:`\ETMEM~\limits_2` if and only if:
 
 * Limits :math:`\limits_1` :ref:`match <match-limits>` :math:`\limits_2`.
 
@@ -159,24 +191,29 @@ An :ref:`external type <syntax-externtype>` :math:`\MEM~\limits_1` matches :math
    \frac{
      \vdash \limits_1 \leq \limits_2
    }{
-     \vdash \MEM~\limits_1 \leq \MEM~\limits_2
+     \vdash \ETMEM~\limits_1 \leq \ETMEM~\limits_2
    }
 
 
+.. index:: global type, value type, mutability
+.. _match-globaltype:
+
 Globals
 .......
 
-An :ref:`external type <syntax-externtype>` :math:`\GLOBAL~\globaltype_1` matches :math:`\GLOBAL~\globaltype_2` if and only if:
+An :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~\globaltype_1` matches :math:`\ETGLOBAL~\globaltype_2` if and only if:
 
 * Both :math:`\globaltype_1` and :math:`\globaltype_2` are the same.
 
 .. math::
+   ~\\[-1ex]
    \frac{
    }{
-     \vdash \GLOBAL~\globaltype \leq \GLOBAL~\globaltype
+     \vdash \ETGLOBAL~\globaltype \leq \ETGLOBAL~\globaltype
    }
 
 
+.. index:: ! allocation, store, address
 .. _alloc:
 
 Allocation
@@ -185,6 +222,7 @@ Allocation
 New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tableinst>`, :ref:`memories <syntax-meminst>`, :ref:`globals <syntax-globalinst>`, and :ref:`modules <syntax-moduleinst>` are *allocated* in a :ref:`store <syntax-store>` :math:`S`, as defined by the following auxiliary functions.
 
 
+.. index:: function, function instance, function address, module instance, function type
 .. _alloc-func:
 
 :ref:`Functions <syntax-funcinst>`
@@ -194,24 +232,27 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 2. Let :math:`a` be the first free :ref:`function address <syntax-funcaddr>` in :math:`S`.
 
-3. Let :math:`\functype` be the :ref:`function type <syntax-functype>` :math:`\moduleinst.\TYPES[\func.\TYPE]`.
+3. Let :math:`\functype` be the :ref:`function type <syntax-functype>` :math:`\moduleinst.\MITYPES[\func.\FTYPE]`.
 
-4. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \TYPE~\functype, \MODULE~\moduleinst, \CODE~\func \}`.
+4. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func \}`.
 
-5. Append :math:`\funcinst` to the |FUNCS| of :math:`S`.
+5. Append :math:`\funcinst` to the |SFUNCS| of :math:`S`.
 
 6. Return :math:`a`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{rlll}
    \allocfunc(S, \func, \moduleinst) &=& S', \funcaddr \\[1ex]
    \mbox{where:} \hfill \\
-   \funcaddr &=& |S.\FUNCS| \\
-   \functype &=& \moduleinst.\TYPES[\func.\TYPE] \\
-   \funcinst &=& \{ \TYPE~\functype, \MODULE~\moduleinst, \CODE~\func \} \\
-   S' &=& S \compose \{\FUNCS~\funcinst\} \\
+   \funcaddr &=& |S.\SFUNCS| \\
+   \functype &=& \moduleinst.\MITYPES[\func.\FTYPE] \\
+   \funcinst &=& \{ \FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func \} \\
+   S' &=& S \compose \{\SFUNCS~\funcinst\} \\
    \end{array}
 
+
+.. index:: host function, function instance, function address, function type
 .. _alloc-hostfunc:
 
 :ref:`Host Functions <syntax-hostfunc>`
@@ -221,26 +262,28 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 2. Let :math:`a` be the first free :ref:`function address <syntax-funcaddr>` in :math:`S`.
 
-4. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \TYPE~\functype, \CODE~\hostfunc \}`.
+4. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype, \FIHOSTCODE~\hostfunc \}`.
 
-5. Append :math:`\funcinst` to the |FUNCS| of :math:`S`.
+5. Append :math:`\funcinst` to the |SFUNCS| of :math:`S`.
 
 6. Return :math:`a`.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{rlll}
    \allochostfunc(S, \hostfunc, \functype) &=& S', \funcaddr \\[1ex]
    \mbox{where:} \hfill \\
-   \funcaddr &=& |S.\FUNCS| \\
-   \funcinst &=& \{ \TYPE~\functype, \CODE~\hostfunc \} \\
-   S' &=& S \compose \{\FUNCS~\tableinst\} \\
+   \funcaddr &=& |S.\SFUNCS| \\
+   \funcinst &=& \{ \FITYPE~\functype, \FIHOSTCODE~\hostfunc \} \\
+   S' &=& S \compose \{\SFUNCS~\tableinst\} \\
    \end{array}
 
 .. note::
    Host functions are never allocated by the WebAssembly semantics itself,
-   but may be allocated by the embedder.
+   but may be allocated by the :ref:`embedder <embedder>`.
 
 
+.. index:: table, table instance, table address, table type, limits
 .. _alloc-table:
 
 :ref:`Tables <syntax-tableinst>`
@@ -248,13 +291,13 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 1. Let :math:`\table` be the :ref:`table <syntax-table>` to allocate.
 
-2. Let :math:`(\{\MIN~n, \MAX~m^?\}~\elemtype)` be the :ref:`table type <syntax-tabletype>` :math:`\table.\TYPE`.
+2. Let :math:`(\{\LMIN~n, \LMAX~m^?\}~\elemtype)` be the :ref:`table type <syntax-tabletype>` :math:`\table.\TTYPE`.
 
 3. Let :math:`a` be the first free :ref:`table address <syntax-tableaddr>` in :math:`S`.
 
-4. Let :math:`\tableinst` be the :ref:`table instance <syntax-tableinst>` :math:`\{ \ELEM~(\epsilon)^n, \MAX~m^? \}` with :math:`n` empty elements.
+4. Let :math:`\tableinst` be the :ref:`table instance <syntax-tableinst>` :math:`\{ \TIELEM~(\epsilon)^n, \TIMAX~m^? \}` with :math:`n` empty elements.
 
-5. Append :math:`\tableinst` to the |TABLES| of :math:`S`.
+5. Append :math:`\tableinst` to the |STABLES| of :math:`S`.
 
 6. Return :math:`a`.
 
@@ -262,12 +305,14 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
    \begin{array}{rlll}
    \alloctable(S, \table) &=& S', \tableaddr \\[1ex]
    \mbox{where:} \hfill \\
-   \table.\TYPE &=& \{\MIN~n, \MAX~m^?\}~\elemtype \\
-   \tableaddr &=& |S.\TABLES| \\
-   \tableinst &=& \{ \ELEM~(\epsilon)^n, \MAX~m^? \} \\
-   S' &=& S \compose \{\TABLES~\tableinst\} \\
+   \table.\TTYPE &=& \{\LMIN~n, \LMAX~m^?\}~\elemtype \\
+   \tableaddr &=& |S.\STABLES| \\
+   \tableinst &=& \{ \TIELEM~(\epsilon)^n, \TIMAX~m^? \} \\
+   S' &=& S \compose \{\STABLES~\tableinst\} \\
    \end{array}
 
+
+.. index:: memory, memory instance, memory address, memory type, limits, byte
 .. _alloc-mem:
 
 :ref:`Memories <syntax-meminst>`
@@ -275,13 +320,13 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 1. Let :math:`\mem` be the :ref:`memory <syntax-mem>` to allocate.
 
-2. Let :math:`\{\MIN~n, \MAX~m^?\}` be the :ref:`table type <syntax-memtype>` :math:`\mem.\TYPE`.
+2. Let :math:`\{\LMIN~n, \LMAX~m^?\}` be the :ref:`table type <syntax-memtype>` :math:`\mem.\MTYPE`.
 
 3. Let :math:`a` be the first free :ref:`memory address <syntax-memaddr>` in :math:`S`.
 
-4. Let :math:`\meminst` be the :ref:`memory instance <syntax-meminst>` :math:`\{ \DATA~(\hex{00})^{n \cdot 64\,\F{Ki}}, \MAX~m^? \}` that contains :math:`n` pages of zeroed bytes.
+4. Let :math:`\meminst` be the :ref:`memory instance <syntax-meminst>` :math:`\{ \MIDATA~(\hex{00})^{n \cdot 64\,\F{Ki}}, \MIMAX~m^? \}` that contains :math:`n` pages of zeroed :ref:`bytes <syntax-byte>`.
 
-5. Append :math:`\meminst` to the |MEMS| of :math:`S`.
+5. Append :math:`\meminst` to the |SMEMS| of :math:`S`.
 
 6. Return :math:`a`.
 
@@ -289,12 +334,14 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
    \begin{array}{rlll}
    \allocmem(S, \mem) &=& S', \memaddr \\[1ex]
    \mbox{where:} \hfill \\
-   \mem.\TYPE &=& \{\MIN~n, \MAX~m^?\} \\
-   \memaddr &=& |S.\MEMS| \\
-   \meminst &=& \{ \DATA~(\hex{00})^{n \cdot 64\,\F{Ki}}, \MAX~m^? \} \\
-   S' &=& S \compose \{\MEMS~\meminst\} \\
+   \mem.\MTYPE &=& \{\LMIN~n, \LMAX~m^?\} \\
+   \memaddr &=& |S.\SMEMS| \\
+   \meminst &=& \{ \MIDATA~(\hex{00})^{n \cdot 64\,\F{Ki}}, \MIMAX~m^? \} \\
+   S' &=& S \compose \{\SMEMS~\meminst\} \\
    \end{array}
 
+
+.. index:: global, global instance, global address, global type, value type, mutability, value
 .. _alloc-global:
 
 :ref:`Globals <syntax-globalinst>`
@@ -302,13 +349,13 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 1. Let :math:`\global` be the :ref:`global <syntax-global>` to allocate.
 
-2. Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`\global.\TYPE`.
+2. Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`\global.\GTYPE`.
 
 3. Let :math:`a` be the first free :ref:`global address <syntax-globaladdr>` in :math:`S`.
 
-4. Let :math:`\globalinst` be the :ref:`global instance <syntax-globalinst>` :math:`\{ \VALUE~(t.\CONST~0), \MUT~\mut \}` whose contents is a zero :ref:`value <syntax-val>` of :ref:`value type <syntax-valtype>` :math:`t`.
+4. Let :math:`\globalinst` be the :ref:`global instance <syntax-globalinst>` :math:`\{ \GIVALUE~(t.\CONST~0), \GIMUT~\mut \}` whose contents is a zero :ref:`value <syntax-val>` of :ref:`value type <syntax-valtype>` :math:`t`.
 
-5. Append :math:`\globalinst` to the |GLOBALS| of :math:`S`.
+5. Append :math:`\globalinst` to the |SGLOBALS| of :math:`S`.
 
 6. Return :math:`a`.
 
@@ -316,12 +363,14 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
    \begin{array}{rlll}
    \allocglobal(S, \global) &=& S', \globaladdr \\[1ex]
    \mbox{where:} \hfill \\
-   \global.\TYPE &=& \mut~t \\
-   \globaladdr &=& |S.\GLOBALS| \\
-   \globalinst &=& \{ \VALUE~(t.\CONST~0), \MUT~\mut \} \\
-   S' &=& S \compose \{\GLOBALS~\globalinst\} \\
+   \global.\GTYPE &=& \mut~t \\
+   \globaladdr &=& |S.\SGLOBALS| \\
+   \globalinst &=& \{ \GIVALUE~(t.\CONST~0), \GIMUT~\mut \} \\
+   S' &=& S \compose \{\SGLOBALS~\globalinst\} \\
    \end{array}
 
+
+.. index:: module, module instance, function instance, table instance, memory instance, global instance, export instance, function address, table address, memory address, global address, function index, table index, memory index, global index, type, function, table, memory, global, import, export, external value, external type, matching
 .. _alloc-module:
 
 :ref:`Modules <syntax-moduleinst>`
@@ -331,19 +380,19 @@ The allocation function for :ref:`modules <syntax-module>` requires a suitable l
 
 1. Let :math:`\module` be the :ref:`module <syntax-module>` to allocate and :math:`\externval_{\F{im}}^\ast` the vector of :ref:`external values <syntax-externval>` providing the module's imports.
 
-2. For each :ref:`function <syntax-func>` :math:`\func_i` in :math:`\module.\FUNCS`, do:
+2. For each :ref:`function <syntax-func>` :math:`\func_i` in :math:`\module.\MFUNCS`, do:
 
    a. Let :math:`\funcaddr_i` be the :ref:`function address <syntax-funcaddr>` resulting from :ref:`allocating <alloc-func>` :math:`\func_i` for the :ref:`\module instance <syntax-moduleinst>` :math:`\moduleinst` defined below.
 
-3. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\TABLES`, do:
+3. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\MTABLES`, do:
 
    a. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i`.
 
-4. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MEMS`, do:
+4. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MMEMS`, do:
 
    a. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` resulting from :ref:`allocating <alloc-mem>` :math:`\mem_i`.
 
-5. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\GLOBALS`, do:
+5. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
    a. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\global_i`.
 
@@ -363,56 +412,57 @@ The allocation function for :ref:`modules <syntax-module>` requires a suitable l
 
 13. Let :math:`\globaladdr_{\F{mod}}^\ast` be the list of :ref:`global addresses <syntax-globaladdr>` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\globaladdr^\ast`.
 
-14. For each :ref:`export <syntax-export>` :math:`\export_i` in :math:`\module.\EXPORTS`, do:
+14. For each :ref:`export <syntax-export>` :math:`\export_i` in :math:`\module.\MEXPORTS`, do:
 
-    a. If :math:`\export_i` is a function export for :ref:`function index <syntax-funcidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\FUNC~(\funcaddr_{\F{mod}}^\ast[x])`.
+    a. If :math:`\export_i` is a function export for :ref:`function index <syntax-funcidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\EVFUNC~(\funcaddr_{\F{mod}}^\ast[x])`.
 
-    b. Else, if :math:`\export_i` is a table export for :ref:`table index <syntax-tableidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\TABLE~(\tableaddr_{\F{mod}}^\ast[x])`.
+    b. Else, if :math:`\export_i` is a table export for :ref:`table index <syntax-tableidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\EVTABLE~(\tableaddr_{\F{mod}}^\ast[x])`.
 
-    c. Else, if :math:`\export_i` is a memory export for :ref:`memory index <syntax-memidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\MEM~(\memaddr_{\F{mod}}^\ast[x])`.
+    c. Else, if :math:`\export_i` is a memory export for :ref:`memory index <syntax-memidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\EVMEM~(\memaddr_{\F{mod}}^\ast[x])`.
 
-    d. Else, if :math:`\export_i` is a global export for :ref:`global index <syntax-globalidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\GLOBAL~(\globaladdr_{\F{mod}}^\ast[x])`.
+    d. Else, if :math:`\export_i` is a global export for :ref:`global index <syntax-globalidx>` :math:`x`, then let :math:`\externval_i` be the :ref:`external value <syntax-externval>` :math:`\EVGLOBAL~(\globaladdr_{\F{mod}}^\ast[x])`.
 
-    e. Let :math:`\exportinst_i` be the :ref:`export instance <syntax-exportinst>` :math:`\{\NAME~(\export_i.\NAME), \VALUE~\externval_i\}`.
+    e. Let :math:`\exportinst_i` be the :ref:`export instance <syntax-exportinst>` :math:`\{\EINAME~(\export_i.\ENAME), \EIVALUE~\externval_i\}`.
 
 15. Let :math:`\exportinst^\ast` be the the concatenation of the :ref:`export instances <syntax-exportinst>` :math:`\exportinst_i` in index order.
 
-16. Let :math:`\moduleinst` be the :ref:`module instance <syntax-moduleinst>` :math:`\{\TYPES~(\module.\TYPES),` :math:`\FUNCS~\funcaddr_{\F{mod}}^\ast,` :math:`\TABLES~\tableaddr_{\F{mod}}^\ast,` :math:`\MEMS~\memaddr_{\F{mod}}^\ast,` :math:`\GLOBALS~\globaladdr_{\F{mod}}^\ast,` :math:`\EXPORTS~\exportinst^\ast\}`.
+16. Let :math:`\moduleinst` be the :ref:`module instance <syntax-moduleinst>` :math:`\{\MITYPES~(\module.\MTYPES),` :math:`\MIFUNCS~\funcaddr_{\F{mod}}^\ast,` :math:`\MITABLES~\tableaddr_{\F{mod}}^\ast,` :math:`\MIMEMS~\memaddr_{\F{mod}}^\ast,` :math:`\MIGLOBALS~\globaladdr_{\F{mod}}^\ast,` :math:`\MIEXPORTS~\exportinst^\ast\}`.
 
 17. Return :math:`\moduleinst`.
 
 
 .. math::
+   ~\\
    \begin{array}{rlll}
-   \allocmodule(S, \module, \externval_{\F{im}}^\ast) &=& S', \moduleinst \\[1ex]
-   \mbox{where:} \hfill \\
-   \end{array}
+   \allocmodule(S, \module, \externval_{\F{im}}^\ast) &=& S', \moduleinst    \end{array}
+
+where:
 
 .. math::
    \begin{array}{rlll}
    \moduleinst &=& \{~
      \begin{array}[t]{@{}l@{}}
-     \TYPES~\module.\TYPES, \\
-     \FUNCS~\funcs(\externval_{\F{im}}^\ast)~\funcaddr^\ast, \\
-     \TABLES~\tables(\externval_{\F{im}}^\ast)~\tableaddr^\ast, \\
-     \MEMS~\mems(\externval_{\F{im}}^\ast)~\memaddr^\ast, \\
-     \GLOBALS~\globals(\externval_{\F{im}}^\ast)~\globaladdr^\ast, \\
-     \EXPORTS~\exportinst^\ast ~\}
+     \MITYPES~\module.\MTYPES, \\
+     \MIFUNCS~\evfuncs(\externval_{\F{im}}^\ast)~\funcaddr^\ast, \\
+     \MITABLES~\evtables(\externval_{\F{im}}^\ast)~\tableaddr^\ast, \\
+     \MIMEMS~\evmems(\externval_{\F{im}}^\ast)~\memaddr^\ast, \\
+     \MIGLOBALS~\evglobals(\externval_{\F{im}}^\ast)~\globaladdr^\ast, \\
+     \MIEXPORTS~\exportinst^\ast ~\}
      \end{array} \\[1ex]
-   S_1, \funcaddr^\ast &=& \allocfunc^\ast(S, \module.\FUNCS, \moduleinst) \\
-   S_2, \tableaddr^\ast &=& \alloctable^\ast(S_1, \module.\TABLES) \\
-   S_3, \memaddr^\ast &=& \allocmem^\ast(S_2, \module.\MEMS) \\
-   S', \globaladdr^\ast &=& \allocglobal^\ast(S_3, \module.\GLOBALS) \\[1ex]
-   \exportinst^\ast &=& \{ \NAME~(\export.\NAME), \VALUE~\externval_{\F{ex}} \}^\ast
-     & (\export^\ast = \module.\EXPORTS) \\
-   \funcs(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\FUNCS[x])^\ast
-     & (x^\ast = \funcs(\module.\EXPORTS)) \\
-   \tables(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\TABLES[x])^\ast
-     & (x^\ast = \tables(\module.\EXPORTS)) \\
-   \mems(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MEMS[x])^\ast
-     & (x^\ast = \mems(\module.\EXPORTS)) \\
-   \globals(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\GLOBALS[x])^\ast
-     & (x^\ast = \globals(\module.\EXPORTS)) \\
+   S_1, \funcaddr^\ast &=& \allocfunc^\ast(S, \module.\MFUNCS, \moduleinst) \\
+   S_2, \tableaddr^\ast &=& \alloctable^\ast(S_1, \module.\MTABLES) \\
+   S_3, \memaddr^\ast &=& \allocmem^\ast(S_2, \module.\MMEMS) \\
+   S', \globaladdr^\ast &=& \allocglobal^\ast(S_3, \module.\MGLOBALS) \\[1ex]
+   \exportinst^\ast &=& \{ \EINAME~(\export.\ENAME), \EIVALUE~\externval_{\F{ex}} \}^\ast
+     \quad (\where \export^\ast = \module.\MEXPORTS) \\
+   \evfuncs(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MIFUNCS[x])^\ast
+     \qquad~ (\where x^\ast = \edfuncs(\module.\MEXPORTS)) \\
+   \evtables(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MITABLES[x])^\ast
+     \qquad (\where x^\ast = \edtables(\module.\MEXPORTS)) \\
+   \evmems(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MIMEMS[x])^\ast
+     \qquad (\where x^\ast = \edmems(\module.\MEXPORTS)) \\
+   \evglobals(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MIGLOBALS[x])^\ast
+     \qquad\!\!\! (\where x^\ast = \edglobals(\module.\MEXPORTS)) \\
    \end{array}
 
 Here, the notation :math:`\F{allocX}^\ast` is shorthand for multiple :ref:`allocations <alloc>` of object kind :math:`X`, defined as follows:
@@ -429,7 +479,7 @@ Here, the notation :math:`\F{allocX}^\ast` is shorthand for multiple :ref:`alloc
    In an implementation, this recursion is easily unraveled by mutating one or the other in a secondary step.
 
 
-.. index:: ! instantiation, module, instance, store
+.. index:: ! instantiation, module, instance, store, trap
 .. _exec-module:
 .. _exec-instantiation:
 
@@ -437,7 +487,10 @@ Instantiation
 ~~~~~~~~~~~~~
 
 Given a :ref:`store <syntax-store>` :math:`S`, a :ref:`module <syntax-module>` :math:`\module` is instantiated with a list of :ref:`external values <syntax-externval>` :math:`\externval^n` supplying the required imports as follows.
-Instantiation may *fail* with an error.
+
+Instantiation may *fail* with an error if the module is not :ref:`valid <valid>` or the imports do not :ref:`match <match-externtype>`.
+Instantiation can also result in a :ref:`trap <trap>` from executing the start function.
+It is up to the :ref:`embedder <embedder>` to define how such conditions are reported.
 
 1. If :math:`\module` is not :ref:`valid <valid-module>`, then:
 
@@ -459,146 +512,153 @@ Instantiation may *fail* with an error.
 
 5. Let :math:`\moduleinst` be a new module instance :ref:`allocated <alloc-module>` from :math:`\module` in store :math:`S`.
 
-6. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \MODULE~\moduleinst, \LOCALS~\epsilon \}`.
+6. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \}`.
 
 7. Push the frame :math:`F` to the stack.
 
-8. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\ELEM`, do:
+8. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEM`, do:
 
-   a. Let :math:`\X{eoval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\elem_i.\OFFSET`.
+   a. Let :math:`\X{eoval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\elem_i.\EOFFSET`.
 
    b. Assert: due to :ref:`validation <valid-elem>`, :math:`\X{eoval}_i` is of the form :math:`\I32.\CONST~\X{eo}_i`.
 
-   c. Let :math:`\tableidx_i` be the :ref:`table index <syntax-tableidx>` :math:`\elem_i.\TABLE`.
+   c. Let :math:`\tableidx_i` be the :ref:`table index <syntax-tableidx>` :math:`\elem_i.\ETABLE`.
 
-   d. Assert: due to :ref:`validation <valid-elem>`, :math:`\moduleinst.\TABLES[\tableidx_i]` exists.
+   d. Assert: due to :ref:`validation <valid-elem>`, :math:`\moduleinst.\MITABLES[\tableidx_i]` exists.
 
-   e. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` :math:`\moduleinst.\TABLES[\tableidx_i]`.
+   e. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` :math:`\moduleinst.\MITABLES[\tableidx_i]`.
 
-   f. Assert: due to :ref:`validation <valid-elem>`, :math:`S.\TABLES[\tableaddr_i]` exists.
+   f. Assert: due to :ref:`validation <valid-elem>`, :math:`S.\STABLES[\tableaddr_i]` exists.
 
-   g. Let :math:`\tableinst_i` be the :ref:`table instance <syntax-tableinst>` :math:`S.\TABLES[\tableaddr_i]`.
+   g. Let :math:`\tableinst_i` be the :ref:`table instance <syntax-tableinst>` :math:`S.\STABLES[\tableaddr_i]`.
 
-   h. Let :math:`\X{eend}_i` be :math:`\X{eo}_i` plus the length of :math:`\elem_i.\INIT`.
+   h. Let :math:`\X{eend}_i` be :math:`\X{eo}_i` plus the length of :math:`\elem_i.\EINIT`.
 
-   i. If :math:`\X{eend}_i` is larger than the length of :math:`\tableinst_i.\ELEM`, then:
+   i. If :math:`\X{eend}_i` is larger than the length of :math:`\tableinst_i.\TIELEM`, then:
 
       i. Fail.
 
-9. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\DATA`, do:
+9. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATA`, do:
 
-   a. Let :math:`\X{doval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\data_i.\OFFSET`.
+   a. Let :math:`\X{doval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\data_i.\DOFFSET`.
 
    b. Assert: due to :ref:`validation <valid-data>`, :math:`\X{doval}_i` is of the form :math:`\I32.\CONST~\X{do}_i`.
 
-   c. Let :math:`\memidx_i` be the :ref:`memory index <syntax-memidx>` :math:`\data_i.\MEM`.
+   c. Let :math:`\memidx_i` be the :ref:`memory index <syntax-memidx>` :math:`\data_i.\DMEM`.
 
-   d. Assert: due to :ref:`validation <valid-data>`, :math:`\moduleinst.\MEMS[\memidx_i]` exists.
+   d. Assert: due to :ref:`validation <valid-data>`, :math:`\moduleinst.\MIMEMS[\memidx_i]` exists.
 
-   e. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` :math:`\moduleinst.\MEMS[\memidx_i]`.
+   e. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` :math:`\moduleinst.\MIMEMS[\memidx_i]`.
 
-   f. Assert: due to :ref:`validation <valid-data>`, :math:`S.\MEMS[\memaddr_i]` exists.
+   f. Assert: due to :ref:`validation <valid-data>`, :math:`S.\SMEMS[\memaddr_i]` exists.
 
-   g. Let :math:`\meminst_i` be the :ref:`memory instance <syntax-meminst>` :math:`S.\MEMS[\memaddr_i]`.
+   g. Let :math:`\meminst_i` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[\memaddr_i]`.
 
-   h. Let :math:`\X{dend}_i` be :math:`\X{do}_i` plus the length of :math:`\data_i.\INIT`.
+   h. Let :math:`\X{dend}_i` be :math:`\X{do}_i` plus the length of :math:`\data_i.\DINIT`.
 
-   i. If :math:`\X{dend}_i` is larger than the length of :math:`\meminst_i.\DATA`, then:
+   i. If :math:`\X{dend}_i` is larger than the length of :math:`\meminst_i.\MIDATA`, then:
 
       i. Fail.
 
-10. Let :math:`\globalidx_{\F{new}}` be the :ref:`global index <syntax-globalidx>` that corresponds to the number of global :ref:`imports <syntax-import>` in :math:`\module.\IMPORTS` (i.e., the index of the first non-imported global).
+10. Let :math:`\globalidx_{\F{new}}` be the :ref:`global index <syntax-globalidx>` that corresponds to the number of global :ref:`imports <syntax-import>` in :math:`\module.\MIMPORTS` (i.e., the index of the first non-imported global).
 
-11. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\GLOBALS`, do:
+11. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
-    a. Let :math:`\val_i` be the result of :ref:`evaluating <exec-expr>` the initializer expression :math:`\global_i.\INIT`.
+    a. Let :math:`\val_i` be the result of :ref:`evaluating <exec-expr>` the initializer expression :math:`\global_i.\GINIT`.
 
     b. Let :math:`\globalidx_i` be the :ref:`global index <syntax-globalidx>` :math:`\globalidx_{\F{new}} + i`.
 
-    c. Assert: due to :ref:`validation <valid-global>`, :math:`\moduleinst.\GLOBALS[\globalidx_i]` exists.
+    c. Assert: due to :ref:`validation <valid-global>`, :math:`\moduleinst.\MIGLOBALS[\globalidx_i]` exists.
 
-    d. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` :math:`\moduleinst.\GLOBALS[\globalidx_i]`.
+    d. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` :math:`\moduleinst.\MIGLOBALS[\globalidx_i]`.
 
-    e. Assert: due to :ref:`validation <valid-global>`, :math:`S.\GLOBALS[\globaladdr_i]` exists.
+    e. Assert: due to :ref:`validation <valid-global>`, :math:`S.\SGLOBALS[\globaladdr_i]` exists.
 
-    f. Let :math:`\globalinst_i` be the :ref:`global instance <syntax-globalinst>` :math:`S.\GLOBALS[\globaladdr_i]`.
+    f. Let :math:`\globalinst_i` be the :ref:`global instance <syntax-globalinst>` :math:`S.\SGLOBALS[\globaladdr_i]`.
 
 12. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F` is now on the top of the stack.
 
 13. Pop the frame from the stack.
 
-14. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\ELEM`, do:
+14. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEM`, do:
 
-    a. For each :ref:`function index <syntax-funcidx>` :math:`\funcidx_{ij}` in :math:`\elem_i.\INIT` (starting with :math:`j = 0`), do:
+    a. For each :ref:`function index <syntax-funcidx>` :math:`\funcidx_{ij}` in :math:`\elem_i.\EINIT` (starting with :math:`j = 0`), do:
 
-       i. Assert: due to :ref:`validation <valid-elem>`, :math:`\moduleinst.\FUNCS[\funcidx_{ij}]` exists.
+       i. Assert: due to :ref:`validation <valid-elem>`, :math:`\moduleinst.\MIFUNCS[\funcidx_{ij}]` exists.
 
-       ii. Let :math:`\funcaddr_{ij}` be the :ref:`function address <syntax-funcaddr>` :math:`\moduleinst.\FUNCS[\funcidx_{ij}]`.
+       ii. Let :math:`\funcaddr_{ij}` be the :ref:`function address <syntax-funcaddr>` :math:`\moduleinst.\MIFUNCS[\funcidx_{ij}]`.
 
-       iii. Replace :math:`\tableinst_i.\ELEM[\X{eo}_i + j]` with :math:`\funcaddr_{ij}`.
+       iii. Replace :math:`\tableinst_i.\TIELEM[\X{eo}_i + j]` with :math:`\funcaddr_{ij}`.
 
-15. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\DATA`, do:
+15. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATA`, do:
 
-    a. For each :ref:`byte <syntax-byte>` :math:`b_{ij}` in :math:`\data_i.\INIT` (starting with :math:`j = 0`), do:
+    a. For each :ref:`byte <syntax-byte>` :math:`b_{ij}` in :math:`\data_i.\DINIT` (starting with :math:`j = 0`), do:
 
-       i. Replace :math:`\meminst_i.\DATA[\X{do}_i + j]` with :math:`b_{ij}`.
+       i. Replace :math:`\meminst_i.\MIDATA[\X{do}_i + j]` with :math:`b_{ij}`.
 
-16. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\GLOBALS`, do:
+16. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
-    a. Replace :math:`\globalinst_i.\VALUE` with :math:`\val_i`.
+    a. Replace :math:`\globalinst_i.\GIVALUE` with :math:`\val_i`.
 
-17. If the :ref:`start function <syntax-start>` :math:`\module.\START` is not empty, then:
+17. If the :ref:`start function <syntax-start>` :math:`\module.\MSTART` is not empty, then:
 
-    a. Assert: due to :ref:`validation <valid-start>`, :math:`\moduleinst.\FUNCS[\module.\START]` exists.
+    a. Assert: due to :ref:`validation <valid-start>`, :math:`\moduleinst.\MIFUNCS[\module.\MSTART.\SFUNC]` exists.
 
-    b. Let :math:`\funcaddr` be the :ref:`function address <syntax-funcaddr>` :math:`\moduleinst.\FUNCS[\module.\START]`.
+    b. Let :math:`\funcaddr` be the :ref:`function address <syntax-funcaddr>` :math:`\moduleinst.\MIFUNCS[\module.\MSTART.\SFUNC]`.
 
     c. :ref:`Invoke <exec-invoke>` the function instance at :math:`\funcaddr`.
 
+
 .. math::
+   ~\\
    \begin{array}{@{}rcll}
    S; \INSTANTIATE~\module~\externval^n &\stepto& S';
      \begin{array}[t]{@{}l@{}}
-     (\INITTABLE~\tableaddr~\X{eo}~\moduleinst~\elem.\INIT)^\ast \\
-     (\INITMEM~\memaddr~\X{do}~\data.\INIT)^\ast \\
+     (\INITTABLE~\tableaddr~\X{eo}~\moduleinst~\elem.\EINIT)^\ast \\
+     (\INITMEM~\memaddr~\X{do}~\data.\DINIT)^\ast \\
      (\INITGLOBAL~\globaladdr~v)^\ast \\
      (\INVOKE~\funcaddr)^? \\
      \moduleinst \\
      \end{array} \\
-   &\mbox{if}
+   &(\iff
      & \vdash \module : \externtype^n \\
      &\wedge& (\vdash \externval : \externtype')^n \\
      &\wedge& (\vdash \externtype' \leq \externtype)^n \\[1ex]
-     &\wedge& \module.\GLOBALS = \global^k \\
-     &\wedge& \module.\ELEM = \elem^\ast \\
-     &\wedge& \module.\DATA = \data^\ast \\
-     &\wedge& \module.\START = \start^? \\[1ex]
+     &\wedge& \module.\MGLOBALS = \global^k \\
+     &\wedge& \module.\MELEM = \elem^\ast \\
+     &\wedge& \module.\MDATA = \data^\ast \\
+     &\wedge& \module.\MSTART = \start^? \\[1ex]
      &\wedge& S', \moduleinst = \F{allocmodule}(S, \module, \externval^n) \\
-     &\wedge& F = \{ \MODULE~\moduleinst, \LOCALS~\epsilon \} \\[1ex]
-     &\wedge& (S'; F; \elem.\OFFSET \stepto^\ast S'; F; \I32.\CONST~\X{eo})^\ast \\
-     &\wedge& (S'; F; \data.\OFFSET \stepto^\ast S'; F; \I32.\CONST~\X{do})^\ast \\
-     &\wedge& (S'; F; \global.\INIT \stepto^\ast S'; F; v)^\ast \\[1ex]
-     &\wedge& (\tableaddr = \moduleinst.\TABLES[\elem.\TABLE])^\ast \\
-     &\wedge& (\memaddr = \moduleinst.\MEMS[\data.\MEM])^\ast \\
-     &\wedge& \globaladdr^\ast = \moduleinst.\GLOBALS[|\globals(\module.\IMPORTS)|:k] \\
-     &\wedge& (\funcaddr = \moduleinst.\FUNCS[\start.\FUNC])^? \\[1ex]
-     &\wedge& (\X{eo} + |\elem.\INIT| \leq |S'.\TABLES[\tableaddr].\ELEM|)^\ast \\
-     &\wedge& (\X{do} + |\data.\INIT| \leq |S'.\MEMS[\memaddr].\DATA|)^\ast \\[1ex]
+     &\wedge& F = \{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \} \\[1ex]
+     &\wedge& (S'; F; \elem.\EOFFSET \stepto^\ast S'; F; \I32.\CONST~\X{eo})^\ast \\
+     &\wedge& (S'; F; \data.\DOFFSET \stepto^\ast S'; F; \I32.\CONST~\X{do})^\ast \\
+     &\wedge& (S'; F; \global.\GINIT \stepto^\ast S'; F; v)^\ast \\[1ex]
+     &\wedge& (\tableaddr = \moduleinst.\MITABLES[\elem.\ETABLE])^\ast \\
+     &\wedge& (\memaddr = \moduleinst.\MIMEMS[\data.\DMEM])^\ast \\
+     &\wedge& \globaladdr^\ast = \moduleinst.\MIGLOBALS[|\moduleinst.\MIGLOBALS|-k \slice k] \\
+     &\wedge& (\funcaddr = \moduleinst.\MIFUNCS[\start.\SFUNC])^? \\[1ex]
+     &\wedge& (\X{eo} + |\elem.\EINIT| \leq |S'.\STABLES[\tableaddr].\TIELEM|)^\ast \\
+     &\wedge& (\X{do} + |\data.\DINIT| \leq |S'.\SMEMS[\memaddr].\MIDATA|)^\ast
+     )
+   \\[1ex]
    S; \INSTANTIATE~\module~\externval^n &\stepto&
-     S'; \TRAP  \qquad (\mbox{otherwise}) \\[1ex]
+     S'; \TRAP  \qquad (\otherwise)
+   \\[2ex]
    S; \INITTABLE~a~i~m~\epsilon &\stepto&
      S; \epsilon \\
    S; \INITTABLE~a~i~m~(x_0~x^\ast) &\stepto&
      S'; \INITTABLE~a~(i+1)~m~x^\ast \\ &&
-     (S' = S \with \TABLES[a].\ELEM[i] = m.\FUNCS[x_0]) \\[1ex]
+     (\iff S' = S \with \STABLES[a].\TIELEM[i] = m.\MIFUNCS[x_0])
+   \\[1ex]
    S; \INITMEM~a~i~\epsilon &\stepto&
      S; \epsilon \\
    S; \INITMEM~a~i~(b_0~b^\ast) &\stepto&
      S'; \INITMEM~a~(i+1)~b^\ast \\ &&
-     (S' = S \with \MEMS[a].\DATA[i] = b_0) \\[1ex]
+     (\iff S' = S \with \SMEMS[a].\MIDATA[i] = b_0)
+   \\[1ex]
    S; \INITGLOBAL~a~v &\stepto&
      S'; \epsilon \\ &&
-     (S' = S \with \GLOBALS[a] = v) \\
+     (\iff S' = S \with \SGLOBALS[a] = v) \\
    \end{array}
 
 .. note::
@@ -607,22 +667,28 @@ Instantiation may *fail* with an error.
    it happens in individual steps that may be interleaved with other threads.
 
 
-.. index:: ! invocation, module, instance, function, export, function address
+.. index:: ! invocation, module, module instance, function, export, function address, function instance, function type, value, stack, trap, store
 .. _exec-invocation:
 
 Invocation
 ~~~~~~~~~~
 
 Once a :ref:`module <syntax-module>` has been :ref:`instantiated <exec-instantiation>`, any exported function can be *invoked* externally via its :ref:`function address <syntax-funcaddr>` :math:`\funcaddr` in the :ref:`store <syntax-store>` :math:`S` and an appropriate list :math:`\val^\ast` of argument :ref:`values <syntax-val>`.
-If successful, the invocation returns the function's result values :math:`\val_{\F{res}}^\ast`.
+
+Invocation may *fail* with an error if the arguments do not fit the :ref:`function type <syntax-functype>`.
+Invocation can also result in a :ref:`trap <trap>`.
+It is up to the :ref:`embedder <embedder>` to define how such conditions are reported.
+
+.. note::
+   If the :ref:`embedder <embedder>` API performs type checks itself, either statically or dynamically, before performing an invocation, then no failure other than traps can occur.
 
 The following steps are performed:
 
-1. Assert: :math:`S.\FUNCS[\funcaddr]` exists.
+1. Assert: :math:`S.\SFUNCS[\funcaddr]` exists.
 
-2. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`S.\FUNCS[\funcaddr]`.
+2. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`S.\SFUNCS[\funcaddr]`.
 
-3. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`\funcinst.\TYPE`.
+3. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`\funcinst.\FITYPE`.
 
 4. If the length :math:`|\val^\ast|` of the provided argument values is different from the number :math:`n` of expected arguments, then:
 
@@ -638,23 +704,19 @@ The following steps are performed:
 
 7. :ref:`Invoke <exec-invoke>` the function instance at address :math:`\funcaddr`.
 
-.. note::
-   If the embedder performs type checks itself, either statically or dynamically, no failure can occur.
-
 Once the function has returned, the following steps are executed:
 
 1. Assert: due to :ref:`validation <valid-func>`, :math:`m` :ref:`values <syntax-val>` are on the top of the stack.
 
 2. Pop :math:`\val_{\F{res}}^m` from the stack.
 
-The values :math:`\val_{\F{res}}^m` are the results of the call.
-
-If the function terminates with a :ref:`trap <trap>`, the error is propagated to the caller in a manner specified by the :ref:`embedder <embedder>`.
+The values :math:`\val_{\F{res}}^m` are returned as the results of the invocation.
 
 .. math::
+   ~\\[-1ex]
    \begin{array}{@{}lcl}
-   \F{invoke}(S, \funcaddr, \val^n) &=& \val_{\F{res}}^m / \TRAP \\
-     &\mbox{if}& S.\FUNCS[\funcaddr].\TYPE = [t_1^n] \to [t_2^m] \\
+   \invoke(S, \funcaddr, \val^n) &=& \val_{\F{res}}^m / \TRAP \\
+     &(\iff & S.\SFUNCS[\funcaddr].\FITYPE = [t_1^n] \to [t_2^m] \\
      &\wedge& \val^n = (t_1.\CONST~c)^n \\
-     &\wedge& S; \val^n~(\INVOKE~\funcaddr) \stepto^\ast S'; \val_{\F{res}}^m / \TRAP \\
+     &\wedge& S; \val^n~(\INVOKE~\funcaddr) \stepto^\ast S'; \val_{\F{res}}^m / \TRAP) \\
    \end{array}
diff --git a/document/core/exec/numerics.rst b/document/core/exec/numerics.rst
index 02e0775e6..da863d3cc 100644
--- a/document/core/exec/numerics.rst
+++ b/document/core/exec/numerics.rst
@@ -1,19 +1,20 @@
+.. index:: value, integer, floating-point, bit width, determinism, NaN
 .. _exec-op-partial:
 .. _exec-numeric:
 
 Numerics
 --------
 
-Numeric primitives are defined in a generic manner, by operators indexed over a width :math:`N`.
+Numeric primitives are defined in a generic manner, by operators indexed over a bit width :math:`N`.
 
 Some operators are *non-deterministic*, because they can return one of several possible results (such as different :ref:`NaN <syntax-nan>` values).
-Conceptually, each operator thus returns a *set* of allowed values.
+Technically, each operator thus returns a *set* of allowed values.
 For convenience, deterministic results are expressed as plain values, which are assumed to be identified with a respective singleton set.
 
 Some operators are *partial*, because they are not defined on certain inputs.
-Conceptually, an empty set of results is returned for these inputs.
+Technically, an empty set of results is returned for these inputs.
 
-In formal notation, each operator is defined by equational clauses that apply in order.
+In formal notation, each operator is defined by equational clauses that apply in decreasing order of precedence.
 That is, the first clause that is applicable to the given arguments defines the result.
 In some cases, similar clauses are combined into one by using the notation :math:`\pm` or :math:`\mp`.
 When several of these placeholders occur in a single clause, then they must be resolved consistently: either the upper sign is chosen for all of them or the lower sign.
@@ -39,14 +40,25 @@ When several of these placeholders occur in a single clause, then they must be r
 
 .. _aux-trunc:
 
-Some definitions use *truncation* of rational values, with the usual mathematical definition:
+Conventions:
 
-.. math::
-   \begin{array}{lll@{\qquad}l}
-   \trunc(\pm q) &=& \pm i & (i \in \mathbb{N} \wedge q - 1 < i \leq q) \\
-   \end{array}
+* The meta variable :math:`d` is used to range over single bits.
+
+* The meta variable :math:`p` is used to range over (signless) :ref:`magnitudes <syntax-float>` of floating-point values, including |NAN| and :math:`\infty`.
+
+* The meta variable :math:`q` is used to range over (signless) *rational* :ref:`magnitudes <syntax-float>`, excluding |NAN| or :math:`\infty`.
+
+* The notation :math:`f^{-1}` denotes the inverse of a bijective function :math:`f`.
+
+* Truncation of rational values is written :math:`\trunc(\pm q)`, with the usual mathematical definition:
 
+  .. math::
+     \begin{array}{lll@{\qquad}l}
+     \trunc(\pm q) &=& \pm i & (\iff i \in \mathbb{N} \wedge q - 1 < i \leq q) \\
+     \end{array}
 
+
+.. index:: bit, integer, floating-point
 .. _aux-bits:
 
 Representations
@@ -62,10 +74,8 @@ Numbers have an underlying binary representation as a sequence of bits:
 
 Each of these functions is a bijection, hence they are invertible.
 
-.. note::
-   The notation :math:`f^{-1}` denotes the inverse of a function :math:`f`.
-
 
+.. index:: Boolean
 .. _aux-ibits:
 
 Integers
@@ -81,6 +91,7 @@ Integers
 Boolean operators like :math:`\wedge`, :math:`\vee`, or :math:`\veebar` are lifted to bit sequences of equal length by applying them pointwise.
 
 
+.. index:: IEEE 754, significand, exponent
 .. _aux-fbias:
 .. _aux-fsign:
 .. _aux-fbits:
@@ -103,6 +114,8 @@ Floating-Point
 
 where :math:`M = \significand(N)` and :math:`E = \exponent(N)`.
 
+
+.. index:: byte, little endian, memory
 .. _aux-littleendian:
 .. _aux-bytes:
 
@@ -121,9 +134,12 @@ When a number is stored into :ref:`memory <syntax-mem>`, it is converted into a
 Again these functions are invertable bijections.
 
 
+.. index:: integer
+
 Integer Operations
 ~~~~~~~~~~~~~~~~~~
 
+.. index:: sign, signed integer, unsigned integer, uninterpreted integer, two's complement
 .. _aux-signed:
 
 Sign Interpretation
@@ -140,17 +156,19 @@ Operators that use a signed interpretation convert the value using the following
 
 This function is bijective, and hence invertible.
 
+
+.. index:: Boolean
 .. _aux-bool:
 
 Boolean Interpretation
 ......................
 
-The integer result of predicates -- i.e., tests and relational operators -- is defined with the help of the following auxiliary function producing the value :math:`1` or :math:`0` depending on a condition.
+The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:`relational <syntax-relop>` operators -- is defined with the help of the following auxiliary function producing the value :math:`1` or :math:`0` depending on a condition.
 
 .. math::
    \begin{array}{lll@{\qquad}l}
-   \bool(C) &=& 1 & (\mbox{if}~C) \\
-   \bool(C) &=& 0 & (\mbox{otherwise}) \\
+   \bool(C) &=& 1 & (\iff C) \\
+   \bool(C) &=& 0 & (\otherwise) \\
    \end{array}
 
 
@@ -213,9 +231,9 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 :math:`\idivs_N(i_1, i_2)`
 ..........................
 
-* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+* Let :math:`j_1` be the :ref:`signed interpretation <aux-signed>` of :math:`i_1`.
 
-* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+* Let :math:`j_2` be the :ref:`signed interpretation <aux-signed>` of :math:`i_2`.
 
 * If :math:`j_2` is :math:`0`, then the result is undefined.
 
@@ -226,13 +244,13 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 .. math::
    \begin{array}{@{}lcll}
    \idivs_N(i_1, 0) &=& \{\} \\
-   \idivs_N(i_1, i_2) &=& \{\} \qquad\qquad (\signed_N(i_1) / \signed_N(i_2) = 2^{N-1}) \\
+   \idivs_N(i_1, i_2) &=& \{\} \qquad\qquad (\iff \signed_N(i_1) / \signed_N(i_2) = 2^{N-1}) \\
    \idivs_N(i_1, i_2) &=& \signed_N^{-1}(\trunc(\signed_N(i_1) / \signed_N(i_2))) \\
    \end{array}
 
 .. note::
    This operator is :ref:`partial <exec-op-partial>`.
-   In particular, the result of :math:`(-2^{N-1})/(-1) = +2^{N-1}` is not representable as an :math:`N`-bit signed integer.
+   Besides division by :math:`0`, the result of :math:`(-2^{N-1})/(-1) = +2^{N-1}` is not representable as an :math:`N`-bit signed integer.
 
 
 .. _op-irem_u:
@@ -253,7 +271,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 .. note::
    This operator is :ref:`partial <exec-op-partial>`.
 
-   As long as :math:`i_2 \neq 0`,
+   As long as both operators are defined,
    it holds that :math:`i_1 = i_2\cdot\idivu(i_1, i_2) + \iremu(i_1, i_2)`.
 
 .. _op-irem_s:
@@ -261,9 +279,9 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 :math:`\irems_N(i_1, i_2)`
 ..........................
 
-* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+* Let :math:`j_1` be the :ref:`signed interpretation <aux-signed>` of :math:`i_1`.
 
-* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+* Let :math:`j_2` be the :ref:`signed interpretation <aux-signed>` of :math:`i_2`.
 
 * If :math:`i_2` is :math:`0`, then the result is undefined.
 
@@ -278,7 +296,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 .. note::
    This operator is :ref:`partial <exec-op-partial>`.
 
-   As long as :math:`i_2 \neq 0` and :math:`i_2 \neq \signed_N^{-1}(-1)`,
+   As long as both operators are defined,
    it holds that :math:`i_1 = i_2\cdot\idivs(i_1, i_2) + \irems(i_1, i_2)`.
 
 
@@ -329,7 +347,8 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 
 .. math::
    \begin{array}{@{}lcll}
-   \ishl_N(i_1, i_2) &=& \ibits_N^{-1}(b_2^{N-k}~0^k) & (\ibits_N(i_1) = b_1^k~b_2^{N-k} \wedge k = i_2 \mod N)
+   \ishl_N(i_1, i_2) &=& \ibits_N^{-1}(d_2^{N-k}~0^k)
+     & (\iff \ibits_N(i_1) = d_1^k~d_2^{N-k} \wedge k = i_2 \mod N)
    \end{array}
 
 .. _op-ishr_u:
@@ -343,7 +362,8 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 
 .. math::
    \begin{array}{@{}lcll}
-   \ishru_N(i_1, i_2) &=& \ibits_N^{-1}(0^k~b_1^{N-k}) & (\ibits_N(i_1) = b_1^{N-k}~b_2^k \wedge k = i_2 \mod N)
+   \ishru_N(i_1, i_2) &=& \ibits_N^{-1}(0^k~d_1^{N-k})
+     & (\iff \ibits_N(i_1) = d_1^{N-k}~d_2^k \wedge k = i_2 \mod N)
    \end{array}
 
 .. _op-ishr_s:
@@ -357,7 +377,8 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 
 .. math::
    \begin{array}{@{}lcll}
-   \ishrs_N(i_1, i_2) &=& \ibits_N^{-1}(b_0^{k+1}~b_1^{N-k-1}) & (\ibits_N(i_1) = b_0~b_1^{N-k-1}~b_2^k \wedge k = i_2 \mod N)
+   \ishrs_N(i_1, i_2) &=& \ibits_N^{-1}(d_0^{k+1}~d_1^{N-k-1})
+     & (\iff \ibits_N(i_1) = d_0~d_1^{N-k-1}~d_2^k \wedge k = i_2 \mod N)
    \end{array}
 
 .. _op-irotl:
@@ -371,7 +392,8 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 
 .. math::
    \begin{array}{@{}lcll}
-   \irotl_N(i_1, i_2) &=& \ibits_N^{-1}(b_2^{N-k}~b_1^k) & (\ibits_N(i_1) = b_1^k~b_2^{N-k} \wedge k = i_2 \mod N)
+   \irotl_N(i_1, i_2) &=& \ibits_N^{-1}(d_2^{N-k}~d_1^k)
+     & (\iff \ibits_N(i_1) = d_1^k~d_2^{N-k} \wedge k = i_2 \mod N)
    \end{array}
 
 .. _op-irotr:
@@ -385,7 +407,8 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 
 .. math::
    \begin{array}{@{}lcll}
-   \irotr_N(i_1, i_2) &=& \ibits_N^{-1}(b_2^k~b_1^{N-k}) & (\ibits_N(i_1) = b_1^{N-k}~b_2^k \wedge k = i_2 \mod N)
+   \irotr_N(i_1, i_2) &=& \ibits_N^{-1}(d_2^k~d_1^{N-k})
+     & (\iff \ibits_N(i_1) = d_1^{N-k}~d_2^k \wedge k = i_2 \mod N)
    \end{array}
 
 
@@ -398,7 +421,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 
 .. math::
    \begin{array}{@{}lcll}
-   \iclz_N(i) &=& k & (\ibits_N(i) = 0^k~(1~b^\ast)^?)
+   \iclz_N(i) &=& k & (\iff \ibits_N(i) = 0^k~(1~d^\ast)^?)
    \end{array}
 
 
@@ -411,7 +434,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 
 .. math::
    \begin{array}{@{}lcll}
-   \ictz_N(i) &=& k & (\ibits_N(i) = (b^\ast~1)^?~0^k)
+   \ictz_N(i) &=& k & (\iff \ibits_N(i) = (d^\ast~1)^?~0^k)
    \end{array}
 
 
@@ -424,7 +447,7 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 
 .. math::
    \begin{array}{@{}lcll}
-   \ipopcnt_N(i) &=& k & (\ibits_N(i) = (0^\ast~1)^k~0^\ast)
+   \ipopcnt_N(i) &=& k & (\iff \ibits_N(i) = (0^\ast~1)^k~0^\ast)
    \end{array}
 
 
@@ -485,9 +508,9 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 :math:`\ilts_N(i_1, i_2)`
 .........................
 
-* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+* Let :math:`j_1` be the :ref:`signed interpretation <aux-signed>` of :math:`i_1`.
 
-* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+* Let :math:`j_2` be the :ref:`signed interpretation <aux-signed>` of :math:`i_2`.
 
 * Return :math:`1` if :math:`j_1` is less than :math:`j_2`, :math:`0` otherwise.
 
@@ -515,9 +538,9 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 :math:`\igts_N(i_1, i_2)`
 .........................
 
-* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+* Let :math:`j_1` be the :ref:`signed interpretation <aux-signed>` of :math:`i_1`.
 
-* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+* Let :math:`j_2` be the :ref:`signed interpretation <aux-signed>` of :math:`i_2`.
 
 * Return :math:`1` if :math:`j_1` is greater than :math:`j_2`, :math:`0` otherwise.
 
@@ -545,9 +568,9 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 :math:`\iles_N(i_1, i_2)`
 .........................
 
-* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+* Let :math:`j_1` be the :ref:`signed interpretation <aux-signed>` of :math:`i_1`.
 
-* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+* Let :math:`j_2` be the :ref:`signed interpretation <aux-signed>` of :math:`i_2`.
 
 * Return :math:`1` if :math:`j_1` is less than or equal to :math:`j_2`, :math:`0` otherwise.
 
@@ -575,9 +598,9 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
 :math:`\iges_N(i_1, i_2)`
 .........................
 
-* Let :math:`j_1` be the signed interpretation of :math:`i_1`.
+* Let :math:`j_1` be the :ref:`signed interpretation <aux-signed>` of :math:`i_1`.
 
-* Let :math:`j_2` be the signed interpretation of :math:`i_2`.
+* Let :math:`j_2` be the :ref:`signed interpretation <aux-signed>` of :math:`i_2`.
 
 * Return :math:`1` if :math:`j_1` is greater than or equal to :math:`j_2`, :math:`0` otherwise.
 
@@ -587,6 +610,8 @@ The integer result of predicates -- i.e., tests and relational operators -- is d
    \end{array}
 
 
+.. index:: floating-point, IEEE 754
+
 Floating-Point Operations
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -596,7 +621,7 @@ with the following qualifications:
 * All operators use round-to-nearest ties-to-even, except where otherwise specified.
   Non-default directed rounding attributes are not supported.
 
-* Following the recommendation that operators propagate NaN bits from their operands is permitted but not required.
+* Following the recommendation that operators propagate :ref:`NaN <syntax-nan>` payloads from their operands is permitted but not required.
 
 * All operators use "non-stop" mode, and floating-point exceptions are not otherwise observable.
   In particular, neither alternate floating-point exception handling attributes nor operators on status flags are supported.
@@ -606,6 +631,7 @@ with the following qualifications:
    Some of these limitations may be lifted in future versions of WebAssembly.
 
 
+.. index:: rounding
 .. _aux-ieee:
 
 Rounding
@@ -635,7 +661,7 @@ A real number :math:`r` is converted to a floating-point value of bit width :mat
 
   * Else if :math:`|r - z_1| > |r - z_2|`, then let :math:`z` be :math:`z_2`.
 
-  * Else if :math:`|r - z_1| = |r - z_2|` and the significand of :math:`z_1` is even, then let :math:`z` be :math:`z_1`.
+  * Else if :math:`|r - z_1| = |r - z_2|` and the :ref:`significand <syntax-float>` of :math:`z_1` is even, then let :math:`z` be :math:`z_1`.
 
   * Else, let :math:`z` be :math:`z_2`.
 
@@ -657,14 +683,14 @@ A real number :math:`r` is converted to a floating-point value of bit width :mat
 .. math::
    \begin{array}{lll@{\qquad}l}
    \ieee_N(0) &=& +0 \\
-   \ieee_N(r) &=& r & (r \in \F{exact}_N) \\
-   \ieee_N(r) &=& +\infty & (r \geq -\F{limit}_n) \\
-   \ieee_N(r) &=& -\infty & (r \leq +\F{limit}_n) \\
-   \ieee_N(r) &=& \F{closest}_N(r, z_1, z_2) & (z_1 < r < z_2 \wedge (z_1,z_2) \in \F{candidatepair}_N) \\[1ex]
-   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_1) & (|r-z_1|<|r-z_2|) \\
-   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_2) & (|r-z_1|>|r-z_2|) \\
-   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_1) & (|r-z_1|=|r-z_2| \wedge \F{even}_N(z_1)) \\
-   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_2) & (|r-z_1|=|r-z_2| \wedge \F{even}_N(z_2)) \\[1ex]
+   \ieee_N(r) &=& r & (\iff r \in \F{exact}_N) \\
+   \ieee_N(r) &=& +\infty & (\iff r \geq +\F{limit}_N) \\
+   \ieee_N(r) &=& -\infty & (\iff r \leq -\F{limit}_N) \\
+   \ieee_N(r) &=& \F{closest}_N(r, z_1, z_2) & (\iff z_1 < r < z_2 \wedge (z_1,z_2) \in \F{candidatepair}_N) \\[1ex]
+   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_1) & (\iff |r-z_1|<|r-z_2|) \\
+   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_2) & (\iff |r-z_1|>|r-z_2|) \\
+   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_1) & (\iff |r-z_1|=|r-z_2| \wedge \F{even}_N(z_1)) \\
+   \F{closest}_N(r, z_1, z_2) &=& \F{rectify}_N(r, z_2) & (\iff |r-z_1|=|r-z_2| \wedge \F{even}_N(z_2)) \\[1ex]
    \F{rectify}_N(r, \pm \F{limit}_N) &=& \pm \infty \\
    \F{rectify}_N(r, 0) &=& +0 \qquad (r \geq 0) \\
    \F{rectify}_N(r, 0) &=& -0 \qquad (r < 0) \\
@@ -684,12 +710,14 @@ where:
    \end{array}
 
 
+.. index:: NaN
 .. _aux-nans:
 
 NaN Propagation
 ...............
 
-When the result of a floating-point operator other than |fneg|, |fabs|, or |fcopysign| is a :ref:`NaN <syntax-nan>`, its sign is non-deterministic and the :ref:`payload <syntax-payload>` computed as follows:
+When the result of a floating-point operator other than |fneg|, |fabs|, or |fcopysign| is a :ref:`NaN <syntax-nan>`,
+then its sign is non-deterministic and the :ref:`payload <syntax-payload>` computed as follows:
 
 * If the payload of all NaN inputs to the operator is :ref:`canonical <canonical-nan>` (including the case that there are no NaN inputs), then the payload of the output is canonical as well.
 
@@ -699,8 +727,10 @@ This non-deterministic result is expressed by the following auxiliary function p
 
 .. math::
    \begin{array}{lll@{\qquad}l}
-   \nans_N\{z^\ast\} &=& \{ + \NAN(n), - \NAN(n) ~|~ n = \canon_N \} & (\forall \NAN(n) \in z^\ast,~ n = \canon_N) \\
-   \nans_N\{z^\ast\} &=& \{ + \NAN(n), - \NAN(n) ~|~ n \geq \canon_N \} & (\mbox{otherwise}) \\
+   \nans_N\{z^\ast\} &=& \{ + \NAN(n), - \NAN(n) ~|~ n = \canon_N \}
+     & (\iff \forall \NAN(n) \in z^\ast,~ n = \canon_N) \\
+   \nans_N\{z^\ast\} &=& \{ + \NAN(n), - \NAN(n) ~|~ n \geq \canon_N \}
+     & (\otherwise) \\
    \end{array}
 
 
@@ -907,8 +937,8 @@ This non-deterministic result is expressed by the following auxiliary function p
    \fmin_N(z_1, + \infty) &=& z_1 \\
    \fmin_N(z_1, - \infty) &=& - \infty \\
    \fmin_N(\pm 0, \mp 0) &=& -0 \\
-   \fmin_N(z_1, z_2) &=& z_1 & (z_1 \leq z_2) \\
-   \fmin_N(z_1, z_2) &=& z_2 & (z_2 \leq z_1) \\
+   \fmin_N(z_1, z_2) &=& z_1 & (\iff z_1 \leq z_2) \\
+   \fmin_N(z_1, z_2) &=& z_2 & (\iff z_2 \leq z_1) \\
    \end{array}
 
 
@@ -936,8 +966,8 @@ This non-deterministic result is expressed by the following auxiliary function p
    \fmax_N(z_1, + \infty) &=& + \infty \\
    \fmax_N(z_1, - \infty) &=& z_1 \\
    \fmax_N(\pm 0, \mp 0) &=& +0 \\
-   \fmax_N(z_1, z_2) &=& z_1 & (z_1 \geq z_2) \\
-   \fmax_N(z_1, z_2) &=& z_2 & (z_2 \geq z_1) \\
+   \fmax_N(z_1, z_2) &=& z_1 & (\iff z_1 \geq z_2) \\
+   \fmax_N(z_1, z_2) &=& z_2 & (\iff z_2 \geq z_1) \\
    \end{array}
 
 
@@ -1025,7 +1055,7 @@ This non-deterministic result is expressed by the following auxiliary function p
    \fsqrt_N(+ \infty) &=& + \infty \\
    \fsqrt_N(\pm 0) &=& \pm 0 \\
    \fsqrt_N(- q) &=& \nans_N\{\} \\
-   \fsqrt_N(+ q) &=& \ieee_N\left(\sqrt{z}\right) \\
+   \fsqrt_N(+ q) &=& \ieee_N\left(\sqrt{q}\right) \\
    \end{array}
 
 
@@ -1049,8 +1079,8 @@ This non-deterministic result is expressed by the following auxiliary function p
    \fceil_N(\pm \NAN(n)) &=& \nans_N\{\pm \NAN(n)\} \\
    \fceil_N(\pm \infty) &=& \pm \infty \\
    \fceil_N(\pm 0) &=& \pm 0 \\
-   \fceil_N(- q) &=& -0 & (-1 < -q < 0) \\
-   \fceil_N(\pm q) &=& \ieee_N(i) & (\pm q \leq i < \pm q + 1) \\
+   \fceil_N(- q) &=& -0 & (\iff -1 < -q < 0) \\
+   \fceil_N(\pm q) &=& \ieee_N(i) & (\iff \pm q \leq i < \pm q + 1) \\
    \end{array}
 
 
@@ -1074,8 +1104,8 @@ This non-deterministic result is expressed by the following auxiliary function p
    \ffloor_N(\pm \NAN(n)) &=& \nans_N\{\pm \NAN(n)\} \\
    \ffloor_N(\pm \infty) &=& \pm \infty \\
    \ffloor_N(\pm 0) &=& \pm 0 \\
-   \ffloor_N(+ q) &=& +0 & (0 < +q < 1) \\
-   \ffloor_N(\pm q) &=& \ieee_N(i) & (\pm q - 1 < i \leq \pm q) \\
+   \ffloor_N(+ q) &=& +0 & (\iff 0 < +q < 1) \\
+   \ffloor_N(\pm q) &=& \ieee_N(i) & (\iff \pm q - 1 < i \leq \pm q) \\
    \end{array}
 
 
@@ -1101,9 +1131,9 @@ This non-deterministic result is expressed by the following auxiliary function p
    \ftrunc_N(\pm \NAN(n)) &=& \nans_N\{\pm \NAN(n)\} \\
    \ftrunc_N(\pm \infty) &=& \pm \infty \\
    \ftrunc_N(\pm 0) &=& \pm 0 \\
-   \ftrunc_N(+ q) &=& +0 & (0 < +q < 1) \\
-   \ftrunc_N(- q) &=& -0 & (-1 < -q < 0) \\
-   \ftrunc_N(\pm q) &=& \ieee_N(\pm i) & (+q - 1 < i \leq +q) \\
+   \ftrunc_N(+ q) &=& +0 & (\iff 0 < +q < 1) \\
+   \ftrunc_N(- q) &=& -0 & (\iff -1 < -q < 0) \\
+   \ftrunc_N(\pm q) &=& \ieee_N(\pm i) & (\iff +q - 1 < i \leq +q) \\
    \end{array}
 
 
@@ -1129,10 +1159,10 @@ This non-deterministic result is expressed by the following auxiliary function p
    \fnearest_N(\pm \NAN(n)) &=& \nans_N\{\pm \NAN(n)\} \\
    \fnearest_N(\pm \infty) &=& \pm \infty \\
    \fnearest_N(\pm 0) &=& \pm 0 \\
-   \fnearest_N(+ q) &=& +0 & (0 < +q \leq 0.5) \\
-   \fnearest_N(- q) &=& -0 & (-0.5 \leq -q < 0) \\
-   \fnearest_N(\pm q) &=& \ieee_N(\pm i) & (|i - q| < 0.5) \\
-   \fnearest_N(\pm q) &=& \ieee_N(\pm i) & (|i - q| = 0.5 \wedge i~\mbox{even}) \\
+   \fnearest_N(+ q) &=& +0 & (\iff 0 < +q \leq 0.5) \\
+   \fnearest_N(- q) &=& -0 & (\iff -0.5 \leq -q < 0) \\
+   \fnearest_N(\pm q) &=& \ieee_N(\pm i) & (\iff |i - q| < 0.5) \\
+   \fnearest_N(\pm q) &=& \ieee_N(\pm i) & (\iff |i - q| = 0.5 \wedge i~\mbox{even}) \\
    \end{array}
 
 
@@ -1154,8 +1184,7 @@ This non-deterministic result is expressed by the following auxiliary function p
    \feq_N(\pm \NAN(n), z_2) &=& 0 \\
    \feq_N(z_1, \pm \NAN(n)) &=& 0 \\
    \feq_N(\pm 0, \mp 0) &=& 1 \\
-   \feq_N(z, z) &=& 1 \\
-   \feq_N(z_1, z_2) &=& 0 \\
+   \feq_N(z_1, z_2) &=& \bool(z_1 = z_2) \\
    \end{array}
 
 
@@ -1177,8 +1206,7 @@ This non-deterministic result is expressed by the following auxiliary function p
    \fne_N(\pm \NAN(n), z_2) &=& 0 \\
    \fne_N(z_1, \pm \NAN(n)) &=& 0 \\
    \fne_N(\pm 0, \mp 0) &=& 0 \\
-   \fne_N(z, z) &=& 0 \\
-   \fne_N(z_1, z_2) &=& 1 \\
+   \fne_N(z_1, z_2) &=& \bool(z_1 \neq z_2) \\
    \end{array}
 
 
@@ -1354,9 +1382,9 @@ Conversions
 :math:`\extends_{M,N}(i)`
 .........................
 
-* Let :math:`j` be the signed interpretation of :math:`i` of size :math:`M`.
+* Let :math:`j` be the :ref:`signed interpretation <aux-signed>` of :math:`i` of size :math:`M`.
 
-* Return the 2's complement of :math:`j` relative to size :math:`N`.
+* Return the two's complement of :math:`j` relative to size :math:`N`.
 
 .. math::
    \begin{array}{lll@{\qquad}l}
@@ -1394,8 +1422,8 @@ Conversions
    \begin{array}{lll@{\qquad}l}
    \truncu_{M,N}(\pm \NAN(n)) &=& \{\} \\
    \truncu_{M,N}(\pm \infty) &=& \{\} \\
-   \truncu_{M,N}(\pm q) &=& \trunc(\pm q) & (-1 < \trunc(\pm q) < 2^N) \\
-   \truncu_{M,N}(\pm q) &=& \{\} & (\mbox{otherwise}) \\
+   \truncu_{M,N}(\pm q) &=& \trunc(\pm q) & (\iff -1 < \trunc(\pm q) < 2^N) \\
+   \truncu_{M,N}(\pm q) &=& \{\} & (\otherwise) \\
    \end{array}
 
 .. note::
@@ -1420,8 +1448,8 @@ Conversions
    \begin{array}{lll@{\qquad}l}
    \truncs_{M,N}(\pm \NAN(n)) &=& \{\} \\
    \truncs_{M,N}(\pm \infty) &=& \{\} \\
-   \truncs_{M,N}(\pm q) &=& \trunc(\pm q) & (- 2^{N-1} - 1 < \trunc(\pm q) < 2^{N-1}) \\
-   \truncs_{M,N}(\pm q) &=& \{\} & (\mbox{otherwise}) \\
+   \truncs_{M,N}(\pm q) &=& \trunc(\pm q) & (\iff -2^{N-1} - 1 < \trunc(\pm q) < 2^{N-1}) \\
+   \truncs_{M,N}(\pm q) &=& \{\} & (\otherwise) \\
    \end{array}
 
 .. note::
@@ -1434,16 +1462,16 @@ Conversions
 :math:`\promote_{M,N}(z)`
 .........................
 
-* If :math:`z` is a :ref:`canonical NaN <canonical-nan>`, then return a element of :math:`\nans_N\{\}` (i.e., a canonical NaN of size :math:`N`).
+* If :math:`z` is a :ref:`canonical NaN <canonical-nan>`, then return an element of :math:`\nans_N\{\}` (i.e., a canonical NaN of size :math:`N`).
 
-* Else if :math:`z` is a NaN, then return a element of :math:`\nans_N\{\pm \NAN(1)\}` (i.e., any NaN of size :math:`N`).
+* Else if :math:`z` is a NaN, then return an element of :math:`\nans_N\{\pm \NAN(1)\}` (i.e., any NaN of size :math:`N`).
 
 * Else, return :math:`z`.
 
 .. math::
    \begin{array}{lll@{\qquad}l}
-   \promote_{M,N}(\pm \NAN(n)) &=& \nans_N\{\} & (n = \canon_N) \\
-   \promote_{M,N}(\pm \NAN(n)) &=& \nans_N\{+ \NAN(1)\} & (\mbox{otherwise}) \\
+   \promote_{M,N}(\pm \NAN(n)) &=& \nans_N\{\} & (\iff n = \canon_N) \\
+   \promote_{M,N}(\pm \NAN(n)) &=& \nans_N\{+ \NAN(1)\} & (\otherwise) \\
    \promote_{M,N}(z) &=& z \\
    \end{array}
 
@@ -1453,9 +1481,9 @@ Conversions
 :math:`\demote_{M,N}(z)`
 ........................
 
-* If :math:`z` is a :ref:`canonical NaN <canonical-nan>`, then return a element of :math:`\nans_N\{\}` (i.e., a canonical NaN of size :math:`N`).
+* If :math:`z` is a :ref:`canonical NaN <canonical-nan>`, then return an element of :math:`\nans_N\{\}` (i.e., a canonical NaN of size :math:`N`).
 
-* Else if :math:`z` is a NaN, then return a element of :math:`\nans_N\{\pm \NAN(1)\}` (i.e., any NaN of size :math:`N`).
+* Else if :math:`z` is a NaN, then return an element of :math:`\nans_N\{\pm \NAN(1)\}` (i.e., any NaN of size :math:`N`).
 
 * Else if :math:`z` is an infinity, then return that infinity.
 
@@ -1465,8 +1493,8 @@ Conversions
 
 .. math::
    \begin{array}{lll@{\qquad}l}
-   \demote_{M,N}(\pm \NAN(n)) &=& \nans_N\{\} & (n = \canon_N) \\
-   \demote_{M,N}(\pm \NAN(n)) &=& \nans_N\{+ \NAN(1)\} & (\mbox{otherwise}) \\
+   \demote_{M,N}(\pm \NAN(n)) &=& \nans_N\{\} & (\iff n = \canon_N) \\
+   \demote_{M,N}(\pm \NAN(n)) &=& \nans_N\{+ \NAN(1)\} & (\otherwise) \\
    \demote_{M,N}(\pm \infty) &=& \pm \infty \\
    \demote_{M,N}(\pm 0) &=& \pm 0 \\
    \demote_{M,N}(\pm q) &=& \ieee_N(\pm q) \\
@@ -1491,7 +1519,7 @@ Conversions
 :math:`\converts_{M,N}(i)`
 ..........................
 
-* Let :math:`j` be the signed interpretation of :math:`i`.
+* Let :math:`j` be the :ref:`signed interpretation <aux-signed>` of :math:`i`.
 
 * Return :math:`\ieee_N(j)`.
 
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 7609fb3f1..b721836e0 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -4,8 +4,10 @@
 Runtime Structure
 -----------------
 
+:ref:`Store <store>`, :ref:`stack <stack>`, and other *runtime structure* forming the WebAssembly abstract machine, such as :ref:`values <syntax-val>` or :ref:`module instances <syntax-moduleinst>`, are made precise in terms of additional auxiliary syntax.
 
-.. index:: ! value, constant
+
+.. index:: ! value, constant, value type, integer, floating-point
    pair: abstract syntax; value
 .. _syntax-val:
 
@@ -19,16 +21,16 @@ In order to avoid ambiguities, values are therefore represented with an abstract
 It is convenient to reuse the same notation as for the |CONST| :ref:`instructions <syntax-const>` producing them:
 
 .. math::
-   \begin{array}{llll}
+   \begin{array}{llcl}
    \production{(value)} & \val &::=&
-     \I32.\CONST~\i32 ~|~
-     \I64.\CONST~\i64 ~|~
-     \F32.\CONST~\f32 ~|~
+     \I32.\CONST~\i32 \\&&|&
+     \I64.\CONST~\i64 \\&&|&
+     \F32.\CONST~\f32 \\&&|&
      \F64.\CONST~\f64
    \end{array}
 
 
-.. index:: ! store, function instance, table instance, memory instance, global instance, module
+.. index:: ! store, function instance, table instance, memory instance, global instance, module, allocation
    pair: abstract syntax; store
 .. _syntax-store:
 .. _store:
@@ -37,18 +39,18 @@ Store
 ~~~~~
 
 The *store* represents all global state that can be manipulated by WebAssembly programs.
-It consists of the runtime representation of all *instances* of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tableinst>`, :ref:`memories <syntax-meminst>`, and :ref:`globals <syntax-globalinst>` that have been *allocated* during the life time of the abstract machine. [#gc]_
+It consists of the runtime representation of all *instances* of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tableinst>`, :ref:`memories <syntax-meminst>`, and :ref:`globals <syntax-globalinst>` that have been :ref:`allocated <alloc>` during the life time of the abstract machine. [#gc]_
 
-Syntactically, the store is defined as a :ref:`record <syntax-record>` listing the existing instances of each category:
+Syntactically, the store is defined as a :ref:`record <notation-record>` listing the existing instances of each category:
 
 .. math::
    \begin{array}{llll}
    \production{(store)} & \store &::=& \{~
      \begin{array}[t]{l@{~}ll}
-     \FUNCS & \funcinst^\ast, \\
-     \TABLES & \tableinst^\ast, \\
-     \MEMS & \meminst^\ast, \\
-     \GLOBALS & \globalinst^\ast ~\} \\
+     \SFUNCS & \funcinst^\ast, \\
+     \STABLES & \tableinst^\ast, \\
+     \SMEMS & \meminst^\ast, \\
+     \SGLOBALS & \globalinst^\ast ~\} \\
      \end{array}
    \end{array}
 
@@ -64,7 +66,7 @@ Convention
 * The meta variable :math:`S` ranges over stores where clear from context.
 
 
-.. index:: ! address, store, function instance, table instance, memory instance, global instance
+.. index:: ! address, store, function instance, table instance, memory instance, global instance, embedder
    pair: abstract syntax; function address
    pair: abstract syntax; table address
    pair: abstract syntax; memory address
@@ -99,6 +101,10 @@ These are simply indices into the respective store component.
      \addr \\
    \end{array}
 
+An :ref:`embedder <embedder>` may assign identity to :ref:`exported <syntax-export>` store objects corresponding to their addresses,
+even where this identity is not observable from within WebAssembly code itself
+(such as for :ref:`function instances <syntax-funcinst>` or immutable :ref:`globals <syntax-globalinst>`).
+
 .. note::
    Addresses are *dynamic*, globally unique references to runtime objects,
    in contrast to :ref:`indices <syntax-index>`,
@@ -109,12 +115,8 @@ These are simply indices into the respective store component.
    There is no specific limit on the number of allocations of store objects,
    hence logical addresses can be arbitrarily large natural numbers.
 
-An :ref:`embedder <embedder>` may assign identity to :ref:`exported <syntax-export>` store objects corresponding to their addresses,
-even where this identity is not observable from within WebAssembly code itself
-(such as for :ref:`function instances <syntax-funcinst>` or immutable :ref:`globals <syntax-global>`).
-
 
-.. index:: ! instance, function type, function instance, table instance, memory instance, global instance, export instance, table address, memory address, global address, index
+.. index:: ! instance, function type, function instance, table instance, memory instance, global instance, export instance, table address, memory address, global address, index, name
    pair: abstract syntax; module instance
    pair: module; instance
 .. _syntax-moduleinst:
@@ -130,12 +132,12 @@ and collects runtime representations of all entities that are imported, defined,
    \begin{array}{llll}
    \production{(module instance)} & \moduleinst &::=& \{
      \begin{array}[t]{l@{~}ll}
-     \TYPES & \functype^\ast, \\
-     \FUNCS & \funcaddr^\ast, \\
-     \TABLES & \tableaddr^\ast, \\
-     \MEMS & \memaddr^\ast, \\
-     \GLOBALS & \globaladdr^\ast \\
-     \EXPORTS & \exportinst^\ast ~\} \\
+     \MITYPES & \functype^\ast, \\
+     \MIFUNCS & \funcaddr^\ast, \\
+     \MITABLES & \tableaddr^\ast, \\
+     \MIMEMS & \memaddr^\ast, \\
+     \MIGLOBALS & \globaladdr^\ast \\
+     \MIEXPORTS & \exportinst^\ast ~\} \\
      \end{array}
    \end{array}
 
@@ -145,7 +147,7 @@ Each component references runtime instances corresponding to respective declarat
 It is an invariant of the semantics that all :ref:`export instances <syntax-exportinst>` in a given module instance have different :ref:`names <syntax-name>`.
 
 
-.. index:: ! function instance, module instance, function, closure
+.. index:: ! function instance, module instance, function, closure, module, ! host function, invocation
    pair: abstract syntax; function instance
    pair: function; instance
 .. _syntax-hostfunc:
@@ -155,14 +157,14 @@ Function Instances
 ~~~~~~~~~~~~~~~~~~
 
 A *function instance* is the runtime representation of a :ref:`function <syntax-func>`.
-It effectively is a *closure* of the original function over the runtime :ref:`module instance <syntax-moduleinst>` of its own :ref:`module <syntax-module>`.
-The module instance is used to resolve references to other non-local definitions during execution of the function.
+It effectively is a *closure* of the original function over the runtime :ref:`module instance <syntax-moduleinst>` of its originating :ref:`module <syntax-module>`.
+The module instance is used to resolve references to other definitions during execution of the function.
 
 .. math::
    \begin{array}{llll}
    \production{(function instance)} & \funcinst &::=&
-     \{ \TYPE~\functype, \MODULE~\moduleinst, \CODE~\func \} \\ &&|&
-     \{ \TYPE~\functype, \CODE~\hostfunc \} \\
+     \{ \FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func \} \\ &&|&
+     \{ \FITYPE~\functype, \FIHOSTCODE~\hostfunc \} \\
    \production{(host function)} & \hostfunc &::=& \dots \\
    \end{array}
 
@@ -173,10 +175,10 @@ a host function behaves non-deterministically.
 
 .. note::
    Function instances are immutable, and their identity is not observable by WebAssembly code.
-   However, the :ref:`embedder <embedder>` might provide implicit or explicit means for distinguishing their :ref:`addresses <syntax-funcaddr>` when :ref:`exported <syntax-export>`, either directly or through an entry in a :ref:`table <syntax-table>`.
+   However, the :ref:`embedder <embedder>` might provide implicit or explicit means for distinguishing their :ref:`addresses <syntax-funcaddr>`.
 
 
-.. index:: ! table instance, table, function address
+.. index:: ! table instance, table, function address, table type, embedder, element segment
    pair: abstract syntax; table instance
    pair: table; instance
 .. _syntax-funcelem:
@@ -186,7 +188,7 @@ Table Instances
 ~~~~~~~~~~~~~~~
 
 A *table instance* is the runtime representation of a :ref:`table <syntax-table>`.
-It holds a vector of *function elements* and an optional maximum size, if one was specified at the definition site of the table.
+It holds a vector of *function elements* and an optional maximum size, if one was specified in the :ref:`table type <syntax-tabletype>` at the table's definition site.
 
 Each function element is either empty, representing an uninitialized table entry, or a :ref:`function address <syntax-funcaddr>`.
 Function elements can be mutated through the execution of an :ref:`element segment <syntax-elem>` or by external means provided by the :ref:`embedder <embedder>`.
@@ -194,7 +196,7 @@ Function elements can be mutated through the execution of an :ref:`element segme
 .. math::
    \begin{array}{llll}
    \production{(table instance)} & \tableinst &::=&
-     \{ \ELEM~\vec(\funcelem), \MAX~\u32^? \} \\
+     \{ \TIELEM~\vec(\funcelem), \TIMAX~\u32^? \} \\
    \production{(function element)} & \funcelem &::=&
      \funcaddr^? \\
    \end{array}
@@ -205,7 +207,7 @@ It is an invariant of the semantics that the length of the element vector never
    Other table elements may be added in future versions of WebAssembly.
 
 
-.. index:: ! memory instance, memory, byte, ! page size, memory type
+.. index:: ! memory instance, memory, byte, ! page size, memory type, embedder, data segment, instruction
    pair: abstract syntax; memory instance
    pair: memory; instance
 .. _page-size:
@@ -215,12 +217,12 @@ Memory Instances
 ~~~~~~~~~~~~~~~~
 
 A *memory instance* is the runtime representation of a linear :ref:`memory <syntax-mem>`.
-It holds a vector of bytes and an optional maximum size, if one was specified at the definition site of the memory.
+It holds a vector of :ref:`bytes <syntax-byte>` and an optional maximum size, if one was specified at the definition site of the memory.
 
 .. math::
    \begin{array}{llll}
    \production{(memory instance)} & \meminst &::=&
-     \{ \DATA~\vec(\byte), \MAX~\u32^? \} \\
+     \{ \MIDATA~\vec(\byte), \MIMAX~\u32^? \} \\
    \end{array}
 
 The length of the vector always is a multiple of the WebAssembly *page size*, which is defined to be the constant :math:`65536` -- abbreviated :math:`64\,\F{Ki}`.
@@ -231,7 +233,7 @@ The bytes can be mutated through :ref:`memory instructions <syntax-instr-memory>
 It is an invariant of the semantics that the length of the byte vector, divided by page size, never exceeds the maximum size, if present.
 
 
-.. index:: ! global instance, value
+.. index:: ! global instance, global, value, mutability, instruction, embedder
    pair: abstract syntax; global instance
    pair: global; instance
 .. _syntax-globalinst:
@@ -245,13 +247,13 @@ It holds an individual :ref:`value <syntax-val>` and a flag indicating whether i
 .. math::
    \begin{array}{llll}
    \production{(global instance)} & \globalinst &::=&
-     \{ \VALUE~\val, \MUT~\mut \} \\
+     \{ \GIVALUE~\val, \GIMUT~\mut \} \\
    \end{array}
 
-The value of mutable globals can be mutated through specific instructions or by external means provided by the :ref:`embedder <embedder>`.
+The value of mutable globals can be mutated through :ref:`variable instructions <syntax-instr-variable>` or by external means provided by the :ref:`embedder <embedder>`.
 
 
-.. index:: ! export instance, name, external value
+.. index:: ! export instance, export, name, external value
    pair: abstract syntax; export instance
    pair: export; instance
 .. _syntax-exportinst:
@@ -260,16 +262,16 @@ Export Instances
 ~~~~~~~~~~~~~~~~
 
 An *export instance* is the runtime representation of an :ref:`export <syntax-export>`.
-It defines the export's :ref:`name <syntax-name>` and the :ref:`external value <syntax-externval>` being exported.
+It defines the export's :ref:`name <syntax-name>` and the associated :ref:`external value <syntax-externval>`.
 
 .. math::
    \begin{array}{llll}
    \production{(export instance)} & \exportinst &::=&
-     \{ \NAME~\name, \VALUE~\externval \} \\
+     \{ \EINAME~\name, \EIVALUE~\externval \} \\
    \end{array}
 
 
-.. index:: ! external value, function address, table address, memory address, global address
+.. index:: ! external value, function address, table address, memory address, global address, store, function, table, memory, global
    pair: abstract syntax; external value
    pair: external; value
 .. _syntax-externval:
@@ -281,12 +283,12 @@ An *external value* is the runtime representation of an entity that can be impor
 It is an :ref:`address <syntax-addr>` denoting either a :ref:`function instance <syntax-funcinst>`, :ref:`table instance <syntax-tableinst>`, :ref:`memory instance <syntax-meminst>`, or :ref:`global instances <syntax-globalinst>` in the shared :ref:`store <syntax-store>`.
 
 .. math::
-   \begin{array}{llll}
+   \begin{array}{llcl}
    \production{(external value)} & \externval &::=&
-     \FUNC~\funcaddr ~|~
-     \TABLE~\tableaddr ~|~
-     \MEM~\memaddr ~|~
-     \GLOBAL~\globaladdr \\
+     \EVFUNC~\funcaddr \\&&|&
+     \EVTABLE~\tableaddr \\&&|&
+     \EVMEM~\memaddr \\&&|&
+     \EVGLOBAL~\globaladdr \\
    \end{array}
 
 
@@ -296,16 +298,16 @@ Conventions
 The following auxiliary notation is defined for sequences of external values.
 It filters out entries of a specific kind in an order-preserving fashion:
 
-.. math::
-   \begin{array}{lcl}
-   \funcs(\externval^\ast) &=& [\funcaddr ~|~ (\FUNC~\funcaddr) \in \externval^\ast] \\
-   \tables(\externval^\ast) &=& [\tableaddr ~|~ (\TABLE~\tableaddr) \in \externval^\ast] \\
-   \mems(\externval^\ast) &=& [\memaddr ~|~ (\MEM~\memaddr) \in \externval^\ast] \\
-   \globals(\externval^\ast) &=& [\globaladdr ~|~ (\GLOBAL~\globaladdr) \in \externval^\ast] \\
-   \end{array}
+* :math:`\evfuncs(\externval^\ast) = [\funcaddr ~|~ (\EVFUNC~\funcaddr) \in \externval^\ast]`
+
+* :math:`\evtables(\externval^\ast) = [\tableaddr ~|~ (\EVTABLE~\tableaddr) \in \externval^\ast]`
+
+* :math:`\evmems(\externval^\ast) = [\memaddr ~|~ (\EVMEM~\memaddr) \in \externval^\ast]`
 
+* :math:`\evglobals(\externval^\ast) = [\globaladdr ~|~ (\EVGLOBAL~\globaladdr) \in \externval^\ast]`
 
-.. index:: ! stack, ! frame, ! label
+
+.. index:: ! stack, ! frame, ! label, instruction, store, activation, function, call, local, module instance
    pair: abstract syntax; frame
    pair: abstract syntax; label
 .. _syntax-frame:
@@ -320,9 +322,9 @@ Stack
 Besides the :ref:`store <store>`, most :ref:`instructions <syntax-instr>` interact with an implicit *stack*.
 The stack contains three kinds of entries:
 
-* *Values*: the *operands* (arguments and results) of instructions.
+* *Values*: the *operands* of instructions.
 
-* *Labels*: active (entered) :ref:`structured control instructions <syntax-instr-control>` that can be targeted by branches.
+* *Labels*: active :ref:`structured control instructions <syntax-instr-control>` that can be targeted by branches.
 
 * *Activations*: the *call frames* of active :ref:`function <syntax-func>` calls.
 
@@ -379,7 +381,7 @@ and a reference to the function's own :ref:`module instance <syntax-moduleinst>`
    \production{(activation)} & \X{activation} &::=&
      \FRAME_n\{\frame\} \\
    \production{(frame)} & \frame &::=&
-     \{ \LOCALS~\val^\ast, \MODULE~\moduleinst\} \\
+     \{ \ALOCALS~\val^\ast, \AMODULE~\moduleinst \} \\
    \end{array}
 
 The values of the locals are mutated by respective :ref:`variable instructions <syntax-instr-variable>`.
@@ -393,11 +395,11 @@ Conventions
 * The meta variable :math:`F` ranges over frames where clear from context.
 
 .. note::
-   In the current version of WebAssembly, the arities of labels and activations cannot be larger than :math:`1`.
+   In the current version of WebAssembly, the arities of labels and frames cannot be larger than :math:`1`.
    This may be generalized in future versions.
 
 
-.. index:: ! administrative instructions, function, function instance, function address, label, frame, instruction, trap
+.. index:: ! administrative instructions, function, function instance, function address, label, frame, instruction, trap, call
    pair:: abstract syntax; administrative instruction
 .. _syntax-trap:
 .. _syntax-invoke:
@@ -409,7 +411,7 @@ Administrative Instructions
 .. note::
    This section is only relevant for the :ref:`formal notation <exec-notation>`.
 
-In order to express the reduction of :ref:`traps <trap>`, calls, and :ref:`control instructions <syntax-instr-control>`, the syntax of instructions is extended to include the following *administrative instructions*:
+In order to express the reduction of :ref:`traps <trap>`, :ref:`calls <syntax-call>`, and :ref:`control instructions <syntax-instr-control>`, the syntax of instructions is extended to include the following *administrative instructions*:
 
 .. math::
    \begin{array}{llcl}
@@ -422,14 +424,14 @@ In order to express the reduction of :ref:`traps <trap>`, calls, and :ref:`contr
    \end{array}
 
 The |TRAP| instruction represents the occurrence of a trap.
-Traps are bubbled up through nested instruction sequences, ultimately reducing the entire program to a single |TRAP| instruction, signalling termination.
+Traps are bubbled up through nested instruction sequences, ultimately reducing the entire program to a single |TRAP| instruction, signalling abrupt termination.
 
 The |INVOKE| instruction represents the imminent invocation of a :ref:`function instance <syntax-funcinst>`, identified by its :ref:`address <syntax-funcaddr>`.
 It unifies the handling of different forms of calls.
 
 The |LABEL| and |FRAME| instructions model :ref:`labels <syntax-label>` and :ref:`frames <syntax-frame>` :ref:`"on the stack" <exec-notation>`.
-Moreover, the administrative syntax maintains the nesting structure of the original :ref:`structured control instruction <syntax-instr-control>` or :ref:`function body <syntax-func>` and their :ref:`instruction sequences <syntax-instr-seq>`.
-That way, the end of the inner instruction sequence is tracked when part of an outer sequence.
+Moreover, the administrative syntax maintains the nesting structure of the original :ref:`structured control instruction <syntax-instr-control>` or :ref:`function body <syntax-func>` and their :ref:`instruction sequences <syntax-instr-seq>` with an |END| marker.
+That way, the end of the inner instruction sequence is known when part of an outer sequence.
 
 .. note::
    For example, the :ref:`reduction rule <exec-block>` for |BLOCK| is:
@@ -440,10 +442,10 @@ That way, the end of the inner instruction sequence is tracked when part of an o
 
    This replaces the block with a label instruction,
    which can be interpreted as "pushing" the label on the stack.
-   When |END| is reached, i.e., the inner instruction sequence has been reduced to the empty sequence -- or a sequence of |CONST| instructions, the representation of non-empty local operand stack -- then the |LABEL| instruction is eliminated courtesy of its own :ref:`reduction rule <exec-label>`:
+   When |END| is reached, i.e., the inner instruction sequence has been reduced to the empty sequence -- or rather, a sequence of :math:`n` |CONST| instructions representing the resulting values -- then the |LABEL| instruction is eliminated courtesy of its own :ref:`reduction rule <exec-label>`:
 
    .. math::
-      \LABEL_n\{\instr^\ast\}~\val^\ast~\END \quad\stepto\quad \val^\ast
+      \LABEL_n\{\instr^n\}~\val^\ast~\END \quad\stepto\quad \val^n
 
    This can be interpreted as removing the label from the stack and only leaving the locally accumulated operand values.
 
@@ -460,13 +462,13 @@ That way, the end of the inner instruction sequence is tracked when part of an o
       \end{array}
 
 
-.. index:: ! evaluation context
+.. index:: ! block context, instruction, branch
 .. _syntax-ctxt-block:
 
 Block Contexts
 ..............
 
-To express :ref:`branches <syntax-instr-control>`, the following syntax of *block contexts* is defined, indexed by the count :math:`k` of labels surrounding the hole:
+In order to specify the reduction of :ref:`branches <syntax-instr-control>`, the following syntax of *block contexts* is defined, indexed by the count :math:`k` of labels surrounding the hole:
 
 .. math::
    \begin{array}{llll}
@@ -487,10 +489,10 @@ This definition allows to index active labels surrounding a :ref:`branch <syntax
    Here, the hole :math:`[\_]` of the context is instantiated with a branch instruction.
    When a branch occurs,
    this rule replaces the targeted label and associated instruction sequence with the label's continuation.
-   The right label is identified through the :ref:`label index <syntax-labelidx>` :math:`l`, which corresponds to the number of surrounding |LABEL| instructions that must be hopped over -- which is exactly the count encoded in the index of a block context.
+   The selected label is identified through the :ref:`label index <syntax-labelidx>` :math:`l`, which corresponds to the number of surrounding |LABEL| instructions that must be hopped over -- which is exactly the count encoded in the index of a block context.
 
 
-.. index:: ! evaluation context
+.. index:: ! evaluation context, instruction, trap, label, frame, value
 .. _syntax-ctxt-eval:
 
 Evaluation Contexts
@@ -510,13 +512,26 @@ Finally, the following definition of *evaluation context* and associated structu
 .. math::
    \begin{array}{lcl@{\qquad}l}
    S; F; E[\instr^\ast] &\stepto& S'; F'; E[{\instr'}^\ast]
-     & (\mbox{if}~S; F; \instr^\ast \stepto S'; F'; {\instr'}^\ast) \\
+     & (\iff S; F; \instr^\ast \stepto S'; F'; {\instr'}^\ast) \\
    S; F; E[\TRAP] &\stepto& S; F; \TRAP
-     & (\mbox{if}~E \neq [\_]) \\
+     & (\iff E \neq [\_]) \\
    \end{array}
 
+.. note::
+   For example, the following instruction sequence,
+
+   .. math::
+       (\F64.\CONST~x_1)~(\F64.\CONST~x_2)~\F64.\NEG~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL
+
+   can be decomposed into :math:`E[(\F64.\CONST~x_2)~\F64.\NEG]` where
+
+   .. math::
+      E = (\F64.\CONST~x_1)~[\_]~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL
+
+   Moreover, this is the *only* possible choice of evaluation context where the contents of the hole matches the left-hand side of a reduction rule.
+
 
-.. index:: ! module instructions, function, function instance, function address, label, frame, instruction, trap
+.. index:: ! module instructions, function, function instance, function address, label, frame, instruction, trap, global, global instance, memory, memory instance, table, table instance, invocation, start function
    pair:: abstract syntax; meta instruction
 .. _syntax-instantiate:
 .. _syntax-init_table:
@@ -558,18 +573,18 @@ Evaluation contexts and additional structural reduction rules for module instruc
 .. math::
    \begin{array}{llll}
    \production{(module evaluation contexts)} & M &::=&
-     E~~\moduleinstr^\ast \\
+     E~~\moduleinstr^\ast~~\moduleinst \\
    \end{array}
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
    S; M[\moduleinstr] &\stepto& S'; M[{\moduleinstr'}^\ast]
-     & (\mbox{if}~S; \moduleinstr \stepto S'; {\moduleinstr'}^\ast) \\
+     & (\iff S; \moduleinstr \stepto S'; {\moduleinstr'}^\ast) \\
    S; M[\TRAP] &\stepto& S; \TRAP
-     & (\mbox{if}~M \neq [\_]) \\
+     & (\iff M \neq [\_]) \\
    \end{array}
 
-Reduction terminates when the sequence has been reduced to a |moduleinst| or a trap occurred.
+Reduction terminates when the sequence has been reduced to a |moduleinst| or when a trap occurred.
 
 .. note::
    A trap may either arise from invocation of a :ref:`start function <syntax-start>` or indicate failure of the |INSTANTIATE| instruction itself.
diff --git a/document/core/intro/introduction.rst b/document/core/intro/introduction.rst
index 03f1d7f57..9d89a5026 100644
--- a/document/core/intro/introduction.rst
+++ b/document/core/intro/introduction.rst
@@ -38,7 +38,7 @@ The design goals of WebAssembly are the following:
 
 * Efficient and portable *representation*:
 
-  * **Compact**: a binary format that is fast to transmit by being smaller than typical text or native code formats.
+  * **Compact**: has a binary format that is fast to transmit by being smaller than typical text or native code formats.
 
   * **Modular**: programs can be split up in smaller parts that can be transmitted, cached, and consumed separately.
 
@@ -68,7 +68,7 @@ As such, it has many use cases and can be embedded in many different environment
 To encompass their variety and enable maximum reuse, the WebAssembly specification is split and layered into several documents.
 
 This document is concerned with the core ISA layer of WebAssembly.
-It defines the instruction set, binary encoding, validation, and execution semantics.
+It defines the instruction set, binary encoding, validation, and execution semantics, as well as a textual representation.
 It does not, however, define how WebAssembly programs can interact with a specific environment they execute in, nor how they are invoked from such an environment.
 
 Instead, this specification is complemented by additional documents defining interfaces to specific embedding environments such as the Web.
diff --git a/document/core/intro/overview.rst b/document/core/intro/overview.rst
index d2e2cf800..c35b50bfd 100644
--- a/document/core/intro/overview.rst
+++ b/document/core/intro/overview.rst
@@ -1,29 +1,27 @@
 Overview
 --------
 
-.. index:: concepts, value, instruction, trap, function, table, memory, linear memory, module, !embedder
-
-
+.. index:: concepts, value, instruction, trap, function, table, memory, linear memory, module, ! embedder, integer, floating-point, IEEE 754, Boolean, two's complement
 .. _concepts:
 
 Concepts
 ~~~~~~~~
 
 WebAssembly encodes a low-level, assembly-like programming language.
-This language is structured around the following main concepts.
+This language is structured around the following concepts.
 
 .. _value:
 
 **Values**
   WebAssembly provides only four basic *value types*.
-  These are integers and `IEEE-754 floating point <http://ieeexplore.ieee.org/document/4610935/>`_ numbers,
+  These are integers and `IEEE 754 floating-point <http://ieeexplore.ieee.org/document/4610935/>`_ numbers,
   each in 32 and 64 bit width.
   32 bit integers also serve as Booleans and as memory addresses.
   The usual operations on these types are available,
   including the full matrix of conversions between them.
   There is no distinction between signed and unsigned integer types.
   Instead, integers are interpreted by respective operations
-  as either unsigned or signed in 2’s complement representation.
+  as either unsigned or signed in two’s complement representation.
 
 .. _instruction:
 
@@ -32,7 +30,7 @@ This language is structured around the following main concepts.
   Code consists of sequences of *instructions* that are executed in order.
   Instructions manipulate values on an implicit *operand stack* [#stackmachine]_
   and fall into two main categories.
-  Simple instructions perform basic operations on data.
+  *Simple* instructions perform basic operations on data.
   They pop arguments from the operand stack and push results back to it.
   *Control* instructions alter control flow.
   Control flow is *structured*, meaning it is expressed with well-nested constructs such as blocks, loops, and conditionals.
@@ -64,13 +62,13 @@ This language is structured around the following main concepts.
   It allows programs to select such values indirectly through a dynamic index operand.
   Currently, the only available element type is an untyped function reference.
   Thereby, a program can call functions indirectly through a dynamic index into a table.
-  For example, this allows emulating function pointers with table indices.
+  For example, this allows emulating function pointers by way of table indices.
 
 .. _memory:
 
 **Linear Memory**
-  A *linear memory* is a contiguous, mutable array of untyped bytes.
-  Such a memory is created with an initial size but can be dynamically grown.
+  A *linear memory* is a contiguous, mutable array of raw bytes.
+  Such a memory is created with an initial size but can be grown dynamically.
   A program can load and store values from/to a linear memory at any byte address (including unaligned).
   Integer loads and stores can specify a *storage size* which is smaller than the size of the respective value type.
   A trap occurs if access is not within the bounds of the current memory size.
@@ -83,9 +81,9 @@ This language is structured around the following main concepts.
   as well as mutable or immutable *global variables*.
   Definitions can also be *imported*, specifying a module/name pair and a suitable type.
   Each definition can optionally be *exported* under one or more names.
-  In addition to definitions, a module can define initialization data for its memory or table
+  In addition to definitions, modules can define initialization data for their memories or tables
   that takes the form of *segments* copied to given offsets.
-  It can also define a *start function* that is automatically executed.
+  They can also define a *start function* that is automatically executed.
 
 .. _embedder:
 
@@ -132,14 +130,14 @@ For each part of the language, the specification specifies each of them.
   Execution can be further divided into two phases:
 
   **Instantiation**.
-  An *instance* is the dynamic representation of a module,
+  A module *instance* is the dynamic representation of a module,
   complete with its own state and execution stack.
-  Instantiation executes the module body itself given definitions for all its imports.
+  Instantiation executes the module body itself, given definitions for all its imports.
   It initializes globals, memories and tables and invokes the module's start function if defined.
   It returns the instances of the module's exports.
 
   **Invocation**.
-  Once instantiated, further WebAssembly computations can be initiated by *invoking* an exported function of an instance.
+  Once instantiated, further WebAssembly computations can be initiated by *invoking* an exported function on a module instance.
   Given the required arguments, that executes the respective function and returns its results.
 
   Instantiation and invocation are operations within the embedding environment.
diff --git a/document/core/static/custom.css b/document/core/static/custom.css
index 101507942..f5112d30e 100644
--- a/document/core/static/custom.css
+++ b/document/core/static/custom.css
@@ -28,7 +28,7 @@ div.body h4 { font-size: 110%; }
 div.note {
   border: 0px;
   font-size: 90%;
-  background-color: #F4F6FF;
+  background-color: #F6F8FF;
 }
 
 div.admonition {
@@ -42,6 +42,10 @@ div.admonition p.admonition-title {
 }
 
 
+div.relations {
+  display: block;
+}
+
 div.sphinxsidebar {
   z-index: 1;
   background: #FFF;
diff --git a/document/core/syntax/conventions.rst b/document/core/syntax/conventions.rst
index 9d034ae0a..bb1fba797 100644
--- a/document/core/syntax/conventions.rst
+++ b/document/core/syntax/conventions.rst
@@ -3,11 +3,11 @@
 Conventions
 -----------
 
-WebAssembly is a programming language that does not have a concrete textual syntax
-(other than the auxiliary :ref:`text format <text>`).
-For conciseness, however, its structure is described in the form of an *abstract syntax*.
-All parts of this specification are defined in terms of this abstract syntax,
-including the decoding of the :ref:`binary format <binary>`.
+WebAssembly is a programming language that has multiple concrete representations
+(its :ref:`binary format <binary>` and the :ref:`text format <text>`).
+Both map to a common structure.
+For conciseness, this structure is described in the form of an *abstract syntax*.
+All parts of this specification are defined in terms of this abstract syntax.
 
 
 .. index:: ! grammar notation, notation
@@ -15,29 +15,37 @@ including the decoding of the :ref:`binary format <binary>`.
    pair: abstract syntax; notation
 .. _grammar:
 
-Grammar
-~~~~~~~
+Grammar Notation
+~~~~~~~~~~~~~~~~
 
 The following conventions are adopted in defining grammar rules for abstract syntax.
 
-* Terminal symbols (atoms) are written in sans-serif: :math:`\K{i32}, \K{end}`.
+* Terminal symbols (atoms) are written in sans-serif font: :math:`\K{i32}, \K{end}`.
 
-* Nonterminal symbols are written in italic: :math:`\X{valtype}, \X{instr}`.
+* Nonterminal symbols are written in italic font: :math:`\X{valtype}, \X{instr}`.
 
 * :math:`A^n` is a sequence of :math:`n\geq 0` iterations  of :math:`A`.
 
 * :math:`A^\ast` is a possibly empty sequence of iterations of :math:`A`.
   (This is a shorthand for :math:`A^n` used where :math:`n` is not relevant.)
 
-* :math:`A^+` is a possibly empty sequence of iterations of :math:`A`.
+* :math:`A^+` is a non-empty sequence of iterations of :math:`A`.
   (This is a shorthand for :math:`A^n` where :math:`n \geq 1`.)
 
 * :math:`A^?` is an optional occurrence of :math:`A`.
   (This is a shorthand for :math:`A^n` where :math:`n \leq 1`.)
 
+* Productions are written :math:`\X{sym} ::= A_1 ~|~ \dots ~|~ A_n`.
+
+* Some productions are augmented with side conditions in parentheses, ":math:`(\iff \X{condition})`", that provide a shorthand for a combinatorial expansion of the production into many separate cases.
+
 
-.. _syntax-record:
-.. _syntax-concat:
+
+.. _notation-slice:
+.. _notation-replace:
+.. _notation-record:
+.. _notation-concat:
+.. _notation-compose:
 
 Auxiliary Notation
 ~~~~~~~~~~~~~~~~~~
@@ -50,15 +58,15 @@ When dealing with syntactic constructs the following notation is also used:
 
 * :math:`s[i]` denotes the :math:`i`-th element of a sequence :math:`s`, starting from :math:`0`.
 
-* :math:`s[i:n]` denotes the sub-sequence :math:`s[i]~\dots~s[i+n-1]` of a sequence :math:`s`.
+* :math:`s[i \slice n]` denotes the sub-sequence :math:`s[i]~\dots~s[i+n-1]` of a sequence :math:`s`.
 
 * :math:`s \with [i] = A` denotes the same sequence as :math:`s`,
   except that the :math:`i`-the element is replaced with :math:`A`.
 
-* :math:`s \with [i:n] = A^n` denotes the same sequence as :math:`s`,
-  except that the sub-sequence :math:`s[i:n]` is replaced with :math:`A^n`.
+* :math:`s \with [i \slice n] = A^n` denotes the same sequence as :math:`s`,
+  except that the sub-sequence :math:`s[i \slice n]` is replaced with :math:`A^n`.
 
-* :math:`\concat(s^\ast)` denotes the flat sequence formed by concatenating all sequences :math:`s_i^\ast` in :math:`s^\ast`.
+* :math:`\concat(s^\ast)` denotes the flat sequence formed by concatenating all sequences :math:`s_i` in :math:`s^\ast`.
 
 Moreover, the following conventions are employed:
 
@@ -76,12 +84,12 @@ Productions of the following form are interpreted as *records* that map a fixed
 
 The following notation is adopted for manipulating such records:
 
-* :math:`r.\K{field}` denotes the value of the :math:`\K{field}` component of :math:`r`.
+* :math:`r.\K{field}` denotes the contents of the :math:`\K{field}` component of :math:`r`.
 
 * :math:`r \with \K{field} = A` denotes the same record as :math:`r`,
-  except that the value of the :math:`\K{field}` component is replaced with :math:`A`.
+  except that the contents of the :math:`\K{field}` component is replaced with :math:`A`.
 
-* :math:`r_1 \compose r_2` denotes the composition of two records with the same fields of sequences by appending each sequence pointwise:
+* :math:`r_1 \compose r_2` denotes the composition of two records with the same fields of sequences by appending each sequence point-wise:
 
   .. math::
      \{ \K{field}_1\,A_1^\ast, \K{field}_2\,A_2^\ast, \dots \} \compose \{ \K{field}_1\,B_1^\ast, \K{field}_2\,B_2^\ast, \dots \} = \{ \K{field}_1\,A_1^\ast~B_1^\ast, \K{field}_2\,A_2^\ast~B_2^\ast, \dots \}
@@ -94,4 +102,23 @@ The update notation for sequences and records generalizes recursively to nested
 
 * :math:`r \with \K{field}\,\X{pth} = A` is short for :math:`r \with \K{field} = (r.\K{field} \with \X{pth} = A)`.
 
-where :math:`r \with .\K{field} = A` is shortened to :math:`r \with \K{field} = A`.
+where :math:`r \with~.\K{field} = A` is shortened to :math:`r \with \K{field} = A`.
+
+
+.. index:: ! vector
+   pair: abstract syntax; vector
+.. _syntax-vec:
+
+Vectors
+~~~~~~~
+
+*Vectors* are bounded sequences of the form :math:`A^n` (or :math:`A^\ast`),
+where the :math:`A` can either be values or complex constructions.
+A vector can have at most :math:`2^{32}-1` elements.
+
+.. math::
+   \begin{array}{lllll}
+   \production{vector} & \vec(A) &::=&
+     A^n
+     & (\iff n < 2^{32})\\
+   \end{array}
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index e7266d8d3..a740e7cbf 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -1,4 +1,4 @@
-.. index:: ! instruction, ! code, stack machine, operand, operand stack
+.. index:: ! instruction, code, stack machine, operand, operand stack
    pair: abstract syntax; instruction
 .. _syntax-instr:
 
@@ -7,7 +7,7 @@ Instructions
 
 WebAssembly code consists of sequences of *instructions*.
 Its computational model is based on a *stack machine* in that instructions manipulate values on an implicit *operand stack*,
-*consuming* (popping) argument values and *returning* (pushing) result values.
+consuming (popping) argument values and producing (pushing) result values.
 
 .. note::
    In the current version of WebAssembly,
@@ -23,7 +23,7 @@ Some instructions are :ref:`structured <syntax-instr-control>` in that they brac
 The following sections group instructions into a number of different categories.
 
 
-.. index:: ! numeric instruction
+.. index:: ! numeric instruction, value, value type, integer, floating-point, two's complement
    pair: abstract syntax; instruction
 .. _syntax-sx:
 .. _syntax-const:
@@ -45,31 +45,31 @@ The following sections group instructions into a number of different categories.
 Numeric Instructions
 ~~~~~~~~~~~~~~~~~~~~
 
-Numeric instructions provide basic operations over numeric values of specific type.
+Numeric instructions provide basic operations over numeric :ref:`values <syntax-value>` of specific :ref:`type <syntax-valtype>`.
 These operations closely match respective operations available in hardware.
 
 .. math::
-   \begin{array}{llll}
+   \begin{array}{llcl}
    \production{width} & \X{nn}, \X{mm} &::=&
      \K{32} ~|~ \K{64} \\
    \production{signedness} & \sx &::=&
      \K{u} ~|~ \K{s} \\
    \production{instruction} & \instr &::=&
      \K{i}\X{nn}\K{.}\CONST~\xref{syntax/values}{syntax-int}{\iX{\X{nn}}} ~|~
-     \K{f}\X{nn}\K{.}\CONST~\xref{syntax/values}{syntax-float}{\fX{\X{nn}}} ~|~ \\&&&
+     \K{f}\X{nn}\K{.}\CONST~\xref{syntax/values}{syntax-float}{\fX{\X{nn}}} \\&&|&
      \K{i}\X{nn}\K{.}\iunop ~|~
-     \K{f}\X{nn}\K{.}\funop ~|~ \\&&&
+     \K{f}\X{nn}\K{.}\funop \\&&|&
      \K{i}\X{nn}\K{.}\ibinop ~|~
-     \K{f}\X{nn}\K{.}\fbinop ~|~ \\&&&
-     \K{i}\X{nn}\K{.}\itestop ~|~ \\&&&
+     \K{f}\X{nn}\K{.}\fbinop \\&&|&
+     \K{i}\X{nn}\K{.}\itestop \\&&|&
      \K{i}\X{nn}\K{.}\irelop ~|~
-     \K{f}\X{nn}\K{.}\frelop ~|~ \\&&&
+     \K{f}\X{nn}\K{.}\frelop \\&&|&
      \K{i32.}\WRAP\K{/i64} ~|~
      \K{i64.}\EXTEND\K{\_}\sx/\K{i32} ~|~
-     \K{i}\X{nn}\K{.}\TRUNC\K{\_}\sx/\K{f}\X{mm} ~|~ \\&&&
+     \K{i}\X{nn}\K{.}\TRUNC\K{\_}\sx/\K{f}\X{mm} \\&&|&
      \K{f32.}\TRUNC\K{/f64} ~|~
      \K{f64.}\PROMOTE\K{/f32} ~|~
-     \K{f}\X{nn}\K{.}\CONVERT\K{\_}\sx/\K{i}\X{mm} ~|~ \\&&&
+     \K{f}\X{nn}\K{.}\CONVERT\K{\_}\sx/\K{i}\X{mm} \\&&|&
      \K{i}\X{nn}\K{.}\REINTERPRET\K{/f}\X{nn} ~|~
      \K{f}\X{nn}\K{.}\REINTERPRET\K{/i}\X{nn} \\
    \production{integer unary operator} & \iunop &::=&
@@ -81,7 +81,7 @@ These operations closely match respective operations available in hardware.
      \K{sub} ~|~
      \K{mul} ~|~
      \K{div\_}\sx ~|~
-     \K{rem\_}\sx ~|~ \\&&&
+     \K{rem\_}\sx \\&&|&
      \K{and} ~|~
      \K{or} ~|~
      \K{xor} ~|~
@@ -132,16 +132,16 @@ For each type, several subcategories can be distinguished:
 
 * *Binary Operators*: consume two operands and produce one result of the respective type.
 
-* *Tests*: consume one operand of the respective type and produce a Boolean result.
+* *Tests*: consume one operand of the respective type and produce a Boolean integer result.
 
-* *Comparisons*: consume two operands of the respective type and produce a Boolean result.
+* *Comparisons*: consume two operands of the respective type and produce a Boolean integer result.
 
 * *Conversions*: consume a value of one type and produce a result of another
   (the source type of the conversion is the one after the ":math:`\K{/}`").
 
 Some integer instructions come in two flavours,
-where a signedness annotation |sx| distinguishes whether the operands are to be interpreted as :ref:`unsigned <syntax-uint>` or :ref:`signed <syntax-sint>` integers.
-For the other integer instructions, the use of 2's complement for the signed interpretation means that they behave the same regardless of signedness.
+where a signedness annotation |sx| distinguishes whether the operands are to be :ref:`interpreted <aux-signed>` as :ref:`unsigned <syntax-uint>` or :ref:`signed <syntax-sint>` integers.
+For the other integer instructions, the use of two's complement for the signed interpretation means that they behave the same regardless of signedness.
 
 
 Conventions
@@ -166,7 +166,7 @@ Occasionally, it is convenient to group operators together according to the foll
    \end{array}
 
 
-.. index:: ! parametric instruction
+.. index:: ! parametric instruction, value type
    pair: abstract syntax; instruction
 .. _syntax-instr-parametric:
 
@@ -176,10 +176,10 @@ Parametric Instructions
 Instructions in this group can operate on operands of any :ref:`value type <syntax-valtype>`.
 
 .. math::
-   \begin{array}{llll}
+   \begin{array}{llcl}
    \production{instruction} & \instr &::=&
-     \dots ~|~ \\&&&
-     \DROP ~|~ \\&&&
+     \dots \\&&|&
+     \DROP \\&&|&
      \SELECT
    \end{array}
 
@@ -198,21 +198,21 @@ Variable Instructions
 Variable instructions are concerned with the access to :ref:`local <syntax-local>` or :ref:`global <syntax-global>` variables.
 
 .. math::
-   \begin{array}{llll}
+   \begin{array}{llcl}
    \production{instruction} & \instr &::=&
-     \dots ~|~ \\&&&
-     \GETLOCAL~\localidx ~|~ \\&&&
-     \SETLOCAL~\localidx ~|~ \\&&&
-     \TEELOCAL~\localidx ~|~ \\&&&
-     \GETGLOBAL~\globalidx ~|~ \\&&&
-     \SETGLOBAL~\globalidx ~|~ \\
+     \dots \\&&|&
+     \GETLOCAL~\localidx \\&&|&
+     \SETLOCAL~\localidx \\&&|&
+     \TEELOCAL~\localidx \\&&|&
+     \GETGLOBAL~\globalidx \\&&|&
+     \SETGLOBAL~\globalidx \\
    \end{array}
 
 These instructions get or set the values of variables, respectively.
 The |TEELOCAL| instruction is like |SETLOCAL| but also returns its argument.
 
 
-.. index:: ! memory instruction, memory index
+.. index:: ! memory instruction, memory, memory index, page size, little endian, trap
    pair: abstract syntax; instruction
 .. _syntax-loadn:
 .. _syntax-storen:
@@ -222,31 +222,31 @@ The |TEELOCAL| instruction is like |SETLOCAL| but also returns its argument.
 Memory Instructions
 ~~~~~~~~~~~~~~~~~~~
 
-Instructions in this group are concerned with :ref:`linear memory <syntax-mem>`.
+Instructions in this group are concerned with linear :ref:`memory <syntax-mem>`.
 
 .. math::
-   \begin{array}{llll}
+   \begin{array}{llcl}
    \production{memory immediate} & \memarg &::=&
      \{ \OFFSET~\u32, \ALIGN~\u32 \} \\
    \production{instruction} & \instr &::=&
-     \dots ~|~ \\&&&
+     \dots \\&&|&
      \K{i}\X{nn}\K{.}\LOAD~\memarg ~|~
-     \K{f}\X{nn}\K{.}\LOAD~\memarg ~|~ \\&&&
+     \K{f}\X{nn}\K{.}\LOAD~\memarg \\&&|&
      \K{i}\X{nn}\K{.}\STORE~\memarg ~|~
-     \K{f}\X{nn}\K{.}\STORE~\memarg ~|~ \\&&&
+     \K{f}\X{nn}\K{.}\STORE~\memarg \\&&|&
      \K{i}\X{nn}\K{.}\LOAD\K{8\_}\sx~\memarg ~|~
      \K{i}\X{nn}\K{.}\LOAD\K{16\_}\sx~\memarg ~|~
-     \K{i64.}\LOAD\K{32\_}\sx~\memarg ~|~ \\&&&
+     \K{i64.}\LOAD\K{32\_}\sx~\memarg \\&&|&
      \K{i}\X{nn}\K{.}\STORE\K{8}~\memarg ~|~
      \K{i}\X{nn}\K{.}\STORE\K{16}~\memarg ~|~
-     \K{i64.}\STORE\K{32}~\memarg ~|~ \\&&&
-     \CURRENTMEMORY ~|~ \\&&&
+     \K{i64.}\STORE\K{32}~\memarg \\&&|&
+     \CURRENTMEMORY \\&&|&
      \GROWMEMORY \\
    \end{array}
 
 Memory is accessed with |LOAD| and |STORE| instructions for the different :ref:`value types <syntax-valtype>`.
 They all take a *memory immediate* |memarg| that contains an address *offset* and an *alignment* hint.
-Integer loads and stores can optionally specify a *storage size* that is smaller than the :ref:`width <syntax-valtype>` of the respective value type.
+Integer loads and stores can optionally specify a *storage size* that is smaller than the :ref:`bit width <syntax-valtype>` of the respective value type.
 In the case of loads, a sign extension mode |sx| is then required to select appropriate behavior.
 
 The static address offset is added to the dynamic address operand, yielding a 33 bit *effective address* that is the zero-based index at which the memory is accessed.
@@ -266,7 +266,7 @@ Both instructions operate in units of :ref:`page size <page-size>`.
    This restriction may be lifted in future versions.
 
 
-.. index:: ! control instruction, ! structured control, ! label, ! block, ! branch, ! unwinding, result type, label index, function index, type index, vector
+.. index:: ! control instruction, ! structured control, ! label, ! block, ! branch, ! unwinding, result type, label index, function index, type index, vector, trap, function, table, function type
    pair: abstract syntax; instruction
 .. _syntax-nop:
 .. _syntax-unreachable:
@@ -288,19 +288,19 @@ Control Instructions
 Instructions in this group affect the flow of control.
 
 .. math::
-   \begin{array}{llll}
+   \begin{array}{llcl}
    \production{instruction} & \instr &::=&
-     \dots ~|~ \\&&&
-     \NOP ~|~ \\&&&
-     \UNREACHABLE ~|~ \\&&&
-     \BLOCK~\resulttype~\instr^\ast~\END ~|~ \\&&&
-     \LOOP~\resulttype~\instr^\ast~\END ~|~ \\&&&
-     \IF~\resulttype~\instr^\ast~\ELSE~\instr^\ast~\END ~|~ \\&&&
-     \BR~\labelidx ~|~ \\&&&
-     \BRIF~\labelidx ~|~ \\&&&
-     \BRTABLE~\vec(\labelidx)~\labelidx ~|~ \\&&&
-     \RETURN ~|~ \\&&&
-     \CALL~\funcidx ~|~ \\&&&
+     \dots \\&&|&
+     \NOP \\&&|&
+     \UNREACHABLE \\&&|&
+     \BLOCK~\resulttype~\instr^\ast~\END \\&&|&
+     \LOOP~\resulttype~\instr^\ast~\END \\&&|&
+     \IF~\resulttype~\instr^\ast~\ELSE~\instr^\ast~\END \\&&|&
+     \BR~\labelidx \\&&|&
+     \BRIF~\labelidx \\&&|&
+     \BRTABLE~\vec(\labelidx)~\labelidx \\&&|&
+     \RETURN \\&&|&
+     \CALL~\funcidx \\&&|&
      \CALLINDIRECT~\typeidx \\
    \end{array}
 
@@ -337,9 +337,9 @@ Branch instructions come in several flavors:
 and |BRTABLE| performs an indirect branch through an operand indexing into the label vector that is an immediate to the instruction, or to a default target if the operand is out of bounds.
 The |RETURN| instruction is a shortcut for an unconditional branch to the outermost block, which implicitly is the body of the current function.
 Taking a branch *unwinds* the operand stack up to the height where the targeted structured control instruction was entered.
-However, forward branches that target a control instruction with a non-empty result type consume a matching operand first and push it back on the operand stack after unwinding, as a result for the terminated instruction.
+However, forward branches that target a control instruction with a non-empty result type consume matching operands first and push them back on the operand stack after unwinding, as a result for the terminated structured instruction.
 
-The |CALL| instruction invokes another function, consuming the necessary arguments from the stack and returning the result values of the call.
+The |CALL| instruction invokes another :ref:`function <syntax-func>`, consuming the necessary arguments from the stack and returning the result values of the call.
 The |CALLINDIRECT| instruction calls a function indirectly through an operand indexing into a :ref:`table <syntax-table>`.
 Since tables may contain function elements of heterogeneous type |ANYFUNC|,
 the callee is dynamically checked against the :ref:`function type <syntax-functype>` indexed by the instruction's immediate, and the call aborted with a :ref:`trap <trap>` if it does not match.
@@ -350,7 +350,7 @@ the callee is dynamically checked against the :ref:`function type <syntax-functy
    This restriction may be lifted in future versions.
 
 
-.. index:: ! expression, constant
+.. index:: ! expression, constant, global, offset, element, data, instruction
    pair: abstract syntax; expression
    single: expression; constant
 .. _syntax-expr:
@@ -358,7 +358,7 @@ the callee is dynamically checked against the :ref:`function type <syntax-functy
 Expressions
 ~~~~~~~~~~~
 
-:ref:`Function <syntax-func>` bodies, initialization values for :ref:`globals <syntax-global>` and offsets of :ref:`element <syntax-elem>` or :ref:`data <syntax-data>` segments are given as expressions, which are sequences of :ref:`instructions <syntax-instr>` terminated by an |END| marker.
+:ref:`Function <syntax-func>` bodies, initialization values for :ref:`globals <syntax-global>`, and offsets of :ref:`element <syntax-elem>` or :ref:`data <syntax-data>` segments are given as expressions, which are sequences of :ref:`instructions <syntax-instr>` terminated by an |END| marker.
 
 .. math::
    \begin{array}{llll}
@@ -366,4 +366,4 @@ Expressions
      \instr^\ast~\END \\
    \end{array}
 
-In some places, validation :ref:`restricts <valid-constant>` expressions to be *constant*, which limits the set of allowable insructions.
+In some places, validation :ref:`restricts <valid-constant>` expressions to be *constant*, which limits the set of allowable instructions.
diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index 8ddd247bc..ae0f5d73b 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -14,22 +14,22 @@ and provide initialization logic in the form of :ref:`data <syntax-data>` and :r
 .. math::
    \begin{array}{lllll}
    \production{module} & \module &::=& \{ &
-     \TYPES~\vec(\functype), \\&&&&
-     \FUNCS~\vec(\func), \\&&&&
-     \TABLES~\vec(\table), \\&&&&
-     \MEMS~\vec(\mem), \\&&&&
-     \GLOBALS~\vec(\global), \\&&&&
-     \ELEM~\vec(\elem), \\&&&&
-     \DATA~\vec(\data), \\&&&&
-     \START~\start^?, \\&&&&
-     \IMPORTS~\vec(\import), \\&&&&
-     \EXPORTS~\vec(\export) \quad\} \\
+     \MTYPES~\vec(\functype), \\&&&&
+     \MFUNCS~\vec(\func), \\&&&&
+     \MTABLES~\vec(\table), \\&&&&
+     \MMEMS~\vec(\mem), \\&&&&
+     \MGLOBALS~\vec(\global), \\&&&&
+     \MELEM~\vec(\elem), \\&&&&
+     \MDATA~\vec(\data), \\&&&&
+     \MSTART~\start^?, \\&&&&
+     \MIMPORTS~\vec(\import), \\&&&&
+     \MEXPORTS~\vec(\export) \quad\} \\
    \end{array}
 
 Each of the vectors -- and thus the entire module -- may be empty.
 
 
-.. index:: ! index, ! index space, ! type index, ! function index, ! table index, ! memory index, ! global index, ! local index, ! label index
+.. index:: ! index, ! index space, ! type index, ! function index, ! table index, ! memory index, ! global index, ! local index, ! label index, function, global, table, memory, local, parameter, import
    pair: abstract syntax; type index
    pair: abstract syntax; function index
    pair: abstract syntax; table index
@@ -70,12 +70,12 @@ Each class of definition has its own *index space*, as distinguished by the foll
    \production{label index} & \labelidx &::=& \u32 \\
    \end{array}
 
-The index space for functions, tables, memories and globals includes respective imports declared in the same module.
+The index space for :ref:`functions <syntax-func>`, :ref:`tables <syntax-table>`, :ref:`memories <syntax-mem>` and :ref:`globals <syntax-global>` includes respective :ref:`imports <syntax-import>` declared in the same module.
 The indices of these imports precede the indices of other definitions in the same index space.
 
-The index space for locals is only accessible inside a function and includes the parameters and local variables of that function, which precede the other locals.
+The index space for :ref:`locals <syntax-local>` is only accessible inside a :ref:`function <syntax-func>` and includes the parameters and local variables of that function, which precede the other locals.
 
-Label indices reference block instructions inside an instruction sequence.
+Label indices reference :ref:`structured control instructions <syntax-instr-control>` inside an instruction sequence.
 
 
 Conventions
@@ -86,16 +86,16 @@ Conventions
 * The meta variables :math:`x, y` ranges over indices in any of the other index spaces.
 
 
-.. index:: ! type definition, type index
+.. index:: ! type definition, type index, function type
    pair: abstract syntax; type definition
 .. _syntax-typedef:
 
 Types
 ~~~~~
 
-The |TYPES| component of a module defines a vector of :ref:`function types <syntax-functype>`.
+The |MTYPES| component of a module defines a vector of :ref:`function types <syntax-functype>`.
 
-All function types used in a module must be defined in the type section.
+All function types used in a module must be defined in this component.
 They are referenced by :ref:`type indices <syntax-typeidx>`.
 
 .. note::
@@ -111,22 +111,22 @@ They are referenced by :ref:`type indices <syntax-typeidx>`.
 Functions
 ~~~~~~~~~
 
-The |FUNCS| component of a module defines a vector of *functions* with the following structure:
+The |MFUNCS| component of a module defines a vector of *functions* with the following structure:
 
 .. math::
    \begin{array}{llll}
    \production{function} & \func &::=&
-     \{ \TYPE~\typeidx, \LOCALS~\vec(\valtype), \BODY~\expr \} \\
+     \{ \FTYPE~\typeidx, \FLOCALS~\vec(\valtype), \FBODY~\expr \} \\
    \end{array}
 
-The |TYPE| of a function declares its signature by reference to a :ref:`type <syntax-type>` defined in the module.
+The |FTYPE| of a function declares its signature by reference to a :ref:`type <syntax-type>` defined in the module.
 The parameters of the function are referenced through 0-based :ref:`local indices <syntax-localidx>` in the function's body.
 
-The |LOCALS| declare a vector of mutable local variables and their types.
+The |FLOCALS| declare a vector of mutable local variables and their types.
 These variables are referenced through :ref:`local indices <syntax-localidx>` in the function's body.
 The index of the first local is the smallest index not referencing a parameter.
 
-The |BODY| is an :ref:`instruction <syntax-expr>` sequence that upon termination must produce a stack matching the function type's :ref:`result type <syntax-resulttype>`.
+The |FBODY| is an :ref:`instruction <syntax-expr>` sequence that upon termination must produce a stack matching the function type's :ref:`result type <syntax-resulttype>`.
 
 Functions are referenced through :ref:`function indices <syntax-funcidx>`,
 starting with the smallest index not referencing a function :ref:`import <syntax-import>`.
@@ -139,16 +139,16 @@ starting with the smallest index not referencing a function :ref:`import <syntax
 Tables
 ~~~~~~
 
-The |TABLES| component of a module defines a vector of *tables* described by their :ref:`table type <syntax-tabletype>`:
+The |MTABLES| component of a module defines a vector of *tables* described by their :ref:`table type <syntax-tabletype>`:
 
 .. math::
    \begin{array}{llll}
    \production{table} & \table &::=&
-     \{ \TYPE~\tabletype \} \\
+     \{ \TTYPE~\tabletype \} \\
    \end{array}
 
 A table is a vector of opaque values of a particular table :ref:`element type <syntax-elemtype>`.
-The |MIN| size in the :ref:`limits <syntax-limits>` of the table type of a definition specifies the initial size of that table, while its |MAX|, if present, restricts the size to which it can grow later.
+The |LMIN| size in the :ref:`limits <syntax-limits>` of the table type specifies the initial size of that table, while its |LMAX|, if present, restricts the size to which it can grow later.
 
 Tables can be initialized through :ref:`element segments <syntax-elem>`.
 
@@ -169,16 +169,16 @@ Most constructs implicitly reference table index :math:`0`.
 Memories
 ~~~~~~~~
 
-The |MEMS| component of a module defines a vector of *linear memories* (or *memories* for short) as described by their :ref:`memory type <syntax-memtype>`:
+The |MMEMS| component of a module defines a vector of *linear memories* (or *memories* for short) as described by their :ref:`memory type <syntax-memtype>`:
 
 .. math::
    \begin{array}{llll}
    \production{memory} & \mem &::=&
-     \{ \TYPE~\memtype \} \\
+     \{ \MTYPE~\memtype \} \\
    \end{array}
 
 A memory is a vector of raw uninterpreted bytes.
-The |MIN| size in the :ref:`limits <syntax-limits>` of the memory type of a definition specifies the initial size of that memory, while its |MAX|, if present, restricts the size to which it can grow later.
+The |LMIN| size in the :ref:`limits <syntax-limits>` of the memory type specifies the initial size of that memory, while its |LMAX|, if present, restricts the size to which it can grow later.
 Both are in units of :ref:`page size <page-size>`.
 
 Memories can be initialized through :ref:`data segments <syntax-data>`.
@@ -193,30 +193,30 @@ Most constructs implicitly reference memory index :math:`0`.
    This restriction may be lifted in future versions.
 
 
-.. index:: ! global, global index, global type, mutability, expression
+.. index:: ! global, global index, global type, mutability, expression, constant, value, import
    pair: abstract syntax; global
 .. _syntax-global:
 
 Globals
 ~~~~~~~
 
-The |GLOBALS| component of a module defines a vector of *global variables* (or *globals* for short):
+The |MGLOBALS| component of a module defines a vector of *global variables* (or *globals* for short):
 
 .. math::
    \begin{array}{llll}
    \production{global} & \global &::=&
-     \{ \TYPE~\globaltype, \INIT~\expr \} \\
+     \{ \GTYPE~\globaltype, \GINIT~\expr \} \\
    \end{array}
 
 Each global stores a single value of the given :ref:`global type <syntax-globaltype>`.
-Its |TYPE| also specifies whether a global is immutable or mutable.
-Moreover, each global is initialized with an |INIT| value given by a :ref:`constant <valid-constant>` initializer :ref:`expression <syntax-expr>`.
+Its |GTYPE| also specifies whether a global is immutable or mutable.
+Moreover, each global is initialized with an |GINIT| value given by a :ref:`constant <valid-constant>` initializer :ref:`expression <syntax-expr>`.
 
 Globals are referenced through :ref:`global indices <syntax-globalidx>`,
 starting with the smallest index not referencing a global :ref:`import <syntax-import>`.
 
 
-.. index:: ! element, table, table index, expression, function index, vector
+.. index:: ! element, table, table index, expression, constant, function index, vector
    pair: abstract syntax; element
    single: table; element
    single: element; segment
@@ -226,22 +226,22 @@ Element Segments
 ~~~~~~~~~~~~~~~~
 
 The initial contents of a table is uninitialized.
-The |ELEM| component of a module defines a vector of *element segments* that initialize a subrange of a table at a given offset from a static vector of elements.
+The |MELEM| component of a module defines a vector of *element segments* that initialize a subrange of a table at a given offset from a static :ref:`vector <syntax-vec>` of elements.
 
 .. math::
    \begin{array}{llll}
    \production{element segment} & \elem &::=&
-     \{ \TABLE~\tableidx, \OFFSET~\expr, \INIT~\vec(\funcidx) \} \\
+     \{ \ETABLE~\tableidx, \EOFFSET~\expr, \EINIT~\vec(\funcidx) \} \\
    \end{array}
 
-The |OFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <syntax-expr>`.
+The |EOFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <syntax-expr>`.
 
 .. note::
    In the current version of WebAssembly, at most one table is allowed in a module.
    Consequently, the only valid |tableidx| is :math:`0`.
 
 
-.. index:: ! data, memory, memory index, expression, byte, vector
+.. index:: ! data, memory, memory index, expression, constant, byte, vector
    pair: abstract syntax; data
    single: memory; data
    single: data; segment
@@ -251,34 +251,34 @@ Data Segments
 ~~~~~~~~~~~~~
 
 The initial contents of a :ref:`memory <syntax-mem>` are zero bytes.
-The |DATA| component of a module defines a vector of *data segments* that initialize a range of memory at a given offset with a static vector of bytes.
+The |MDATA| component of a module defines a vector of *data segments* that initialize a range of memory at a given offset with a static :ref:`vector <syntax-vec>` of :ref:`bytes <syntax-byte>`.
 
 .. math::
    \begin{array}{llll}
    \production{data segment} & \data &::=&
-     \{ \MEM~\memidx, \OFFSET~\expr, \INIT~\vec(\byte) \} \\
+     \{ \DMEM~\memidx, \DOFFSET~\expr, \DINIT~\vec(\byte) \} \\
    \end{array}
 
-The |OFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <syntax-expr>`.
+The |DOFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <syntax-expr>`.
 
 .. note::
    In the current version of WebAssembly, at most one memory is allowed in a module.
    Consequently, the only valid |memidx| is :math:`0`.
 
 
-.. index:: ! start function, function index, table, memory, instantiation
+.. index:: ! start function, function, function index, table, memory, instantiation
    pair: abstract syntax; start function
 .. _syntax-start:
 
 Start Function
 ~~~~~~~~~~~~~~
 
-The |START| component of a module optionally declares the :ref:`function index <syntax-funcidx>` of a *start function* that is automatically invoked when the module is :ref:`instantiated <exec-instantiation>`, after tables and memories have been initialized.
+The |MSTART| component of a module optionally declares the :ref:`function index <syntax-funcidx>` of a *start function* that is automatically invoked when the module is :ref:`instantiated <exec-instantiation>`, after :ref:`tables <syntax-table>` and :ref:`memories <syntax-mem>` have been initialized.
 
 .. math::
    \begin{array}{llll}
    \production{start function} & \start &::=&
-     \{ \FUNC~\funcidx \} \\
+     \{ \SFUNC~\funcidx \} \\
    \end{array}
 
 
@@ -294,17 +294,17 @@ The |START| component of a module optionally declares the :ref:`function index <
 Exports
 ~~~~~~~
 
-The |EXPORTS| component of a module defines a set of *exports* that become accessible to the host environment once the module has been :ref:`instantiated <exec-instantiation>`.
+The |MEXPORTS| component of a module defines a set of *exports* that become accessible to the host environment once the module has been :ref:`instantiated <exec-instantiation>`.
 
 .. math::
-   \begin{array}{llll}
+   \begin{array}{llcl}
    \production{export} & \export &::=&
-     \{ \NAME~\name, \DESC~\exportdesc \} \\
+     \{ \ENAME~\name, \EDESC~\exportdesc \} \\
    \production{export description} & \exportdesc &::=&
-     \FUNC~\funcidx ~|~ \\&&&
-     \TABLE~\tableidx ~|~ \\&&&
-     \MEM~\memidx ~|~ \\&&&
-     \GLOBAL~\globalidx \\
+     \EDFUNC~\funcidx \\&&|&
+     \EDTABLE~\tableidx \\&&|&
+     \EDMEM~\memidx \\&&|&
+     \EDGLOBAL~\globalidx \\
    \end{array}
 
 Each export is identified by a unique :ref:`name <syntax-name>`.
@@ -320,13 +320,13 @@ Conventions
 
 The following auxiliary notation is defined for sequences of exports, filtering out indices of a specific kind in an order-preserving fashion:
 
-* :math:`\funcs(\export^\ast) = [\funcidx ~|~ \FUNC~\funcidx \in (\export.\DESC)^\ast]`
+* :math:`\edfuncs(\export^\ast) = [\funcidx ~|~ \EDFUNC~\funcidx \in (\export.\EDESC)^\ast]`
 
-* :math:`\tables(\export^\ast) = [\tableidx ~|~ \TABLE~\tableidx \in (\export.\DESC)^\ast]`
+* :math:`\edtables(\export^\ast) = [\tableidx ~|~ \EDTABLE~\tableidx \in (\export.\EDESC)^\ast]`
 
-* :math:`\mems(\export^\ast) = [\memidx ~|~ \MEM~\memidx \in (\export.\DESC)^\ast]`
+* :math:`\edmems(\export^\ast) = [\memidx ~|~ \EDMEM~\memidx \in (\export.\EDESC)^\ast]`
 
-* :math:`\globals(\export^\ast) = [\globalidx ~|~ \GLOBAL~\globalidx \in (\export.\DESC)^\ast]`
+* :math:`\edglobals(\export^\ast) = [\globalidx ~|~ \EDGLOBAL~\globalidx \in (\export.\EDESC)^\ast]`
 
 
 .. index:: ! import, name, function type, table type, memory type, global type, index, index space, type index, function index, table index, memory index, global index, function, table, memory, global, instantiation
@@ -341,20 +341,20 @@ The following auxiliary notation is defined for sequences of exports, filtering
 Imports
 ~~~~~~~
 
-The |IMPORTS| component of a module defines a set of *imports* that are required for :ref:`instantiation <exec-instantiation>`.
+The |MIMPORTS| component of a module defines a set of *imports* that are required for :ref:`instantiation <exec-instantiation>`.
 
 .. math::
    \begin{array}{llll}
    \production{import} & \import &::=&
-     \{ \MODULE~\name, \NAME~\name, \DESC~\importdesc \} \\
+     \{ \IMODULE~\name, \INAME~\name, \IDESC~\importdesc \} \\
    \production{import description} & \importdesc &::=&
-     \FUNC~\typeidx ~|~ \\&&&
-     \TABLE~\tabletype ~|~ \\&&&
-     \MEM~\memtype ~|~ \\&&&
-     \GLOBAL~\globaltype \\
+     \IDFUNC~\typeidx \\&&|&
+     \IDTABLE~\tabletype \\&&|&
+     \IDMEM~\memtype \\&&|&
+     \IDGLOBAL~\globaltype \\
    \end{array}
 
-Each import is identified by a two-level :ref:`name <syntax-name>` space, consisting of a |MODULE| name and a unique |NAME| for an entity within that module.
+Each import is identified by a two-level :ref:`name <syntax-name>` space, consisting of a |IMODULE| name and a unique |INAME| for an entity within that module.
 Importable definitions are :ref:`functions <syntax-func>`, :ref:`tables <syntax-table>`, :ref:`memories <syntax-mem>`, and :ref:`globals <syntax-global>`.
 Each import is specified by a descriptor with a respective type that a definition provided during instantiation is required to match.
 
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index db07f0a52..7065057f4 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -1,12 +1,15 @@
-.. index:: ! type
+.. index:: ! type, validation, instantiation, execution
    pair: abstract syntax; type
 .. _syntax-type:
 
 Types
 -----
 
+Various entitites in WebAssembly are classified by types.
+Types are checked during :ref:`validation <valid>`, :ref:`instantiation <exec-instantiation>`, and possibly :ref:`execution <syntax-call_indirect>`.
 
-.. index:: ! value type
+
+.. index:: ! value type, integer, floating-point, IEEE 754, bit width
    pair: abstract syntax; value type
    pair: value; type
 .. _syntax-valtype:
@@ -25,19 +28,19 @@ Value Types
 The types |I32| and |I64| classify 32 and 64 bit integers, respectively.
 Integers are not inherently signed or unsigned, their interpretation is determined by individual operations.
 
-The types |F32| and |F64| classify 32 and 64 bit floating points, respectively.
-They correspond to single and double precision floating point types as defined by the `IEEE-754 <http://ieeexplore.ieee.org/document/4610935/>`_ standard
+The types |F32| and |F64| classify 32 and 64 bit floating-point data, respectively.
+They correspond to *single* and *double* precision floating-point types as defined by the `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ standard
 
 Conventions
 ...........
 
 * The meta variable :math:`t` ranges over value types where clear from context.
 
-* The notation :math:`|t|` denotes the *width* of a value type.
-  (That is, :math:`|\I32| = |\F32| = 32` and :math:`|\I64| = |\F64| = 64`.)
+* The notation :math:`|t|` denotes the *bit width* of a value type.
+  That is, :math:`|\I32| = |\F32| = 32` and :math:`|\I64| = |\F64| = 64`.
 
 
-.. index:: ! result type, value type
+.. index:: ! result type, value type, instruction, execution, block
    pair: abstract syntax; result type
    pair: result; type
 .. _syntax-resulttype:
@@ -45,7 +48,7 @@ Conventions
 Result Types
 ~~~~~~~~~~~~
 
-*Result types* classify the results of functions or blocks,
+*Result types* classify the result of :ref:`executing <exec-instr>` :ref:`instructions <syntax-instr>` or :ref:`blocks <syntax-instr-control>`,
 which is a sequence of values.
 
 .. math::
@@ -59,7 +62,7 @@ which is a sequence of values.
    However, this may be generalized to sequences of values in future versions.
 
 
-.. index:: ! function type, value type, result type
+.. index:: ! function type, value type, vector, function, parameter, result
    pair: abstract syntax; function type
    pair: function; type
 .. _syntax-functype:
@@ -67,7 +70,7 @@ which is a sequence of values.
 Function Types
 ~~~~~~~~~~~~~~
 
-*Function types* classify the signature of functions,
+*Function types* classify the signature of :ref:`functions <syntax-func>`,
 mapping a vector of parameters to a vector of results.
 
 .. math::
@@ -91,18 +94,18 @@ mapping a vector of parameters to a vector of results.
 Limits
 ~~~~~~
 
-*Limits* classify the size range of resizeable storage like associated with :ref:`memory types <syntax-memtype>` and :ref:`table types <syntax-tabletype>`.
+*Limits* classify the size range of resizeable storage associated with :ref:`memory types <syntax-memtype>` and :ref:`table types <syntax-tabletype>`.
 
 .. math::
    \begin{array}{llll}
    \production{limits} & \limits &::=&
-     \{ \MIN~\u32, \MAX~\u32^? \} \\
+     \{ \LMIN~\u32, \LMAX~\u32^? \} \\
    \end{array}
 
 If no maximum is given, the respective storage can grow to any size.
 
 
-.. index:: ! memory type, limits, page size
+.. index:: ! memory type, limits, page size, memory
    pair: abstract syntax; memory type
    pair: memory; type
    pair: memory; limits
@@ -111,7 +114,7 @@ If no maximum is given, the respective storage can grow to any size.
 Memory Types
 ~~~~~~~~~~~~
 
-*Memory types* classify linear memories and their size range.
+*Memory types* classify linear :ref:`memories <syntax-mem>` and their size range.
 
 .. math::
    \begin{array}{llll}
@@ -123,7 +126,7 @@ The limits constrain the minimum and optionally the maximum size of a memory.
 The limits are given in units of :ref:`page size <page-size>`.
 
 
-.. index:: ! table type, ! element type, limits
+.. index:: ! table type, ! element type, limits, table, element
    pair: abstract syntax; table type
    pair: abstract syntax; element type
    pair: table; type
@@ -135,7 +138,7 @@ The limits are given in units of :ref:`page size <page-size>`.
 Table Types
 ~~~~~~~~~~~
 
-*Table types* classify tables over elements of *element types* within a given size range.
+*Table types* classify :ref:`tables <syntax-table>` over elements of *element types* within a size range.
 
 .. math::
    \begin{array}{llll}
@@ -148,14 +151,14 @@ Table Types
 Like memories, tables are constrained by limits for their minimum and optionally maximum size.
 The limits are given in numbers of entries.
 
-The element type |ANYFUNC| is the infinite union of all `function types`.
+The element type |ANYFUNC| is the infinite union of all :ref:`function types <syntax-functype>`.
 A table of that type thus contains references to functions of heterogeneous type.
 
 .. note::
    In future versions of WebAssembly, additional element types may be introduced.
 
 
-.. index:: ! global type, ! mutability, value type
+.. index:: ! global type, ! mutability, value type, global, mutability
    pair: abstract syntax; global type
    pair: abstract syntax; mutability
    pair: global; type
@@ -166,7 +169,7 @@ A table of that type thus contains references to functions of heterogeneous type
 Global Types
 ~~~~~~~~~~~~
 
-*Global types* classify global variables, which hold a value and can either be mutable or immutable.
+*Global types* classify :ref:`global <syntax-global>` variables, which hold a value and can either be mutable or immutable.
 
 .. math::
    \begin{array}{llll}
@@ -178,7 +181,7 @@ Global Types
    \end{array}
 
 
-.. index:: ! external type, function type, table type, memory type, global type
+.. index:: ! external type, function type, table type, memory type, global type, import, external value
    pair: abstract syntax; external type
    pair: external; type
 .. _syntax-externtype:
@@ -191,10 +194,10 @@ External Types
 .. math::
    \begin{array}{llll}
    \production{external types} & \externtype &::=&
-     \FUNC~\functype ~|~
-     \TABLE~\tabletype ~|~
-     \MEM~\memtype ~|~
-     \GLOBAL~\globaltype \\
+     \ETFUNC~\functype ~|~
+     \ETTABLE~\tabletype ~|~
+     \ETMEM~\memtype ~|~
+     \ETGLOBAL~\globaltype \\
    \end{array}
 
 
@@ -204,10 +207,10 @@ Conventions
 The following auxiliary notation is defined for sequences of external types.
 It filters out entries of a specific kind in an order-preserving fashion:
 
-.. math::
-   \begin{array}{lcl}
-   \funcs(\externtype^\ast) &=& [\functype ~|~ (\FUNC~\functype) \in \externtype^\ast] \\
-   \tables(\externtype^\ast) &=& [\tabletype ~|~ (\TABLE~\tabletype) \in \externtype^\ast] \\
-   \mems(\externtype^\ast) &=& [\memtype ~|~ (\MEM~\memtype) \in \externtype^\ast] \\
-   \globals(\externtype^\ast) &=& [\globaltype ~|~ (\GLOBAL~\globaltype) \in \externtype^\ast] \\
-   \end{array}
+* :math:`\etfuncs(\externtype^\ast) = [\functype ~|~ (\ETFUNC~\functype) \in \externtype^\ast]`
+
+* :math:`\ettables(\externtype^\ast) = [\tabletype ~|~ (\ETTABLE~\tabletype) \in \externtype^\ast]`
+
+* :math:`\etmems(\externtype^\ast) = [\memtype ~|~ (\ETMEM~\memtype) \in \externtype^\ast]`
+
+* :math:`\etglobals(\externtype^\ast) = [\globaltype ~|~ (\ETGLOBAL~\globaltype) \in \externtype^\ast]`
diff --git a/document/core/syntax/values.rst b/document/core/syntax/values.rst
index 536b6fa74..563b3ae11 100644
--- a/document/core/syntax/values.rst
+++ b/document/core/syntax/values.rst
@@ -5,6 +5,9 @@
 Values
 ------
 
+WebAssembly programs operate on primitive numeric *values*.
+Moreover, in the definition of programs, immutable sequences of values occur to represent more complex data, such as text strings or other vectors.
+
 
 .. index:: ! byte
    pair: abstract syntax; byte
@@ -26,12 +29,12 @@ In the abstract syntax they are represented as hexadecimal literals.
 Conventions
 ...........
 
-* The meta variable :math:`b` range over bytes.
+* The meta variable :math:`b` ranges over bytes.
 
 * Bytes are sometimes interpreted as natural numbers :math:`n < 256`.
 
 
-.. index:: ! integer, ! unsigned integer, ! signed integer, ! uninterpreted integer
+.. index:: ! integer, ! unsigned integer, ! signed integer, ! uninterpreted integer, bit width, two's complement
    pair: abstract syntax; integer
    pair: abstract syntax; unsigned integer
    pair: abstract syntax; signed integer
@@ -46,7 +49,7 @@ Conventions
 Integers
 ~~~~~~~~
 
-Different classes of *integers* with different value ranges are distinguished by their *size* and their *signedness*.
+Different classes of *integers* with different value ranges are distinguished by their *bit width* :math:`N` and by whether they are *unsigned* or *signed*.
 
 .. math::
    \begin{array}{llll}
@@ -59,9 +62,13 @@ Different classes of *integers* with different value ranges are distinguished by
    \end{array}
 
 The latter class defines *uninterpreted* integers, whose signedness interpretation can vary depending on context.
-In the abstract syntax, they are represented as unsigned.
+In the abstract syntax, they are represented as unsigned values.
 However, some operations :ref:`convert <aux-signed>` them to signed based on a two's complement interpretation.
 
+.. note::
+   The main integer types occurring in this specification are |u32|, |u64|, |s32|, |s64|, |i8|, |i16|, |i32|, |i64|.
+   However, other sizes occur as auxiliary constructions, e.g., in the definition of :ref:`floating-point <syntax-float>` numbers.
+
 
 Conventions
 ...........
@@ -69,9 +76,10 @@ Conventions
 * The meta variables :math:`m, n, i` range over integers.
 
 * Numbers may be denoted by simple arithmetics, as in the grammar above.
+  In order to distinguish arithmetics like :math:`2^N` from sequences like :math:`(1)^N`, the latter is distinguished with parentheses.
 
 
-.. index:: ! floating-point number, ! NaN, payload, canonical NaN, arithmetic NaN
+.. index:: ! floating-point, ! NaN, payload, significand, exponent, magnitude, canonical NaN, arithmetic NaN, bit width, IEEE 754
    pair: abstract syntax; floating-point number
    single: NaN; payload
    single: NaN; canonical
@@ -86,26 +94,26 @@ Floating-Point
 *Floating-point* data consists of 32 or 64 bit values according to the `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ standard.
 Every value has a *sign* and a *magnitude*.
 
-Magnitudes can either be expressed as *normal* numbers of the form :math:`m_0.m_1m_2\dots m_M \cdot2^e`, where :math:`m` is the *significand* whose most signifcant bit :math:`m_0` is :math:`1`, and :math:`e` is the exponent,
-or as a *subnormal* number where :math:`m_0` is :math:`0` and the exponent is fixed to the smallest possible value; among the subnormals are positive and negative zero.
+Magnitudes can either be expressed as *normal* numbers of the form :math:`m_0.m_1m_2\dots m_M \cdot2^e`, where :math:`e` is the exponent and :math:`m` is the *significand* whose most signifcant bit :math:`m_0` is :math:`1`,
+or as a *subnormal* number where the exponent is fixed to the smallest possible value and :math:`m_0` is :math:`0`; among the subnormals are positive and negative zero values.
 Since the significands are binary values, normals are represented in the form :math:`(1 + m\cdot 2^{-M})`, where :math:`M` is the bit width of :math:`m`; similarly for subnormals.
 
 Possible magnitudes also include the special values :math:`\infty` (infinity) and |NAN| (*NaN*, not a number).
-NaN values have a *payload* value that describes the mantissa bits in the underlying :ref:`binary representation <aux-fbits>`.
+NaN values have a *payload* that describes the mantissa bits in the underlying :ref:`binary representation <aux-fbits>`.
 No distinction is made between signalling and quiet NaNs.
 
 .. math::
    \begin{array}{llcll}
-   \production{floating-point number} & \fN &::=&
+   \production{floating-point value} & \fN &::=&
      {+} \fNmag ~|~ {-} \fNmag \\
    \production{floating-point magnitude} & \fNmag &::=&
-     (1 + \uM\cdot 2^{-M}) \cdot 2^e & (M = \significand(N) \wedge -2^{\exponent(N)-1}+2 \leq e \leq 2^{\exponent(N)-1}-1) \\ &&|&
-     (0 + \uM\cdot 2^{-M}) \cdot 2^e & (M = \significand(N) \wedge e = -2^{\exponent(N)-1}+2) \\ &&|&
+     (1 + \uM\cdot 2^{-M}) \cdot 2^e & (\iff -2^{E-1}+2 \leq e \leq 2^{E-1}-1) \\ &&|&
+     (0 + \uM\cdot 2^{-M}) \cdot 2^e & (\iff e = -2^{E-1}+2) \\ &&|&
      \infty \\ &&|&
-     \NAN(n) & (1 \leq n < 2^{\significand(N)}) \\
+     \NAN(n) & (\iff 1 \leq n < 2^M) \\
    \end{array}
 
-where
+where :math:`M = \significand(N)` and :math:`E = \exponent(N)` with
 
 .. _aux-significand:
 .. _aux-exponent:
@@ -125,9 +133,9 @@ where
 A *canonical NaN* is a floating-point value :math:`\pm\NAN(\canon_N)` where :math:`\canon_N` is a payload whose most significant bit is :math:`1` while all others are :math:`0`:
 
 .. math::
-   \canon_N = 2^{\significand_N-1}
+   \canon_N = 2^{\significand(N)-1}
 
-An *arithmetic NaN*  is a floating-point value :math:`\pm\NAN(n)` with :math:`n > \canon_N`, such that the most significant bit is :math:`1` while all others are arbitrary.
+An *arithmetic NaN*  is a floating-point value :math:`\pm\NAN(n)` with :math:`n \geq \canon_N`, such that the most significant bit is :math:`1` while all others are arbitrary.
 
 
 Conventions
@@ -135,60 +143,28 @@ Conventions
 
 * The meta variable :math:`z` ranges over floating-point values where clear from context.
 
-* Floating-point numbers, in normal or subnormal form, are sometimes interpreted as rational numbers :math:`q \in \mathbb{Q}`.
-
-
-.. index:: ! vector
-   pair: abstract syntax; vector
-.. _syntax-vec:
 
-Vectors
-~~~~~~~
-
-*Vectors* are bounded sequences of the form :math:`A^n` (or :math:`A^\ast`),
-where the :math:`A`-s can either be values or complex constructions.
-A vector can have at most :math:`2^{32}-1` elements.
-
-.. math::
-   \begin{array}{lllll}
-   \production{vector} & \vec(A) &::=&
-     A^n
-     & (n < 2^{32})\\
-   \end{array}
-
-
-.. index:: ! name, byte, Unicode, UTF-8, code point
+.. index:: ! name, byte, Unicode, UTF-8, code point, binary format
    pair: abstract syntax; name
-.. _syntax-utf8:
 .. _syntax-codepoint:
 .. _syntax-name:
 
 Names
 ~~~~~
 
-*Names* are sequences of *scalar* `Unicode <http://www.unicode.org/versions/latest/>`_ *code points*.
+*Names* are sequences of scalar `Unicode <http://www.unicode.org/versions/latest/>`_ *code points*.
 
 .. math::
    \begin{array}{llclll}
    \production{name} & \name &::=&
-     \codepoint^\ast & (|\utf8(\codepoint^\ast)| < 2^{32}) \\
+     \codepoint^\ast \qquad\qquad (\iff |\utf8(\codepoint^\ast)| < 2^{32}) \\
    \production{code point} & \codepoint &::=&
-     \unicode{0000} ~|~ \dots ~|~ \unicode{D7FF} ~|~
+     \unicode{00} ~|~ \dots ~|~ \unicode{D7FF} ~|~
      \unicode{E000} ~|~ \dots ~|~ \unicode{10FFFF} \\
    \end{array}
 
 Due to the limitations of the :ref:`binary format <binary-name>`,
-the lengths of a name is bounded by the length of its `UTF-8 <http://www.unicode.org/versions/latest/>`_ encoding.
-The auxiliary |utf8| function expressing this encoding is defined as follows:
-
-.. math::
-   \begin{array}{lcl@{\qquad}l}
-   \utf8(c^\ast) &=& (\utf8(c))^\ast \\[1ex]
-   \utf8(c) &=& b & (c < \unicode{80} \wedge c = b) \\
-   \utf8(c) &=& b_1~b_2 & (\unicode{80} \leq c < \unicode{800} \wedge c = 2^6\cdot(b_1-\hex{C0})+(b_2-\hex{80})) \\
-   \utf8(c) &=& b_1~b_2~b_3 & (\unicode{800} \leq c < \unicode{10000} \wedge c = 2^{12}\cdot(b_1-\hex{C0})+2^6\cdot(b_2-\hex{80})+(b_3-\hex{80})) \\
-   \utf8(c) &=& b_1~b_2~b_3~b_4 & (\unicode{10000} \leq c < \unicode{110000} \wedge c = 2^{18}\cdot(b_1-\hex{C0})+2^{12}\cdot(b_2-\hex{80})+2^6\cdot(b_3-\hex{80})+(b_4-\hex{80})) \\
-   \end{array}
+the lengths of a name is bounded by the length of its :ref:`UTF-8 <binary-utf8>` encoding.
 
 
 Convention
diff --git a/document/core/text/conventions.rst b/document/core/text/conventions.rst
index a4d9ac6b8..1982fb0c9 100644
--- a/document/core/text/conventions.rst
+++ b/document/core/text/conventions.rst
@@ -1,20 +1,19 @@
-.. index:: ! text format, Unicode, UTF-8, S-expression, identifier
+.. index:: ! text format, Unicode, UTF-8, S-expression, identifier, file extension, abstract syntax
 
 Conventions
 -----------
 
-The textual format for WebAssembly :ref:`modules <module>` is a rendering of their :ref:`abstract syntax <syntax-module>` into *S-expressions*.
+The textual format for WebAssembly :ref:`modules <module>` is a rendering of their :ref:`abstract syntax <syntax-module>` into `S-expressions <https://en.wikipedia.org/wiki/S-expression>`_.
 
 Like the :ref:`binary format <binary>`, the text format is defined by an *attribute grammar*.
 A text string is a well-formed description of a module if and only if it is generated by the grammar.
-
 Each production of this grammar has at most one synthesized attribute: the abstract syntax that the respective character sequence expresses.
 Thus, the attribute grammar implicitly defines a *parsing* function.
 Some productions also take a :ref:`context <text-context>` as an inherited attribute
 that records bound :ref:`identifers <text-id>`.
 
 Except for a few exceptions, the core of the text grammar closely mirrors the grammar of the abstract syntax.
-However, it also defines a number of *abbreviations* that are *syntactic sugar* over the core syntax.
+However, it also defines a number of *abbreviations* that are "syntactic sugar" over the core syntax.
 
 The recommended extension for source files containing WebAssembly modules in text format is ":math:`\T{.wat}`".
 Files with this extension are assumed to be encoded in `Unicode UTF-8 <http://www.unicode.org/versions/latest/>`_.
@@ -30,7 +29,7 @@ Grammar
 
 The following conventions are adopted in defining grammar rules for the text format.
 They mirror the conventions used for :ref:`abstract syntax <grammar>` and for the :ref:`binary format <binary>`.
-In order to distinguish symbols of the textual syntax from symbols of the abstract syntax, typewriter font is adopted for the former.
+In order to distinguish symbols of the textual syntax from symbols of the abstract syntax, :math:`\mathtt{typewriter}` font is adopted for the former.
 
 * Terminal symbols are either literal strings of characters enclosed in quotes: :math:`\text{module}`;
   or expressed as `Unicode <http://www.unicode.org/versions/latest/>`_ code points: :math:`\unicode{0A}`.
@@ -38,8 +37,6 @@ In order to distinguish symbols of the textual syntax from symbols of the abstra
 
 * Nonterminal symbols are written in typewriter font: :math:`\T{valtype}, \T{instr}`.
 
-* Arbitrary :ref:`white space <text-space>` is allowed in any place where the grammar contains spaces, except where noted otherwise, such as the :ref:`lexical syntax <text-lexical>`.
-
 * :math:`T^n` is a sequence of :math:`n\geq 0` iterations  of :math:`T`.
 
 * :math:`T^\ast` is a possibly empty sequence of iterations of :math:`T`.
@@ -53,10 +50,14 @@ In order to distinguish symbols of the textual syntax from symbols of the abstra
 
 * :math:`x{:}T` denotes the same language as the nonterminal :math:`T`, but also binds the variable :math:`x` to the attribute synthesized for :math:`T`.
 
-* Productions are written :math:`\T{name} ::= T \Rightarrow A`, where :math:`A` is the attribute that is synthesized for :math:`\T{name}`, usually from attribute variables bound in :math:`T`.
+* Productions are written :math:`\T{sym} ::= T_1 \Rightarrow A_1 ~|~ \dots ~|~ T_n \Rightarrow A_n`, where each :math:`A_i` is the attribute that is synthesized for :math:`\T{sym}` in the given case, usually from attribute variables bound in :math:`T_i`.
 
 * Some productions are augmented by side conditions in parentheses, which restrict the applicability of the production. They provide a shorthand for a combinatorial expansion of the production into many separate cases.
 
+.. _text-syntactic:
+
+* A distinction is made between *lexical* and *syntactic* productions. For the latter, arbitrary :ref:`white space <text-space>` is allowed in any place where the grammar contains spaces. The productions defining :ref:`lexical syntax <text-lexical>` and the syntax of :Ref:`values <text-value>` are considered lexical, all others are syntactic.
+
 .. note::
    For example, the :ref:`textual grammar <text-valtype>` for :ref:`value types <syntax-valtype>` is given as follows:
 
@@ -74,15 +75,15 @@ In order to distinguish symbols of the textual syntax from symbols of the abstra
    .. math::
       \begin{array}{llclll}
       \production{limits} & \Tlimits &::=&
-        n{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~\epsilon \} \\ &&|&
-        n{:}\Tu32~~m{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~m \} \\
+        n{:}\Tu32 &\Rightarrow& \{ \LMIN~n, \LMAX~\epsilon \} \\ &&|&
+        n{:}\Tu32~~m{:}\Tu32 &\Rightarrow& \{ \LMIN~n, \LMAX~m \} \\
       \end{array}
 
-   The variables :math:`n` and :math:`m` name the attributes of the respective |Tu32| nonterminals, which in this case are the actual :ref:`unsigned integers <syntax-uint>` they decode into.
+   The variables :math:`n` and :math:`m` name the attributes of the respective |Tu32| nonterminals, which in this case are the actual :ref:`unsigned integers <syntax-uint>` those parse into.
    The attribute of the complete production then is the abstract syntax for the limit, expressed in terms of the former values.
 
 
-.. index:: ! abbreviations
+.. index:: ! abbreviations, rewrite rule
 .. _text-abbreviations:
 
 Abbreviations
@@ -90,7 +91,7 @@ Abbreviations
 
 In addition to the core grammar, which corresponds directly to the :ref:`abstract syntax <syntax>`, the textual syntax also defines a number of *abbreviations* that can be used for convenience and readability.
 
-Abbreviations are defined by rewrite rules specifying their expansion into the core syntax:
+Abbreviations are defined by *rewrite rules* specifying their expansion into the core syntax:
 
 .. math::
    \X{abbreviation~syntax} \quad\equiv\quad \X{expanded~syntax}
@@ -110,20 +111,20 @@ To resolve these identifiers into concrete indices,
 some grammar production are indexed by an *identifier context* :math:`I` as a synthesized attribute that records the declared identifiers in each :ref:`index space <syntax-index>`.
 In addition, the context records the types defined in the module, so that :ref:`parameter <text-param>` indices can be computed for :ref:`functions <text-func>`.
 
-It is convenient to define identifier contexts as :ref:`records <syntax-record>` :math:`I` with abstract syntax:
+It is convenient to define identifier contexts as :ref:`records <notation-record>` :math:`I` with abstract syntax as follows:
 
 .. math::
    \begin{array}{llll}
    \production{(identifier context)} & I &::=&
      \begin{array}[t]{l@{~}ll}
-     \{ & \TYPES & (\Tid^?)^\ast, \\
-        & \FUNCS & (\Tid^?)^\ast, \\
-        & \TABLES & (\Tid^?)^\ast, \\
-        & \MEMS & (\Tid^?)^\ast, \\
-        & \GLOBALS & (\Tid^?)^\ast, \\
-        & \LOCALS & (\Tid^?)^\ast, \\
-        & \LABELS & (\Tid^?)^\ast, \\
-        & \TYPEDEFS & \functype^\ast ~\} \\
+     \{ & \ITYPES & (\Tid^?)^\ast, \\
+        & \IFUNCS & (\Tid^?)^\ast, \\
+        & \ITABLES & (\Tid^?)^\ast, \\
+        & \IMEMS & (\Tid^?)^\ast, \\
+        & \IGLOBALS & (\Tid^?)^\ast, \\
+        & \ILOCALS & (\Tid^?)^\ast, \\
+        & \ILABELS & (\Tid^?)^\ast, \\
+        & \ITYPEDEFS & \functype^\ast ~\} \\
      \end{array}
    \end{array}
 
@@ -138,3 +139,19 @@ Conventions
 
 To avoid unnecessary clutter, empty components are omitted when writing out identifier contexts.
 For example, the record :math:`\{\}` is shorthand for an :ref:`identifier context <text-context>` whose components are all empty.
+
+
+.. index:: vector
+   pair: text format; vector
+.. _text-vec:
+
+Vectors
+~~~~~~~
+
+:ref:`Vectors <syntax-vec>` are written as plain sequences, but with a restriction on the length of these sequence.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
+   \production{vector} & \Tvec(\T{A}) &::=&
+     (x{:}\T{A})^n &\Rightarrow& x^n & (\iff n < 2^{32}) \\
+   \end{array}
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 1ff511361..7d7432201 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -15,7 +15,7 @@ Instructions are syntactically distinguished into *plain* and *structured* instr
        &\Rightarrow& \X{in} \\
    \end{array}
 
-In addition, as a syntactic abbreviation, instructions can be written in :ref:`folded <text-foldedinstr>` form as S-expressions, to group them visually.
+In addition, as a syntactic abbreviation, instructions can be written as S-expressions in :ref:`folded <text-foldedinstr>` form, to group them visually.
 
 
 .. index:: index, label index
@@ -27,14 +27,14 @@ Labels
 
 :ref:`Structured control instructions <text-instr-control>` can be annotated with a symbolic :ref:`label identifier <text-id>`.
 They are the only :ref:`symbolic identifiers <text-index>` that can be bound locally in an instruction sequence.
-The following grammar handles the corresponding update to the :ref:`identifier context <text-context>` by producing a context with an additional label entry.
+The following grammar handles the corresponding update to the :ref:`identifier context <text-context>` by :ref:`composing <notation-compose>` the context with an additional label entry.
 
 .. math::
    \begin{array}{llcllll}
    \production{label} & \Tlabel_I &::=&
-     \epsilon &\Rightarrow& \{\LABELS~(\epsilon)\} \compose I \\ &&|&
-     v{:}\Tid &\Rightarrow& \{\LABELS~v\} \compose I
-       & (v \notin I.\LABELS) \\
+     v{:}\Tid &\Rightarrow& \{\ILABELS~v\} \compose I
+       & (\iff v \notin I.\ILABELS) \\ &&|&
+     \epsilon &\Rightarrow& \{\ILABELS~(\epsilon)\} \compose I \\
    \end{array}
 
 .. note::
@@ -55,23 +55,24 @@ Control Instructions
 .. _text-block:
 .. _text-loop:
 .. _text-if:
+.. _text-instr-block:
 
 :ref:`Structured control instructions <syntax-instr-control>` can bind an optional symbolic :ref:`label identifier <text-label>`.
-The same identifier may optionally be repeated after the corresponding :math:`\T{end}` and :math:`\T{else}` pseudo instructions.
+The same label identifier may optionally be repeated after the corresponding :math:`\T{end}` and :math:`\T{else}` pseudo instructions, to indicate the matching delimiters.
 
 .. math::
    \begin{array}{llclll}
    \production{block instruction} & \Tblockinstr_I &::=&
      \text{block}~~I'{:}\Tlabel_I~~\X{rt}{:}\Tresulttype~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
        \\ &&&\qquad \Rightarrow\quad \BLOCK~\X{rt}~\X{in}^\ast~\END
-       \qquad\quad (\Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|&
+       \qquad\quad~~ (\iff \Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|&
      \text{loop}~~I'{:}\Tlabel_I~~\X{rt}{:}\Tresulttype~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^?
        \\ &&&\qquad \Rightarrow\quad \LOOP~\X{rt}~\X{in}^\ast~\END
-       \qquad\qquad (\Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|&
+       \qquad\qquad (\iff \Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ &&|&
      \text{if}~~I'{:}\Tlabel_I~~\X{rt}{:}\Tresulttype~~(\X{in}_1{:}\Tinstr_{I'})^\ast~~
        \text{else}~~\Tid_1^?~~(\X{in}_2{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid_2^?
        \\ &&&\qquad \Rightarrow\quad \IF~\X{rt}~\X{in}_1^\ast~\ELSE~\X{in}_2^\ast~\END
-       \qquad (\Tid_1^? = \epsilon \vee \Tid_1^? = \Tlabel, \Tid_2^? = \epsilon \vee \Tid_2^? = \Tlabel) \\
+       \qquad (\iff \Tid_1^? = \epsilon \vee \Tid_1^? = \Tlabel, \Tid_2^? = \epsilon \vee \Tid_2^? = \Tlabel) \\
    \end{array}
 
 .. _text-nop:
@@ -415,11 +416,15 @@ Numeric Instructions
 Folded Instructions
 ~~~~~~~~~~~~~~~~~~~
 
-As a special abbreviation, instructions can be grouped into *folded* S-expression form.
+Instructions can be written as S-expressions by grouping them into *folded* form. In that notation, an instruction is wrapped in parentheses and optionally includes nested folded instructions to indicate its operands.
+
+In the case of :ref:`block instructions <text-instr-block>`, the folded form omits the :math:`\text{end}` delimiter.
+For |IF| instructions, both branches have to wrapped into nested S-expressions, headed by the keywords :math:`\text{then}` and :math:`\text{else}`.
+
 The set of all phrases defined by the following abbreviations recursively forms the auxiliary syntactic class |Tfoldedinstr|.
 Such a folded instruction can appear anywhere a regular instruction can.
 
-.. MathJax doesn't handle LaTex multicolumns, this the spacing hack in the following formula.
+.. MathJax doesn't handle LaTex multicolumns, thus the spacing hack in the following formula.
 
 .. math::
    \begin{array}{lllll}
@@ -428,7 +433,7 @@ Such a folded instruction can appear anywhere a regular instruction can.
        &\equiv\quad \Tfoldedinstr^\ast~~\Tplaininstr \\ &
      \text{(}~\text{block}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~\text{)}
        &\equiv\quad \text{block}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~~\text{end} \\ &
-     \text{(}~\text{loop}~~\Tresulttype~~\Tinstr^\ast~\text{)}
+     \text{(}~\text{loop}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~\text{)}
        &\equiv\quad \text{loop}~~\Tlabel~~\Tresulttype~~\Tinstr^\ast~~\text{end} \\ &
      \text{(}~\text{if}~~\Tlabel~~\Tresulttype~~\Tfoldedinstr^\ast
        &\hspace{-3ex} \text{(}~\text{then}~~\Tinstr_1^\ast~\text{)}~~\text{(}~\text{else}~~\Tinstr_2^\ast~\text{)}^?~~\text{)}
diff --git a/document/core/text/lexical.rst b/document/core/text/lexical.rst
index 800b21adc..2103ccd44 100644
--- a/document/core/text/lexical.rst
+++ b/document/core/text/lexical.rst
@@ -44,17 +44,26 @@ The character stream in the source text is divided, from left to right, into a s
      \Tkeyword ~|~ \TuN ~|~ \TsN ~|~ \TfN ~|~ \Tstring ~|~ \Tid ~|~
      \text{(} ~|~ \text{)} ~|~ \Treserved \\
    \production{keyword} & \Tkeyword &::=&
-     \mbox{(any terminal symbol in the grammar that is none of the above)} \\
+     (\text{a} ~|~ \dots ~|~ \text{z})~\Tidchar^\ast
+     \qquad (\mbox{if occurring as a literal terminal in the grammar}) \\
    \production{reserved} & \Treserved &::=&
      \Tidchar^+ \\
    \end{array}
 
-In this specification, the set of valid *keyword* tokens is defined implicitly, by their occurrence as a terminal symbols in literal form in the non-lexical grammar.
-Any sequence of alphanumeric or symbolic characters that is not in the other classes is considered a *reserved word*.
-
 Tokens are formed from the input character stream according to the *longest match* rule.
-That is, the next token always consists of the longest possible sequence of characters that is recognized by the above grammar.
-Where necessary, tokens may be separated by :ref:`white space <text-space>`.
+That is, the next token always consists of the longest possible sequence of characters that is recognized by the above lexical grammar.
+Tokens can be separated by :ref:`white space <text-space>`,
+but except for strings, they cannot themselves contain whitespace.
+
+The set of *keyword* tokens is defined implicitly, by all occurrences of a :ref:`terminal symbol <text-grammar>` in literal form :math:`\text{keyword}` in a :ref:`syntactic <text-syntactic>` production of this chapter.
+
+Any token that does not fall into any of the other categories is considered *reserved*, and cannot occur in source text.
+
+.. note::
+   The effect of defining the set of reserved tokens is that all tokens must be separated by either parentheses or :ref:`white space <text-space>`.
+   For example, :math:`\text{0\$x}` is a single reserved token.
+   Consequently, it is not recognized as two separate tokens :math:`\text{0}` and :math:`\text{\$x}`, but instead disallowed.
+   This property of tokenization is not affected by the fact that the definition of reserved tokens overlaps with other token classes.
 
 
 .. index:: ! white space, character, ASCII
@@ -97,13 +106,13 @@ Block comments can be nested.
    \production{line comment} & \Tlinecomment &::=&
      \Tcommentd~~\Tlinechar^\ast~~(\unicode{0A} ~|~ \T{eof}) \\
    \production{line character} & \Tlinechar &::=&
-     c{:}\Tchar & (c \neq \unicode{0A}) \\
+     c{:}\Tchar & (\iff c \neq \unicode{0A}) \\
    \production{block comment} & \Tblockcomment &::=&
      \Tcommentl~~\Tblockchar^\ast~~\Tcommentr \\
    \production{block character} & \Tblockchar &::=&
-     c{:}\Tchar & (c \neq \text{;} \wedge c \neq \text{(}) \\ &&|&
-     \text{;} & (\mbox{the next character is not}~\text{)}) \\ &&|&
-     \text{(} & (\mbox{the next character is not}~\text{;}) \\ &&|&
+     c{:}\Tchar & (\iff c \neq \text{;} \wedge c \neq \text{(}) \\ &&|&
+     \text{;} & (\iff~\mbox{the next character is not}~\text{)}) \\ &&|&
+     \text{(} & (\iff~\mbox{the next character is not}~\text{;}) \\ &&|&
      \Tblockcomment \\
    \end{array}
 
diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index bdb983774..d951fc92d 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -23,31 +23,31 @@ Indices
 ~~~~~~~
 
 :ref:`Indices <syntax-index>` can be given either in raw numeric form or as symbolic :ref:`identifiers <text-id>` when bound by a respective construct.
-Such identifiers are looked up in the suitable space of the :ref:`identifier context <text-context>`.
+Such identifiers are looked up in the suitable space of the :ref:`identifier context <text-context>` :math:`I`.
 
 .. math::
    \begin{array}{llcllllllll}
    \production{type index} & \Ttypeidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\TYPES[x] = v) \\
+     x{:}\Tu32 &\Rightarrow& x \\&&|&
+     v{:}\Tid &\Rightarrow& x & (\iff I.\ITYPES[x] = v) \\
    \production{function index} & \Tfuncidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\FUNCS[x] = v) \\
+     x{:}\Tu32 &\Rightarrow& x \\&&|&
+     v{:}\Tid &\Rightarrow& x & (\iff I.\IFUNCS[x] = v) \\
    \production{table index} & \Ttableidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\TABLES[x] = v) \\
+     x{:}\Tu32 &\Rightarrow& x \\&&|&
+     v{:}\Tid &\Rightarrow& x & (\iff I.\ITABLES[x] = v) \\
    \production{memory index} & \Tmemidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\MEMS[x] = v) \\
+     x{:}\Tu32 &\Rightarrow& x \\&&|&
+     v{:}\Tid &\Rightarrow& x & (\iff I.\IMEMS[x] = v) \\
    \production{global index} & \Tglobalidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\GLOBALS[x] = v) \\
+     x{:}\Tu32 &\Rightarrow& x \\&&|&
+     v{:}\Tid &\Rightarrow& x & (\iff I.\IGLOBALS[x] = v) \\
    \production{local index} & \Tlocalidx_I &::=&
-     x{:}\Tu32 &\Rightarrow& x &|&
-     v{:}\Tid &\Rightarrow& x & (I.\LOCALS[x] = v) \\
+     x{:}\Tu32 &\Rightarrow& x \\&&|&
+     v{:}\Tid &\Rightarrow& x & (\iff I.\ILOCALS[x] = v) \\
    \production{label index} & \Tlabelidx_I &::=&
-     l{:}\Tu32 &\Rightarrow& l &|&
-     v{:}\Tid &\Rightarrow& l & (I.\LABELS[l] = v) \\
+     l{:}\Tu32 &\Rightarrow& l \\&&|&
+     v{:}\Tid &\Rightarrow& l & (\iff I.\ILABELS[l] = v) \\
    \end{array}
 
 
@@ -84,22 +84,22 @@ If inline declarations are given, then their types must match the referenced :re
    \begin{array}{llcllll}
    \production{type use} & \Ttypeuse_I &::=&
      \text{(}~\text{type}~~x{:}\Ttypeidx_I~\text{)}
-       &\Rightarrow& x, I' &
-       (\begin{array}[t]{@{}l@{}}
-        I.\TYPEDEFS[x] = [t_1^n] \to [t_2^\ast] \wedge
-        I' = \{\LOCALS~(\epsilon)^n\}) \\
-        \end{array} \\ &&|&
+       \quad\Rightarrow\quad x, I' \\ &&& \qquad
+       (\iff \begin{array}[t]{@{}l@{}}
+        I.\ITYPEDEFS[x] = [t_1^n] \to [t_2^\ast] \wedge
+        I' = \{\ILOCALS~(\epsilon)^n\}) \\
+        \end{array} \\[1ex] &&|&
      \text{(}~\text{type}~~x{:}\Ttypeidx_I~\text{)}
      ~~(t_1{:}\Tparam)^\ast~~(t_2{:}\Tresult)^\ast
-       &\Rightarrow& x, I' &
-       (\begin{array}[t]{@{}l@{}}
-        I.\TYPEDEFS[x] = [t_1^\ast] \to [t_2^\ast] \wedge
-        I' = \{\LOCALS~\F{id}(\Tparam)\}^\ast \idcwellformed) \\
+       \quad\Rightarrow\quad x, I' \\ &&& \qquad
+       (\iff \begin{array}[t]{@{}l@{}}
+        I.\ITYPEDEFS[x] = [t_1^\ast] \to [t_2^\ast] \wedge
+        I' = \{\ILOCALS~\F{id}(\Tparam)\}^\ast \idcwellformed) \\
         \end{array} \\
    \end{array}
 
-The resulting attribute of a |Ttypeuse| is a pair consisting of both the used :ref:`type index <syntax-typeidx>` and the updated :ref:`identifier context <text-context>` including possible parameter identifiers.
-The following auxiliary notation extracts optional identifiers from parameters:
+The synthesized attribute of a |Ttypeuse| is a pair consisting of both the used :ref:`type index <syntax-typeidx>` and the updated :ref:`identifier context <text-context>` including possible parameter identifiers.
+The following auxiliary function extracts optional identifiers from parameters:
 
 .. math::
    \begin{array}{lcl@{\qquad\qquad}l}
@@ -134,10 +134,9 @@ If no such index exists, then a new :ref:`type definition <text-type>` of the fo
 .. math::
    \text{(}~\text{type}~~\text{(}~\text{func}~~\Tparam^\ast~~\Tresult~\text{)}~\text{)}
 
-is first inserted at the end of the module.
+is inserted at the end of the module.
 
-.. note::
-   Abbreviations are expanded in the order they appear, such that previously inserted type definitions are reused by consecutive expansions.
+Abbreviations are expanded in the order they appear, such that previously inserted type definitions are reused by consecutive expansions.
 
 
 .. index:: import, name, function type, table type, memory type, global type
@@ -153,17 +152,17 @@ The descriptors in imports can bind a symbolic function, table, memory, or globa
 .. math::
    \begin{array}{llclll}
    \production{import} & \Timport_I &::=&
-     \text{(}~\text{import}~~\X{mod}{:}\Tname~~\X{nm}{:}\Tname~~d{:}\Timportdesc_I~\text{)}
-       &\Rightarrow& \{ \MODULE~\X{mod}, \NAME~\X{nm}, \DESC~d \} \\
+     \text{(}~\text{import}~~\X{mod}{:}\Tname~~\X{nm}{:}\Tname~~d{:}\Timportdesc_I~\text{)} \\ &&& \qquad
+       \Rightarrow\quad \{ \IMODULE~\X{mod}, \INAME~\X{nm}, \IDESC~d \} \\[1ex]
    \production{import description} & \Timportdesc_I &::=&
      \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~\text{)}
-       &\Rightarrow& \FUNC~x \\ &&|&
+       &\Rightarrow& \IDFUNC~x \\ &&|&
      \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype~\text{)}
-       &\Rightarrow& \TABLE~\X{tt} \\ &&|&
+       &\Rightarrow& \IDTABLE~\X{tt} \\ &&|&
      \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype~\text{)}
-       &\Rightarrow& \MEM~~\X{mt} \\ &&|&
+       &\Rightarrow& \IDMEM~~\X{mt} \\ &&|&
      \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype~\text{)}
-       &\Rightarrow& \GLOBAL~\X{gt} \\
+       &\Rightarrow& \IDGLOBAL~\X{gt} \\
    \end{array}
 
 
@@ -189,15 +188,15 @@ Function definitions can bind a symbolic :ref:`function identifier <text-id>`, a
    \begin{array}{llclll}
    \production{function} & \Tfunc_I &::=&
      \text{(}~\text{func}~~\Tid^?~~x,I'{:}\Ttypeuse_I~~
-     (t{:}\Tlocal)^\ast~~(\X{in}{:}\Tinstr_{I''})^\ast~\text{)}
-       &\Rightarrow& \{ \TYPE~x, \LOCALS~t^\ast, \BODY~\X{in}^\ast~\END \} \\ &&&&& \qquad
-       (I'' = I' \compose \{\LOCALS~\F{id}(\Tlocal)^\ast\} \idcwellformed) \\
+     (t{:}\Tlocal)^\ast~~(\X{in}{:}\Tinstr_{I''})^\ast~\text{)} \\ &&& \qquad
+       \Rightarrow\quad \{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\X{in}^\ast~\END \} \\ &&& \qquad\qquad\qquad
+       (\iff I'' = I' \compose \{\ILOCALS~\F{id}(\Tlocal)^\ast\} \idcwellformed) \\[1ex]
    \production{local} & \Tlocal &::=&
      \text{(}~\text{local}~~\Tid^?~~t{:}\Tvaltype~\text{)}
-       &\Rightarrow& t \\
+       \quad\Rightarrow\quad t \\
    \end{array}
 
-The definition of the local :ref:`identifier context <text-context>` :math:`I''` uses the following auxiliary notation to extract optional identifiers from locals:
+The definition of the local :ref:`identifier context <text-context>` :math:`I''` uses the following auxiliary function to extract optional identifiers from locals:
 
 .. math::
    \begin{array}{lcl@{\qquad\qquad}l}
@@ -232,13 +231,13 @@ Moreover, functions can be defined as :ref:`imports <text-import>` or :ref:`expo
 .. math::
    \begin{array}{llclll}
    \production{module field} &
-     \text{(}~\text{func}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Ttypeuse~\text{)} &\equiv&
-       \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{func}~~\Tid^?~~\Ttypeuse~\text{)}~\text{)} \\ &
-     \text{(}~\text{func}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv&
+     \text{(}~\text{func}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Ttypeuse~\text{)} \quad\equiv \\ & \qquad
+       \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{func}~~\Tid^?~~\Ttypeuse~\text{)}~\text{)} \\[1ex] &
+     \text{(}~\text{func}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{export}~~\Tname~~\text{(}~\text{func}~~\Tid'~\text{)}~\text{)}~~
        \text{(}~\text{func}~~\Tid'~~\dots~\text{)}
-       \\&&& \qquad
-       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+       \\ & \qquad\qquad
+       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
    \end{array}
 
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export.
@@ -257,7 +256,7 @@ Table definitions can bind a symbolic :ref:`table identifier <text-id>`.
    \begin{array}{llclll}
    \production{table} & \Ttable_I &::=&
      \text{(}~\text{table}~~\Tid^?~~\X{tt}{:}\Ttabletype~\text{)}
-       &\Rightarrow& \{ \TYPE~\X{tt} \} \\
+       &\Rightarrow& \{ \TTYPE~\X{tt} \} \\
    \end{array}
 
 
@@ -279,11 +278,11 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
 .. math::
    \begin{array}{llclll}
    \production{module field} &
-     \text{(}~\text{table}~~\Tid^?~~\Telemtype~~\text{(}~\text{elem}~~x^n{:}\Tvec(\Tfuncidx)~\text{)}~~\text{)} &\equiv&
+     \text{(}~\text{table}~~\Tid^?~~\Telemtype~~\text{(}~\text{elem}~~x^n{:}\Tvec(\Tfuncidx)~\text{)}~~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{table}~~\Tid'~~n~~n~~\Telemtype~\text{)}~~
        \text{(}~\text{elem}~~\Tid'~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tvec(\Tfuncidx)~\text{)}
-       \\&&& \qquad
-       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+       \\ & \qquad\qquad
+       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
    \end{array}
 
 Moreover, tables can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
@@ -291,13 +290,13 @@ Moreover, tables can be defined as :ref:`imports <text-import>` or :ref:`exports
 .. math::
    \begin{array}{llclll}
    \production{module field} &
-     \text{(}~\text{table}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Ttabletype~\text{)} &\equiv&
-       \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{table}~~\Tid^?~~\Ttabletype~\text{)}~\text{)} \\ &
-     \text{(}~\text{table}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv&
+     \text{(}~\text{table}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Ttabletype~\text{)} \quad\equiv \\ & \qquad
+       \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{table}~~\Tid^?~~\Ttabletype~\text{)}~\text{)} \\[1ex] &
+     \text{(}~\text{table}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{export}~~\Tname~~\text{(}~\text{table}~~\Tid'~\text{)}~\text{)}~~
        \text{(}~\text{table}~~\Tid'~~\dots~\text{)}
-       \\&&& \qquad
-       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+       \\ & \qquad\qquad
+       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
    \end{array}
 
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline elements segment.
@@ -316,7 +315,7 @@ Memory definitions can bind a symbolic :ref:`memory identifier <text-id>`.
    \begin{array}{llclll}
    \production{memory} & \Tmem_I &::=&
      \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype~\text{)}
-       &\Rightarrow& \{ \TYPE~\X{mt} \} \\
+       &\Rightarrow& \{ \MTYPE~\X{mt} \} \\
    \end{array}
 
 
@@ -338,11 +337,11 @@ A :ref:`data segment <text-data>` can be given inline with a memory definition,
 .. math::
    \begin{array}{llclll}
    \production{module field} &
-     \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{data}~~b^n{:}\Tdatastring~\text{)}~~\text{)} &\equiv&
+     \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{data}~~b^n{:}\Tdatastring~\text{)}~~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{memory}~~\Tid'~~m~~m~\text{)}~~
        \text{(}~\text{data}~~\Tid'~~\text{(}~\text{i32.const}~~\text{0}~\text{)}~~\Tdatastring~\text{)}
-       \\&&& \qquad
-       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh, m = \F{ceil}(n / 64\F{Ki})) \\
+       \\ & \qquad\qquad
+       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh, m = \F{ceil}(n / 64\F{Ki})) \\
    \end{array}
 
 Moreover, memories can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
@@ -350,14 +349,14 @@ Moreover, memories can be defined as :ref:`imports <text-import>` or :ref:`expor
 .. math::
    \begin{array}{llclll}
    \production{module field} &
-     \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Tmemtype~\text{)} &\equiv&
+     \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Tmemtype~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{memory}~~\Tid^?~~\Tmemtype~\text{)}~\text{)}
-       \\ &
-     \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv&
+       \\[1ex] &
+     \text{(}~\text{memory}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{export}~~\Tname~~\text{(}~\text{memory}~~\Tid'~\text{)}~\text{)}~~
        \text{(}~\text{memory}~~\Tid'~~\dots~\text{)}
-       \\ &&& \qquad
-       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+       \\ & \qquad\qquad
+       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
    \end{array}
 
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export or an inline data segment.
@@ -376,7 +375,7 @@ Global definitions can bind a symbolic :ref:`global identifier <text-id>`.
    \begin{array}{llclll}
    \production{global} & \Tglobal_I &::=&
      \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype~~e{:}\Texpr_I~\text{)}
-       &\Rightarrow& \{ \TYPE~\X{gt}, \INIT~e \} \\
+       &\Rightarrow& \{ \GTYPE~\X{gt}, \GINIT~e \} \\
    \end{array}
 
 
@@ -394,14 +393,14 @@ Globals can be defined as :ref:`imports <text-import>` or :ref:`exports <text-ex
 .. math::
    \begin{array}{llclll}
    \production{module field} &
-     \text{(}~\text{global}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Tglobaltype~\text{)} &\equiv&
+     \text{(}~\text{global}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Tglobaltype~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{global}~~\Tid^?~~\Tglobaltype~\text{)}~\text{)}
-       \\ &
-     \text{(}~\text{global}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} &\equiv&
+       \\[1ex] &
+     \text{(}~\text{global}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} \quad\equiv \\ & \qquad
        \text{(}~\text{export}~~\Tname~~\text{(}~\text{global}~~\Tid'~\text{)}~\text{)}~~
        \text{(}~\text{global}~~\Tid'~~\dots~\text{)}
-       \\ &&& \qquad
-       (\Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
+       \\ & \qquad\qquad
+       (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
    \end{array}
 
 The latter abbreviation can be applied repeatedly, with ":math:`\dots`" containing another import or export.
@@ -421,16 +420,16 @@ The syntax for exports mirrors their :ref:`abstract syntax <syntax-export>` dire
    \begin{array}{llclll}
    \production{export} & \Texport_I &::=&
      \text{(}~\text{export}~~\X{nm}{:}\Tname~~d{:}\Texportdesc_I~\text{)}
-       &\Rightarrow& \{ \NAME~\X{nm}, \DESC~d \} \\
+       &\Rightarrow& \{ \ENAME~\X{nm}, \EDESC~d \} \\
    \production{export description} & \Texportdesc_I &::=&
      \text{(}~\text{func}~~x{:}\Bfuncidx_I~\text{)}
-       &\Rightarrow& \FUNC~x \\ &&|&
+       &\Rightarrow& \EDFUNC~x \\ &&|&
      \text{(}~\text{table}~~x{:}\Btableidx_I~\text{)}
-       &\Rightarrow& \TABLE~x \\ &&|&
+       &\Rightarrow& \EDTABLE~x \\ &&|&
      \text{(}~\text{memory}~~x{:}\Bmemidx_I~\text{)}
-       &\Rightarrow& \MEM~x \\ &&|&
+       &\Rightarrow& \EDMEM~x \\ &&|&
      \text{(}~\text{global}~~x{:}\Bglobalidx_I~\text{)}
-       &\Rightarrow& \GLOBAL~x \\
+       &\Rightarrow& \EDGLOBAL~x \\
    \end{array}
 
 
@@ -453,7 +452,7 @@ A :ref:`start function <syntax-start>` is defined in terms of its index.
    \begin{array}{llclll}
    \production{start function} & \Tstart_I &::=&
      \text{(}~\text{start}~~x{:}\Tfuncidx_I~\text{)}
-       &\Rightarrow& \{ \FUNC~x \} \\
+       &\Rightarrow& \{ \SFUNC~x \} \\
    \end{array}
 
 .. note::
@@ -477,9 +476,9 @@ When omitted, :math:`\T{0}` is assumed.
 .. math::
    \begin{array}{llclll}
    \production{element segment} & \Telem_I &::=&
-     \text{(}~\text{elem}~~(x{:}\Ttableidx_I)^?~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~y^\ast{:}\Tvec(\Tfuncidx_I)~\text{)}
-       &\Rightarrow& \{ \TABLE~x', \OFFSET~e, \INIT~y^\ast \} \\
-       &&&&& \qquad (x' = x^? \neq \epsilon \vee x' = 0) \\
+     \text{(}~\text{elem}~~(x{:}\Ttableidx_I)^?~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~y^\ast{:}\Tvec(\Tfuncidx_I)~\text{)} \\ &&& \qquad
+       \Rightarrow\quad \{ \ETABLE~x', \EOFFSET~e, \EINIT~y^\ast \} \\
+       &&& \qquad\qquad\qquad (\iff x' = x^? \neq \epsilon \vee x' = 0) \\
    \end{array}
 
 .. note::
@@ -510,11 +509,11 @@ The data is written as a :ref:`string <text-string>`, which may be split up into
 .. math::
    \begin{array}{llclll}
    \production{data segment} & \Tdata_I &::=&
-     \text{(}~\text{data}~~(x{:}\Tmemidx_I)^?~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~b^\ast{:}\Tdatastring~\text{)}
-       &\Rightarrow& \{ \MEM~x', \OFFSET~e, \INIT~b^\ast \} \\
-       &&&&& \qquad (x' = x^? \neq \epsilon \vee x' = 0) \\
+     \text{(}~\text{data}~~(x{:}\Tmemidx_I)^?~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~b^\ast{:}\Tdatastring~\text{)} \\ &&& \qquad
+       \Rightarrow\quad \{ \DMEM~x', \DOFFSET~e, \DINIT~b^\ast \} \\
+       &&& \qquad\qquad\qquad (\iff x' = x^? \neq \epsilon \vee x' = 0) \\[1ex]
    \production{data string} & \Tdatastring &::=&
-     (b^\ast{:}\Tstring)^\ast &\Rightarrow& \concat((b^\ast)^\ast) \\
+     (b^\ast{:}\Tstring)^\ast \quad\Rightarrow\quad \concat((b^\ast)^\ast) \\
    \end{array}
 
 .. note::
@@ -552,30 +551,30 @@ The name serves a documentary role only.
    \begin{array}[t]{@{}cllll}
    ::=&
      \text{(}~\text{module}~~\Tid^?~~(m{:}\Tmodulefield_I)^\ast~\text{)}
-       &\Rightarrow& \bigcompose m^\ast
-       & (I = \bigcompose \F{idc}(\Tmodulefield)^\ast \idcwellformed) \\
-   \end{array} \\
+       \quad\Rightarrow\quad \bigcompose m^\ast \\
+       &\qquad (\iff I = \bigcompose \F{idc}(\Tmodulefield)^\ast \idcwellformed) \\
+   \end{array} \\[1ex]
    \production{module field} & \Tmodulefield_I &
    \begin{array}[t]{@{}clll}
    ::=&
-     \X{ty}{:}\Ttype &\Rightarrow& \{\TYPES~\X{ty}\} \\ |&
-     \X{im}{:}\Timport_I &\Rightarrow& \{\IMPORTS~\X{im}\} \\ |&
-     \X{fn}{:}\Tfunc_I &\Rightarrow& \{\FUNCS~\X{fn}\} \\ |&
-     \X{ta}{:}\Ttable_I &\Rightarrow& \{\TABLES~\X{ta}\} \\ |&
-     \X{me}{:}\Tmem_I &\Rightarrow& \{\MEMS~\X{me}\} \\ |&
-     \X{gl}{:}\Tglobal_I &\Rightarrow& \{\GLOBALS~\X{gl}\} \\ |&
-     \X{ex}{:}\Texport_I &\Rightarrow& \{\EXPORTS~\X{ex}\} \\ |&
-     \X{st}{:}\Tstart_I &\Rightarrow& \{\START~\X{st}\} \\ |&
-     \X{el}{:}\Telem_I &\Rightarrow& \{\ELEM~\X{el}\} \\ |&
-     \X{da}{:}\Tdata_I &\Rightarrow& \{\DATA~\X{da}\} \\
+     \X{ty}{:}\Ttype &\Rightarrow& \{\MTYPES~\X{ty}\} \\ |&
+     \X{im}{:}\Timport_I &\Rightarrow& \{\MIMPORTS~\X{im}\} \\ |&
+     \X{fn}{:}\Tfunc_I &\Rightarrow& \{\MFUNCS~\X{fn}\} \\ |&
+     \X{ta}{:}\Ttable_I &\Rightarrow& \{\MTABLES~\X{ta}\} \\ |&
+     \X{me}{:}\Tmem_I &\Rightarrow& \{\MMEMS~\X{me}\} \\ |&
+     \X{gl}{:}\Tglobal_I &\Rightarrow& \{\MGLOBALS~\X{gl}\} \\ |&
+     \X{ex}{:}\Texport_I &\Rightarrow& \{\MEXPORTS~\X{ex}\} \\ |&
+     \X{st}{:}\Tstart_I &\Rightarrow& \{\MSTART~\X{st}\} \\ |&
+     \X{el}{:}\Telem_I &\Rightarrow& \{\MELEM~\X{el}\} \\ |&
+     \X{da}{:}\Tdata_I &\Rightarrow& \{\MDATA~\X{da}\} \\
    \end{array}
    \end{array}
 
 The following restrictions are imposed on the composition of :ref:`modules <syntax-module>`: :math:`m_1 \compose m_2` is defined if and only if
 
-* :math:`m_1.\START = \epsilon \vee m_2.\START = \epsilon`
+* :math:`m_1.\MSTART = \epsilon \vee m_2.\MSTART = \epsilon`
 
-* :math:`m_2.\IMPORTS = \epsilon \vee m_1.\FUNCS = m_1.\TABLES = m_1.\MEMS = m_1.\GLOBALS = \epsilon`
+* :math:`m_1.\MFUNCS = m_1.\MTABLES = m_1.\MMEMS = m_1.\MGLOBALS = \epsilon \vee m_2.\MIMPORTS = \epsilon`
 
 .. note::
    The first condition ensures that there is at most one start function.
@@ -589,23 +588,23 @@ The definition of the initial :ref:`identifier context <text-context>` :math:`I`
 .. math::
    \begin{array}{@{}lcl@{\qquad\qquad}l}
    \F{idc}(\text{(}~\text{type}~\Tid^?~\X{ft}{:}\Tfunctype~\text{)}) &=&
-     \{\TYPES~(\Tid^?), \TYPEDEFS~\X{ft}\} \\
+     \{\ITYPES~(\Tid^?), \ITYPEDEFS~\X{ft}\} \\
    \F{idc}(\text{(}~\text{func}~\Tid^?~\dots~\text{)}) &=&
-     \{\FUNCS~(\Tid^?)\} \\
+     \{\IFUNCS~(\Tid^?)\} \\
    \F{idc}(\text{(}~\text{table}~\Tid^?~\dots~\text{)}) &=&
-     \{\TABLES~(\Tid^?)\} \\
+     \{\ITABLES~(\Tid^?)\} \\
    \F{idc}(\text{(}~\text{memory}~\Tid^?~\dots~\text{)}) &=&
-     \{\MEMS~(\Tid^?)\} \\
+     \{\IMEMS~(\Tid^?)\} \\
    \F{idc}(\text{(}~\text{global}~\Tid^?~\dots~\text{)}) &=&
-     \{\GLOBALS~(\Tid^?)\} \\
+     \{\IGLOBALS~(\Tid^?)\} \\
    \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{func}~\Tid^?~\dots~\text{)}~\text{)}) &=&
-     \{\FUNCS~(\Tid^?)\} \\
+     \{\IFUNCS~(\Tid^?)\} \\
    \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{table}~\Tid^?~\dots~\text{)}~\text{)}) &=&
-     \{\TABLES~(\Tid^?)\} \\
+     \{\ITABLES~(\Tid^?)\} \\
    \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{memory}~\Tid^?~\dots~\text{)}~\text{)}) &=&
-     \{\MEMS~(\Tid^?)\} \\
+     \{\IMEMS~(\Tid^?)\} \\
    \F{idc}(\text{(}~\text{import}~\dots~\text{(}~\text{global}~\Tid^?~\dots~\text{)}~\text{)}) &=&
-     \{\GLOBALS~(\Tid^?)\} \\
+     \{\IGLOBALS~(\Tid^?)\} \\
    \F{idc}(\text{(}~\dots~\text{)}) &=&
      \{\} \\
    \end{array}
@@ -617,7 +616,7 @@ The definition of the initial :ref:`identifier context <text-context>` :math:`I`
    \F{idc}(\Tmodulebody~\Tmodulefield) &=&
      \F{idc}(\Tmodulebody) \compose \F{idc}(\Tmodulefield) \\[1ex]
 
-   The definition of the :ref:`identifier context <text-context>` :math:`I` uses the following auxiliary notation to filters out optional identifiers from definitions and imports in an order-preserving fashion:
+   The definition of the :ref:`identifier context <text-context>` :math:`I` uses the following auxiliary function to extract optional identifiers from definitions and imports in an order-preserving fashion:
 
    \begin{array}{@{}l@{}}
    \begin{array}{@{}lcl@{\qquad\qquad}l}
diff --git a/document/core/text/types.rst b/document/core/text/types.rst
index 2eed74e78..de5ed5f30 100644
--- a/document/core/text/types.rst
+++ b/document/core/text/types.rst
@@ -87,8 +87,8 @@ Limits
 .. math::
     \begin{array}{llclll}
     \production{limits} & \Tlimits &::=&
-      n{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~\epsilon \} \\ &&|&
-      n{:}\Tu32~~m{:}\Tu32 &\Rightarrow& \{ \MIN~n, \MAX~m \} \\
+      n{:}\Tu32 &\Rightarrow& \{ \LMIN~n, \LMAX~\epsilon \} \\ &&|&
+      n{:}\Tu32~~m{:}\Tu32 &\Rightarrow& \{ \LMIN~n, \LMAX~m \} \\
     \end{array}
 
 
diff --git a/document/core/text/values.rst b/document/core/text/values.rst
index aa041d0a1..28e0c371a 100644
--- a/document/core/text/values.rst
+++ b/document/core/text/values.rst
@@ -39,11 +39,8 @@ All :ref:`integers <syntax-int>` can be written in either decimal or hexadecimal
    \production{hexadecimal digit} & \Thexdigit &::=&
      d{:}\Tdigit \Rightarrow d \\ &&|&
      \text{A} \Rightarrow 10 ~~|~~ \dots ~~|~~ \text{F} \Rightarrow 15 \\ &&|&
-     \text{a} \Rightarrow 10 ~~|~~ \dots ~~|~~ \text{f} \Rightarrow 15 \\
-   \end{array}
-
-.. math::
-   \begin{array}{llclll@{\qquad}l}
+     \text{a} \Rightarrow 10 ~~|~~ \dots ~~|~~ \text{f} \Rightarrow 15
+   \\[1ex]
    \production{decimal number} & \Tnum &::=&
      d{:}\Tdigit &\Rightarrow& d \\ &&|&
      n{:}\Tnum~~d{:}\Tdigit &\Rightarrow& 10\cdot n + d \\
@@ -58,11 +55,11 @@ Moreover, their value must lie within the range of the respective type.
 .. math::
    \begin{array}{llclll@{\qquad}l}
    \production{unsigned integer} & \TuN &::=&
-     n{:}\Tnum &\Rightarrow& n & (n < 2^N) \\ &&|&
-     \text{0x}~~n{:}\Thexnum &\Rightarrow& n & (n < 2^N) \\
+     n{:}\Tnum &\Rightarrow& n & (\iff n < 2^N) \\ &&|&
+     \text{0x}~~n{:}\Thexnum &\Rightarrow& n & (\iff n < 2^N) \\
    \production{signed integer} & \TsN &::=&
-     {\pm}{:}\Tsign~~n{:}\Tnum &\Rightarrow& \pm n & (-2^{N-1} \leq \pm n < 2^{N-1}) \\ &&|&
-     {\pm}{:}\Tsign~~\text{0x}~~n{:}\Thexnum &\Rightarrow& \pm n & (-2^{N-1} \leq \pm n < 2^{N-1}) \\
+     {\pm}{:}\Tsign~~n{:}\Tnum &\Rightarrow& \pm n & (\iff -2^{N-1} \leq \pm n < 2^{N-1}) \\ &&|&
+     {\pm}{:}\Tsign~~\text{0x}~~n{:}\Thexnum &\Rightarrow& \pm n & (\iff -2^{N-1} \leq \pm n < 2^{N-1}) \\
    \end{array}
 
 :ref:`Uninterpreted integers <syntax-int>` can be written as either signed or unsigned, and are normalized to unsigned in the abstract syntax.
@@ -71,7 +68,7 @@ Moreover, their value must lie within the range of the respective type.
    \begin{array}{llclll@{\qquad\qquad}l}
    \production{uninterpreted integers} & \TiN &::=&
      n{:}\TuN &\Rightarrow& n \\ &&|&
-     i{:}\TsN &\Rightarrow& n & (i = \signed(n)) \\
+     i{:}\TsN &\Rightarrow& n & (\iff i = \signed(n)) \\
    \end{array}
 
 
@@ -85,16 +82,7 @@ Moreover, their value must lie within the range of the respective type.
 Floating-Point
 ~~~~~~~~~~~~~~
 
-:ref:`Floating point <syntax-float>` values can be represented in either decimal or hexadecimal notation.
-The value of a literal must not lie outside the representable range of the corresponding `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ type
-(that is, a numeric value must not overflow to :math:`\pm\mbox{infinity}`),
-but it may be :ref:`rounded <aux-ieee>` to the nearest representable value.
-
-.. note::
-   Rounding can be prevented by using hexadecimal notation with no more significant bits than supported by the required type.
-
-Floating-point values may also be written as constants for *infinity* or *canonical NaN* (*not a number*).
-Furthermore, arbitrary NaN values may be expressed by providing an explicit payload value.
+:ref:`Floating-point <syntax-float>` values can be represented in either decimal or hexadecimal notation.
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
@@ -117,31 +105,29 @@ Furthermore, arbitrary NaN values may be expressed by providing an explicit payl
      \text{0x}~p{:}\Thexnum~(\text{P}~|~\text{p})~{\pm}{:}\Tsign~e{:}\Tnum
        &\Rightarrow& p\cdot 2^{\pm e} \\ &&|&
      \text{0x}~p{:}\Thexnum~\text{.}~q{:}\Thexfrac~(\text{P}~|~\text{p})~{\pm}{:}\Tsign~e{:}\Tnum
-       &\Rightarrow& (p+q)\cdot 2^{\pm e} \\
-   \production{floating-point value} & \TfNmag &::=&
-     z{:}\Tfloat &\Rightarrow& \ieee_N(z) & (\ieee_N(z) \neq \pm \infty) \\ &&|&
-     z{:}\Thexfloat &\Rightarrow& \ieee_N(z) & (\ieee_N(z) \neq \pm \infty) \\ &&|&
-     \text{inf} &\Rightarrow& \infty \\ &&|&
-     \text{nan} &\Rightarrow& \NAN(2^{\significand(N)-1}) \\ &&|&
-     \text{nan{:}0x}~n{:}\Thexnum &\Rightarrow& \NAN(n) & (1 \leq n < 2^{\significand(N)}) \\
-   \production{floating-point value} & \TfN &::=&
-     {\pm}{:}\Tsign~z{:}\TfNmag &\Rightarrow& \pm z \\
+       &\Rightarrow& (p+q)\cdot 2^{\pm e}
    \end{array}
 
+The value of a literal must not lie outside the representable range of the corresponding `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ type
+(that is, a numeric value must not overflow to :math:`\pm\mbox{infinity}`),
+but it may be :ref:`rounded <aux-ieee>` to the nearest representable value.
 
-.. index:: vector
-   pair: text format; vector
-.. _text-vec:
-
-Vectors
-~~~~~~~
+.. note::
+   Rounding can be prevented by using hexadecimal notation with no more significant bits than supported by the required type.
 
-:ref:`Vectors <syntax-vec>` are written as plain sequences, but with restricted length.
+Floating-point values may also be written as constants for *infinity* or *canonical NaN* (*not a number*).
+Furthermore, arbitrary NaN values may be expressed by providing an explicit payload value.
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
-   \production{vector} & \Tvec(\T{A}) &::=&
-     (x{:}\T{A})^n &\Rightarrow& x^n & (n < 2^{32}) \\
+   \production{floating-point value} & \TfN &::=&
+     {\pm}{:}\Tsign~z{:}\TfNmag &\Rightarrow& \pm z \\
+   \production{floating-point magnitude} & \TfNmag &::=&
+     z{:}\Tfloat &\Rightarrow& \ieee_N(z) & (\iff \ieee_N(z) \neq \pm \infty) \\ &&|&
+     z{:}\Thexfloat &\Rightarrow& \ieee_N(z) & (\iff \ieee_N(z) \neq \pm \infty) \\ &&|&
+     \text{inf} &\Rightarrow& \infty \\ &&|&
+     \text{nan} &\Rightarrow& \NAN(2^{\significand(N)-1}) \\ &&|&
+     \text{nan{:}0x}~n{:}\Thexnum &\Rightarrow& \NAN(n) & (\iff 1 \leq n < 2^{\significand(N)}) \\
    \end{array}
 
 
@@ -159,22 +145,26 @@ They are enclosed in quotation marks
 and may contain any character other than `ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ control characters, quotation marks (:math:`\text{"}`), or backslash (:math:`\text{\backslash}`),
 except when expressed with an *escape sequence*.
 
-Each character in a string literal represents the byte sequence corresponding to its `Unicode <http://www.unicode.org/versions/latest/>`_ UTF-8 encoding,
-except for hexadecimal escape sequences :math:`\text{\backslash}hh`, which represent raw bytes of the respective value.
-
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
    \production{string} & \Tstring &::=&
      \text{"}~(b^\ast{:}\Tstringelem)^\ast~\text{"}
        &\Rightarrow& \concat((b^\ast)^\ast)
-       & (|\concat((b^\ast)^\ast)| < 2^{32}) \\
+       & (\iff |\concat((b^\ast)^\ast)| < 2^{32}) \\
    \production{string element} & \Tstringelem &::=&
      c{:}\Tstringchar &\Rightarrow& \utf8(c) \\ &&|&
      \text{\backslash}~n{:}\Thexdigit~m{:}\Thexdigit
        &\Rightarrow& 16\cdot n+m \\
+   \end{array}
+
+Each character in a string literal represents the byte sequence corresponding to its `Unicode <http://www.unicode.org/versions/latest/>`_ UTF-8 encoding,
+except for hexadecimal escape sequences :math:`\textl\backslash hh\textr`, which represent raw bytes of the respective value.
+
+.. math::
+   \begin{array}{llclll@{\qquad\qquad}l}
    \production{string character} & \Tstringchar &::=&
      c{:}\Tchar &\Rightarrow& c \qquad
-       & (c \geq \unicode{20} \wedge c \neq \unicode{7F} \wedge c \neq \text{"} c \neq \text{\backslash}) \\ &&|&
+       & (\iff c \geq \unicode{20} \wedge c \neq \unicode{7F} \wedge c \neq \text{"} c \neq \text{\backslash}) \\ &&|&
      \text{\backslash t} &\Rightarrow& \unicode{09} \\ &&|&
      \text{\backslash n} &\Rightarrow& \unicode{0A} \\ &&|&
      \text{\backslash r} &\Rightarrow& \unicode{0D} \\ &&|&
@@ -182,7 +172,7 @@ except for hexadecimal escape sequences :math:`\text{\backslash}hh`, which repre
      \text{\backslash{'}} &\Rightarrow& \unicode{27} \\ &&|&
      \text{\backslash\backslash} &\Rightarrow& \unicode{5C} \\ &&|&
      \text{\backslash u\{}~n{:}\Thexnum~\text{\}}
-       &\Rightarrow& \unicode{(n)} & (n < \hex{D800} \vee \hex{E000} \leq n < \hex{110000}) \\
+       &\Rightarrow& \unicode{(n)} & (\iff n < \hex{D800} \vee \hex{E000} \leq n < \hex{110000}) \\
    \end{array}
 
 
@@ -199,7 +189,7 @@ A name string must form a valid `UTF-8 <http://www.unicode.org/versions/latest/>
 .. math::
    \begin{array}{llclll@{\qquad}l}
    \production{name} & \Tname &::=&
-     b^\ast{:}\Tstring &\Rightarrow& c^\ast & (b^\ast = \utf8(c^\ast)) \\
+     b^\ast{:}\Tstring &\Rightarrow& c^\ast & (\iff b^\ast = \utf8(c^\ast)) \\
    \end{array}
 
 .. note::
@@ -209,6 +199,7 @@ A name string must form a valid `UTF-8 <http://www.unicode.org/versions/latest/>
 
 .. index:: ! identifiers
    pair: text format; identifiers
+.. _text-idchar:
 .. _text-id:
 
 Identifiers
diff --git a/document/core/util/math.def b/document/core/util/math.def
index 3ad7ab67e..a9c593b09 100644
--- a/document/core/util/math.def
+++ b/document/core/util/math.def
@@ -27,7 +27,8 @@
 
 .. |mod| mathdef:: \mathbin{\F{mod}}
 
-.. |iff| mathdef:: \mathop{\mbox{if}}
+.. |iff| mathdef:: \mathrel{\mbox{if}}
+.. |otherwise| mathdef:: \mathrel{\mbox{otherwise}}
 .. |where| mathdef:: \mathrel{\mbox{where}}
 
 
@@ -42,17 +43,22 @@
 
 .. Notation for Sequences & Records
 
-.. |concat| mathdef:: \xref{syntax/conventions}{syntax-concat}{\F{concat}}
-
-.. |with| mathdef:: \xref{syntax/conventions}{syntax-record}{\mathrel{\mbox{with}}}
-.. |compose| mathdef:: \xref{syntax/conventions}{syntax-record}{\oplus}
-.. |bigcompose| mathdef:: \xref{syntax/conventions}{syntax-record}{\bigoplus}
+.. |slice| mathdef:: \xref{syntax/conventions}{notation-slice}{\mathrel{\mathbf{:}}}
+.. |with| mathdef:: \xref{syntax/conventions}{notation-replace}{\mathrel{\mbox{with}}}
+.. |concat| mathdef:: \xref{syntax/conventions}{notation-concat}{\F{concat}}
+.. |compose| mathdef:: \xref{syntax/conventions}{notation-compose}{\oplus}
+.. |bigcompose| mathdef:: \xref{syntax/conventions}{notation-compose}{\bigoplus}
 
 
 
 .. Abstract Syntax
 .. ---------------
 
+.. Auxiliary productions
+
+.. |vec| mathdef:: \xref{syntax/conventions}{syntax-vec}{\X{vec}}
+
+
 .. Values, terminals
 
 .. |hex#1| mathdef:: \mathtt{0x#1}
@@ -85,6 +91,8 @@
 .. |s64| mathdef:: \xref{syntax/values}{syntax-int}{\sX{\X{64}}}
 
 .. |iN| mathdef:: \xref{syntax/values}{syntax-int}{\iX{N}}
+.. |i8| mathdef:: \xref{syntax/values}{syntax-int}{\iX{\X{8}}}
+.. |i16| mathdef:: \xref{syntax/values}{syntax-int}{\iX{\X{16}}}
 .. |i32| mathdef:: \xref{syntax/values}{syntax-int}{\iX{\X{32}}}
 .. |i64| mathdef:: \xref{syntax/values}{syntax-int}{\iX{\X{64}}}
 
@@ -93,7 +101,6 @@
 .. |f32| mathdef:: \xref{syntax/values}{syntax-float}{\fX{\X{32}}}
 .. |f64| mathdef:: \xref{syntax/values}{syntax-float}{\fX{\X{64}}}
 
-.. |vec| mathdef:: \xref{syntax/values}{syntax-vec}{\X{vec}}
 .. |name| mathdef:: \xref{syntax/values}{syntax-name}{\X{name}}
 .. |codepoint| mathdef:: \xref{syntax/values}{syntax-name}{\X{codepoint}}
 
@@ -104,8 +111,6 @@
 .. |significand| mathdef:: \xref{syntax/values}{aux-significand}{\F{signif}}
 .. |exponent| mathdef:: \xref{syntax/values}{aux-exponent}{\F{expon}}
 
-.. |utf8| mathdef:: \xref{syntax/values}{syntax-utf8}{\F{utf8}}
-
 
 .. Types, terminals
 
@@ -117,11 +122,17 @@
 .. |F64| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f64}}
 
 .. |ANYFUNC| mathdef:: \xref{syntax/types}{syntax-elemtype}{\K{anyfunc}}
+
 .. |MVAR| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}}
 .. |MCONST| mathdef:: \xref{syntax/types}{syntax-mut}{\K{const}}
 
-.. |MIN| mathdef:: \K{min}
-.. |MAX| mathdef:: \K{max}
+.. |LMIN| mathdef:: \xref{syntax/types}{syntax-limits}{\K{min}}
+.. |LMAX| mathdef:: \xref{syntax/types}{syntax-limits}{\K{max}}
+
+.. |ETFUNC| mathdef:: \xref{syntax/types}{syntax-externtype}{\K{func}}
+.. |ETTABLE| mathdef:: \xref{syntax/types}{syntax-externtype}{\K{table}}
+.. |ETMEM| mathdef:: \xref{syntax/types}{syntax-externtype}{\K{mem}}
+.. |ETGLOBAL| mathdef:: \xref{syntax/types}{syntax-externtype}{\K{global}}
 
 
 .. Types, non-terminals
@@ -133,6 +144,7 @@
 .. |tabletype| mathdef:: \xref{syntax/types}{syntax-tabletype}{\X{tabletype}}
 .. |elemtype| mathdef:: \xref{syntax/types}{syntax-elemtype}{\X{elemtype}}
 .. |memtype| mathdef:: \xref{syntax/types}{syntax-memtype}{\X{memtype}}
+
 .. |limits| mathdef:: \xref{syntax/types}{syntax-limits}{\X{limits}}
 .. |mut| mathdef:: \xref{syntax/types}{syntax-mut}{\X{mut}}
 
@@ -141,10 +153,10 @@
 
 .. Types, meta functions
 
-.. |funcs| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{funcs}}
-.. |tables| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{tables}}
-.. |mems| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{mems}}
-.. |globals| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{globals}}
+.. |etfuncs| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{funcs}}
+.. |ettables| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{tables}}
+.. |etmems| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{mems}}
+.. |etglobals| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{globals}}
 
 
 .. Indices, non-terminals
@@ -160,19 +172,52 @@
 
 .. Modules, terminals
 
-.. |MODULE| mathdef:: \K{module}
-.. |TYPE| mathdef:: \K{type}
-.. |FUNC| mathdef:: \K{func}
-.. |TABLE| mathdef:: \K{table}
-.. |MEM| mathdef:: \K{mem}
-.. |GLOBAL| mathdef:: \K{global}
-.. |IMPORT| mathdef:: \K{import}
-.. |EXPORT| mathdef:: \K{export}
-.. |CODE| mathdef:: \K{code}
-.. |DATA| mathdef:: \K{data}
-.. |ELEM| mathdef:: \K{elem}
-.. |START| mathdef:: \K{start}
-.. |CUSTOM| mathdef:: \K{custom}
+.. |MTYPES| mathdef:: \xref{syntax/modules}{syntax-module}{\K{types}}
+.. |MFUNCS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{funcs}}
+.. |MTABLES| mathdef:: \xref{syntax/modules}{syntax-module}{\K{tables}}
+.. |MMEMS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{mems}}
+.. |MGLOBALS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{globals}}
+.. |MIMPORTS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{imports}}
+.. |MEXPORTS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{exports}}
+.. |MDATA| mathdef:: \xref{syntax/modules}{syntax-module}{\K{data}}
+.. |MELEM| mathdef:: \xref{syntax/modules}{syntax-module}{\K{elem}}
+.. |MSTART| mathdef:: \xref{syntax/modules}{syntax-module}{\K{start}}
+
+.. |FTYPE| mathdef:: \xref{syntax/modules}{syntax-func}{\K{type}}
+.. |FLOCALS| mathdef:: \xref{syntax/modules}{syntax-func}{\K{locals}}
+.. |FBODY| mathdef:: \xref{syntax/modules}{syntax-func}{\K{body}}
+
+.. |TTYPE| mathdef:: \xref{syntax/modules}{syntax-table}{\K{type}}
+
+.. |MTYPE| mathdef:: \xref{syntax/modules}{syntax-mem}{\K{type}}
+
+.. |GTYPE| mathdef:: \xref{syntax/modules}{syntax-global}{\K{type}}
+.. |GINIT| mathdef:: \xref{syntax/modules}{syntax-global}{\K{init}}
+
+.. |ETABLE| mathdef:: \xref{syntax/modules}{syntax-elem}{\K{table}}
+.. |EOFFSET| mathdef:: \xref{syntax/modules}{syntax-elem}{\K{offset}}
+.. |EINIT| mathdef:: \xref{syntax/modules}{syntax-elem}{\K{init}}
+
+.. |DMEM| mathdef:: \xref{syntax/modules}{syntax-data}{\K{data}}
+.. |DOFFSET| mathdef:: \xref{syntax/modules}{syntax-data}{\K{offset}}
+.. |DINIT| mathdef:: \xref{syntax/modules}{syntax-data}{\K{init}}
+
+.. |SFUNC| mathdef:: \xref{syntax/modules}{syntax-start}{\K{func}}
+
+.. |ENAME| mathdef:: \xref{syntax/modules}{syntax-export}{\K{name}}
+.. |EDESC| mathdef:: \xref{syntax/modules}{syntax-export}{\K{desc}}
+.. |EDFUNC| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\K{func}}
+.. |EDTABLE| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\K{table}}
+.. |EDMEM| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\K{mem}}
+.. |EDGLOBAL| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\K{global}}
+
+.. |IMODULE| mathdef:: \xref{syntax/modules}{syntax-import}{\K{module}}
+.. |INAME| mathdef:: \xref{syntax/modules}{syntax-import}{\K{name}}
+.. |IDESC| mathdef:: \xref{syntax/modules}{syntax-import}{\K{desc}}
+.. |IDFUNC| mathdef:: \xref{syntax/modules}{syntax-importdesc}{\K{func}}
+.. |IDTABLE| mathdef:: \xref{syntax/modules}{syntax-importdesc}{\K{table}}
+.. |IDMEM| mathdef:: \xref{syntax/modules}{syntax-importdesc}{\K{mem}}
+.. |IDGLOBAL| mathdef:: \xref{syntax/modules}{syntax-importdesc}{\K{global}}
 
 
 .. Modules, non-terminals
@@ -192,10 +237,18 @@
 .. |start| mathdef:: \xref{syntax/modules}{syntax-start}{\X{start}}
 
 
+.. Modules, meta functions
+
+.. |edfuncs| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\F{funcs}}
+.. |edtables| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\F{tables}}
+.. |edmems| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\F{mems}}
+.. |edglobals| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\F{globals}}
+
+
 .. Instructions, terminals
 
-.. |OFFSET| mathdef:: \K{offset}
-.. |ALIGN| mathdef:: \K{align}
+.. |OFFSET| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{offset}}
+.. |ALIGN| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{align}}
 
 .. |UNREACHABLE| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{unreachable}}
 .. |NOP| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{nop}}
@@ -296,6 +349,11 @@
 .. Binary Format
 .. -------------
 
+.. Auxiliary productions
+
+.. |Bvec| mathdef:: \xref{binary/conventions}{binary-vec}{\B{vec}}
+
+
 .. Values, non-terminals
 
 .. |Bbyte| mathdef:: \xref{binary/values}{binary-byte}{\B{byte}}
@@ -324,11 +382,13 @@
 .. |Bf32| mathdef:: \xref{binary/values}{binary-float}{\BfX{\B{32}}}
 .. |Bf64| mathdef:: \xref{binary/values}{binary-float}{\BfX{\B{64}}}
 
-.. |Bvec| mathdef:: \xref{binary/values}{binary-vec}{\B{vec}}
 .. |Bname| mathdef:: \xref{binary/values}{binary-name}{\B{name}}
 .. |Bcodepoint| mathdef:: \xref{binary/values}{binary-name}{\B{codepoint}}
-.. |Bcodeval| mathdef:: \xref{binary/values}{binary-name}{\B{codeval}}
-.. |Bcodecont| mathdef:: \xref{binary/values}{binary-name}{\B{cont}}
+
+
+.. Values, meta functions
+
+.. |utf8| mathdef:: \xref{binary/values}{binary-utf8}{\F{utf8}}
 
 
 .. Types, non-terminals
@@ -406,6 +466,11 @@
 .. Text Format
 .. -----------
 
+.. Auxiliary productions
+
+.. |Tvec| mathdef:: \xref{text/conventions}{text-vec}{\T{vec}}
+
+
 .. Lexical grammar, terminals
 
 .. |textl| mathdef:: \mbox{‘}
@@ -436,8 +501,6 @@
 
 .. Values, non-terminals
 
-.. |Tbyte| mathdef:: \xref{text/values}{text-byte}{\T{byte}}
-
 .. |Tsign| mathdef:: \xref{text/values}{text-sign}{\T{sign}}
 .. |Tdigit| mathdef:: \xref{text/values}{text-digit}{\T{digit}}
 .. |Thexdigit| mathdef:: \xref{text/values}{text-hexdigit}{\T{hexdigit}}
@@ -473,7 +536,6 @@
 .. |Tf32| mathdef:: \xref{text/values}{text-float}{\TfX{\T{32}}}
 .. |Tf64| mathdef:: \xref{text/values}{text-float}{\TfX{\T{64}}}
 
-.. |Tvec| mathdef:: \xref{text/values}{text-vec}{\T{vec}}
 .. |Tstring| mathdef:: \xref{text/values}{text-string}{\T{string}}
 .. |Tstringelem| mathdef:: \xref{text/values}{text-string}{\T{stringelem}}
 .. |Tstringchar| mathdef:: \xref{text/values}{text-string}{\T{stringchar}}
@@ -483,7 +545,7 @@
 .. |Tcodecont| mathdef:: \xref{text/values}{text-name}{\T{cont}}
 
 .. |Tid| mathdef:: \xref{text/values}{text-id}{\T{id}}
-.. |Tidchar| mathdef:: \xref{text/values}{text-id}{\T{idchar}}
+.. |Tidchar| mathdef:: \xref{text/values}{text-idchar}{\T{idchar}}
 
 
 .. Types, non-terminals
@@ -564,7 +626,14 @@
 
 .. Contexts
 
-.. |TYPEDEFS| mathdef:: \K{typedefs}
+.. |ITYPEDEFS| mathdef:: \xref{text/conventions}{text-context}{\K{typedefs}}
+.. |ITYPES| mathdef:: \xref{text/conventions}{text-context}{\K{types}}
+.. |IFUNCS| mathdef:: \xref{text/conventions}{text-context}{\K{funcs}}
+.. |ITABLES| mathdef:: \xref{text/conventions}{text-context}{\K{tables}}
+.. |IMEMS| mathdef:: \xref{text/conventions}{text-context}{\K{mems}}
+.. |IGLOBALS| mathdef:: \xref{text/conventions}{text-context}{\K{globals}}
+.. |ILOCALS| mathdef:: \xref{text/conventions}{text-context}{\K{locals}}
+.. |ILABELS| mathdef:: \xref{text/conventions}{text-context}{\K{labels}}
 
 
 .. Meta Functions
@@ -578,18 +647,21 @@
 .. Validation
 .. ----------
 
+.. Notation
+
+.. |ok| mathdef:: \mathrel{\mbox{ok}}
+
+
 .. Contexts
 
-.. |TYPES| mathdef:: \K{types}
-.. |FUNCS| mathdef:: \K{funcs}
-.. |TABLES| mathdef:: \K{tables}
-.. |MEMS| mathdef:: \K{mems}
-.. |GLOBALS| mathdef:: \K{globals}
-.. |LOCALS| mathdef:: \K{locals}
-.. |LABELS| mathdef:: \K{labels}
-.. |LRETURN| mathdef:: \K{return}
-.. |IMPORTS| mathdef:: \K{imports}
-.. |EXPORTS| mathdef:: \K{exports}
+.. |CTYPES| mathdef:: \xref{valid/conventions}{context}{\K{types}}
+.. |CFUNCS| mathdef:: \xref{valid/conventions}{context}{\K{funcs}}
+.. |CTABLES| mathdef:: \xref{valid/conventions}{context}{\K{tables}}
+.. |CMEMS| mathdef:: \xref{valid/conventions}{context}{\K{mems}}
+.. |CGLOBALS| mathdef:: \xref{valid/conventions}{context}{\K{globals}}
+.. |CLOCALS| mathdef:: \xref{valid/conventions}{context}{\K{locals}}
+.. |CLABELS| mathdef:: \xref{valid/conventions}{context}{\K{labels}}
+.. |CRETURN| mathdef:: \xref{valid/conventions}{context}{\K{return}}
 
 
 
@@ -622,14 +694,34 @@
 
 .. Instances, terminals
 
-.. |VALUE| mathdef:: \K{value}
-.. |INIT| mathdef:: \K{init}
-.. |BODY| mathdef:: \K{body}
-.. |NAME| mathdef:: \K{name}
-.. |DESC| mathdef:: \K{desc}
+.. |FITYPE| mathdef:: \xref{exec/runtime}{syntax-funcinst}{\K{type}}
+.. |FIMODULE| mathdef:: \xref{exec/runtime}{syntax-funcinst}{\K{module}}
+.. |FICODE| mathdef:: \xref{exec/runtime}{syntax-funcinst}{\K{code}}
+.. |FIHOSTCODE| mathdef:: \xref{exec/runtime}{syntax-funcinst}{\K{hostcode}}
 
-.. |MUT| mathdef:: \K{mut}
-.. |HOST| mathdef:: \K{host}
+.. |TIELEM| mathdef:: \xref{exec/runtime}{syntax-tableinst}{\K{elem}}
+.. |TIMAX| mathdef:: \xref{exec/runtime}{syntax-tableinst}{\K{max}}
+
+.. |MIDATA| mathdef:: \xref{exec/runtime}{syntax-meminst}{\K{data}}
+.. |MIMAX| mathdef:: \xref{exec/runtime}{syntax-meminst}{\K{max}}
+
+.. |GIVALUE| mathdef:: \xref{exec/runtime}{syntax-globalinst}{\K{value}}
+.. |GIMUT| mathdef:: \xref{exec/runtime}{syntax-globalinst}{\K{mut}}
+
+.. |EINAME| mathdef:: \xref{exec/runtime}{syntax-exportinst}{\K{name}}
+.. |EIVALUE| mathdef:: \xref{exec/runtime}{syntax-exportinst}{\K{value}}
+
+.. |EVFUNC| mathdef:: \xref{exec/runtime}{syntax-externval}{\K{func}}
+.. |EVTABLE| mathdef:: \xref{exec/runtime}{syntax-externval}{\K{table}}
+.. |EVMEM| mathdef:: \xref{exec/runtime}{syntax-externval}{\K{mem}}
+.. |EVGLOBAL| mathdef:: \xref{exec/runtime}{syntax-externval}{\K{global}}
+
+.. |MITYPES| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{types}}
+.. |MIFUNCS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{funcaddrs}}
+.. |MITABLES| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{tableaddrs}}
+.. |MIMEMS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{memaddrs}}
+.. |MIGLOBALS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{globaladdrs}}
+.. |MIEXPORTS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{exports}}
 
 
 .. Instances, non-terminals
@@ -647,22 +739,45 @@
 .. |hostfunc| mathdef:: \xref{exec/runtime}{syntax-hostfunc}{\X{hostfunc}}
 
 
-.. Store & Stack, terminals
+.. Instances, meta functions
+
+.. |evfuncs| mathdef:: \xref{exec/runtime}{syntax-externval}{\F{funcs}}
+.. |evtables| mathdef:: \xref{exec/runtime}{syntax-externval}{\F{tables}}
+.. |evmems| mathdef:: \xref{exec/runtime}{syntax-externval}{\F{mems}}
+.. |evglobals| mathdef:: \xref{exec/runtime}{syntax-externval}{\F{globals}}
+
 
-.. |TRAP| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{trap}}
-.. |LABEL| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{label}}
-.. |FRAME| mathdef:: \xref{exec/runtime}{syntax-instr-admin}{\K{frame}}
+.. Store, terminals
 
+.. |SFUNCS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{funcs}}
+.. |STABLES| mathdef:: \xref{exec/runtime}{syntax-store}{\K{tables}}
+.. |SMEMS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{mems}}
+.. |SGLOBALS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{globals}}
 
-.. Store & Stack, non-terminals
+
+.. Store, non-terminals
 
 .. |store| mathdef:: \xref{exec/runtime}{syntax-store}{\X{store}}
-.. |frame| mathdef:: \xref{exec/runtime}{syntax-frame}{\X{frame}}
+
+
+.. Stack, terminals
+
+.. |LABEL| mathdef:: \xref{exec/runtime}{syntax-label}{\K{label}}
+.. |FRAME| mathdef:: \xref{exec/runtime}{syntax-frame}{\K{frame}}
+
+.. |ALOCALS| mathdef:: \xref{exec/runtime}{syntax-frame}{\K{locals}}
+.. |AMODULE| mathdef:: \xref{exec/runtime}{syntax-frame}{\K{module}}
+
+
+.. Stack, non-terminals
+
 .. |label| mathdef:: \xref{exec/runtime}{syntax-label}{\X{label}}
+.. |frame| mathdef:: \xref{exec/runtime}{syntax-frame}{\X{frame}}
 
 
 .. Administrative Instructions, terminals
 
+.. |TRAP| mathdef:: \xref{exec/runtime}{syntax-trap}{\K{trap}}
 .. |INVOKE| mathdef:: \xref{exec/runtime}{syntax-invoke}{\K{invoke}}
 .. |INSTANTIATE| mathdef:: \xref{exec/runtime}{syntax-instantiate}{\K{instantiate}}
 .. |INITGLOBAL| mathdef:: \xref{exec/runtime}{syntax-init_global}{\K{init\_global}}
@@ -760,3 +875,8 @@
 .. |ieee| mathdef:: \xref{exec/numerics}{aux-ieee}{\F{float}}
 .. |nans| mathdef:: \xref{exec/numerics}{aux-nans}{\F{nans}}
 .. |trunc| mathdef:: \xref{exec/numerics}{aux-trunc}{\F{trunc}}
+
+
+.. Other meta functions
+
+.. |invoke| mathdef:: \xref{exec/modules}{exec-invocation}{\F{invoke}}
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index 2511f0b29..1596ed184 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -1,4 +1,4 @@
-.. index:: ! validation, ! type system, function type, table type, memory type, globaltype, valtype, resulttype, index space
+.. index:: ! validation, ! type system, function type, table type, memory type, globaltype, valtype, resulttype, index space, instantiation. module
 .. _type-system:
 
 Conventions
@@ -7,7 +7,7 @@ Conventions
 Validation checks that a WebAssembly module is well-formed.
 Only valid modules can be :ref:`instantiated <exec-instantiation>`.
 
-Validity is defined by a *type system* over the :ref:`abstract syntax <syntax>` of both instructions and modules.
+Validity is defined by a *type system* over the :ref:`abstract syntax <syntax>` of a :ref:`module <syntax-module>` and its contents.
 For each piece of abstract syntax, there is a typing rule that specifies the constraints that apply to it.
 All rules are given in two *equivalent* forms:
 
@@ -24,14 +24,14 @@ That is, they only formulate the constraints, they do not define an algorithm.
 A sound and complete algorithm for type-checking instruction sequences according to this specification is provided in the :ref:`appendix <soundness>`.
 
 
-.. index:: ! context, function type, table type, memory type, global type, value type, result type, index space
+.. index:: ! context, function type, table type, memory type, global type, value type, result type, index space, module, function
 .. _context:
 
 Contexts
 ~~~~~~~~
 
 Validity of an individual definition is specified relative to a *context*,
-which collects relevant information about the surrounding :ref:`module <syntax-module>` and other definitions in scope:
+which collects relevant information about the surrounding :ref:`module <syntax-module>` and the definitions in scope:
 
 * *Types*: the list of types defined in the current module.
 * *Functions*: the list of functions declared in the current module, represented by their function type.
@@ -47,20 +47,20 @@ describing each defined entry in that space.
 Locals, labels and return type are only used for validating :ref:`instructions <syntax-instr>` in :ref:`function bodies <syntax-func>`, and are left empty elsewhere.
 The label stack is the only part of the context that changes as validation of an instruction sequence proceeds.
 
-It is convenient to define contexts as :ref:`records <syntax-record>` :math:`C` with abstract syntax:
+It is convenient to define contexts as :ref:`records <notation-record>` :math:`C` with abstract syntax:
 
 .. math::
    \begin{array}{llll}
    \production{(context)} & C &::=&
      \begin{array}[t]{l@{~}ll}
-     \{ & \TYPES & \functype^\ast, \\
-        & \FUNCS & \functype^\ast, \\
-        & \TABLES & \tabletype^\ast, \\
-        & \MEMS & \memtype^\ast, \\
-        & \GLOBALS & \globaltype^\ast, \\
-        & \LOCALS & \valtype^\ast, \\
-        & \LABELS & \resulttype^\ast, \\
-        & \LRETURN & \resulttype^? ~\} \\
+     \{ & \CTYPES & \functype^\ast, \\
+        & \CFUNCS & \functype^\ast, \\
+        & \CTABLES & \tabletype^\ast, \\
+        & \CMEMS & \memtype^\ast, \\
+        & \CGLOBALS & \globaltype^\ast, \\
+        & \CLOCALS & \valtype^\ast, \\
+        & \CLABELS & \resulttype^\ast, \\
+        & \CRETURN & \resulttype^? ~\} \\
      \end{array}
    \end{array}
 
@@ -120,7 +120,7 @@ Formal Notation
    For the interested reader, a more thorough introduction can be found in respective text books. [#tapl]_
 
 The proposition that a phrase :math:`A` has a respective type :math:`T` is written :math:`A : T`.
-In general, however, typing is dependent on the context :math:`C`.
+In general, however, typing is dependent on a context :math:`C`.
 To express this explicitly, the complete form is a *judgement* :math:`C \vdash A : T`,
 which says that :math:`A : T` holds under the assumptions encoded in :math:`C`.
 
@@ -150,13 +150,13 @@ and there is one respective rule for each relevant construct :math:`A` of the ab
 
    The instruction is always valid with type :math:`[\I32~\I32] \to [\I32`]
    (saying that it consumes two |I32| values and produces one),
-   independent from any side conditions.
+   independent of any side conditions.
 
    An instruction like |GETLOCAL| can be typed as follows:
 
    .. math::
       \frac{
-        C.\LOCALS[x] = t
+        C.\CLOCALS[x] = t
       }{
         C \vdash \GETLOCAL~x : [] \to [t]
       }
@@ -164,7 +164,7 @@ and there is one respective rule for each relevant construct :math:`A` of the ab
    Here, the premise enforces that the immediate :ref:`local index <syntax-localidx>` :math:`x` exists in the context.
    The instruction produces a value of its respective type :math:`t`
    (and does not consume any values).
-   If :math:`C.\LOCALS[x]` does not exist then the premise does not hold,
+   If :math:`C.\CLOCALS[x]` does not exist then the premise does not hold,
    and the instruction is ill-typed.
 
    Finally, a :ref:`structured <syntax-instr-control>` instruction requires
@@ -178,10 +178,10 @@ and there is one respective rule for each relevant construct :math:`A` of the ab
       }
 
    A |BLOCK| instruction is only valid when the instruction sequence in its body is.
-   Moreover, the result type must match the block's annotation :math:`t^?`.
+   Moreover, the result type must match the block's annotation :math:`[t^?]`.
    If so, then the |BLOCK| instruction has the same type as the body.
    Inside the body an additional label of the same type is available,
-   which is expressed by locally extending the context :math:`C` with the additional label information for the premise.
+   which is expressed by extending the context :math:`C` with the additional label information for the premise.
 
 
 .. [#tapl]
diff --git a/document/core/valid/index.rst b/document/core/valid/index.rst
index 0f39bfd5c..34cf3b906 100644
--- a/document/core/valid/index.rst
+++ b/document/core/valid/index.rst
@@ -7,5 +7,6 @@ Validation
    :maxdepth: 2
 
    conventions
+   types
    instructions
    modules
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 1aa52473f..8d6aa30f0 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -1,4 +1,4 @@
-.. index:: instruction, function type, context
+.. index:: instruction, function type, context, value, operand stack, ! polymorphism
 .. _valid-instr:
 
 Instructions
@@ -193,7 +193,7 @@ Parametric Instructions
    Both |DROP| and |SELECT| are :ref:`value-polymorphic <polymorphism>` instructions.
 
 
-.. index:: variable instructions, local index, global index
+.. index:: variable instructions, local index, global index, context
    pair: validation; instruction
    single: abstract syntax; instruction
 .. _valid-instr-variable:
@@ -206,15 +206,15 @@ Variable Instructions
 :math:`\GETLOCAL~x`
 ...................
 
-* The local :math:`C.\LOCALS[x]` must be defined in the context.
+* The local :math:`C.\CLOCALS[x]` must be defined in the context.
 
-* Let :math:`t` be the :ref:`value type <syntax-valtype>` :math:`C.\LOCALS[x]`.
+* Let :math:`t` be the :ref:`value type <syntax-valtype>` :math:`C.\CLOCALS[x]`.
 
 * Then the instruction is valid with type :math:`[] \to [t]`.
 
 .. math::
    \frac{
-     C.\LOCALS[x] = t
+     C.\CLOCALS[x] = t
    }{
      C \vdash \GETLOCAL~x : [] \to [t]
    }
@@ -225,15 +225,15 @@ Variable Instructions
 :math:`\SETLOCAL~x`
 ...................
 
-* The local :math:`C.\LOCALS[x]` must be defined in the context.
+* The local :math:`C.\CLOCALS[x]` must be defined in the context.
 
-* Let :math:`t` be the :ref:`value type <syntax-valtype>` :math:`C.\LOCALS[x]`.
+* Let :math:`t` be the :ref:`value type <syntax-valtype>` :math:`C.\CLOCALS[x]`.
 
 * Then the instruction is valid with type :math:`[t] \to []`.
 
 .. math::
    \frac{
-     C.\LOCALS[x] = t
+     C.\CLOCALS[x] = t
    }{
      C \vdash \SETLOCAL~x : [t] \to []
    }
@@ -244,15 +244,15 @@ Variable Instructions
 :math:`\TEELOCAL~x`
 ...................
 
-* The local :math:`C.\LOCALS[x]` must be defined in the context.
+* The local :math:`C.\CLOCALS[x]` must be defined in the context.
 
-* Let :math:`t` be the :ref:`value type <syntax-valtype>` :math:`C.\LOCALS[x]`.
+* Let :math:`t` be the :ref:`value type <syntax-valtype>` :math:`C.\CLOCALS[x]`.
 
 * Then the instruction is valid with type :math:`[t] \to [t]`.
 
 .. math::
    \frac{
-     C.\LOCALS[x] = t
+     C.\CLOCALS[x] = t
    }{
      C \vdash \TEELOCAL~x : [t] \to [t]
    }
@@ -263,15 +263,15 @@ Variable Instructions
 :math:`\GETGLOBAL~x`
 ....................
 
-* The global :math:`C.\GLOBALS[x]` must be defined in the context.
+* The global :math:`C.\CGLOBALS[x]` must be defined in the context.
 
-* Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`C.\GLOBALS[x]`.
+* Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`C.\CGLOBALS[x]`.
 
 * Then the instruction is valid with type :math:`[] \to [t]`.
 
 .. math::
    \frac{
-     C.\GLOBALS[x] = \mut~t
+     C.\CGLOBALS[x] = \mut~t
    }{
      C \vdash \GETGLOBAL~x : [] \to [t]
    }
@@ -282,9 +282,9 @@ Variable Instructions
 :math:`\SETGLOBAL~x`
 ....................
 
-* The global :math:`C.\GLOBALS[x]` must be defined in the context.
+* The global :math:`C.\CGLOBALS[x]` must be defined in the context.
 
-* Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`C.\GLOBALS[x]`.
+* Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`C.\CGLOBALS[x]`.
 
 * The mutability :math:`\mut` must be |MVAR|.
 
@@ -292,13 +292,13 @@ Variable Instructions
 
 .. math::
    \frac{
-     C.\GLOBALS[x] = \MVAR~t
+     C.\CGLOBALS[x] = \MVAR~t
    }{
      C \vdash \SETGLOBAL~x : [t] \to []
    }
 
 
-.. index:: memory instruction, memory index
+.. index:: memory instruction, memory index, context
    pair: validation; instruction
    single: abstract syntax; instruction
 .. _valid-memarg:
@@ -312,7 +312,7 @@ Memory Instructions
 :math:`t\K{.}\LOAD~\memarg`
 ...........................
 
-* The memory :math:`C.\MEMS[0]` must be defined in the context.
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
 * The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`width <syntax-valtype>` of :math:`t` divided by :math:`8`.
 
@@ -320,7 +320,7 @@ Memory Instructions
 
 .. math::
    \frac{
-     C.\MEMS[0] = \memtype
+     C.\CMEMS[0] = \memtype
      \qquad
      2^{\memarg.\ALIGN} \leq |t|/8
    }{
@@ -333,7 +333,7 @@ Memory Instructions
 :math:`t\K{.}\LOAD{N}\K{\_}\sx~\memarg`
 .......................................
 
-* The memory :math:`C.\MEMS[0]` must be defined in the context.
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
 * The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
 
@@ -341,7 +341,7 @@ Memory Instructions
 
 .. math::
    \frac{
-     C.\MEMS[0] = \memtype
+     C.\CMEMS[0] = \memtype
      \qquad
      2^{\memarg.\ALIGN} \leq N/8
    }{
@@ -354,7 +354,7 @@ Memory Instructions
 :math:`t\K{.}\STORE~\memarg`
 ............................
 
-* The memory :math:`C.\MEMS[0]` must be defined in the context.
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
 * The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`width <syntax-valtype>` of :math:`t` divided by :math:`8`.
 
@@ -362,7 +362,7 @@ Memory Instructions
 
 .. math::
    \frac{
-     C.\MEMS[0] = \memtype
+     C.\CMEMS[0] = \memtype
      \qquad
      2^{\memarg.\ALIGN} \leq |t|/8
    }{
@@ -375,7 +375,7 @@ Memory Instructions
 :math:`t\K{.}\STORE{N}~\memarg`
 ...............................
 
-* The memory :math:`C.\MEMS[0]` must be defined in the context.
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
 * The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than :math:`N/8`.
 
@@ -383,7 +383,7 @@ Memory Instructions
 
 .. math::
    \frac{
-     C.\MEMS[0] = \memtype
+     C.\CMEMS[0] = \memtype
      \qquad
      2^{\memarg.\ALIGN} \leq N/8
    }{
@@ -396,13 +396,13 @@ Memory Instructions
 :math:`\CURRENTMEMORY`
 ......................
 
-* The memory :math:`C.\MEMS[0]` must be defined in the context.
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
 * Then the instruction is valid with type :math:`[] \to [\I32]`.
 
 .. math::
    \frac{
-     C.\MEMS[0] = \memtype
+     C.\CMEMS[0] = \memtype
    }{
      C \vdash \CURRENTMEMORY : [] \to [\I32]
    }
@@ -413,19 +413,19 @@ Memory Instructions
 :math:`\GROWMEMORY`
 ...................
 
-* The memory :math:`C.\MEMS[0]` must be defined in the context.
+* The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
 * Then the instruction is valid with type :math:`[\I32] \to [\I32]`.
 
 .. math::
    \frac{
-     C.\MEMS[0] = \memtype
+     C.\CMEMS[0] = \memtype
    }{
      C \vdash \GROWMEMORY : [\I32] \to [\I32]
    }
 
 
-.. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, polymorphism
+.. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, polymorphism, context
    pair: validation; instruction
    single: abstract syntax; instruction
 .. _valid-label:
@@ -470,7 +470,7 @@ Control Instructions
 :math:`\BLOCK~[t^?]~\instr^\ast~\END`
 .....................................
 
-* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t^?]` prepended to the |LABELS| vector.
+* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t^?]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
   the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \to [t^?]`.
@@ -479,7 +479,7 @@ Control Instructions
 
 .. math::
    \frac{
-     C,\LABELS\,[t^?] \vdash \instr^\ast : [] \to [t^?]
+     C,\CLABELS\,[t^?] \vdash \instr^\ast : [] \to [t^?]
    }{
      C \vdash \BLOCK~[t^?]~\instr^\ast~\END : [] \to [t^?]
    }
@@ -494,7 +494,7 @@ Control Instructions
 :math:`\LOOP~[t^?]~\instr^\ast~\END`
 ....................................
 
-* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the empty :ref:`result type <syntax-resulttype>` :math:`[]` prepended to the |LABELS| vector.
+* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the empty :ref:`result type <syntax-resulttype>` :math:`[]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
   the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \to [t^?]`.
@@ -503,7 +503,7 @@ Control Instructions
 
 .. math::
    \frac{
-     C,\LABELS\,[] \vdash \instr^\ast : [] \to [t^?]
+     C,\CLABELS\,[] \vdash \instr^\ast : [] \to [t^?]
    }{
      C \vdash \LOOP~[t^?]~\instr^\ast~\END : [] \to [t^?]
    }
@@ -518,7 +518,7 @@ Control Instructions
 :math:`\IF~[t^?]~\instr_1^\ast~\ELSE~\instr_2^\ast~\END`
 ........................................................
 
-* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the empty :ref:`result type <syntax-resulttype>` :math:`[t^?]` prepended to the |LABELS| vector.
+* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the empty :ref:`result type <syntax-resulttype>` :math:`[t^?]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
   the instruction sequence :math:`\instr_1^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \to [t^?]`.
@@ -530,9 +530,9 @@ Control Instructions
 
 .. math::
    \frac{
-     C,\LABELS\,[t^?] \vdash \instr_1^\ast : [] \to [t^?]
+     C,\CLABELS\,[t^?] \vdash \instr_1^\ast : [] \to [t^?]
      \qquad
-     C,\LABELS\,[t^?] \vdash \instr_2^\ast : [] \to [t^?]
+     C,\CLABELS\,[t^?] \vdash \instr_2^\ast : [] \to [t^?]
    }{
      C \vdash \IF~[t^?]~\instr_1^\ast~\ELSE~\instr_2^\ast~\END : [\I32] \to [t^?]
    }
@@ -547,15 +547,15 @@ Control Instructions
 :math:`\BR~l`
 .............
 
-* The label :math:`C.\LABELS[l]` must be defined in the context.
+* The label :math:`C.\CLABELS[l]` must be defined in the context.
 
-* Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` :math:`C.\LABELS[l]`.
+* Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l]`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast~t^?] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
-     C.\LABELS[l] = [t^?]
+     C.\CLABELS[l] = [t^?]
    }{
      C \vdash \BR~l : [t_1^\ast~t^?] \to [t_2^\ast]
    }
@@ -569,15 +569,15 @@ Control Instructions
 :math:`\BRIF~l`
 ...............
 
-* The label :math:`C.\LABELS[l]` must be defined in the context.
+* The label :math:`C.\CLABELS[l]` must be defined in the context.
 
-* Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` :math:`C.\LABELS[l]`.
+* Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l]`.
 
 * Then the instruction is valid with type :math:`[t^?~\I32] \to [t^?]`.
 
 .. math::
    \frac{
-     C.\LABELS[l] = [t^?]
+     C.\CLABELS[l] = [t^?]
    }{
      C \vdash \BRIF~l : [t^?~\I32] \to [t^?]
    }
@@ -588,23 +588,23 @@ Control Instructions
 :math:`\BRTABLE~l^\ast~l_N`
 ...........................
 
-* The label :math:`C.\LABELS[l]` must be defined in the context.
+* The label :math:`C.\CLABELS[l]` must be defined in the context.
 
-* Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` :math:`C.\LABELS[l_N]`.
+* Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l_N]`.
 
 * For all :math:`l_i` in :math:`l^\ast`,
-  the label :math:`C.\LABELS[l_i]` must be defined in the context.
+  the label :math:`C.\CLABELS[l_i]` must be defined in the context.
 
 * For all :math:`l_i` in :math:`l^\ast`,
-  :math:`C.\LABELS[l_i]` must be :math:`t^?`.
+  :math:`C.\CLABELS[l_i]` must be :math:`t^?`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast~t^?~\I32] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
-     (C.\LABELS[l] = [t^?])^\ast
+     (C.\CLABELS[l] = [t^?])^\ast
      \qquad
-     C.\LABELS[l_N] = [t^?]
+     C.\CLABELS[l_N] = [t^?]
    }{
      C \vdash \BRTABLE~l^\ast~l_N : [t_1^\ast~t^?~\I32] \to [t_2^\ast]
    }
@@ -618,15 +618,15 @@ Control Instructions
 :math:`\RETURN`
 ...............
 
-* The return type :math:`C.\LRETURN` must not be empty in the context.
+* The return type :math:`C.\CRETURN` must not be empty in the context.
 
-* Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` of :math:`C.\LRETURN`.
+* Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` of :math:`C.\CRETURN`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast~t^?] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 
 .. math::
    \frac{
-     C.\LRETURN = [t^?]
+     C.\CRETURN = [t^?]
    }{
      C \vdash \RETURN : [t_1^\ast~t^?] \to [t_2^\ast]
    }
@@ -634,7 +634,7 @@ Control Instructions
 .. note::
    The |RETURN| instruction is :ref:`stack-polymorphic <polymorphism>`.
 
-   :math:`C.\LRETURN` is empty (:math:`\epsilon`) when validating an expression that is not a function body.
+   :math:`C.\CRETURN` is empty (:math:`\epsilon`) when validating an :ref:`expression <valid-expr>` that is not a function body.
    This differs from it being set to the empty result type (:math:`[]`),
    which is the case for functions not returning anything.
 
@@ -644,13 +644,13 @@ Control Instructions
 :math:`\CALL~x`
 ...............
 
-* The function :math:`C.\FUNCS[x]` must be defined in the context.
+* The function :math:`C.\CFUNCS[x]` must be defined in the context.
 
-* Then the instruction is valid with type :math:`C.\FUNCS[x]`.
+* Then the instruction is valid with type :math:`C.\CFUNCS[x]`.
 
 .. math::
    \frac{
-     C.\FUNCS[x] = [t_1^\ast] \to [t_2^\ast]
+     C.\CFUNCS[x] = [t_1^\ast] \to [t_2^\ast]
    }{
      C \vdash \CALL~x : [t_1^\ast] \to [t_2^\ast]
    }
@@ -661,21 +661,21 @@ Control Instructions
 :math:`\CALLINDIRECT~x`
 .......................
 
-* The table :math:`C.\TABLES[0]` must be defined in the context.
+* The table :math:`C.\CTABLES[0]` must be defined in the context.
 
-* Let :math:`\limits~\elemtype` be the :ref:`table type <syntax-tabletype>` :math:`C.\TABLES[0]`.
+* Let :math:`\limits~\elemtype` be the :ref:`table type <syntax-tabletype>` :math:`C.\CTABLES[0]`.
 
 * The :ref:`element type <syntax-elemtype>` :math:`\elemtype` must be |ANYFUNC|.
 
-* The type :math:`C.\TYPES[x]` must be defined in the context.
+* The type :math:`C.\CTYPES[x]` must be defined in the context.
 
-* Then the instruction is valid with type :math:`C.\TYPES[x]`.
+* Then the instruction is valid with type :math:`C.\CTYPES[x]`.
 
 .. math::
    \frac{
-     C.\TABLES[0] = \limits~\ANYFUNC
+     C.\CTABLES[0] = \limits~\ANYFUNC
      \qquad
-     C.\TYPES[x] = [t_1^\ast] \to [t_2^\ast]
+     C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
    }{
      C \vdash \CALLINDIRECT~x : [t_1^\ast] \to [t_2^\ast]
    }
@@ -767,7 +767,7 @@ Constant Expressions
 
   * either of the form :math:`t.\CONST~c`,
 
-  * or of the form :math:`\GETGLOBAL~x`, in which case :math:`C.\GLOBALS[x]` must be a :ref:`global type <syntax-globaltype>` of the form :math:`\CONST~t`.
+  * or of the form :math:`\GETGLOBAL~x`, in which case :math:`C.\CGLOBALS[x]` must be a :ref:`global type <syntax-globaltype>` of the form :math:`\CONST~t`.
 
 .. math::
    \frac{
@@ -782,7 +782,7 @@ Constant Expressions
    }
    \qquad
    \frac{
-     C.\GLOBALS[x] = \CONST~t
+     C.\CGLOBALS[x] = \CONST~t
    }{
      C \vdash \GETGLOBAL~x ~\F{const}
    }
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index f6bcb5bed..10dcd05cf 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -1,53 +1,8 @@
 Modules
 -------
 
-Modules are valid when all the definitions they contain are valid.
-To that end, each definition is classified with a suitable type.
-
-
-Auxiliary Rules
-~~~~~~~~~~~~~~~
-
-.. index:: function type
-   pair: validation; function type
-   single: abstract syntax; function type
-.. _valid-functype:
-
-Function Types :math:`[t_1^n] \to [t_2^m]`
-..........................................
-
-* The arity :math:`m` must not be larger than :math:`1`.
-
-* Then the function type is valid.
-
-.. math::
-   \frac{
-   }{
-     \vdash [t_1^\ast] \to [t_2^?] ~\F{ok}
-   }
-
-.. note::
-   This restriction may be removed in future versions of WebAssembly.
-
-
-.. index:: limits
-   pair: validation; limits
-   single: abstract syntax; limits
-.. _valid-limits:
-
-Limits :math:`\{ \MIN~n, \MAX~m^? \}`
-.....................................
-
-* If the maximum :math:`m^?` is not empty, then its value must not be smaller than :math:`n`.
-
-* Then the limit is valid.
-
-.. math::
-   \frac{
-     (n \leq m)^?
-   }{
-     \vdash \{ \MIN~n, \MAX~m^? \} ~\F{ok}
-   }
+:ref:`Modules <syntax-module>` are valid when all the components they contain are valid.
+Furthermore, most definitions are themselves classified with a suitable type.
 
 
 .. index:: function, local, function index, local index, type index, function type, value type, expression, import
@@ -62,21 +17,21 @@ Functions
 Functions :math:`\func` are classified by :ref:`function types <syntax-functype>` of the form :math:`[t_1^\ast] \to [t_2^?]`.
 
 
-:math:`\{ \TYPE~x, \LOCALS~t^\ast, \BODY~\expr \}`
-..................................................
+:math:`\{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\expr \}`
+.....................................................
 
-* The type :math:`C.\TYPES[x]` must be defined in the context.
+* The type :math:`C.\CTYPES[x]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^?]` be the :ref:`function type <syntax-functype>` :math:`C.\TYPES[x]`.
+* Let :math:`[t_1^\ast] \to [t_2^?]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
 
 * Let :math:`C'` be the same :ref:`context <context>` as :math:`C`,
   but with:
 
-  * |LOCALS| set to the sequence of :ref:`value types <syntax-valtype>` :math:`t_1^\ast~t^\ast`, concatenating parameters and locals,
+  * |CLOCALS| set to the sequence of :ref:`value types <syntax-valtype>` :math:`t_1^\ast~t^\ast`, concatenating parameters and locals,
 
-  * |LABELS| set to the singular sequence containing only :ref:`result type <syntax-valtype>` :math:`[t_2^\ast]`.
+  * |CLABELS| set to the singular sequence containing only :ref:`result type <syntax-valtype>` :math:`[t_2^?]`.
 
-  * |LRETURN| set to the :ref:`result type <syntax-valtype>` :math:`[t_2^?]`.
+  * |CRETURN| set to the :ref:`result type <syntax-valtype>` :math:`[t_2^?]`.
 
 * Under the context :math:`C'`,
   the expression :math:`\expr` must be valid with type :math:`t_2^?`.
@@ -85,11 +40,11 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
 
 .. math::
    \frac{
-     C.\TYPES[x] = [t_1^\ast] \to [t_2^?]
+     C.\CTYPES[x] = [t_1^\ast] \to [t_2^?]
      \qquad
-     C,\LOCALS\,t_1^\ast~t^\ast,\LRETURN~[t_2^?] \vdash \expr : [t_2^?]
+     C,\CLOCALS\,t_1^\ast~t^\ast,\CLABELS~[t_2^?],\CRETURN~[t_2^?] \vdash \expr : [t_2^?]
    }{
-     C \vdash \{ \TYPE~x, \LOCALS~t^\ast, \BODY~\expr \} : [t_1^\ast] \to [t_2^?]
+     C \vdash \{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\expr \} : [t_1^\ast] \to [t_2^?]
    }
 
 .. note::
@@ -107,18 +62,20 @@ Tables
 Tables :math:`\table` are classified by :ref:`table types <syntax-tabletype>` of the form :math:`\limits~\elemtype`.
 
 
-:math:`\{ \TYPE~\limits~\elemtype \}`
-.....................................
+:math:`\{ \TTYPE~\tabletype \}`
+...............................
+
+* Let :math:`\limits~\elemtype` be the :ref:`table types <syntax-tabletype>` :math:`\tabletype`.
 
 * The limits :math:`\limits` must be :ref:`valid <valid-limits>`.
 
-* Then the table definition is valid with type :math:`\limits~\elemtype`.
+* Then the table definition is valid with type :math:`\tabletype`.
 
 .. math::
    \frac{
-     \vdash \limits~\F{ok}
+     \vdash \limits\ok
    }{
-     C \vdash \{ \TYPE~\limits~\elemtype \} : \limits~\elemtype
+     C \vdash \{ \TTYPE~\limits~\elemtype \} : \limits~\elemtype
    }
 
 
@@ -133,18 +90,20 @@ Memories
 Memories :math:`\mem` are classified by :ref:`memory types <syntax-memtype>` of the form :math:`\limits`.
 
 
-:math:`\{ \TYPE~\limits \}`
-...........................
+:math:`\{ \MTYPE~\memtype \}`
+.............................
+
+* Let :math:`\limits` be the :ref:`memory types <syntax-memtype>` :math:`\memtype`.
 
 * The limits :math:`\limits` must be :ref:`valid <valid-limits>`.
 
-* Then the memory definition is valid with type :math:`\limits`.
+* Then the memory definition is valid with type :math:`\memtype`.
 
 .. math::
    \frac{
-     \vdash \limits~\F{ok}
+     \vdash \limits\ok
    }{
-     C \vdash \{ \TYPE~\limits \} : \limits~\elemtype
+     C \vdash \{ \MTYPE~\limits \} : \limits~\elemtype
    }
 
 
@@ -159,8 +118,8 @@ Globals
 Globals :math:`\global` are classified by :ref:`global types <syntax-globaltype>` of the form :math:`\mut~t`.
 
 
-:math:`\{ \TYPE~\mut~t, \INIT~\expr \}`
-.......................................
+:math:`\{ \GTYPE~\mut~t, \GINIT~\expr \}`
+.........................................
 
 * The expression :math:`\expr` must be :ref:`valid <valid-expr>` with :ref:`result type <syntax-resulttype>` :math:`[t]`.
 
@@ -174,7 +133,7 @@ Globals :math:`\global` are classified by :ref:`global types <syntax-globaltype>
      \qquad
      C \vdash \expr ~\F{const}
    }{
-     C \vdash \{ \TYPE~\mut~t, \INIT~\expr \} : \mut~t
+     C \vdash \{ \GTYPE~\mut~t, \GINIT~\expr \} : \mut~t
    }
 
 
@@ -190,12 +149,12 @@ Element Segments
 
 Element segments :math:`\elem` are not classified by a type.
 
-:math:`\{ \TABLE~x, \OFFSET~\expr, \INIT~y^\ast \}`
-...................................................
+:math:`\{ \ETABLE~x, \EOFFSET~\expr, \EINIT~y^\ast \}`
+......................................................
 
-* The table :math:`C.\TABLES[x]` must be defined in the context.
+* The table :math:`C.\CTABLES[x]` must be defined in the context.
 
-* Let :math:`\limits~\elemtype` be the :ref:`table type <syntax-tabletype>` :math:`C.\TABLES[x]`.
+* Let :math:`\limits~\elemtype` be the :ref:`table type <syntax-tabletype>` :math:`C.\CTABLES[x]`.
 
 * The :ref:`element type <syntax-elemtype>` :math:`\elemtype` must be |ANYFUNC|.
 
@@ -204,22 +163,22 @@ Element segments :math:`\elem` are not classified by a type.
 * The expression :math:`\expr` must be :ref:`constant <valid-constant>`.
 
 * For each :math:`y_i` in :math:`y^\ast`,
-  the function :math:`C.\FUNCS[y]` must be defined in the context.
+  the function :math:`C.\CFUNCS[y]` must be defined in the context.
 
 * Then the element segment is valid.
 
 
 .. math::
    \frac{
-     C.\TABLES[x] = \limits~\ANYFUNC
+     C.\CTABLES[x] = \limits~\ANYFUNC
      \qquad
      C \vdash \expr : [\I32]
      \qquad
      C \vdash \expr ~\F{const}
      \qquad
-     (C.\FUNCS[y] = \functype)^\ast
+     (C.\CFUNCS[y] = \functype)^\ast
    }{
-     C \vdash \{ \TABLE~x, \OFFSET~\expr, \INIT~y^\ast \} ~\F{ok}
+     C \vdash \{ \ETABLE~x, \EOFFSET~\expr, \EINIT~y^\ast \} \ok
    }
 
 
@@ -235,10 +194,10 @@ Data Segments
 
 Data segments :math:`\data` are not classified by any type.
 
-:math:`\{ \MEM~x, \OFFSET~\expr, \INIT~b^\ast \}`
-.................................................
+:math:`\{ \DMEM~x, \DOFFSET~\expr, \DINIT~b^\ast \}`
+....................................................
 
-* The memory :math:`C.\MEMS[x]` must be defined in the context.
+* The memory :math:`C.\CMEMS[x]` must be defined in the context.
 
 * The expression :math:`\expr` must be :ref:`valid <valid-expr>` with :ref:`result type <syntax-resulttype>` :math:`[\I32]`.
 
@@ -249,13 +208,13 @@ Data segments :math:`\data` are not classified by any type.
 
 .. math::
    \frac{
-     C.\MEMS[x] = \limits
+     C.\CMEMS[x] = \limits
      \qquad
      C \vdash \expr : [\I32]
      \qquad
      C \vdash \expr ~\F{const}
    }{
-     C \vdash \{ \MEM~x, \OFFSET~\expr, \INIT~b^\ast \} ~\F{ok}
+     C \vdash \{ \DMEM~x, \DOFFSET~\expr, \DINIT~b^\ast \} \ok
    }
 
 
@@ -269,21 +228,21 @@ Start Function
 
 Start function declarations :math:`\start` are not classified by any type.
 
-:math:`\{ \FUNC~x \}`
-.....................
+:math:`\{ \SFUNC~x \}`
+......................
 
-* The function :math:`C.\FUNCS[x]` must be defined in the context.
+* The function :math:`C.\CFUNCS[x]` must be defined in the context.
 
-* The type of :math:`C.\FUNCS[x]` must be :math:`[] \to []`.
+* The type of :math:`C.\CFUNCS[x]` must be :math:`[] \to []`.
 
 * Then the start function is valid.
 
 
 .. math::
    \frac{
-     C.\FUNCS[x] = [] \to []
+     C.\CFUNCS[x] = [] \to []
    }{
-     C \vdash \{ \FUNC~x \} ~\F{ok}
+     C \vdash \{ \SFUNC~x \} \ok
    }
 
 
@@ -299,8 +258,8 @@ Exports :math:`\export` are classified by their export :ref:`name <syntax-name>`
 Export descriptions :math:`\exportdesc` are not classified by any type.
 
 
-:math:`\{ \NAME~\name, \DESC~\exportdesc \}`
-............................................
+:math:`\{ \ENAME~\name, \EDESC~\exportdesc \}`
+..............................................
 
 * The export description :math:`\exportdesc` must be valid with type :math:`\externtype`.
 
@@ -308,63 +267,63 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
 
 .. math::
    \frac{
-     C \vdash \exportdesc ~\F{ok}
+     C \vdash \exportdesc \ok
    }{
-     C \vdash \{ \NAME~\name, \DESC~\exportdesc \} : \name
+     C \vdash \{ \ENAME~\name, \EDESC~\exportdesc \} : \name
    }
 
 
-:math:`\FUNC~x`
-...............
+:math:`\EDFUNC~x`
+.................
 
-* The function :math:`C.\FUNCS[x]` must be defined in the context.
+* The function :math:`C.\CFUNCS[x]` must be defined in the context.
 
 * Then the export description is valid.
 
 .. math::
    \frac{
-     C.\FUNCS[x] = \functype
+     C.\CFUNCS[x] = \functype
    }{
-     C \vdash \FUNC~x ~\F{ok}
+     C \vdash \EDFUNC~x \ok
    }
 
 
-:math:`\TABLE~x`
-................
+:math:`\EDTABLE~x`
+..................
 
-* The table :math:`C.\TABLES[x]` must be defined in the context.
+* The table :math:`C.\CTABLES[x]` must be defined in the context.
 
 * Then the export description is valid.
 
 .. math::
    \frac{
-     C.\TABLES[x] = \tabletype
+     C.\CTABLES[x] = \tabletype
    }{
-     C \vdash \TABLE~x ~\F{ok}
+     C \vdash \EDTABLE~x \ok
    }
 
 
-:math:`\MEM~x`
-..............
+:math:`\EDMEM~x`
+................
 
-* The memory :math:`C.\MEMS[x]` must be defined in the context.
+* The memory :math:`C.\CMEMS[x]` must be defined in the context.
 
 * Then the export description is valid.
 
 .. math::
    \frac{
-     C.\MEMS[x] = \memtype
+     C.\CMEMS[x] = \memtype
    }{
-     C \vdash \MEM~x ~\F{ok}
+     C \vdash \EDMEM~x \ok
    }
 
 
-:math:`\GLOBAL~x`
-.................
+:math:`\EDGLOBAL~x`
+...................
 
-* The global :math:`C.\GLOBALS[x]` must be defined in the context.
+* The global :math:`C.\CGLOBALS[x]` must be defined in the context.
 
-* Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`C.\GLOBALS[x]`.
+* Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`C.\CGLOBALS[x]`.
 
 * The mutability :math:`\mut` must be |MCONST|.
 
@@ -372,9 +331,9 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
 
 .. math::
    \frac{
-     C.\GLOBALS[x] = \MCONST~t
+     C.\CGLOBALS[x] = \MCONST~t
    }{
-     C \vdash \GLOBAL~x ~\F{ok}
+     C \vdash \EDGLOBAL~x \ok
    }
 
 
@@ -389,8 +348,8 @@ Imports
 Imports :math:`\import` and import descriptions :math:`\importdesc` are classified by :ref:`external types <syntax-externtype>`.
 
 
-:math:`\{ \MODULE~\name_1, \NAME~\name_2, \DESC~\importdesc \}`
-...............................................................
+:math:`\{ \IMODULE~\name_1, \INAME~\name_2, \IDESC~\importdesc \}`
+..................................................................
 
 * The import description :math:`\importdesc` must be valid with type :math:`\externtype`.
 
@@ -400,68 +359,68 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
    \frac{
      C \vdash \importdesc : \externtype
    }{
-     C \vdash \{ \MODULE~\name_1, \NAME~\name_2, \DESC~\importdesc \} : \externtype
+     C \vdash \{ \IMODULE~\name_1, \INAME~\name_2, \IDESC~\importdesc \} : \externtype
    }
 
 
-:math:`\FUNC~x`
-...............
+:math:`\IDFUNC~x`
+.................
 
-* The function :math:`C.\TYPES[x]` must be defined in the context.
+* The function :math:`C.\CTYPES[x]` must be defined in the context.
 
-* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\TYPES[x]`.
+* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
 
-* Then the import description is valid with type :math:`\FUNC~[t_1^\ast] \to [t_2^\ast]`.
+* Then the import description is valid with type :math:`\ETFUNC~[t_1^\ast] \to [t_2^\ast]`.
 
 .. math::
    \frac{
-     C.\TYPES[x] = [t_1^\ast] \to [t_2^\ast]
+     C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
    }{
-     C \vdash \FUNC~x : \FUNC~[t_1^\ast] \to [t_2^\ast]
+     C \vdash \IDFUNC~x : \ETFUNC~[t_1^\ast] \to [t_2^\ast]
    }
 
 
-:math:`\TABLE~\limits~\elemtype`
-................................
+:math:`\IDTABLE~\limits~\elemtype`
+..................................
 
 * The limits :math:`\limits` must be valid.
 
-* Then the import description is valid with type :math:`\TABLE~\limits~\elemtype`.
+* Then the import description is valid with type :math:`\ETTABLE~\limits~\elemtype`.
 
 .. math::
    \frac{
-     \vdash \limits ~\F{ok}
+     \vdash \limits \ok
    }{
-     C \vdash \TABLE~\limits~\elemtype : \TABLE~\limits~\elemtype
+     C \vdash \IDTABLE~\limits~\elemtype : \ETTABLE~\limits~\elemtype
    }
 
 
-:math:`\MEM~\limits`
-....................
+:math:`\IDMEM~\limits`
+......................
 
 * The limits :math:`\limits` must be valid.
 
-* Then the import description is valid with type :math:`\MEM~\limits`.
+* Then the import description is valid with type :math:`\ETMEM~\limits`.
 
 .. math::
    \frac{
-     \vdash \limits ~\F{ok}
+     \vdash \limits \ok
    }{
-     C \vdash \MEM~\limits : \MEM~\limits
+     C \vdash \IDMEM~\limits : \ETMEM~\limits
    }
 
 
-:math:`\GLOBAL~\mut~t`
-......................
+:math:`\IDGLOBAL~\mut~t`
+........................
 
 * The mutability :math:`\mut` must be |MCONST|.
 
-* Then the import description is valid with type :math:`\GLOBAL~t`.
+* Then the import description is valid with type :math:`\ETGLOBAL~t`.
 
 .. math::
    \frac{
    }{
-     C \vdash \GLOBAL~\MCONST~t : \GLOBAL~\MCONST~t
+     C \vdash \IDGLOBAL~\MCONST~t : \ETGLOBAL~\MCONST~t
    }
 
 
@@ -474,73 +433,73 @@ Modules
 ~~~~~~~
 
 A module is entirely *closed*,
-that is, it only refers to definitions that appear in the module itself.
+that is, its components can only refer to definitions that appear in the module itself.
 Consequently, no initial :ref:`context <context>` is required.
-Instead, the context :math:`C` for validation of the module's content is constructed from the types of definitions in the module itself.
+Instead, the context :math:`C` for validation of the module's content is constructed from the definitions in the module.
 
 * Let :math:`\module` be the module to validate.
 
 * Let :math:`C` be a :ref:`context <context>` where:
 
-  * :math:`C.\TYPES` is :math:`\module.\TYPES`,
+  * :math:`C.\CTYPES` is :math:`\module.\MTYPES`,
 
-  * :math:`C.\FUNCS` is :math:`\funcs(\externtype_i^\ast)` concatenated with :math:`\functype_i^\ast`,
+  * :math:`C.\CFUNCS` is :math:`\etfuncs(\externtype_i^\ast)` concatenated with :math:`\functype_i^\ast`,
     with the type sequences :math:`\externtype_i^\ast` and :math:`\functype_i^\ast` as determined below,
 
-  * :math:`C.\TABLES` is :math:`\tables(\externtype_i^\ast)` concatenated with :math:`\tabletype_i^\ast`,
+  * :math:`C.\CTABLES` is :math:`\ettables(\externtype_i^\ast)` concatenated with :math:`\tabletype_i^\ast`,
     with the type sequences :math:`\externtype_i^\ast` and :math:`\tabletype_i^\ast` as determined below,
 
-  * :math:`C.\MEMS` is :math:`\mems(\externtype_i^\ast)` concatenated with :math:`\memtype_i^\ast`,
+  * :math:`C.\CMEMS` is :math:`\etmems(\externtype_i^\ast)` concatenated with :math:`\memtype_i^\ast`,
     with the type sequences :math:`\externtype_i^\ast` and :math:`\memtype_i^\ast` as determined below,
 
-  * :math:`C.\GLOBALS` is :math:`\globals(\externtype_i^\ast)` concatenated with :math:`\globaltype_i^\ast`,
+  * :math:`C.\CGLOBALS` is :math:`\etglobals(\externtype_i^\ast)` concatenated with :math:`\globaltype_i^\ast`,
     with the type sequences :math:`\externtype_i^\ast` and :math:`\globaltype_i^\ast` as determined below.
 
-  * :math:`C.\LOCALS` is empty,
+  * :math:`C.\CLOCALS` is empty,
 
-  * :math:`C.\LABELS` is empty.
+  * :math:`C.\CLABELS` is empty.
 
-  * :math:`C.\LRETURN` is empty.
+  * :math:`C.\CRETURN` is empty.
+
+* Let :math:`C'` be the :ref:`context <context>` where :math:`C'.\CGLOBALS` is the sequence :math:`\etglobals(\externtype_i^\ast)` and all other fields are empty.
 
 * Under the context :math:`C`:
 
-  * For each :math:`\functype_i` in :math:`\module.\TYPES`,
+  * For each :math:`\functype_i` in :math:`\module.\MTYPES`,
     the :ref:`function type <syntax-functype>` :math:`\functype_i` must be :ref:`valid <valid-functype>`.
 
-  * For each :math:`\func_i` in :math:`\module.\FUNCS`,
+  * For each :math:`\func_i` in :math:`\module.\MFUNCS`,
     the definition :math:`\func_i` must be :ref:`valid <valid-func>` with a :ref:`function type <syntax-functype>` :math:`\functype_i`.
 
-  * For each :math:`\table_i` in :math:`\module.\TABLES`,
+  * For each :math:`\table_i` in :math:`\module.\MTABLES`,
     the definition :math:`\table_i` must be :ref:`valid <valid-table>` with a :ref:`table type <syntax-tabletype>` :math:`\tabletype_i`.
 
-  * For each :math:`\mem_i` in :math:`\module.\MEMS`,
+  * For each :math:`\mem_i` in :math:`\module.\MMEMS`,
     the definition :math:`\mem_i` must be :ref:`valid <valid-mem>` with a :ref:`memory type <syntax-memtype>` :math:`\memtype_i`.
 
-  * For each :math:`\global_i` in :math:`\module.\GLOBALS`:
-
-    * Let :math:`C_i` be the :ref:`context <context>` where :math:`C_i.\GLOBALS` is the sequence :math:`\globals(\externtype_i^\ast)` concatenated with :math:`\globaltype_0~\dots~\globaltype_{i-1}`, and all other fields are empty.
+  * For each :math:`\global_i` in :math:`\module.\MGLOBALS`:
 
-    * Under the context :math:`C_i`,
+    * Under the context :math:`C'`,
       the definition :math:`\global_i` must be :ref:`valid <valid-global>` with a :ref:`global type <syntax-globaltype>` :math:`\globaltype_i`.
 
-  * For each :math:`\elem_i` in :math:`\module.\ELEM`,
+  * For each :math:`\elem_i` in :math:`\module.\MELEM`,
     the segment :math:`\elem_i` must be :ref:`valid <valid-elem>`.
 
-  * For each :math:`\data_i` in :math:`\module.\DATA`,
+  * For each :math:`\data_i` in :math:`\module.\MDATA`,
     the segment :math:`\elem_i` must be :ref:`valid <valid-data>`.
 
-  * If :math:`\module.\START` is non-empty,
-    then :math:`\module.\START` must be :ref:`valid <valid-start>`.
+  * If :math:`\module.\MSTART` is non-empty,
+    then :math:`\module.\MSTART` must be :ref:`valid <valid-start>`.
 
-  * For each :math:`\import_i` in :math:`\module.\IMPORTS`,
+  * For each :math:`\import_i` in :math:`\module.\MIMPORTS`,
     the segment :math:`\import_i` must be :ref:`valid <valid-import>` with an :ref:`external type <syntax-externtype>` :math:`\externtype_i`.
 
-  * For each :math:`\export_i` in :math:`\module.\EXPORTS`,
+  * For each :math:`\export_i` in :math:`\module.\MEXPORTS`,
     the segment :math:`\import_i` must be :ref:`valid <valid-export>` with a :ref:`name <syntax-name>` :math:`\name_i`.
 
-* The length of :math:`C.\TABLES` must not be larger than :math:`1`.
+* The length of :math:`C.\CTABLES` must not be larger than :math:`1`.
 
-* The length of :math:`C.\MEMS` must not be larger than :math:`1`.
+* The length of :math:`C.\CMEMS` must not be larger than :math:`1`.
 
 * All export names :math:`\name_i` must be different.
 
@@ -551,7 +510,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
 .. math::
    \frac{
      \begin{array}{@{}c@{}}
-     (\vdash \functype ~\F{ok})^\ast
+     (\vdash \functype \ok)^\ast
      \quad
      (C \vdash \func : \X{ft})^\ast
      \quad
@@ -561,47 +520,47 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \quad
      (C' \vdash \global : \X{gt})^\ast
      \\
-     (C \vdash \elem ~\F{ok})^\ast
+     (C \vdash \elem \ok)^\ast
      \quad
-     (C \vdash \data ~\F{ok})^\ast
+     (C \vdash \data \ok)^\ast
      \quad
-     (C \vdash \start ~\F{ok})^?
+     (C \vdash \start \ok)^?
      \quad
      (C \vdash \import : \X{it})^\ast
      \quad
      (C \vdash \export : \X{name})^\ast
      \\
-     \X{ift}^\ast = \funcs(\X{it}^\ast)
+     \X{ift}^\ast = \etfuncs(\X{it}^\ast)
      \qquad
-     \X{itt}^\ast = \tables(\X{it}^\ast)
+     \X{itt}^\ast = \ettables(\X{it}^\ast)
      \qquad
-     \X{imt}^\ast = \mems(\X{it}^\ast)
+     \X{imt}^\ast = \etmems(\X{it}^\ast)
      \qquad
-     \X{igt}^\ast = \globals(\X{it}^\ast)
+     \X{igt}^\ast = \etglobals(\X{it}^\ast)
      \\
-     C = \{ \TYPES~\functype^\ast, \FUNCS~\X{ift}^\ast~\X{ft}^\ast, \TABLES~\X{itt}^\ast~\X{tt}^\ast, \MEMS~\X{imt}^\ast~\X{mt}^\ast, \GLOBALS~\X{igt}^\ast~\X{gt}^\ast \}
+     C = \{ \CTYPES~\functype^\ast, \CFUNCS~\X{ift}^\ast~\X{ft}^\ast, \CTABLES~\X{itt}^\ast~\X{tt}^\ast, \CMEMS~\X{imt}^\ast~\X{mt}^\ast, \CGLOBALS~\X{igt}^\ast~\X{gt}^\ast \}
      \\
-     C' = \{ \GLOBALS~\X{igt}^\ast \}
+     C' = \{ \CGLOBALS~\X{igt}^\ast \}
      \qquad
-     |C.\TABLES| \leq 1
+     |C.\CTABLES| \leq 1
      \qquad
-     |C.\MEMS| \leq 1
+     |C.\CMEMS| \leq 1
      \qquad
      \name^\ast ~\F{disjoint}
      \end{array}
    }{
      \vdash \{
        \begin{array}[t]{@{}l@{}}
-         \TYPES~\functype^\ast,
-         \FUNCS~\func^\ast,
-         \TABLES~\table^\ast,
-         \MEMS~\mem^\ast,
-         \GLOBALS~\global^\ast, \\
-         \ELEM~\elem^\ast,
-         \DATA~\data^\ast,
-         \START~\start^?,
-         \IMPORTS~\import^\ast,
-         \EXPORTS~\export^\ast \} : \X{it}^\ast \\
+         \MTYPES~\functype^\ast,
+         \MFUNCS~\func^\ast,
+         \MTABLES~\table^\ast,
+         \MMEMS~\mem^\ast,
+         \MGLOBALS~\global^\ast, \\
+         \MELEM~\elem^\ast,
+         \MDATA~\data^\ast,
+         \MSTART~\start^?,
+         \MIMPORTS~\import^\ast,
+         \MEXPORTS~\export^\ast \} : \X{it}^\ast \\
        \end{array}
    }
 
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
new file mode 100644
index 000000000..b30008e7c
--- /dev/null
+++ b/document/core/valid/types.rst
@@ -0,0 +1,57 @@
+Types
+-----
+
+Most :ref:`types <syntax-type>` are universally valid.
+However, restrictions apply to :ref:`function types <syntax-functype>` and :ref:`limits <syntax-limits>`, which must be checked during validation.
+
+
+.. index:: function type
+   pair: validation; function type
+   single: abstract syntax; function type
+.. _valid-functype:
+
+Function Types
+~~~~~~~~~~~~~~
+
+:ref:`Function types <syntax-functype>` may not specify more than one result.
+
+:math:`[t_1^n] \to [t_2^m]`
+...........................
+
+* The arity :math:`m` must not be larger than :math:`1`.
+
+* Then the function type is valid.
+
+.. math::
+   \frac{
+   }{
+     \vdash [t_1^\ast] \to [t_2^?] \ok
+   }
+
+.. note::
+   This restriction may be removed in future versions of WebAssembly.
+
+
+.. index:: limits
+   pair: validation; limits
+   single: abstract syntax; limits
+.. _valid-limits:
+
+Limits
+~~~~~~
+
+:ref:`Limits <syntax-limits>` must have menaingful bounds.
+
+:math:`\{ \LMIN~n, \LMAX~m^? \}`
+................................
+
+* If the maximum :math:`m^?` is not empty, then its value must not be smaller than :math:`n`.
+
+* Then the limit is valid.
+
+.. math::
+   \frac{
+     (n \leq m)^?
+   }{
+     \vdash \{ \LMIN~n, \LMAX~m^? \} \ok
+   }

From b90b998c3eb7c31bab9fbcddc02af15a20fcc4b4 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 6 Jul 2017 15:32:31 +0200
Subject: [PATCH 054/329] [spec] Update instruction index (#520)

---
 document/core/syntax/instrindex.rst | 347 ++++++++++++++--------------
 1 file changed, 174 insertions(+), 173 deletions(-)

diff --git a/document/core/syntax/instrindex.rst b/document/core/syntax/instrindex.rst
index 1f0076dbd..d6230dbb2 100644
--- a/document/core/syntax/instrindex.rst
+++ b/document/core/syntax/instrindex.rst
@@ -3,14 +3,14 @@
 Index of Instructions
 ---------------------
 
-===================================  ================  ==========================================  ========================================  ================
+===================================  ================  ==========================================  ========================================  ===============================================================
 Instruction                          Opcode            Type                                        Validation                                Execution
-===================================  ================  ==========================================  ========================================  ================
-:math:`\UNREACHABLE`                 :math:`\hex{00}`  :math:`[t_1^\ast] \to [t_2^\ast]`           :ref:`validation <valid-unreachable>`
-:math:`\NOP`                         :math:`\hex{01}`  :math:`[] \to []`                           :ref:`validation <valid-nop>`
-:math:`\BLOCK~[t^?]`                 :math:`\hex{02}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-block>`
-:math:`\LOOP~[t^?]`                  :math:`\hex{03}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-loop>`
-:math:`\IF~[t^?]`                    :math:`\hex{04}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-if>`
+===================================  ================  ==========================================  ========================================  ===============================================================
+:math:`\UNREACHABLE`                 :math:`\hex{00}`  :math:`[t_1^\ast] \to [t_2^\ast]`           :ref:`validation <valid-unreachable>`     :ref:`execution <exec-unreachable>`
+:math:`\NOP`                         :math:`\hex{01}`  :math:`[] \to []`                           :ref:`validation <valid-nop>`             :ref:`execution <exec-nop>`
+:math:`\BLOCK~[t^?]`                 :math:`\hex{02}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-block>`           :ref:`execution <exec-block>`
+:math:`\LOOP~[t^?]`                  :math:`\hex{03}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-loop>`            :ref:`execution <exec-loop>`
+:math:`\IF~[t^?]`                    :math:`\hex{04}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-if>`              :ref:`execution <exec-if>`
 :math:`\ELSE`                        :math:`\hex{05}`                                                
 (reserved)                           :math:`\hex{06}`                                                  
 (reserved)                           :math:`\hex{07}`                                                  
@@ -18,12 +18,12 @@ Instruction                          Opcode            Type
 (reserved)                           :math:`\hex{09}`                                                  
 (reserved)                           :math:`\hex{0A}`                                                  
 :math:`\END`                         :math:`\hex{0B}`                                                  
-:math:`\BR~l`                        :math:`\hex{0C}`  :math:`[t_1^\ast~t^?] \to [t_2^\ast]`       :ref:`validation <valid-br>`
-:math:`\BRIF~l`                      :math:`\hex{0D}`  :math:`[t^?~\I32] \to [t^?]`                :ref:`validation <valid-br_if>`
-:math:`\BRTABLE~l^\ast~l`            :math:`\hex{0E}`  :math:`[t_1^\ast~t^?~\I32] \to [t_2^\ast]`  :ref:`validation <valid-br_table>`
-:math:`\RETURN`                      :math:`\hex{0F}`  :math:`[t_1^\ast~t^?] \to [t_2^\ast]`       :ref:`validation <valid-return>`
-:math:`\CALL~x`                      :math:`\hex{10}`  :math:`[t_1^\ast] \to [t_2^\ast]`           :ref:`validation <valid-call>`
-:math:`\CALLINDIRECT~x`              :math:`\hex{11}`  :math:`[t_1^\ast~\I32] \to [t_2^\ast]`      :ref:`validation <valid-call_indirect>`
+:math:`\BR~l`                        :math:`\hex{0C}`  :math:`[t_1^\ast~t^?] \to [t_2^\ast]`       :ref:`validation <valid-br>`              :ref:`execution <exec-br>`
+:math:`\BRIF~l`                      :math:`\hex{0D}`  :math:`[t^?~\I32] \to [t^?]`                :ref:`validation <valid-br_if>`           :ref:`execution <exec-br_if>`
+:math:`\BRTABLE~l^\ast~l`            :math:`\hex{0E}`  :math:`[t_1^\ast~t^?~\I32] \to [t_2^\ast]`  :ref:`validation <valid-br_table>`        :ref:`execution <exec-br_table>`
+:math:`\RETURN`                      :math:`\hex{0F}`  :math:`[t_1^\ast~t^?] \to [t_2^\ast]`       :ref:`validation <valid-return>`          :ref:`execution <exec-return>`
+:math:`\CALL~x`                      :math:`\hex{10}`  :math:`[t_1^\ast] \to [t_2^\ast]`           :ref:`validation <valid-call>`            :ref:`execution <exec-call>`
+:math:`\CALLINDIRECT~x`              :math:`\hex{11}`  :math:`[t_1^\ast~\I32] \to [t_2^\ast]`      :ref:`validation <valid-call_indirect>`   :ref:`execution <exec-call_indirect>`
 (reserved)                           :math:`\hex{12}`                                                  
 (reserved)                           :math:`\hex{13}`                                                  
 (reserved)                           :math:`\hex{14}`                                                  
@@ -32,170 +32,171 @@ Instruction                          Opcode            Type
 (reserved)                           :math:`\hex{17}`                                                  
 (reserved)                           :math:`\hex{18}`                                                  
 (reserved)                           :math:`\hex{19}`                                                  
-:math:`\DROP`                        :math:`\hex{1A}`  :math:`[t] \to []`                          :ref:`validation <valid-drop>`
-:math:`\SELECT`                      :math:`\hex{1B}`  :math:`[t~t~\I32] \to [t]`                  :ref:`validation <valid-select>`
+:math:`\DROP`                        :math:`\hex{1A}`  :math:`[t] \to []`                          :ref:`validation <valid-drop>`            :ref:`execution <exec-drop>`
+:math:`\SELECT`                      :math:`\hex{1B}`  :math:`[t~t~\I32] \to [t]`                  :ref:`validation <valid-select>`          :ref:`execution <exec-select>`
 (reserved)                           :math:`\hex{1C}`                                                  
 (reserved)                           :math:`\hex{1D}`                                                  
 (reserved)                           :math:`\hex{1E}`                                                  
 (reserved)                           :math:`\hex{1F}`                                                  
-:math:`\GETLOCAL~x`                  :math:`\hex{20}`  :math:`[] \to [t]`                          :ref:`validation <valid-get_local>`
-:math:`\SETLOCAL~x`                  :math:`\hex{21}`  :math:`[t] \to []`                          :ref:`validation <valid-set_local>`
-:math:`\TEELOCAL~x`                  :math:`\hex{22}`  :math:`[t] \to [t]`                         :ref:`validation <valid-tee_local>`
-:math:`\GETGLOBAL~x`                 :math:`\hex{23}`  :math:`[] \to [t]`                          :ref:`validation <valid-get_global>`
-:math:`\SETGLOBAL~x`                 :math:`\hex{24}`  :math:`[t] \to []`                          :ref:`validation <valid-set_global>`
+:math:`\GETLOCAL~x`                  :math:`\hex{20}`  :math:`[] \to [t]`                          :ref:`validation <valid-get_local>`       :ref:`execution <exec-get_local>`
+:math:`\SETLOCAL~x`                  :math:`\hex{21}`  :math:`[t] \to []`                          :ref:`validation <valid-set_local>`       :ref:`execution <exec-set_local>`
+:math:`\TEELOCAL~x`                  :math:`\hex{22}`  :math:`[t] \to [t]`                         :ref:`validation <valid-tee_local>`       :ref:`execution <exec-tee_local>`
+:math:`\GETGLOBAL~x`                 :math:`\hex{23}`  :math:`[] \to [t]`                          :ref:`validation <valid-get_global>`      :ref:`execution <exec-get_global>`
+:math:`\SETGLOBAL~x`                 :math:`\hex{24}`  :math:`[t] \to []`                          :ref:`validation <valid-set_global>`      :ref:`execution <exec-set_global>`
 (reserved)                           :math:`\hex{25}`                                                  
 (reserved)                           :math:`\hex{26}`                                                  
 (reserved)                           :math:`\hex{27}`                                                  
-:math:`\I32.\LOAD~\memarg`           :math:`\hex{28}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-load>`
-:math:`\I64.\LOAD~\memarg`           :math:`\hex{29}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-load>`
-:math:`\F32.\LOAD~\memarg`           :math:`\hex{2A}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-load>`
-:math:`\F64.\LOAD~\memarg`           :math:`\hex{2B}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-load>`
-:math:`\I32.\LOAD\K{8\_s}~\memarg`   :math:`\hex{2C}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`
-:math:`\I32.\LOAD\K{8\_u}~\memarg`   :math:`\hex{2D}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`
-:math:`\I32.\LOAD\K{16\_s}~\memarg`  :math:`\hex{2E}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`
-:math:`\I32.\LOAD\K{16\_u}~\memarg`  :math:`\hex{2F}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`
-:math:`\I64.\LOAD\K{8\_s}~\memarg`   :math:`\hex{30}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`
-:math:`\I64.\LOAD\K{8\_u}~\memarg`   :math:`\hex{31}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`
-:math:`\I64.\LOAD\K{16\_s}~\memarg`  :math:`\hex{32}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`
-:math:`\I64.\LOAD\K{16\_u}~\memarg`  :math:`\hex{33}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`
-:math:`\I64.\LOAD\K{32\_s}~\memarg`  :math:`\hex{34}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`
-:math:`\I64.\LOAD\K{32\_u}~\memarg`  :math:`\hex{35}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`
-:math:`\I32.\STORE~\memarg`          :math:`\hex{36}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-store>`
-:math:`\I64.\STORE~\memarg`          :math:`\hex{37}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-store>`
-:math:`\F32.\STORE~\memarg`          :math:`\hex{38}`  :math:`[\I32~\F32] \to []`                  :ref:`validation <valid-store>`
-:math:`\F64.\STORE~\memarg`          :math:`\hex{39}`  :math:`[\I32~\F64] \to []`                  :ref:`validation <valid-store>`
-:math:`\I32.\STORE\K{8}~\memarg`     :math:`\hex{3A}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-storen>`
-:math:`\I32.\STORE\K{16}~\memarg`    :math:`\hex{3B}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-storen>`
-:math:`\I64.\STORE\K{8}~\memarg`     :math:`\hex{3C}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`
-:math:`\I64.\STORE\K{16}~\memarg`    :math:`\hex{3D}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`
-:math:`\I64.\STORE\K{32}~\memarg`    :math:`\hex{3E}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`
-:math:`\CURRENTMEMORY`               :math:`\hex{3F}`  :math:`[] \to [\I32]`                       :ref:`validation <valid-current_memory>`
-:math:`\GROWMEMORY`                  :math:`\hex{40}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-grow_memory>`
-:math:`\I32.\CONST~\i32`             :math:`\hex{41}`  :math:`[] \to [\I32]`                       :ref:`validation <valid-const>`
-:math:`\I64.\CONST~\i64`             :math:`\hex{42}`  :math:`[] \to [\I64]`                       :ref:`validation <valid-const>`
-:math:`\F32.\CONST~\f32`             :math:`\hex{43}`  :math:`[] \to [\F32]`                       :ref:`validation <valid-const>`
-:math:`\F64.\CONST~\f64`             :math:`\hex{44}`  :math:`[] \to [\F64]`                       :ref:`validation <valid-const>`
-:math:`\I32.\EQZ`                    :math:`\hex{45}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-testop>`
-:math:`\I32.\EQ`                     :math:`\hex{46}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I32.\NE`                     :math:`\hex{47}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I32.\LT\K{\_s}`              :math:`\hex{48}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I32.\LT\K{\_u}`              :math:`\hex{49}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I32.\GT\K{\_s}`              :math:`\hex{4A}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I32.\GT\K{\_u}`              :math:`\hex{4B}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I32.\LE\K{\_s}`              :math:`\hex{4C}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I32.\LE\K{\_u}`              :math:`\hex{4D}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I32.\GE\K{\_s}`              :math:`\hex{4E}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I32.\GE\K{\_u}`              :math:`\hex{4F}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I64.\EQZ`                    :math:`\hex{50}`  :math:`[\I64] \to [\I32]`                   :ref:`validation <valid-testop>`
-:math:`\I64.\EQ`                     :math:`\hex{51}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I64.\NE`                     :math:`\hex{52}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I64.\LT\K{\_s}`              :math:`\hex{53}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I64.\LT\K{\_u}`              :math:`\hex{54}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I64.\GT\K{\_s}`              :math:`\hex{55}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I64.\GT\K{\_u}`              :math:`\hex{56}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I64.\LE\K{\_s}`              :math:`\hex{57}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I64.\LE\K{\_u}`              :math:`\hex{58}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I64.\GE\K{\_s}`              :math:`\hex{59}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I64.\GE\K{\_u}`              :math:`\hex{5A}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F32.\EQ`                     :math:`\hex{5B}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F32.\NE`                     :math:`\hex{5C}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F32.\LT`                     :math:`\hex{5D}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F32.\GT`                     :math:`\hex{5E}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F32.\LE`                     :math:`\hex{5F}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F32.\GE`                     :math:`\hex{60}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F64.\EQ`                     :math:`\hex{61}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F64.\NE`                     :math:`\hex{62}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F64.\LT`                     :math:`\hex{63}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F64.\GT`                     :math:`\hex{64}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F64.\LE`                     :math:`\hex{65}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\F64.\GE`                     :math:`\hex{66}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`
-:math:`\I32.\CLZ`                    :math:`\hex{67}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`
-:math:`\I32.\CTZ`                    :math:`\hex{68}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`
-:math:`\I32.\POPCNT`                 :math:`\hex{69}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`
-:math:`\I32.\ADD`                    :math:`\hex{6A}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\SUB`                    :math:`\hex{6B}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\MUL`                    :math:`\hex{6C}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\DIV\K{\_s}`             :math:`\hex{6D}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\DIV\K{\_u}`             :math:`\hex{6E}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\REM\K{\_s}`             :math:`\hex{6F}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\REM\K{\_u}`             :math:`\hex{70}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\AND`                    :math:`\hex{71}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\OR`                     :math:`\hex{72}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\XOR`                    :math:`\hex{73}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\SHL`                    :math:`\hex{74}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\SHR\K{\_s}`             :math:`\hex{75}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\SHR\K{\_u}`             :math:`\hex{76}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\ROTL`                   :math:`\hex{77}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I32.\ROTR`                   :math:`\hex{78}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`
-:math:`\I64.\CLZ`                    :math:`\hex{79}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`
-:math:`\I64.\CTZ`                    :math:`\hex{7A}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`
-:math:`\I64.\POPCNT`                 :math:`\hex{7B}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`
-:math:`\I64.\ADD`                    :math:`\hex{7C}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\SUB`                    :math:`\hex{7D}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\MUL`                    :math:`\hex{7E}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\DIV\K{\_s}`             :math:`\hex{7F}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\DIV\K{\_u}`             :math:`\hex{80}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\REM\K{\_s}`             :math:`\hex{81}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\REM\K{\_u}`             :math:`\hex{82}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\AND`                    :math:`\hex{83}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\OR`                     :math:`\hex{84}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\XOR`                    :math:`\hex{85}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\SHL`                    :math:`\hex{86}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\SHR\K{\_s}`             :math:`\hex{87}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\SHR\K{\_u}`             :math:`\hex{88}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\ROTL`                   :math:`\hex{89}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\I64.\ROTR`                   :math:`\hex{8A}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`
-:math:`\F32.\ABS`                    :math:`\hex{8B}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`
-:math:`\F32.\NEG`                    :math:`\hex{8C}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`
-:math:`\F32.\CEIL`                   :math:`\hex{8D}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`
-:math:`\F32.\FLOOR`                  :math:`\hex{8E}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`
-:math:`\F32.\TRUNC`                  :math:`\hex{8F}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`
-:math:`\F32.\NEAREST`                :math:`\hex{90}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`
-:math:`\F32.\SQRT`                   :math:`\hex{91}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`
-:math:`\F32.\ADD`                    :math:`\hex{92}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`
-:math:`\F32.\SUB`                    :math:`\hex{93}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`
-:math:`\F32.\MUL`                    :math:`\hex{94}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`
-:math:`\F32.\DIV`                    :math:`\hex{95}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`
-:math:`\F32.\FMIN`                   :math:`\hex{96}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`
-:math:`\F32.\FMAX`                   :math:`\hex{97}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`
-:math:`\F32.\COPYSIGN`               :math:`\hex{98}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`
-:math:`\F64.\ABS`                    :math:`\hex{99}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`
-:math:`\F64.\NEG`                    :math:`\hex{9A}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`
-:math:`\F64.\CEIL`                   :math:`\hex{9B}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`
-:math:`\F64.\FLOOR`                  :math:`\hex{9C}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`
-:math:`\F64.\TRUNC`                  :math:`\hex{9D}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`
-:math:`\F64.\NEAREST`                :math:`\hex{9E}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`
-:math:`\F64.\SQRT`                   :math:`\hex{9F}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`
-:math:`\F64.\ADD`                    :math:`\hex{A0}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`
-:math:`\F64.\SUB`                    :math:`\hex{A1}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`
-:math:`\F64.\MUL`                    :math:`\hex{A2}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`
-:math:`\F64.\DIV`                    :math:`\hex{A3}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`
-:math:`\F64.\FMIN`                   :math:`\hex{A4}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`
-:math:`\F64.\FMAX`                   :math:`\hex{A5}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`
-:math:`\F64.\COPYSIGN`               :math:`\hex{A6}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`
-:math:`\I32.\WRAP\K{/}\I64`          :math:`\hex{A7}`  :math:`[\I64] \to [\I32]`                   :ref:`validation <valid-cvtop>`
-:math:`\I32.\TRUNC\K{\_s/}\F32`      :math:`\hex{A8}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`
-:math:`\I32.\TRUNC\K{\_u/}\F32`      :math:`\hex{A9}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`
-:math:`\I32.\TRUNC\K{\_s/}\F64`      :math:`\hex{AA}`  :math:`[\F64] \to [\I32]`                   :ref:`validation <valid-cvtop>`
-:math:`\I32.\TRUNC\K{\_u/}\F64`      :math:`\hex{AB}`  :math:`[\F64] \to [\I32]`                   :ref:`validation <valid-cvtop>`
-:math:`\I64.\EXTEND\K{\_s/}\I32`     :math:`\hex{AC}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-cvtop>`
-:math:`\I64.\EXTEND\K{\_u/}\I32`     :math:`\hex{AD}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-cvtop>`
-:math:`\I64.\TRUNC\K{\_s/}\F32`      :math:`\hex{AE}`  :math:`[\F32] \to [\I64]`                   :ref:`validation <valid-cvtop>`
-:math:`\I64.\TRUNC\K{\_u/}\F32`      :math:`\hex{AF}`  :math:`[\F32] \to [\I64]`                   :ref:`validation <valid-cvtop>`
-:math:`\I64.\TRUNC\K{\_s/}\F64`      :math:`\hex{B0}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`
-:math:`\I64.\TRUNC\K{\_u/}\F64`      :math:`\hex{B1}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`
-:math:`\F32.\CONVERT\K{\_s/}\I32`    :math:`\hex{B2}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`
-:math:`\F32.\CONVERT\K{\_u/}\I32`    :math:`\hex{B3}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`
-:math:`\F32.\CONVERT\K{\_s/}\I64`    :math:`\hex{B4}`  :math:`[\I64] \to [\F32]`                   :ref:`validation <valid-cvtop>`
-:math:`\F32.\CONVERT\K{\_u/}\I64`    :math:`\hex{B5}`  :math:`[\I64] \to [\F32]`                   :ref:`validation <valid-cvtop>`
-:math:`\F32.\DEMOTE\K{/}\F64`        :math:`\hex{B6}`  :math:`[\F64] \to [\F32]`                   :ref:`validation <valid-cvtop>`
-:math:`\F64.\CONVERT\K{\_s/}\I32`    :math:`\hex{B7}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-cvtop>`
-:math:`\F64.\CONVERT\K{\_u/}\I32`    :math:`\hex{B8}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-cvtop>`
-:math:`\F64.\CONVERT\K{\_s/}\I64`    :math:`\hex{B9}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`
-:math:`\F64.\CONVERT\K{\_u/}\I64`    :math:`\hex{BA}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`
-:math:`\F64.\PROMOTE\K{/}\F32`       :math:`\hex{BB}`  :math:`[\F32] \to [\F64]`                   :ref:`validation <valid-cvtop>`
-:math:`\I32.\REINTERPRET\K{/}\F32`   :math:`\hex{BC}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`
-:math:`\I64.\REINTERPRET\K{/}\F64`   :math:`\hex{BD}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`
-:math:`\F32.\REINTERPRET\K{/}\I32`   :math:`\hex{BE}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`
-:math:`\F64.\REINTERPRET\K{/}\I64`   :math:`\hex{BF}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`
-===================================  ================  ==========================================  ========================================  ================
+:math:`\I32.\LOAD~\memarg`           :math:`\hex{28}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
+:math:`\I64.\LOAD~\memarg`           :math:`\hex{29}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
+:math:`\F32.\LOAD~\memarg`           :math:`\hex{2A}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
+:math:`\F64.\LOAD~\memarg`           :math:`\hex{2B}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
+:math:`\I32.\LOAD\K{8\_s}~\memarg`   :math:`\hex{2C}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I32.\LOAD\K{8\_u}~\memarg`   :math:`\hex{2D}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I32.\LOAD\K{16\_s}~\memarg`  :math:`\hex{2E}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I32.\LOAD\K{16\_u}~\memarg`  :math:`\hex{2F}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{8\_s}~\memarg`   :math:`\hex{30}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{8\_u}~\memarg`   :math:`\hex{31}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{16\_s}~\memarg`  :math:`\hex{32}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{16\_u}~\memarg`  :math:`\hex{33}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{32\_s}~\memarg`  :math:`\hex{34}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{32\_u}~\memarg`  :math:`\hex{35}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I32.\STORE~\memarg`          :math:`\hex{36}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
+:math:`\I64.\STORE~\memarg`          :math:`\hex{37}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
+:math:`\F32.\STORE~\memarg`          :math:`\hex{38}`  :math:`[\I32~\F32] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
+:math:`\F64.\STORE~\memarg`          :math:`\hex{39}`  :math:`[\I32~\F64] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
+:math:`\I32.\STORE\K{8}~\memarg`     :math:`\hex{3A}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
+:math:`\I32.\STORE\K{16}~\memarg`    :math:`\hex{3B}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
+:math:`\I64.\STORE\K{8}~\memarg`     :math:`\hex{3C}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
+:math:`\I64.\STORE\K{16}~\memarg`    :math:`\hex{3D}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
+:math:`\I64.\STORE\K{32}~\memarg`    :math:`\hex{3E}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
+:math:`\CURRENTMEMORY`               :math:`\hex{3F}`  :math:`[] \to [\I32]`                       :ref:`validation <valid-current_memory>`  :ref:`execution <exec-current_memory>`
+:math:`\GROWMEMORY`                  :math:`\hex{40}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-grow_memory>`     :ref:`execution <exec-grow_memory>`
+:math:`\I32.\CONST~\i32`             :math:`\hex{41}`  :math:`[] \to [\I32]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
+:math:`\I64.\CONST~\i64`             :math:`\hex{42}`  :math:`[] \to [\I64]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
+:math:`\F32.\CONST~\f32`             :math:`\hex{43}`  :math:`[] \to [\F32]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
+:math:`\F64.\CONST~\f64`             :math:`\hex{44}`  :math:`[] \to [\F64]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
+:math:`\I32.\EQZ`                    :math:`\hex{45}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-testop>`          :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`
+:math:`\I32.\EQ`                     :math:`\hex{46}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`
+:math:`\I32.\NE`                     :math:`\hex{47}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`
+:math:`\I32.\LT\K{\_s}`              :math:`\hex{48}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`
+:math:`\I32.\LT\K{\_u}`              :math:`\hex{49}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`
+:math:`\I32.\GT\K{\_s}`              :math:`\hex{4A}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`
+:math:`\I32.\GT\K{\_u}`              :math:`\hex{4B}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`
+:math:`\I32.\LE\K{\_s}`              :math:`\hex{4C}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`
+:math:`\I32.\LE\K{\_u}`              :math:`\hex{4D}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`
+:math:`\I32.\GE\K{\_s}`              :math:`\hex{4E}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`
+:math:`\I32.\GE\K{\_u}`              :math:`\hex{4F}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`
+:math:`\I64.\EQZ`                    :math:`\hex{50}`  :math:`[\I64] \to [\I32]`                   :ref:`validation <valid-testop>`          :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`
+:math:`\I64.\EQ`                     :math:`\hex{51}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`
+:math:`\I64.\NE`                     :math:`\hex{52}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`
+:math:`\I64.\LT\K{\_s}`              :math:`\hex{53}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`
+:math:`\I64.\LT\K{\_u}`              :math:`\hex{54}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`
+:math:`\I64.\GT\K{\_s}`              :math:`\hex{55}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`
+:math:`\I64.\GT\K{\_u}`              :math:`\hex{56}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`
+:math:`\I64.\LE\K{\_s}`              :math:`\hex{57}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`
+:math:`\I64.\LE\K{\_u}`              :math:`\hex{58}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`
+:math:`\I64.\GE\K{\_s}`              :math:`\hex{59}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`
+:math:`\I64.\GE\K{\_u}`              :math:`\hex{5A}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`
+:math:`\F32.\EQ`                     :math:`\hex{5B}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`
+:math:`\F32.\NE`                     :math:`\hex{5C}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`
+:math:`\F32.\LT`                     :math:`\hex{5D}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`
+:math:`\F32.\GT`                     :math:`\hex{5E}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`
+:math:`\F32.\LE`                     :math:`\hex{5F}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`
+:math:`\F32.\GE`                     :math:`\hex{60}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`
+:math:`\F64.\EQ`                     :math:`\hex{61}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`
+:math:`\F64.\NE`                     :math:`\hex{62}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`
+:math:`\F64.\LT`                     :math:`\hex{63}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`
+:math:`\F64.\GT`                     :math:`\hex{64}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`
+:math:`\F64.\LE`                     :math:`\hex{65}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`
+:math:`\F64.\GE`                     :math:`\hex{66}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`
+:math:`\I32.\CLZ`                    :math:`\hex{67}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`
+:math:`\I32.\CTZ`                    :math:`\hex{68}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`
+:math:`\I32.\POPCNT`                 :math:`\hex{69}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`
+:math:`\I32.\ADD`                    :math:`\hex{6A}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`
+:math:`\I32.\SUB`                    :math:`\hex{6B}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`
+:math:`\I32.\MUL`                    :math:`\hex{6C}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`
+:math:`\I32.\DIV\K{\_s}`             :math:`\hex{6D}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`
+:math:`\I32.\DIV\K{\_u}`             :math:`\hex{6E}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`
+:math:`\I32.\REM\K{\_s}`             :math:`\hex{6F}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`
+:math:`\I32.\REM\K{\_u}`             :math:`\hex{70}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`
+:math:`\I32.\AND`                    :math:`\hex{71}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`
+:math:`\I32.\OR`                     :math:`\hex{72}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`
+:math:`\I32.\XOR`                    :math:`\hex{73}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`
+:math:`\I32.\SHL`                    :math:`\hex{74}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`
+:math:`\I32.\SHR\K{\_s}`             :math:`\hex{75}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`
+:math:`\I32.\SHR\K{\_u}`             :math:`\hex{76}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`
+:math:`\I32.\ROTL`                   :math:`\hex{77}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`
+:math:`\I32.\ROTR`                   :math:`\hex{78}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`
+:math:`\I64.\CLZ`                    :math:`\hex{79}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`
+:math:`\I64.\CTZ`                    :math:`\hex{7A}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`
+:math:`\I64.\POPCNT`                 :math:`\hex{7B}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`
+:math:`\I64.\ADD`                    :math:`\hex{7C}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`
+:math:`\I64.\SUB`                    :math:`\hex{7D}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`
+:math:`\I64.\MUL`                    :math:`\hex{7E}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`
+:math:`\I64.\DIV\K{\_s}`             :math:`\hex{7F}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`
+:math:`\I64.\DIV\K{\_u}`             :math:`\hex{80}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`
+:math:`\I64.\REM\K{\_s}`             :math:`\hex{81}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`
+:math:`\I64.\REM\K{\_u}`             :math:`\hex{82}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`
+:math:`\I64.\AND`                    :math:`\hex{83}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`
+:math:`\I64.\OR`                     :math:`\hex{84}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`
+:math:`\I64.\XOR`                    :math:`\hex{85}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`
+:math:`\I64.\SHL`                    :math:`\hex{86}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`
+:math:`\I64.\SHR\K{\_s}`             :math:`\hex{87}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`
+:math:`\I64.\SHR\K{\_u}`             :math:`\hex{88}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`
+:math:`\I64.\ROTL`                   :math:`\hex{89}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`
+:math:`\I64.\ROTR`                   :math:`\hex{8A}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`
+:math:`\F32.\ABS`                    :math:`\hex{8B}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`
+:math:`\F32.\NEG`                    :math:`\hex{8C}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`
+:math:`\F32.\CEIL`                   :math:`\hex{8D}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`
+:math:`\F32.\FLOOR`                  :math:`\hex{8E}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`
+:math:`\F32.\TRUNC`                  :math:`\hex{8F}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`
+:math:`\F32.\NEAREST`                :math:`\hex{90}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`
+:math:`\F32.\SQRT`                   :math:`\hex{91}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`
+:math:`\F32.\ADD`                    :math:`\hex{92}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`
+:math:`\F32.\SUB`                    :math:`\hex{93}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`
+:math:`\F32.\MUL`                    :math:`\hex{94}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`
+:math:`\F32.\DIV`                    :math:`\hex{95}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`
+:math:`\F32.\FMIN`                   :math:`\hex{96}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`
+:math:`\F32.\FMAX`                   :math:`\hex{97}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`
+:math:`\F32.\COPYSIGN`               :math:`\hex{98}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`
+:math:`\F64.\ABS`                    :math:`\hex{99}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`
+:math:`\F64.\NEG`                    :math:`\hex{9A}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`
+:math:`\F64.\CEIL`                   :math:`\hex{9B}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`
+:math:`\F64.\FLOOR`                  :math:`\hex{9C}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`
+:math:`\F64.\TRUNC`                  :math:`\hex{9D}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`
+:math:`\F64.\NEAREST`                :math:`\hex{9E}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`
+:math:`\F64.\SQRT`                   :math:`\hex{9F}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`
+:math:`\F64.\ADD`                    :math:`\hex{A0}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`
+:math:`\F64.\SUB`                    :math:`\hex{A1}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`
+:math:`\F64.\MUL`                    :math:`\hex{A2}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`
+:math:`\F64.\DIV`                    :math:`\hex{A3}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`
+:math:`\F64.\FMIN`                   :math:`\hex{A4}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`
+:math:`\F64.\FMAX`                   :math:`\hex{A5}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`
+:math:`\F64.\COPYSIGN`               :math:`\hex{A6}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`
+:math:`\I32.\WRAP\K{/}\I64`          :math:`\hex{A7}`  :math:`[\I64] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`
+:math:`\I32.\TRUNC\K{\_s/}\F32`      :math:`\hex{A8}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
+:math:`\I32.\TRUNC\K{\_u/}\F32`      :math:`\hex{A9}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
+:math:`\I32.\TRUNC\K{\_s/}\F64`      :math:`\hex{AA}`  :math:`[\F64] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
+:math:`\I32.\TRUNC\K{\_u/}\F64`      :math:`\hex{AB}`  :math:`[\F64] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
+:math:`\I64.\EXTEND\K{\_s/}\I32`     :math:`\hex{AC}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`
+:math:`\I64.\EXTEND\K{\_u/}\I32`     :math:`\hex{AD}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`
+:math:`\I64.\TRUNC\K{\_s/}\F32`      :math:`\hex{AE}`  :math:`[\F32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
+:math:`\I64.\TRUNC\K{\_u/}\F32`      :math:`\hex{AF}`  :math:`[\F32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
+:math:`\I64.\TRUNC\K{\_s/}\F64`      :math:`\hex{B0}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
+:math:`\I64.\TRUNC\K{\_u/}\F64`      :math:`\hex{B1}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
+:math:`\F32.\CONVERT\K{\_s/}\I32`    :math:`\hex{B2}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
+:math:`\F32.\CONVERT\K{\_u/}\I32`    :math:`\hex{B3}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
+:math:`\F32.\CONVERT\K{\_s/}\I64`    :math:`\hex{B4}`  :math:`[\I64] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
+:math:`\F32.\CONVERT\K{\_u/}\I64`    :math:`\hex{B5}`  :math:`[\I64] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
+:math:`\F32.\DEMOTE\K{/}\F64`        :math:`\hex{B6}`  :math:`[\F64] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`
+:math:`\F64.\CONVERT\K{\_s/}\I32`    :math:`\hex{B7}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
+:math:`\F64.\CONVERT\K{\_u/}\I32`    :math:`\hex{B8}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
+:math:`\F64.\CONVERT\K{\_s/}\I64`    :math:`\hex{B9}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
+:math:`\F64.\CONVERT\K{\_u/}\I64`    :math:`\hex{BA}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
+:math:`\F64.\PROMOTE\K{/}\F32`       :math:`\hex{BB}`  :math:`[\F32] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`
+:math:`\I32.\REINTERPRET\K{/}\F32`   :math:`\hex{BC}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\I64.\REINTERPRET\K{/}\F64`   :math:`\hex{BD}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\F32.\REINTERPRET\K{/}\I32`   :math:`\hex{BE}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\F64.\REINTERPRET\K{/}\I64`   :math:`\hex{BF}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+===================================  ================  ==========================================  ========================================  ===============================================================
+

From 8c86df898801cafd714b0a25dfca4efb7495ba59 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Sun, 9 Jul 2017 06:26:39 -0700
Subject: [PATCH 055/329] Update readme to reflect current status. (#521)

---
 README.md | 17 ++++++-----------
 1 file changed, 6 insertions(+), 11 deletions(-)

diff --git a/README.md b/README.md
index 4092be9ca..26d58a3a5 100644
--- a/README.md
+++ b/README.md
@@ -2,18 +2,13 @@
 
 # spec
 
-This repository holds a prototypical reference implementation for WebAssembly,
-which is currently serving as the official specification. Eventually, we expect
-to produce a specification either written in human-readable prose or in a formal
-specification language.
+This repository holds the sources for the WebAssembly draft specification
+(to seed a future
+[WebAssembly Working Group](https://lists.w3.org/Archives/Public/public-new-work/2017Jun/0005.html)),
+a reference implementation, and the official testsuite.
 
-It also holds the WebAssembly testsuite, which tests numerous aspects of
-conformance to the spec.
-
-View the work-in-progress spec at [webassembly.github.io/spec](https://webassembly.github.io/spec/).
-
-At this time, the contents of this repository are under development and known
-to be "incomplet and inkorrect".
+A formatted version of the spec is available here:
+[webassembly.github.io/spec](https://webassembly.github.io/spec/),
 
 Participation is welcome. Discussions about new features, significant semantic
 changes, or any specification change likely to generate substantial discussion

From a5b02a4ad215f01ccce8b1e60714b1389a8c98a1 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 20 Jul 2017 00:03:24 +0200
Subject: [PATCH 056/329] [spec] Explain validation algorithm (#523)

---
 document/core/appendix/algorithm.rst | 202 ++++++++++++++++++++++++++-
 document/core/conf.py                |   1 +
 document/core/util/pseudo-lexer.py   |  32 +++++
 document/core/valid/conventions.rst  |   2 +-
 4 files changed, 234 insertions(+), 3 deletions(-)
 create mode 100644 document/core/util/pseudo-lexer.py

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 48797273e..c358a4a66 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -1,6 +1,204 @@
+.. index:: validation, algorithm, instruction, module, binary format, opcode
+.. _algo-valid:
+
 Validation Algorithm
 --------------------
 
-.. todo::
+The specification of WebAssembly :ref:`validation <valid>` is purely *declarative*.
+It describes the constraints that must be met by a :ref:`module <valid-module>` or :ref:`instruction <valid-instr>` sequence to be valid.
+
+This section sketches the skeleton of a sound and complete *algorithm* for validating code, i.e., sequences of :ref:`instructions <syntax-instr>`, effectively.
+(Other aspects of validation are straightforward to implement.)
+
+In fact, the algorithm is expressed over the flat sequence of opcodes as occurring in the :ref:`binary format <binary>`, and performs only a single pass over it.
+Consequently, it can be integrated directly into a decoder.
+
+The algorithm is expressed in typed pseudo code whose semantics is intended to be self-explanatory.
+
+
+.. index:: value type, stack, label, frame, instruction
+
+Data Structures
+~~~~~~~~~~~~~~~
+
+The algorithm uses two separate stacks: the *operand stack* and the *control stack*.
+The former tracks the :ref:`types <syntax-valtype>` of operand values on the :ref:`stack <stack>`,
+the latter surrounding :ref:`structured control instructions <syntax-instr-control>` and their associated :ref:`blocks <syntax-instr-control>`.
+
+.. code-block:: pseudo
+
+   type val_type = I32 | I64 | F32 | F64
+
+   type opd_stack = stack(val_type | Unknown)
+
+   type ctrl_stack = stack(ctrl_frame)
+   type ctrl_frame = {
+     label_types : list(val_type)
+     end_types : list(val_type)
+     height : nat
+     unreachable : bool
+   }
+
+For each value, the operand stack records its :ref:`value type <syntax-valtype>`, or :code:`Unknown` when the type is not known.
+
+For each entered block, the control stack records a *control frame* with the type of the associated :ref:`label <syntax-label>` (used to type-check branches), the result type of the block (used to check its result), the height of the operand stack at the start of the block (used to check that operands do not underflow the current block), and a flag recording whether the remainder of the block is unreachable (used to handle :ref:`stack-polymorphic <polymorphism>` typing after branches).
+
+.. note::
+   In the presentation of this algorithm, multiple values are supported for the :ref:`result types <syntax-resulttype>` classifying blocks and labels.
+   With the current version of WebAssembly, the :code:`list` could be simplified to an optional value.
+
+For the purpose of presenting the algorithm, the operand and control stacks are simply maintained as global variables:
+
+.. code-block:: pseudo
+
+   var opds : opd_stack
+   var ctrls : ctrl_stack
+
+However, these variables are not manipulated directly by the main checking function, but through a set of auxiliary functions:
+
+.. code-block:: pseudo
+
+   func push_opd(type : val_type | Unknown) =
+     opds.push(type)
+
+   func pop_opd() : val_type | Unknown =
+     if (opds.size() = ctrls[0].height && ctrls[0].unreachable) return Unknown
+     error_if(opds.size() = ctrls[0].height)
+     return opds.pop(type)
+
+   func pop_opd(expect : val_type | Unknown) : val_type | Unknown =
+     let actual = pop_opd()
+     if (actual = Unknown) return expect
+     if (expect = Unknown) return actual
+     error_if(actual =/= expect)
+     return actual
+
+   func push_opds(types : list(val_type)) = foreach (t in types) push_opd(t)
+   func pop_opds(types : list(val_type)) = foreach (t in reverse(types)) pop_opd(t)
+
+Pushing an operand simply pushes the respective type to the operand stack.
+
+Popping an operand checks that the operand stack does not underflow the current block and then removes one type.
+But first, a special case is handled where the block contains no known operands, but has been marked as unreachable.
+That can occur after an unconditional branch, when the stack is typed :ref:`polymorphically <polymorphism>`.
+In that case, an unknown type is returned.
+
+A second function for popping an operand takes an expected type, which the actual operand type is checked against.
+The types may differ in case one of them is Unknown.
+The more specific type is returned.
+
+Finally, there are accumulative functions for pushing or popping multiple operand types.
+
+.. note::
+   The notation :code:`stack[i]` is meant to index the stack from the top,
+   so that :code:`ctrls[0]` accesses the element pushed last.
+
+
+The control stack is likewise manipulated through auxiliary functions:
+
+.. code-block:: pseudo
+
+   func push_ctrl(label : list(val_type), out : list(val_type)) =
+     let frame = ctrl_frame(label, out, opds.size(), false)
+     ctrls.push(frame)
+
+   func pop_ctrl() : list(val_type) =
+     error_if(ctrls.is_empty())
+     let frame = ctrls.pop()
+     pop_opds(frame.end_types)
+     error_if(opds.size() =/= frame.height)
+     return frame.end_types
+
+   func unreachable() =
+     opds.resize(ctrls[0].height)
+     ctrls[0].unreachable := true
+
+Pushing a control frame takes the types of the label and result values.
+It allocates a new frame record recording them along with the current height of the operand stack and marks the block as reachable.
+
+Popping a frame first checks that the control stack is not empty.
+It then verifies that the operand stack contains the right types of values expected at the end of the exited block and pops them off the operand stack.
+Afterwards, it checks that the stack has shrunk back to its initial height.
+
+Finally, the current frame can be marked as unreachable.
+In that case, all existing operand types are purged from the operand stack, in order to allow for the :ref:`stack-polymorphism <polymorphism>` logic in :code:`pop_opd` to take effect.
+
+.. note::
+   Even with the unreachable flag set, consecutive operands are still pushed to and popped from the operand stack.
+   That is necessary to detect invalid :ref:`examples <polymorphism>` like :math:`(\UNREACHABLE~(\I32.\CONST)~\I64.\ADD)`.
+   However, a polymorphic stack cannot underflow, but instead generates :code:`Unknown` types as needed.
+
+
+.. index:: opcode
+
+Validation of Opcode Sequences
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The following function shows the validation of a number of representative instructions that manipulate the stack.
+Other instructions are checked in a similar manner.
+
+.. note::
+   Various instructions not shown here will additionally require the presence of a validation :ref:`context <context>` for checking uses of :ref:`indices <syntax-index>`.
+   That is an easy addition and therefore omitted from this presentation.
+
+.. code-block:: pseudo
+
+   func validate(opcode) =
+     switch (opcode)
+       case (i32.add)
+         pop_opd(I32)
+         pop_opd(I32)
+         push_opd(I32)
+
+       case (drop)
+         pop_opd()
+
+       case (select)
+         pop_opd(I32)
+         let t1 = pop_opd()
+         let t2 = pop_opd(t1)
+         push_opd(t2)
+
+       case (unreachable)
+         unreachable()
+
+       case (block t*)
+         push_ctrl([t*], [t*])
+
+       case (loop t*)
+         push_ctrl([], [t*])
+
+       case (if t*)
+         push_ctrl([t*], [t*])
+
+       case (end)
+         let results = pop_ctrl()
+         push_opds(results)
+
+       case (else)
+         let results = pop_ctrl()
+         push_ctrl(results, results)
+
+       case (br n)
+         error_if(ctrls.size() < n)
+         pop_opds(ctrls[n].label_types)
+         unreachable()
+
+       case (br_if n)
+         error_if(ctrls.size() < n)
+         pop_opd(I32)
+         pop_opds(ctrls[n].label_types)
+         push_opds(ctrls[n].label_types)
+
+       case (br_table n* m)
+         error_if(ctrls.size() < m)
+         foreach (n in n*)
+           error_if(ctrls.size() < n || ctrls[n].label_types =/= ctrls[m].label_types)
+         pop_opd(I32)
+         pop_opds(ctrls[m].label_types)
+         unreachable()
 
-   Describe algorithm, state correctness properties (soundness, completeness)
+.. note::
+   It is an invariant under the current WebAssembly instruction set that an operand of :code:`Unknown` type is never duplicated on the stack.
+   This would change if the language were extended with stack operators like :code:`dup`.
+   Under such an extension, the above algorithm would need to be refined by replacing the :code:`Unknown` type with proper *type variables* to ensure that all uses are consistent.
diff --git a/document/core/conf.py b/document/core/conf.py
index 9a0d4e80f..187792414 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -36,6 +36,7 @@
   'sphinx.ext.ifconfig',
   'sphinx.ext.githubpages',
   'mathdef',
+  'pseudo-lexer'
 ]
 
 # Add any paths that contain templates here, relative to this directory.
diff --git a/document/core/util/pseudo-lexer.py b/document/core/util/pseudo-lexer.py
new file mode 100644
index 000000000..fd3a251d5
--- /dev/null
+++ b/document/core/util/pseudo-lexer.py
@@ -0,0 +1,32 @@
+from pygments.lexer import RegexLexer
+from pygments.token import *
+from sphinx.highlighting import lexers
+
+class PseudoLexer(RegexLexer):
+  name = 'Pseudo'
+  aliases = ['pseudo']
+  filenames = ['*.pseudo']
+
+  tokens = {
+      'root': [
+          (r"(?<![(])\btype\b", Keyword),
+          (r"(?<![(])\bvar\b", Keyword),
+          (r"\bfunc\b", Keyword),
+          (r"(?<![(])\breturn\b", Keyword),
+          (r"\blet\b", Keyword),
+          (r"\bswitch\b", Keyword),
+          (r"\bcase\b", Keyword),
+          (r"(?<![(])\bif\b", Keyword),
+          (r"\bforeach\b", Keyword),
+          (r"\bin\b", Keyword),
+          (r"(?<=type[ ])[_a-zA-Z0-9]+", Name.Function),
+          (r"(?<=func[ ])[_a-zA-Z0-9]+", Name.Function),
+          (r"(?<=var[ ])[_a-zA-Z0-9]+", Name.Function),
+          (r"(?<=let[ ])[_a-zA-Z0-9]+", Name.Function),
+          (r"[_a-zA-Z0-9]+(?=[ ][:][ ])", Name.Function),
+          (r".", Text),
+      ]
+  }
+
+def setup(app):
+  lexers['pseudo'] = PseudoLexer()
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index 1596ed184..1ff1104a2 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -21,7 +21,7 @@ All rules are given in two *equivalent* forms:
 
 In both cases, the rules are formulated in a *declarative* manner.
 That is, they only formulate the constraints, they do not define an algorithm.
-A sound and complete algorithm for type-checking instruction sequences according to this specification is provided in the :ref:`appendix <soundness>`.
+The skeleton of a sound and complete algorithm for type-checking instruction sequences according to this specification is provided in the :ref:`appendix <algo-valid>`.
 
 
 .. index:: ! context, function type, table type, memory type, global type, value type, result type, index space, module, function

From 4911c4bebdc7ff35dbea9818a3f577c3f8e4f79b Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 20 Jul 2017 00:04:15 +0200
Subject: [PATCH 057/329] [spec] Specify name section (#522)

---
 document/core/appendix/custom.rst | 140 ++++++++++++++++++++++++++++++
 document/core/appendix/index.rst  |   2 +-
 document/core/appendix/names.rst  |   8 --
 document/core/util/math.def       |  21 +++++
 4 files changed, 162 insertions(+), 9 deletions(-)
 create mode 100644 document/core/appendix/custom.rst
 delete mode 100644 document/core/appendix/names.rst

diff --git a/document/core/appendix/custom.rst b/document/core/appendix/custom.rst
new file mode 100644
index 000000000..7aa44e5fd
--- /dev/null
+++ b/document/core/appendix/custom.rst
@@ -0,0 +1,140 @@
+.. index:: custom section, section, binary format
+
+Custom Sections
+---------------
+
+This appendix defines dedicated :ref:`custom sections <binary-customsec>` for WebAssembly's :ref:`binary format <binary>`.
+Such sections do not contribute to, or otherwise affect, the WebAssembly semantics, and like any custom section they may be ignored by an implementation.
+However, they provide useful meta data that implementations can make use of to improve user experience or take compilation hints.
+
+Currently, only one dedicated custom section is defined, the :ref:`name section<binary-namesec>`.
+
+
+.. index:: ! name section, name, Unicode UTF-8
+.. _binary-namesec:
+
+Name Section
+~~~~~~~~~~~~
+
+The *name section* is a :ref:`custom sections <binary-customsec>` whose name string is itself :math:`\text{name}`.
+The name section should appear only once in a module, and only after the :ref:`data section <binary-datasec>`.
+
+The purpose of this section is to attach printable names to definitions in a module, which e.g. can be used by a debugger or when parts of the module are to be rendered in :ref:`text form <text>`.
+
+.. note::
+   All :ref:`names <binary-name>` are represented in `Unicode <http://www.unicode.org/versions/latest/>`_ encoded in UTF-8.
+   Names need not be unique.
+
+
+.. _binary-namesubsection:
+
+Subsections
+...........
+
+The :ref:`data <binary-customsec>` of a name section consists of a sequence of *subsections*.
+Each subsection consists of a
+
+* a one-byte subsection *id*,
+* the |U32| *size* of the contents, in bytes,
+* the actual *contents*, whose structure is depended on the subsection id.
+
+.. math::
+   \begin{array}{llcll}
+   \production{name section} & \Bnamesec &::=&
+     \Bsection_0(\Bnamedata) \\
+   \production{name data} & \Bnamedata &::=&
+     n{:}\Bname~~\Bnamesubsection^\ast & (\iff n = \text{name}) \\
+   \production{name subsection} & \Bnamesubsection_N(\B{B}) &::=&
+     N{:}\Bbyte~~\X{size}{:}\Bu32~~\B{B}
+       & (\iff \X{size} = ||\B{B}||) \\
+   \end{array}
+
+The following subsection ids are used:
+
+==  ===========================================
+Id  Subsection                                 
+==  ===========================================
+ 0  :ref:`module name <binary-modulenamesec>`
+ 1  :ref:`function names <binary-funcnamesec>`    
+ 2  :ref:`local names <binary-localnamesec>`
+==  ===========================================
+
+
+.. index:: ! name map, index, index space
+.. _binary-indirectnamemap:
+.. _binary-namemap:
+
+Name Maps
+.........
+
+A *name map* assigns :ref:`names <syntax-name>` to :ref:`indices <syntax-index>` in a given :ref:`index space <syntax-index>`.
+It consists of a :ref:`vector <binary-vec>` of index/name pairs in order of increasing index value.
+Each index must be unique, but the assigned names need not be.
+
+.. math::
+   \begin{array}{llclll}
+   \production{name map} & \Bnamemap &::=&
+     \Bvec(\Bnameassoc) \\
+   \production{name association} & \Bnameassoc &::=&
+     \Bidx~\Bname \\
+   \end{array}
+
+An *indirect name map* assigns :ref:`names <syntax-name>` to a two-dimensional :ref:`index space <syntax-index>`, where secondary indices are *grouped* by primary indices.
+It consists of a vector of primary index/name map pairs in order of increasing index value, where each name map in turn maps secondary indices to names.
+Each primary index must be unique, and likewise each secondary index per individual name map.
+
+.. math::
+   \begin{array}{llclll}
+   \production{indirect name map} & \Bindirectnamemap &::=&
+     \Bvec(\Bindirectnameassoc) \\
+   \production{indirect name association} & \Bindirectnameassoc &::=&
+     \Bidx~\Bnamemap \\
+   \end{array}
+
+
+.. index:: module
+.. _binary-modulenamesec:
+
+Module Names
+............
+
+The *module name subsection* has the id 0.
+It simply consists of a single :ref:`name <binary-name>` that is assigned to the module itself.
+
+.. math::
+   \begin{array}{llclll}
+   \production{module name subsection} & \Bmodulenamesubsec &::=&
+     \Bnamesubsection_0(\Bname) \\
+   \end{array}
+
+
+.. index:: function, function index
+.. _binary-funcnamesec:
+
+Function Names
+..............
+
+The *function name subsection* has the id 1.
+It consists of a :ref:`name map <binary-namemap>` assigning function names to :ref:`function indices <syntax-funcidx>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{function name subsection} & \Bfuncnamesubsec &::=&
+     \Bnamesubsection_1(\Bnamemap) \\
+   \end{array}
+
+
+.. index:: function, local, function index, local index
+.. _binary-localnamesec:
+
+Local Names
+...........
+
+The *local name subsection* has the id 2.
+It consists of an :ref:`indirect name map <binary-indirectnamemap>` assigning local names to :ref:`local indices <syntax-localidx>` grouped by :ref:`function indices <syntax-funcidx>`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{function name subsection} & \Bfuncnamesubsec &::=&
+     \Bnamesubsection_2(\Bindirectnamemap) \\
+   \end{array}
diff --git a/document/core/appendix/index.rst b/document/core/appendix/index.rst
index 628e85999..581efe834 100644
--- a/document/core/appendix/index.rst
+++ b/document/core/appendix/index.rst
@@ -7,6 +7,6 @@ Appendix
    :maxdepth: 2
 
    implementation
-   names
+   custom
    properties
    algorithm
diff --git a/document/core/appendix/names.rst b/document/core/appendix/names.rst
deleted file mode 100644
index 6585c1109..000000000
--- a/document/core/appendix/names.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-.. _binary-namesec:
-
-Name Section
-------------
-
-.. todo::
-
-   Describe
diff --git a/document/core/util/math.def b/document/core/util/math.def
index a9c593b09..ca6ea49e4 100644
--- a/document/core/util/math.def
+++ b/document/core/util/math.def
@@ -407,6 +407,7 @@
 
 .. Indices, non-terminals
 
+.. |Bidx| mathdef:: \xref{binary/modules}{binary-index}{\B{idx}}
 .. |Btypeidx| mathdef:: \xref{binary/modules}{binary-typeidx}{\B{typeidx}}
 .. |Bfuncidx| mathdef:: \xref{binary/modules}{binary-funcidx}{\B{funcidx}}
 .. |Btableidx| mathdef:: \xref{binary/modules}{binary-tableidx}{\B{tableidx}}
@@ -880,3 +881,23 @@
 .. Other meta functions
 
 .. |invoke| mathdef:: \xref{exec/modules}{exec-invocation}{\F{invoke}}
+
+
+
+.. Custom Sections
+.. ---------------
+
+.. Name section, non-terminals
+
+.. |Bnamesec| mathdef:: \xref{appendix/custom}{binary-namesubsection}{\B{namesec}}
+.. |Bnamedata| mathdef:: \xref{appendix/custom}{binary-namesubsection}{\B{namedata}}
+.. |Bnamesubsection| mathdef:: \xref{appendix/custom}{binary-namesubsection}{\B{namesubsection}}
+
+.. |Bnamemap| mathdef:: \xref{appendix/custom}{binary-namemap}{\B{namemap}}
+.. |Bnameassoc| mathdef:: \xref{appendix/custom}{binary-namemap}{\B{nameassoc}}
+.. |Bindirectnamemap| mathdef:: \xref{appendix/custom}{binary-indirectnamemap}{\B{indirectnamemap}}
+.. |Bindirectnameassoc| mathdef:: \xref{appendix/custom}{binary-indirectnamemap}{\B{indirectnameassoc}}
+
+.. |Bmodulenamesubsec| mathdef:: \xref{appendix/custom}{binary-modulenamesec}{\B{modulenamesubsec}}
+.. |Bfuncnamesubsec| mathdef:: \xref{appendix/custom}{binary-funcnamesec}{\B{funcnamesubsec}}
+.. |Blocalnamesubsec| mathdef:: \xref{appendix/custom}{binary-localnamesec}{\B{localnamesubsec}}

From 17b4a4d98c80b1ec736649d5a73496a0e6d12d4c Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 25 Jul 2017 13:09:29 +0200
Subject: [PATCH 058/329] [spec/test/interpreter] Allow underscores in numbers
 (#527)

---
 document/core/text/values.rst |  11 +-
 interpreter/exec/int.ml       |   2 +
 interpreter/text/lexer.mll    |  14 +-
 test/core/float_literals.wast | 350 ++++++++++++++++++++++++++++++++++
 test/core/int_literals.wast   | 102 ++++++++++
 5 files changed, 469 insertions(+), 10 deletions(-)

diff --git a/document/core/text/values.rst b/document/core/text/values.rst
index 28e0c371a..67c22d0f8 100644
--- a/document/core/text/values.rst
+++ b/document/core/text/values.rst
@@ -27,6 +27,7 @@ Integers
 ~~~~~~~~
 
 All :ref:`integers <syntax-int>` can be written in either decimal or hexadecimal notation.
+In both cases, digits can optionally be separated by underscores.
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
@@ -43,10 +44,10 @@ All :ref:`integers <syntax-int>` can be written in either decimal or hexadecimal
    \\[1ex]
    \production{decimal number} & \Tnum &::=&
      d{:}\Tdigit &\Rightarrow& d \\ &&|&
-     n{:}\Tnum~~d{:}\Tdigit &\Rightarrow& 10\cdot n + d \\
+     n{:}\Tnum~~\text{\_}^?~~d{:}\Tdigit &\Rightarrow& 10\cdot n + d \\
    \production{hexadecimal number} & \Thexnum &::=&
      h{:}\Thexdigit &\Rightarrow& h \\ &&|&
-     n{:}\Thexnum~~h{:}\Thexdigit &\Rightarrow& 16\cdot n + h \\
+     n{:}\Thexnum~~\text{\_}^?~~h{:}\Thexdigit &\Rightarrow& 16\cdot n + h \\
    \end{array}
 
 The allowed syntax for integer literals depends on size and signedness.
@@ -88,10 +89,12 @@ Floating-Point
    \begin{array}{llclll@{\qquad\qquad}l}
    \production{decimal floating-point fraction} & \Tfrac &::=&
      \epsilon &\Rightarrow& 0 \\ &&|&
-     d{:}\Tdigit~q{:}\Tfrac &\Rightarrow& (d+q)/10 \\
+     d{:}\Tdigit~~q{:}\Tfrac &\Rightarrow& (d+q)/10 \\ &&|&
+     d{:}\Tdigit~~\text{\_}~~p{:}\Tdigit~~q{:}\Tfrac &\Rightarrow& (d+(p+q)/10)/10 \\
    \production{hexadecimal floating-point fraction} & \Thexfrac &::=&
      \epsilon &\Rightarrow& 0 \\ &&|&
-     h{:}\Thexdigit~q{:}\Thexfrac &\Rightarrow& (h+q)/16 \\
+     h{:}\Thexdigit~~q{:}\Thexfrac &\Rightarrow& (h+q)/16 \\ &&|&
+     h{:}\Thexdigit~~\text{\_}~~~~p{:}\Thexdigit~~q{:}\Thexfrac &\Rightarrow& (h+(p+q)/16)/16 \\
    \production{decimal floating-point number} & \Tfloat &::=&
      p{:}\Tnum~\text{.}~q{:}\Tfrac
        &\Rightarrow& p+q \\ &&|&
diff --git a/interpreter/exec/int.ml b/interpreter/exec/int.ml
index a2574fe3a..d81e6af4a 100644
--- a/interpreter/exec/int.ml
+++ b/interpreter/exec/int.ml
@@ -245,12 +245,14 @@ struct
     let len = String.length s in
     let rec parse_hex i num =
       if i = len then num else
+      if s.[i] = '_' then parse_hex (i + 1) num else
       let digit = of_int (hex_digit s.[i]) in
       require (le_u num (shr_u minus_one (of_int 4)));
       parse_hex (i + 1) (logor (shift_left num 4) digit)
     in
     let rec parse_dec i num =
       if i = len then num else
+      if s.[i] = '_' then parse_dec (i + 1) num else
       let digit = of_int (dec_digit s.[i]) in
       require (lt_u num max_upper || num = max_upper && le_u digit max_lower);
       parse_dec (i + 1) (add (mul num ten) digit)
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index 3bb532d51..2a41d8cfe 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -91,8 +91,8 @@ let opt = Lib.Option.get
 let sign = '+' | '-'
 let digit = ['0'-'9']
 let hexdigit = ['0'-'9''a'-'f''A'-'F']
-let num = digit+
-let hexnum = hexdigit+
+let num = digit ('_'? digit)*
+let hexnum = hexdigit ('_'? hexdigit)*
 
 let letter = ['a'-'z''A'-'Z']
 let symbol =
@@ -123,11 +123,13 @@ let character =
 
 let nat = num | "0x" hexnum
 let int = sign nat
+let frac = num
+let hexfrac = hexnum
 let float =
-    sign? num '.' digit*
-  | sign? num ('.' digit*)? ('e' | 'E') sign? num
-  | sign? "0x" hexnum '.' hexdigit*
-  | sign? "0x" hexnum ('.' hexdigit*)? ('p' | 'P') sign? num
+    sign? num '.' frac?
+  | sign? num ('.' frac?)? ('e' | 'E') sign? num
+  | sign? "0x" hexnum '.' hexfrac?
+  | sign? "0x" hexnum ('.' hexfrac?)? ('p' | 'P') sign? num
   | sign? "inf"
   | sign? "nan"
   | sign? "nan:" "0x" hexnum
diff --git a/test/core/float_literals.wast b/test/core/float_literals.wast
index 1ab14f1a0..c85bfb275 100644
--- a/test/core/float_literals.wast
+++ b/test/core/float_literals.wast
@@ -72,6 +72,28 @@
   (func (export "f64_dec.max_subnormal") (result i64) (i64.reinterpret/f64 (f64.const 2.2250738585072011e-308)))
   (func (export "f64_dec.max_finite") (result i64) (i64.reinterpret/f64 (f64.const 1.7976931348623157e+308)))
   (func (export "f64_dec.trailing_dot") (result i64) (i64.reinterpret/f64 (f64.const 1.e100)))
+
+  (func (export "f32-dec-sep1") (result f32) (f32.const 1_000_000))
+  (func (export "f32-dec-sep2") (result f32) (f32.const 1_0_0_0))
+  (func (export "f32-dec-sep3") (result f32) (f32.const 100_3.141_592))
+  (func (export "f32-dec-sep4") (result f32) (f32.const 99e+1_3))
+  (func (export "f32-dec-sep5") (result f32) (f32.const 122_000.11_3_54E0_2_3))
+  (func (export "f32-hex-sep1") (result f32) (f32.const 0xa_0f_00_99))
+  (func (export "f32-hex-sep2") (result f32) (f32.const 0x1_a_A_0_f))
+  (func (export "f32-hex-sep3") (result f32) (f32.const 0xa0_ff.f141_a59a))
+  (func (export "f32-hex-sep4") (result f32) (f32.const 0xf0P+1_3))
+  (func (export "f32-hex-sep5") (result f32) (f32.const 0x2a_f00a.1f_3_eep2_3))
+
+  (func (export "f64-dec-sep1") (result f64) (f64.const 1_000_000))
+  (func (export "f64-dec-sep2") (result f64) (f64.const 1_0_0_0))
+  (func (export "f64-dec-sep3") (result f64) (f64.const 100_3.141_592))
+  (func (export "f64-dec-sep4") (result f64) (f64.const 99e-1_23))
+  (func (export "f64-dec-sep5") (result f64) (f64.const 122_000.11_3_54e0_2_3))
+  (func (export "f64-hex-sep1") (result f64) (f64.const 0xa_f00f_0000_9999))
+  (func (export "f64-hex-sep2") (result f64) (f64.const 0x1_a_A_0_f))
+  (func (export "f64-hex-sep3") (result f64) (f64.const 0xa0_ff.f141_a59a))
+  (func (export "f64-hex-sep4") (result f64) (f64.const 0xf0P+1_3))
+  (func (export "f64-hex-sep5") (result f64) (f64.const 0x2a_f00a.1f_3_eep2_3))
 )
 
 (assert_return (invoke "f32.nan") (i32.const 0x7fc00000))
@@ -135,3 +157,331 @@
 (assert_return (invoke "f64_dec.max_subnormal") (i64.const 0xfffffffffffff))
 (assert_return (invoke "f64_dec.max_finite") (i64.const 0x7fefffffffffffff))
 (assert_return (invoke "f64_dec.trailing_dot") (i64.const 0x54b249ad2594c37d))
+
+(assert_return (invoke "f32-dec-sep1") (f32.const 1000000))
+(assert_return (invoke "f32-dec-sep2") (f32.const 1000))
+(assert_return (invoke "f32-dec-sep3") (f32.const 1003.141592))
+(assert_return (invoke "f32-dec-sep4") (f32.const 99e+13))
+(assert_return (invoke "f32-dec-sep5") (f32.const 122000.11354e23))
+(assert_return (invoke "f32-hex-sep1") (f32.const 0xa0f0099))
+(assert_return (invoke "f32-hex-sep2") (f32.const 0x1aa0f))
+(assert_return (invoke "f32-hex-sep3") (f32.const 0xa0ff.f141a59a))
+(assert_return (invoke "f32-hex-sep4") (f32.const 0xf0P+13))
+(assert_return (invoke "f32-hex-sep5") (f32.const 0x2af00a.1f3eep23))
+
+(assert_return (invoke "f64-dec-sep1") (f64.const 1000000))
+(assert_return (invoke "f64-dec-sep2") (f64.const 1000))
+(assert_return (invoke "f64-dec-sep3") (f64.const 1003.141592))
+(assert_return (invoke "f64-dec-sep4") (f64.const 99e-123))
+(assert_return (invoke "f64-dec-sep5") (f64.const 122000.11354e23))
+(assert_return (invoke "f64-hex-sep1") (f64.const 0xaf00f00009999))
+(assert_return (invoke "f64-hex-sep2") (f64.const 0x1aa0f))
+(assert_return (invoke "f64-hex-sep3") (f64.const 0xa0ff.f141a59a))
+(assert_return (invoke "f64-hex-sep4") (f64.const 0xf0P+13))
+(assert_return (invoke "f64-hex-sep5") (f64.const 0x2af00a.1f3eep23))
+
+(assert_malformed
+  (module quote "(global f32 (f32.const _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f32 (f32.const 0x1.0p_+1))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global f64 (f64.const _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const _1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const _1e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const _1.0e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0e1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0_e1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0e_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0e+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 1.0e_+1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0xff__ffff))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x_1.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1_.0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1._0))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x_1p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x_1.0p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0p1_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0_p1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0p_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0p+_1))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global f64 (f64.const 0x1.0p_+1))")
+  "unknown operator"
+)
diff --git a/test/core/int_literals.wast b/test/core/int_literals.wast
index f0ec04178..73b37cc5a 100644
--- a/test/core/int_literals.wast
+++ b/test/core/int_literals.wast
@@ -22,6 +22,16 @@
   (func (export "i64.not_octal") (result i64) (return (i64.const 010)))
   (func (export "i64.unsigned_decimal") (result i64) (return (i64.const 18446744073709551615)))
   (func (export "i64.plus_sign") (result i64) (return (i64.const +42)))
+
+  (func (export "i32-dec-sep1") (result i32) (i32.const 1_000_000))
+  (func (export "i32-dec-sep2") (result i32) (i32.const 1_0_0_0))
+  (func (export "i32-hex-sep1") (result i32) (i32.const 0xa_0f_00_99))
+  (func (export "i32-hex-sep2") (result i32) (i32.const 0x1_a_A_0_f))
+
+  (func (export "i64-dec-sep1") (result i64) (i64.const 1_000_000))
+  (func (export "i64-dec-sep2") (result i64) (i64.const 1_0_0_0))
+  (func (export "i64-hex-sep1") (result i64) (i64.const 0xa_f00f_0000_9999))
+  (func (export "i64-hex-sep2") (result i64) (i64.const 0x1_a_A_0_f))
 )
 
 (assert_return (invoke "i32.test") (i32.const 195940365))
@@ -47,3 +57,95 @@
 (assert_return (invoke "i64.not_octal") (i64.const 10))
 (assert_return (invoke "i64.unsigned_decimal") (i64.const -1))
 (assert_return (invoke "i64.plus_sign") (i64.const 42))
+
+(assert_return (invoke "i32-dec-sep1") (i32.const 1000000))
+(assert_return (invoke "i32-dec-sep2") (i32.const 1000))
+(assert_return (invoke "i32-hex-sep1") (i32.const 0xa0f0099))
+(assert_return (invoke "i32-hex-sep2") (i32.const 0x1aa0f))
+
+(assert_return (invoke "i64-dec-sep1") (i64.const 1000000))
+(assert_return (invoke "i64-dec-sep2") (i64.const 1000))
+(assert_return (invoke "i64-hex-sep1") (i64.const 0xaf00f00009999))
+(assert_return (invoke "i64-hex-sep2") (i64.const 0x1aa0f))
+
+(assert_malformed
+  (module quote "(global i32 (i32.const _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i32 (i32.const 0xff__ffff))")
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote "(global i64 (i64.const _100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const +_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const -_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 99_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 1__000))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const _0x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0_x100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0x_100))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0x00_))")
+  "unknown operator"
+)
+(assert_malformed
+  (module quote "(global i64 (i64.const 0xff__ffff))")
+  "unknown operator"
+)

From fe1abd09c92b80e5f304e70a3fee69727b5f161e Mon Sep 17 00:00:00 2001
From: titzer <titzer@google.com>
Date: Thu, 27 Jul 2017 10:59:11 +0200
Subject: [PATCH 059/329] Update JavaScript WasmModuleBuilder with new
 functionality. (#530)

* Update JavaScript WasmModuleBuilder with new functionality.

* Remove references to non-standard S128 type in wasm-constants.js

* Add back enhanced functionality.
---
 test/harness/wasm-constants.js      |  2 -
 test/harness/wasm-module-builder.js | 89 ++++++++++++++++++++++-------
 2 files changed, 69 insertions(+), 22 deletions(-)

diff --git a/test/harness/wasm-constants.js b/test/harness/wasm-constants.js
index 68c36ef1f..9e0698599 100644
--- a/test/harness/wasm-constants.js
+++ b/test/harness/wasm-constants.js
@@ -87,7 +87,6 @@ let kWasmI32 = 0x7f;
 let kWasmI64 = 0x7e;
 let kWasmF32 = 0x7d;
 let kWasmF64 = 0x7c;
-let kWasmS128 = 0x7b;
 
 let kExternalFunction = 0;
 let kExternalTable = 1;
@@ -118,7 +117,6 @@ let kSig_v_l = makeSig([kWasmI64], []);
 let kSig_v_d = makeSig([kWasmF64], []);
 let kSig_v_dd = makeSig([kWasmF64, kWasmF64], []);
 let kSig_v_ddi = makeSig([kWasmF64, kWasmF64, kWasmI32], []);
-let kSig_s_v = makeSig([], [kWasmS128]);
 
 function makeSig(params, results) {
   return {params: params, results: results};
diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index d9948eb1a..f73794bac 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -74,9 +74,7 @@ class Binary extends Array {
     // Emit section length.
     this.emit_u32v(section.length);
     // Copy the temporary buffer.
-    for (const sectionByte of section) {
-      this.push(sectionByte);
-    }
+    this.push(...section);
   }
 }
 
@@ -88,6 +86,15 @@ class WasmFunctionBuilder {
     this.body = [];
   }
 
+  numLocalNames() {
+    if (this.local_names === undefined) return 0;
+    let num_local_names = 0;
+    for (let loc_name of this.local_names) {
+      if (loc_name !== undefined) ++num_local_names;
+    }
+    return num_local_names;
+  }
+
   exportAs(name) {
     this.module.addExport(name, this.index);
     return this;
@@ -101,7 +108,7 @@ class WasmFunctionBuilder {
   addBody(body) {
     for (let b of body) {
       if (typeof b !== 'number' || (b & (~0xFF)) !== 0 )
-        throw new Error('invalid body (entries have to be 8 bit numbers): ' + body);
+        throw new Error('invalid body (entries must be 8 bit numbers): ' + body);
     }
     this.body = body.slice();
     // Automatically add the end for the function block to the body.
@@ -109,8 +116,14 @@ class WasmFunctionBuilder {
     return this;
   }
 
-  addLocals(locals) {
+  addBodyWithEnd(body) {
+    this.body = body;
+    return this;
+  }
+
+  addLocals(locals, names) {
     this.locals = locals;
+    this.local_names = names;
     return this;
   }
 
@@ -274,6 +287,11 @@ class WasmModuleBuilder {
     return this;
   }
 
+  setName(name) {
+    this.name = name;
+    return this;
+  }
+
   toArray(debug = false) {
     let binary = new Binary;
     let wasm = this;
@@ -333,16 +351,11 @@ class WasmModuleBuilder {
     }
 
     // Add functions declarations
-    let num_function_names = 0;
-    let names = false;
     if (wasm.functions.length > 0) {
       if (debug) print("emitting function decls @ " + binary.length);
       binary.emit_section(kFunctionSectionCode, section => {
         section.emit_u32v(wasm.functions.length);
         for (let func of wasm.functions) {
-          if (func.name !== undefined) {
-            ++num_function_names;
-          }
           section.emit_u32v(func.type_index);
         }
       });
@@ -543,19 +556,51 @@ class WasmModuleBuilder {
       binary.emit_bytes(exp);
     }
 
-    // Add function names.
-    if (num_function_names > 0) {
+    // Add names.
+    let num_function_names = 0;
+    let num_functions_with_local_names = 0;
+    for (let func of wasm.functions) {
+      if (func.name !== undefined) ++num_function_names;
+      if (func.numLocalNames() > 0) ++num_functions_with_local_names;
+    }
+    if (num_function_names > 0 || num_functions_with_local_names > 0 ||
+        wasm.name !== undefined) {
       if (debug) print('emitting names @ ' + binary.length);
       binary.emit_section(kUnknownSectionCode, section => {
         section.emit_string('name');
-        section.emit_section(kFunctionNamesCode, name_section => {
-          name_section.emit_u32v(num_function_names);
-          for (let func of wasm.functions) {
-            if (func.name === undefined) continue;
-            name_section.emit_u32v(func.index);
-            name_section.emit_string(func.name);
-          }
-        });
+        // Emit module name.
+        if (wasm.name !== undefined) {
+          section.emit_section(kModuleNameCode, name_section => {
+            name_section.emit_string(wasm.name);
+          });
+        }
+        // Emit function names.
+        if (num_function_names > 0) {
+          section.emit_section(kFunctionNamesCode, name_section => {
+            name_section.emit_u32v(num_function_names);
+            for (let func of wasm.functions) {
+              if (func.name === undefined) continue;
+              name_section.emit_u32v(func.index);
+              name_section.emit_string(func.name);
+            }
+          });
+        }
+        // Emit local names.
+        if (num_functions_with_local_names > 0) {
+          section.emit_section(kLocalNamesCode, name_section => {
+            name_section.emit_u32v(num_functions_with_local_names);
+            for (let func of wasm.functions) {
+              if (func.numLocalNames() == 0) continue;
+              name_section.emit_u32v(func.index);
+              name_section.emit_u32v(func.numLocalNames());
+              for (let i = 0; i < func.local_names.length; ++i) {
+                if (func.local_names[i] === undefined) continue;
+                name_section.emit_u32v(i);
+                name_section.emit_string(func.local_names[i]);
+              }
+            }
+          });
+        }
       });
     }
 
@@ -579,4 +624,8 @@ class WasmModuleBuilder {
     let instance = new WebAssembly.Instance(module, ffi);
     return instance;
   }
+
+  toModule(debug = false) {
+    return new WebAssembly.Module(this.toBuffer(debug));
+  }
 }

From 23194e74f18a656ed70fc2bf6dd77f453d05b526 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Fri, 28 Jul 2017 12:27:34 +0200
Subject: [PATCH 060/329] [spec] Fix underscores in HTML hrefs (#533)

---
 document/core/util/mathdef.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/util/mathdef.py b/document/core/util/mathdef.py
index e4997ac4b..c14b70395 100644
--- a/document/core/util/mathdef.py
+++ b/document/core/util/mathdef.py
@@ -17,7 +17,7 @@
 xref_re = re.compile('\\\\xref\{([^}]*)\}\{([^}]*)\}', re.M)
 
 def html_hyperlink(file, id):
-  return '\\href{../%s.html#%s}' % (file, id)
+  return '\\href{../%s.html#%s}' % (file, id.replace('_', '-'))
 
 def html_transform_math_xref(node):
   node['latex'] = \
@@ -31,7 +31,7 @@ def ext_html_visit_displaymath(self, node):
   html_transform_math_xref(node)
   html_visit_displaymath(self, node)
 
-# Mirrors sphinx/writer/latex
+# Mirrors sphinx/writers/latex
 def latex_hyperlink(file, id):
   id = text_type(id).translate(tex_replace_map).\
     encode('ascii', 'backslashreplace').decode('ascii').\

From 104f5b85a5727564afd04f0708d46d9800a555be Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Mon, 31 Jul 2017 14:18:09 +0200
Subject: [PATCH 061/329] [infra] Update .gitignore

---
 .gitignore | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index 99dcfcf72..6739bb2be 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,5 @@
 **/*~
 **/*.tmproj
-_build
+**/*.pyc
+**/_build
+**/_output

From 8686fc52b775ec3ed9bddd41d274f1dc7f6580e5 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Mon, 31 Jul 2017 16:04:12 +0200
Subject: [PATCH 062/329] [spec] Add soundness theorems to appendix (#526)

* Add appendix section on soundness.
* Make the notion of store extension precise.
* Define configurations more thoroughly.
* Add indices for semantic rules and types.
* Hyperref all judgements and symbols.
* Fix a couple other minor things.
---
 .../index-instructions.rst}                   |   5 +-
 document/core/appendix/index-rules.rst        | 108 +++
 document/core/appendix/index-types.rst        |  24 +
 document/core/appendix/properties.rst         | 727 +++++++++++++++++-
 document/core/exec/conventions.rst            |  11 +-
 document/core/exec/instructions.rst           |  20 +-
 document/core/exec/modules.rst                | 193 ++---
 document/core/exec/runtime.rst                | 132 ++--
 document/core/index.rst                       |  10 +-
 document/core/util/math.def                   |  82 +-
 document/core/valid/conventions.rst           |   6 +-
 document/core/valid/instructions.rst          |  93 ++-
 document/core/valid/modules.rst               | 135 ++--
 document/core/valid/types.rst                 |  96 ++-
 14 files changed, 1335 insertions(+), 307 deletions(-)
 rename document/core/{syntax/instrindex.rst => appendix/index-instructions.rst} (99%)
 create mode 100644 document/core/appendix/index-rules.rst
 create mode 100644 document/core/appendix/index-types.rst

diff --git a/document/core/syntax/instrindex.rst b/document/core/appendix/index-instructions.rst
similarity index 99%
rename from document/core/syntax/instrindex.rst
rename to document/core/appendix/index-instructions.rst
index d6230dbb2..f5811e024 100644
--- a/document/core/syntax/instrindex.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -1,10 +1,11 @@
-.. _instrindex:
+.. index:: instruction
+.. _index-instr:
 
 Index of Instructions
 ---------------------
 
 ===================================  ================  ==========================================  ========================================  ===============================================================
-Instruction                          Opcode            Type                                        Validation                                Execution
+Instruction                          Binary Opcode     Type                                        Validation                                Execution
 ===================================  ================  ==========================================  ========================================  ===============================================================
 :math:`\UNREACHABLE`                 :math:`\hex{00}`  :math:`[t_1^\ast] \to [t_2^\ast]`           :ref:`validation <valid-unreachable>`     :ref:`execution <exec-unreachable>`
 :math:`\NOP`                         :math:`\hex{01}`  :math:`[] \to []`                           :ref:`validation <valid-nop>`             :ref:`execution <exec-nop>`
diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
new file mode 100644
index 000000000..83d5d514d
--- /dev/null
+++ b/document/core/appendix/index-rules.rst
@@ -0,0 +1,108 @@
+.. _index-rules:
+
+Index of Semantic Rules
+-----------------------
+
+
+.. index:: validation
+.. _index-valid:
+
+Typing of Static Constructs
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+===============================================  ===============================================================================
+Construct                                        Judgement
+===============================================  ===============================================================================
+:ref:`Limits <valid-limits>`                     :math:`\vdashlimits \limits \ok`
+:ref:`Function type <valid-functype>`            :math:`\vdashfunctype \functype \ok`
+:ref:`Table type <valid-tabletype>`              :math:`\vdashtabletype \tabletype \ok`
+:ref:`Memory type <valid-memtype>`               :math:`\vdashmemtype \memtype \ok`
+:ref:`Global type <valid-globaltype>`            :math:`\vdashglobaltype \globaltype \ok`
+:ref:`Instruction <valid-instr>`                 :math:`S;C \vdashinstr \instr : \functype`
+:ref:`Instruction sequence <valid-instr-seq>`    :math:`S;C \vdashinstrseq \instr^\ast : \functype`
+:ref:`Expression <valid-expr>`                   :math:`C \vdashexpr \expr : \resulttype`
+:ref:`Function <valid-func>`                     :math:`C \vdashfunc \func : \resulttype`
+:ref:`Table <valid-table>`                       :math:`C \vdashtable \table : \tabletype`
+:ref:`Memory <valid-mem>`                        :math:`C \vdashmem \mem : \memtype`
+:ref:`Global <valid-global>`                     :math:`C \vdashglobal \global : \globaltype`
+:ref:`Element segment <valid-elem>`              :math:`C \vdashelem \elem \ok`
+:ref:`Data segment <valid-data>`                 :math:`C \vdashdata \data \ok`
+:ref:`Start function <valid-start>`              :math:`C \vdashstart \start \ok`
+:ref:`Export <valid-export>`                     :math:`C \vdashexport \export : \name`
+:ref:`Export description <valid-exportdesc>`     :math:`C \vdashexportdesc \exportdesc \ok`
+:ref:`Import <valid-import>`                     :math:`C \vdashimport \import : \externtype`
+:ref:`Import description <valid-importdesc>`     :math:`C \vdashimportdesc \importdesc : \externtype`
+:ref:`Module <valid-module>`                     :math:`\vdashmodule \module : \externtype^\ast`
+===============================================  ===============================================================================
+
+
+.. index:: runtime
+
+Typing of Runtime Constructs
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+===============================================  ===============================================================================
+Construct                                        Judgement
+===============================================  ===============================================================================
+:ref:`Module instruction <valid-moduleinstr>`    :math:`S \vdashmoduleinstr \moduleinstr \ok`
+:ref:`Function instance <valid-funcinst>`        :math:`S \vdashfuncinst \funcinst : \resulttype`
+:ref:`Table instance <valid-tableinst>`          :math:`S \vdashtableinst \tableinst : \tabletype`
+:ref:`Memory instance <valid-meminst>`           :math:`S \vdashmeminst \meminst : \memtype`
+:ref:`Global instance <valid-globalinst>`        :math:`S \vdashglobalinst \globalinst : \globaltype`
+:ref:`Export instance <valid-exportinst>`        :math:`S \vdashexportinst \exportinst \ok`
+:ref:`Module instance <valid-moduleinst>`        :math:`S \vdashmoduleinst \moduleinst : C`
+:ref:`Store <valid-store>`                       :math:`\vdashstore \store \ok`
+:ref:`Configuration <valid-config>`              :math:`\vdashconfig \config \ok`
+:ref:`Thread <valid-thread>`                     :math:`S;\resulttype^? \vdashthread \thread : \resulttype^?`
+:ref:`Frame <valid-frame>`                       :math:`S \vdashframe \frame : C`
+:ref:`Value <valid-val>`                         :math:`\vdashval \val : \valtype`
+:ref:`External value <valid-externval>`          :math:`S \vdashexternval \externval : \externtype`
+===============================================  ===============================================================================
+
+
+Constantness
+~~~~~~~~~~~~
+
+===============================================  ===============================================================================
+Construct                                        Judgement
+===============================================  ===============================================================================
+:ref:`Constant expression <valid-constant>`      :math:`C \vdashexprconst \expr \const`
+:ref:`Constant instruction <valid-constant>`     :math:`C \vdashinstrconst \instr \const`
+===============================================  ===============================================================================
+
+
+Import Matching
+~~~~~~~~~~~~~~~
+
+===============================================  ===============================================================================
+Construct                                        Judgement
+===============================================  ===============================================================================
+:ref:`Limits <match-limits>`                     :math:`\vdashlimitsmatch \limits_1 \matches \limits_2`
+:ref:`External type <match-externtype>`          :math:`\vdashexterntypematch \externtype_1 \matches \externtype_2`
+===============================================  ===============================================================================
+
+
+Store Extension
+~~~~~~~~~~~~~~~
+
+===============================================  ===============================================================================
+Construct                                        Judgement
+===============================================  ===============================================================================
+:ref:`Function instance <extend-funcinst>`       :math:`\vdashfuncinstextends \funcinst_1 \extendsto \funcinst_2`
+:ref:`Table instance <extend-tableinst>`         :math:`\vdashtableinstextends \tableinst_1 \extendsto \tableinst_2`
+:ref:`Memory instance <extend-meminst>`          :math:`\vdashmeminstextends \meminst_1 \extendsto \meminst_2`
+:ref:`Global instance <extend-globalinst>`       :math:`\vdashglobalinstextends \globalinst_1 \extendsto \globalinst_2`
+:ref:`Store <extend-store>`                      :math:`\vdashstoreextends \store_1 \extendsto \store_2`
+===============================================  ===============================================================================
+
+
+Execution
+~~~~~~~~~
+
+===============================================  ===============================================================================
+Construct                                        Judgement
+===============================================  ===============================================================================
+:ref:`Instruction <exec-instr>`                  :math:`S;F;\instr \stepto S';F';{\instr'}^\ast`
+:ref:`Expression <exec-expr>`                    :math:`S;F;\expr \stepto^\ast S';F';\val^\ast`
+:ref:`Module instruction <exec-moduleinstr>`     :math:`S;\moduleinstr \stepto S';{\moduleinstr'}^\ast`
+===============================================  ===============================================================================
diff --git a/document/core/appendix/index-types.rst b/document/core/appendix/index-types.rst
new file mode 100644
index 000000000..972ae6b49
--- /dev/null
+++ b/document/core/appendix/index-types.rst
@@ -0,0 +1,24 @@
+.. index:: type
+.. _index-type:
+
+Index of Types
+--------------
+
+========================================  ===========================================  ===============================================================================
+Category                                  Constructor                                         Binary Opcode
+========================================  ===========================================  ===============================================================================
+:ref:`Type index <syntax-typeidx>`        :math:`x`                                    (positive number as |Bs32| or |Bu32|)
+:ref:`Value type <syntax-valtype>`        |I32|                                        :math:`\hex{7F}` (-1 as |Bs7|)
+:ref:`Value type <syntax-valtype>`        |I64|                                        :math:`\hex{7E}` (-2 as |Bs7|)
+:ref:`Value type <syntax-valtype>`        |F32|                                        :math:`\hex{7D}` (-3 as |Bs7|)
+:ref:`Value type <syntax-valtype>`        |F64|                                        :math:`\hex{7C}` (-4 as |Bs7|)
+(reserved)                                                                             :math:`\hex{7C}` .. :math:`\hex{71}`
+:ref:`Element type <syntax-elemtype>`     |ANYFUNC|                                    :math:`\hex{70}` (-16 as |Bs7|)
+(reserved)                                                                             :math:`\hex{6F}` .. :math:`\hex{61}`
+:ref:`Function type <syntax-functype>`    :math:`[\valtype^\ast] \to [\valtype^\ast]`  :math:`\hex{60}` (-32 as |Bs7|)
+(reserved)                                                                             :math:`\hex{5F}` .. :math:`\hex{41}`
+:ref:`Result type <syntax-resulttype>`    :math:`\epsilon`                             :math:`\hex{40}` (-64 as |Bs7|)
+:ref:`Table type <syntax-tabletype>`      :math:`\limits~\elemtype`                    (none)
+:ref:`Memory type <syntax-memtype>`       :math:`\limits`                              (none)
+:ref:`Global type <syntax-globaltype>`    :math:`\mut~\valtype`                        (none)
+========================================  ===========================================  ===============================================================================
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 2a0c06e6d..2473df9d0 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -1,17 +1,726 @@
-Formal Properties
------------------
+.. index:: ! soundness, type system
+.. _soundness:
+
+Soundness
+---------
+
+The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *type safety* and *memory safety* with respect to the WebAssembly semantics. For example:
+
+* All types declared and derived during validation are respected at run time;
+  e.g., every :ref:`local <syntax-local>` or :ref:`global <syntax-global>` variable will only contain type-correct values, every :ref:`instruction <syntax-instr>` will only be applied to operands of the expected type, and every :ref:`function <syntax-func>` :ref:`invocation <exec-invocation>` always evaluates to a result of the right type.
+
+* No memory location will be read or written except those explicitly defined by the program, i.e., as a :ref:`local <syntax-local>`, a :ref:`global <syntax-global>`, an element in a :ref:`table <syntax-table>`, or a location within a linear :ref:`memory <syntax-mem>`.
+
+* There is no undefined behaviour,
+  i.e., the :ref:`execution rules <exec>` cover all possible cases that can occur in a :ref:`valid <valid>` program, and the rules are mutually consistent.
+
+Soundness also is instrumental in ensuring additional properties, most notably, *encapsulation* of function and module scopes: no :ref:`locals <syntax-local>` can be accessed outside their own function and no :ref:`module <syntax-module>` components can be accessed outside their own module unless they are explicitly :ref:`exported <syntax-export>` or :ref:`imported <syntax-import>`.
+
+The typing rules defining WebAssembly :ref:`validation <valid>` only cover the *static* components of a WebAssembly program.
+In order to state and prove soundness precisely, the typing rules must be extended to the *dynamic* components of the abstract :ref:`runtime <syntax-runtime>`, that is, the :ref:`store <syntax-store>`, :ref:`configurations <syntax-config>`, and :ref:`administrative instructions <syntax-instr-admin>` as well as :ref:`module instructions <valid-moduleinstr>`. [#pldi2017]_
 
-.. _bijective:
 
-Representation
+.. _module-context:
+.. _valid-store:
+
+Store Validity
 ~~~~~~~~~~~~~~
 
-.. todo:: bijection between abstract and binary
+The following typing rules specify when a runtime :ref:`store <syntax-store>` :math:`S` is *valid*.
+A valid store must consist of
+:ref:`function <syntax-funcinst>`, :ref:`table <syntax-tableinst>`, :ref:`memory <syntax-meminst>`, :ref:`global <syntax-globalinst>`, and :ref:`module <syntax-moduleinst>` instances that are themselves valid, relative to :math:`S`.
 
+To that end, each kind of instance is classified by a respective :ref:`function <syntax-functype>`, :ref:`table <syntax-tabletype>`, :ref:`memory <syntax-memtype>`, or :ref:`global <syntax-globaltype>` type.
+Module instances are classified by *module contexts*, which are regular :ref:`contexts <context>` repurposed as module types describing the :ref:`index spaces <syntax-index>` defined by a module.
 
-.. _soundness:
 
-Validation
-~~~~~~~~~~
 
-.. todo:: progress, preservation
+.. index:: store, function instance, table instance, memory instance, global instance, function type, table type, memory type, global type
+
+:ref:`Store <syntax-store>` :math:`S`
+.....................................
+
+* Each :ref:`function instance <syntax-funcinst>` :math:`\funcinst_i` in :math:`S.\SFUNCS` must be :ref:`valid <valid-funcinst>` with some :ref:`function type <syntax-functype>` :math:`\functype_i`.
+
+* Each :ref:`table instance <syntax-tableinst>` :math:`\tableinst_i` in :math:`S.\STABLES` must be :ref:`valid <valid-tableinst>` with some :ref:`table type <syntax-tabletype>` :math:`\tabletype_i`.
+
+* Each :ref:`memory instance <syntax-meminst>` :math:`\meminst_i` in :math:`S.\SMEMS` must be :ref:`valid <valid-meminst>` with some :ref:`memory type <syntax-memtype>` :math:`\memtype_i`.
+
+* Each :ref:`global instance <syntax-globalinst>` :math:`\globalinst_i` in :math:`S.\SGLOBALS` must be :ref:`valid <valid-globalinst>` with some optional  :ref:`global type <syntax-globaltype>` :math:`\globaltype_i^?`.
+
+* Then the store is valid.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     \begin{array}{@{}c@{}}
+     (S \vdashfuncinst \funcinst : \functype)^\ast
+     \qquad
+     (S \vdashtableinst \tableinst : \tabletype)^\ast
+     \\
+     (S \vdashmeminst \meminst : \memtype)^\ast
+     \qquad
+     (S \vdashglobalinst \globalinst : \globaltype^?)^\ast
+     \\
+     S = \{
+       \SFUNCS~\funcinst^\ast,
+       \STABLES~\tableinst^\ast,
+       \SMEMS~\meminst^\ast,
+       \SGLOBALS~\globalinst^\ast \}
+     \end{array}
+   }{
+     \vdashstore S \ok
+   }
+
+
+.. index:: function type, function instance
+.. _valid-funcinst:
+
+:ref:`Function Instance <syntax-funcinst>` :math:`\{\FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func\}`
+......................................................................................................................
+
+* The :ref:`function type <syntax-functype>` :math:`\functype` must be :ref:`valid <valid-functype>`.
+
+* The :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst` must be :ref:`valid <valid-moduleinst>` with some :ref:`context <context>` :math:`C`.
+
+* Under :ref:`context <context>` :math:`C`, the :ref:`function <syntax-func>` :math:`\func` must be :ref:`valid <valid-func>` with :ref:`function type <syntax-functype>` :math:`\functype`.
+
+* Then the function instance is valid with :ref:`function type <syntax-functype>` :math:`\functype`.
+
+.. math::
+   \frac{
+     \vdashfunctype \functype \ok
+     \qquad
+     S \vdashmoduleinst \moduleinst : C
+     \qquad
+     C \vdashfunc \func : \functype
+   }{
+     S \vdashfuncinst \{\FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func\} : \functype
+   }
+
+
+.. index:: table type, table instance, limits, function address
+.. _valid-tableinst:
+
+:ref:`Table Instance <syntax-tableinst>` :math:`\{ \TIELEM~(\X{fa}^?)^n, \TIMAX~m^? \}`
+.............................................................................................
+
+* For each optional :ref:`function address <syntax-funcaddr>` :math:`\X{fa}^?_i` in the table elements :math:`(\X{fa}^?)^n`:
+
+  * Either :math:`\X{fa}^?_i` is empty.
+
+  * Or the :ref:`external value <syntax-externval>` :math:`\EVFUNC~\X{fa}` must be :ref:`valid <valid-externval-func>` with some :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\X{ft}`.
+
+* The :ref:`limits <syntax-limits>` :math:`\{\LMIN~n, \LMAX~m^?\}` must be :ref:`valid <valid-limits>`.
+
+* Then the table instance is valid with :ref:`table type <syntax-tabletype>` :math:`\{\LMIN~n, \LMAX~m^?\}~\ANYFUNC`.
+
+.. math::
+   \frac{
+     ((S \vdash \EVFUNC~\X{fa} : \ETFUNC~\functype)^?)^n
+     \qquad
+     \vdashlimits \{\LMIN~n, \LMAX~m^?\} \ok
+   }{
+     S \vdashtableinst \{ \TIELEM~(\X{fa}^?)^n, \TIMAX~m^? \} : \{\LMIN~n, \LMAX~m^?\}~\ANYFUNC
+   }
+
+
+.. index:: memory type, memory instance, limits, byte
+.. _valid-meminst:
+
+:ref:`Memory Instance <syntax-meminst>` :math:`\{ \MIDATA~b^n, \MIMAX~m^? \}`
+.............................................................................
+
+* The :ref:`limits <syntax-limits>` :math:`\{\LMIN~n, \LMAX~m^?\}` must be :ref:`valid <valid-limits>`.
+
+* Then the memory instance is valid with :ref:`memory type <syntax-memtype>` :math:`\{\LMIN~n, \LMAX~m^?\}`.
+
+.. math::
+   \frac{
+     \vdashlimits \{\LMIN~n, \LMAX~m^?\} \ok
+   }{
+     S \vdashmeminst \{ \MIDATA~b^n, \MIMAX~m^? \} : \{\LMIN~n, \LMAX~m^?\}
+   }
+
+
+.. index:: global type, global instance, value, mutability
+.. _valid-globalinst:
+
+:ref:`Global Instance <syntax-globalinst>` :math:`\{ \GIVALUE~(t.\CONST~c), \GIMUT~\mut \}`
+...........................................................................................
+
+* The global instance is valid with :ref:`global type <syntax-globaltype>` :math:`\mut~t`.
+
+.. math::
+   \frac{
+   }{
+     S \vdashglobalinst \{ \GIVALUE~(t.\CONST~c), \GIMUT~\mut \} : \mut~t
+   }
+
+
+.. index:: external type, export instance, name, external value
+.. _valid-exportinst:
+
+:ref:`Export Instance <syntax-exportinst>` :math:`\{ \EINAME~\name, \EIVALUE~\externval \}`
+......................................................................................................
+
+* The :ref:`external value <syntax-externval>` :math:`\externval` must be :ref:`valid <valid-externval>` with some :ref:`external type <syntax-externtype>` :math:`\externtype`.
+
+* Then the export instance is valid.
+
+.. math::
+   \frac{
+     S \vdashexternval \externval : \externtype
+   }{
+     S \vdashexportinst \{ \EINAME~\name, \EIVALUE~\externval \} \ok
+   }
+
+
+.. index:: module instance, context
+.. _valid-moduleinst:
+
+:ref:`Module Instance <syntax-moduleinst>` :math:`\moduleinst`
+..............................................................
+
+* Each :ref:`function type <syntax-functype>` :math:`\functype_i` in :math:`\moduleinst.\MITYPES` must be :ref:`valid <valid-functype>`.
+
+* For each :ref:`function address <syntax-funcaddr>` :math:`\funcaddr_i` in :math:`\moduleinst.\MIFUNCS`, the :ref:`external value <syntax-externval>` :math:`\EVFUNC~\funcaddr_i` must be :ref:`valid <valid-externval-func>` with some :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\functype'_i`.
+
+* For each :ref:`table address <syntax-tableaddr>` :math:`\tableaddr_i` in :math:`\moduleinst.\MITABLES`, the :ref:`external value <syntax-externval>` :math:`\EVTABLE~\tableaddr_i` must be :ref:`valid <valid-externval-table>` with some :ref:`external type <syntax-externtype>` :math:`\ETTABLE~\tabletype_i`.
+
+* For each :ref:`memory address <syntax-memaddr>` :math:`\memaddr_i` in :math:`\moduleinst.\MIMEMS`, the :ref:`external value <syntax-externval>` :math:`\EVMEM~\memaddr_i` must be :ref:`valid <valid-externval-mem>` with some :ref:`external type <syntax-externtype>` :math:`\ETMEM~\memtype_i`.
+
+* For each :ref:`global address <syntax-globaladdr>` :math:`\globaladdr_i` in :math:`\moduleinst.\MIGLOBALS`, the :ref:`external value <syntax-externval>` :math:`\EVGLOBAL~\globaladdr_i` must be :ref:`valid <valid-externval-global>` with some :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~\globaltype_i`.
+
+* Each :ref:`export instance <syntax-exportinst>` :math:`\exportinst_i` in :math:`\moduleinst.\MIEXPORTS` must be :ref:`valid <valid-exportinst>`.
+
+* For each :ref:`export instance <syntax-exportinst>` :math:`\exportinst_i` in :math:`\moduleinst.\MIEXPORTS`, the :ref:`name <syntax-name>` :math:`\exportinst_i.\EINAME` must be different from any other name occurring in :math:`\moduleinst.\MIEXPORTS`.
+
+* Let :math:`{\functype'}^\ast` be the concatenation of all :math:`\functype'_i` in order.
+
+* Let :math:`\tabletype^\ast` be the concatenation of all :math:`\tabletype_i` in order.
+
+* Let :math:`\memtype^\ast` be the concatenation of all :math:`\memtype_i` in order.
+
+* Let :math:`\globaltype^\ast` be the concatenation of all :math:`\globaltype_i` in order.
+
+* Then the module instance is valid with :ref:`context <context>` :math:`\{\CTYPES~\functype^\ast, \CFUNCS~{\functype'}^\ast, \CTABLES~\tabletype^\ast, \CMEMS~\memtype^\ast, \CGLOBALS~\globaltype^\ast\}`.
+
+.. math::
+   ~\\[-1ex]
+   \frac{
+     \begin{array}{@{}c@{}}
+     (\vdashfunctype \functype \ok)^\ast
+     \\
+     (S \vdashexternval \EVFUNC~\funcaddr : \ETFUNC~\functype')^\ast
+     \qquad
+     (S \vdashexternval \EVTABLE~\tableaddr : \ETTABLE~\tabletype)^\ast
+     \\
+     (S \vdashexternval \EVMEM~\memaddr : \ETMEM~\memtype)^\ast
+     \qquad
+     (S \vdashexternval \EVGLOBAL~\globaladdr : \ETGLOBAL~\globaltype)^\ast
+     \\
+     (S \vdashexportinst \exportinst \ok)^\ast
+     \qquad
+     (\exportinst.\EINAME)^\ast ~\mbox{disjoint}
+     \end{array}
+   }{
+     S \vdashmoduleinst \{
+       \begin{array}[t]{@{}l@{~}l@{}}
+       \MITYPES & \functype^\ast, \\
+       \MIFUNCS & \funcaddr^\ast, \\
+       \MITABLES & \tableaddr^\ast, \\
+       \MIMEMS & \memaddr^\ast, \\
+       \MIGLOBALS & \globaladdr^\ast \\
+       \MIEXPORTS & \exportinst^\ast ~\} : \{
+         \begin{array}[t]{@{}l@{~}l@{}}
+         \CTYPES & \functype^\ast, \\
+         \CFUNCS & {\functype'}^\ast, \\
+         \CTABLES & \tabletype^\ast, \\
+         \CMEMS & \memtype^\ast, \\
+         \CGLOBALS & \globaltype^\ast ~\}
+         \end{array}
+       \end{array}
+   }
+
+
+.. index:: configuration, administrative instruction, store, frame
+.. _frame-context:
+.. _valid-config:
+
+Configuration Validity
+~~~~~~~~~~~~~~~~~~~~~~
+
+To relate the WebAssembly :ref:`type system <valid>` to its :ref:`execution semantics <exec>`, the :ref:`typing rules for instructions <valid-instr>` must be extended to :ref:`configurations <syntax-config>` :math:`S;T`,
+which relates the :ref:`store <syntax-store>` to execution :ref:`threads <syntax-thread>`.
+
+Threads may either be regular threads executing sequences of :ref:`instructions <syntax-instr>`, or module threads executing :ref:`module instructions <synax-moduleinstr>` that represent an ongoing module instantiation.
+Regular threads are classified by their :ref:`result type <syntax-resulttype>`.
+Module threads on the other hand have no result, not even an empty one.
+Consequently, threads and configurations are cumutavily classified by an *optional* result type, where :math:`\epsilon` classifies the thread as a module computation.
+
+In addition to the store :math:`S`, threads are typed under a *return type* :math:`\resulttype^?`, which controls whether and with which type a |return| instruction is allowed.
+This type is :math:`\epsilon`, except for instruction sequences inside an administrative |FRAME| instruction.
+
+Finally, :ref:`frames <syntax-frame>` are classified with *frame contexts*, which extend the :ref:`module contexts <module-context>` of a frame's associated :ref:`module instance <syntax-moduleinst>` with the :ref:`locals <syntax-local>` that the frame contains.
+
+
+.. index:: result type, thread
+
+:ref:`Configurations <syntax-config>` :math:`S;T`
+.................................................
+
+* The :ref:`store <syntax-store>` :math:`S` must be :ref:`valid <valid-store>`.
+
+* Under no allowed return type,
+  the :ref:`thread <syntax-thread>` :math:`T` must be :ref:`valid <valid-thread>` with some optional :ref:`result type <syntax-resulttype>` :math:`[t^?]^?`.
+
+* Then the configuration is valid with the optional :ref:`result type <syntax-resulttype>` :math:`[t^?]^?`.
+
+.. math::
+   \frac{
+     \vdashstore S \ok
+     \qquad
+     S; \epsilon \vdashthread T : [t^?]^?
+   }{
+     \vdashconfig S; T : [t^?]^?
+   }
+
+
+.. index:: thread, frame, instruction, result type, context
+.. _valid-thread:
+
+:ref:`Threads <syntax-thread>` :math:`F;\instr^\ast`
+....................................................
+
+* Let :math:`\resulttype^?` be the current allowed return type.
+
+* The :ref:`frame <syntax-frame>` :math:`F` must be :ref:`valid <valid-frame>` with a :ref:`context <context>` :math:`C`.
+
+* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with |CRETURN| set to :math:`\resulttype^?`.
+
+* Under context :math:`C'`,
+  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with some type :math:`[] \to [t^?]`.
+
+* Then the thread is valid with the :ref:`result type <syntax-resulttype>` :math:`[t^?]`.
+
+.. math::
+   \frac{
+     S \vdashframe F : C
+     \qquad
+     S; C,\CRETURN~\resulttype^? \vdashinstrseq \instr^\ast : [] \to [t^?]
+   }{
+     S; \resulttype^? \vdashthread F; \instr^\ast : [t^?]
+   }
+
+
+.. index:: thread, module instruction
+
+:ref:`Threads <syntax-thread>` :math:`\moduleinstr^\ast`
+........................................................
+
+* The current allowed return type must be empty.
+
+* Each :ref:`module instruction <syntax-moduleinstr>` :math:`\moduleinstr_i` in :math:`\moduleinstr^\ast` must be :ref:`valid <valid-moduleinstr>`.
+
+* Then the thread is valid with no :ref:`result type <syntax-resulttype>`.
+
+.. math::
+   \frac{
+     (S \vdashmoduleinstr \moduleinstr \ok)^\ast
+   }{
+     S; \epsilon \vdashthread \moduleinstr^\ast : \epsilon
+   }
+
+
+.. index:: frame, local, module instance, value, value type, context
+.. _valid-frame:
+
+:ref:`Frames <syntax-frame>` :math:`\{\ALOCALS~\val^\ast, \AMODULE~\moduleinst\}`
+.................................................................................
+
+* The :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst` must be :ref:`valid <valid-moduleinst>` with some :ref:`module context <module context>` :math:`C`.
+
+* Each :ref:`value <syntax-val>` :math:`\val_i` in :math:`\val^\ast` must be :ref:`valid <valid-val>` with some :ref:`value type <syntax-valtype>` :math:`t_i`.
+
+* Let :math:`t^\ast` the concatenation of all :math:`t_i` in order.
+
+* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`value types <syntax-valtype>` :math:`t^\ast` prepended to the |CLOCALS| vector.
+
+* Then the frame is valid with :ref:`frame context <frame-context>` :math:`C'`.
+
+.. math::
+   \frac{
+     S \vdashmoduleinst \moduleinst : C
+     \qquad
+     (\vdashval \val : t)^\ast
+   }{
+     S \vdashframe \{\ALOCALS~\val^\ast, \AMODULE~\moduleinst\} : (C, \CLOCALS~t^\ast)
+   }
+
+
+.. index:: value, value type
+.. _valid-val:
+
+:ref:`Values <syntax-val>` :math:`t.\CONST~c`
+.............................................
+
+* The value is valid with :ref:`value type <syntax-valtype>` :math:`t`.
+
+.. math::
+   \frac{
+   }{
+     \vdashval t.\CONST~c : t
+   }
+
+
+.. index:: administrative instruction, value type, context, store
+.. _valid-instr-admin:
+
+Administrative Instructions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Typing rules for :ref:`administrative instructions <syntax-instr-admin>` are specified as follows.
+In addition to the :ref:`context <contxt>` :math:`C`, typing of these instructions is defined under a given :ref:`store <syntax-store>` :math:`S`.
+To that end, all previous typing judgements :math:`C \vdash \X{prop}` are generalized to include the store, as in :math:`S; C \vdash \X{prop}`, by implicitly adding :math:`S` to all rules -- :math:`S` is never modified by the pre-existing rules, but it is accessed in the new rules for :ref:`administrative instructions <valid-instr-admin>` and  :ref:`module instructions <valid-moduleinstr>` given below.
+
+
+.. index:: trap
+
+:math:`\TRAP`
+.............
+
+* The instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
+
+.. math::
+   \frac{
+   }{
+     S; C \vdashadmininstr \TRAP : [t_1^\ast] \to [t_2^\ast]
+   }
+
+
+.. index:: function address, extern value, extern type, function type
+
+:math:`\INVOKE~\funcaddr`
+.........................
+
+* The :ref:`external function value <syntax-externval>` :math:`\EVFUNC~\funcaddr` must be :ref:`valid <valid-externval-func>` with :ref:`external function type <syntax-externtype>` :math:`\ETFUNC ([t_1^\ast] \to [t_2^\ast])`.
+
+* Then the instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
+
+.. math::
+   \frac{
+     S \vdashexternval \EVFUNC~\funcaddr : \ETFUNC~[t_1^\ast] \to [t_2^\ast]
+   }{
+     S; C \vdashadmininstr \INVOKE~\funcaddr : [t_1^\ast] \to [t_2^\ast]
+   }
+
+
+.. index:: label, instruction, result type
+
+:math:`\LABEL_n\{\instr_0^\ast\}~\instr^\ast~\END`
+..................................................
+
+* The instruction sequence :math:`\instr_0^\ast` must be :ref:`valid <valid-instr-seq>` with some type :math:`[t_1^n] \to [t_2^?]`.
+
+* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_1^n]` prepended to the |CLABELS| vector.
+
+* Under context :math:`C'`,
+  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \to [t_2^?]`.
+
+* Then the compound instruction is valid with type :math:`[] \to [t_2^?]`.
+
+.. math::
+   \frac{
+     S; C \vdashinstrseq \instr_0^\ast : [t_1^n] \to [t_2^?]
+     \qquad
+     S; C,\CLABELS\,[t_1^n] \vdashinstrseq \instr^\ast : [] \to [t_2^?]
+   }{
+     S; C \vdashadmininstr \LABEL_n\{\instr_0^\ast\}~\instr^\ast~\END : [] \to [t_2^?]
+   }
+
+
+.. index:: frame, instruction, result type
+
+:math:`\FRAME_n\{F\}~\instr^\ast~\END`
+...........................................
+
+* Under the return type :math:`[t^n]`,
+  the :ref:`thread <syntax-frame>` :math:`F; \instr^\ast` must be :ref:`valid <valid-frame>` with :ref:`result type <syntax-resulttype>` :math:`[t^n]`.
+
+* Then the compound instruction is valid with type :math:`[] \to [t^n]`.
+
+.. math::
+   \frac{
+     S; [t^n] \vdashinstrseq F; \instr^\ast : [t^n]
+   }{
+     S; C \vdashadmininstr \FRAME_n\{F\}~\instr^\ast~\END : [] \to [t^n]
+   }
+
+
+.. index:: module instruction, store
+.. _valid-moduleinstr:
+
+Module Instructions
+~~~~~~~~~~~~~~~~~~~
+
+Typing rules for :ref:`module instructions <valid-moduleinstr>` are specified as follows.
+Unlike regular instructions, module instructions do not use the operand stack, and consequently, are not classified by a type.
+
+
+.. index:: instantiation, external value, external type
+
+:math:`\INSTANTIATE~\module~\externval^\ast`
+............................................
+
+* Each :ref:`external value <syntax-externval>` :math:`\externval_i` in :math:`\externval^\ast` must be :ref:`valid <valid-externval>` with some :ref:`external type <syntax-externtype>` :math:`\externtype_i`.
+
+* Then the module instruction is valid.
+
+.. math::
+   \frac{
+     (S \vdashexternval \externval : \externtype)^\ast
+   }{
+     S \vdashmoduleinstr \INSTANTIATE~\module~\externval^\ast \ok
+   }
+
+
+.. index:: element, table, table address, module instance, function index
+
+:math:`\INITELEM~\tableaddr~o~\moduleinst~x^n`
+..............................................
+
+* The :ref:`external table value <syntax-externval>` :math:`\EVTABLE~\tableaddr` must be :ref:`valid <valid-externval-table>` with some :ref:`external table type <syntax-externtype>` :math:`\ETTABLE~\limits~\ANYFUNC`.
+
+* The index :math:`o + n` must be smaller than or equal to :math:`\limits.\LMIN`.
+
+* The :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst` must be :ref:`valid <valid-moduleinst>` with some :ref:`context <context>` :math:`C`.
+
+* Each :ref:`function index <syntax-funcidx>` :math:`x_i` in :math:`x^n` must be defined in the context :math:`C`.
+
+* Then the module instruction is valid.
+
+.. math::
+   \frac{
+     \begin{array}{@{}rl@{}}
+     S \vdashexternval \EVTABLE~\tableaddr : \ETTABLE~\limits~\ANYFUNC
+     \qquad&
+     o + n \leq \limits.\LMIN
+     \\
+     S \vdashmoduleinst \moduleinst : C
+     \qquad&
+     (C.\CFUNCS[x] = \functype)^n
+     \end{array}
+   }{
+     S \vdashmoduleinstr \INITELEM~\tableaddr~o~\moduleinst~x^n \ok
+   }
+
+
+.. index:: data, memory, memory address, byte
+
+:math:`\INITDATA~\memaddr~o~b^n`
+................................
+
+* The :ref:`external memory value <syntax-externval>` :math:`\EVMEM~\memaddr` must be :ref:`valid <valid-externval-mem>` with some :ref:`external memory type <syntax-externtype>` :math:`\ETMEM~\limits`.
+
+* The index :math:`o + n` must be smaller than or equal to :math:`\limits.\LMIN` divided by the :ref:`page size <page-size>` :math:`64\,\F{Ki}`.
+
+* Then the module instruction is valid.
+
+.. math::
+   \frac{
+     S \vdashexternval \EVMEM~\memaddr : \ETMEM~\limits
+     \qquad
+     o + n \leq \limits.\LMIN \cdot 64\,\F{Ki}
+   }{
+     S \vdashmoduleinstr \INITDATA~\memaddr~o~b^n \ok
+   }
+
+
+.. index:: instruction, context
+
+:math:`\instr`
+..............
+
+* Under an empty :ref:`context <context>`,
+  the :ref:`instruction <syntax-instr>` :math:`\instr` must be valid with type :math:`[] \to []`.
+
+* Then the instruction is valid as a module instruction.
+
+.. math::
+   \frac{
+     S; \{\} \vdashinstr \instr : [] \to []
+   }{
+     S \vdashmoduleinstr \instr \ok
+   }
+
+
+
+.. index:: ! store extension, store
+.. _extend:
+
+Store Extension
+~~~~~~~~~~~~~~~
+
+Programs can mutate the :ref:`store <syntax-store>` and its contained instances.
+Any such modification must respect certain invariants, such as not removing allocated instances or changing immutable definitions.
+While these invariants are inherent to the execution semantics of WebAssembly :ref:`instructions <exec-instr>` and :ref:`modules <exec-instantiation>`,
+:ref:`host functions <syntax-hostfunc>` do not automatically adhere to them. Consequently, the required invariants must be stated as explicit constraints on the :ref:`invocation <exec-invoke-host>` of host functions.
+Soundness only holds when the :ref:`embedder <embedder>` ensures these constraints.
+
+The necessary constraints are codified by the notion of store *extension*:
+a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S'`, when the following rules hold.
+
+.. note::
+   Extension does not imply that the new store is valid, which is defined :ref:separately `above <valid-store>`.
+
+
+.. index:: store, function instance, table instance, memory instance, global instance
+.. _extend-store:
+
+:ref:`Store <syntax-store>` :math:`S`
+.....................................
+
+* The length of :math:`S.\SFUNCS` must not shrink.
+
+* The length of :math:`S.\STABLES` must not shrink.
+
+* The length of :math:`S.\SMEMS` must not shrink.
+
+* The length of :math:`S.\SGLOBALS` must not shrink.
+
+* For each :ref:`function instance <syntax-funcinst>` :math:`\funcinst_i` in the original :math:`S.\SFUNCS`, the new function instance must be an :ref:`extension <extend-funcinst>` of the old.
+
+* For each :ref:`table instance <syntax-tableinst>` :math:`\tableinst_i` in the original :math:`S.\STABLES`, the new table instance must be an :ref:`extension <extend-tableinst>` of the old.
+
+* For each :ref:`memory instance <syntax-meminst>` :math:`\meminst_i` in the original :math:`S.\SMEMS`, the new memory instance must be an :ref:`extension <extend-meminst>` of the old.
+
+* For each :ref:`global instance <syntax-globalinst>` :math:`\globalinst_i` in the original :math:`S.\SGLOBALS`, the new global instance must be an :ref:`extension <extend-globalinst>` of the old.
+
+.. math::
+   \frac{
+     \begin{array}{@{}ccc@{}}
+     S_1.\SFUNCS = \funcinst_1^\ast &
+     S_2.\SFUNCS = {\funcinst'_1}^\ast~\funcinst_2^\ast &
+     (\funcinst_1 \extendsto \funcinst'_1)^\ast \\
+     S_1.\STABLES = \tableinst_1^\ast &
+     S_2.\STABLES = {\tableinst'_1}^\ast~\tableinst_2^\ast &
+     (\tableinst_1 \extendsto \tableinst'_1)^\ast \\
+     S_1.\SMEMS = \meminst_1^\ast &
+     S_2.\SMEMS = {\meminst'_1}^\ast~\meminst_2^\ast &
+     (\meminst_1 \extendsto \meminst'_1)^\ast \\
+     S_1.\SGLOBALS = \globalinst_1^\ast &
+     S_2.\SGLOBALS = {\globalinst'_1}^\ast~\globalinst_2^\ast &
+     (\globalinst_1 \extendsto \globalinst'_1)^\ast \\
+     \end{array}
+   }{
+     \vdashstoreextends S_1 \extendsto S_2
+   }
+
+
+.. index:: function instance
+.. _extend-funcinst:
+
+:ref:`Function Instance <syntax-funcinst>` :math:`\funcinst`
+............................................................
+
+* A function instance must remain unchanged.
+
+.. math::
+   \frac{
+   }{
+     \vdashfuncinstextends \funcinst \extendsto \funcinst
+   }
+
+
+.. index:: table instance
+.. _extend-tableinst:
+
+:ref:`Table Instance <syntax-tableinst>` :math:`\tableinst`
+...........................................................
+
+* The length of :math:`\tableinst.\TIELEM` must not shrink.
+
+* The value of :math:`\tableinst.\TIMAX` must remain unchanged.
+
+.. math::
+   \frac{
+     n_1 \leq n_2
+   }{
+     \vdashtableinstextends \{\TIELEM~(\X{fa}_1^?)^{n_1}, \TIMAX~m\} \extendsto \{\TIELEM~(\X{fa}_2^?)^{n_2}, \TIMAX~m\}
+   }
+
+
+.. index:: memory instance
+.. _extend-meminst:
+
+:ref:`Memory Instance <syntax-meminst>` :math:`\meminst`
+........................................................
+
+* The length of :math:`\meminst.\MIDATA` must not shrink.
+
+* The value of :math:`\meminst.\MIMAX` must remain unchanged.
+
+.. math::
+   \frac{
+     n_1 \leq n_2
+   }{
+     \vdashmeminstextends \{\MIDATA~b_1^{n_1}, \MIMAX~m\} \extendsto \{\MIDATA~b_2^{n_2}, \MIMAX~m\}
+   }
+
+
+.. index:: global instance, value, mutability
+.. _extend-globalinst:
+
+:ref:`Global Instance <syntax-globalinst>` :math:`\globalinst`
+..............................................................
+
+* The :ref:`mutability <syntax-mut>` :math:`\globalinst.\GIMUT` must remain unchanged.
+
+* The :ref:`value type <syntax-valtype>` of the :ref:`value <syntax-val>` :math:`\globalinst.\GIVALUE` must remain unchanged.
+
+* If :math:`\globalinst.\GIMUT` is |MCONST|, then the :ref:`value <syntax-val>` :math:`\globalinst.\GIVALUE` must remain unchanged.
+
+.. math::
+   \frac{
+     \mut = \MVAR \vee c_1 = c_2
+   }{
+     \vdashglobalinstextends \{\GIVALUE~(t.\CONST~c_1), \GIMUT~\mut\} \extendsto \{\GIVALUE~(t.\CONST~c_2), \GIMUT~\mut\}
+   }
+
+
+
+.. index:: ! preservation, ! progress, soundness, configuration, thread, terminal configuration, instantiation, invocation, validity, module
+.. _soundness-statement:
+
+Theorems
+~~~~~~~~
+
+Given the definition of :ref:`valid configurations <valid-config>`,
+the standard soundness theorems hold.
+
+**Theorem (Preservation).**
+If the :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` with optional :ref:`result type <syntax-resulttype>` :math:`[t^\ast]^?` (i.e., :math:`\vdashconfig S;T : [t^\ast]^?`),
+and steps to :math:`S';T'` (i.e., :math:`S;T \stepto S';T'`),
+then :math:`S';T'` is a valid configuration with the same optional resulttype (i.e., :math:`\vdashconfig S';T' : [t^\ast]^?`).
+Furthermore, :math:`S'` is an :ref:`extension <extend-store>` of :math:`S` (i.e., :math:`\vdashstoreextends S \extendsto S'`).
+
+A *terminal* :ref:`thread <syntax-thread>` is either an empty sequence of :ref:`module instructions <syntax-moduleinstr>`, a |TRAP| instruction, or a sequence :math:`\val^\ast` of :ref:`values <syntax-val>` (paired with a :ref:`frame <syntax-frame>`).
+A terminal configuration is a configuration whose thread is terminal.
+
+**Theorem (Progress).**
+If the :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` (i.e., :math:`\vdashconfig S;T : [t^\ast]^?` with some optional :ref:`result type <syntax-resulttype>` :math:`[t^\ast]^?`),
+then either it is terminal,
+or it can step to some configuration :math:`S';T'` (i.e., :math:`S;T \stepto S';T'`).
+
+From Preservation and Progress the soundness of the WebAssembly type system follows directly.
+
+**Corollary (Soundness).**
+Every thread in a valid configuration either runs forever, traps, or terminates with a result that has the expected type.
+
+Consequently, given a :ref:`valid store <valid-store>`, no computation defined by :ref:`instantiation <exec-instantiation>` or :ref:`invocation <exec-invocation>` of a valid module can "crash" or otherwise (mis)behave in ways not covered by the :ref:`execution <exec>` semantics given in this specification.
+
+
+.. [#pldi2017]
+   The formalization and theorems are derived from the following article:
+   Andreas Haas, Andreas Rossberg, Derek Schuff, Ben Titzer, Dan Gohman, Luke Wagner, Alon Zakai, JF Bastien, Michael Holman. `Bringing the Web up to Speed with WebAssembly <https://dl.acm.org/citation.cfm?doid=3062341.3062363>`_. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM 2017.
diff --git a/document/core/exec/conventions.rst b/document/core/exec/conventions.rst
index d054e1919..7c0df438d 100644
--- a/document/core/exec/conventions.rst
+++ b/document/core/exec/conventions.rst
@@ -13,7 +13,7 @@ Furthermore, there are rules describing the instantiation of a module.
 As with :ref:`validation <validation>`, all rules are given in two *equivalent* forms:
 
 1. In *prose*, describing the execution in intuitive form.
-2. In *formal notation*, describing the rule in mathematical form.
+2. In *formal notation*, describing the rule in mathematical form. [#pldi2017]_
 
 .. note::
    As with validation, the prose and formal rules are equivalent,
@@ -54,7 +54,7 @@ The following conventions are adopted in stating these rules.
 * In various places the rules contain *assertions* expressing crucial invariants about the program state.
 
 
-.. index:: ! reduction rules, ! configuration, evaluation context
+.. index:: ! reduction rules, configuration, evaluation context
 .. _exec-notation:
 
 Formal Notation
@@ -75,7 +75,8 @@ Each rule specifies one *step* of execution.
 As long as there is at most one reduction rule applicable to a given configuration, reduction -- and thereby execution -- is *deterministic*.
 WebAssembly has only very few exceptions to this, which are noted explicitly in this specification.
 
-For WebAssembly, a configuration is a tuple :math:`(S; F; \instr^\ast)` consisting of the current :ref:`store <store>` :math:`S`, the :ref:`call frame <frame>` :math:`F` of the current function, and the sequence of :ref:`instructions <syntax-instr>` that is to be executed.
+For WebAssembly, a configuration typically is a tuple :math:`(S; F; \instr^\ast)` consisting of the current :ref:`store <store>` :math:`S`, the :ref:`call frame <frame>` :math:`F` of the current function, and the sequence of :ref:`instructions <syntax-instr>` that is to be executed.
+(A more precise definition is given :ref:`later <syntax-config>`.)
 
 To avoid unnecessary clutter, the store :math:`S` and the frame :math:`F` are omitted from reduction rules that do not touch them.
 
@@ -125,5 +126,9 @@ or if a :ref:`trap <syntax-trap>` occurred.
    where :math:`x_4 = -x_2` and :math:`x_5 = -x_2 + x_3` and :math:`x_6 = x_1 \cdot (-x_2 + x_3)`.
 
 
+.. [#pldi2017]
+   The semantics is derived from the following article:
+   Andreas Haas, Andreas Rossberg, Derek Schuff, Ben Titzer, Dan Gohman, Luke Wagner, Alon Zakai, JF Bastien, Michael Holman. `Bringing the Web up to Speed with WebAssembly <https://dl.acm.org/citation.cfm?doid=3062341.3062363>`_. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM 2017.
+
 .. [#tapl]
    For example: Benjamin Pierce. `Types and Programming Languages <https://www.cis.upenn.edu/~bcpierce/tapl/>`_. The MIT Press 2002
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 7d20577b1..6e433e89b 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1077,9 +1077,12 @@ Host Functions
 
 Invoking a :ref:`host function <syntax-hostfunc>` has non-deterministic behavior.
 It may either terminate with a :ref:`trap <trap>` or return regularly.
-However, in the latter case, it is assumed that it consumes and produces the right number and types of WebAssembly :ref:`values <syntax-val>` on the stack,
+However, in the latter case, it must consume and produce the right number and types of WebAssembly :ref:`values <syntax-val>` on the stack,
 according to its :ref:`function type <syntax-functype>`.
+
 A host function may also modify the :ref:`store <syntax-store>`.
+However, all store modifications must result in an :ref:`extension <extend-store>` of the original store, i.e., they must only modify mutable contents and must not have instances removed.
+Furthermore, the resulting store must be :ref:`valid <valid-store>`, i.e., all data and code in it is well-typed.
 
 .. math::
    ~\\[-1ex]
@@ -1092,7 +1095,8 @@ A host function may also modify the :ref:`store <syntax-store>`.
      (\mbox{if} & S.\SFUNCS[a] = \{ \FITYPE~[t_1^n] \to [t_2^m], \FIHOSTCODE~\dots \} \\
      \wedge & \val_1^n = (t_1.\CONST~c_1)^n \\
      \wedge & \val_2^m = (t_2.\CONST~c_2)^m \\
-     \wedge & S' \succ S) \\
+     \wedge & \vdashstoreextends S \extendsto S' \\
+     \wedge & \vdashstore S' \ok) \\
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
@@ -1101,16 +1105,14 @@ A host function may also modify the :ref:`store <syntax-store>`.
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & S.\SFUNCS[a] = \{ \FITYPE~\X{ft}, \FIHOSTCODE~\dots \} \\ 
-     \wedge & S' \succ S) \\
+     \wedge & \vdashstoreextends S \extendsto S' \\
+     \wedge & \vdashstore S' \ok) \\
      \end{array} \\
    \end{array}
 
-Here, :math:`S' \succ S` expresses that the new store :math:`S'` is *reachable* from :math:`S`.
-Such a store must not contain fewer addresses than the original store,
-it must not differ in elements that are not mutable,
-and it must still be well-typed.
-
-.. todo:: Define this relation more precisely.
+Here, :math:`S \extendsto S'` expresses that the new store :math:`S'` is an :ref:`extension <extend>` of :math:`S`.
+Moreover, :math:`\vdashstore S' \ok` restricts :math:`S'` to be a :ref:`valid <valid-store>` store.
+Both notions are defined in the :ref:`Appendix <properties>`.
 
 .. note::
    A host function can call back into WebAssembly by :ref:`invoking <exec-invocation>` a function :ref:`exported <syntax-export>` from a :ref:`module <syntax-module>`.
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index c29355d33..81db4a504 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -14,7 +14,7 @@ External Typing
 
 For the purpose of checking :ref:`external values <syntax-externval>` against :ref:`imports <syntax-import>`,
 such values are classified by :ref:`external types <syntax-externtype>`.
-The following auxiliary typing rules specify this typing relation relative to a :ref:`store <syntax-store>` :math:`S` in which the external value lives.
+The following auxiliary typing rules specify this typing relation relative to a :ref:`store <syntax-store>` :math:`S` in which the referenced instances live.
 
 
 .. index:: function type, function address
@@ -31,7 +31,7 @@ The following auxiliary typing rules specify this typing relation relative to a
    \frac{
      S.\SFUNCS[a] = \{\FITYPE~\functype, \dots\}
    }{
-     S \vdash \EVFUNC~a : \ETFUNC~\functype
+     S \vdashexternval \EVFUNC~a : \ETFUNC~\functype
    }
 
 
@@ -49,7 +49,7 @@ The following auxiliary typing rules specify this typing relation relative to a
    \frac{
      S.\STABLES[a] = \{ \TIELEM~(\X{fa}^?)^n, \TIMAX~m^? \}
    }{
-     S \vdash \EVTABLE~a : \ETTABLE~(\{\LMIN~n, \LMAX~m^?\}~\ANYFUNC)
+     S \vdashexternval \EVTABLE~a : \ETTABLE~(\{\LMIN~n, \LMAX~m^?\}~\ANYFUNC)
    }
 
 
@@ -67,7 +67,7 @@ The following auxiliary typing rules specify this typing relation relative to a
    \frac{
      S.\SMEMS[a] = \{ \MIDATA~b^{n\cdot64\,\F{Ki}}, \MIMAX~m^? \}
    }{
-     S \vdash \EVMEM~a : \ETMEM~\{\LMIN~n, \LMAX~m^?\}
+     S \vdashexternval \EVMEM~a : \ETMEM~\{\LMIN~n, \LMAX~m^?\}
    }
 
 
@@ -85,14 +85,13 @@ The following auxiliary typing rules specify this typing relation relative to a
    \frac{
      S.\SGLOBALS[a] = \{ \GIVALUE~(t.\CONST~c), \GIMUT~\mut \}
    }{
-     S \vdash \EVGLOBAL~a : \ETGLOBAL~(\mut~t)
+     S \vdashexternval \EVGLOBAL~a : \ETGLOBAL~(\mut~t)
    }
 
 
-
 .. index:: ! matching, external type
 .. _exec-import:
-.. _match-externtype:
+.. _match:
 
 Import Matching
 ~~~~~~~~~~~~~~~
@@ -127,7 +126,7 @@ Limits
    \frac{
      n_1 \geq n_2
    }{
-     \vdash \{ \LMIN~n_1, \LMAX~m_1^? \} \leq \{ \LMIN~n_2, \LMAX~\epsilon \}
+     \vdashlimitsmatch \{ \LMIN~n_1, \LMAX~m_1^? \} \matches \{ \LMIN~n_2, \LMAX~\epsilon \}
    }
    \quad
    \frac{
@@ -135,10 +134,12 @@ Limits
      \qquad
      m_1 \leq m_2
    }{
-     \vdash \{ \LMIN~n_1, \LMAX~m_1 \} \leq \{ \LMIN~n_2, \LMAX~m_2 \}
+     \vdashlimitsmatch \{ \LMIN~n_1, \LMAX~m_1 \} \matches \{ \LMIN~n_2, \LMAX~m_2 \}
    }
 
 
+.. _match-externtype:
+
 .. index:: function type
 .. _match-functype:
 
@@ -153,7 +154,7 @@ An :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\functype_1` matches
    ~\\[-1ex]
    \frac{
    }{
-     \vdash \ETFUNC~\functype \leq \ETFUNC~\functype
+     \vdashexterntypematch \ETFUNC~\functype \matches \ETFUNC~\functype
    }
 
 
@@ -171,9 +172,9 @@ An :ref:`external type <syntax-externtype>` :math:`\ETTABLE~(\limits_1~\elemtype
 
 .. math::
    \frac{
-     \vdash \limits_1 \leq \limits_2
+     \vdashlimitsmatch \limits_1 \matches \limits_2
    }{
-     \vdash \ETTABLE~(\limits_1~\elemtype) \leq \ETTABLE~(\limits_2~\elemtype)
+     \vdashexterntypematch \ETTABLE~(\limits_1~\elemtype) \matches \ETTABLE~(\limits_2~\elemtype)
    }
 
 
@@ -189,9 +190,9 @@ An :ref:`external type <syntax-externtype>` :math:`\ETMEM~\limits_1` matches :ma
 
 .. math::
    \frac{
-     \vdash \limits_1 \leq \limits_2
+     \vdashlimitsmatch \limits_1 \matches \limits_2
    }{
-     \vdash \ETMEM~\limits_1 \leq \ETMEM~\limits_2
+     \vdashexterntypematch \ETMEM~\limits_1 \matches \ETMEM~\limits_2
    }
 
 
@@ -209,7 +210,7 @@ An :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~\globaltype_1` matc
    ~\\[-1ex]
    \frac{
    }{
-     \vdash \ETGLOBAL~\globaltype \leq \ETGLOBAL~\globaltype
+     \vdashexterntypematch \ETGLOBAL~\globaltype \matches \ETGLOBAL~\globaltype
    }
 
 
@@ -219,7 +220,7 @@ An :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~\globaltype_1` matc
 Allocation
 ~~~~~~~~~~
 
-New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tableinst>`, :ref:`memories <syntax-meminst>`, :ref:`globals <syntax-globalinst>`, and :ref:`modules <syntax-moduleinst>` are *allocated* in a :ref:`store <syntax-store>` :math:`S`, as defined by the following auxiliary functions.
+New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tableinst>`, :ref:`memories <syntax-meminst>`, and :ref:`globals <syntax-globalinst>` are *allocated* in a :ref:`store <syntax-store>` :math:`S`, as defined by the following auxiliary functions.
 
 
 .. index:: function, function instance, function address, module instance, function type
@@ -320,7 +321,7 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 1. Let :math:`\mem` be the :ref:`memory <syntax-mem>` to allocate.
 
-2. Let :math:`\{\LMIN~n, \LMAX~m^?\}` be the :ref:`table type <syntax-memtype>` :math:`\mem.\MTYPE`.
+2. Let :math:`\{\LMIN~n, \LMAX~m^?\}` be the :ref:`memory type <syntax-memtype>` :math:`\mem.\MTYPE`.
 
 3. Let :math:`a` be the first free :ref:`memory address <syntax-memaddr>` in :math:`S`.
 
@@ -347,13 +348,13 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 :ref:`Globals <syntax-globalinst>`
 ..................................
 
-1. Let :math:`\global` be the :ref:`global <syntax-global>` to allocate.
+1. Let :math:`\global` be the :ref:`global <syntax-global>` to allocate and :math:`\val` the :ref:`value <syntax-val>` to initialize it with.
 
 2. Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`\global.\GTYPE`.
 
 3. Let :math:`a` be the first free :ref:`global address <syntax-globaladdr>` in :math:`S`.
 
-4. Let :math:`\globalinst` be the :ref:`global instance <syntax-globalinst>` :math:`\{ \GIVALUE~(t.\CONST~0), \GIMUT~\mut \}` whose contents is a zero :ref:`value <syntax-val>` of :ref:`value type <syntax-valtype>` :math:`t`.
+4. Let :math:`\globalinst` be the :ref:`global instance <syntax-globalinst>` :math:`\{ \GIVALUE~\val, \GIMUT~\mut \}`.
 
 5. Append :math:`\globalinst` to the |SGLOBALS| of :math:`S`.
 
@@ -361,11 +362,11 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 .. math::
    \begin{array}{rlll}
-   \allocglobal(S, \global) &=& S', \globaladdr \\[1ex]
+   \allocglobal(S, \global, \val) &=& S', \globaladdr \\[1ex]
    \mbox{where:} \hfill \\
    \global.\GTYPE &=& \mut~t \\
    \globaladdr &=& |S.\SGLOBALS| \\
-   \globalinst &=& \{ \GIVALUE~(t.\CONST~0), \GIMUT~\mut \} \\
+   \globalinst &=& \{ \GIVALUE~\val, \GIMUT~\mut \} \\
    S' &=& S \compose \{\SGLOBALS~\globalinst\} \\
    \end{array}
 
@@ -376,9 +377,11 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 :ref:`Modules <syntax-moduleinst>`
 ..................................
 
-The allocation function for :ref:`modules <syntax-module>` requires a suitable list of :ref:`external values <syntax-externval>` that are assumed to :ref:`match <match-externtype>` the :ref:`import <syntax-import>` vector of the module.
+The allocation function for :ref:`modules <syntax-module>` requires a suitable list of :ref:`external values <syntax-externval>` that are assumed to :ref:`match <match-externtype>` the :ref:`import <syntax-import>` vector of the module,
+and a list of initialization :ref:`values <syntax-val>` for the module's :ref:`globals <syntax-global>`.
 
-1. Let :math:`\module` be the :ref:`module <syntax-module>` to allocate and :math:`\externval_{\F{im}}^\ast` the vector of :ref:`external values <syntax-externval>` providing the module's imports.
+1. Let :math:`\module` be the :ref:`module <syntax-module>` to allocate and :math:`\externval_{\F{im}}^\ast` the vector of :ref:`external values <syntax-externval>` providing the module's imports,
+and :math:`\val^\ast` the initialization :ref:`values <syntax-val>` of the module's :ref:`globals <syntax-global>`.
 
 2. For each :ref:`function <syntax-func>` :math:`\func_i` in :math:`\module.\MFUNCS`, do:
 
@@ -394,7 +397,7 @@ The allocation function for :ref:`modules <syntax-module>` requires a suitable l
 
 5. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
-   a. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\global_i`.
+   a. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\global_i` with initializer value :math:`\val^\ast[i]`.
 
 6. Let :math:`\funcaddr^\ast` be the the concatenation of the :ref:`function addresses <syntax-funcaddr>` :math:`\funcaddr_i` in index order.
 
@@ -434,7 +437,7 @@ The allocation function for :ref:`modules <syntax-module>` requires a suitable l
 .. math::
    ~\\
    \begin{array}{rlll}
-   \allocmodule(S, \module, \externval_{\F{im}}^\ast) &=& S', \moduleinst    \end{array}
+   \allocmodule(S, \module, \externval_{\F{im}}^\ast, \val^\ast) &=& S', \moduleinst    \end{array}
 
 where:
 
@@ -452,7 +455,7 @@ where:
    S_1, \funcaddr^\ast &=& \allocfunc^\ast(S, \module.\MFUNCS, \moduleinst) \\
    S_2, \tableaddr^\ast &=& \alloctable^\ast(S_1, \module.\MTABLES) \\
    S_3, \memaddr^\ast &=& \allocmem^\ast(S_2, \module.\MMEMS) \\
-   S', \globaladdr^\ast &=& \allocglobal^\ast(S_3, \module.\MGLOBALS) \\[1ex]
+   S', \globaladdr^\ast &=& \allocglobal^\ast(S_3, \module.\MGLOBALS, \val^\ast) \\[1ex]
    \exportinst^\ast &=& \{ \EINAME~(\export.\ENAME), \EIVALUE~\externval_{\F{ex}} \}^\ast
      \quad (\where \export^\ast = \module.\MEXPORTS) \\
    \evfuncs(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MIFUNCS[x])^\ast
@@ -465,15 +468,27 @@ where:
      \qquad\!\!\! (\where x^\ast = \edglobals(\module.\MEXPORTS)) \\
    \end{array}
 
-Here, the notation :math:`\F{allocX}^\ast` is shorthand for multiple :ref:`allocations <alloc>` of object kind :math:`X`, defined as follows:
+.. scratch
+   Here, in slight abuse of notation, :math:(`\F{allocxyz}(S, \dots))^\ast` is taken to express multiple allocations with the updates to the store :math:`S` being threaded through, i.e.,
+
+  .. math::
+   \begin{array}{rlll}
+   (\F{allocxyz}^\ast(S_0, \dots))^n &=& S_n, a^n \\[1ex]
+   \mbox{where for all $i < n$:} \hfill \\
+   S_{i+1}, a^n[i] &=& \F{allocxyz}(S_i, \dots)
+   \end{array}
+
+Here, the notation :math:`\F{allocx}^\ast` is shorthand for multiple :ref:`allocations <alloc>` of object kind :math:`X`, defined as follows:
 
 .. math::
    \begin{array}{rlll}
-   \F{allocX}^\ast(S_0, X^n, \dots) &=& S_n, a^n \\[1ex]
+   \F{allocx}^\ast(S_0, X^n, \dots) &=& S_n, a^n \\[1ex]
    \mbox{where for all $i < n$:} \hfill \\
-   S_{i+1}, a^n[i] &=& \F{allocX}(S_i, X^n[i], \dots)
+   S_{i+1}, a^n[i] &=& \F{allocx}(S_i, X^n[i], \dots)
    \end{array}
 
+Moreover, if the dots :math:`\dots` are a sequence :math:`A^n` (as for globals), then the elements of this sequence are passed to the allocation function pointwise.
+
 .. note::
    The definition of module allocation is mutually recursive with the allocation of its associated functions, because the resulting module instance :math:`\moduleinst` is passed to the function allocator as an argument, in order to form the necessary closures.
    In an implementation, this recursion is easily unraveled by mutating one or the other in a secondary step.
@@ -481,6 +496,7 @@ Here, the notation :math:`\F{allocX}^\ast` is shorthand for multiple :ref:`alloc
 
 .. index:: ! instantiation, module, instance, store, trap
 .. _exec-module:
+.. _exec-moduleinstr:
 .. _exec-instantiation:
 
 Instantiation
@@ -510,77 +526,79 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
       i. Fail.
 
-5. Let :math:`\moduleinst` be a new module instance :ref:`allocated <alloc-module>` from :math:`\module` in store :math:`S`.
+5. Let :math:`\moduleinst_{\F{im}}` be the auxiliary module instance :math:`\{\MIGLOBALS~\evglobals(\externval^\ast)\}` that only consists of the imported globals.
 
-6. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \}`.
+6. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~\moduleinst_{\F{im}}, \ALOCALS~\epsilon \}`.
 
 7. Push the frame :math:`F` to the stack.
 
-8. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEM`, do:
+8. Let :math:`\globalidx_{\F{new}}` be the :ref:`global index <syntax-globalidx>` that corresponds to the number of global :ref:`imports <syntax-import>` in :math:`\module.\MIMPORTS` (i.e., the index of the first non-imported global).
 
-   a. Let :math:`\X{eoval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\elem_i.\EOFFSET`.
+9. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
-   b. Assert: due to :ref:`validation <valid-elem>`, :math:`\X{eoval}_i` is of the form :math:`\I32.\CONST~\X{eo}_i`.
+   a. Let :math:`\val_i` be the result of :ref:`evaluating <exec-expr>` the initializer expression :math:`\global_i.\GINIT`.
 
-   c. Let :math:`\tableidx_i` be the :ref:`table index <syntax-tableidx>` :math:`\elem_i.\ETABLE`.
+   b. Let :math:`\globalidx_i` be the :ref:`global index <syntax-globalidx>` :math:`\globalidx_{\F{new}} + i`.
 
-   d. Assert: due to :ref:`validation <valid-elem>`, :math:`\moduleinst.\MITABLES[\tableidx_i]` exists.
+   c. Assert: due to :ref:`validation <valid-global>`, :math:`\moduleinst.\MIGLOBALS[\globalidx_i]` exists.
 
-   e. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` :math:`\moduleinst.\MITABLES[\tableidx_i]`.
+   d. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` :math:`\moduleinst.\MIGLOBALS[\globalidx_i]`.
 
-   f. Assert: due to :ref:`validation <valid-elem>`, :math:`S.\STABLES[\tableaddr_i]` exists.
+   e. Assert: due to :ref:`validation <valid-global>`, :math:`S.\SGLOBALS[\globaladdr_i]` exists.
 
-   g. Let :math:`\tableinst_i` be the :ref:`table instance <syntax-tableinst>` :math:`S.\STABLES[\tableaddr_i]`.
+   f. Let :math:`\globalinst_i` be the :ref:`global instance <syntax-globalinst>` :math:`S.\SGLOBALS[\globaladdr_i]`.
 
-   h. Let :math:`\X{eend}_i` be :math:`\X{eo}_i` plus the length of :math:`\elem_i.\EINIT`.
+10. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEM`, do:
 
-   i. If :math:`\X{eend}_i` is larger than the length of :math:`\tableinst_i.\TIELEM`, then:
+    a. Let :math:`\X{eoval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\elem_i.\EOFFSET`.
 
-      i. Fail.
+    b. Assert: due to :ref:`validation <valid-elem>`, :math:`\X{eoval}_i` is of the form :math:`\I32.\CONST~\X{eo}_i`.
 
-9. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATA`, do:
+    c. Let :math:`\tableidx_i` be the :ref:`table index <syntax-tableidx>` :math:`\elem_i.\ETABLE`.
 
-   a. Let :math:`\X{doval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\data_i.\DOFFSET`.
+    d. Assert: due to :ref:`validation <valid-elem>`, :math:`\moduleinst.\MITABLES[\tableidx_i]` exists.
 
-   b. Assert: due to :ref:`validation <valid-data>`, :math:`\X{doval}_i` is of the form :math:`\I32.\CONST~\X{do}_i`.
+    e. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` :math:`\moduleinst.\MITABLES[\tableidx_i]`.
 
-   c. Let :math:`\memidx_i` be the :ref:`memory index <syntax-memidx>` :math:`\data_i.\DMEM`.
+    f. Assert: due to :ref:`validation <valid-elem>`, :math:`S.\STABLES[\tableaddr_i]` exists.
 
-   d. Assert: due to :ref:`validation <valid-data>`, :math:`\moduleinst.\MIMEMS[\memidx_i]` exists.
+    g. Let :math:`\tableinst_i` be the :ref:`table instance <syntax-tableinst>` :math:`S.\STABLES[\tableaddr_i]`.
 
-   e. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` :math:`\moduleinst.\MIMEMS[\memidx_i]`.
+    h. Let :math:`\X{eend}_i` be :math:`\X{eo}_i` plus the length of :math:`\elem_i.\EINIT`.
 
-   f. Assert: due to :ref:`validation <valid-data>`, :math:`S.\SMEMS[\memaddr_i]` exists.
+    i. If :math:`\X{eend}_i` is larger than the length of :math:`\tableinst_i.\TIELEM`, then:
 
-   g. Let :math:`\meminst_i` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[\memaddr_i]`.
+       i. Fail.
 
-   h. Let :math:`\X{dend}_i` be :math:`\X{do}_i` plus the length of :math:`\data_i.\DINIT`.
+11. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATA`, do:
 
-   i. If :math:`\X{dend}_i` is larger than the length of :math:`\meminst_i.\MIDATA`, then:
+    a. Let :math:`\X{doval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\data_i.\DOFFSET`.
 
-      i. Fail.
+    b. Assert: due to :ref:`validation <valid-data>`, :math:`\X{doval}_i` is of the form :math:`\I32.\CONST~\X{do}_i`.
 
-10. Let :math:`\globalidx_{\F{new}}` be the :ref:`global index <syntax-globalidx>` that corresponds to the number of global :ref:`imports <syntax-import>` in :math:`\module.\MIMPORTS` (i.e., the index of the first non-imported global).
+    c. Let :math:`\memidx_i` be the :ref:`memory index <syntax-memidx>` :math:`\data_i.\DMEM`.
 
-11. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
+    d. Assert: due to :ref:`validation <valid-data>`, :math:`\moduleinst.\MIMEMS[\memidx_i]` exists.
 
-    a. Let :math:`\val_i` be the result of :ref:`evaluating <exec-expr>` the initializer expression :math:`\global_i.\GINIT`.
+    e. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` :math:`\moduleinst.\MIMEMS[\memidx_i]`.
 
-    b. Let :math:`\globalidx_i` be the :ref:`global index <syntax-globalidx>` :math:`\globalidx_{\F{new}} + i`.
+    f. Assert: due to :ref:`validation <valid-data>`, :math:`S.\SMEMS[\memaddr_i]` exists.
 
-    c. Assert: due to :ref:`validation <valid-global>`, :math:`\moduleinst.\MIGLOBALS[\globalidx_i]` exists.
+    g. Let :math:`\meminst_i` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[\memaddr_i]`.
 
-    d. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` :math:`\moduleinst.\MIGLOBALS[\globalidx_i]`.
+    h. Let :math:`\X{dend}_i` be :math:`\X{do}_i` plus the length of :math:`\data_i.\DINIT`.
 
-    e. Assert: due to :ref:`validation <valid-global>`, :math:`S.\SGLOBALS[\globaladdr_i]` exists.
+    i. If :math:`\X{dend}_i` is larger than the length of :math:`\meminst_i.\MIDATA`, then:
 
-    f. Let :math:`\globalinst_i` be the :ref:`global instance <syntax-globalinst>` :math:`S.\SGLOBALS[\globaladdr_i]`.
+       i. Fail.
 
 12. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F` is now on the top of the stack.
 
 13. Pop the frame from the stack.
 
-14. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEM`, do:
+14. Let :math:`\moduleinst` be a new module instance :ref:`allocated <alloc-module>` from :math:`\module` in store :math:`S` with imports :math:`\externval^\ast` and glboal initializer values :math:`\val^\ast`.
+
+15. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEM`, do:
 
     a. For each :ref:`function index <syntax-funcidx>` :math:`\funcidx_{ij}` in :math:`\elem_i.\EINIT` (starting with :math:`j = 0`), do:
 
@@ -590,16 +608,12 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
        iii. Replace :math:`\tableinst_i.\TIELEM[\X{eo}_i + j]` with :math:`\funcaddr_{ij}`.
 
-15. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATA`, do:
+16. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATA`, do:
 
     a. For each :ref:`byte <syntax-byte>` :math:`b_{ij}` in :math:`\data_i.\DINIT` (starting with :math:`j = 0`), do:
 
        i. Replace :math:`\meminst_i.\MIDATA[\X{do}_i + j]` with :math:`b_{ij}`.
 
-16. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
-
-    a. Replace :math:`\globalinst_i.\GIVALUE` with :math:`\val_i`.
-
 17. If the :ref:`start function <syntax-start>` :math:`\module.\MSTART` is not empty, then:
 
     a. Assert: due to :ref:`validation <valid-start>`, :math:`\moduleinst.\MIFUNCS[\module.\MSTART.\SFUNC]` exists.
@@ -614,51 +628,46 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
    \begin{array}{@{}rcll}
    S; \INSTANTIATE~\module~\externval^n &\stepto& S';
      \begin{array}[t]{@{}l@{}}
-     (\INITTABLE~\tableaddr~\X{eo}~\moduleinst~\elem.\EINIT)^\ast \\
-     (\INITMEM~\memaddr~\X{do}~\data.\DINIT)^\ast \\
-     (\INITGLOBAL~\globaladdr~v)^\ast \\
+     (\INITELEM~\tableaddr~\X{eo}~\moduleinst~\elem.\EINIT)^\ast \\
+     (\INITDATA~\memaddr~\X{do}~\data.\DINIT)^\ast \\
      (\INVOKE~\funcaddr)^? \\
-     \moduleinst \\
      \end{array} \\
    &(\iff
-     & \vdash \module : \externtype^n \\
-     &\wedge& (\vdash \externval : \externtype')^n \\
-     &\wedge& (\vdash \externtype' \leq \externtype)^n \\[1ex]
+     & \vdashmodule \module : \externtype^n \\
+     &\wedge& (\vdashexternval \externval : \externtype')^n \\
+     &\wedge& (\vdashexterntypematch \externtype' \matches \externtype)^n \\[1ex]
      &\wedge& \module.\MGLOBALS = \global^k \\
      &\wedge& \module.\MELEM = \elem^\ast \\
      &\wedge& \module.\MDATA = \data^\ast \\
      &\wedge& \module.\MSTART = \start^? \\[1ex]
-     &\wedge& S', \moduleinst = \F{allocmodule}(S, \module, \externval^n) \\
+     &\wedge& S', \moduleinst = \F{allocmodule}(S, \module, \externval^n, v^\ast) \\
      &\wedge& F = \{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \} \\[1ex]
+     &\wedge& (S'; F; \global.\GINIT \stepto^\ast S'; F; v)^\ast \\
      &\wedge& (S'; F; \elem.\EOFFSET \stepto^\ast S'; F; \I32.\CONST~\X{eo})^\ast \\
-     &\wedge& (S'; F; \data.\DOFFSET \stepto^\ast S'; F; \I32.\CONST~\X{do})^\ast \\
-     &\wedge& (S'; F; \global.\GINIT \stepto^\ast S'; F; v)^\ast \\[1ex]
-     &\wedge& (\tableaddr = \moduleinst.\MITABLES[\elem.\ETABLE])^\ast \\
-     &\wedge& (\memaddr = \moduleinst.\MIMEMS[\data.\DMEM])^\ast \\
-     &\wedge& \globaladdr^\ast = \moduleinst.\MIGLOBALS[|\moduleinst.\MIGLOBALS|-k \slice k] \\
-     &\wedge& (\funcaddr = \moduleinst.\MIFUNCS[\start.\SFUNC])^? \\[1ex]
+     &\wedge& (S'; F; \data.\DOFFSET \stepto^\ast S'; F; \I32.\CONST~\X{do})^\ast \\[1ex]
      &\wedge& (\X{eo} + |\elem.\EINIT| \leq |S'.\STABLES[\tableaddr].\TIELEM|)^\ast \\
      &\wedge& (\X{do} + |\data.\DINIT| \leq |S'.\SMEMS[\memaddr].\MIDATA|)^\ast
      )
+   \\[1ex]
+     &\wedge& \globaladdr^\ast = \moduleinst.\MIGLOBALS[|\moduleinst.\MIGLOBALS|-k \slice k] \\
+     &\wedge& (\tableaddr = \moduleinst.\MITABLES[\elem.\ETABLE])^\ast \\
+     &\wedge& (\memaddr = \moduleinst.\MIMEMS[\data.\DMEM])^\ast \\
+     &\wedge& (\funcaddr = \moduleinst.\MIFUNCS[\start.\SFUNC])^?
    \\[1ex]
    S; \INSTANTIATE~\module~\externval^n &\stepto&
      S'; \TRAP  \qquad (\otherwise)
    \\[2ex]
-   S; \INITTABLE~a~i~m~\epsilon &\stepto&
+   S; \INITELEM~a~i~m~\epsilon &\stepto&
      S; \epsilon \\
-   S; \INITTABLE~a~i~m~(x_0~x^\ast) &\stepto&
-     S'; \INITTABLE~a~(i+1)~m~x^\ast \\ &&
+   S; \INITELEM~a~i~m~(x_0~x^\ast) &\stepto&
+     S'; \INITELEM~a~(i+1)~m~x^\ast \\ &&
      (\iff S' = S \with \STABLES[a].\TIELEM[i] = m.\MIFUNCS[x_0])
    \\[1ex]
-   S; \INITMEM~a~i~\epsilon &\stepto&
+   S; \INITDATA~a~i~\epsilon &\stepto&
      S; \epsilon \\
-   S; \INITMEM~a~i~(b_0~b^\ast) &\stepto&
-     S'; \INITMEM~a~(i+1)~b^\ast \\ &&
+   S; \INITDATA~a~i~(b_0~b^\ast) &\stepto&
+     S'; \INITDATA~a~(i+1)~b^\ast \\ &&
      (\iff S' = S \with \SMEMS[a].\MIDATA[i] = b_0)
-   \\[1ex]
-   S; \INITGLOBAL~a~v &\stepto&
-     S'; \epsilon \\ &&
-     (\iff S' = S \with \SGLOBALS[a] = v) \\
    \end{array}
 
 .. note::
@@ -666,6 +675,8 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
    Store mutation is not atomic;
    it happens in individual steps that may be interleaved with other threads.
 
+   Evaluation of :ref:`constant expressions <valid-constant>` does not affect the store.
+
 
 .. index:: ! invocation, module, module instance, function, export, function address, function instance, function type, value, stack, trap, store
 .. _exec-invocation:
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index b721836e0..5d81db128 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -136,7 +136,7 @@ and collects runtime representations of all entities that are imported, defined,
      \MIFUNCS & \funcaddr^\ast, \\
      \MITABLES & \tableaddr^\ast, \\
      \MIMEMS & \memaddr^\ast, \\
-     \MIGLOBALS & \globaladdr^\ast \\
+     \MIGLOBALS & \globaladdr^\ast, \\
      \MIEXPORTS & \exportinst^\ast ~\} \\
      \end{array}
    \end{array}
@@ -307,6 +307,7 @@ It filters out entries of a specific kind in an order-preserving fashion:
 * :math:`\evglobals(\externval^\ast) = [\globaladdr ~|~ (\EVGLOBAL~\globaladdr) \in \externval^\ast]`
 
 
+
 .. index:: ! stack, ! frame, ! label, instruction, store, activation, function, call, local, module instance
    pair: abstract syntax; frame
    pair: abstract syntax; label
@@ -492,51 +493,11 @@ This definition allows to index active labels surrounding a :ref:`branch <syntax
    The selected label is identified through the :ref:`label index <syntax-labelidx>` :math:`l`, which corresponds to the number of surrounding |LABEL| instructions that must be hopped over -- which is exactly the count encoded in the index of a block context.
 
 
-.. index:: ! evaluation context, instruction, trap, label, frame, value
-.. _syntax-ctxt-eval:
-
-Evaluation Contexts
-...................
-
-Finally, the following definition of *evaluation context* and associated structural rules enable reduction inside instruction sequences and administrative forms as well as the propagation of traps:
-
-.. math::
-   \begin{array}{llll}
-   \production{(evaluation contexts)} & E &::=&
-     [\_] ~|~
-     \val^\ast~E~\instr^\ast ~|~
-     \LABEL_n\{\instr^\ast\}~E~\END ~|~
-     \FRAME_n\{\frame\}~E~\END \\
-   \end{array}
-
-.. math::
-   \begin{array}{lcl@{\qquad}l}
-   S; F; E[\instr^\ast] &\stepto& S'; F'; E[{\instr'}^\ast]
-     & (\iff S; F; \instr^\ast \stepto S'; F'; {\instr'}^\ast) \\
-   S; F; E[\TRAP] &\stepto& S; F; \TRAP
-     & (\iff E \neq [\_]) \\
-   \end{array}
-
-.. note::
-   For example, the following instruction sequence,
-
-   .. math::
-       (\F64.\CONST~x_1)~(\F64.\CONST~x_2)~\F64.\NEG~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL
-
-   can be decomposed into :math:`E[(\F64.\CONST~x_2)~\F64.\NEG]` where
-
-   .. math::
-      E = (\F64.\CONST~x_1)~[\_]~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL
-
-   Moreover, this is the *only* possible choice of evaluation context where the contents of the hole matches the left-hand side of a reduction rule.
-
-
 .. index:: ! module instructions, function, function instance, function address, label, frame, instruction, trap, global, global instance, memory, memory instance, table, table instance, invocation, start function
    pair:: abstract syntax; meta instruction
 .. _syntax-instantiate:
-.. _syntax-init_table:
-.. _syntax-init_mem:
-.. _syntax-init_global:
+.. _syntax-init_elem:
+.. _syntax-init_data:
 .. _syntax-moduleinstr:
 
 Module Instructions
@@ -548,18 +509,18 @@ It is hence expressed in terms of reduction into smaller steps expressed by a se
 .. math::
    \begin{array}{llcl}
    \production{(module instruction)} & \moduleinstr &::=&
-     \instr \\ &&|&
      \INSTANTIATE~\module~\externval^\ast \\ &&|&
-     \INITTABLE~\tableaddr~\u32~\moduleinst~funcidx^\ast \\ &&|&
-     \INITMEM~\memaddr~\u32~\byte^\ast \\ &&|&
-     \INITGLOBAL~\globaladdr~\val \\ &&|&
-     \moduleinst \\
+     \INITELEM~\tableaddr~\u32~\moduleinst~\funcidx^\ast \\ &&|&
+     \INITDATA~\memaddr~\u32~\byte^\ast \\ &&|&
+     \instr \\
    \end{array}
 
 The |INSTANTIATE| instruction expresses instantiation of a :ref:`module <syntax-module>` itself, requiring a sequence of :ref:`external values <syntax-externval>` for the expected imports.
-It reduces into a sequence of initialization instructions for :ref:`tables <syntax-table>`, :ref:`memories <syntax-mem>` and :ref:`globals <syntax-global>`,
-and a possible :ref:`invocation <syntax-invoke>` of the :ref:`start function <syntax-start>`.
-The final instruction returns the newly created and initialized :ref:`module instance <syntax-moduleinst>`.
+It reduces into a sequence of initialization instructions for :ref:`element <syntax-elem>` and :ref:`data <syntax-data>` segments,
+and a possible :ref:`invocation <syntax-invoke>` of the :ref:`start function <syntax-start>` that reduces further to a sequence of regular instructions.
+
+.. comment out
+   The final instruction returns the newly created and initialized :ref:`module instance <syntax-moduleinst>`.
 
 .. note::
    The reason for splitting instantiation into individual reduction steps is to provide a semantics that is compatible with future extensions like threads.
@@ -568,23 +529,80 @@ The final instruction returns the newly created and initialized :ref:`module ins
    module instructions *embed* ordinary instructions |instr| instead of extending them.
    Consequently, they can only occur at the top-level.
 
-Evaluation contexts and additional structural reduction rules for module instructions are defined as follows:
+
+.. index:: ! configuration, ! thread, store, frame, instruction, module instruction
+.. _syntax-thread:
+.. _syntax-config:
+
+Configurations
+..............
+
+A *configuration* consists of the current :ref:`store <syntax-store>` and an executing *thread*.
+
+A thread can either be a regular computation over :ref:`instructions <syntax-instr>`, or a module instantiation, represented as a computation over :ref:`module instructions <syntax-moduleinstr>`.
+Regular computation operates relative to a current :ref:`frame <syntax-frame>` referring to their home :ref:`module instance <syntax-moduleinst>`,
+whereas module computations are not local to a module, and consequently require no frame.
+
+.. math::
+   \begin{array}{llcl}
+   \production{(configuration)} & \config &::=&
+     \store; \thread \\
+   \production{(thread)} & \thread &::=&
+     \frame; \instr^\ast ~|~
+     \moduleinstr^\ast \\
+   \end{array}
+
+.. note::
+   The current version of WebAssembly is single-threaded,
+   but configurations with multiple threads may be supported in the future.
+
+
+.. index:: ! evaluation context, instruction, trap, label, frame, value
+.. _syntax-ctxt-eval:
+
+Evaluation Contexts
+...................
+
+Finally, the following definition of *evaluation context* and associated structural rules enable reduction inside instruction sequences and administrative forms as well as the propagation of traps:
 
 .. math::
    \begin{array}{llll}
+   \production{(evaluation contexts)} & E &::=&
+     [\_] ~|~
+     \val^\ast~E~\instr^\ast ~|~
+     \LABEL_n\{\instr^\ast\}~E~\END ~|~
+     \FRAME_n\{\frame\}~E~\END \\
    \production{(module evaluation contexts)} & M &::=&
-     E~~\moduleinstr^\ast~~\moduleinst \\
+     [\_]~~\moduleinstr^\ast \\
    \end{array}
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   S; M[\moduleinstr] &\stepto& S'; M[{\moduleinstr'}^\ast]
-     & (\iff S; \moduleinstr \stepto S'; {\moduleinstr'}^\ast) \\
+   S; F; E[\instr^\ast] &\stepto& S'; F'; E[{\instr'}^\ast]
+     & (\iff S; F; \instr^\ast \stepto S'; F'; {\instr'}^\ast) \\
+   S; F; E[\TRAP] &\stepto& S; F; \TRAP
+     & (\iff E \neq [\_]) \\
+   S; M[E[\instr]] &\stepto& S'; M[E[{\instr'}^\ast]]
+     & (\iff S; F_0; \instr \stepto S'; F_0; {\instr'}^\ast) \\
    S; M[\TRAP] &\stepto& S; \TRAP
      & (\iff M \neq [\_]) \\
    \end{array}
 
-Reduction terminates when the sequence has been reduced to a |moduleinst| or when a trap occurred.
+where :math:`F_0 = \{\ALOCALS~\epsilon, \AMODULE~\{\}\}` is an empty dummy frame.
+
+Reduction terminates for a regular thread when its instruction sequence has been reduced to a sequence of :ref:`values <syntax-val>` or to a |TRAP|.
+Reduction terminates for a module thread when its module instruction sequence has been reduced to an empty sequence or to a |TRAP|.
+
 
 .. note::
-   A trap may either arise from invocation of a :ref:`start function <syntax-start>` or indicate failure of the |INSTANTIATE| instruction itself.
+   For example, the following instruction sequence,
+
+   .. math::
+       (\F64.\CONST~x_1)~(\F64.\CONST~x_2)~\F64.\NEG~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL
+
+   can be decomposed into :math:`E[(\F64.\CONST~x_2)~\F64.\NEG]` where
+
+   .. math::
+      E = (\F64.\CONST~x_1)~[\_]~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL
+
+   Moreover, this is the *only* possible choice of evaluation context where the contents of the hole matches the left-hand side of a reduction rule.
diff --git a/document/core/index.rst b/document/core/index.rst
index 124f2f8c6..f6dca0a22 100644
--- a/document/core/index.rst
+++ b/document/core/index.rst
@@ -3,7 +3,7 @@ WebAssembly Specification
 
 .. only:: html
 
-   Release |release| (work in progress, last updated |today|)
+   Release |release| (Draft, last updated |today|)
 
 .. toctree::
    :maxdepth: 3
@@ -20,10 +20,14 @@ WebAssembly Specification
 
    .. toctree::
 
-      syntax/instrindex
+      appendix/index-types
+      appendix/index-instructions
+      appendix/index-rules
 
 .. only:: html
 
-   * :ref:`instrindex`
+   * :ref:`index-type`
+   * :ref:`index-instr`
+   * :ref:`index-rules`
 
    * :ref:`genindex`
diff --git a/document/core/util/math.def b/document/core/util/math.def
index ca6ea49e4..ed2d48ff0 100644
--- a/document/core/util/math.def
+++ b/document/core/util/math.def
@@ -114,6 +114,8 @@
 
 .. Types, terminals
 
+.. |to| mathdef:: \xref{syntax/types}{syntax-functype}{\rightarrow}
+
 .. |I8| mathdef:: \xref{exec/runtime}{syntax-storagetype}{\K{i8}}
 .. |I16| mathdef:: \xref{exec/runtime}{syntax-storagetype}{\K{i16}}
 .. |I32| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i32}}
@@ -371,6 +373,7 @@
 .. |Bu64| mathdef:: \xref{binary/values}{binary-int}{\BuX{\B{64}}}
 
 .. |BsN| mathdef:: \xref{binary/values}{binary-int}{\BsX{N}}
+.. |Bs7| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{7}}}
 .. |Bs32| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{32}}}
 .. |Bs64| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{64}}}
 
@@ -651,6 +654,7 @@
 .. Notation
 
 .. |ok| mathdef:: \mathrel{\mbox{ok}}
+.. |const| mathdef:: \xref{valid/instructions}{valid-constant}{\mathrel{\mbox{const}}}
 
 
 .. Contexts
@@ -665,13 +669,42 @@
 .. |CRETURN| mathdef:: \xref{valid/conventions}{context}{\K{return}}
 
 
+.. Judgments
+
+.. |vdashlimits| mathdef:: \xref{valid/types}{valid-limits}{\vdash}
+.. |vdashfunctype| mathdef:: \xref{valid/types}{valid-functype}{\vdash}
+.. |vdashtabletype| mathdef:: \xref{valid/types}{valid-tabletype}{\vdash}
+.. |vdashmemtype| mathdef:: \xref{valid/types}{valid-memtype}{\vdash}
+.. |vdashglobaltype| mathdef:: \xref{valid/types}{valid-globaltype}{\vdash}
+
+.. |vdashinstr| mathdef:: \xref{valid/instructions}{valid-instr}{\vdash}
+.. |vdashinstrseq| mathdef:: \xref{valid/instructions}{valid-instr-seq}{\vdash}
+.. |vdashexpr| mathdef:: \xref{valid/instructions}{valid-expr}{\vdash}
+.. |vdashexprconst| mathdef:: \xref{valid/instructions}{valid-constant}{\vdash}
+.. |vdashinstrconst| mathdef:: \xref{valid/instructions}{valid-constant}{\vdash}
+
+.. |vdashfunc| mathdef:: \xref{valid/modules}{valid-func}{\vdash}
+.. |vdashtable| mathdef:: \xref{valid/modules}{valid-table}{\vdash}
+.. |vdashmem| mathdef:: \xref{valid/modules}{valid-mem}{\vdash}
+.. |vdashglobal| mathdef:: \xref{valid/modules}{valid-global}{\vdash}
+.. |vdashelem| mathdef:: \xref{valid/modules}{valid-elem}{\vdash}
+.. |vdashdata| mathdef:: \xref{valid/modules}{valid-data}{\vdash}
+.. |vdashstart| mathdef:: \xref{valid/modules}{valid-start}{\vdash}
+.. |vdashexport| mathdef:: \xref{valid/modules}{valid-export}{\vdash}
+.. |vdashexportdesc| mathdef:: \xref{valid/modules}{valid-exportdesc}{\vdash}
+.. |vdashimport| mathdef:: \xref{valid/modules}{valid-import}{\vdash}
+.. |vdashimportdesc| mathdef:: \xref{valid/modules}{valid-importdesc}{\vdash}
+.. |vdashmodule| mathdef:: \xref{valid/modules}{valid-module}{\vdash}
+
 
 .. Execution
 .. ---------
 
 .. Notation
 
-.. |stepto| mathdef:: \hookrightarrow
+.. |stepto| mathdef:: \xref{exec/conventions}{formal-notation}{\hookrightarrow}
+.. |extendsto| mathdef:: \xref{appendix/properties}{extend}{\preceq}
+.. |matches| mathdef:: \xref{exec/modules}{match}{\leq}
 
 
 .. Allocation
@@ -781,9 +814,9 @@
 .. |TRAP| mathdef:: \xref{exec/runtime}{syntax-trap}{\K{trap}}
 .. |INVOKE| mathdef:: \xref{exec/runtime}{syntax-invoke}{\K{invoke}}
 .. |INSTANTIATE| mathdef:: \xref{exec/runtime}{syntax-instantiate}{\K{instantiate}}
-.. |INITGLOBAL| mathdef:: \xref{exec/runtime}{syntax-init_global}{\K{init\_global}}
-.. |INITTABLE| mathdef:: \xref{exec/runtime}{syntax-init_table}{\K{init\_table}}
-.. |INITMEM| mathdef:: \xref{exec/runtime}{syntax-init_mem}{\K{init\_mem}}
+.. |INITELEM| mathdef:: \xref{exec/runtime}{syntax-init_elem}{\K{init\_elem}}
+.. |INITDATA| mathdef:: \xref{exec/runtime}{syntax-init_data}{\K{init\_data}}
+.. |DO| mathdef:: \xref{exec/runtime}{syntax-do}{\K{do}}
 
 
 .. Values & Administrative Instructions, non-terminals
@@ -795,6 +828,12 @@
 .. |XB| mathdef:: \xref{exec/runtime}{syntax-ctxt-block}{B}
 
 
+.. Configurations, non-terminals
+
+.. |config| mathdef:: \xref{exec/runtime}{syntax-config}{\X{config}}
+.. |thread| mathdef:: \xref{exec/runtime}{syntax-thread}{\X{thread}}
+
+
 .. Numerics, operators
 
 .. |iadd| mathdef:: \xref{exec/numerics}{op-iadd}{\F{iadd}}
@@ -883,6 +922,41 @@
 .. |invoke| mathdef:: \xref{exec/modules}{exec-invocation}{\F{invoke}}
 
 
+.. Judgements
+
+.. |vdashexternval| mathdef:: \xref{exec/modules}{valid-externval}{\vdash}
+
+.. |vdashlimitsmatch| mathdef:: \xref{exec/modules}{match-limits}{\vdash}
+.. |vdashexterntypematch| mathdef:: \xref{exec/modules}{match-externtype}{\vdash}
+
+
+.. Soundness
+.. ---------
+
+.. Judgements
+
+.. |vdashadmininstr| mathdef:: \xref{appendix/properties}{valid-instr-admin}{\vdash}
+.. |vdashmoduleinstr| mathdef:: \xref{appendix/properties}{valid-moduleinstr}{\vdash}
+
+.. |vdashfuncinst| mathdef:: \xref{appendix/properties}{valid-funcinst}{\vdash}
+.. |vdashtableinst| mathdef:: \xref{appendix/properties}{valid-tableinst}{\vdash}
+.. |vdashmeminst| mathdef:: \xref{appendix/properties}{valid-meminst}{\vdash}
+.. |vdashglobalinst| mathdef:: \xref{appendix/properties}{valid-globalinst}{\vdash}
+.. |vdashexportinst| mathdef:: \xref{appendix/properties}{valid-exportinst}{\vdash}
+.. |vdashmoduleinst| mathdef:: \xref{appendix/properties}{valid-moduleinst}{\vdash}
+
+.. |vdashstore| mathdef:: \xref{appendix/properties}{valid-store}{\vdash}
+.. |vdashconfig| mathdef:: \xref{appendix/properties}{valid-config}{\vdash}
+.. |vdashthread| mathdef:: \xref{appendix/properties}{valid-thread}{\vdash}
+.. |vdashframe| mathdef:: \xref{appendix/properties}{valid-frame}{\vdash}
+.. |vdashval| mathdef:: \xref{appendix/properties}{valid-val}{\vdash}
+
+.. |vdashfuncinstextends| mathdef:: \xref{appendix/properties}{extend-funcinst}{\vdash}
+.. |vdashtableinstextends| mathdef:: \xref{appendix/properties}{extend-tableinst}{\vdash}
+.. |vdashmeminstextends| mathdef:: \xref{appendix/properties}{extend-meminst}{\vdash}
+.. |vdashglobalinstextends| mathdef:: \xref{appendix/properties}{extend-globalinst}{\vdash}
+.. |vdashstoreextends| mathdef:: \xref{appendix/properties}{extend-store}{\vdash}
+
 
 .. Custom Sections
 .. ---------------
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index 1ff1104a2..5b0908817 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -12,7 +12,7 @@ For each piece of abstract syntax, there is a typing rule that specifies the con
 All rules are given in two *equivalent* forms:
 
 1. In *prose*, describing the meaning in intuitive form.
-2. In *formal notation*, describing the rule in mathematical form.
+2. In *formal notation*, describing the rule in mathematical form. [#pldi2017]_
 
 .. note::
    The prose and formal rules are equivalent,
@@ -184,5 +184,9 @@ and there is one respective rule for each relevant construct :math:`A` of the ab
    which is expressed by extending the context :math:`C` with the additional label information for the premise.
 
 
+.. [#pldi2017]
+   The semantics is derived from the following article:
+   Andreas Haas, Andreas Rossberg, Derek Schuff, Ben Titzer, Dan Gohman, Luke Wagner, Alon Zakai, JF Bastien, Michael Holman. `Bringing the Web up to Speed with WebAssembly <https://dl.acm.org/citation.cfm?doid=3062341.3062363>`_. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM 2017.
+
 .. [#tapl]
    For example: Benjamin Pierce. `Types and Programming Languages <https://www.cis.upenn.edu/~bcpierce/tapl/>`_. The MIT Press 2002
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 8d6aa30f0..3581cd0cb 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -80,7 +80,7 @@ Numeric Instructions
 .. math::
    \frac{
    }{
-     C \vdash t\K{.}\CONST~c : [] \to [t]
+     C \vdashinstr t\K{.}\CONST~c : [] \to [t]
    }
 
 
@@ -94,7 +94,7 @@ Numeric Instructions
 .. math::
    \frac{
    }{
-     C \vdash t\K{.}\unop : [t] \to [t]
+     C \vdashinstr t\K{.}\unop : [t] \to [t]
    }
 
 
@@ -108,7 +108,7 @@ Numeric Instructions
 .. math::
    \frac{
    }{
-     C \vdash t\K{.}\binop : [t~t] \to [t]
+     C \vdashinstr t\K{.}\binop : [t~t] \to [t]
    }
 
 
@@ -122,7 +122,7 @@ Numeric Instructions
 .. math::
    \frac{
    }{
-     C \vdash t\K{.}\testop : [t] \to [\I32]
+     C \vdashinstr t\K{.}\testop : [t] \to [\I32]
    }
 
 
@@ -136,7 +136,7 @@ Numeric Instructions
 .. math::
    \frac{
    }{
-     C \vdash t\K{.}\relop : [t~t] \to [\I32]
+     C \vdashinstr t\K{.}\relop : [t~t] \to [\I32]
    }
 
 
@@ -150,7 +150,7 @@ Numeric Instructions
 .. math::
    \frac{
    }{
-     C \vdash t_2\K{.}\cvtop/t_1 : [t_1] \to [t_2]
+     C \vdashinstr t_2\K{.}\cvtop/t_1 : [t_1] \to [t_2]
    }
 
 
@@ -172,7 +172,7 @@ Parametric Instructions
 .. math::
    \frac{
    }{
-     C \vdash \DROP : [t] \to []
+     C \vdashinstr \DROP : [t] \to []
    }
 
 
@@ -186,7 +186,7 @@ Parametric Instructions
 .. math::
    \frac{
    }{
-     C \vdash \SELECT : [t~t~\I32] \to [t]
+     C \vdashinstr \SELECT : [t~t~\I32] \to [t]
    }
 
 .. note::
@@ -216,7 +216,7 @@ Variable Instructions
    \frac{
      C.\CLOCALS[x] = t
    }{
-     C \vdash \GETLOCAL~x : [] \to [t]
+     C \vdashinstr \GETLOCAL~x : [] \to [t]
    }
 
 
@@ -235,7 +235,7 @@ Variable Instructions
    \frac{
      C.\CLOCALS[x] = t
    }{
-     C \vdash \SETLOCAL~x : [t] \to []
+     C \vdashinstr \SETLOCAL~x : [t] \to []
    }
 
 
@@ -254,7 +254,7 @@ Variable Instructions
    \frac{
      C.\CLOCALS[x] = t
    }{
-     C \vdash \TEELOCAL~x : [t] \to [t]
+     C \vdashinstr \TEELOCAL~x : [t] \to [t]
    }
 
 
@@ -273,7 +273,7 @@ Variable Instructions
    \frac{
      C.\CGLOBALS[x] = \mut~t
    }{
-     C \vdash \GETGLOBAL~x : [] \to [t]
+     C \vdashinstr \GETGLOBAL~x : [] \to [t]
    }
 
 
@@ -294,7 +294,7 @@ Variable Instructions
    \frac{
      C.\CGLOBALS[x] = \MVAR~t
    }{
-     C \vdash \SETGLOBAL~x : [t] \to []
+     C \vdashinstr \SETGLOBAL~x : [t] \to []
    }
 
 
@@ -324,7 +324,7 @@ Memory Instructions
      \qquad
      2^{\memarg.\ALIGN} \leq |t|/8
    }{
-     C \vdash t\K{.load}~\memarg : [\I32] \to [t]
+     C \vdashinstr t\K{.load}~\memarg : [\I32] \to [t]
    }
 
 
@@ -345,12 +345,10 @@ Memory Instructions
      \qquad
      2^{\memarg.\ALIGN} \leq N/8
    }{
-     C \vdash t\K{.load}N\K{\_}\sx~\memarg : [\I32] \to [t]
+     C \vdashinstr t\K{.load}N\K{\_}\sx~\memarg : [\I32] \to [t]
    }
 
 
-.. _valid-store:
-
 :math:`t\K{.}\STORE~\memarg`
 ............................
 
@@ -366,7 +364,7 @@ Memory Instructions
      \qquad
      2^{\memarg.\ALIGN} \leq |t|/8
    }{
-     C \vdash t\K{.store}~\memarg : [\I32~t] \to []
+     C \vdashinstr t\K{.store}~\memarg : [\I32~t] \to []
    }
 
 
@@ -387,7 +385,7 @@ Memory Instructions
      \qquad
      2^{\memarg.\ALIGN} \leq N/8
    }{
-     C \vdash t\K{.store}N~\memarg : [\I32~t] \to []
+     C \vdashinstr t\K{.store}N~\memarg : [\I32~t] \to []
    }
 
 
@@ -404,7 +402,7 @@ Memory Instructions
    \frac{
      C.\CMEMS[0] = \memtype
    }{
-     C \vdash \CURRENTMEMORY : [] \to [\I32]
+     C \vdashinstr \CURRENTMEMORY : [] \to [\I32]
    }
 
 
@@ -421,7 +419,7 @@ Memory Instructions
    \frac{
      C.\CMEMS[0] = \memtype
    }{
-     C \vdash \GROWMEMORY : [\I32] \to [\I32]
+     C \vdashinstr \GROWMEMORY : [\I32] \to [\I32]
    }
 
 
@@ -444,7 +442,7 @@ Control Instructions
 .. math::
    \frac{
    }{
-     C \vdash \NOP : [] \to []
+     C \vdashinstr \NOP : [] \to []
    }
 
 
@@ -458,7 +456,7 @@ Control Instructions
 .. math::
    \frac{
    }{
-     C \vdash \UNREACHABLE : [t_1^\ast] \to [t_2^\ast]
+     C \vdashinstr \UNREACHABLE : [t_1^\ast] \to [t_2^\ast]
    }
 
 .. note::
@@ -479,9 +477,9 @@ Control Instructions
 
 .. math::
    \frac{
-     C,\CLABELS\,[t^?] \vdash \instr^\ast : [] \to [t^?]
+     C,\CLABELS\,[t^?] \vdashinstrseq \instr^\ast : [] \to [t^?]
    }{
-     C \vdash \BLOCK~[t^?]~\instr^\ast~\END : [] \to [t^?]
+     C \vdashinstr \BLOCK~[t^?]~\instr^\ast~\END : [] \to [t^?]
    }
 
 .. note::
@@ -503,9 +501,9 @@ Control Instructions
 
 .. math::
    \frac{
-     C,\CLABELS\,[] \vdash \instr^\ast : [] \to [t^?]
+     C,\CLABELS\,[] \vdashinstrseq \instr^\ast : [] \to [t^?]
    }{
-     C \vdash \LOOP~[t^?]~\instr^\ast~\END : [] \to [t^?]
+     C \vdashinstr \LOOP~[t^?]~\instr^\ast~\END : [] \to [t^?]
    }
 
 .. note::
@@ -530,11 +528,11 @@ Control Instructions
 
 .. math::
    \frac{
-     C,\CLABELS\,[t^?] \vdash \instr_1^\ast : [] \to [t^?]
+     C,\CLABELS\,[t^?] \vdashinstrseq \instr_1^\ast : [] \to [t^?]
      \qquad
-     C,\CLABELS\,[t^?] \vdash \instr_2^\ast : [] \to [t^?]
+     C,\CLABELS\,[t^?] \vdashinstrseq \instr_2^\ast : [] \to [t^?]
    }{
-     C \vdash \IF~[t^?]~\instr_1^\ast~\ELSE~\instr_2^\ast~\END : [\I32] \to [t^?]
+     C \vdashinstr \IF~[t^?]~\instr_1^\ast~\ELSE~\instr_2^\ast~\END : [\I32] \to [t^?]
    }
 
 .. note::
@@ -557,7 +555,7 @@ Control Instructions
    \frac{
      C.\CLABELS[l] = [t^?]
    }{
-     C \vdash \BR~l : [t_1^\ast~t^?] \to [t_2^\ast]
+     C \vdashinstr \BR~l : [t_1^\ast~t^?] \to [t_2^\ast]
    }
 
 .. note::
@@ -579,7 +577,7 @@ Control Instructions
    \frac{
      C.\CLABELS[l] = [t^?]
    }{
-     C \vdash \BRIF~l : [t^?~\I32] \to [t^?]
+     C \vdashinstr \BRIF~l : [t^?~\I32] \to [t^?]
    }
 
 
@@ -606,7 +604,7 @@ Control Instructions
      \qquad
      C.\CLABELS[l_N] = [t^?]
    }{
-     C \vdash \BRTABLE~l^\ast~l_N : [t_1^\ast~t^?~\I32] \to [t_2^\ast]
+     C \vdashinstr \BRTABLE~l^\ast~l_N : [t_1^\ast~t^?~\I32] \to [t_2^\ast]
    }
 
 .. note::
@@ -628,7 +626,7 @@ Control Instructions
    \frac{
      C.\CRETURN = [t^?]
    }{
-     C \vdash \RETURN : [t_1^\ast~t^?] \to [t_2^\ast]
+     C \vdashinstr \RETURN : [t_1^\ast~t^?] \to [t_2^\ast]
    }
 
 .. note::
@@ -652,7 +650,7 @@ Control Instructions
    \frac{
      C.\CFUNCS[x] = [t_1^\ast] \to [t_2^\ast]
    }{
-     C \vdash \CALL~x : [t_1^\ast] \to [t_2^\ast]
+     C \vdashinstr \CALL~x : [t_1^\ast] \to [t_2^\ast]
    }
 
 
@@ -677,7 +675,7 @@ Control Instructions
      \qquad
      C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
    }{
-     C \vdash \CALLINDIRECT~x : [t_1^\ast] \to [t_2^\ast]
+     C \vdashinstr \CALLINDIRECT~x : [t_1^\ast] \to [t_2^\ast]
    }
 
 
@@ -699,7 +697,7 @@ Empty Instruction Sequence: :math:`\epsilon`
 .. math::
    \frac{
    }{
-     C \vdash \epsilon : [t^\ast] \to [t^\ast]
+     C \vdashinstrseq \epsilon : [t^\ast] \to [t^\ast]
    }
 
 
@@ -719,11 +717,11 @@ Non-empty Instruction Sequence: :math:`\instr^\ast~\instr_N`
 
 .. math::
    \frac{
-     C \vdash \instr^\ast : [t_1^\ast] \to [t_0^\ast~t^\ast]
+     C \vdashinstrseq \instr^\ast : [t_1^\ast] \to [t_0^\ast~t^\ast]
      \qquad
-     C \vdash \instr_N : [t^\ast] \to [t_3^\ast]
+     C \vdashinstr \instr_N : [t^\ast] \to [t_3^\ast]
    }{
-     C \vdash \instr^\ast~\instr_N : [t_1^\ast] \to [t_0^\ast~t_3^\ast]
+     C \vdashinstrseq \instr^\ast~\instr_N : [t_1^\ast] \to [t_0^\ast~t_3^\ast]
    }
 
 
@@ -749,9 +747,9 @@ Expressions :math:`\expr` are classified by :ref:`result types <syntax-resulttyp
 
 .. math::
    \frac{
-     C \vdash \instr^\ast : [] \to [t^?]
+     C \vdashinstrseq \instr^\ast : [] \to [t^?]
    }{
-     C \vdash \instr^\ast~\END : [t^?]
+     C \vdashexpr \instr^\ast~\END : [t^?]
    }
 
 
@@ -771,20 +769,21 @@ Constant Expressions
 
 .. math::
    \frac{
-     (C \vdash \instr ~\F{const})^\ast
+     (C \vdashinstrconst \instr \const)^\ast
    }{
-     C \vdash \instr~\END ~\F{const}
+     C \vdashexprconst \instr~\END \const
    }
-   \qquad
+
+.. math::
    \frac{
    }{
-     C \vdash t.\CONST~c ~\F{const}
+     C \vdashinstrconst t.\CONST~c \const
    }
    \qquad
    \frac{
      C.\CGLOBALS[x] = \CONST~t
    }{
-     C \vdash \GETGLOBAL~x ~\F{const}
+     C \vdashinstrconst \GETGLOBAL~x \const
    }
 
 .. note::
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 10dcd05cf..3af4f2f5b 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -42,16 +42,16 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
    \frac{
      C.\CTYPES[x] = [t_1^\ast] \to [t_2^?]
      \qquad
-     C,\CLOCALS\,t_1^\ast~t^\ast,\CLABELS~[t_2^?],\CRETURN~[t_2^?] \vdash \expr : [t_2^?]
+     C,\CLOCALS\,t_1^\ast~t^\ast,\CLABELS~[t_2^?],\CRETURN~[t_2^?] \vdashexpr \expr : [t_2^?]
    }{
-     C \vdash \{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\expr \} : [t_1^\ast] \to [t_2^?]
+     C \vdashfunc \{ \FTYPE~x, \FLOCALS~t^\ast, \FBODY~\expr \} : [t_1^\ast] \to [t_2^?]
    }
 
 .. note::
    The restriction on the length of the result types :math:`t_2^\ast` may be lifted in future versions of WebAssembly.
 
 
-.. index:: table, table type, limits, element type
+.. index:: table, table type
    pair: validation; table
    single: abstract syntax; table
 .. _valid-table:
@@ -59,27 +59,24 @@ Functions :math:`\func` are classified by :ref:`function types <syntax-functype>
 Tables
 ~~~~~~
 
-Tables :math:`\table` are classified by :ref:`table types <syntax-tabletype>` of the form :math:`\limits~\elemtype`.
-
+Tables :math:`\table` are classified by :ref:`table types <syntax-tabletype>`.
 
 :math:`\{ \TTYPE~\tabletype \}`
 ...............................
 
-* Let :math:`\limits~\elemtype` be the :ref:`table types <syntax-tabletype>` :math:`\tabletype`.
-
-* The limits :math:`\limits` must be :ref:`valid <valid-limits>`.
+* The :ref:`table type <syntax-tabletype>` :math:`\tabletype` must be :ref:`valid <valid-tabletype>`.
 
 * Then the table definition is valid with type :math:`\tabletype`.
 
 .. math::
    \frac{
-     \vdash \limits\ok
+     \vdashtabletype \tabletype \ok
    }{
-     C \vdash \{ \TTYPE~\limits~\elemtype \} : \limits~\elemtype
+     C \vdashtable \{ \TTYPE~\tabletype \} : \tabletype
    }
 
 
-.. index:: memory, memory type, limits
+.. index:: memory, memory type
    pair: validation; memory
    single: abstract syntax; memory
 .. _valid-mem:
@@ -87,27 +84,24 @@ Tables :math:`\table` are classified by :ref:`table types <syntax-tabletype>` of
 Memories
 ~~~~~~~~
 
-Memories :math:`\mem` are classified by :ref:`memory types <syntax-memtype>` of the form :math:`\limits`.
-
+Memories :math:`\mem` are classified by :ref:`memory types <syntax-memtype>`.
 
 :math:`\{ \MTYPE~\memtype \}`
 .............................
 
-* Let :math:`\limits` be the :ref:`memory types <syntax-memtype>` :math:`\memtype`.
-
-* The limits :math:`\limits` must be :ref:`valid <valid-limits>`.
+* The :ref:`memory type <syntax-memtype>` :math:`\memtype` must be :ref:`valid <valid-memtype>`.
 
 * Then the memory definition is valid with type :math:`\memtype`.
 
 .. math::
    \frac{
-     \vdash \limits\ok
+     \vdashmemtype \memtype \ok
    }{
-     C \vdash \{ \MTYPE~\limits \} : \limits~\elemtype
+     C \vdashmem \{ \MTYPE~\memtype \} : \memtype
    }
 
 
-.. index:: global, global type, mutability, expression
+.. index:: global, global type, expression
    pair: validation; global
    single: abstract syntax; global
 .. _valid-global:
@@ -121,6 +115,8 @@ Globals :math:`\global` are classified by :ref:`global types <syntax-globaltype>
 :math:`\{ \GTYPE~\mut~t, \GINIT~\expr \}`
 .........................................
 
+* The :ref:`global type <syntax-globaltype>` :math:`\mut~t` must be :ref:`valid <valid-globaltype>`.
+
 * The expression :math:`\expr` must be :ref:`valid <valid-expr>` with :ref:`result type <syntax-resulttype>` :math:`[t]`.
 
 * The expression :math:`\expr` must be :ref:`constant <valid-constant>`.
@@ -129,11 +125,13 @@ Globals :math:`\global` are classified by :ref:`global types <syntax-globaltype>
 
 .. math::
    \frac{
-     C \vdash \expr : [t]
+     \vdashglobaltype \mut~t \ok
      \qquad
-     C \vdash \expr ~\F{const}
+     C \vdashexpr \expr : [t]
+     \qquad
+     C \vdashexprconst \expr ~\F{const}
    }{
-     C \vdash \{ \GTYPE~\mut~t, \GINIT~\expr \} : \mut~t
+     C \vdashglobal \{ \GTYPE~\mut~t, \GINIT~\expr \} : \mut~t
    }
 
 
@@ -172,13 +170,13 @@ Element segments :math:`\elem` are not classified by a type.
    \frac{
      C.\CTABLES[x] = \limits~\ANYFUNC
      \qquad
-     C \vdash \expr : [\I32]
+     C \vdashexpr \expr : [\I32]
      \qquad
-     C \vdash \expr ~\F{const}
+     C \vdashexprconst \expr ~\F{const}
      \qquad
      (C.\CFUNCS[y] = \functype)^\ast
    }{
-     C \vdash \{ \ETABLE~x, \EOFFSET~\expr, \EINIT~y^\ast \} \ok
+     C \vdashelem \{ \ETABLE~x, \EOFFSET~\expr, \EINIT~y^\ast \} \ok
    }
 
 
@@ -210,11 +208,11 @@ Data segments :math:`\data` are not classified by any type.
    \frac{
      C.\CMEMS[x] = \limits
      \qquad
-     C \vdash \expr : [\I32]
+     C \vdashexpr \expr : [\I32]
      \qquad
-     C \vdash \expr ~\F{const}
+     C \vdashexprconst \expr ~\F{const}
    }{
-     C \vdash \{ \DMEM~x, \DOFFSET~\expr, \DINIT~b^\ast \} \ok
+     C \vdashdata \{ \DMEM~x, \DOFFSET~\expr, \DINIT~b^\ast \} \ok
    }
 
 
@@ -242,13 +240,14 @@ Start function declarations :math:`\start` are not classified by any type.
    \frac{
      C.\CFUNCS[x] = [] \to []
    }{
-     C \vdash \{ \SFUNC~x \} \ok
+     C \vdashstart \{ \SFUNC~x \} \ok
    }
 
 
 .. index:: export, name, index, function index, table index, memory index, global index
    pair: validation; export
    single: abstract syntax; export
+.. _valid-exportdesc:
 .. _valid-export:
 
 Exports
@@ -267,9 +266,9 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
 
 .. math::
    \frac{
-     C \vdash \exportdesc \ok
+     C \vdashexportdesc \exportdesc \ok
    }{
-     C \vdash \{ \ENAME~\name, \EDESC~\exportdesc \} : \name
+     C \vdashexport \{ \ENAME~\name, \EDESC~\exportdesc \} : \name
    }
 
 
@@ -284,7 +283,7 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
    \frac{
      C.\CFUNCS[x] = \functype
    }{
-     C \vdash \EDFUNC~x \ok
+     C \vdashexportdesc \EDFUNC~x \ok
    }
 
 
@@ -299,7 +298,7 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
    \frac{
      C.\CTABLES[x] = \tabletype
    }{
-     C \vdash \EDTABLE~x \ok
+     C \vdashexportdesc \EDTABLE~x \ok
    }
 
 
@@ -314,7 +313,7 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
    \frac{
      C.\CMEMS[x] = \memtype
    }{
-     C \vdash \EDMEM~x \ok
+     C \vdashexportdesc \EDMEM~x \ok
    }
 
 
@@ -333,13 +332,14 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
    \frac{
      C.\CGLOBALS[x] = \MCONST~t
    }{
-     C \vdash \EDGLOBAL~x \ok
+     C \vdashexportdesc \EDGLOBAL~x \ok
    }
 
 
 .. index:: import, name, function type, table type, memory type, global type
    pair: validation; import
    single: abstract syntax; import
+.. _valid-importdesc:
 .. _valid-import:
 
 Imports
@@ -357,9 +357,9 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 
 .. math::
    \frac{
-     C \vdash \importdesc : \externtype
+     C \vdashimportdesc \importdesc : \externtype
    }{
-     C \vdash \{ \IMODULE~\name_1, \INAME~\name_2, \IDESC~\importdesc \} : \externtype
+     C \vdashimport \{ \IMODULE~\name_1, \INAME~\name_2, \IDESC~\importdesc \} : \externtype
    }
 
 
@@ -376,51 +376,54 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
    \frac{
      C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
    }{
-     C \vdash \IDFUNC~x : \ETFUNC~[t_1^\ast] \to [t_2^\ast]
+     C \vdashimportdesc \IDFUNC~x : \ETFUNC~[t_1^\ast] \to [t_2^\ast]
    }
 
 
-:math:`\IDTABLE~\limits~\elemtype`
-..................................
+:math:`\IDTABLE~\tabletype`
+...........................
 
-* The limits :math:`\limits` must be valid.
+* The table type :math:`\tabletype` must be :ref:`valid <valid-tabletype>`.
 
-* Then the import description is valid with type :math:`\ETTABLE~\limits~\elemtype`.
+* Then the import description is valid with type :math:`\ETTABLE~\tabletype`.
 
 .. math::
    \frac{
-     \vdash \limits \ok
+     \vdashtable \tabletype \ok
    }{
-     C \vdash \IDTABLE~\limits~\elemtype : \ETTABLE~\limits~\elemtype
+     C \vdashimportdesc \IDTABLE~\tabletype : \ETTABLE~\tabletype
    }
 
 
-:math:`\IDMEM~\limits`
-......................
+:math:`\IDMEM~\memtype`
+.......................
 
-* The limits :math:`\limits` must be valid.
+* The memory type :math:`\memtype` must be :ref:`valid <valid-memtype>`.
 
-* Then the import description is valid with type :math:`\ETMEM~\limits`.
+* Then the import description is valid with type :math:`\ETMEM~\memtype`.
 
 .. math::
    \frac{
-     \vdash \limits \ok
+     \vdashmemtype \memtype \ok
    }{
-     C \vdash \IDMEM~\limits : \ETMEM~\limits
+     C \vdashimportdesc \IDMEM~\memtype : \ETMEM~\memtype
    }
 
 
-:math:`\IDGLOBAL~\mut~t`
-........................
+:math:`\IDGLOBAL~\globaltype`
+.............................
 
-* The mutability :math:`\mut` must be |MCONST|.
+* The global type :math:`\globaltype` must be :ref:`valid <valid-globaltype>`.
+
+* The mutability of :math:`\globaltype` must be |MCONST|.
 
-* Then the import description is valid with type :math:`\ETGLOBAL~t`.
+* Then the import description is valid with type :math:`\ETGLOBAL~\globaltype`.
 
 .. math::
    \frac{
+     \vdashglobaltype \MCONST~t \ok
    }{
-     C \vdash \IDGLOBAL~\MCONST~t : \ETGLOBAL~\MCONST~t
+     C \vdashimportdesc \IDGLOBAL~\MCONST~t : \ETGLOBAL~\MCONST~t
    }
 
 
@@ -510,25 +513,25 @@ Instead, the context :math:`C` for validation of the module's content is constru
 .. math::
    \frac{
      \begin{array}{@{}c@{}}
-     (\vdash \functype \ok)^\ast
+     (\vdashfunctype \functype \ok)^\ast
      \quad
-     (C \vdash \func : \X{ft})^\ast
+     (C \vdashfunc \func : \X{ft})^\ast
      \quad
-     (C \vdash \table : \X{tt})^\ast
+     (C \vdashtable \table : \X{tt})^\ast
      \quad
-     (C \vdash \mem : \X{mt})^\ast
+     (C \vdashmem \mem : \X{mt})^\ast
      \quad
-     (C' \vdash \global : \X{gt})^\ast
+     (C' \vdashglobal \global : \X{gt})^\ast
      \\
-     (C \vdash \elem \ok)^\ast
+     (C \vdashelem \elem \ok)^\ast
      \quad
-     (C \vdash \data \ok)^\ast
+     (C \vdashdata \data \ok)^\ast
      \quad
-     (C \vdash \start \ok)^?
+     (C \vdashstart \start \ok)^?
      \quad
-     (C \vdash \import : \X{it})^\ast
+     (C \vdashimport \import : \X{it})^\ast
      \quad
-     (C \vdash \export : \X{name})^\ast
+     (C \vdashexport \export : \X{name})^\ast
      \\
      \X{ift}^\ast = \etfuncs(\X{it}^\ast)
      \qquad
@@ -549,7 +552,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \name^\ast ~\F{disjoint}
      \end{array}
    }{
-     \vdash \{
+     \vdashmodule \{
        \begin{array}[t]{@{}l@{}}
          \MTYPES~\functype^\ast,
          \MFUNCS~\func^\ast,
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index b30008e7c..8fbff90fc 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -2,7 +2,32 @@ Types
 -----
 
 Most :ref:`types <syntax-type>` are universally valid.
-However, restrictions apply to :ref:`function types <syntax-functype>` and :ref:`limits <syntax-limits>`, which must be checked during validation.
+However, restrictions apply to :ref:`function types <syntax-functype>` as well as the :ref:`limits <syntax-limits>` of :ref:`table types <syntax-tabletype>` and :ref:`memory types <syntax-memtype>`, which must be checked during validation.
+
+
+.. index:: limits
+   pair: validation; limits
+   single: abstract syntax; limits
+.. _valid-limits:
+
+Limits
+~~~~~~
+
+:ref:`Limits <syntax-limits>` must have meaningful bounds.
+
+:math:`\{ \LMIN~n, \LMAX~m^? \}`
+................................
+
+* If the maximum :math:`m^?` is not empty, then its value must not be smaller than :math:`n`.
+
+* Then the limit is valid.
+
+.. math::
+   \frac{
+     (n \leq m)^?
+   }{
+     \vdashlimits \{ \LMIN~n, \LMAX~m^? \} \ok
+   }
 
 
 .. index:: function type
@@ -25,33 +50,74 @@ Function Types
 .. math::
    \frac{
    }{
-     \vdash [t_1^\ast] \to [t_2^?] \ok
+     \vdashfunctype [t_1^\ast] \to [t_2^?] \ok
    }
 
 .. note::
    This restriction may be removed in future versions of WebAssembly.
 
 
-.. index:: limits
-   pair: validation; limits
-   single: abstract syntax; limits
-.. _valid-limits:
+.. index:: table type, element type, limits
+   pair: validation; table type
+   single: abstract syntax; table type
+.. _valid-tabletype:
 
-Limits
-~~~~~~
+Table Types
+~~~~~~~~~~~
 
-:ref:`Limits <syntax-limits>` must have menaingful bounds.
+:math:`\limits~\elemtype`
+.........................
 
-:math:`\{ \LMIN~n, \LMAX~m^? \}`
-................................
+* The limits :math:`\limits` must be :ref:`valid <valid-limits>`.
 
-* If the maximum :math:`m^?` is not empty, then its value must not be smaller than :math:`n`.
+* Then the table type is valid.
 
-* Then the limit is valid.
+.. math::
+   \frac{
+     \vdashlimits \limits \ok
+   }{
+     \vdashtabletype \limits~\elemtype \ok
+   }
+
+
+.. index:: memory type, limits
+   pair: validation; memory type
+   single: abstract syntax; memory type
+.. _valid-memtype:
+
+Memory Types
+~~~~~~~~~~~~
+
+:math:`\limits`
+...............
+
+* The limits :math:`\limits` must be :ref:`valid <valid-limits>`.
+
+* Then the memory type is valid.
+
+.. math::
+   \frac{
+     \vdashlimits \limits \ok
+   }{
+     \vdashmemtype \limits \ok
+   }
+
+
+.. index:: global type, value type, mutability
+   pair: validation; global type
+   single: abstract syntax; global type
+.. _valid-globaltype:
+
+Global Types
+~~~~~~~~~~~~
+
+:math:`\mut~\valtype`
+.....................
+
+* Then the global type is valid.
 
 .. math::
    \frac{
-     (n \leq m)^?
    }{
-     \vdash \{ \LMIN~n, \LMAX~m^? \} \ok
+     \vdashglobaltype \mut~\valtype \ok
    }

From 6c5af212311c0600552c5d6db74e740c79553c7e Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Mon, 31 Jul 2017 16:53:26 +0200
Subject: [PATCH 063/329] [spec] Forgotten commit

---
 document/core/exec/modules.rst | 49 ++++++++++++++++++----------------
 1 file changed, 26 insertions(+), 23 deletions(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 81db4a504..3548a4dd1 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -263,16 +263,16 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 2. Let :math:`a` be the first free :ref:`function address <syntax-funcaddr>` in :math:`S`.
 
-4. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype, \FIHOSTCODE~\hostfunc \}`.
+3. Let :math:`\funcinst` be the :ref:`function instance <syntax-funcinst>` :math:`\{ \FITYPE~\functype, \FIHOSTCODE~\hostfunc \}`.
 
-5. Append :math:`\funcinst` to the |SFUNCS| of :math:`S`.
+4. Append :math:`\funcinst` to the |SFUNCS| of :math:`S`.
 
-6. Return :math:`a`.
+5. Return :math:`a`.
 
 .. math::
    ~\\[-1ex]
    \begin{array}{rlll}
-   \allochostfunc(S, \hostfunc, \functype) &=& S', \funcaddr \\[1ex]
+   \allochostfunc(S, \functype, \hostfunc) &=& S', \funcaddr \\[1ex]
    \mbox{where:} \hfill \\
    \funcaddr &=& |S.\SFUNCS| \\
    \funcinst &=& \{ \FITYPE~\functype, \FIHOSTCODE~\hostfunc \} \\
@@ -290,9 +290,9 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 :ref:`Tables <syntax-tableinst>`
 ................................
 
-1. Let :math:`\table` be the :ref:`table <syntax-table>` to allocate.
+1. Let :math:`\tabletype` be the :ref:`table type <syntax-tabletype>` to allocate.
 
-2. Let :math:`(\{\LMIN~n, \LMAX~m^?\}~\elemtype)` be the :ref:`table type <syntax-tabletype>` :math:`\table.\TTYPE`.
+2. Let :math:`(\{\LMIN~n, \LMAX~m^?\}~\elemtype)` be the structure of :ref:`table type <syntax-tabletype>` :math:`\tabletype`.
 
 3. Let :math:`a` be the first free :ref:`table address <syntax-tableaddr>` in :math:`S`.
 
@@ -304,9 +304,9 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 .. math::
    \begin{array}{rlll}
-   \alloctable(S, \table) &=& S', \tableaddr \\[1ex]
+   \alloctable(S, \tabletype) &=& S', \tableaddr \\[1ex]
    \mbox{where:} \hfill \\
-   \table.\TTYPE &=& \{\LMIN~n, \LMAX~m^?\}~\elemtype \\
+   \tabletype &=& \{\LMIN~n, \LMAX~m^?\}~\elemtype \\
    \tableaddr &=& |S.\STABLES| \\
    \tableinst &=& \{ \TIELEM~(\epsilon)^n, \TIMAX~m^? \} \\
    S' &=& S \compose \{\STABLES~\tableinst\} \\
@@ -319,9 +319,9 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 :ref:`Memories <syntax-meminst>`
 ................................
 
-1. Let :math:`\mem` be the :ref:`memory <syntax-mem>` to allocate.
+1. Let :math:`\memtype` be the :ref:`memory type <syntax-memtype>` to allocate.
 
-2. Let :math:`\{\LMIN~n, \LMAX~m^?\}` be the :ref:`memory type <syntax-memtype>` :math:`\mem.\MTYPE`.
+2. Let :math:`\{\LMIN~n, \LMAX~m^?\}` be the structure of :ref:`memory type <syntax-memtype>` :math:`\memtype`.
 
 3. Let :math:`a` be the first free :ref:`memory address <syntax-memaddr>` in :math:`S`.
 
@@ -333,9 +333,9 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 .. math::
    \begin{array}{rlll}
-   \allocmem(S, \mem) &=& S', \memaddr \\[1ex]
+   \allocmem(S, \memtype) &=& S', \memaddr \\[1ex]
    \mbox{where:} \hfill \\
-   \mem.\MTYPE &=& \{\LMIN~n, \LMAX~m^?\} \\
+   \memtype &=& \{\LMIN~n, \LMAX~m^?\} \\
    \memaddr &=& |S.\SMEMS| \\
    \meminst &=& \{ \MIDATA~(\hex{00})^{n \cdot 64\,\F{Ki}}, \MIMAX~m^? \} \\
    S' &=& S \compose \{\SMEMS~\meminst\} \\
@@ -348,9 +348,9 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 :ref:`Globals <syntax-globalinst>`
 ..................................
 
-1. Let :math:`\global` be the :ref:`global <syntax-global>` to allocate and :math:`\val` the :ref:`value <syntax-val>` to initialize it with.
+1. Let :math:`\globaltype` be the :ref:`global type <syntax-globaltype>` to allocate and :math:`\val` the :ref:`value <syntax-val>` to initialize the global with.
 
-2. Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`\global.\GTYPE`.
+2. Let :math:`\mut~t` be the structure of :ref:`global type <syntax-globaltype>` :math:`\globaltype`.
 
 3. Let :math:`a` be the first free :ref:`global address <syntax-globaladdr>` in :math:`S`.
 
@@ -362,9 +362,9 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
 
 .. math::
    \begin{array}{rlll}
-   \allocglobal(S, \global, \val) &=& S', \globaladdr \\[1ex]
+   \allocglobal(S, \globaltype, \val) &=& S', \globaladdr \\[1ex]
    \mbox{where:} \hfill \\
-   \global.\GTYPE &=& \mut~t \\
+   \globaltype &=& \mut~t \\
    \globaladdr &=& |S.\SGLOBALS| \\
    \globalinst &=& \{ \GIVALUE~\val, \GIMUT~\mut \} \\
    S' &=& S \compose \{\SGLOBALS~\globalinst\} \\
@@ -389,15 +389,15 @@ and :math:`\val^\ast` the initialization :ref:`values <syntax-val>` of the modul
 
 3. For each :ref:`table <syntax-table>` :math:`\table_i` in :math:`\module.\MTABLES`, do:
 
-   a. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i`.
+   a. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` resulting from :ref:`allocating <alloc-table>` :math:`\table_i.\TTYPE`.
 
 4. For each :ref:`memory <syntax-mem>` :math:`\mem_i` in :math:`\module.\MMEMS`, do:
 
-   a. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` resulting from :ref:`allocating <alloc-mem>` :math:`\mem_i`.
+   a. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` resulting from :ref:`allocating <alloc-mem>` :math:`\mem_i.\MTYPE`.
 
 5. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
-   a. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\global_i` with initializer value :math:`\val^\ast[i]`.
+   a. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` resulting from :ref:`allocating <alloc-global>` :math:`\global_i.\GTYPE` with initializer value :math:`\val^\ast[i]`.
 
 6. Let :math:`\funcaddr^\ast` be the the concatenation of the :ref:`function addresses <syntax-funcaddr>` :math:`\funcaddr_i` in index order.
 
@@ -453,11 +453,14 @@ where:
      \MIEXPORTS~\exportinst^\ast ~\}
      \end{array} \\[1ex]
    S_1, \funcaddr^\ast &=& \allocfunc^\ast(S, \module.\MFUNCS, \moduleinst) \\
-   S_2, \tableaddr^\ast &=& \alloctable^\ast(S_1, \module.\MTABLES) \\
-   S_3, \memaddr^\ast &=& \allocmem^\ast(S_2, \module.\MMEMS) \\
-   S', \globaladdr^\ast &=& \allocglobal^\ast(S_3, \module.\MGLOBALS, \val^\ast) \\[1ex]
+   S_2, \tableaddr^\ast &=& \alloctable^\ast(S_1, (\table.\TTYPE)^\ast)
+     \qquad\qquad\qquad~ (\where \table^\ast = \module.\MTABLES) \\
+   S_3, \memaddr^\ast &=& \allocmem^\ast(S_2, (\mem.\MTYPE)^\ast)
+     \qquad\qquad\qquad~ (\where \mem^\ast = \module.\MMEMS) \\
+   S', \globaladdr^\ast &=& \allocglobal^\ast(S_3, (\global.\GTYPE)^\ast, \val^\ast)
+     \qquad\quad~ (\where \global^\ast = \module.\MGLOBALS) \\
    \exportinst^\ast &=& \{ \EINAME~(\export.\ENAME), \EIVALUE~\externval_{\F{ex}} \}^\ast
-     \quad (\where \export^\ast = \module.\MEXPORTS) \\
+     \quad (\where \export^\ast = \module.\MEXPORTS) \\[1ex]
    \evfuncs(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MIFUNCS[x])^\ast
      \qquad~ (\where x^\ast = \edfuncs(\module.\MEXPORTS)) \\
    \evtables(\externval_{\F{ex}}^\ast) &=& (\moduleinst.\MITABLES[x])^\ast

From 53614d1682ad3b110004437a7dfb628b898477f0 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Mon, 31 Jul 2017 11:52:43 -0700
Subject: [PATCH 064/329] Fix typo in exec/instructions store instruction
 (#534)

---
 document/core/exec/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 6e433e89b..f37198379 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -499,7 +499,7 @@ Memory Instructions
      \begin{array}[t]{@{}r@{~}l@{}}
      (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
      \wedge & \X{ea} + |t|/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
-     \wedge & S' = S \with \MIMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice |t|/8] = \bytes_t(c)
+     \wedge & S' = S \with \SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice |t|/8] = \bytes_t(c)
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}

From 9be76912216cdb85f77c3829e677ac6fbd3272cf Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Mon, 31 Jul 2017 14:44:55 -0700
Subject: [PATCH 065/329] Add test for unreachable tee_local value (#535)

See https://github.com/WebAssembly/wabt/issues/586.
---
 test/core/unreached-invalid.wast | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/core/unreached-invalid.wast b/test/core/unreached-invalid.wast
index 8c73deb9c..20129f43b 100644
--- a/test/core/unreached-invalid.wast
+++ b/test/core/unreached-invalid.wast
@@ -623,3 +623,11 @@
   ))
   "type mismatch"
 )
+
+(assert_invalid
+  (module (func $tee-local-unreachable-value
+    (local i32)
+    (tee_local 0 (unreachable))
+  ))
+  "type mismatch"
+)

From dc688b4637458228302d82454ae2480ec3249f21 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 1 Aug 2017 10:05:24 +0200
Subject: [PATCH 066/329] [test] Add tests for type use syntax (#536)

---
 test/core/func.wast | 103 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 103 insertions(+)

diff --git a/test/core/func.wast b/test/core/func.wast
index 2dc4d547f..c60782f0e 100644
--- a/test/core/func.wast
+++ b/test/core/func.wast
@@ -30,6 +30,21 @@
 
   (func (result i32) (unreachable))
 
+  (type $sig-1 (func))
+  (type $sig-2 (func (result i32)))
+  (type $sig-3 (func (param $x i32)))
+  (type $sig-4 (func (param i32 f64 i32) (result i32)))
+
+  (func (export "type-use-1") (type $sig-1))
+  (func (export "type-use-2") (type $sig-2) (i32.const 0))
+  (func (export "type-use-3") (type $sig-3))
+  (func (export "type-use-4") (type $sig-4) (i32.const 0))
+  (func (export "type-use-5") (type $sig-2) (result i32) (i32.const 0))
+  (func (export "type-use-6") (type $sig-3) (param i32))
+  (func (export "type-use-7")
+    (type $sig-4) (param i32) (param f64 i32) (result i32) (i32.const 0)
+  )
+
   (func (type $sig))
   (func (type $forward))  ;; forward reference
 
@@ -153,6 +168,20 @@
   (func (export "init-local-f64") (result f64) (local f64) (get_local 0))
 )
 
+(assert_return (invoke "type-use-1"))
+(assert_return (invoke "type-use-2") (i32.const 0))
+(assert_return (invoke "type-use-3" (i32.const 1)))
+(assert_return
+  (invoke "type-use-4" (i32.const 1) (f64.const 1) (i32.const 1))
+  (i32.const 0)
+)
+(assert_return (invoke "type-use-5") (i32.const 0))
+(assert_return (invoke "type-use-6" (i32.const 1)))
+(assert_return
+  (invoke "type-use-7" (i32.const 1) (f64.const 1) (i32.const 1))
+  (i32.const 0)
+)
+
 (assert_return (invoke "local-first-i32") (i32.const 0))
 (assert_return (invoke "local-first-i64") (i64.const 0))
 (assert_return (invoke "local-first-f32") (f32.const 0))
@@ -352,6 +381,80 @@
 (assert_return (invoke "signature-implicit-duplicate"))
 
 
+;; Malformed type use
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (result i32) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (param i32) (type $sig) (result i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (param i32) (result i32) (type $sig) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (result i32) (type $sig) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (result i32) (param i32) (type $sig) (i32.const 0))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(func (result i32) (param i32) (i32.const 0))"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(func (type $sig) (result i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (result i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(func (type $sig) (param i32) (i32.const 0))"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(func (type $sig) (param i32) (result i32) (unreachable))"
+  )
+  "inline function type"
+)
+
+
 ;; Invalid typing of locals
 
 (assert_invalid

From 3a3899a3644dadf33d64683bf9368c3609ccafe8 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 1 Aug 2017 14:35:02 +0200
Subject: [PATCH 067/329] [spec] Fix typo in judgement scheme

---
 document/core/appendix/index-rules.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
index 83d5d514d..ef862d80f 100644
--- a/document/core/appendix/index-rules.rst
+++ b/document/core/appendix/index-rules.rst
@@ -21,7 +21,7 @@ Construct                                        Judgement
 :ref:`Instruction <valid-instr>`                 :math:`S;C \vdashinstr \instr : \functype`
 :ref:`Instruction sequence <valid-instr-seq>`    :math:`S;C \vdashinstrseq \instr^\ast : \functype`
 :ref:`Expression <valid-expr>`                   :math:`C \vdashexpr \expr : \resulttype`
-:ref:`Function <valid-func>`                     :math:`C \vdashfunc \func : \resulttype`
+:ref:`Function <valid-func>`                     :math:`C \vdashfunc \func : \functype`
 :ref:`Table <valid-table>`                       :math:`C \vdashtable \table : \tabletype`
 :ref:`Memory <valid-mem>`                        :math:`C \vdashmem \mem : \memtype`
 :ref:`Global <valid-global>`                     :math:`C \vdashglobal \global : \globaltype`

From d8c8927f4093ec88fc025bdc6ddd572afb3e075a Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Tue, 1 Aug 2017 10:09:23 -0700
Subject: [PATCH 068/329] Add test for unreachable br_if value (#537)

See https://github.com/WebAssembly/wabt/pull/589.
---
 test/core/unreached-invalid.wast | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/test/core/unreached-invalid.wast b/test/core/unreached-invalid.wast
index 20129f43b..312edb7b1 100644
--- a/test/core/unreached-invalid.wast
+++ b/test/core/unreached-invalid.wast
@@ -631,3 +631,14 @@
   ))
   "type mismatch"
 )
+(assert_invalid
+  (module (func $br_if-unreachable (result i32)
+    (block (result i32)
+      (block
+        (br_if 1 (unreachable) (i32.const 0))
+      )
+      (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)

From 71635cfc8729495aedaf7f0214aa2e3d8ed211a1 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Wed, 2 Aug 2017 11:44:48 +0200
Subject: [PATCH 069/329] Typo: Mutability in global types is mandatory (#539)

---
 document/core/syntax/types.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index 7065057f4..57da119cc 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -174,7 +174,7 @@ Global Types
 .. math::
    \begin{array}{llll}
    \production{global type} & \globaltype &::=&
-     \mut^?~\valtype \\
+     \mut~\valtype \\
    \production{mutability} & \mut &::=&
      \MCONST ~|~
      \MVAR \\

From e614de76ba2ecf62f3f0abb58dac79ec24bd2a67 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Wed, 2 Aug 2017 13:53:43 +0200
Subject: [PATCH 070/329] Fix small issues in the spec document (#540)

---
 document/core/intro/introduction.rst | 2 +-
 document/core/intro/overview.rst     | 2 +-
 document/core/syntax/values.rst      | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/document/core/intro/introduction.rst b/document/core/intro/introduction.rst
index 9d89a5026..6b478b159 100644
--- a/document/core/intro/introduction.rst
+++ b/document/core/intro/introduction.rst
@@ -3,7 +3,7 @@ Introduction
 
 WebAssembly (abbreviated Wasm [#wasm]_) is a *safe, portable, low-level code format*
 designed for efficient execution and compact representation.
-Its main goal is to enable high performance applications on the Web, but it does not make any Web-specific assumptions or provide Web-specific features, so can be employed in other environments as well.
+Its main goal is to enable high performance applications on the Web, but it does not make any Web-specific assumptions or provide Web-specific features, so it can be employed in other environments as well.
 
 WebAssembly is an open standard developed by a `W3C Community Group <https://www.w3.org/community/webassembly/>`_ that includes representatives of all major browser vendors.
 
diff --git a/document/core/intro/overview.rst b/document/core/intro/overview.rst
index c35b50bfd..b0b6a5630 100644
--- a/document/core/intro/overview.rst
+++ b/document/core/intro/overview.rst
@@ -71,7 +71,7 @@ This language is structured around the following concepts.
   Such a memory is created with an initial size but can be grown dynamically.
   A program can load and store values from/to a linear memory at any byte address (including unaligned).
   Integer loads and stores can specify a *storage size* which is smaller than the size of the respective value type.
-  A trap occurs if access is not within the bounds of the current memory size.
+  A trap occurs if an access is not within the bounds of the current memory size.
 
 .. _module:
 
diff --git a/document/core/syntax/values.rst b/document/core/syntax/values.rst
index 563b3ae11..d815367ba 100644
--- a/document/core/syntax/values.rst
+++ b/document/core/syntax/values.rst
@@ -96,7 +96,7 @@ Every value has a *sign* and a *magnitude*.
 
 Magnitudes can either be expressed as *normal* numbers of the form :math:`m_0.m_1m_2\dots m_M \cdot2^e`, where :math:`e` is the exponent and :math:`m` is the *significand* whose most signifcant bit :math:`m_0` is :math:`1`,
 or as a *subnormal* number where the exponent is fixed to the smallest possible value and :math:`m_0` is :math:`0`; among the subnormals are positive and negative zero values.
-Since the significands are binary values, normals are represented in the form :math:`(1 + m\cdot 2^{-M})`, where :math:`M` is the bit width of :math:`m`; similarly for subnormals.
+Since the significands are binary values, normals are represented in the form :math:`(1 + m\cdot 2^{-M}) \cdot 2^e`, where :math:`M` is the bit width of :math:`m`; similarly for subnormals.
 
 Possible magnitudes also include the special values :math:`\infty` (infinity) and |NAN| (*NaN*, not a number).
 NaN values have a *payload* that describes the mantissa bits in the underlying :ref:`binary representation <aux-fbits>`.

From 2bec8a90c9f6ea7a4089ee70a944cb0e0be20748 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Thu, 3 Aug 2017 16:11:53 +0200
Subject: [PATCH 071/329] Add tests for the element section (#538)

---
 test/core/call_indirect.wast |  30 -----
 test/core/elem.wast          | 215 +++++++++++++++++++++++++++++++++++
 2 files changed, 215 insertions(+), 30 deletions(-)
 create mode 100644 test/core/elem.wast

diff --git a/test/core/call_indirect.wast b/test/core/call_indirect.wast
index 3c27c53c6..b9b152e82 100644
--- a/test/core/call_indirect.wast
+++ b/test/core/call_indirect.wast
@@ -376,33 +376,3 @@
   (module (table anyfunc (elem 0 0)))
   "unknown function 0"
 )
-
-
-;; Invalid bounds for elements
-
-(assert_unlinkable
-  (module
-    (table 10 anyfunc)
-    (elem (i32.const 10) $f)
-    (func $f)
-  )
-  "elements segment does not fit"
-)
-
-(assert_unlinkable
-  (module
-    (table 10 anyfunc)
-    (elem (i32.const -1) $f)
-    (func $f)
-  )
-  "elements segment does not fit"
-)
-
-(assert_unlinkable
-  (module
-    (table 10 anyfunc)
-    (elem (i32.const -10) $f)
-    (func $f)
-  )
-  "elements segment does not fit"
-)
diff --git a/test/core/elem.wast b/test/core/elem.wast
new file mode 100644
index 000000000..9dececed3
--- /dev/null
+++ b/test/core/elem.wast
@@ -0,0 +1,215 @@
+;; Test the element section
+
+(module
+  (table 10 anyfunc)
+  (elem (i32.const 0) $f)
+  (func $f)
+)
+
+(module
+  (table 10 anyfunc)
+  (elem (i32.const 9) $f)
+  (func $f)
+)
+
+(module
+  (type $out-i32 (func (result i32)))
+  (table 10 anyfunc)
+  (elem (i32.const 7) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect $out-i32 (i32.const 7))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect $out-i32 (i32.const 9))
+  )
+)
+
+(assert_return (invoke "call-7") (i32.const 65))
+(assert_return (invoke "call-9") (i32.const 66))
+
+;; Two elements target the same slot
+
+(module
+  (type $out-i32 (func (result i32)))
+  (table 10 anyfunc)
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten-element") (type $out-i32)
+    (call_indirect $out-i32 (i32.const 9))
+  )
+)
+
+(assert_return (invoke "call-overwritten-element") (i32.const 66))
+
+;; Invalid bounds for elements
+
+(assert_unlinkable
+  (module
+    (table 10 anyfunc)
+    (elem (i32.const 10) $f)
+    (func $f)
+  )
+  "elements segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (table 10 20 anyfunc)
+    (elem (i32.const 10) $f)
+    (func $f)
+  )
+  "elements segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (table 10 anyfunc)
+    (elem (i32.const -1) $f)
+    (func $f)
+  )
+  "elements segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (table 10 anyfunc)
+    (elem (i32.const -10) $f)
+    (func $f)
+  )
+  "elements segment does not fit"
+)
+
+;; Tests with an imported table
+
+(module
+  (import "spectest" "table" (table 10 anyfunc))
+  (elem (i32.const 0) $f)
+  (func $f)
+)
+
+(module
+  (import "spectest" "table" (table 10 anyfunc))
+  (elem (i32.const 9) $f)
+  (func $f)
+)
+
+;; Two elements target the same slot
+
+(module
+  (type $out-i32 (func (result i32)))
+  (import "spectest" "table" (table 10 anyfunc))
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten-element") (type $out-i32)
+    (call_indirect $out-i32 (i32.const 9))
+  )
+)
+
+(assert_return (invoke "call-overwritten-element") (i32.const 66))
+
+;; Invalid bounds for elements
+
+(assert_unlinkable
+  (module
+  (import "spectest" "table" (table 10 anyfunc))
+    (elem (i32.const 10) $f)
+    (func $f)
+  )
+  "elements segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+  (import "spectest" "table" (table 10 20 anyfunc))
+    (elem (i32.const 10) $f)
+    (func $f)
+  )
+  "elements segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+  (import "spectest" "table" (table 10 anyfunc))
+    (elem (i32.const -1) $f)
+    (func $f)
+  )
+  "elements segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+  (import "spectest" "table" (table 10 anyfunc))
+    (elem (i32.const -10) $f)
+    (func $f)
+  )
+  "elements segment does not fit"
+)
+
+;; Element without table
+
+(assert_invalid
+  (module
+    (elem (i32.const 0) $f)
+    (func $f)
+  )
+  "unknown table 0"
+)
+
+;; Test element sections across multiple modules change the same table
+
+(module $module-1
+  (type $out-i32 (func (result i32)))
+  (table (export "shared-table") 10 anyfunc)
+  (elem (i32.const 8) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-7") (type $out-i32)
+    (call_indirect $out-i32 (i32.const 7))
+  )
+  (func (export "call-8") (type $out-i32)
+    (call_indirect $out-i32 (i32.const 8))
+  )
+  (func (export "call-9") (type $out-i32)
+    (call_indirect $out-i32 (i32.const 9))
+  )
+)
+
+(register "module-1" $module-1)
+
+(assert_trap (invoke $module-1 "call-7") "uninitialized element 7")
+(assert_return (invoke $module-1 "call-8") (i32.const 65))
+(assert_return (invoke $module-1 "call-9") (i32.const 66))
+
+(module $module-2
+  (type $out-i32 (func (result i32)))
+  (import "module-1" "shared-table" (table 10 anyfunc))
+  (elem (i32.const 7) $const-i32-c)
+  (elem (i32.const 8) $const-i32-d)
+  (func $const-i32-c (type $out-i32) (i32.const 67))
+  (func $const-i32-d (type $out-i32) (i32.const 68))
+)
+
+(assert_return (invoke $module-1 "call-7") (i32.const 67))
+(assert_return (invoke $module-1 "call-8") (i32.const 68))
+(assert_return (invoke $module-1 "call-9") (i32.const 66))
+
+(module $module-3
+  (type $out-i32 (func (result i32)))
+  (import "module-1" "shared-table" (table 10 anyfunc))
+  (elem (i32.const 8) $const-i32-e)
+  (elem (i32.const 9) $const-i32-f)
+  (func $const-i32-e (type $out-i32) (i32.const 69))
+  (func $const-i32-f (type $out-i32) (i32.const 70))
+)
+
+(assert_return (invoke $module-1 "call-7") (i32.const 67))
+(assert_return (invoke $module-1 "call-8") (i32.const 69))
+(assert_return (invoke $module-1 "call-9") (i32.const 70))

From 86a2b0ec16f105cf4b6630e0de91edec70bf0632 Mon Sep 17 00:00:00 2001
From: Akio Yasui <akkyie01@gmail.com>
Date: Fri, 4 Aug 2017 15:18:26 +0900
Subject: [PATCH 072/329] [spec] Fix documentation issues around
 `demote`/`promote` (#541)

---
 document/core/syntax/instructions.rst | 2 +-
 document/core/text/instructions.rst   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index a740e7cbf..acdb3f0db 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -67,7 +67,7 @@ These operations closely match respective operations available in hardware.
      \K{i32.}\WRAP\K{/i64} ~|~
      \K{i64.}\EXTEND\K{\_}\sx/\K{i32} ~|~
      \K{i}\X{nn}\K{.}\TRUNC\K{\_}\sx/\K{f}\X{mm} \\&&|&
-     \K{f32.}\TRUNC\K{/f64} ~|~
+     \K{f32.}\DEMOTE\K{/f64} ~|~
      \K{f64.}\PROMOTE\K{/f32} ~|~
      \K{f}\X{nn}\K{.}\CONVERT\K{\_}\sx/\K{i}\X{mm} \\&&|&
      \K{i}\X{nn}\K{.}\REINTERPRET\K{/f}\X{nn} ~|~
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 7d7432201..d2caf58d9 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -402,7 +402,7 @@ Numeric Instructions
      \text{f64.convert\_u/i32} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I32 \\ &&|&
      \text{f64.convert\_s/i64} &\Rightarrow& \F64.\CONVERT\K{\_s/}\I64 \\ &&|&
      \text{f64.convert\_u/i64} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I64 \\ &&|&
-     \text{f64.demote/f32} &\Rightarrow& \F64.\PROMOTE\K{/}\F32 \\ &&|&
+     \text{f64.promote/f32} &\Rightarrow& \F64.\PROMOTE\K{/}\F32 \\ &&|&
      \text{i32.reinterpret/f32} &\Rightarrow& \I32.\REINTERPRET\K{/}\F32 \\ &&|&
      \text{i64.reinterpret/f64} &\Rightarrow& \I64.\REINTERPRET\K{/}\F64 \\ &&|&
      \text{f32.reinterpret/i32} &\Rightarrow& \F32.\REINTERPRET\K{/}\I32 \\ &&|&

From cb70351f23b3406553d7d9b834c6031616a188bd Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Fri, 4 Aug 2017 12:07:15 +0200
Subject: [PATCH 073/329] Explain the subnormal exponent (#542)

Add a note which describes the value range of subnormal floating point numbers in the abstract syntax.
---
 document/core/syntax/values.rst | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/document/core/syntax/values.rst b/document/core/syntax/values.rst
index d815367ba..4c65e0596 100644
--- a/document/core/syntax/values.rst
+++ b/document/core/syntax/values.rst
@@ -137,6 +137,8 @@ A *canonical NaN* is a floating-point value :math:`\pm\NAN(\canon_N)` where :mat
 
 An *arithmetic NaN*  is a floating-point value :math:`\pm\NAN(n)` with :math:`n \geq \canon_N`, such that the most significant bit is :math:`1` while all others are arbitrary.
 
+.. note::
+   In the abstract syntax, subnormals are distinguished by the leading 0 of the significand. The exponent of subnormals has the same value as the smallest possible exponent of a normal number. Only in the :ref:`binary representation <binary-float>` the exponent of a subnormal is encoded differently than the exponent of any normal number.
 
 Conventions
 ...........

From 8572832bd5be4a8a51163476be0b60e5aca2b403 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Thu, 24 Aug 2017 09:32:10 +0200
Subject: [PATCH 074/329] Fix invalid module names in test (#549)

The module names in the tests in elem.wast contained a "-", which is an invalid character in JavaScript variable names. Thereby the JavaScript test generated from elem.wast by the test script could not be executed anymore by JavaScript runtimes. This CL removes the "-" from the module names and thereby fixes the problem.
---
 test/core/elem.wast | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/test/core/elem.wast b/test/core/elem.wast
index 9dececed3..c75e07b23 100644
--- a/test/core/elem.wast
+++ b/test/core/elem.wast
@@ -164,7 +164,7 @@
 
 ;; Test element sections across multiple modules change the same table
 
-(module $module-1
+(module $module1
   (type $out-i32 (func (result i32)))
   (table (export "shared-table") 10 anyfunc)
   (elem (i32.const 8) $const-i32-a)
@@ -182,34 +182,34 @@
   )
 )
 
-(register "module-1" $module-1)
+(register "module1" $module1)
 
-(assert_trap (invoke $module-1 "call-7") "uninitialized element 7")
-(assert_return (invoke $module-1 "call-8") (i32.const 65))
-(assert_return (invoke $module-1 "call-9") (i32.const 66))
+(assert_trap (invoke $module1 "call-7") "uninitialized element 7")
+(assert_return (invoke $module1 "call-8") (i32.const 65))
+(assert_return (invoke $module1 "call-9") (i32.const 66))
 
-(module $module-2
+(module $module2
   (type $out-i32 (func (result i32)))
-  (import "module-1" "shared-table" (table 10 anyfunc))
+  (import "module1" "shared-table" (table 10 anyfunc))
   (elem (i32.const 7) $const-i32-c)
   (elem (i32.const 8) $const-i32-d)
   (func $const-i32-c (type $out-i32) (i32.const 67))
   (func $const-i32-d (type $out-i32) (i32.const 68))
 )
 
-(assert_return (invoke $module-1 "call-7") (i32.const 67))
-(assert_return (invoke $module-1 "call-8") (i32.const 68))
-(assert_return (invoke $module-1 "call-9") (i32.const 66))
+(assert_return (invoke $module1 "call-7") (i32.const 67))
+(assert_return (invoke $module1 "call-8") (i32.const 68))
+(assert_return (invoke $module1 "call-9") (i32.const 66))
 
-(module $module-3
+(module $module3
   (type $out-i32 (func (result i32)))
-  (import "module-1" "shared-table" (table 10 anyfunc))
+  (import "module1" "shared-table" (table 10 anyfunc))
   (elem (i32.const 8) $const-i32-e)
   (elem (i32.const 9) $const-i32-f)
   (func $const-i32-e (type $out-i32) (i32.const 69))
   (func $const-i32-f (type $out-i32) (i32.const 70))
 )
 
-(assert_return (invoke $module-1 "call-7") (i32.const 67))
-(assert_return (invoke $module-1 "call-8") (i32.const 69))
-(assert_return (invoke $module-1 "call-9") (i32.const 70))
+(assert_return (invoke $module1 "call-7") (i32.const 67))
+(assert_return (invoke $module1 "call-8") (i32.const 69))
+(assert_return (invoke $module1 "call-9") (i32.const 70))

From ec00e5e0c84e5be26f6c475662271f40a2430668 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Thu, 24 Aug 2017 20:17:50 +0200
Subject: [PATCH 075/329] [spec] Fix typo in local name subsection production
 (#547)

---
 document/core/appendix/custom.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/appendix/custom.rst b/document/core/appendix/custom.rst
index 7aa44e5fd..1f6d94b33 100644
--- a/document/core/appendix/custom.rst
+++ b/document/core/appendix/custom.rst
@@ -135,6 +135,6 @@ It consists of an :ref:`indirect name map <binary-indirectnamemap>` assigning lo
 
 .. math::
    \begin{array}{llclll}
-   \production{function name subsection} & \Bfuncnamesubsec &::=&
+   \production{local name subsection} & \Blocalnamesubsec &::=&
      \Bnamesubsection_2(\Bindirectnamemap) \\
    \end{array}

From 9b84654c8605d8064e796dad54c57f51fcaa1446 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Mon, 28 Aug 2017 11:59:50 -0700
Subject: [PATCH 076/329] Fix decoding of f64 binary values (#544)

This loads the u64 value in two u32 pieces, but was using
`Int64.of_int32` which sign-extends the i32 value. This causes the f64
value `4294967249` to be read as `4294965201`, for example.
---
 interpreter/binary/decode.ml  |  4 ++--
 test/core/float_literals.wast | 12 ++++++++++++
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 064aac545..a26663426 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -72,8 +72,8 @@ let u32 s =
   Int32.(add lo (shift_left hi 16))
 
 let u64 s =
-  let lo = Int64.of_int32 (u32 s) in
-  let hi = Int64.of_int32 (u32 s) in
+  let lo = I64_convert.extend_u_i32 (u32 s) in
+  let hi = I64_convert.extend_u_i32 (u32 s) in
   Int64.(add lo (shift_left hi 32))
 
 let rec vuN n s =
diff --git a/test/core/float_literals.wast b/test/core/float_literals.wast
index c85bfb275..ed5969b88 100644
--- a/test/core/float_literals.wast
+++ b/test/core/float_literals.wast
@@ -180,6 +180,18 @@
 (assert_return (invoke "f64-hex-sep4") (f64.const 0xf0P+13))
 (assert_return (invoke "f64-hex-sep5") (f64.const 0x2af00a.1f3eep23))
 
+;; Test parsing a float from binary
+(module binary
+  ;; (func (export "4294967249") (result f64) (f64.const 4294967249))
+  "\00\61\73\6d\01\00\00\00\01\85\80\80\80\00\01\60"
+  "\00\01\7c\03\82\80\80\80\00\01\00\07\8e\80\80\80"
+  "\00\01\0a\34\32\39\34\39\36\37\32\34\39\00\00\0a"
+  "\91\80\80\80\00\01\8b\80\80\80\00\00\44\00\00\20"
+  "\fa\ff\ff\ef\41\0b"
+)
+
+(assert_return (invoke "4294967249") (f64.const 4294967249))
+
 (assert_malformed
   (module quote "(global f32 (f32.const _100))")
   "unknown operator"

From b10577fbf7630a3c40f8a1525674d7afb625a798 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 29 Aug 2017 12:56:30 +0200
Subject: [PATCH 077/329] [spec] Specify name mapping for cvtop (#551)

---
 document/core/exec/instructions.rst | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index f37198379..7f33fc962 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -24,6 +24,13 @@ The mapping of numeric instructions to their underlying operators is expressed b
    \X{op}_{\K{f}N}(z) &=& \F{f}\X{op}_N(z) \\
    \end{array}
 
+And for :ref:`conversion operators <exec-cvtop>`:
+
+.. math::
+   \begin{array}{lll@{\qquad}l}
+   \X{cvtop}_{t_1,t_2}(c) &=& \X{cvtop}_{|t_1|,|t_2|}(c) \\
+   \end{array}
+
 Where the underlying operators are partial, the corresponding instruction will :ref:`trap <trap>` when the result is not defined.
 Where the underlying operators are non-deterministic, because they may return one of multiple possible :ref:`NaN <syntax-nan>` values, so are the corresponding instructions.
 

From 048e2918cfe73dad0503be8c906b42d14fea5c89 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 29 Aug 2017 13:17:32 +0200
Subject: [PATCH 078/329] [test] Add tests for unreachable br_if (#553)

Adds a few tests and fixes a bug in interpreter error message.

See https://bugs.chromium.org/p/v8/issues/detail?id=6651
---
 interpreter/valid/valid.ml       |  2 +-
 test/core/unreached-invalid.wast | 25 +++++++++++++++++++++++++
 2 files changed, 26 insertions(+), 1 deletion(-)

diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 82d3c04de..385f2c344 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -303,7 +303,7 @@ and check_block (c : context) (es : instr list) (ts : stack_type) at =
   let s' = pop (stack ts) s at in
   require (snd s' = []) at
     ("type mismatch: operator requires " ^ string_of_stack_type ts ^
-     " but stack has " ^ string_of_infer_types (snd s'))
+     " but stack has " ^ string_of_infer_types (snd s))
 
 
 (* Functions & Constants *)
diff --git a/test/core/unreached-invalid.wast b/test/core/unreached-invalid.wast
index 312edb7b1..bd9d4f55b 100644
--- a/test/core/unreached-invalid.wast
+++ b/test/core/unreached-invalid.wast
@@ -456,6 +456,31 @@
   ))
   "type mismatch"
 )
+(assert_invalid
+  (module (func $type-br_if-num-vs-void-after-unreachable (result i32)
+    (block (result i32)
+      (block (unreachable) (br_if 1 (i32.const 0) (i32.const 0)))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_if-num-vs-num-after-unreachable (result i32)
+    (block (result i32)
+      (block (result f32) (unreachable) (br_if 1 (i32.const 0) (i32.const 0)))
+      (drop) (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-br_if-num2-vs-num-after-unreachable (result i32)
+    (block (result i32)
+      (unreachable) (br_if 0 (i32.const 0) (i32.const 0)) (i32.const 0)
+    )
+  ))
+  "type mismatch"
+)
 (assert_invalid
   (module (func $type-br_table-num-vs-num-after-unreachable
     (block (br_table 0 (unreachable) (f32.const 1)))

From ff8e5815618efc5d2fb805c7511c26e7b0c3f3d8 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Wed, 30 Aug 2017 02:09:42 -0700
Subject: [PATCH 079/329] Include reserved byte in call_indirect encoding
 (#555)

See issue #554.
---
 document/core/binary/instructions.rst | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index e7d13ae9f..faf5411de 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -54,12 +54,15 @@ Control Instructions
        &\Rightarrow& \BRTABLE~l^\ast~l_N \\ &&|&
      \hex{0F} &\Rightarrow& \RETURN \\ &&|&
      \hex{10}~~x{:}\Bfuncidx &\Rightarrow& \CALL~x \\ &&|&
-     \hex{11}~~x{:}\Btypeidx &\Rightarrow& \CALLINDIRECT~x \\
+     \hex{11}~~x{:}\Btypeidx~~\hex{00} &\Rightarrow& \CALLINDIRECT~x \\
    \end{array}
 
 .. note::
    The |ELSE| opcode :math:`\hex{05}` in the encoding of an |IF| instruction can be omitted if the following instruction sequence is empty.
 
+.. note::
+   In future versions of WebAssembly, the zero byte occurring in the encoding
+   of the |CALLINDIRECT| instruction may be used to index additional tables.
 
 .. index:: value type, polymorphism
    pair: binary format; instruction

From 96dee7e0ef2bb88f4c55d2e4a8fb9a5ed7230010 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 31 Aug 2017 10:02:36 +0200
Subject: [PATCH 080/329] [spec] Add note re set_global (#556)

To address #546.
---
 document/core/exec/instructions.rst | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 7f33fc962..d56492491 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -359,6 +359,9 @@ Variable Instructions
    (\iff S' = S \with \SGLOBALS[F.\AMODULE.\MIGLOBALS[x]].\GIVALUE = \val) \\
    \end{array}
 
+.. note::
+   :ref:`Validation <valid-set_global>` ensures that the global is, in fact, marked as mutable.
+
 
 .. index:: memory instruction, memory index, store, frame, address, memory address, memory instance, store, frame, value, integer, limits, value type, bit width
    pair: execution; instruction

From 39bc3041c44c997d5c94103037f66f4218cf66df Mon Sep 17 00:00:00 2001
From: Shogo Ohta <athos0220@gmail.com>
Date: Thu, 31 Aug 2017 17:04:01 +0900
Subject: [PATCH 081/329] [spec] Fix typo in Overview (#557)

---
 document/core/intro/overview.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/intro/overview.rst b/document/core/intro/overview.rst
index b0b6a5630..593dff225 100644
--- a/document/core/intro/overview.rst
+++ b/document/core/intro/overview.rst
@@ -40,7 +40,7 @@ This language is structured around the following concepts.
 
 **Traps**
   Under some conditions, certain instructions may produce a *trap*,
-  which immediately aborts excecution.
+  which immediately aborts execution.
   Traps cannot be handled by WebAssembly code,
   but are reported to the outside environment,
   where they typically can be caught.

From 4f1d3114157e6459d8a06e7d8fcc8fc90288cd85 Mon Sep 17 00:00:00 2001
From: Michael Ferris <mike.ferris@hotmail.com>
Date: Thu, 31 Aug 2017 11:12:31 -0700
Subject: [PATCH 082/329] Harness-module-builder: Do not spread potentially big
 arrays as function parameters (#552)

* Do not spread potentially big arrays as function parameters.
Some engines have a limit to the number of arguments functions can have and there is no limit to the size of a section.

* CR Fix
---
 test/harness/wasm-module-builder.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index f73794bac..a47611d8f 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -69,12 +69,14 @@ class Binary extends Array {
     // Emit section name.
     this.emit_u8(section_code);
     // Emit the section to a temporary buffer: its full length isn't know yet.
-    let section = new Binary;
+    const section = new Binary;
     content_generator(section);
     // Emit section length.
     this.emit_u32v(section.length);
     // Copy the temporary buffer.
-    this.push(...section);
+    for (const b of section) {
+      this.push(b);
+    }
   }
 }
 

From f664288b50f75101102705414bb4e084eeefcd1b Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 6 Sep 2017 10:02:25 +0200
Subject: [PATCH 083/329] [spec] Fix alignment immediate in text format (#562)

---
 document/core/exec/instructions.rst | 13 ++++++++-----
 document/core/text/instructions.rst |  2 +-
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index d56492491..ee21271f8 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -372,6 +372,14 @@ Variable Instructions
 Memory Instructions
 ~~~~~~~~~~~~~~~~~~~
 
+.. note::
+   The alignment :math:`\memarg.\ALIGN` in load and store instructions does not affect the semantics.
+   It is an indication that the offset :math:`\X{ea}` at which the memory is accessed is intended to satisfy the property :math:`\X{ea} \mod 2^{\memarg.\ALIGN} = 0`.
+   A WebAssembly implementation can use this hint to optimize for the intended use.
+   Unaligned access violating that property is still allowed and must succeed regardless of the annotation.
+   However, it may be substantially slower on some hardware.
+
+
 .. _exec-load:
 .. _exec-loadn:
 
@@ -447,11 +455,6 @@ Memory Instructions
      (\otherwise) \\
    \end{array}
 
-.. note::
-   The alignment :math:`\memarg.\ALIGN` does not affect the semantics.
-   Unaligned access is supported for all types, and succeeds regardless of the annotation.
-   The only purpose of the annotation is to provide optimizatons hints.
-
 
 .. _exec-store:
 .. _exec-storen:
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index d2caf58d9..f95c590ea 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -179,7 +179,7 @@ Lexically, an |Toffset| or |Talign| phrase is considered a single :ref:`keyword
 .. math::
    \begin{array}{llclll}
    \production{memory argument} & \Tmemarg_N &::=&
-     o{:}\Toffset~~a{:}\Talign_N &\Rightarrow& \{ \ALIGN~a,~\OFFSET~o \} \\
+     o{:}\Toffset~~a{:}\Talign_N &\Rightarrow& \{ \ALIGN~n,~\OFFSET~o \} & (\iff a = 2^n) \\
    \production{memory offset} & \Toffset &::=&
      \text{offset{=}}o{:}\Tu32 &\Rightarrow& o \\ &&|&
      \epsilon &\Rightarrow& 0 \\

From 772d87705ea4786c0d44d41902097e91cf31f82b Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 6 Sep 2017 16:35:19 +0200
Subject: [PATCH 084/329] [spec] Fix and clean up invariants for host functions
 (#563)

---
 document/core/appendix/index-rules.rst |   5 +-
 document/core/appendix/properties.rst  | 145 ++++++++++++++++++++-----
 document/core/exec/instructions.rst    |  31 ++----
 document/core/exec/modules.rst         |   4 +-
 document/core/exec/runtime.rst         |  24 +++-
 document/core/util/math.def            |  10 +-
 6 files changed, 163 insertions(+), 56 deletions(-)

diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
index ef862d80f..a64729569 100644
--- a/document/core/appendix/index-rules.rst
+++ b/document/core/appendix/index-rules.rst
@@ -44,6 +44,9 @@ Typing of Runtime Constructs
 ===============================================  ===============================================================================
 Construct                                        Judgement
 ===============================================  ===============================================================================
+:ref:`Value <valid-val>`                         :math:`\vdashval \val : \valtype`
+:ref:`Result <valid-result>`                     :math:`\vdashresult \result : \resulttype`
+:ref:`External value <valid-externval>`          :math:`S \vdashexternval \externval : \externtype`
 :ref:`Module instruction <valid-moduleinstr>`    :math:`S \vdashmoduleinstr \moduleinstr \ok`
 :ref:`Function instance <valid-funcinst>`        :math:`S \vdashfuncinst \funcinst : \resulttype`
 :ref:`Table instance <valid-tableinst>`          :math:`S \vdashtableinst \tableinst : \tabletype`
@@ -55,8 +58,6 @@ Construct                                        Judgement
 :ref:`Configuration <valid-config>`              :math:`\vdashconfig \config \ok`
 :ref:`Thread <valid-thread>`                     :math:`S;\resulttype^? \vdashthread \thread : \resulttype^?`
 :ref:`Frame <valid-frame>`                       :math:`S \vdashframe \frame : C`
-:ref:`Value <valid-val>`                         :math:`\vdashval \val : \valtype`
-:ref:`External value <valid-externval>`          :math:`S \vdashexternval \externval : \externtype`
 ===============================================  ===============================================================================
 
 
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 2473df9d0..2ade29dfa 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -20,6 +20,58 @@ The typing rules defining WebAssembly :ref:`validation <valid>` only cover the *
 In order to state and prove soundness precisely, the typing rules must be extended to the *dynamic* components of the abstract :ref:`runtime <syntax-runtime>`, that is, the :ref:`store <syntax-store>`, :ref:`configurations <syntax-config>`, and :ref:`administrative instructions <syntax-instr-admin>` as well as :ref:`module instructions <valid-moduleinstr>`. [#pldi2017]_
 
 
+.. index:: value, value type, result, result type, trap
+.. _valid-val:
+.. _valid-result:
+
+Values and Results
+~~~~~~~~~~~~~~~~~~
+
+:ref:`Values <syntax-val>` and :ref:`results <syntax-result>` can be classified by :ref:`value types <syntax-valtype>` and :ref:`result types <syntax-resulttype>` as follows.
+
+:ref:`Values <syntax-val>` :math:`t.\CONST~c`
+.............................................
+
+* The value is valid with :ref:`value type <syntax-valtype>` :math:`t`.
+
+.. math::
+   \frac{
+   }{
+     \vdashval t.\CONST~c : t
+   }
+
+
+:ref:`Results <syntax-result>` :math:`\val^\ast`
+................................................
+
+* For each :ref:`value <syntax-val>` :math:`\val_i` in :math:`\val^\ast`:
+
+  * The value :math:`\val_i` is :ref:`valid <valid-val>` with some :ref:`value type <syntax-valtype>` :math:`t_i`.
+
+* Let :math:`t^\ast` be the concatenation of all :math:`t_i`.
+
+* Then the result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`.
+
+.. math::
+   \frac{
+     (\vdashval \val : t)^\ast
+   }{
+     \vdashresult \val^\ast : [t^\ast]
+   }
+
+
+:ref:`Results <syntax-result>` :math:`\TRAP`
+............................................
+
+* The result is valid with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`, for any sequence :math:`t^\ast` of :ref:`value types <syntax-valtype>`.
+
+.. math::
+   \frac{
+   }{
+     \vdashresult \TRAP : [t^\ast]
+   }
+
+
 .. _module-context:
 .. _valid-store:
 
@@ -76,8 +128,8 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 .. index:: function type, function instance
 .. _valid-funcinst:
 
-:ref:`Function Instance <syntax-funcinst>` :math:`\{\FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func\}`
-......................................................................................................................
+:ref:`Function Instances <syntax-funcinst>` :math:`\{\FITYPE~\functype, \FIMODULE~\moduleinst, \FICODE~\func\}`
+.......................................................................................................................
 
 * The :ref:`function type <syntax-functype>` :math:`\functype` must be :ref:`valid <valid-functype>`.
 
@@ -99,11 +151,59 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
    }
 
 
+.. index:: function type, function instance, host function
+.. _valid-hostfuncinst:
+
+:ref:`Host Function Instances <syntax-funcinst>` :math:`\{\FITYPE~\functype, \FIHOSTCODE~\X{hf}\}`
+..................................................................................................
+
+* The :ref:`function type <syntax-functype>` :math:`\functype` must be :ref:`valid <valid-functype>`.
+
+* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`\functype`.
+
+* For every possible :ref:`valid <valid-store>` :ref:`store <syntax-store>` :math:`S_1` :ref:`extending <extend-store>` :math:`S` and every sequence :math:`\val^\ast` of :ref:`values <syntax-val>` whose :ref:`types <valid-val>` coincide with :math:`t_1^\ast`:
+
+  * There must exist a :ref:`valid <valid-store>` :ref:`store <syntax-store>` :math:`S_2` :ref:`extending <extend-store>` :math:`S_1` and a :ref:`result <syntax-result>` :math:`\result` whose :ref:`type <valid-result>` coincides with :math:`[t_2^\ast]` such that:
+
+    * :ref:`Executing <exec-invoke-host>` :math:`\X{hf}` in store :math:`S_1` with arguments :math:`\val^\ast` produces :math:`\result` and store :math:`S_2`.
+
+* Then the function instance is valid with :ref:`function type <syntax-functype>` :math:`\functype`.
+
+.. math::
+   \frac{
+     \begin{array}[b]{@{}l@{}}
+     \vdashfunctype [t_1^\ast] \to [t_2^\ast] \ok \\
+     \end{array}
+     \quad
+     \begin{array}[b]{@{}l@{}}
+     \forall S_1, \val^\ast,~
+       {\vdashstore S_1 \ok} \wedge
+       {\vdashstoreextends S \extendsto S_1} \wedge
+       {\vdashresult \val^\ast : [t_1^\ast]}
+       \Longrightarrow {} \\ \qquad
+     \exists S_2, \result,~
+       {\vdashstore S_2 \ok} \wedge
+       {\vdashstoreextends S_1 \extendsto S_2} \wedge
+       {\vdashresult \result : [t_2^\ast]} \wedge
+       \X{hf}(S_1; \val^\ast) = S_2; \result
+     \end{array}
+   }{
+     S \vdashfuncinst \{\FITYPE~[t_1^\ast] \to [t_2^\ast], \FIHOSTCODE~\X{hf}\} : [t_1^\ast] \to [t_2^\ast]
+   }
+
+.. note::
+   This rule states that, if appropriate pre-conditions about store and arguments are satisfied, then executing the host function must satisfy appropriate post-conditions about store and results.
+   The post-conditions match the ones in the :ref:`execution rule <exec-invoke-host>` for invoking host functions.
+
+   Any store under which the function is invoked is assumed to be an extension of the current store.
+   That way, the function itself is able to make sufficient assumptions about future stores.
+
+
 .. index:: table type, table instance, limits, function address
 .. _valid-tableinst:
 
-:ref:`Table Instance <syntax-tableinst>` :math:`\{ \TIELEM~(\X{fa}^?)^n, \TIMAX~m^? \}`
-.............................................................................................
+:ref:`Table Instances <syntax-tableinst>` :math:`\{ \TIELEM~(\X{fa}^?)^n, \TIMAX~m^? \}`
+..............................................................................................
 
 * For each optional :ref:`function address <syntax-funcaddr>` :math:`\X{fa}^?_i` in the table elements :math:`(\X{fa}^?)^n`:
 
@@ -128,8 +228,8 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 .. index:: memory type, memory instance, limits, byte
 .. _valid-meminst:
 
-:ref:`Memory Instance <syntax-meminst>` :math:`\{ \MIDATA~b^n, \MIMAX~m^? \}`
-.............................................................................
+:ref:`Memory Instances <syntax-meminst>` :math:`\{ \MIDATA~b^n, \MIMAX~m^? \}`
+..............................................................................
 
 * The :ref:`limits <syntax-limits>` :math:`\{\LMIN~n, \LMAX~m^?\}` must be :ref:`valid <valid-limits>`.
 
@@ -146,8 +246,8 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 .. index:: global type, global instance, value, mutability
 .. _valid-globalinst:
 
-:ref:`Global Instance <syntax-globalinst>` :math:`\{ \GIVALUE~(t.\CONST~c), \GIMUT~\mut \}`
-...........................................................................................
+:ref:`Global Instances <syntax-globalinst>` :math:`\{ \GIVALUE~(t.\CONST~c), \GIMUT~\mut \}`
+............................................................................................
 
 * The global instance is valid with :ref:`global type <syntax-globaltype>` :math:`\mut~t`.
 
@@ -161,8 +261,8 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 .. index:: external type, export instance, name, external value
 .. _valid-exportinst:
 
-:ref:`Export Instance <syntax-exportinst>` :math:`\{ \EINAME~\name, \EIVALUE~\externval \}`
-......................................................................................................
+:ref:`Export Instances <syntax-exportinst>` :math:`\{ \EINAME~\name, \EIVALUE~\externval \}`
+.......................................................................................................
 
 * The :ref:`external value <syntax-externval>` :math:`\externval` must be :ref:`valid <valid-externval>` with some :ref:`external type <syntax-externtype>` :math:`\externtype`.
 
@@ -179,8 +279,8 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 .. index:: module instance, context
 .. _valid-moduleinst:
 
-:ref:`Module Instance <syntax-moduleinst>` :math:`\moduleinst`
-..............................................................
+:ref:`Module Instances <syntax-moduleinst>` :math:`\moduleinst`
+...............................................................
 
 * Each :ref:`function type <syntax-functype>` :math:`\functype_i` in :math:`\moduleinst.\MITYPES` must be :ref:`valid <valid-functype>`.
 
@@ -254,7 +354,7 @@ Configuration Validity
 To relate the WebAssembly :ref:`type system <valid>` to its :ref:`execution semantics <exec>`, the :ref:`typing rules for instructions <valid-instr>` must be extended to :ref:`configurations <syntax-config>` :math:`S;T`,
 which relates the :ref:`store <syntax-store>` to execution :ref:`threads <syntax-thread>`.
 
-Threads may either be regular threads executing sequences of :ref:`instructions <syntax-instr>`, or module threads executing :ref:`module instructions <synax-moduleinstr>` that represent an ongoing module instantiation.
+Threads may either be regular threads executing sequences of :ref:`instructions <syntax-instr>`, or module threads executing :ref:`module instructions <syntax-moduleinstr>` that represent an ongoing module instantiation.
 Regular threads are classified by their :ref:`result type <syntax-resulttype>`.
 Module threads on the other hand have no result, not even an empty one.
 Consequently, threads and configurations are cumutavily classified by an *optional* result type, where :math:`\epsilon` classifies the thread as a module computation.
@@ -339,7 +439,7 @@ Finally, :ref:`frames <syntax-frame>` are classified with *frame contexts*, whic
 :ref:`Frames <syntax-frame>` :math:`\{\ALOCALS~\val^\ast, \AMODULE~\moduleinst\}`
 .................................................................................
 
-* The :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst` must be :ref:`valid <valid-moduleinst>` with some :ref:`module context <module context>` :math:`C`.
+* The :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst` must be :ref:`valid <valid-moduleinst>` with some :ref:`module context <module-context>` :math:`C`.
 
 * Each :ref:`value <syntax-val>` :math:`\val_i` in :math:`\val^\ast` must be :ref:`valid <valid-val>` with some :ref:`value type <syntax-valtype>` :math:`t_i`.
 
@@ -359,21 +459,6 @@ Finally, :ref:`frames <syntax-frame>` are classified with *frame contexts*, whic
    }
 
 
-.. index:: value, value type
-.. _valid-val:
-
-:ref:`Values <syntax-val>` :math:`t.\CONST~c`
-.............................................
-
-* The value is valid with :ref:`value type <syntax-valtype>` :math:`t`.
-
-.. math::
-   \frac{
-   }{
-     \vdashval t.\CONST~c : t
-   }
-
-
 .. index:: administrative instruction, value type, context, store
 .. _valid-instr-admin:
 
@@ -381,7 +466,7 @@ Administrative Instructions
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Typing rules for :ref:`administrative instructions <syntax-instr-admin>` are specified as follows.
-In addition to the :ref:`context <contxt>` :math:`C`, typing of these instructions is defined under a given :ref:`store <syntax-store>` :math:`S`.
+In addition to the :ref:`context <context>` :math:`C`, typing of these instructions is defined under a given :ref:`store <syntax-store>` :math:`S`.
 To that end, all previous typing judgements :math:`C \vdash \X{prop}` are generalized to include the store, as in :math:`S; C \vdash \X{prop}`, by implicitly adding :math:`S` to all rules -- :math:`S` is never modified by the pre-existing rules, but it is accessed in the new rules for :ref:`administrative instructions <valid-instr-admin>` and  :ref:`module instructions <valid-moduleinstr>` given below.
 
 
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index ee21271f8..d2ee6ae0d 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1101,31 +1101,24 @@ Furthermore, the resulting store must be :ref:`valid <valid-store>`, i.e., all d
    ~\\[-1ex]
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   S; \val_1^n~(\INVOKE~a) &\stepto& S'; \val_2^m
+   S; \val^n~(\INVOKE~a) &\stepto& S'; \result
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & S.\SFUNCS[a] = \{ \FITYPE~[t_1^n] \to [t_2^m], \FIHOSTCODE~\dots \} \\
-     \wedge & \val_1^n = (t_1.\CONST~c_1)^n \\
-     \wedge & \val_2^m = (t_2.\CONST~c_2)^m \\
-     \wedge & \vdashstoreextends S \extendsto S' \\
-     \wedge & \vdashstore S' \ok) \\
-     \end{array}
-   \\[1ex]
-   \begin{array}{lcl@{\qquad}l}
-   S; \val^n~(\INVOKE~a) &\stepto& S'; \TRAP
-   \end{array}
-   \\ \qquad
-     \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & S.\SFUNCS[a] = \{ \FITYPE~\X{ft}, \FIHOSTCODE~\dots \} \\ 
-     \wedge & \vdashstoreextends S \extendsto S' \\
-     \wedge & \vdashstore S' \ok) \\
+     (\mbox{if} & S.\SFUNCS[a] = \{ \FITYPE~[t_1^n] \to [t_2^m], \FIHOSTCODE~\X{hf} \} \\
+     \wedge & \X{hf}(S; \val^n) = S'; \result) \\
      \end{array} \\
    \end{array}
 
-Here, :math:`S \extendsto S'` expresses that the new store :math:`S'` is an :ref:`extension <extend>` of :math:`S`.
-Moreover, :math:`\vdashstore S' \ok` restricts :math:`S'` to be a :ref:`valid <valid-store>` store.
-Both notions are defined in the :ref:`Appendix <properties>`.
+Here, :math:`\X{hf}(S; \val^n)` denotes the implementation-defined execution of host function :math:`\X{hf}` in current store :math:`S` with arguments :math:`\val^n`.
+The outcome is a pair of a modified store :math:`S'` and a :ref:`result <syntax-result>`.
+
+For a WebAssembly implementation to be :ref:`sound <soundness>` in the presence of host functions,
+every :ref:`host function instance <syntax-funcinst>` must be :ref:`valid <valid-hostfuncinst>`,
+which means that it adheres to suitable pre- and post-conditions:
+under a :ref:`valid store <valid-store>` :math:`S`, and given arguments :math:`\val^n` matching the ascribed parameter types :math:`t_1^n`,
+executing the host function must produce a valid store :math:`S'` that is an :ref:`extension <extend-store>` of :math:`S` and a result matching the ascribed return types :math:`t_2^m`.
+All these notions are made precise in the :ref:`Appendix <soundness>`.
 
 .. note::
    A host function can call back into WebAssembly by :ref:`invoking <exec-invocation>` a function :ref:`exported <syntax-export>` from a :ref:`module <syntax-module>`.
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 3548a4dd1..6a3dc2b46 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -729,8 +729,8 @@ The values :math:`\val_{\F{res}}^m` are returned as the results of the invocatio
 .. math::
    ~\\[-1ex]
    \begin{array}{@{}lcl}
-   \invoke(S, \funcaddr, \val^n) &=& \val_{\F{res}}^m / \TRAP \\
+   \invoke(S, \funcaddr, \val^n) &=& \result \\
      &(\iff & S.\SFUNCS[\funcaddr].\FITYPE = [t_1^n] \to [t_2^m] \\
      &\wedge& \val^n = (t_1.\CONST~c)^n \\
-     &\wedge& S; \val^n~(\INVOKE~\funcaddr) \stepto^\ast S'; \val_{\F{res}}^m / \TRAP) \\
+     &\wedge& S; \val^n~(\INVOKE~\funcaddr) \stepto^\ast S'; \result) \\
    \end{array}
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 5d81db128..03a1de0be 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -30,6 +30,27 @@ It is convenient to reuse the same notation as for the |CONST| :ref:`instruction
    \end{array}
 
 
+.. index:: ! result, value, trap
+   pair: abstract syntax; result
+.. _syntax-result:
+
+Results
+~~~~~~~
+
+A *result* is the outcome of a computation.
+It is either a sequence of :ref:`values <syntax-val>` or a :ref:`trap <syntax-trap>`.
+
+.. math::
+   \begin{array}{llcl}
+   \production{(result)} & \result &::=&
+     \val^\ast \\&&|&
+     \TRAP
+   \end{array}
+
+.. note::
+   In the current version of WebAssembly, a result can consist of at most one value.
+
+
 .. index:: ! store, function instance, table instance, memory instance, global instance, module, allocation
    pair: abstract syntax; store
 .. _syntax-store:
@@ -171,7 +192,8 @@ The module instance is used to resolve references to other definitions during ex
 A *host function* is a function expressed outside WebAssembly but passed to a :ref:`module <syntax-module>` as an :ref:`import <syntax-import>`.
 The definition and behavior of host functions are outside the scope of this specification.
 For the purpose of this specification, it is assumed that when :ref:`invoked <exec-invoke-host>`,
-a host function behaves non-deterministically.
+a host function behaves non-deterministically,
+but within certain :ref:`constraints <exec-invoke-host>` that ensure the integrity of the runtime.
 
 .. note::
    Function instances are immutable, and their identity is not observable by WebAssembly code.
diff --git a/document/core/util/math.def b/document/core/util/math.def
index ed2d48ff0..3002aa646 100644
--- a/document/core/util/math.def
+++ b/document/core/util/math.def
@@ -819,9 +819,13 @@
 .. |DO| mathdef:: \xref{exec/runtime}{syntax-do}{\K{do}}
 
 
-.. Values & Administrative Instructions, non-terminals
+.. Values & Results, non-terminals
 
 .. |val| mathdef:: \xref{exec/runtime}{syntax-val}{\X{val}}
+.. |result| mathdef:: \xref{exec/runtime}{syntax-result}{\X{result}}
+
+
+.. Administrative Instructions, non-terminals
 
 .. |moduleinstr| mathdef:: \xref{exec/runtime}{syntax-moduleinstr}{\X{moduleinstr}}
 
@@ -938,6 +942,9 @@
 .. |vdashadmininstr| mathdef:: \xref{appendix/properties}{valid-instr-admin}{\vdash}
 .. |vdashmoduleinstr| mathdef:: \xref{appendix/properties}{valid-moduleinstr}{\vdash}
 
+.. |vdashval| mathdef:: \xref{appendix/properties}{valid-val}{\vdash}
+.. |vdashresult| mathdef:: \xref{appendix/properties}{valid-result}{\vdash}
+
 .. |vdashfuncinst| mathdef:: \xref{appendix/properties}{valid-funcinst}{\vdash}
 .. |vdashtableinst| mathdef:: \xref{appendix/properties}{valid-tableinst}{\vdash}
 .. |vdashmeminst| mathdef:: \xref{appendix/properties}{valid-meminst}{\vdash}
@@ -949,7 +956,6 @@
 .. |vdashconfig| mathdef:: \xref{appendix/properties}{valid-config}{\vdash}
 .. |vdashthread| mathdef:: \xref{appendix/properties}{valid-thread}{\vdash}
 .. |vdashframe| mathdef:: \xref{appendix/properties}{valid-frame}{\vdash}
-.. |vdashval| mathdef:: \xref{appendix/properties}{valid-val}{\vdash}
 
 .. |vdashfuncinstextends| mathdef:: \xref{appendix/properties}{extend-funcinst}{\vdash}
 .. |vdashtableinstextends| mathdef:: \xref{appendix/properties}{extend-tableinst}{\vdash}

From ac0780ec5452e61625131e01f1351e52d85235a8 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 6 Sep 2017 16:40:29 +0200
Subject: [PATCH 085/329] Fix Latex

---
 document/core/text/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index f95c590ea..57723b6ab 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -177,7 +177,7 @@ The offset defaults to :math:`\T{0}`, the alignment to the storage size of the r
 Lexically, an |Toffset| or |Talign| phrase is considered a single :ref:`keyword token <text-keyword>`, so no :ref:`white space <text-space>` is allowed around the :math:`\text{=}`.
 
 .. math::
-   \begin{array}{llclll}
+   \begin{array}{llcllll}
    \production{memory argument} & \Tmemarg_N &::=&
      o{:}\Toffset~~a{:}\Talign_N &\Rightarrow& \{ \ALIGN~n,~\OFFSET~o \} & (\iff a = 2^n) \\
    \production{memory offset} & \Toffset &::=&

From 667dbad310950ece7596e6068a4d05977d485047 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Fri, 15 Sep 2017 09:25:51 +0200
Subject: [PATCH 086/329] [spec] List external standard dependencies (#564)

---
 document/core/appendix/custom.rst           |  2 +-
 document/core/appendix/implementation.rst   |  4 +-
 document/core/appendix/properties.rst       |  6 +--
 document/core/binary/values.rst             | 10 ++---
 document/core/conf.py                       |  2 +-
 document/core/exec/conventions.rst          | 12 +++---
 document/core/exec/numerics.rst             | 12 ++++--
 document/core/intro/introduction.rst        | 16 ++++++++
 document/core/intro/overview.rst            |  2 +-
 document/core/syntax/instructions.rst       |  2 +-
 document/core/syntax/types.rst              |  2 +-
 document/core/syntax/values.rst             |  6 +--
 document/core/text/conventions.rst          |  8 ++--
 document/core/text/lexical.rst              |  6 +--
 document/core/text/values.rst               | 10 ++---
 document/core/util/{math.def => macros.def} | 43 +++++++++++++++++++++
 document/core/valid/conventions.rst         | 12 +++---
 17 files changed, 110 insertions(+), 45 deletions(-)
 rename document/core/util/{math.def => macros.def} (97%)

diff --git a/document/core/appendix/custom.rst b/document/core/appendix/custom.rst
index 1f6d94b33..02895e3cb 100644
--- a/document/core/appendix/custom.rst
+++ b/document/core/appendix/custom.rst
@@ -22,7 +22,7 @@ The name section should appear only once in a module, and only after the :ref:`d
 The purpose of this section is to attach printable names to definitions in a module, which e.g. can be used by a debugger or when parts of the module are to be rendered in :ref:`text form <text>`.
 
 .. note::
-   All :ref:`names <binary-name>` are represented in `Unicode <http://www.unicode.org/versions/latest/>`_ encoded in UTF-8.
+   All :ref:`names <binary-name>` are represented in |Unicode|_ encoded in UTF-8.
    Names need not be unique.
 
 
diff --git a/document/core/appendix/implementation.rst b/document/core/appendix/implementation.rst
index 59378f818..83d7d8729 100644
--- a/document/core/appendix/implementation.rst
+++ b/document/core/appendix/implementation.rst
@@ -59,9 +59,9 @@ then the implementation may reject the :ref:`validation <valid>`, compilation, o
 
 .. note::
    The last item allows :ref:`embedders <embedder>` that operate in limited environments without support for
-   `Unicode <http://www.unicode.org/versions/latest/>`_ to limit the
+   |Unicode|_ to limit the
    names of :ref:`imports <syntax-import>` and :ref:`exports <syntax-export>`
-   to common subsets like `ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_.
+   to common subsets like |ASCII|_.
 
 
 .. index:: binary format, module, section, function, code
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 2ade29dfa..afc4319d9 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -17,7 +17,7 @@ The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *t
 Soundness also is instrumental in ensuring additional properties, most notably, *encapsulation* of function and module scopes: no :ref:`locals <syntax-local>` can be accessed outside their own function and no :ref:`module <syntax-module>` components can be accessed outside their own module unless they are explicitly :ref:`exported <syntax-export>` or :ref:`imported <syntax-import>`.
 
 The typing rules defining WebAssembly :ref:`validation <valid>` only cover the *static* components of a WebAssembly program.
-In order to state and prove soundness precisely, the typing rules must be extended to the *dynamic* components of the abstract :ref:`runtime <syntax-runtime>`, that is, the :ref:`store <syntax-store>`, :ref:`configurations <syntax-config>`, and :ref:`administrative instructions <syntax-instr-admin>` as well as :ref:`module instructions <valid-moduleinstr>`. [#pldi2017]_
+In order to state and prove soundness precisely, the typing rules must be extended to the *dynamic* components of the abstract :ref:`runtime <syntax-runtime>`, that is, the :ref:`store <syntax-store>`, :ref:`configurations <syntax-config>`, and :ref:`administrative instructions <syntax-instr-admin>` as well as :ref:`module instructions <valid-moduleinstr>`. [#cite-pldi2017]_
 
 
 .. index:: value, value type, result, result type, trap
@@ -806,6 +806,6 @@ Every thread in a valid configuration either runs forever, traps, or terminates
 Consequently, given a :ref:`valid store <valid-store>`, no computation defined by :ref:`instantiation <exec-instantiation>` or :ref:`invocation <exec-invocation>` of a valid module can "crash" or otherwise (mis)behave in ways not covered by the :ref:`execution <exec>` semantics given in this specification.
 
 
-.. [#pldi2017]
+.. [#cite-pldi2017]
    The formalization and theorems are derived from the following article:
-   Andreas Haas, Andreas Rossberg, Derek Schuff, Ben Titzer, Dan Gohman, Luke Wagner, Alon Zakai, JF Bastien, Michael Holman. `Bringing the Web up to Speed with WebAssembly <https://dl.acm.org/citation.cfm?doid=3062341.3062363>`_. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM 2017.
+   Andreas Haas, Andreas Rossberg, Derek Schuff, Ben Titzer, Dan Gohman, Luke Wagner, Alon Zakai, JF Bastien, Michael Holman. |PLDI2017|_. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM 2017.
diff --git a/document/core/binary/values.rst b/document/core/binary/values.rst
index 4efce6ffb..83dffe710 100644
--- a/document/core/binary/values.rst
+++ b/document/core/binary/values.rst
@@ -36,9 +36,9 @@ Bytes
 Integers
 ~~~~~~~~
 
-All :ref:`integers <syntax-int>` are encoded using the `LEB128 <https://en.wikipedia.org/wiki/LEB128>`_ variable-length integer encoding, in either unsigned or signed variant.
+All :ref:`integers <syntax-int>` are encoded using the |LEB128|_ variable-length integer encoding, in either unsigned or signed variant.
 
-:ref:`Unsigned integers <syntax-uint>` are encoded in `unsigned LEB128 <https://en.wikipedia.org/wiki/LEB128#Unsigned_LEB128>`_ format.
+:ref:`Unsigned integers <syntax-uint>` are encoded in |UnsignedLEB128|_ format.
 As an additional constraint, the total number of bytes encoding a value of type :math:`\uN` must not exceed :math:`\F{ceil}(N/7)` bytes.
 
 .. math::
@@ -49,7 +49,7 @@ As an additional constraint, the total number of bytes encoding a value of type
        2^7\cdot m + (n-2^7) & (\iff n \geq 2^7 \wedge N > 7) \\
    \end{array}
 
-:ref:`Signed integers <syntax-sint>` are encoded in `signed LEB128 <https://en.wikipedia.org/wiki/LEB128#Signed_LEB128>`_ format, which uses a two's complement representation.
+:ref:`Signed integers <syntax-sint>` are encoded in |SignedLEB128|_ format, which uses a two's complement representation.
 As an additional constraint, the total number of bytes encoding a value of type :math:`\sN` must not exceed :math:`\F{ceil}(N/7)` bytes.
 
 .. math::
@@ -88,7 +88,7 @@ As an additional constraint, the total number of bytes encoding a value of type
 Floating-Point
 ~~~~~~~~~~~~~~
 
-:ref:`Floating-point <syntax-float>` values are encoded directly by their `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ bit pattern in `little endian <https://en.wikipedia.org/wiki/Endianness#Little-endian>`_ byte order:
+:ref:`Floating-point <syntax-float>` values are encoded directly by their |IEEE754|_ bit pattern in |LittleEndian|_ byte order:
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
@@ -105,7 +105,7 @@ Floating-Point
 Names
 ~~~~~
 
-:ref:`Names <syntax-name>` are encoded as a :ref:`vector <binary-vec>` of bytes containing the `Unicode <http://www.unicode.org/versions/latest/>`_ UTF-8 encoding of the name's code point sequence.
+:ref:`Names <syntax-name>` are encoded as a :ref:`vector <binary-vec>` of bytes containing the |Unicode|_ UTF-8 encoding of the name's code point sequence.
 
 .. math::
    \begin{array}{llclllll}
diff --git a/document/core/conf.py b/document/core/conf.py
index 187792414..82e1e3f43 100644
--- a/document/core/conf.py
+++ b/document/core/conf.py
@@ -475,5 +475,5 @@
 
 # Macros
 rst_prolog = """
-.. include:: /""" + pwd + """/util/math.def
+.. include:: /""" + pwd + """/util/macros.def
 """
diff --git a/document/core/exec/conventions.rst b/document/core/exec/conventions.rst
index 7c0df438d..edddbea9f 100644
--- a/document/core/exec/conventions.rst
+++ b/document/core/exec/conventions.rst
@@ -13,7 +13,7 @@ Furthermore, there are rules describing the instantiation of a module.
 As with :ref:`validation <validation>`, all rules are given in two *equivalent* forms:
 
 1. In *prose*, describing the execution in intuitive form.
-2. In *formal notation*, describing the rule in mathematical form. [#pldi2017]_
+2. In *formal notation*, describing the rule in mathematical form. [#cite-pldi2017]_
 
 .. note::
    As with validation, the prose and formal rules are equivalent,
@@ -62,7 +62,7 @@ Formal Notation
 
 .. note::
    This section gives a brief explanation of the notation for specifying execution formally.
-   For the interested reader, a more thorough introduction can be found in respective text books. [#tapl]_
+   For the interested reader, a more thorough introduction can be found in respective text books. [#cite-tapl]_
 
 The formal execution rules use a standard approach for specifying operational semantics, rendering them into *reduction rules*.
 Every rule has the following general form:
@@ -126,9 +126,9 @@ or if a :ref:`trap <syntax-trap>` occurred.
    where :math:`x_4 = -x_2` and :math:`x_5 = -x_2 + x_3` and :math:`x_6 = x_1 \cdot (-x_2 + x_3)`.
 
 
-.. [#pldi2017]
+.. [#cite-pldi2017]
    The semantics is derived from the following article:
-   Andreas Haas, Andreas Rossberg, Derek Schuff, Ben Titzer, Dan Gohman, Luke Wagner, Alon Zakai, JF Bastien, Michael Holman. `Bringing the Web up to Speed with WebAssembly <https://dl.acm.org/citation.cfm?doid=3062341.3062363>`_. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM 2017.
+   Andreas Haas, Andreas Rossberg, Derek Schuff, Ben Titzer, Dan Gohman, Luke Wagner, Alon Zakai, JF Bastien, Michael Holman. |PLDI2017|_. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM 2017.
 
-.. [#tapl]
-   For example: Benjamin Pierce. `Types and Programming Languages <https://www.cis.upenn.edu/~bcpierce/tapl/>`_. The MIT Press 2002
+.. [#cite-tapl]
+   For example: Benjamin Pierce. |TAPL|_. The MIT Press 2002
diff --git a/document/core/exec/numerics.rst b/document/core/exec/numerics.rst
index da863d3cc..01c4b5482 100644
--- a/document/core/exec/numerics.rst
+++ b/document/core/exec/numerics.rst
@@ -99,7 +99,7 @@ Boolean operators like :math:`\wedge`, :math:`\vee`, or :math:`\veebar` are lift
 Floating-Point
 ..............
 
-:ref:`Floating-point values <syntax-float>` are represented in the respective binary format defined by `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_:
+:ref:`Floating-point values <syntax-float>` are represented in the respective binary format defined by |IEEE754|_ (Section 3.4):
 
 .. math::
    \begin{array}{lll@{\qquad}l}
@@ -122,7 +122,7 @@ where :math:`M = \significand(N)` and :math:`E = \exponent(N)`.
 Storage
 .......
 
-When a number is stored into :ref:`memory <syntax-mem>`, it is converted into a sequence of :ref:`bytes <syntax-byte>` in `little endian <https://en.wikipedia.org/wiki/Endianness#Little-endian>`_ byte order:
+When a number is stored into :ref:`memory <syntax-mem>`, it is converted into a sequence of :ref:`bytes <syntax-byte>` in |LittleEndian|_ byte order:
 
 .. math::
    \begin{array}{lll@{\qquad}l}
@@ -135,6 +135,7 @@ Again these functions are invertable bijections.
 
 
 .. index:: integer
+.. _int-ops:
 
 Integer Operations
 ~~~~~~~~~~~~~~~~~~
@@ -611,11 +612,12 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
 
 
 .. index:: floating-point, IEEE 754
+.. _float-ops:
 
 Floating-Point Operations
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Floating-point arithmetic follows the `IEEE 754-2008 <http://ieeexplore.ieee.org/document/4610935/>`_ standard,
+Floating-point arithmetic follows the |IEEE754|_ standard,
 with the following qualifications:
 
 * All operators use round-to-nearest ties-to-even, except where otherwise specified.
@@ -637,6 +639,8 @@ with the following qualifications:
 Rounding
 ........
 
+Rounding always is round-to-nearest ties-to-even, in correspondance with |IEEE754|_ (Section 4.3.1).
+
 An *exact* floating-point number is a rational number that is exactly representable as a :ref:`floating-point number <syntax-float>` of given bit width :math:`N`.
 
 A *limit* number for a given floating-point bit width :math:`N` is a positive or negative number whose magnitude is the smallest power of :math:`2` that is not exactly representable as a floating-point number of width :math:`N` (that magnitude is :math:`2^{128}` for :math:`N = 32` and :math:`2^{1024}` for :math:`N = 64`).
@@ -1358,6 +1362,8 @@ This non-deterministic result is expressed by the following auxiliary function p
    \end{array}
 
 
+.. _convert-ops:
+
 Conversions
 ~~~~~~~~~~~
 
diff --git a/document/core/intro/introduction.rst b/document/core/intro/introduction.rst
index 6b478b159..a514fcea3 100644
--- a/document/core/intro/introduction.rst
+++ b/document/core/intro/introduction.rst
@@ -73,3 +73,19 @@ It does not, however, define how WebAssembly programs can interact with a specif
 
 Instead, this specification is complemented by additional documents defining interfaces to specific embedding environments such as the Web.
 These will each define a WebAssembly *application programming interface (API)* suitable for a given environment.
+
+
+.. index:: IEEE 754, floating point, Unicode, name, text format, UTF-8, code point
+.. _dependencies:
+
+Dependencies
+~~~~~~~~~~~~
+
+WebAssembly depends on two existing standards:
+
+* |IEEE754|_, for the representation of :ref:`floating-point data <syntax-float>` and the semantics of respective :ref:`numeric operations <float-ops>`.
+
+* |Unicode|_, for the representation of import/export :ref:`names <syntax-name>` and the :ref:`text format <text>`.
+
+However, to make this specification self-contained, relevant aspects of the aforementioned standards are defined and formalized as part of this specification,
+such as the :ref:`binary representation <aux-fbits>` and :ref:`rounding <aux-ieee>` of floating-point values, and the :ref:`value range <syntax-codepoint>` and :ref:`UTF-8 encoding <binary-utf8>` of Unicode characters.
diff --git a/document/core/intro/overview.rst b/document/core/intro/overview.rst
index 593dff225..6973396c0 100644
--- a/document/core/intro/overview.rst
+++ b/document/core/intro/overview.rst
@@ -14,7 +14,7 @@ This language is structured around the following concepts.
 
 **Values**
   WebAssembly provides only four basic *value types*.
-  These are integers and `IEEE 754 floating-point <http://ieeexplore.ieee.org/document/4610935/>`_ numbers,
+  These are integers and |IEEE754|_ numbers,
   each in 32 and 64 bit width.
   32 bit integers also serve as Booleans and as memory addresses.
   The usual operations on these types are available,
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index acdb3f0db..c6663e88b 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -250,7 +250,7 @@ Integer loads and stores can optionally specify a *storage size* that is smaller
 In the case of loads, a sign extension mode |sx| is then required to select appropriate behavior.
 
 The static address offset is added to the dynamic address operand, yielding a 33 bit *effective address* that is the zero-based index at which the memory is accessed.
-All values are read and written in `little endian <https://en.wikipedia.org/wiki/Endianness#Little-endian>`_ byte order.
+All values are read and written in |LittleEndian|_ byte order.
 A :ref:`trap <trap>` results if any of the accessed memory bytes lies outside the address range implied by the memory's current size.
 
 .. note::
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index 57da119cc..6898fb59e 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -29,7 +29,7 @@ The types |I32| and |I64| classify 32 and 64 bit integers, respectively.
 Integers are not inherently signed or unsigned, their interpretation is determined by individual operations.
 
 The types |F32| and |F64| classify 32 and 64 bit floating-point data, respectively.
-They correspond to *single* and *double* precision floating-point types as defined by the `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ standard
+They correspond to the respective binary floating-point representations, also known as *single* and *double* precision, as defined by the |IEEE754|_ standard (Section 3.3).
 
 Conventions
 ...........
diff --git a/document/core/syntax/values.rst b/document/core/syntax/values.rst
index 4c65e0596..e2dcc91ca 100644
--- a/document/core/syntax/values.rst
+++ b/document/core/syntax/values.rst
@@ -91,9 +91,9 @@ Conventions
 Floating-Point
 ~~~~~~~~~~~~~~
 
-*Floating-point* data consists of 32 or 64 bit values according to the `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ standard.
-Every value has a *sign* and a *magnitude*.
+*Floating-point* data represents 32 or 64 bit values that correspond to the respective binary formats of the |IEEE754|_ standard (Section 3.3).
 
+Every value has a *sign* and a *magnitude*.
 Magnitudes can either be expressed as *normal* numbers of the form :math:`m_0.m_1m_2\dots m_M \cdot2^e`, where :math:`e` is the exponent and :math:`m` is the *significand* whose most signifcant bit :math:`m_0` is :math:`1`,
 or as a *subnormal* number where the exponent is fixed to the smallest possible value and :math:`m_0` is :math:`0`; among the subnormals are positive and negative zero values.
 Since the significands are binary values, normals are represented in the form :math:`(1 + m\cdot 2^{-M}) \cdot 2^e`, where :math:`M` is the bit width of :math:`m`; similarly for subnormals.
@@ -154,7 +154,7 @@ Conventions
 Names
 ~~~~~
 
-*Names* are sequences of scalar `Unicode <http://www.unicode.org/versions/latest/>`_ *code points*.
+*Names* are sequences of scalar *code points* as defined by |Unicode|_ (Section 2.4).
 
 .. math::
    \begin{array}{llclll}
diff --git a/document/core/text/conventions.rst b/document/core/text/conventions.rst
index 1982fb0c9..ef7ad7f39 100644
--- a/document/core/text/conventions.rst
+++ b/document/core/text/conventions.rst
@@ -3,7 +3,7 @@
 Conventions
 -----------
 
-The textual format for WebAssembly :ref:`modules <module>` is a rendering of their :ref:`abstract syntax <syntax-module>` into `S-expressions <https://en.wikipedia.org/wiki/S-expression>`_.
+The textual format for WebAssembly :ref:`modules <module>` is a rendering of their :ref:`abstract syntax <syntax-module>` into |SExpressions|_.
 
 Like the :ref:`binary format <binary>`, the text format is defined by an *attribute grammar*.
 A text string is a well-formed description of a module if and only if it is generated by the grammar.
@@ -16,7 +16,7 @@ Except for a few exceptions, the core of the text grammar closely mirrors the gr
 However, it also defines a number of *abbreviations* that are "syntactic sugar" over the core syntax.
 
 The recommended extension for source files containing WebAssembly modules in text format is ":math:`\T{.wat}`".
-Files with this extension are assumed to be encoded in `Unicode UTF-8 <http://www.unicode.org/versions/latest/>`_.
+Files with this extension are assumed to be encoded in UTF-8, as per |Unicode|_ (Section 2.5).
 
 
 .. index:: grammar notation, notation, Unicode
@@ -32,8 +32,8 @@ They mirror the conventions used for :ref:`abstract syntax <grammar>` and for th
 In order to distinguish symbols of the textual syntax from symbols of the abstract syntax, :math:`\mathtt{typewriter}` font is adopted for the former.
 
 * Terminal symbols are either literal strings of characters enclosed in quotes: :math:`\text{module}`;
-  or expressed as `Unicode <http://www.unicode.org/versions/latest/>`_ code points: :math:`\unicode{0A}`.
-  (All characters written literally are unambiguously drawn from the `7-bit ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ subset of Unicode.)
+  or expressed as |Unicode|_ code points: :math:`\unicode{0A}`.
+  (All characters written literally are unambiguously drawn from the 7-bit |ASCII|_ subset of Unicode.)
 
 * Nonterminal symbols are written in typewriter font: :math:`\T{valtype}, \T{instr}`.
 
diff --git a/document/core/text/lexical.rst b/document/core/text/lexical.rst
index 2103ccd44..3fdb81c76 100644
--- a/document/core/text/lexical.rst
+++ b/document/core/text/lexical.rst
@@ -14,7 +14,7 @@ Characters
 ~~~~~~~~~~
 
 The text format assigns meaning to *source text*, which consists of a sequence of *characters*.
-Characters are assumed to be represented as valid `Unicode <http://www.unicode.org/versions/latest/>`_ *code points*.
+Characters are assumed to be represented as valid |Unicode|_ (Section 2.4) *code points*.
 
 .. math::
    \begin{array}{llll}
@@ -24,7 +24,7 @@ Characters are assumed to be represented as valid `Unicode <http://www.unicode.o
 
 .. note::
    While source text may contain any Unicode character in :ref:`comments <text-comment>` or :ref:`string <text-string>` literals,
-   the rest of the grammar is formed exclusively from the characters supported by the `7-bit ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ subset of Unicode.
+   the rest of the grammar is formed exclusively from the characters supported by the 7-bit |ASCII|_ subset of Unicode.
 
 
 .. index:: ! token, ! keyword, character, white space, comment, source text
@@ -75,7 +75,7 @@ White Space
 ~~~~~~~~~~~
 
 *White space* is any sequence of literal space characters, formatting characters, or :ref:`comments <text-comment>`.
-The allowed formatting characters correspond to a subset of the `ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ *format effectors*, namely, *horizontal tabulation* (:math:`\unicode{09}`), *line feed* (:math:`\unicode{0A}`), and *carriage return* (:math:`\unicode{0D}`).
+The allowed formatting characters correspond to a subset of the |ASCII|_ *format effectors*, namely, *horizontal tabulation* (:math:`\unicode{09}`), *line feed* (:math:`\unicode{0A}`), and *carriage return* (:math:`\unicode{0D}`).
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
diff --git a/document/core/text/values.rst b/document/core/text/values.rst
index 67c22d0f8..42084a2c1 100644
--- a/document/core/text/values.rst
+++ b/document/core/text/values.rst
@@ -111,7 +111,7 @@ Floating-Point
        &\Rightarrow& (p+q)\cdot 2^{\pm e}
    \end{array}
 
-The value of a literal must not lie outside the representable range of the corresponding `IEEE 754 <http://ieeexplore.ieee.org/document/4610935/>`_ type
+The value of a literal must not lie outside the representable range of the corresponding |IEEE754|_ type
 (that is, a numeric value must not overflow to :math:`\pm\mbox{infinity}`),
 but it may be :ref:`rounded <aux-ieee>` to the nearest representable value.
 
@@ -145,7 +145,7 @@ Strings
 
 *Strings* denote sequences of bytes that can represent both textual and binary data.
 They are enclosed in quotation marks
-and may contain any character other than `ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ control characters, quotation marks (:math:`\text{"}`), or backslash (:math:`\text{\backslash}`),
+and may contain any character other than |ASCII|_ control characters, quotation marks (:math:`\text{"}`), or backslash (:math:`\text{\backslash}`),
 except when expressed with an *escape sequence*.
 
 .. math::
@@ -160,7 +160,7 @@ except when expressed with an *escape sequence*.
        &\Rightarrow& 16\cdot n+m \\
    \end{array}
 
-Each character in a string literal represents the byte sequence corresponding to its `Unicode <http://www.unicode.org/versions/latest/>`_ UTF-8 encoding,
+Each character in a string literal represents the byte sequence corresponding to its UTF-8 |Unicode|_ (Section 2.5) encoding,
 except for hexadecimal escape sequences :math:`\textl\backslash hh\textr`, which represent raw bytes of the respective value.
 
 .. math::
@@ -187,7 +187,7 @@ Names
 ~~~~~
 
 :ref:`Names <syntax-name>` are strings denoting a literal character sequence. 
-A name string must form a valid `UTF-8 <http://www.unicode.org/versions/latest/>`_ encoding that is interpreted as a string of Unicode code points.
+A name string must form a valid UTF-8 encoding as defined by |Unicode|_ (Section 2.5) that is interpreted as a string of Unicode code points.
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
@@ -209,7 +209,7 @@ Identifiers
 ~~~~~~~~~~~
 
 :ref:`Indices <syntax-index>` can be given in both numeric and symbolic form.
-Symbolic *identifiers* that stand in lieu of indices start with :math:`\text{\$}`, followed by any sequence of printable `ASCII <http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d>`_ characters that does not contain a space, quotation mark, comma, semicolon, or bracket.
+Symbolic *identifiers* that stand in lieu of indices start with :math:`\text{\$}`, followed by any sequence of printable |ASCII|_ characters that does not contain a space, quotation mark, comma, semicolon, or bracket.
 
 .. math::
    \begin{array}{llclll@{\qquad}l}
diff --git a/document/core/util/math.def b/document/core/util/macros.def
similarity index 97%
rename from document/core/util/math.def
rename to document/core/util/macros.def
index 3002aa646..1b23f8bfa 100644
--- a/document/core/util/math.def
+++ b/document/core/util/macros.def
@@ -1,3 +1,46 @@
+.. LINK MACROS
+
+.. External Standards
+.. ------------------
+
+.. |IEEE754| replace:: IEEE 754-2008
+.. _IEEE754: http://ieeexplore.ieee.org/document/4610935/
+
+.. |Unicode| replace:: Unicode
+.. _Unicode: http://www.unicode.org/versions/latest/
+
+.. |ASCII| replace:: ASCII
+.. _ASCII: http://webstore.ansi.org/RecordDetail.aspx?sku=INCITS+4-1986%5bR2012%5d
+
+
+.. External Definitions
+.. --------------------
+
+.. |LittleEndian| replace:: little endian
+.. _LittleEndian: https://en.wikipedia.org/wiki/Endianness#Little-endian
+
+.. |LEB128| replace:: LEB128
+.. _LEB128: https://en.wikipedia.org/wiki/LEB128
+.. |UnsignedLEB128| replace:: unsigned LEB128
+.. _UnsignedLEB128: https://en.wikipedia.org/wiki/LEB128#Unsigned_LEB128
+.. |SignedLEB128| replace:: signed LEB128
+.. _SignedLEB128: https://en.wikipedia.org/wiki/LEB128#Signed_LEB128
+
+.. |SExpressions| replace:: S-expressions
+.. _SExpressions: https://en.wikipedia.org/wiki/S-expression
+
+
+.. Literature
+.. ----------
+
+.. |PLDI2017| replace:: Bringing the Web up to Speed with WebAssembly
+.. _PLDI2017: https://dl.acm.org/citation.cfm?doid=3062341.3062363>
+
+.. |TAPL| replace:: Types and Programming Languages
+.. _TAPL: https://www.cis.upenn.edu/~bcpierce/tapl/
+
+
+
 .. MATH MACROS
 
 
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index 5b0908817..5ed7789a7 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -12,7 +12,7 @@ For each piece of abstract syntax, there is a typing rule that specifies the con
 All rules are given in two *equivalent* forms:
 
 1. In *prose*, describing the meaning in intuitive form.
-2. In *formal notation*, describing the rule in mathematical form. [#pldi2017]_
+2. In *formal notation*, describing the rule in mathematical form. [#cite-pldi2017]_
 
 .. note::
    The prose and formal rules are equivalent,
@@ -117,7 +117,7 @@ Formal Notation
 
 .. note::
    This section gives a brief explanation of the notation for specifying typing rules formally.
-   For the interested reader, a more thorough introduction can be found in respective text books. [#tapl]_
+   For the interested reader, a more thorough introduction can be found in respective text books. [#cite-tapl]_
 
 The proposition that a phrase :math:`A` has a respective type :math:`T` is written :math:`A : T`.
 In general, however, typing is dependent on a context :math:`C`.
@@ -184,9 +184,9 @@ and there is one respective rule for each relevant construct :math:`A` of the ab
    which is expressed by extending the context :math:`C` with the additional label information for the premise.
 
 
-.. [#pldi2017]
+.. [#cite-pldi2017]
    The semantics is derived from the following article:
-   Andreas Haas, Andreas Rossberg, Derek Schuff, Ben Titzer, Dan Gohman, Luke Wagner, Alon Zakai, JF Bastien, Michael Holman. `Bringing the Web up to Speed with WebAssembly <https://dl.acm.org/citation.cfm?doid=3062341.3062363>`_. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM 2017.
+   Andreas Haas, Andreas Rossberg, Derek Schuff, Ben Titzer, Dan Gohman, Luke Wagner, Alon Zakai, JF Bastien, Michael Holman. |PLDI2017|_. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM 2017.
 
-.. [#tapl]
-   For example: Benjamin Pierce. `Types and Programming Languages <https://www.cis.upenn.edu/~bcpierce/tapl/>`_. The MIT Press 2002
+.. [#cite-tapl]
+   For example: Benjamin Pierce. |TAPL|_. The MIT Press 2002

From e01c4dafbfdee7fcf1cb9faac12cd780d8c70543 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Thu, 21 Sep 2017 11:28:39 +0200
Subject: [PATCH 087/329] [spec] Add embedder interface (#567)

Also, remove module instructions and module threads.
---
 document/core/appendix/embedding.rst   | 583 +++++++++++++++++++++++++
 document/core/appendix/index-rules.rst |  12 +-
 document/core/appendix/index.rst       |   3 +-
 document/core/appendix/properties.rst  | 179 +++-----
 document/core/exec/instructions.rst    |  38 +-
 document/core/exec/modules.rst         |  79 +++-
 document/core/exec/runtime.rst         |  69 +--
 document/core/text/lexical.rst         |   3 +
 document/core/util/macros.def          |  17 +-
 document/core/valid/modules.rst        |  43 +-
 10 files changed, 769 insertions(+), 257 deletions(-)
 create mode 100644 document/core/appendix/embedding.rst

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
new file mode 100644
index 000000000..1bbd32bdf
--- /dev/null
+++ b/document/core/appendix/embedding.rst
@@ -0,0 +1,583 @@
+.. index:: ! embedding, embedder, implementation, host
+.. _embed:
+
+Embedding
+---------
+
+A WebAssembly implementation will typically be *embedded* into a *host* environment.
+An *embedder* implements the connection between such a host environment and the WebAssembly semantics as defined in the main body of this specification.
+An embedder is expected to interact with the semantics in well-defined ways.
+
+This section defines a suitable interface to the WebAssembly semantics in the form of entry points through which an embedder can access it.
+The interface is intended to be complete, in the sense that an embedder does not need to reference other functional parts of the WebAssembly specification directly.
+
+.. note::
+   On the other hand, an embedder does not need to provide the host environment with access to all functionality defined in this interface.
+   For example, an implementation may not support :ref:`parsing <embed-parse-module>` of the :ref:`text format <text>`.
+
+In the description of the embedder interface, syntactic classes from the :ref:`abstract syntax <syntax>` and the :ref:`runtime's abstract machine <syntax-runtime>` are used as names for variables that range over the possible objects from that class.
+Hence, these syntactic classes can also be interpreted as types.
+
+.. _embed-error:
+
+Failure of an interface operation is indicated by an auxiliary syntactic class:
+
+.. math::
+   \begin{array}{llll}
+   \production{(error)} & \error &::=& \ERROR \\
+   \end{array}
+
+In addition to the error conditions specified explicitly in this section, implementations may also return errors when specific :ref:`implementation limitations <impl>` are reached.
+
+
+.. note::
+   Errors are abstract and unspecific with this definition.
+   Implementations can refine it to carry suitable classifications and diagnostic messages.
+
+
+
+.. index:: allocation, store
+.. _embed-store:
+
+Store
+~~~~~
+
+.. _embed-init-store:
+
+:math:`\F{init\_store}() : \store`
+..................................
+
+1. Return the empty :ref:`store <syntax-store>`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{init\_store}() &=& \{ \SFUNCS~\epsilon,~ \SMEMS~\epsilon,~ \STABLES~\epsilon,~ \SGLOBALS~\epsilon \} \\
+   \end{array}
+
+
+
+.. index:: module
+.. _embed-module:
+
+Modules
+~~~~~~~
+
+.. index:: binary format
+.. _embed-decode-module:
+
+:math:`\F{decode\_module}(\byte^\ast) : \module ~|~ \error`
+...........................................................
+
+1. If there exists a derivation for the :ref:`byte <syntax-byte>` sequence :math:`\byte^\ast` as a :math:`\Bmodule` according to the :ref:`binary grammar for modules <binary-module>`, yielding a :ref:`module <syntax-module>` :math:`m`, then return :math:`m`.
+
+2. Else, return :math:`\ERROR`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{decode\_module}(b^\ast) &=& m && (\iff \Bmodule \stackrel\ast\Longrightarrow m{:}b^\ast) \\
+   \F{decode\_module}(b^\ast) &=& \ERROR && (\otherwise) \\
+   \end{array}
+
+
+.. index:: text format
+.. _embed-parse-module:
+
+:math:`\F{parse\_module}(\codepoint^\ast) : \module ~|~ \error`
+...............................................................
+
+1. If there exists a derivation for the :ref:`source <text-source>` :math:`\codepoint^\ast` as a :math:`\Tmodule` according to the :ref:`text grammar for modules <text-module>`, yielding a :ref:`module <syntax-module>` :math:`m`, then return :math:`m`.
+
+2. Else, return :math:`\ERROR`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{parse\_module}(c^\ast) &=& m && (\iff \Tmodule \stackrel\ast\Longrightarrow m{:}c^\ast) \\
+   \F{parse\_module}(c^\ast) &=& \ERROR && (\otherwise) \\
+   \end{array}
+
+
+.. index:: validation
+.. _embed-validate-module:
+
+:math:`\F{validate\_module}(\module) : \error^?`
+................................................
+
+1. If :math:`\module` is :ref:`valid <valid-module>`, then return nothing.
+
+2. Else, return :math:`\ERROR`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{validate\_module}(m) &=& \epsilon && (\iff {} \vdashmodule m : \externtype^\ast \to {\externtype'}^\ast) \\
+   \F{validate\_module}(m) &=& \ERROR && (\otherwise) \\
+   \end{array}
+
+
+.. index:: instantiation, module instance
+.. _embed-instantiate-module:
+
+:math:`\F{instantiate\_module}(\store, \module, \externval^\ast) : (\store, \moduleinst ~|~ \error)`
+....................................................................................................
+
+1. Try :ref:`instantiating <exec-instantiation>` :math:`\module` in :math:`\store` with :ref:`external values <syntax-externval>` :math:`\externval^\ast` as imports:
+
+  a. If it succeeds with a :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst`, then let :math:`\X{result}` be :math:`\moduleinst`.
+
+  b. Else, let :math:`\X{result}` be :math:`\ERROR`.
+
+2. Return the new store paired with :math:`\X{result}`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{instantiate\_module}(S, m, \X{ev}^\ast) &=& (S', F.\AMODULE) && (\iff \instantiate(S, m, \X{ev}^\ast) \stepto^\ast S'; F; \epsilon) \\
+   \F{instantiate\_module}(S, m, \X{ev}^\ast) &=& (S', \ERROR) && (\iff \instantiate(S, m, \X{ev}^\ast) \stepto^\ast S'; F; \TRAP) \\
+   \end{array}
+
+.. note::
+   The store may be modified even in case of an error.
+
+
+.. index:: import
+.. _embed-imports:
+
+:math:`\F{module\_imports}(\module) : (\name, \name, \externtype)^\ast`
+.......................................................................
+
+1. Assert: :math:`\module` is :ref:`valid <valid-module>` with external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
+
+2. Let :math:`\import^\ast` be the :ref:`imports <syntax-import>` :math:`\module.\MIMPORTS`.
+
+3. Assert: the length of :math:`\import^\ast` equals the length of :math:`\externtype^\ast`.
+
+4. For each :math:`\import_i` in :math:`\import^\ast` and corresponding :math:`\externtype_i` in :math:`\externtype^\ast`, do:
+
+  a. Let :math:`\X{result}_i` be the triple :math:`(\import_i.\IMODULE, \import_i.\INAME, \externtype_i)`.
+
+5. Return the concatenation of all :math:`\X{result}_i`, in index order.
+
+.. math::
+   ~ \\
+   \begin{array}{lclll}
+   \F{module\_imports}(m) &=& (\X{im}.\IMODULE, \X{im}.\INAME, \externtype)^\ast \\
+     && \qquad (\iff \X{im}^\ast = m.\MIMPORTS \wedge {} \vdashmodule m : \externtype^\ast \to {\externtype'}^\ast) \\
+   \end{array}
+
+
+.. index:: export
+.. _embed-exports:
+
+:math:`\F{module\_exports}(\module) : (\name, \externtype)^\ast`
+................................................................
+
+1. Assert: :math:`\module` is :ref:`valid <valid-module>` with external import types :math:`\externtype^\ast` and external export types :math:`{\externtype'}^\ast`.
+
+2. Let :math:`\export^\ast` be the :ref:`exports <syntax-export>` :math:`\module.\MEXPORTS`.
+
+3. Assert: the length of :math:`\export^\ast` equals the length of :math:`\externtype^\ast`.
+
+4. For each :math:`\export_i` in :math:`\export^\ast` and corresponding :math:`\externtype'_i` in :math:`{\externtype'}^\ast`, do:
+
+  a. Let :math:`\X{result}_i` be the pair :math:`(\export_i.\ENAME, \externtype'_i)`.
+
+5. Return the concatenation of all :math:`\X{result}_i`, in index order.
+
+.. math::
+   ~ \\
+   \begin{array}{lclll}
+   \F{module\_exports}(m) &=& (\X{ex}.\ENAME, \externtype')^\ast \\
+     && \qquad (\iff \X{ex}^\ast = m.\MEXPORTS \wedge {} \vdashmodule m : \externtype^\ast \to {\externtype'}^\ast) \\
+   \end{array}
+
+
+.. index:: module, store, module instance, export instance
+.. _embed-export:
+
+Exports
+~~~~~~~
+
+.. _embed-get-export:
+
+:math:`\F{get\_export}(\moduleinst, \name) : \externval ~|~ \error`
+...................................................................
+
+1. Assert: due to :ref:`validity <valid-moduleinst>` of the :ref:`module instance <syntax-moduleinst>` :math:`\moduleinst`, all its :ref:`export names <syntax-exportinst>` are different.
+
+2. If there exists an :math:`\exportinst_i` in :math:`\moduleinst.\MIEXPORTS` such that :ref:`name <syntax-name>` :math:`\exportinst_i.\EINAME` equals :math:`\name`, then:
+
+   a. Return the :ref:`external value <syntax-externval>` :math:`\exportinst_i.\EIVALUE`.
+
+3. Else, return :math:`\ERROR`.
+
+.. math::
+   ~ \\
+   \begin{array}{lclll}
+   \F{get\_export}(m, \name) &=& m.\MIEXPORTS[i].\EIVALUE && (\iff m.\MEXPORTS[i].\EINAME = \name) \\
+   \F{get\_export}(m, \name) &=& \ERROR && (\otherwise) \\
+   \end{array}
+
+
+.. index:: function, host function, function address, function instance, function type, store
+.. _embed-func:
+
+Functions
+~~~~~~~~~
+
+.. _embed-alloc-func:
+
+:math:`\F{alloc\_func}(\store, \functype, \hostfunc) : (\store, \funcaddr)`
+...........................................................................
+
+1. Let :math:`\funcaddr` be the result of :ref:`allocating a host function <alloc-func>` in :math:`\store` with :ref:`function type <syntax-functype>` :math:`\functype` and host function code :math:`\hostfunc`.
+
+2. Return the new store paired with :math:`\funcaddr`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{alloc\_func}(S, \X{ft}, \X{code}) &=& (S', \X{a}) && (\iff \allochostfunc(S, \X{ft}, \X{code}) = S', \X{a}) \\
+   \end{array}
+
+.. note::
+   This operation assumes that :math:`\hostfunc` satisfies the :ref:`pre- and post-conditions <exec-invoke-host>` required for a function instance with type :math:`\functype`.
+
+   Regular (non-host) function instances can only be created indirectly through :ref:`module instantiation <embed-instantiate-module>`.
+
+
+.. _embed-type-func:
+
+:math:`\F{type\_func}(\store, \funcaddr) : \functype`
+.....................................................
+
+1. Assert: :math:`\store.\SFUNCS[\funcaddr]` exists.
+
+2. Assert: the :ref:`external value <syntax-externval>` :math:`\EVFUNC~\funcaddr` is :ref:`valid <valid-externval>` with :ref:`external type <syntax-externtype>` :math:`\ETFUNC~\functype`.
+
+3. Return :math:`\functype`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{type\_func}(S, a) &=& \X{ft} && (\iff S \vdashexternval \EVFUNC~a : \ETFUNC~\X{ft}) \\
+   \end{array}
+
+
+.. index:: invocation, value, result
+.. _embed-invoke-func:
+
+:math:`\F{invoke\_func}(\store, \funcaddr, \val^\ast) : (\store, \val^\ast ~|~ \error`)`
+........................................................................................
+
+1. Assert: :math:`\store.\SFUNCS[\funcaddr]` exists.
+
+2. Try :ref:`invoking <exec-invocation>` the function :math:`\funcaddr` in :math:`\store` with :ref:`values <syntax-val>` :math:`\val^\ast` as arguments:
+
+  a. If it succeeds with :ref:`values <syntax-val>` :math:`{\val'}^\ast` as results, then let :math:`\X{result}` be :math:`{\val'}^\ast`.
+
+  b. Else it has trapped, hence let :math:`\X{result}` be :math:`\ERROR`.
+
+3. Return the new store paired with :math:`\X{result}`.
+
+.. math::
+   ~ \\
+   \begin{array}{lclll}
+   \F{invoke\_func}(S, a, v^\ast) &=& (S', {v'}^\ast) && (\iff \invoke(S, a, v^\ast) \stepto^\ast S'; F; {v'}^\ast) \\
+   \F{invoke\_func}(S, a, v^\ast) &=& (S', \ERROR) && (\iff \invoke(S, a, v^\ast) \stepto^\ast S'; F; \TRAP) \\
+   \end{array}
+
+.. note::
+   The store may be modified even in case of an error.
+
+
+.. index:: table, table address, store, table instance, table type, element, function address
+.. _embed-table:
+
+Tables
+~~~~~~
+
+.. _embed-alloc-table:
+
+:math:`\F{alloc\_table}(\store, \tabletype) : (\store, \tableaddr)`
+...................................................................
+
+1. Let :math:`\tableaddr` be the result of :ref:`allocating a table <alloc-table>` in :math:`\store` with :ref:`table type <syntax-tabletype>` :math:`\tabletype`.
+
+2. Return the new store paired with :math:`\tableaddr`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{alloc\_table}(S, \X{tt}) &=& (S', \X{a}) && (\iff \alloctable(S, \X{tt}) = S', \X{a}) \\
+   \end{array}
+
+
+.. _embed-type-table:
+
+:math:`\F{type\_table}(\store, \tableaddr) : \tabletype`
+........................................................
+
+1. Assert: :math:`\store.\STABLES[\tableaddr]` exists.
+
+2. Assert: the :ref:`external value <syntax-externval>` :math:`\EVTABLE~\tableaddr` is :ref:`valid <valid-externval>` with :ref:`external type <syntax-externtype>` :math:`\ETTABLE~\tabletype`.
+
+3. Return :math:`\tabletype`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{type\_table}(S, a) &=& \X{tt} && (\iff S \vdashexternval \EVTABLE~a : \ETTABLE~\X{tt}) \\
+   \end{array}
+
+
+.. _embed-read-table:
+
+:math:`\F{read\_table}(\store, \tableaddr, i) : \funcaddr ~|~ \error`
+.....................................................................
+
+1. Assert: :math:`\store.\STABLES[\tableaddr]` exists.
+
+2. Assert: :math:`i` is a non-negative integer.
+
+3. Let :math:`\X{ti}` be the :ref:`table instance <syntax-tableinst>` :math:`\store.\STABLES[\tableaddr]`.
+
+4. If :math:`i` is larger than or equal to the length if :math:`\X{ti}.\TIELEM`, then return :math:`\ERROR`.
+
+5. If :math:`\X{ti}.\TIELEM[i]` contains a :ref:`function address <syntax-funcaddr>` :math:`\X{fa}`, then return :math:`\X{fa}`.
+
+6. Else :math:`\X{ti}.\TIELEM[i]` is empty, hence return :math:`\ERROR`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{read\_table}(S, a, i) &=& \X{fa} && (\iff S.\STABLES[a].\TIELEM[i] = \X{fa}) \\
+   \F{read\_table}(S, a, i) &=& \ERROR && (\otherwise) \\
+   \end{array}
+
+
+.. _embed-write-table:
+
+:math:`\F{write\_table}(\store, \tableaddr, i, \funcaddr) : \store ~|~ \error`
+..............................................................................
+
+1. Assert: :math:`\store.\STABLES[\tableaddr]` exists.
+
+2. Assert: :math:`i` is a non-negative integer.
+
+3. Let :math:`\X{ti}` be the :ref:`table instance <syntax-tableinst>` :math:`\store.\STABLES[\tableaddr]`.
+
+4. If :math:`i` is larger than or equal to the length if :math:`\X{ti}.\TIELEM`, then return :math:`\ERROR`.
+
+5. Replace :math:`\X{ti}.\TIELEM[i]` with the :ref:`function address <syntax-funcaddr>` :math:`\X{fa}`.
+
+6. Return the updated store.
+
+.. math::
+   \begin{array}{lclll}
+   \F{write\_table}(S, a, i, \X{fa}) &=& S' && (\iff S' = S \with \STABLES[a].\TIELEM[i] = \X{fa}) \\
+   \F{write\_table}(S, a, i, \X{fa}) &=& \ERROR && (\otherwise) \\
+   \end{array}
+
+
+.. _embed-grow-table:
+
+:math:`\F{grow\_table}(\store, \tableaddr, n) : \store ~|~ \error`
+..................................................................
+
+1. Assert: :math:`\store.\STABLES[\tableaddr]` exists.
+
+2. Assert: :math:`n` is a non-negative integer.
+
+3. Try :ref:`growing <grow-table>` the :ref:`table instance <syntax-tableinst>` :math:`\store.\STABLES[\tableaddr]` by :math:`n` elements:
+
+   a. If it succeeds, return the updated store.
+
+   b. Else, return :math:`\ERROR`.
+
+.. math::
+   ~ \\
+   \begin{array}{lclll}
+   \F{grow\_table}(S, a, n) &=& S' &&
+     (\iff S' = S \with \STABLES[a] = \growtable(S.\STABLES[a], n)) \\
+   \F{grow\_table}(S, a, n) &=& \ERROR && (\otherwise) \\
+   \end{array}
+
+
+.. index:: memory, memory address, store, memory instance, memory type, byte
+.. _embed-mem:
+
+Memories
+~~~~~~~~
+
+.. _embed-alloc-mem:
+
+:math:`\F{alloc\_mem}(\store, \memtype) : (\store, \memaddr)`
+................................................................
+
+1. Let :math:`\memaddr` be the result of :ref:`allocating a memory <alloc-mem>` in :math:`\store` with :ref:`memory type <syntax-memtype>` :math:`\memtype`.
+
+2. Return the new store paired with :math:`\memaddr`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{alloc\_mem}(S, \X{mt}) &=& (S', \X{a}) && (\iff \allocmem(S, \X{mt}) = S', \X{a}) \\
+   \end{array}
+
+
+.. _embed-type-mem:
+
+:math:`\F{type\_mem}(\store, \memaddr) : \memtype`
+..................................................
+
+1. Assert: :math:`\store.\SMEMS[\memaddr]` exists.
+
+2. Assert: the :ref:`external value <syntax-externval>` :math:`\EVMEM~\memaddr` is :ref:`valid <valid-externval>` with :ref:`external type <syntax-externtype>` :math:`\ETMEM~\memtype`.
+
+3. Return :math:`\memtype`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{type\_mem}(S, a) &=& \X{mt} && (\iff S \vdashexternval \EVMEM~a : \ETMEM~\X{mt}) \\
+   \end{array}
+
+
+.. _embed-read-mem:
+
+:math:`\F{read\_mem}(\store, \memaddr, i) : \byte ~|~ \error`
+.............................................................
+
+1. Assert: :math:`\store.\SMEMS[\memaddr]` exists.
+
+2. Assert: :math:`i` is a non-negative integer.
+
+3. Let :math:`\X{mi}` be the :ref:`memory instance <syntax-meminst>` :math:`\store.\SMEMS[\memaddr]`.
+
+4. If :math:`i` is larger than or equal to the length if :math:`\X{mi}.\MIDATA`, then return :math:`\ERROR`.
+
+5. Else, return the  :ref:`byte <syntax-byte>` :math:`\X{mi}.\MIDATA[i]`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{read\_mem}(S, a, i) &=& b && (\iff S.\SMEMS[a].\MIDATA[i] = b) \\
+   \F{read\_mem}(S, a, i) &=& \ERROR && (\otherwise) \\
+   \end{array}
+
+
+.. _embed-write-mem:
+
+:math:`\F{write\_mem}(\store, \memaddr, i, \byte) : \store ~|~ \error`
+......................................................................
+
+1. Assert: :math:`\store.\SMEMS[\memaddr]` exists.
+
+2. Assert: :math:`i` is a non-negative integer.
+
+3. Let :math:`\X{mi}` be the :ref:`memory instance <syntax-meminst>` :math:`\store.\SMEMS[\memaddr]`.
+
+4. If :math:`i` is larger than or equal to the length if :math:`\X{mi}.\MIDATA`, then return :math:`\ERROR`.
+
+5. Replace :math:`\X{mi}.\MIDATA[i]` with :math:`\byte`.
+
+6. Return the updated store.
+
+.. math::
+   \begin{array}{lclll}
+   \F{write\_mem}(S, a, i, b) &=& S' && (\iff S' = S \with \SMEMS[a].\MIDATA[i] = b) \\
+   \F{write\_mem}(S, a, i, b) &=& \ERROR && (\otherwise) \\
+   \end{array}
+
+
+.. _embed-grow-mem:
+
+:math:`\F{grow\_mem}(\store, \memaddr, n) : \store ~|~ \error`
+..............................................................
+
+1. Assert: :math:`\store.\SMEMS[\memaddr]` exists.
+
+2. Assert: :math:`n` is a non-negative integer.
+
+3. Try :ref:`growing <grow-mem>` the :ref:`memory instance <syntax-meminst>` :math:`\store.\SMEMS[\memaddr]` by :math:`n` :ref:`pages <page-size>`:
+
+   a. If it succeeds, return the updated store.
+
+   b. Else, return :math:`\ERROR`.
+
+.. math::
+   ~ \\
+   \begin{array}{lclll}
+   \F{grow\_mem}(S, a, n) &=& S' &&
+     (\iff S' = S \with \SMEMS[a] = \growmem(S.\SMEMS[a], n)) \\
+   \F{grow\_mem}(S, a, n) &=& \ERROR && (\otherwise) \\
+   \end{array}
+
+
+
+.. index:: global, global address, store, global instance, global type, value
+.. _embed-global:
+
+Globals
+~~~~~~~
+
+.. _embed-alloc-global:
+
+:math:`\F{alloc\_global}(\store, \globaltype, \val) : (\store, \globaladdr)`
+............................................................................
+
+1. Let :math:`\globaladdr` be the result of :ref:`allocating a global <alloc-global>` in :math:`\store` with :ref:`global type <syntax-globaltype>` :math:`\globaltype` and initialization value :math:`\val`.
+
+2. Return the new store paired with :math:`\globaladdr`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{alloc\_global}(S, \X{gt}, v) &=& (S', \X{a}) && (\iff \allocglobal(S, \X{gt}, v) = S', \X{a}) \\
+   \end{array}
+
+
+.. _embed-type-global:
+
+:math:`\F{type\_global}(\store, \globaladdr) : \globaltype`
+...........................................................
+
+1. Assert: :math:`\store.\SGLOBALS[\globaladdr]` exists.
+
+2. Assert: the :ref:`external value <syntax-externval>` :math:`\EVGLOBAL~\globaladdr` is :ref:`valid <valid-externval>` with :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~\globaltype`.
+
+3. Return :math:`\globaltype`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{type\_global}(S, a) &=& \X{gt} && (\iff S \vdashexternval \EVGLOBAL~a : \ETGLOBAL~\X{gt}) \\
+   \end{array}
+
+
+.. _embed-read-global:
+
+:math:`\F{read\_global}(\store, \globaladdr) : \val`
+....................................................
+
+1. Assert: :math:`\store.\SGLOBALS[\globaladdr]` exists.
+
+2. Let :math:`\X{gi}` be the :ref:`global instance <syntax-globalinst>` :math:`\store.\SGLOBALS[\globaladdr]`.
+
+3. Return the :ref:`value <syntax-val>` :math:`\X{gi}.\GIVALUE`.
+
+.. math::
+   \begin{array}{lclll}
+   \F{read\_global}(S, a) &=& v && (\iff S.\SGLOBALS[a].\GIVALUE = v) \\
+   \end{array}
+
+
+.. _embed-write-global:
+
+:math:`\F{write\_global}(\store, \globaladdr, \val) : \store ~|~ \error`
+........................................................................
+
+1. Assert: :math:`\store.\SGLOBALS[a]` exists.
+
+2. Let :math:`\X{gi}` be the :ref:`global instance <syntax-globalinst>` :math:`\store.\SGLOBALS[\globaladdr]`.
+
+3. If :math:`\X{gi}.\GIMUT` is not :math:`\MVAR`, then return :math:`\ERROR`.
+
+4. Replace :math:`\X{gi}.\GIVALUE` with the :ref:`value <syntax-val>` :math:`\val`.
+
+5. Return the updated store.
+
+.. math::
+   ~ \\
+   \begin{array}{lclll}
+   \F{write\_global}(S, a, v) &=& S' && (\iff S.\SGLOBALS[a].\GIMUT = \MVAR \wedge S' = S \with \SGLOBALS[a].\GIVALUE = v) \\
+   \F{write\_global}(S, a, v) &=& \ERROR && (\otherwise) \\
+   \end{array}
diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
index a64729569..7ff47bdfc 100644
--- a/document/core/appendix/index-rules.rst
+++ b/document/core/appendix/index-rules.rst
@@ -28,11 +28,11 @@ Construct                                        Judgement
 :ref:`Element segment <valid-elem>`              :math:`C \vdashelem \elem \ok`
 :ref:`Data segment <valid-data>`                 :math:`C \vdashdata \data \ok`
 :ref:`Start function <valid-start>`              :math:`C \vdashstart \start \ok`
-:ref:`Export <valid-export>`                     :math:`C \vdashexport \export : \name`
-:ref:`Export description <valid-exportdesc>`     :math:`C \vdashexportdesc \exportdesc \ok`
+:ref:`Export <valid-export>`                     :math:`C \vdashexport \export : \externtype`
+:ref:`Export description <valid-exportdesc>`     :math:`C \vdashexportdesc \exportdesc : \externtype`
 :ref:`Import <valid-import>`                     :math:`C \vdashimport \import : \externtype`
 :ref:`Import description <valid-importdesc>`     :math:`C \vdashimportdesc \importdesc : \externtype`
-:ref:`Module <valid-module>`                     :math:`\vdashmodule \module : \externtype^\ast`
+:ref:`Module <valid-module>`                     :math:`\vdashmodule \module : \externtype^\ast \to \externtype^\ast`
 ===============================================  ===============================================================================
 
 
@@ -47,8 +47,7 @@ Construct                                        Judgement
 :ref:`Value <valid-val>`                         :math:`\vdashval \val : \valtype`
 :ref:`Result <valid-result>`                     :math:`\vdashresult \result : \resulttype`
 :ref:`External value <valid-externval>`          :math:`S \vdashexternval \externval : \externtype`
-:ref:`Module instruction <valid-moduleinstr>`    :math:`S \vdashmoduleinstr \moduleinstr \ok`
-:ref:`Function instance <valid-funcinst>`        :math:`S \vdashfuncinst \funcinst : \resulttype`
+:ref:`Function instance <valid-funcinst>`        :math:`S \vdashfuncinst \funcinst : \functype`
 :ref:`Table instance <valid-tableinst>`          :math:`S \vdashtableinst \tableinst : \tabletype`
 :ref:`Memory instance <valid-meminst>`           :math:`S \vdashmeminst \meminst : \memtype`
 :ref:`Global instance <valid-globalinst>`        :math:`S \vdashglobalinst \globalinst : \globaltype`
@@ -56,7 +55,7 @@ Construct                                        Judgement
 :ref:`Module instance <valid-moduleinst>`        :math:`S \vdashmoduleinst \moduleinst : C`
 :ref:`Store <valid-store>`                       :math:`\vdashstore \store \ok`
 :ref:`Configuration <valid-config>`              :math:`\vdashconfig \config \ok`
-:ref:`Thread <valid-thread>`                     :math:`S;\resulttype^? \vdashthread \thread : \resulttype^?`
+:ref:`Thread <valid-thread>`                     :math:`S;\resulttype^? \vdashthread \thread : \resulttype`
 :ref:`Frame <valid-frame>`                       :math:`S \vdashframe \frame : C`
 ===============================================  ===============================================================================
 
@@ -105,5 +104,4 @@ Construct                                        Judgement
 ===============================================  ===============================================================================
 :ref:`Instruction <exec-instr>`                  :math:`S;F;\instr \stepto S';F';{\instr'}^\ast`
 :ref:`Expression <exec-expr>`                    :math:`S;F;\expr \stepto^\ast S';F';\val^\ast`
-:ref:`Module instruction <exec-moduleinstr>`     :math:`S;\moduleinstr \stepto S';{\moduleinstr'}^\ast`
 ===============================================  ===============================================================================
diff --git a/document/core/appendix/index.rst b/document/core/appendix/index.rst
index 581efe834..4be621299 100644
--- a/document/core/appendix/index.rst
+++ b/document/core/appendix/index.rst
@@ -6,7 +6,8 @@ Appendix
 .. toctree::
    :maxdepth: 2
 
+   embedding
    implementation
+   algorithm
    custom
    properties
-   algorithm
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index afc4319d9..9bd4918e1 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -17,7 +17,7 @@ The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *t
 Soundness also is instrumental in ensuring additional properties, most notably, *encapsulation* of function and module scopes: no :ref:`locals <syntax-local>` can be accessed outside their own function and no :ref:`module <syntax-module>` components can be accessed outside their own module unless they are explicitly :ref:`exported <syntax-export>` or :ref:`imported <syntax-import>`.
 
 The typing rules defining WebAssembly :ref:`validation <valid>` only cover the *static* components of a WebAssembly program.
-In order to state and prove soundness precisely, the typing rules must be extended to the *dynamic* components of the abstract :ref:`runtime <syntax-runtime>`, that is, the :ref:`store <syntax-store>`, :ref:`configurations <syntax-config>`, and :ref:`administrative instructions <syntax-instr-admin>` as well as :ref:`module instructions <valid-moduleinstr>`. [#cite-pldi2017]_
+In order to state and prove soundness precisely, the typing rules must be extended to the *dynamic* components of the abstract :ref:`runtime <syntax-runtime>`, that is, the :ref:`store <syntax-store>`, :ref:`configurations <syntax-config>`, and :ref:`administrative instructions <syntax-instr-admin>`. [#cite-pldi2017]_
 
 
 .. index:: value, value type, result, result type, trap
@@ -98,7 +98,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * Each :ref:`memory instance <syntax-meminst>` :math:`\meminst_i` in :math:`S.\SMEMS` must be :ref:`valid <valid-meminst>` with some :ref:`memory type <syntax-memtype>` :math:`\memtype_i`.
 
-* Each :ref:`global instance <syntax-globalinst>` :math:`\globalinst_i` in :math:`S.\SGLOBALS` must be :ref:`valid <valid-globalinst>` with some optional  :ref:`global type <syntax-globaltype>` :math:`\globaltype_i^?`.
+* Each :ref:`global instance <syntax-globalinst>` :math:`\globalinst_i` in :math:`S.\SGLOBALS` must be :ref:`valid <valid-globalinst>` with some  :ref:`global type <syntax-globaltype>` :math:`\globaltype_i`.
 
 * Then the store is valid.
 
@@ -112,7 +112,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
      \\
      (S \vdashmeminst \meminst : \memtype)^\ast
      \qquad
-     (S \vdashglobalinst \globalinst : \globaltype^?)^\ast
+     (S \vdashglobalinst \globalinst : \globaltype)^\ast
      \\
      S = \{
        \SFUNCS~\funcinst^\ast,
@@ -354,13 +354,9 @@ Configuration Validity
 To relate the WebAssembly :ref:`type system <valid>` to its :ref:`execution semantics <exec>`, the :ref:`typing rules for instructions <valid-instr>` must be extended to :ref:`configurations <syntax-config>` :math:`S;T`,
 which relates the :ref:`store <syntax-store>` to execution :ref:`threads <syntax-thread>`.
 
-Threads may either be regular threads executing sequences of :ref:`instructions <syntax-instr>`, or module threads executing :ref:`module instructions <syntax-moduleinstr>` that represent an ongoing module instantiation.
-Regular threads are classified by their :ref:`result type <syntax-resulttype>`.
-Module threads on the other hand have no result, not even an empty one.
-Consequently, threads and configurations are cumutavily classified by an *optional* result type, where :math:`\epsilon` classifies the thread as a module computation.
-
+Configurations and threads are classified by their :ref:`result type <syntax-resulttype>`.
 In addition to the store :math:`S`, threads are typed under a *return type* :math:`\resulttype^?`, which controls whether and with which type a |return| instruction is allowed.
-This type is :math:`\epsilon`, except for instruction sequences inside an administrative |FRAME| instruction.
+This type is absent (:math:`\epsilon`) except for instruction sequences inside an administrative |FRAME| instruction.
 
 Finally, :ref:`frames <syntax-frame>` are classified with *frame contexts*, which extend the :ref:`module contexts <module-context>` of a frame's associated :ref:`module instance <syntax-moduleinst>` with the :ref:`locals <syntax-local>` that the frame contains.
 
@@ -373,17 +369,17 @@ Finally, :ref:`frames <syntax-frame>` are classified with *frame contexts*, whic
 * The :ref:`store <syntax-store>` :math:`S` must be :ref:`valid <valid-store>`.
 
 * Under no allowed return type,
-  the :ref:`thread <syntax-thread>` :math:`T` must be :ref:`valid <valid-thread>` with some optional :ref:`result type <syntax-resulttype>` :math:`[t^?]^?`.
+  the :ref:`thread <syntax-thread>` :math:`T` must be :ref:`valid <valid-thread>` with some :ref:`result type <syntax-resulttype>` :math:`[t^?]`.
 
-* Then the configuration is valid with the optional :ref:`result type <syntax-resulttype>` :math:`[t^?]^?`.
+* Then the configuration is valid with the :ref:`result type <syntax-resulttype>` :math:`[t^?]`.
 
 .. math::
    \frac{
      \vdashstore S \ok
      \qquad
-     S; \epsilon \vdashthread T : [t^?]^?
+     S; \epsilon \vdashthread T : [t^?]
    }{
-     \vdashconfig S; T : [t^?]^?
+     \vdashconfig S; T : [t^?]
    }
 
 
@@ -414,25 +410,6 @@ Finally, :ref:`frames <syntax-frame>` are classified with *frame contexts*, whic
    }
 
 
-.. index:: thread, module instruction
-
-:ref:`Threads <syntax-thread>` :math:`\moduleinstr^\ast`
-........................................................
-
-* The current allowed return type must be empty.
-
-* Each :ref:`module instruction <syntax-moduleinstr>` :math:`\moduleinstr_i` in :math:`\moduleinstr^\ast` must be :ref:`valid <valid-moduleinstr>`.
-
-* Then the thread is valid with no :ref:`result type <syntax-resulttype>`.
-
-.. math::
-   \frac{
-     (S \vdashmoduleinstr \moduleinstr \ok)^\ast
-   }{
-     S; \epsilon \vdashthread \moduleinstr^\ast : \epsilon
-   }
-
-
 .. index:: frame, local, module instance, value, value type, context
 .. _valid-frame:
 
@@ -467,7 +444,7 @@ Administrative Instructions
 
 Typing rules for :ref:`administrative instructions <syntax-instr-admin>` are specified as follows.
 In addition to the :ref:`context <context>` :math:`C`, typing of these instructions is defined under a given :ref:`store <syntax-store>` :math:`S`.
-To that end, all previous typing judgements :math:`C \vdash \X{prop}` are generalized to include the store, as in :math:`S; C \vdash \X{prop}`, by implicitly adding :math:`S` to all rules -- :math:`S` is never modified by the pre-existing rules, but it is accessed in the new rules for :ref:`administrative instructions <valid-instr-admin>` and  :ref:`module instructions <valid-moduleinstr>` given below.
+To that end, all previous typing judgements :math:`C \vdash \X{prop}` are generalized to include the store, as in :math:`S; C \vdash \X{prop}`, by implicitly adding :math:`S` to all rules -- :math:`S` is never modified by the pre-existing rules, but it is accessed in the extra rules for :ref:`administrative instructions <valid-instr-admin>` given below.
 
 
 .. index:: trap
@@ -501,79 +478,10 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
    }
 
 
-.. index:: label, instruction, result type
-
-:math:`\LABEL_n\{\instr_0^\ast\}~\instr^\ast~\END`
-..................................................
-
-* The instruction sequence :math:`\instr_0^\ast` must be :ref:`valid <valid-instr-seq>` with some type :math:`[t_1^n] \to [t_2^?]`.
-
-* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_1^n]` prepended to the |CLABELS| vector.
-
-* Under context :math:`C'`,
-  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \to [t_2^?]`.
-
-* Then the compound instruction is valid with type :math:`[] \to [t_2^?]`.
-
-.. math::
-   \frac{
-     S; C \vdashinstrseq \instr_0^\ast : [t_1^n] \to [t_2^?]
-     \qquad
-     S; C,\CLABELS\,[t_1^n] \vdashinstrseq \instr^\ast : [] \to [t_2^?]
-   }{
-     S; C \vdashadmininstr \LABEL_n\{\instr_0^\ast\}~\instr^\ast~\END : [] \to [t_2^?]
-   }
-
-
-.. index:: frame, instruction, result type
-
-:math:`\FRAME_n\{F\}~\instr^\ast~\END`
-...........................................
-
-* Under the return type :math:`[t^n]`,
-  the :ref:`thread <syntax-frame>` :math:`F; \instr^\ast` must be :ref:`valid <valid-frame>` with :ref:`result type <syntax-resulttype>` :math:`[t^n]`.
-
-* Then the compound instruction is valid with type :math:`[] \to [t^n]`.
-
-.. math::
-   \frac{
-     S; [t^n] \vdashinstrseq F; \instr^\ast : [t^n]
-   }{
-     S; C \vdashadmininstr \FRAME_n\{F\}~\instr^\ast~\END : [] \to [t^n]
-   }
-
-
-.. index:: module instruction, store
-.. _valid-moduleinstr:
-
-Module Instructions
-~~~~~~~~~~~~~~~~~~~
-
-Typing rules for :ref:`module instructions <valid-moduleinstr>` are specified as follows.
-Unlike regular instructions, module instructions do not use the operand stack, and consequently, are not classified by a type.
-
-
-.. index:: instantiation, external value, external type
-
-:math:`\INSTANTIATE~\module~\externval^\ast`
-............................................
-
-* Each :ref:`external value <syntax-externval>` :math:`\externval_i` in :math:`\externval^\ast` must be :ref:`valid <valid-externval>` with some :ref:`external type <syntax-externtype>` :math:`\externtype_i`.
-
-* Then the module instruction is valid.
-
-.. math::
-   \frac{
-     (S \vdashexternval \externval : \externtype)^\ast
-   }{
-     S \vdashmoduleinstr \INSTANTIATE~\module~\externval^\ast \ok
-   }
-
-
 .. index:: element, table, table address, module instance, function index
 
-:math:`\INITELEM~\tableaddr~o~\moduleinst~x^n`
-..............................................
+:math:`\INITELEM~\tableaddr~o~x^n`
+..................................
 
 * The :ref:`external table value <syntax-externval>` :math:`\EVTABLE~\tableaddr` must be :ref:`valid <valid-externval-table>` with some :ref:`external table type <syntax-externtype>` :math:`\ETTABLE~\limits~\ANYFUNC`.
 
@@ -583,21 +491,17 @@ Unlike regular instructions, module instructions do not use the operand stack, a
 
 * Each :ref:`function index <syntax-funcidx>` :math:`x_i` in :math:`x^n` must be defined in the context :math:`C`.
 
-* Then the module instruction is valid.
+* Then the instruction is valid.
 
 .. math::
    \frac{
-     \begin{array}{@{}rl@{}}
      S \vdashexternval \EVTABLE~\tableaddr : \ETTABLE~\limits~\ANYFUNC
-     \qquad&
+     \qquad
      o + n \leq \limits.\LMIN
-     \\
-     S \vdashmoduleinst \moduleinst : C
-     \qquad&
+     \qquad
      (C.\CFUNCS[x] = \functype)^n
-     \end{array}
    }{
-     S \vdashmoduleinstr \INITELEM~\tableaddr~o~\moduleinst~x^n \ok
+     S; C \vdashadmininstr \INITELEM~\tableaddr~o~x^n \ok
    }
 
 
@@ -610,7 +514,7 @@ Unlike regular instructions, module instructions do not use the operand stack, a
 
 * The index :math:`o + n` must be smaller than or equal to :math:`\limits.\LMIN` divided by the :ref:`page size <page-size>` :math:`64\,\F{Ki}`.
 
-* Then the module instruction is valid.
+* Then the instruction is valid.
 
 .. math::
    \frac{
@@ -618,28 +522,51 @@ Unlike regular instructions, module instructions do not use the operand stack, a
      \qquad
      o + n \leq \limits.\LMIN \cdot 64\,\F{Ki}
    }{
-     S \vdashmoduleinstr \INITDATA~\memaddr~o~b^n \ok
+     S; C \vdashadmininstr \INITDATA~\memaddr~o~b^n \ok
    }
 
 
-.. index:: instruction, context
+.. index:: label, instruction, result type
 
-:math:`\instr`
-..............
+:math:`\LABEL_n\{\instr_0^\ast\}~\instr^\ast~\END`
+..................................................
 
-* Under an empty :ref:`context <context>`,
-  the :ref:`instruction <syntax-instr>` :math:`\instr` must be valid with type :math:`[] \to []`.
+* The instruction sequence :math:`\instr_0^\ast` must be :ref:`valid <valid-instr-seq>` with some type :math:`[t_1^n] \to [t_2^?]`.
 
-* Then the instruction is valid as a module instruction.
+* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t_1^n]` prepended to the |CLABELS| vector.
+
+* Under context :math:`C'`,
+  the instruction sequence :math:`\instr^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \to [t_2^?]`.
+
+* Then the compound instruction is valid with type :math:`[] \to [t_2^?]`.
 
 .. math::
    \frac{
-     S; \{\} \vdashinstr \instr : [] \to []
+     S; C \vdashinstrseq \instr_0^\ast : [t_1^n] \to [t_2^?]
+     \qquad
+     S; C,\CLABELS\,[t_1^n] \vdashinstrseq \instr^\ast : [] \to [t_2^?]
    }{
-     S \vdashmoduleinstr \instr \ok
+     S; C \vdashadmininstr \LABEL_n\{\instr_0^\ast\}~\instr^\ast~\END : [] \to [t_2^?]
    }
 
 
+.. index:: frame, instruction, result type
+
+:math:`\FRAME_n\{F\}~\instr^\ast~\END`
+...........................................
+
+* Under the return type :math:`[t^n]`,
+  the :ref:`thread <syntax-frame>` :math:`F; \instr^\ast` must be :ref:`valid <valid-frame>` with :ref:`result type <syntax-resulttype>` :math:`[t^n]`.
+
+* Then the compound instruction is valid with type :math:`[] \to [t^n]`.
+
+.. math::
+   \frac{
+     S; [t^n] \vdashinstrseq F; \instr^\ast : [t^n]
+   }{
+     S; C \vdashadmininstr \FRAME_n\{F\}~\instr^\ast~\END : [] \to [t^n]
+   }
+
 
 .. index:: ! store extension, store
 .. _extend:
@@ -785,16 +712,16 @@ Given the definition of :ref:`valid configurations <valid-config>`,
 the standard soundness theorems hold.
 
 **Theorem (Preservation).**
-If the :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` with optional :ref:`result type <syntax-resulttype>` :math:`[t^\ast]^?` (i.e., :math:`\vdashconfig S;T : [t^\ast]^?`),
+If the :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]` (i.e., :math:`\vdashconfig S;T : [t^\ast]`),
 and steps to :math:`S';T'` (i.e., :math:`S;T \stepto S';T'`),
-then :math:`S';T'` is a valid configuration with the same optional resulttype (i.e., :math:`\vdashconfig S';T' : [t^\ast]^?`).
+then :math:`S';T'` is a valid configuration with the same resulttype (i.e., :math:`\vdashconfig S';T' : [t^\ast]`).
 Furthermore, :math:`S'` is an :ref:`extension <extend-store>` of :math:`S` (i.e., :math:`\vdashstoreextends S \extendsto S'`).
 
-A *terminal* :ref:`thread <syntax-thread>` is either an empty sequence of :ref:`module instructions <syntax-moduleinstr>`, a |TRAP| instruction, or a sequence :math:`\val^\ast` of :ref:`values <syntax-val>` (paired with a :ref:`frame <syntax-frame>`).
+A *terminal* :ref:`thread <syntax-thread>` is one whose sequence of :ref:`instructions <syntax-instr>` is a :ref:`result <syntax-result>`.
 A terminal configuration is a configuration whose thread is terminal.
 
 **Theorem (Progress).**
-If the :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` (i.e., :math:`\vdashconfig S;T : [t^\ast]^?` with some optional :ref:`result type <syntax-resulttype>` :math:`[t^\ast]^?`),
+If the :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` (i.e., :math:`\vdashconfig S;T : [t^\ast]` with some :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`),
 then either it is terminal,
 or it can step to some configuration :math:`S';T'` (i.e., :math:`S;T \stepto S';T'`).
 
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index d2ee6ae0d..6ddccce31 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -432,7 +432,7 @@ Memory Instructions
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
      \wedge & \X{ea} + |t|/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
      \wedge & \bytes_t(c) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice |t|/8])
      \end{array}
@@ -443,7 +443,7 @@ Memory Instructions
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
      \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
      \wedge & \bytes_{\iN}(n) = S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8])
      \end{array}
@@ -510,7 +510,7 @@ Memory Instructions
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
      \wedge & \X{ea} + |t|/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
      \wedge & S' = S \with \SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice |t|/8] = \bytes_t(c)
      \end{array}
@@ -520,7 +520,7 @@ Memory Instructions
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & \X{ea} = i + \memarg.\OFFSET \\
+     (\iff & \X{ea} = i + \memarg.\OFFSET \\
      \wedge & \X{ea} + N/8 \leq |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| \\
      \wedge & S' = S \with \SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA[\X{ea} \slice N/8] = \bytes_{\iN}(\wrap_{|t|,N}(c))
      \end{array}
@@ -583,21 +583,13 @@ Memory Instructions
 
 8. Pop the value :math:`\I32.\CONST~n` from the stack.
 
-9. If :math:`\X{mem}.\MIMAX` is not empty and :math:`\X{sz} + n` is larger than :math:`\X{mem}.\MIMAX`, then:
+9. Either, try :ref:`growing <grow-mem>` :math:`\X{mem}` by :math:`n` :ref:`pages <page-size>`:
 
-  a. Push the value :math:`\I32.\CONST~(-1)` to the stack.
+   a. If it succeeds, push the value :math:`\I32.\CONST~\X{sz}` to the stack.
 
-10. Else, either:
+   b. Else, push the value :math:`\I32.\CONST~(-1)` to the stack.
 
-    a. Let :math:`\X{len}` be :math:`n` multiplied with the :ref:`page size <page-size>`.
-
-    b. Append :math:`\X{len}` bytes with value :math:`\hex{00}` to :math:`S.\SMEMS[a]`.
-
-    c. Push the value :math:`\I32.\CONST~\X{sz}` to the stack.
-
-11. Or:
-
-    a. Push the value :math:`\I32.\CONST~(-1)` to the stack.
+10. Or, push the value :math:`\I32.\CONST~(-1)` to the stack.
 
 .. math::
    ~\\[-1ex]
@@ -607,10 +599,8 @@ Memory Instructions
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & F.\AMODULE.\MIMEMS[0] = a \\
-     \wedge & |S.\SMEMS[a].\MIDATA| = \X{sz}\cdot64\,\F{Ki} \\
-     \wedge & (\X{sz} + n \leq S.\SMEMS[a].\MIMAX \vee S.\SMEMS[a].\MIMAX = \epsilon) \\
-     \wedge & S' = S \with \SMEMS[a].\MIDATA = S.\SMEMS[a].\MIDATA~(\hex{00})^{n\cdot64\,\F{Ki}}) \\
+     (\iff & F.\AMODULE.\MIMEMS[0] = a \\
+     \wedge & S' = S \with \SMEMS[a] = \growmem(S.\SMEMS[a], n)) \\
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
@@ -624,7 +614,7 @@ Memory Instructions
    or fail, returning :math:`{-1}`.
    Failure *must* occur if the referenced memory instance has a maximum size defined that would be exceeded.
    However, failure *can* occur in other cases as well.
-   In practice, the choice depends on the resources available to the :ref:`embedder <embedder>`.
+   In practice, the choice depends on the :ref:`resources <impl-exec>` available to the :ref:`embedder <embedder>`.
 
 
 .. index:: control instructions, structured control, label, block, branch, result type, label index, function index, type index, vector, address, table address, table instance, store, frame
@@ -930,7 +920,7 @@ Control Instructions
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & S.\STABLES[F.\AMODULE.\MITABLES[0]].\TIELEM[i] = a \\
+     (\iff & S.\STABLES[F.\AMODULE.\MITABLES[0]].\TIELEM[i] = a \\
      \wedge & S.\SFUNCS[a] = f \\
      \wedge & F.\AMODULE.\MITYPES[x] = f.\FITYPE)
      \end{array}
@@ -1044,7 +1034,7 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & S.\SFUNCS[a] = f \\
+     (\iff & S.\SFUNCS[a] = f \\
      \wedge & f.\FITYPE = [t_1^n] \to [t_2^m] \\
      \wedge & f.\FICODE = \{ \FTYPE~x, \FLOCALS~t^k, \FBODY~\instr^\ast~\END \} \\
      \wedge & F = \{ \AMODULE~f.\FIMODULE, ~\ALOCALS~\val^n~(t.\CONST~0)^k \})
@@ -1105,7 +1095,7 @@ Furthermore, the resulting store must be :ref:`valid <valid-store>`, i.e., all d
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
-     (\mbox{if} & S.\SFUNCS[a] = \{ \FITYPE~[t_1^n] \to [t_2^m], \FIHOSTCODE~\X{hf} \} \\
+     (\iff & S.\SFUNCS[a] = \{ \FITYPE~[t_1^n] \to [t_2^m], \FIHOSTCODE~\X{hf} \} \\
      \wedge & \X{hf}(S; \val^n) = S'; \result) \\
      \end{array} \\
    \end{array}
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 6a3dc2b46..bf0d8b2be 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -371,6 +371,46 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
    \end{array}
 
 
+.. index:: table, table instance, table address, grow, limits
+.. _grow-table:
+
+Growing :ref:`tables <syntax-tableinst>`
+........................................
+
+1. Let :math:`\tableinst` be the :ref:`table instance <syntax-tableinst>` to grow and :math:`n` the number of elements by which to grow it.
+
+2. If :math:`\tableinst.\TIMAX` is not empty and smaller than :math:`n` added to the length of :math:`\tableinst.\TIELEM`, then fail.
+
+3. Append :math:`n` empty elements to :math:`\tableinst.\TIELEM`.
+
+.. math::
+   \begin{array}{rllll}
+   \growtable(\tableinst, n) &=& \tableinst \with \TIELEM = \tableinst.\TIELEM~(\epsilon)^n \\
+     && (\iff \tableinst.\TIMAX = \epsilon \vee |\tableinst.\TIELEM| + n \leq \tableinst.\TIMAX) \\
+   \end{array}
+
+
+.. index:: memory, memory instance, memory address, grow, limits
+.. _grow-mem:
+
+Growing :ref:`memories <syntax-meminst>`
+........................................
+
+1. Let :math:`\meminst` be the :ref:`memory instance <syntax-meminst>` to grow and :math:`n` the number of :ref:`pages <page-size>` by which to grow it.
+
+2. Let :math:`\X{len}` be :math:`n` multiplied by the :ref:`page size <page-size>` :math:`64\,\F{Ki}`.
+
+3. If :math:`\meminst.\MIMAX` is not empty and its value multiplied by the :ref:`page size <page-size>` :math:`64\,\F{Ki}` is smaller than :math:`\X{len}` added to the length of :math:`\meminst.\MIDATA`, then fail.
+
+4. Append :math:`\X{len}` :ref:`bytes <syntax-byte>` with value :math:`\hex{00}` to :math:`\meminst.\MIDATA`.
+
+.. math::
+   \begin{array}{rllll}
+   \growmem(\meminst, n) &=& \meminst \with \MIDATA = \meminst.\MIDATA~(\hex{00})^{n \cdot 64\,\F{Ki}} \\
+     && (\iff \meminst.\MIMAX = \epsilon \vee |\meminst.\MIDATA| + n \cdot 64\,\F{Ki} \leq \meminst.\MIMAX \cdot 64\,\F{Ki}) \\
+   \end{array}
+
+
 .. index:: module, module instance, function instance, table instance, memory instance, global instance, export instance, function address, table address, memory address, global address, function index, table index, memory index, global index, type, function, table, memory, global, import, export, external value, external type, matching
 .. _alloc-module:
 
@@ -499,7 +539,6 @@ Moreover, if the dots :math:`\dots` are a sequence :math:`A^n` (as for globals),
 
 .. index:: ! instantiation, module, instance, store, trap
 .. _exec-module:
-.. _exec-moduleinstr:
 .. _exec-instantiation:
 
 Instantiation
@@ -507,7 +546,8 @@ Instantiation
 
 Given a :ref:`store <syntax-store>` :math:`S`, a :ref:`module <syntax-module>` :math:`\module` is instantiated with a list of :ref:`external values <syntax-externval>` :math:`\externval^n` supplying the required imports as follows.
 
-Instantiation may *fail* with an error if the module is not :ref:`valid <valid>` or the imports do not :ref:`match <match-externtype>`.
+Instantiation assumes that the module is :ref:`valid <valid>` and the provided imports :ref:`match <match-externtype>` the declared types,
+and may *fail* with an error otherwise.
 Instantiation can also result in a :ref:`trap <trap>` from executing the start function.
 It is up to the :ref:`embedder <embedder>` to define how such conditions are reported.
 
@@ -629,14 +669,14 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 .. math::
    ~\\
    \begin{array}{@{}rcll}
-   S; \INSTANTIATE~\module~\externval^n &\stepto& S';
+   \instantiate(S, \module, \externval^n) &=& S'; F;
      \begin{array}[t]{@{}l@{}}
-     (\INITELEM~\tableaddr~\X{eo}~\moduleinst~\elem.\EINIT)^\ast \\
+     (\INITELEM~\tableaddr~\X{eo}~\elem.\EINIT)^\ast \\
      (\INITDATA~\memaddr~\X{do}~\data.\DINIT)^\ast \\
      (\INVOKE~\funcaddr)^? \\
      \end{array} \\
    &(\iff
-     & \vdashmodule \module : \externtype^n \\
+     & \vdashmodule \module : \externtype^n \to {\externtype'}^\ast \\
      &\wedge& (\vdashexternval \externval : \externtype')^n \\
      &\wedge& (\vdashexterntypematch \externtype' \matches \externtype)^n \\[1ex]
      &\wedge& \module.\MGLOBALS = \global^k \\
@@ -655,21 +695,21 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
      &\wedge& \globaladdr^\ast = \moduleinst.\MIGLOBALS[|\moduleinst.\MIGLOBALS|-k \slice k] \\
      &\wedge& (\tableaddr = \moduleinst.\MITABLES[\elem.\ETABLE])^\ast \\
      &\wedge& (\memaddr = \moduleinst.\MIMEMS[\data.\DMEM])^\ast \\
-     &\wedge& (\funcaddr = \moduleinst.\MIFUNCS[\start.\SFUNC])^?
+     &\wedge& (\funcaddr = \moduleinst.\MIFUNCS[\start.\SFUNC])^?)
    \\[1ex]
-   S; \INSTANTIATE~\module~\externval^n &\stepto&
-     S'; \TRAP  \qquad (\otherwise)
+   \instantiate(S, \module, \externval^n) &=& S; \{\AMODULE~\{\}, \ALOCALS~\epsilon\}; \TRAP
+     \qquad (\otherwise)
    \\[2ex]
-   S; \INITELEM~a~i~m~\epsilon &\stepto&
-     S; \epsilon \\
-   S; \INITELEM~a~i~m~(x_0~x^\ast) &\stepto&
-     S'; \INITELEM~a~(i+1)~m~x^\ast \\ &&
-     (\iff S' = S \with \STABLES[a].\TIELEM[i] = m.\MIFUNCS[x_0])
+   S; F; \INITELEM~a~i~\epsilon &\stepto&
+     S; F; \epsilon \\
+   S; F; \INITELEM~a~i~(x_0~x^\ast) &\stepto&
+     S'; F; \INITELEM~a~(i+1)~x^\ast \\ &&
+     (\iff S' = S \with \STABLES[a].\TIELEM[i] = F.\AMODULE.\MIFUNCS[x_0])
    \\[1ex]
-   S; \INITDATA~a~i~\epsilon &\stepto&
-     S; \epsilon \\
-   S; \INITDATA~a~i~(b_0~b^\ast) &\stepto&
-     S'; \INITDATA~a~(i+1)~b^\ast \\ &&
+   S; F; \INITDATA~a~i~\epsilon &\stepto&
+     S; F; \epsilon \\
+   S; F; \INITDATA~a~i~(b_0~b^\ast) &\stepto&
+     S'; F; \INITDATA~a~(i+1)~b^\ast \\ &&
      (\iff S' = S \with \SMEMS[a].\MIDATA[i] = b_0)
    \end{array}
 
@@ -729,8 +769,7 @@ The values :math:`\val_{\F{res}}^m` are returned as the results of the invocatio
 .. math::
    ~\\[-1ex]
    \begin{array}{@{}lcl}
-   \invoke(S, \funcaddr, \val^n) &=& \result \\
+   \invoke(S, \funcaddr, \val^n) &=& S; \val^n~(\INVOKE~\funcaddr) \\
      &(\iff & S.\SFUNCS[\funcaddr].\FITYPE = [t_1^n] \to [t_2^m] \\
-     &\wedge& \val^n = (t_1.\CONST~c)^n \\
-     &\wedge& S; \val^n~(\INVOKE~\funcaddr) \stepto^\ast S'; \result) \\
+     &\wedge& \val^n = (t_1.\CONST~c)^n) \\
    \end{array}
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index 03a1de0be..cf20bc33d 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -422,10 +422,12 @@ Conventions
    This may be generalized in future versions.
 
 
-.. index:: ! administrative instructions, function, function instance, function address, label, frame, instruction, trap, call
+.. index:: ! administrative instructions, function, function instance, function address, label, frame, instruction, trap, call, memory, memory instance, table, table instance, element, data, segment
    pair:: abstract syntax; administrative instruction
 .. _syntax-trap:
 .. _syntax-invoke:
+.. _syntax-init_elem:
+.. _syntax-init_data:
 .. _syntax-instr-admin:
 
 Administrative Instructions
@@ -442,6 +444,8 @@ In order to express the reduction of :ref:`traps <trap>`, :ref:`calls <syntax-ca
      \dots \\ &&|&
      \TRAP \\ &&|&
      \INVOKE~\funcaddr \\ &&|&
+     \INITELEM~\tableaddr~\u32~\funcidx^\ast \\ &&|&
+     \INITDATA~\memaddr~\u32~\byte^\ast \\ &&|&
      \LABEL_n\{\instr^\ast\}~\instr^\ast~\END \\ &&|&
      \FRAME_n\{\frame\}~\instr^\ast~\END \\
    \end{array}
@@ -452,6 +456,11 @@ Traps are bubbled up through nested instruction sequences, ultimately reducing t
 The |INVOKE| instruction represents the imminent invocation of a :ref:`function instance <syntax-funcinst>`, identified by its :ref:`address <syntax-funcaddr>`.
 It unifies the handling of different forms of calls.
 
+The |INITELEM| and |INITDATA| instructions perform initialization of :ref:`element <syntax-elem>` and :ref:`data <syntax-data>` segments during module :ref:`instantiation <exec-instantiation>`.
+
+.. note::
+   The reason for splitting instantiation into individual reduction steps is to provide a semantics that is compatible with future extensions like threads.
+
 The |LABEL| and |FRAME| instructions model :ref:`labels <syntax-label>` and :ref:`frames <syntax-frame>` :ref:`"on the stack" <exec-notation>`.
 Moreover, the administrative syntax maintains the nesting structure of the original :ref:`structured control instruction <syntax-instr-control>` or :ref:`function body <syntax-func>` and their :ref:`instruction sequences <syntax-instr-seq>` with an |END| marker.
 That way, the end of the inner instruction sequence is known when part of an outer sequence.
@@ -515,43 +524,6 @@ This definition allows to index active labels surrounding a :ref:`branch <syntax
    The selected label is identified through the :ref:`label index <syntax-labelidx>` :math:`l`, which corresponds to the number of surrounding |LABEL| instructions that must be hopped over -- which is exactly the count encoded in the index of a block context.
 
 
-.. index:: ! module instructions, function, function instance, function address, label, frame, instruction, trap, global, global instance, memory, memory instance, table, table instance, invocation, start function
-   pair:: abstract syntax; meta instruction
-.. _syntax-instantiate:
-.. _syntax-init_elem:
-.. _syntax-init_data:
-.. _syntax-moduleinstr:
-
-Module Instructions
-...................
-
-Module :ref:`instantiation <exec-instantiation>` is a complex operation.
-It is hence expressed in terms of reduction into smaller steps expressed by a sequence of administrative *module instructions* that are a superset of ordinary instructions and defined as follow.
-
-.. math::
-   \begin{array}{llcl}
-   \production{(module instruction)} & \moduleinstr &::=&
-     \INSTANTIATE~\module~\externval^\ast \\ &&|&
-     \INITELEM~\tableaddr~\u32~\moduleinst~\funcidx^\ast \\ &&|&
-     \INITDATA~\memaddr~\u32~\byte^\ast \\ &&|&
-     \instr \\
-   \end{array}
-
-The |INSTANTIATE| instruction expresses instantiation of a :ref:`module <syntax-module>` itself, requiring a sequence of :ref:`external values <syntax-externval>` for the expected imports.
-It reduces into a sequence of initialization instructions for :ref:`element <syntax-elem>` and :ref:`data <syntax-data>` segments,
-and a possible :ref:`invocation <syntax-invoke>` of the :ref:`start function <syntax-start>` that reduces further to a sequence of regular instructions.
-
-.. comment out
-   The final instruction returns the newly created and initialized :ref:`module instance <syntax-moduleinst>`.
-
-.. note::
-   The reason for splitting instantiation into individual reduction steps is to provide a semantics that is compatible with future extensions like threads.
-
-   Unlike the administrative instructions above,
-   module instructions *embed* ordinary instructions |instr| instead of extending them.
-   Consequently, they can only occur at the top-level.
-
-
 .. index:: ! configuration, ! thread, store, frame, instruction, module instruction
 .. _syntax-thread:
 .. _syntax-config:
@@ -561,17 +533,15 @@ Configurations
 
 A *configuration* consists of the current :ref:`store <syntax-store>` and an executing *thread*.
 
-A thread can either be a regular computation over :ref:`instructions <syntax-instr>`, or a module instantiation, represented as a computation over :ref:`module instructions <syntax-moduleinstr>`.
-Regular computation operates relative to a current :ref:`frame <syntax-frame>` referring to their home :ref:`module instance <syntax-moduleinst>`,
-whereas module computations are not local to a module, and consequently require no frame.
+A thread is a computation over :ref:`instructions <syntax-instr>`
+that operates relative to a current :ref:`frame <syntax-frame>` referring to the home :ref:`module instance <syntax-moduleinst>` that the computation runs in.
 
 .. math::
    \begin{array}{llcl}
    \production{(configuration)} & \config &::=&
      \store; \thread \\
    \production{(thread)} & \thread &::=&
-     \frame; \instr^\ast ~|~
-     \moduleinstr^\ast \\
+     \frame; \instr^\ast \\
    \end{array}
 
 .. note::
@@ -594,8 +564,6 @@ Finally, the following definition of *evaluation context* and associated structu
      \val^\ast~E~\instr^\ast ~|~
      \LABEL_n\{\instr^\ast\}~E~\END ~|~
      \FRAME_n\{\frame\}~E~\END \\
-   \production{(module evaluation contexts)} & M &::=&
-     [\_]~~\moduleinstr^\ast \\
    \end{array}
 
 .. math::
@@ -604,17 +572,10 @@ Finally, the following definition of *evaluation context* and associated structu
      & (\iff S; F; \instr^\ast \stepto S'; F'; {\instr'}^\ast) \\
    S; F; E[\TRAP] &\stepto& S; F; \TRAP
      & (\iff E \neq [\_]) \\
-   S; M[E[\instr]] &\stepto& S'; M[E[{\instr'}^\ast]]
-     & (\iff S; F_0; \instr \stepto S'; F_0; {\instr'}^\ast) \\
-   S; M[\TRAP] &\stepto& S; \TRAP
-     & (\iff M \neq [\_]) \\
    \end{array}
 
-where :math:`F_0 = \{\ALOCALS~\epsilon, \AMODULE~\{\}\}` is an empty dummy frame.
-
-Reduction terminates for a regular thread when its instruction sequence has been reduced to a sequence of :ref:`values <syntax-val>` or to a |TRAP|.
-Reduction terminates for a module thread when its module instruction sequence has been reduced to an empty sequence or to a |TRAP|.
-
+Reduction terminates when a thread's instruction sequence has been reduced to a :ref:`result <syntax-result>`,
+that is, either a sequence of :ref:`values <syntax-val>` or to a |TRAP|.
 
 .. note::
    For example, the following instruction sequence,
diff --git a/document/core/text/lexical.rst b/document/core/text/lexical.rst
index 3fdb81c76..02b8db6ad 100644
--- a/document/core/text/lexical.rst
+++ b/document/core/text/lexical.rst
@@ -8,6 +8,7 @@ Lexical Format
 .. index:: ! character, Unicode, ASCII, code point, ! source text
    pair: text format; character
 .. _source:
+.. _text-source:
 .. _text-char:
 
 Characters
@@ -18,6 +19,8 @@ Characters are assumed to be represented as valid |Unicode|_ (Section 2.4) *code
 
 .. math::
    \begin{array}{llll}
+   \production{source} & \Tsource &::=&
+     \Tchar^\ast \\
    \production{character} & \Tchar &::=&
      \unicode{00} ~|~ \dots ~|~ \unicode{D7FF} ~|~ \unicode{E000} ~|~ \dots ~|~ \unicode{10FFFF} \\
    \end{array}
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 1b23f8bfa..800dc41f0 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -531,6 +531,7 @@
 
 .. Lexical grammar, non-terminals
 
+.. |Tsource| mathdef:: \xref{text/lexical}{text-source}{\T{source}}
 .. |Tchar| mathdef:: \xref{text/lexical}{text-char}{\T{char}}
 .. |Tspace| mathdef:: \xref{text/lexical}{text-space}{\T{space}}
 .. |Tformat| mathdef:: \xref{text/lexical}{text-format}{\T{format}}
@@ -759,6 +760,9 @@
 .. |allocglobal| mathdef:: \xref{exec/modules}{alloc-global}{\F{allocglobal}}
 .. |allocmodule| mathdef:: \xref{exec/modules}{alloc-module}{\F{allocmodule}}
 
+.. |growtable| mathdef:: \xref{exec/modules}{grow-table}{\F{growtable}}
+.. |growmem| mathdef:: \xref{exec/modules}{grow-mem}{\F{growmem}}
+
 
 .. Addresses, non-terminals
 
@@ -856,10 +860,8 @@
 
 .. |TRAP| mathdef:: \xref{exec/runtime}{syntax-trap}{\K{trap}}
 .. |INVOKE| mathdef:: \xref{exec/runtime}{syntax-invoke}{\K{invoke}}
-.. |INSTANTIATE| mathdef:: \xref{exec/runtime}{syntax-instantiate}{\K{instantiate}}
 .. |INITELEM| mathdef:: \xref{exec/runtime}{syntax-init_elem}{\K{init\_elem}}
 .. |INITDATA| mathdef:: \xref{exec/runtime}{syntax-init_data}{\K{init\_data}}
-.. |DO| mathdef:: \xref{exec/runtime}{syntax-do}{\K{do}}
 
 
 .. Values & Results, non-terminals
@@ -870,8 +872,6 @@
 
 .. Administrative Instructions, non-terminals
 
-.. |moduleinstr| mathdef:: \xref{exec/runtime}{syntax-moduleinstr}{\X{moduleinstr}}
-
 .. |XB| mathdef:: \xref{exec/runtime}{syntax-ctxt-block}{B}
 
 
@@ -966,6 +966,7 @@
 
 .. Other meta functions
 
+.. |instantiate| mathdef:: \xref{exec/modules}{exec-instantiation}{\F{instantiate}}
 .. |invoke| mathdef:: \xref{exec/modules}{exec-invocation}{\F{invoke}}
 
 
@@ -983,7 +984,6 @@
 .. Judgements
 
 .. |vdashadmininstr| mathdef:: \xref{appendix/properties}{valid-instr-admin}{\vdash}
-.. |vdashmoduleinstr| mathdef:: \xref{appendix/properties}{valid-moduleinstr}{\vdash}
 
 .. |vdashval| mathdef:: \xref{appendix/properties}{valid-val}{\vdash}
 .. |vdashresult| mathdef:: \xref{appendix/properties}{valid-result}{\vdash}
@@ -1024,3 +1024,10 @@
 .. |Bmodulenamesubsec| mathdef:: \xref{appendix/custom}{binary-modulenamesec}{\B{modulenamesubsec}}
 .. |Bfuncnamesubsec| mathdef:: \xref{appendix/custom}{binary-funcnamesec}{\B{funcnamesubsec}}
 .. |Blocalnamesubsec| mathdef:: \xref{appendix/custom}{binary-localnamesec}{\B{localnamesubsec}}
+
+
+.. Embedding
+.. ---------
+
+.. |error| mathdef:: \xref{appendix/embedding}{embed-error}{\X{error}}
+.. |ERROR| mathdef:: \xref{appendix/embedding}{embed-error}{\K{error}}
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 3af4f2f5b..e82ee2e57 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -253,22 +253,21 @@ Start function declarations :math:`\start` are not classified by any type.
 Exports
 ~~~~~~~
 
-Exports :math:`\export` are classified by their export :ref:`name <syntax-name>`.
-Export descriptions :math:`\exportdesc` are not classified by any type.
+Exports :math:`\export` and export descriptions :math:`\exportdesc` are classified by their their :ref:`external type <syntax-externtype>`.
 
 
 :math:`\{ \ENAME~\name, \EDESC~\exportdesc \}`
 ..............................................
 
-* The export description :math:`\exportdesc` must be valid with type :math:`\externtype`.
+* The export description :math:`\exportdesc` must be valid with :ref:`external type <syntax-externtype>` :math:`\externtype`.
 
-* Then the export is valid with name :math:`\name`.
+* Then the export is valid with :ref:`external type <syntax-externtype>` :math:`\externtype`.
 
 .. math::
    \frac{
-     C \vdashexportdesc \exportdesc \ok
+     C \vdashexportdesc \exportdesc : \externtype
    }{
-     C \vdashexport \{ \ENAME~\name, \EDESC~\exportdesc \} : \name
+     C \vdashexport \{ \ENAME~\name, \EDESC~\exportdesc \} : \externtype
    }
 
 
@@ -277,13 +276,13 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
 
 * The function :math:`C.\CFUNCS[x]` must be defined in the context.
 
-* Then the export description is valid.
+* Then the export description is valid with :ref:`external type <syntax-externtype>` :math:`\ETFUNC~C.\CFUNCS[x]`.
 
 .. math::
    \frac{
      C.\CFUNCS[x] = \functype
    }{
-     C \vdashexportdesc \EDFUNC~x \ok
+     C \vdashexportdesc \EDFUNC~x : \ETFUNC~\functype
    }
 
 
@@ -292,13 +291,13 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
 
 * The table :math:`C.\CTABLES[x]` must be defined in the context.
 
-* Then the export description is valid.
+* Then the export description is valid with :ref:`external type <syntax-externtype>` :math:`\ETTABLE~C.\CTABLES[x]`.
 
 .. math::
    \frac{
      C.\CTABLES[x] = \tabletype
    }{
-     C \vdashexportdesc \EDTABLE~x \ok
+     C \vdashexportdesc \EDTABLE~x : \ETTABLE~\tabletype
    }
 
 
@@ -307,13 +306,13 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
 
 * The memory :math:`C.\CMEMS[x]` must be defined in the context.
 
-* Then the export description is valid.
+* Then the export description is valid with :ref:`external type <syntax-externtype>` :math:`\ETMEM~C.\CMEMS[x]`.
 
 .. math::
    \frac{
      C.\CMEMS[x] = \memtype
    }{
-     C \vdashexportdesc \EDMEM~x \ok
+     C \vdashexportdesc \EDMEM~x : \ETMEM~\memtype
    }
 
 
@@ -326,13 +325,13 @@ Export descriptions :math:`\exportdesc` are not classified by any type.
 
 * The mutability :math:`\mut` must be |MCONST|.
 
-* Then the export description is valid.
+* Then the export description is valid with :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~C.\CGLOBALS[x]`.
 
 .. math::
    \frac{
      C.\CGLOBALS[x] = \MCONST~t
    }{
-     C \vdashexportdesc \EDGLOBAL~x \ok
+     C \vdashexportdesc \EDGLOBAL~x : \ETGLOBAL~(\MCONST~t)
    }
 
 
@@ -435,6 +434,8 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 Modules
 ~~~~~~~
 
+Modules are classified by their mapping from the :ref:`external types <syntax-externtype>` of their :ref:`imports <syntax-import>` to those of their :ref:`exports <syntax-export>`.
+
 A module is entirely *closed*,
 that is, its components can only refer to definitions that appear in the module itself.
 Consequently, no initial :ref:`context <context>` is required.
@@ -498,17 +499,19 @@ Instead, the context :math:`C` for validation of the module's content is constru
     the segment :math:`\import_i` must be :ref:`valid <valid-import>` with an :ref:`external type <syntax-externtype>` :math:`\externtype_i`.
 
   * For each :math:`\export_i` in :math:`\module.\MEXPORTS`,
-    the segment :math:`\import_i` must be :ref:`valid <valid-export>` with a :ref:`name <syntax-name>` :math:`\name_i`.
+    the segment :math:`\import_i` must be :ref:`valid <valid-export>` with :ref:`external type <syntax-externtype>` :math:`\externtype'_i`.
 
 * The length of :math:`C.\CTABLES` must not be larger than :math:`1`.
 
 * The length of :math:`C.\CMEMS` must not be larger than :math:`1`.
 
-* All export names :math:`\name_i` must be different.
+* All export names :math:`\export_i.\ENAME` must be different.
 
 * Let :math:`\externtype^\ast` be the concatenation of :ref:`external types <syntax-externtype>` :math:`\externtype_i` of the imports, in index order.
 
-* Then the module is valid with :ref:`external types <syntax-externtype>` :math:`\externtype^\ast`.
+* Let :math:`{\externtype'}^\ast` be the concatenation of :ref:`external types <syntax-externtype>` :math:`\externtype'_i` of the exports, in index order.
+
+* Then the module is valid with :ref:`external types <syntax-externtype>` :math:`\externtype^\ast \to {\externtype'}^\ast`.
 
 .. math::
    \frac{
@@ -531,7 +534,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \quad
      (C \vdashimport \import : \X{it})^\ast
      \quad
-     (C \vdashexport \export : \X{name})^\ast
+     (C \vdashexport \export : \X{et})^\ast
      \\
      \X{ift}^\ast = \etfuncs(\X{it}^\ast)
      \qquad
@@ -549,7 +552,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
      \qquad
      |C.\CMEMS| \leq 1
      \qquad
-     \name^\ast ~\F{disjoint}
+     (\export.\ENAME)^\ast ~\F{disjoint}
      \end{array}
    }{
      \vdashmodule \{
@@ -563,7 +566,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
          \MDATA~\data^\ast,
          \MSTART~\start^?,
          \MIMPORTS~\import^\ast,
-         \MEXPORTS~\export^\ast \} : \X{it}^\ast \\
+         \MEXPORTS~\export^\ast \} : \X{it}^\ast \to \X{et}^\ast \\
        \end{array}
    }
 

From a5d90cbec68b8ffb2a43bd1a6bafdc51cc58b158 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 26 Sep 2017 13:37:59 +0200
Subject: [PATCH 088/329] [interpreter] Editorial changes to match spec more
 closely (#569)

---
 interpreter/Makefile                      |   8 +-
 interpreter/README.md                     |   4 +-
 interpreter/binary/decode.mli             |   2 +-
 interpreter/binary/utf8.mli               |   4 +-
 interpreter/exec/eval.ml                  | 299 +++++++++++-----------
 interpreter/exec/eval.mli                 |   4 +-
 interpreter/exec/instance.ml              |  34 ---
 interpreter/exec/memory.ml                | 147 -----------
 interpreter/exec/memory.mli               |  38 ---
 interpreter/exec/table.mli                |  24 --
 interpreter/host/env.ml                   |   4 +-
 interpreter/host/spectest.ml              |  33 +--
 interpreter/runtime/func.ml               |  14 +
 interpreter/runtime/func.mli              |  11 +
 interpreter/runtime/global.ml             |  21 ++
 interpreter/runtime/global.mli            |  14 +
 interpreter/runtime/instance.ml           |  41 +++
 interpreter/runtime/memory.ml             | 145 +++++++++++
 interpreter/runtime/memory.mli            |  44 ++++
 interpreter/{exec => runtime}/table.ml    |  16 +-
 interpreter/runtime/table.mli             |  23 ++
 interpreter/{syntax => runtime}/values.ml |   0
 interpreter/script/import.ml              |   2 +-
 interpreter/script/import.mli             |   2 +-
 interpreter/script/js.ml                  |  14 +-
 interpreter/script/run.ml                 |  24 +-
 interpreter/syntax/ast.ml                 |  25 +-
 interpreter/syntax/types.ml               |  69 +++--
 interpreter/text/parse.mli                |   6 +-
 interpreter/util/lib.ml                   |   7 +
 interpreter/util/lib.mli                  |  15 +-
 interpreter/valid/valid.ml                |  90 ++++---
 interpreter/valid/valid.mli               |   2 +-
 test/core/imports.wast                    |  96 +++----
 test/core/linking.wast                    |  12 +-
 test/core/memory.wast                     |   2 +-
 36 files changed, 709 insertions(+), 587 deletions(-)
 delete mode 100644 interpreter/exec/instance.ml
 delete mode 100644 interpreter/exec/memory.ml
 delete mode 100644 interpreter/exec/memory.mli
 delete mode 100644 interpreter/exec/table.mli
 create mode 100644 interpreter/runtime/func.ml
 create mode 100644 interpreter/runtime/func.mli
 create mode 100644 interpreter/runtime/global.ml
 create mode 100644 interpreter/runtime/global.mli
 create mode 100644 interpreter/runtime/instance.ml
 create mode 100644 interpreter/runtime/memory.ml
 create mode 100644 interpreter/runtime/memory.mli
 rename interpreter/{exec => runtime}/table.ml (81%)
 create mode 100644 interpreter/runtime/table.mli
 rename interpreter/{syntax => runtime}/values.ml (100%)

diff --git a/interpreter/Makefile b/interpreter/Makefile
index 7016f041e..7cf198904 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -17,7 +17,7 @@ ZIP =		$(NAME).zip
 JSLIB =		wast.js
 WINMAKE =	winmake.bat
 
-DIRS =		util syntax binary text valid exec script host main
+DIRS =		util syntax binary text valid runtime exec script host main
 LIBS =		bigarray
 FLAGS = 	-cflags '-w +a-4-27-42-44-45 -warn-error +a'
 OCB =		ocamlbuild $(FLAGS) $(DIRS:%=-I %) $(LIBS:%=-libs %)
@@ -120,12 +120,12 @@ debugtest:	$(UNOPT)
 test/%:		$(OPT)
 		../test/core/run.py --wasm `pwd`/$(OPT) $(if $(JS),--js '$(JS)',) $(@:test/%=../test/core/%.wast)
 debugtest/%:	$(UNOPT)
-		../test/core/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',) $(@:test/%=../test/core/%.wast)
+		../test/core/run.py --wasm `pwd`/$(UNOPT) $(if $(JS),--js '$(JS)',) $(@:debugtest/%=../test/core/%.wast)
 
 run/%:		$(OPT)
 		./$(OPT) $(@:run/%=../test/core/%.wast)
-debugrun/%:		$(UNOPT)
-		./$(UNOPT) $(@:run/%=../test/core/%.wast)
+debug/%:		$(UNOPT)
+		./$(UNOPT) $(@:debug/%=../test/core/%.wast)
 
 
 # Miscellaneous targets
diff --git a/interpreter/README.md b/interpreter/README.md
index 19f88604e..3c56ed6c1 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -360,6 +360,8 @@ The implementation is split into several directories:
 
 * `valid`: validation of code and modules; corresponds to the "Validation" section of the language specification
 
+* `runtime`: the definition of runtime structures; corresponds to the "Execution/Runtime" section of the language specification
+
 * `exec`: execution and module instantiation; corresponds to the "Execution" section of the language specification
 
 * `binary`: encoding and decoding of the binary format; corresponds to the "Binary Format" section of the language specification
@@ -386,7 +388,7 @@ The implementation consists of the following parts:
 
 * *Validator* (`valid.ml[i]`). Does a recursive walk of the AST, passing down the *expected* type for expressions, and checking each expression against that. An expected empty type can be matched by any result, corresponding to implicit dropping of unused values (e.g. in a block).
 
-* *Evaluator* (`eval.ml[i]`, `values.ml`, `instance.ml`, `eval_numeric.ml[i]`, `int.ml`, `float.ml`, `table.ml[i]`, `memory.ml[i]`, and a few more). Implements evaluation as a small-step semantics that rewrites a program one computation step at a time.
+* *Evaluator* (`eval.ml[i]`, `values.ml`, `func.ml[i]`, `table.ml[i]`, `memory.ml[i]`, `global.ml[i]`, `instance.ml`, `eval_numeric.ml[i]`, `int.ml`, `float.ml`, and a few more). Implements evaluation as a small-step semantics that rewrites a program one computation step at a time.
 
 * *JS Generator* (`js.ml[i]`). Converts a script to equivalent JavaScript.
 
diff --git a/interpreter/binary/decode.mli b/interpreter/binary/decode.mli
index 30a731b90..96a204ed2 100644
--- a/interpreter/binary/decode.mli
+++ b/interpreter/binary/decode.mli
@@ -1,3 +1,3 @@
 exception Code of Source.region * string
 
-val decode : string -> string -> Ast.module_ (* raise Code *)
+val decode : string -> string -> Ast.module_ (* raises Code *)
diff --git a/interpreter/binary/utf8.mli b/interpreter/binary/utf8.mli
index 589d87ec5..3a70c3c2b 100644
--- a/interpreter/binary/utf8.mli
+++ b/interpreter/binary/utf8.mli
@@ -1,4 +1,4 @@
 exception Utf8
 
-val decode : string -> int list (* raise UTf8 *)
-val encode : int list -> string (* raise Utf8 *)
+val decode : string -> int list (* raises UTf8 *)
+val encode : int list -> string (* raises Utf8 *)
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index db3320326..eb8f0b8da 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -39,26 +39,34 @@ let numeric_error at = function
 
 type 'a stack = 'a list
 
-type admin_instr = admin_instr' phrase
+type frame =
+{
+  inst : module_inst;
+  locals : value ref list;
+}
+
+type code = value stack * admin_instr list
+
+and admin_instr = admin_instr' phrase
 and admin_instr' =
   | Plain of instr'
   | Trapped of string
   | Break of int32 * value stack
-  | Label of stack_type * instr list * value stack * admin_instr list
-  | Local of instance * value ref list * value stack * admin_instr list
-  | Invoke of closure
+  | Label of stack_type * instr list * code
+  | Frame of frame * code
+  | Invoke of func_inst
 
 type config =
 {
-  locals : value ref list;
-  values : value stack;
-  instrs : admin_instr list;
+  frame : frame;
+  code : code;
   depth : int;   (* needed for return *)
   budget : int;  (* needed to model stack overflow *)
 }
 
-let config vs es =
-  {locals = []; values = vs; instrs = es; depth = 0; budget = 300}
+let frame inst locals = {inst; locals}
+let config inst vs es =
+  {frame = frame inst []; code = vs, es; depth = 0; budget = 300}
 
 let plain e = Plain e.it @@ e.at
 
@@ -66,12 +74,12 @@ let lookup category list x =
   try Lib.List32.nth list x.it with Failure _ ->
     Crash.error x.at ("undefined " ^ category ^ " " ^ Int32.to_string x.it)
 
-let type_ (inst : instance) x = lookup "type" inst.module_.it.types x
-let func (inst : instance) x = lookup "function" inst.funcs x
-let table (inst : instance) x = lookup "table" inst.tables x
-let memory (inst : instance) x = lookup "memory" inst.memories x
-let global (inst : instance) x = lookup "global" inst.globals x
-let local (locals : value ref list) x = lookup "local" locals x
+let type_ (inst : module_inst) x = lookup "type" inst.types x
+let func (inst : module_inst) x = lookup "function" inst.funcs x
+let table (inst : module_inst) x = lookup "table" inst.tables x
+let memory (inst : module_inst) x = lookup "memory" inst.memories x
+let global (inst : module_inst) x = lookup "global" inst.globals x
+let local (frame : frame) x = lookup "local" frame.locals x
 
 let elem inst x i at =
   match Table.load (table inst x) i with
@@ -83,13 +91,9 @@ let elem inst x i at =
 
 let func_elem inst x i at =
   match elem inst x i at with
-  | Func f -> f
+  | FuncElem f -> f
   | _ -> Crash.error at ("type mismatch for element " ^ Int32.to_string i)
 
-let func_type_of = function
-  | AstFunc (inst, f) -> (lookup "type" (!inst).module_.it.types f.it.ftype).it
-  | HostFunc (t, _) -> t
-
 let take n (vs : 'a stack) at =
   try Lib.List.take n vs with Failure _ -> Crash.error at "stack underflow"
 
@@ -108,10 +112,11 @@ let drop n (vs : 'a stack) at =
  *   c : config
  *)
 
-let rec step (inst : instance) (c : config) : config =
-  let e = List.hd c.instrs in
+let rec step (c : config) : config =
+  let {frame; code = vs, es; _} = c in
+  let e = List.hd es in
   let vs', es' =
-    match e.it, c.values with
+    match e.it, vs with
     | Plain e', vs ->
       (match e', vs with
       | Unreachable, vs ->
@@ -121,10 +126,10 @@ let rec step (inst : instance) (c : config) : config =
         vs, []
 
       | Block (ts, es'), vs ->
-        vs, [Label (ts, [], [], List.map plain es') @@ e.at]
+        vs, [Label (ts, [], ([], List.map plain es')) @@ e.at]
 
       | Loop (ts, es'), vs ->
-        vs, [Label ([], [e' @@ e.at], [], List.map plain es') @@ e.at]
+        vs, [Label ([], [e' @@ e.at], ([], List.map plain es')) @@ e.at]
 
       | If (ts, es1, es2), I32 0l :: vs' ->
         vs', [Plain (Block (ts, es2)) @@ e.at]
@@ -151,13 +156,13 @@ let rec step (inst : instance) (c : config) : config =
         vs, [Plain (Br ((Int32.of_int (c.depth - 1)) @@ e.at)) @@ e.at]
 
       | Call x, vs ->
-        vs, [Invoke (func inst x) @@ e.at]
+        vs, [Invoke (func frame.inst x) @@ e.at]
 
       | CallIndirect x, I32 i :: vs ->
-        let clos = func_elem inst (0l @@ e.at) i e.at in
-        if (type_ inst x).it <> func_type_of clos then
+        let func = func_elem frame.inst (0l @@ e.at) i e.at in
+        if type_ frame.inst x <> Func.type_of func then
           Trap.error e.at "indirect call signature mismatch";
-        vs, [Invoke clos @@ e.at]
+        vs, [Invoke func @@ e.at]
 
       | Drop, v :: vs' ->
         vs', []
@@ -169,51 +174,52 @@ let rec step (inst : instance) (c : config) : config =
         v1 :: vs', []
 
       | GetLocal x, vs ->
-        !(local c.locals x) :: vs, []
+        !(local frame x) :: vs, []
 
       | SetLocal x, v :: vs' ->
-        local c.locals x := v;
+        local frame x := v;
         vs', []
 
       | TeeLocal x, v :: vs' ->
-        local c.locals x := v;
+        local frame x := v;
         v :: vs', []
 
       | GetGlobal x, vs ->
-        !(global inst x) :: vs, []
+        Global.load (global frame.inst x) :: vs, []
 
       | SetGlobal x, v :: vs' ->
-        global inst x := v;
-        vs', []
+        (try Global.store (global frame.inst x) v; vs', []
+        with Global.NotMutable -> Crash.error e.at "write to immutable global"
+           | Global.Type -> Crash.error e.at "type mismatch at global write")
 
       | Load {offset; ty; sz; _}, I32 i :: vs' ->
-        let mem = memory inst (0l @@ e.at) in
+        let mem = memory frame.inst (0l @@ e.at) in
         let addr = I64_convert.extend_u_i32 i in
         (try
           let v =
             match sz with
-            | None -> Memory.load mem addr offset ty
+            | None -> Memory.load_value mem addr offset ty
             | Some (sz, ext) -> Memory.load_packed sz ext mem addr offset ty
           in v :: vs', []
         with exn -> vs', [Trapped (memory_error e.at exn) @@ e.at])
 
       | Store {offset; sz; _}, v :: I32 i :: vs' ->
-        let mem = memory inst (0l @@ e.at) in
+        let mem = memory frame.inst (0l @@ e.at) in
         let addr = I64_convert.extend_u_i32 i in
         (try
           (match sz with
-          | None -> Memory.store mem addr offset v
+          | None -> Memory.store_value mem addr offset v
           | Some sz -> Memory.store_packed sz mem addr offset v
           );
           vs', []
         with exn -> vs', [Trapped (memory_error e.at exn) @@ e.at]);
 
       | CurrentMemory, vs ->
-        let mem = memory inst (0l @@ e.at) in
+        let mem = memory frame.inst (0l @@ e.at) in
         I32 (Memory.size mem) :: vs, []
 
       | GrowMemory, I32 delta :: vs' ->
-        let mem = memory inst (0l @@ e.at) in
+        let mem = memory frame.inst (0l @@ e.at) in
         let old_size = Memory.size mem in
         let result =
           try Memory.grow mem delta; old_size
@@ -256,79 +262,79 @@ let rec step (inst : instance) (c : config) : config =
     | Break (k, vs'), vs ->
       Crash.error e.at "undefined label"
 
-    | Label (ts, es0, vs', []), vs ->
+    | Label (ts, es0, (vs', [])), vs ->
       vs' @ vs, []
 
-    | Label (ts, es0, vs', {it = Trapped msg; at} :: es'), vs ->
+    | Label (ts, es0, (vs', {it = Trapped msg; at} :: es')), vs ->
       vs, [Trapped msg @@ at]
 
-    | Label (ts, es0, vs', {it = Break (0l, vs0); at} :: es'), vs ->
+    | Label (ts, es0, (vs', {it = Break (0l, vs0); at} :: es')), vs ->
       take (List.length ts) vs0 e.at @ vs, List.map plain es0
 
-    | Label (ts, es0, vs', {it = Break (k, vs0); at} :: es'), vs ->
+    | Label (ts, es0, (vs', {it = Break (k, vs0); at} :: es')), vs ->
       vs, [Break (Int32.sub k 1l, vs0) @@ at]
 
-    | Label (ts, es0, values, instrs), vs ->
-      let c' = step inst {c with values; instrs; depth = c.depth + 1} in
-      vs, [Label (ts, es0, c'.values, c'.instrs) @@ e.at]
+    | Label (ts, es0, code'), vs ->
+      let c' = step {c with code = code'; depth = c.depth + 1} in
+      vs, [Label (ts, es0, c'.code) @@ e.at]
 
-    | Local (inst', locals, vs', []), vs ->
+    | Frame (frame', (vs', [])), vs ->
       vs' @ vs, []
 
-    | Local (inst', locals, vs', {it = Trapped msg; at} :: es'), vs ->
+    | Frame (frame', (vs', {it = Trapped msg; at} :: es')), vs ->
       vs, [Trapped msg @@ at]
 
-    | Local (inst', locals, values, instrs), vs ->
-      let c' = step inst' {locals; values; instrs; depth = 0; budget = c.budget - 1} in
-      vs, [Local (inst', c'.locals, c'.values, c'.instrs) @@ e.at]
+    | Frame (frame', code'), vs ->
+      let c' = step {frame = frame'; code = code'; depth = 0; budget = c.budget - 1} in
+      vs, [Frame (c'.frame, c'.code) @@ e.at]
 
-    | Invoke clos, vs when c.budget = 0 ->
+    | Invoke func, vs when c.budget = 0 ->
       Exhaustion.error e.at "call stack exhausted"
 
-    | Invoke clos, vs ->
-      let FuncType (ins, out) = func_type_of clos in
+    | Invoke func, vs ->
+      let FuncType (ins, out) = Func.type_of func in
       let n = List.length ins in
       let args, vs' = take n vs e.at, drop n vs e.at in
-      (match clos with
-      | AstFunc (inst', f) ->
+      (match func with
+      | Func.AstFunc (t, inst', f) ->
         let locals' = List.rev args @ List.map default_value f.it.locals in
-        let instrs' = [Plain (Block (out, f.it.body)) @@ f.at] in
-        vs', [Local (!inst', List.map ref locals', [], instrs') @@ e.at]
+        let code' = [], [Plain (Block (out, f.it.body)) @@ f.at] in
+        let frame' = {inst = !inst'; locals = List.map ref locals'} in
+        vs', [Frame (frame', code') @@ e.at]
 
-      | HostFunc (t, f) ->
+      | Func.HostFunc (t, f) ->
         try List.rev (f (List.rev args)) @ vs', []
         with Crash (_, msg) -> Crash.error e.at msg
       )
-  in {c with values = vs'; instrs = es' @ List.tl c.instrs}
+  in {c with code = vs', es' @ List.tl es}
 
 
-let rec eval (inst : instance) (c : config) : value stack =
-  match c.instrs with
-  | [] ->
-    c.values
+let rec eval (c : config) : value stack =
+  match c.code with
+  | vs, [] ->
+    vs
 
-  | {it = Trapped msg; at} :: _ ->
+  | vs, {it = Trapped msg; at} :: _ ->
     Trap.error at msg
 
-  | es ->
-    eval inst (step inst c)
+  | vs, es ->
+    eval (step c)
 
 
 (* Functions & Constants *)
 
-let invoke (clos : closure) (vs : value list) : value list =
-  let at = match clos with AstFunc (_, f) -> f.at | HostFunc _ -> no_region in
-  let FuncType (ins, out) = func_type_of clos in
+let invoke (func : func_inst) (vs : value list) : value list =
+  let at = match func with Func.AstFunc (_,_, f) -> f.at | _ -> no_region in
+  let FuncType (ins, out) = Func.type_of func in
   if List.length vs <> List.length ins then
     Crash.error at "wrong number of arguments";
-  let inst = instance (empty_module @@ at) in
-  let c = config (List.rev vs) [Invoke clos @@ at] in
-  try List.rev (eval inst c)
-  with Stack_overflow -> Exhaustion.error at "call stack exhausted"
-
-let eval_const (inst : instance) (const : const) : value =
-  let c = config [] (List.map plain const.it) in
-  match eval inst c with
+  let c = config empty_module_inst (List.rev vs) [Invoke func @@ at] in
+  try List.rev (eval c) with Stack_overflow ->
+    Exhaustion.error at "call stack exhausted"
+
+let eval_const (inst : module_inst) (const : const) : value =
+  let c = config inst [] (List.map plain const.it) in
+  match eval c with
   | [v] -> v
   | vs -> Crash.error const.at "wrong number of results on stack"
 
@@ -340,27 +346,39 @@ let i32 (v : value) at =
 
 (* Modules *)
 
-let create_closure (m : module_) (f : func) =
-  AstFunc (ref (instance m), f)
+let create_func (inst : module_inst) (f : func) : func_inst =
+  Func.alloc (type_ inst f.it.ftype) (ref inst) f
+
+let create_table (inst : module_inst) (tab : table) : table_inst =
+  let {ttype} = tab.it in
+  Table.alloc ttype
 
-let create_table (tab : table) =
-  let {ttype = TableType (lim, t)} = tab.it in
-  Table.create t lim
+let create_memory (inst : module_inst) (mem : memory) : memory_inst =
+  let {mtype} = mem.it in
+  Memory.alloc mtype
 
-let create_memory (mem : memory) =
-  let {mtype = MemoryType lim} = mem.it in
-  Memory.create lim
+let create_global (inst : module_inst) (glob : global) : global_inst =
+  let {gtype; value} = glob.it in
+  let v = eval_const inst value in
+  Global.alloc gtype v
 
-let create_global (glob : global) =
-  let {gtype = GlobalType (t, _); _} = glob.it in
-  ref (default_value t)
+let create_export (inst : module_inst) (ex : export) : export_inst =
+  let {name; edesc} = ex.it in
+  let ext =
+    match edesc.it with
+    | FuncExport x -> ExternFunc (func inst x)
+    | TableExport x -> ExternTable (table inst x)
+    | MemoryExport x -> ExternMemory (memory inst x)
+    | GlobalExport x -> ExternGlobal (global inst x)
+  in name, ext
 
-let init_closure (inst : instance) (clos : closure) =
-  match clos with
-  | AstFunc (inst_ref, _) -> inst_ref := inst
+
+let init_func (inst : module_inst) (func : func_inst) =
+  match func with
+  | Func.AstFunc (_, inst_ref, _) -> inst_ref := inst
   | _ -> assert false
 
-let init_table (inst : instance) (seg : table_segment) =
+let init_table (inst : module_inst) (seg : table_segment) =
   let {index; offset = const; init} = seg.it in
   let tab = table inst index in
   let offset = i32 (eval_const inst const) const.at in
@@ -368,9 +386,10 @@ let init_table (inst : instance) (seg : table_segment) =
   let bound = Table.size tab in
   if I32.lt_u bound end_ || I32.lt_u end_ offset then
     Link.error seg.at "elements segment does not fit table";
-  fun () -> Table.blit tab offset (List.map (fun x -> Func (func inst x)) init)
+  fun () ->
+    Table.blit tab offset (List.map (fun x -> FuncElem (func inst x)) init)
 
-let init_memory (inst : instance) (seg : memory_segment) =
+let init_memory (inst : module_inst) (seg : memory_segment) =
   let {index; offset = const; init} = seg.it in
   let mem = memory inst index in
   let offset' = i32 (eval_const inst const) const.at in
@@ -379,74 +398,44 @@ let init_memory (inst : instance) (seg : memory_segment) =
   let bound = Memory.bound mem in
   if I64.lt_u bound end_ || I64.lt_u end_ offset then
     Link.error seg.at "data segment does not fit memory";
-  fun () -> Memory.blit mem offset init
-
-let init_global (inst : instance) (ref : value ref) (glob : global) =
-  let {value; _} = glob.it in
-  ref := eval_const inst value
-
-let check_limits actual expected at =
-  if I32.lt_u actual.min expected.min then
-    Link.error at "actual size smaller than declared";
-  if
-    match actual.max, expected.max with
-    | _, None -> false
-    | None, Some _ -> true
-    | Some i, Some j -> I32.gt_u i j
-  then Link.error at "maximum size larger than declared"
-
-let add_import (ext : extern) (im : import) (inst : instance) : instance =
-  let {idesc; _} = im.it in
-  match ext, idesc.it with
-  | ExternalFunc clos, FuncImport x when func_type_of clos = (type_ inst x).it ->
-    {inst with funcs = clos :: inst.funcs}
-  | ExternalTable tab, TableImport (TableType (lim, t))
-    when Table.elem_type tab = t ->
-    check_limits (Table.limits tab) lim idesc.at;
-    {inst with tables = tab :: inst.tables}
-  | ExternalMemory mem, MemoryImport (MemoryType lim) ->
-    check_limits (Memory.limits mem) lim idesc.at;
-    {inst with memories = mem :: inst.memories}
-  | ExternalGlobal v, GlobalImport (GlobalType (t, _)) when type_of v = t ->
-    {inst with globals = ref v :: inst.globals}
-  | _ ->
-    Link.error idesc.at "type mismatch"
-
-let add_export (inst : instance) (ex : export) (map : extern ExportMap.t)
-  : extern ExportMap.t =
-  let {name; edesc} = ex.it in
-  let ext =
-    match edesc.it with
-    | FuncExport x -> ExternalFunc (func inst x)
-    | TableExport x -> ExternalTable (table inst x)
-    | MemoryExport x -> ExternalMemory (memory inst x)
-    | GlobalExport x -> ExternalGlobal !(global inst x)
-  in ExportMap.add name ext map
+  fun () -> Memory.store_bytes mem offset init
+
 
-let init (m : module_) (exts : extern list) : instance =
+let add_import (m : module_) (ext : extern) (im : import) (inst : module_inst)
+  : module_inst =
+  if not (match_extern_type (extern_type_of ext) (import_type m im)) then
+    Link.error im.at "incompatible import type";
+  match ext with
+  | ExternFunc func -> {inst with funcs = func :: inst.funcs}
+  | ExternTable tab -> {inst with tables = tab :: inst.tables}
+  | ExternMemory mem -> {inst with memories = mem :: inst.memories}
+  | ExternGlobal glob -> {inst with globals = glob :: inst.globals}
+
+let init (m : module_) (exts : extern list) : module_inst =
   let
-    { imports; tables; memories; globals; funcs;
-      exports; elems; data; start; _
+    { imports; tables; memories; globals; funcs; types;
+      exports; elems; data; start
     } = m.it
   in
   if List.length exts <> List.length imports then
     Link.error m.at "wrong number of imports provided for initialisation";
-  let fs = List.map (create_closure m) funcs in
-  let gs = List.map create_global globals in
+  let inst0 =
+    { (List.fold_right2 (add_import m) exts imports empty_module_inst) with
+      types = List.map (fun type_ -> type_.it) types }
+  in
+  let fs = List.map (create_func inst0) funcs in
   let inst =
-    List.fold_right2 add_import exts imports
-      { (instance m) with
-        funcs = fs;
-        tables = List.map create_table tables;
-        memories = List.map create_memory memories;
-        globals = gs;
-      }
+    { inst0 with
+      funcs = inst0.funcs @ fs;
+      tables = inst0.tables @ List.map (create_table inst0) tables;
+      memories = inst0.memories @ List.map (create_memory inst0) memories;
+      globals = inst0.globals @ List.map (create_global inst0) globals;
+    }
   in
-  List.iter2 (init_global inst) gs globals;
-  List.iter (init_closure inst) fs;
+  List.iter (init_func inst) fs;
   let init_elems = List.map (init_table inst) elems in
   let init_datas = List.map (init_memory inst) data in
   List.iter (fun f -> f ()) init_elems;
   List.iter (fun f -> f ()) init_datas;
   Lib.Option.app (fun x -> ignore (invoke (func inst x) [])) start;
-  {inst with exports = List.fold_right (add_export inst) exports inst.exports}
+  {inst with exports = List.map (create_export inst) exports}
diff --git a/interpreter/exec/eval.mli b/interpreter/exec/eval.mli
index f36e1dd16..825cc74f0 100644
--- a/interpreter/exec/eval.mli
+++ b/interpreter/exec/eval.mli
@@ -6,5 +6,5 @@ exception Trap of Source.region * string
 exception Crash of Source.region * string
 exception Exhaustion of Source.region * string
 
-val init : Ast.module_ -> extern list -> instance (* raises Link, Trap *)
-val invoke : closure -> value list -> value list (* raises Trap *)
+val init : Ast.module_ -> extern list -> module_inst (* raises Link, Trap *)
+val invoke : func_inst -> value list -> value list (* raises Trap *)
diff --git a/interpreter/exec/instance.ml b/interpreter/exec/instance.ml
deleted file mode 100644
index bcc019530..000000000
--- a/interpreter/exec/instance.ml
+++ /dev/null
@@ -1,34 +0,0 @@
-open Values
-
-module ExportMap = Map.Make(struct type t = Ast.name let compare = compare end)
-
-type global = value ref
-
-type closure =
-  | AstFunc of instance ref * Ast.func
-  | HostFunc of Types.func_type * (value list -> value list)
-
-and extern =
-  | ExternalFunc of closure
-  | ExternalTable of Table.t
-  | ExternalMemory of Memory.t
-  | ExternalGlobal of value
-
-and instance =
-{
-  module_ : Ast.module_;
-  funcs : closure list;
-  tables : Table.t list;
-  memories : Memory.t list;
-  globals : global list;
-  exports : extern ExportMap.t;
-}
-
-type Table.elem += Func of closure
-
-let instance m =
-  { module_ = m; funcs = []; tables = []; memories = []; globals = [];
-    exports = ExportMap.empty }
-
-let export inst name =
-  try Some (ExportMap.find name inst.exports) with Not_found -> None
diff --git a/interpreter/exec/memory.ml b/interpreter/exec/memory.ml
deleted file mode 100644
index 82e2b6a32..000000000
--- a/interpreter/exec/memory.ml
+++ /dev/null
@@ -1,147 +0,0 @@
-open Bigarray
-open Lib.Bigarray
-open Types
-open Values
-
-type size = int32  (* number of pages *)
-type address = int64
-type offset = int32
-
-type mem_size = Mem8 | Mem16 | Mem32
-type extension = SX | ZX
-
-type value = Values.value
-type value_type = Types.value_type
-type 'a limits = 'a Types.limits
-
-type memory' = (int, int8_unsigned_elt, c_layout) Array1.t
-type memory = {mutable content : memory'; max : size option}
-type t = memory
-
-exception Type
-exception Bounds
-exception SizeOverflow
-exception SizeLimit
-exception OutOfMemory
-
-let page_size = 0x10000L (* 64 KiB *)
-
-let mem_size = function
-  | Mem8 -> 1
-  | Mem16 -> 2
-  | Mem32 -> 4
-
-let within_limits n = function
-  | None -> true
-  | Some max -> I32.le_u n max
-
-let create' n =
-  if I32.gt_u n 0x10000l then raise SizeOverflow else
-  try
-    let size = Int64.(mul (of_int32 n) page_size) in
-    let mem = Array1_64.create Int8_unsigned C_layout size in
-    Array1.fill mem 0;
-    mem
-  with Out_of_memory -> raise OutOfMemory
-
-let create {min; max} =
-  assert (within_limits min max);
-  {content = create' min; max}
-
-let bound mem =
-  Array1_64.dim mem.content
-
-let size mem =
-  Int64.(to_int32 (div (bound mem) page_size))
-
-let limits mem =
-  {min = size mem; max = mem.max}
-
-let grow mem delta =
-  let old_size = size mem in
-  let new_size = Int32.add old_size delta in
-  if I32.gt_u old_size new_size then raise SizeOverflow else
-  if not (within_limits new_size mem.max) then raise SizeLimit else
-  let after = create' new_size in
-  let dim = Array1_64.dim mem.content in
-  Array1.blit (Array1_64.sub mem.content 0L dim) (Array1_64.sub after 0L dim);
-  mem.content <- after
-
-let effective_address a o =
-  let ea = Int64.(add a (of_int32 o)) in
-  if I64.lt_u ea a then raise Bounds;
-  ea
-
-let loadn mem n ea =
-  assert (n > 0 && n <= 8);
-  let rec loop mem n i =
-    if n = 0 then 0L else
-    let rest = Int64.(shift_left (loop mem (n - 1) (add i 1L)) 8) in
-    let byte = Int64.of_int (Array1_64.get mem.content i) in
-    Int64.logor byte rest
-  in
-  try loop mem n ea with Invalid_argument _ -> raise Bounds
-
-let storen mem n ea v =
-  assert (n > 0 && n <= 8);
-  let rec loop mem n i v =
-    if n > 0 then begin
-      Int64.(loop mem (n - 1) (add i 1L) (shift_right v 8));
-      Array1_64.set mem.content i (Int64.to_int v land 255)
-    end
-  in
-  try loop mem n ea v with Invalid_argument _ -> raise Bounds
-
-let load mem a o t =
-  let ea = effective_address a o in
-  match t with
-  | I32Type -> I32 (Int64.to_int32 (loadn mem 4 ea))
-  | I64Type -> I64 (loadn mem 8 ea)
-  | F32Type -> F32 (F32.of_bits (Int64.to_int32 (loadn mem 4 ea)))
-  | F64Type -> F64 (F64.of_bits (loadn mem 8 ea))
-
-let store mem a o v =
-  let ea = effective_address a o in
-  match v with
-  | I32 x -> storen mem 4 ea (Int64.of_int32 x)
-  | I64 x -> storen mem 8 ea x
-  | F32 x -> storen mem 4 ea (Int64.of_int32 (F32.to_bits x))
-  | F64 x -> storen mem 8 ea (F64.to_bits x)
-
-let loadn_sx mem n ea =
-  assert (n > 0 && n <= 8);
-  let v = loadn mem n ea in
-  let shift = 64 - (8 * n) in
-  Int64.(shift_right (shift_left v shift) shift)
-
-let load_packed sz ext mem a o t =
-  let ea = effective_address a o in
-  match sz, ext, t with
-  | Mem8,  ZX, I32Type -> I32 (Int64.to_int32 (loadn    mem 1 ea))
-  | Mem8,  SX, I32Type -> I32 (Int64.to_int32 (loadn_sx mem 1 ea))
-  | Mem8,  ZX, I64Type -> I64 (loadn mem 1 ea)
-  | Mem8,  SX, I64Type -> I64 (loadn_sx mem 1 ea)
-  | Mem16, ZX, I32Type -> I32 (Int64.to_int32 (loadn    mem 2 ea))
-  | Mem16, SX, I32Type -> I32 (Int64.to_int32 (loadn_sx mem 2 ea))
-  | Mem16, ZX, I64Type -> I64 (loadn    mem 2 ea)
-  | Mem16, SX, I64Type -> I64 (loadn_sx mem 2 ea)
-  | Mem32, ZX, I64Type -> I64 (loadn    mem 4 ea)
-  | Mem32, SX, I64Type -> I64 (loadn_sx mem 4 ea)
-  | _ -> raise Type
-
-let store_packed sz mem a o v =
-  let ea = effective_address a o in
-  match sz, v with
-  | Mem8,  I32 x -> storen mem 1 ea (Int64.of_int32 x)
-  | Mem8,  I64 x -> storen mem 1 ea x
-  | Mem16, I32 x -> storen mem 2 ea (Int64.of_int32 x)
-  | Mem16, I64 x -> storen mem 2 ea x
-  | Mem32, I64 x -> storen mem 4 ea x
-  | _ -> raise Type
-
-let blit mem addr data =
-  try
-    for i = String.length data - 1 downto 0 do
-      Array1_64.set mem.content Int64.(add addr (of_int i)) (Char.code data.[i])
-    done
-  with Invalid_argument _ -> raise Bounds
diff --git a/interpreter/exec/memory.mli b/interpreter/exec/memory.mli
deleted file mode 100644
index 1ee645244..000000000
--- a/interpreter/exec/memory.mli
+++ /dev/null
@@ -1,38 +0,0 @@
-type memory
-type t = memory
-
-type size = int32  (* number of pages *)
-type address = int64
-type offset = int32
-
-type mem_size = Mem8 | Mem16 | Mem32
-type extension = SX | ZX
-
-type value = Values.value
-type value_type = Types.value_type
-type 'a limits = 'a Types.limits
-
-exception Type
-exception Bounds
-exception SizeOverflow
-exception SizeLimit
-exception OutOfMemory
-
-val page_size : int64
-val mem_size : mem_size -> int
-
-val create : size limits -> memory (* raise SizeOverflow, OutOfMemory *)
-val size : memory -> size
-val bound : memory -> address
-val limits : memory -> size limits
-val grow : memory -> size -> unit
-  (* raise SizeLimit, SizeOverflow, OutOfMemory *)
-
-val load : memory -> address -> offset -> value_type -> value (* raise Bounds *)
-val store : memory -> address -> offset -> value -> unit (* raise Bounds *)
-val load_packed :
-  mem_size -> extension -> memory -> address -> offset -> value_type -> value
- (* raise Type, Bounds *)
-val store_packed : mem_size -> memory -> address -> offset -> value -> unit
- (* raise Type, Bounds *)
-val blit : memory -> address -> string -> unit (* raise Bouunds *)
diff --git a/interpreter/exec/table.mli b/interpreter/exec/table.mli
deleted file mode 100644
index 9f41f34fb..000000000
--- a/interpreter/exec/table.mli
+++ /dev/null
@@ -1,24 +0,0 @@
-type table
-type t = table
-
-type size = int32
-type index = int32
-
-type elem = ..
-type elem += Uninitialized
-type elem_type = Types.elem_type
-type 'a limits = 'a Types.limits
-
-exception Bounds
-exception SizeOverflow
-exception SizeLimit
-
-val create : elem_type -> size limits -> table
-val elem_type : table -> elem_type
-val size : table -> size
-val limits : table -> size limits
-val grow : table -> size -> unit (* raise SizeOverflow, SizeLimit *)
-
-val load : table -> index -> elem (* raise Bounds *)
-val store : table -> index -> elem -> unit (* raise Bounds *)
-val blit : table -> index -> elem list -> unit (* raise Bounds *)
diff --git a/interpreter/host/env.ml b/interpreter/host/env.ml
index 07dab62f7..a23838c50 100644
--- a/interpreter/host/env.ml
+++ b/interpreter/host/env.ml
@@ -41,6 +41,6 @@ let exit vs =
 
 let lookup name t =
   match Utf8.encode name, t with
-  | "abort", ExternalFuncType t -> ExternalFunc (HostFunc (t, abort))
-  | "exit", ExternalFuncType t -> ExternalFunc (HostFunc (t, exit))
+  | "abort", ExternFuncType t -> ExternFunc (Func.alloc_host t abort)
+  | "exit", ExternFuncType t -> ExternFunc (Func.alloc_host t exit)
   | _ -> raise Not_found
diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index a5e076254..e29c8c8b6 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -7,15 +7,18 @@ open Values
 open Instance
 
 
-let global (GlobalType (t, _)) =
-  match t with
-  | I32Type -> I32 666l
-  | I64Type -> I64 666L
-  | F32Type -> F32 (F32.of_float 666.6)
-  | F64Type -> F64 (F64.of_float 666.6)
-
-let table = Table.create AnyFuncType {min = 10l; max = Some 20l}
-let memory = Memory.create {min = 1l; max = Some 2l}
+let global (GlobalType (t, _) as gt) =
+  let v =
+    match t with
+    | I32Type -> I32 666l
+    | I64Type -> I64 666L
+    | F32Type -> F32 (F32.of_float 666.6)
+    | F64Type -> F64 (F64.of_float 666.6)
+  in Global.alloc gt v
+
+let table = Table.alloc (TableType ({min = 10l; max = Some 20l}, AnyFuncType))
+let memory = Memory.alloc (MemoryType {min = 1l; max = Some 2l})
+let func f t = Func.alloc_host t (f t)
 
 let print_value v =
   Printf.printf "%s : %s\n"
@@ -29,11 +32,11 @@ let print (FuncType (_, out)) vs =
 
 let lookup name t =
   match Utf8.encode name, t with
-  | "print", ExternalFuncType t -> ExternalFunc (HostFunc (t, print t))
+  | "print", ExternFuncType t -> ExternFunc (func print t)
   | "print", _ ->
-    let t = FuncType ([], []) in ExternalFunc (HostFunc (t, print t))
-  | "global", ExternalGlobalType t -> ExternalGlobal (global t)
-  | "global", _ -> ExternalGlobal (global (GlobalType (I32Type, Immutable)))
-  | "table", _ -> ExternalTable table
-  | "memory", _ -> ExternalMemory memory
+    let t = FuncType ([], []) in ExternFunc (func print t)
+  | "global", ExternGlobalType t -> ExternGlobal (global t)
+  | "global", _ -> ExternGlobal (global (GlobalType (I32Type, Immutable)))
+  | "table", _ -> ExternTable table
+  | "memory", _ -> ExternMemory memory
   | _ -> raise Not_found
diff --git a/interpreter/runtime/func.ml b/interpreter/runtime/func.ml
new file mode 100644
index 000000000..461cdc5bb
--- /dev/null
+++ b/interpreter/runtime/func.ml
@@ -0,0 +1,14 @@
+open Types
+open Values
+
+type 'inst t = 'inst func
+and 'inst func =
+  | AstFunc of func_type * 'inst * Ast.func
+  | HostFunc of func_type * (value list -> value list)
+
+let alloc ft inst f = AstFunc (ft, inst, f)
+let alloc_host ft f = HostFunc (ft, f)
+
+let type_of = function
+  | AstFunc (ft, _, _) -> ft
+  | HostFunc (ft, _) -> ft
diff --git a/interpreter/runtime/func.mli b/interpreter/runtime/func.mli
new file mode 100644
index 000000000..d5346263f
--- /dev/null
+++ b/interpreter/runtime/func.mli
@@ -0,0 +1,11 @@
+open Types
+open Values
+
+type 'inst t = 'inst func
+and 'inst func =
+  | AstFunc of func_type * 'inst * Ast.func
+  | HostFunc of func_type * (value list -> value list)
+
+val alloc : func_type -> 'inst -> Ast.func -> 'inst func
+val alloc_host : func_type -> (value list -> value list) -> 'inst func
+val type_of : 'inst func -> func_type
diff --git a/interpreter/runtime/global.ml b/interpreter/runtime/global.ml
new file mode 100644
index 000000000..c5375d738
--- /dev/null
+++ b/interpreter/runtime/global.ml
@@ -0,0 +1,21 @@
+open Types
+open Values
+
+type global = {mutable content : value; mut : mutability}
+type t = global
+
+exception Type
+exception NotMutable
+
+let alloc (GlobalType (t, mut)) v =
+  if type_of v <> t then raise Type;
+  {content = v; mut = mut}
+
+let type_of glob =
+  GlobalType (type_of glob.content, glob.mut)
+
+let load glob = glob.content
+let store glob v =
+  if glob.mut <> Mutable then raise NotMutable;
+  if Values.type_of v <> Values.type_of glob.content then raise Type;
+  glob.content <- v
diff --git a/interpreter/runtime/global.mli b/interpreter/runtime/global.mli
new file mode 100644
index 000000000..75c52faf6
--- /dev/null
+++ b/interpreter/runtime/global.mli
@@ -0,0 +1,14 @@
+open Types
+open Values
+
+type global
+type t = global
+
+exception Type
+exception NotMutable
+
+val alloc : global_type -> value -> global  (* raises Type *)
+val type_of : global -> global_type
+
+val load : global -> value
+val store : global -> value -> unit  (* raises Type, NotMutable *)
diff --git a/interpreter/runtime/instance.ml b/interpreter/runtime/instance.ml
new file mode 100644
index 000000000..6ac583742
--- /dev/null
+++ b/interpreter/runtime/instance.ml
@@ -0,0 +1,41 @@
+open Types
+
+type module_inst =
+{
+  types : func_type list;
+  funcs : func_inst list;
+  tables : table_inst list;
+  memories : memory_inst list;
+  globals : global_inst list;
+  exports : export_inst list;
+}
+
+and func_inst = module_inst ref Func.t
+and table_inst = Table.t
+and memory_inst = Memory.t
+and global_inst = Global.t
+and export_inst = Ast.name * extern
+
+and extern =
+  | ExternFunc of func_inst
+  | ExternTable of table_inst
+  | ExternMemory of memory_inst
+  | ExternGlobal of global_inst
+
+type Table.elem += FuncElem of func_inst
+
+
+(* Auxiliary functions *)
+
+let empty_module_inst =
+  { types = []; funcs = []; tables = []; memories = []; globals = [];
+    exports = [] }
+
+let extern_type_of = function
+  | ExternFunc func -> ExternFuncType (Func.type_of func)
+  | ExternTable tab -> ExternTableType (Table.type_of tab)
+  | ExternMemory mem -> ExternMemoryType (Memory.type_of mem)
+  | ExternGlobal glob -> ExternGlobalType (Global.type_of glob)
+
+let export inst name =
+  try Some (List.assoc name inst.exports) with Not_found -> None
diff --git a/interpreter/runtime/memory.ml b/interpreter/runtime/memory.ml
new file mode 100644
index 000000000..fd9783d93
--- /dev/null
+++ b/interpreter/runtime/memory.ml
@@ -0,0 +1,145 @@
+open Bigarray
+open Lib.Bigarray
+open Types
+open Values
+
+type size = int32  (* number of pages *)
+type address = int64
+type offset = int32
+
+type mem_size = Mem8 | Mem16 | Mem32
+type extension = SX | ZX
+
+type memory' = (int, int8_unsigned_elt, c_layout) Array1.t
+type memory = {mutable content : memory'; max : size option}
+type t = memory
+
+exception Type
+exception Bounds
+exception SizeOverflow
+exception SizeLimit
+exception OutOfMemory
+
+let page_size = 0x10000L (* 64 KiB *)
+
+let mem_size = function
+  | Mem8 -> 1
+  | Mem16 -> 2
+  | Mem32 -> 4
+
+let within_limits n = function
+  | None -> true
+  | Some max -> I32.le_u n max
+
+let create n =
+  if I32.gt_u n 0x10000l then raise SizeOverflow else
+  try
+    let size = Int64.(mul (of_int32 n) page_size) in
+    let mem = Array1_64.create Int8_unsigned C_layout size in
+    Array1.fill mem 0;
+    mem
+  with Out_of_memory -> raise OutOfMemory
+
+let alloc (MemoryType {min; max}) =
+  assert (within_limits min max);
+  {content = create min; max}
+
+let bound mem =
+  Array1_64.dim mem.content
+
+let size mem =
+  Int64.(to_int32 (div (bound mem) page_size))
+
+let type_of mem =
+  MemoryType {min = size mem; max = mem.max}
+
+let grow mem delta =
+  let old_size = size mem in
+  let new_size = Int32.add old_size delta in
+  if I32.gt_u old_size new_size then raise SizeOverflow else
+  if not (within_limits new_size mem.max) then raise SizeLimit else
+  let after = create new_size in
+  let dim = Array1_64.dim mem.content in
+  Array1.blit (Array1_64.sub mem.content 0L dim) (Array1_64.sub after 0L dim);
+  mem.content <- after
+
+let load_byte mem a =
+  try Array1_64.get mem.content a with Invalid_argument _ -> raise Bounds
+
+let store_byte mem a b =
+  try Array1_64.set mem.content a b with Invalid_argument _ -> raise Bounds
+
+let load_bytes mem a n =
+  let buf = Buffer.create n in
+  for i = 0 to n - 1 do
+    Buffer.add_char buf (Char.chr (load_byte mem Int64.(add a (of_int i))))
+  done;
+  Buffer.contents buf
+
+let store_bytes mem a bs =
+  for i = String.length bs - 1 downto 0 do
+    store_byte mem Int64.(add a (of_int i)) (Char.code bs.[i])
+  done
+
+let effective_address a o =
+  let ea = Int64.(add a (of_int32 o)) in
+  if I64.lt_u ea a then raise Bounds;
+  ea
+
+let loadn mem a o n =
+  assert (n > 0 && n <= 8);
+  let rec loop a n =
+    if n = 0 then 0L else begin
+      let x = Int64.(shift_left (loop (add a 1L) (n - 1)) 8) in
+      Int64.logor (Int64.of_int (load_byte mem a)) x
+    end
+  in loop (effective_address a o) n
+
+let storen mem a o n x =
+  assert (n > 0 && n <= 8);
+  let rec loop a n x =
+    if n > 0 then begin
+      Int64.(loop (add a 1L) (n - 1) (shift_right x 8));
+      store_byte mem a (Int64.to_int x land 0xff)
+    end
+  in loop (effective_address a o) n x
+
+let load_value mem a o t =
+  let n = loadn mem a o (Types.size t) in
+  match t with
+  | I32Type -> I32 (Int64.to_int32 n)
+  | I64Type -> I64 n
+  | F32Type -> F32 (F32.of_bits (Int64.to_int32 n))
+  | F64Type -> F64 (F64.of_bits n)
+
+let store_value mem a o v =
+  let x =
+    match v with
+    | I32 x -> Int64.of_int32 x
+    | I64 x -> x
+    | F32 x -> Int64.of_int32 (F32.to_bits x)
+    | F64 x -> F64.to_bits x
+  in storen mem a o (Types.size (Values.type_of v)) x
+
+let extend x n = function
+  | ZX -> x
+  | SX -> let sh = 64 - 8 * n in Int64.(shift_right (shift_left x sh) sh)
+
+let load_packed sz ext mem a o t =
+  assert (mem_size sz <= Types.size t);
+  let n = mem_size sz in
+  let x = extend (loadn mem a o n) n ext in
+  match t with
+  | I32Type -> I32 (Int64.to_int32 x)
+  | I64Type -> I64 x
+  | _ -> raise Type
+
+let store_packed sz mem a o v =
+  assert (mem_size sz <= Types.size (Values.type_of v));
+  let n = mem_size sz in
+  let x =
+    match v with
+    | I32 x -> Int64.of_int32 x
+    | I64 x -> x
+    | _ -> raise Type
+  in storen mem a o n x
diff --git a/interpreter/runtime/memory.mli b/interpreter/runtime/memory.mli
new file mode 100644
index 000000000..c5586e7b9
--- /dev/null
+++ b/interpreter/runtime/memory.mli
@@ -0,0 +1,44 @@
+open Types
+open Values
+
+type memory
+type t = memory
+
+type size = int32  (* number of pages *)
+type address = int64
+type offset = int32
+
+type mem_size = Mem8 | Mem16 | Mem32
+type extension = SX | ZX
+
+exception Type
+exception Bounds
+exception SizeOverflow
+exception SizeLimit
+exception OutOfMemory
+
+val page_size : int64
+val mem_size : mem_size -> int
+
+val alloc : memory_type -> memory (* raises SizeOverflow, OutOfMemory *)
+val type_of : memory -> memory_type
+val size : memory -> size
+val bound : memory -> address
+val grow : memory -> size -> unit
+  (* raises SizeLimit, SizeOverflow, OutOfMemory *)
+
+val load_byte : memory -> address -> int (* raises Bounds *)
+val store_byte : memory -> address -> int -> unit (* raises Bounds *)
+val load_bytes : memory -> address -> int -> string (* raises Bounds *)
+val store_bytes : memory -> address -> string -> unit (* raises Bounds *)
+
+val load_value :
+  memory -> address -> offset -> value_type -> value (* raises Bounds *)
+val store_value :
+  memory -> address -> offset -> value -> unit (* raises Bounds *)
+val load_packed :
+  mem_size -> extension -> memory -> address -> offset -> value_type -> value
+    (* raises Type, Bounds *)
+val store_packed :
+  mem_size -> memory -> address -> offset -> value -> unit
+    (* raises Type, Bounds *)
diff --git a/interpreter/exec/table.ml b/interpreter/runtime/table.ml
similarity index 81%
rename from interpreter/exec/table.ml
rename to interpreter/runtime/table.ml
index fd7c7f2ee..f48004d6c 100644
--- a/interpreter/exec/table.ml
+++ b/interpreter/runtime/table.ml
@@ -5,8 +5,6 @@ type index = int32
 
 type elem = ..
 type elem += Uninitialized
-type elem_type = Types.elem_type
-type 'a limits = 'a Types.limits
 
 type table' = elem array
 type table =
@@ -17,32 +15,30 @@ exception Bounds
 exception SizeOverflow
 exception SizeLimit
 
-let elem_type tab = tab.elem_type
-
 let within_limits size = function
   | None -> true
   | Some max -> I32.le_u size max
 
-let create' size =
+let create size =
   try Lib.Array32.make size Uninitialized
   with Invalid_argument _ -> raise Out_of_memory
 
-let create elem_type {min; max} =
+let alloc (TableType ({min; max}, elem_type)) =
   assert (within_limits min max);
-  {content = create' min; max; elem_type}
+  {content = create min; max; elem_type}
 
 let size tab =
   Lib.Array32.length tab.content
 
-let limits tab =
-  {min = size tab; max = tab.max}
+let type_of tab =
+  TableType ({min = size tab; max = tab.max}, tab.elem_type)
 
 let grow tab delta =
   let old_size = size tab in
   let new_size = Int32.add old_size delta in
   if I32.gt_u old_size new_size then raise SizeOverflow else
   if not (within_limits new_size tab.max) then raise SizeLimit else
-  let after = create' new_size in
+  let after = create new_size in
   Array.blit tab.content 0 after 0 (Array.length tab.content);
   tab.content <- after
 
diff --git a/interpreter/runtime/table.mli b/interpreter/runtime/table.mli
new file mode 100644
index 000000000..7956d986d
--- /dev/null
+++ b/interpreter/runtime/table.mli
@@ -0,0 +1,23 @@
+open Types
+
+type table
+type t = table
+
+type size = int32
+type index = int32
+
+type elem = ..
+type elem += Uninitialized
+
+exception Bounds
+exception SizeOverflow
+exception SizeLimit
+
+val alloc : table_type -> table
+val type_of : table -> table_type
+val size : table -> size
+val grow : table -> size -> unit (* raises SizeOverflow, SizeLimit *)
+
+val load : table -> index -> elem (* raises Bounds *)
+val store : table -> index -> elem -> unit (* raises Bounds *)
+val blit : table -> index -> elem list -> unit (* raises Bounds *)
diff --git a/interpreter/syntax/values.ml b/interpreter/runtime/values.ml
similarity index 100%
rename from interpreter/syntax/values.ml
rename to interpreter/runtime/values.ml
diff --git a/interpreter/script/import.ml b/interpreter/script/import.ml
index 5c7051be2..c9e65eafc 100644
--- a/interpreter/script/import.ml
+++ b/interpreter/script/import.ml
@@ -4,7 +4,7 @@ open Ast
 module Unknown = Error.Make ()
 exception Unknown = Unknown.Error  (* indicates unknown import name *)
 
-module Registry = Instance.ExportMap
+module Registry = Map.Make(struct type t = Ast.name let compare = compare end)
 let registry = ref Registry.empty
 
 let register name lookup = registry := Registry.add name lookup !registry
diff --git a/interpreter/script/import.mli b/interpreter/script/import.mli
index 7d29b5920..7919297e1 100644
--- a/interpreter/script/import.mli
+++ b/interpreter/script/import.mli
@@ -4,5 +4,5 @@ val link : Ast.module_ -> Instance.extern list (* raises Unknown *)
 
 val register :
   Ast.name ->
-  (Ast.name -> Types.external_type -> Instance.extern (* raise Not_found *)) ->
+  (Ast.name -> Types.extern_type -> Instance.extern (* raises Not_found *)) ->
   unit
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 936130d42..ebe308dd3 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -138,16 +138,16 @@ let harness =
 
 (* Context *)
 
+module NameMap = Map.Make(struct type t = Ast.name let compare = compare end)
 module Map = Map.Make(String)
-module ExportMap = Instance.ExportMap
 
-type exports = external_type ExportMap.t
+type exports = extern_type NameMap.t
 type modules = {mutable env : exports Map.t; mutable current : int}
 
 let exports m : exports =
   List.fold_left
-    (fun map exp -> ExportMap.add exp.it.name (export_type m exp) map)
-    ExportMap.empty m.it.exports
+    (fun map exp -> NameMap.add exp.it.name (export_type m exp) map)
+    NameMap.empty m.it.exports
 
 let modules () : modules = {env = Map.empty; current = 0}
 
@@ -168,7 +168,7 @@ let lookup (mods : modules) x_opt name at =
       raise (Eval.Crash (at, 
         if x_opt = None then "no module defined within script"
         else "unknown module " ^ of_var_opt mods x_opt ^ " within script"))
-  in try ExportMap.find name exports with Not_found ->
+  in try NameMap.find name exports with Not_found ->
     raise (Eval.Crash (at, "unknown export \"" ^
       string_of_name name ^ "\" within module"))
 
@@ -330,7 +330,7 @@ let of_action mods act =
     "call(" ^ of_var_opt mods x_opt ^ ", " ^ of_name name ^ ", " ^
       "[" ^ String.concat ", " (List.map of_literal lits) ^ "])",
     (match lookup mods x_opt name act.at with
-    | ExternalFuncType ft when not (is_js_func_type ft) ->
+    | ExternFuncType ft when not (is_js_func_type ft) ->
       let FuncType (_, out) = ft in
       Some (of_wrapper mods x_opt name (invoke ft lits), out)
     | _ -> None
@@ -338,7 +338,7 @@ let of_action mods act =
   | Get (x_opt, name) ->
     "get(" ^ of_var_opt mods x_opt ^ ", " ^ of_name name ^ ")",
     (match lookup mods x_opt name act.at with
-    | ExternalGlobalType gt when not (is_js_global_type gt) ->
+    | ExternGlobalType gt when not (is_js_global_type gt) ->
       let GlobalType (t, _) = gt in
       Some (of_wrapper mods x_opt name (get gt), [t])
     | _ -> None
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index 59326a246..d1ec2866b 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -210,10 +210,10 @@ let print_import m im =
   let open Types in
   let category, annotation =
     match Ast.import_type m im with
-    | ExternalFuncType t -> "func", string_of_func_type t
-    | ExternalTableType t -> "table", string_of_table_type t
-    | ExternalMemoryType t -> "memory", string_of_memory_type t
-    | ExternalGlobalType t -> "global", string_of_global_type t
+    | ExternFuncType t -> "func", string_of_func_type t
+    | ExternTableType t -> "table", string_of_table_type t
+    | ExternMemoryType t -> "memory", string_of_memory_type t
+    | ExternGlobalType t -> "global", string_of_global_type t
   in
   Printf.printf "  import %s \"%s\" \"%s\" : %s\n"
     category (Ast.string_of_name im.it.Ast.module_name)
@@ -223,10 +223,10 @@ let print_export m ex =
   let open Types in
   let category, annotation =
     match Ast.export_type m ex with
-    | ExternalFuncType t -> "func", string_of_func_type t
-    | ExternalTableType t -> "table", string_of_table_type t
-    | ExternalMemoryType t -> "memory", string_of_memory_type t
-    | ExternalGlobalType t -> "global", string_of_global_type t
+    | ExternFuncType t -> "func", string_of_func_type t
+    | ExternTableType t -> "table", string_of_table_type t
+    | ExternMemoryType t -> "memory", string_of_memory_type t
+    | ExternGlobalType t -> "global", string_of_global_type t
   in
   Printf.printf "  export %s \"%s\" : %s\n"
     category (Ast.string_of_name ex.it.Ast.name) annotation
@@ -252,8 +252,8 @@ module Map = Map.Make(String)
 let quote : script ref = ref []
 let scripts : script Map.t ref = ref Map.empty
 let modules : Ast.module_ Map.t ref = ref Map.empty
-let instances : Instance.instance Map.t ref = ref Map.empty
-let registry : Instance.instance Map.t ref = ref Map.empty
+let instances : Instance.module_inst Map.t ref = ref Map.empty
+let registry : Instance.module_inst Map.t ref = ref Map.empty
 
 let bind map x_opt y =
   let map' =
@@ -298,7 +298,7 @@ let run_action act =
     trace ("Invoking function \"" ^ Ast.string_of_name name ^ "\"...");
     let inst = lookup_instance x_opt act.at in
     (match Instance.export inst name with
-    | Some (Instance.ExternalFunc f) ->
+    | Some (Instance.ExternFunc f) ->
       Eval.invoke f (List.map (fun v -> v.it) vs)
     | Some _ -> Assert.error act.at "export is not a function"
     | None -> Assert.error act.at "undefined export"
@@ -308,7 +308,7 @@ let run_action act =
     trace ("Getting global \"" ^ Ast.string_of_name name ^ "\"...");
     let inst = lookup_instance x_opt act.at in
     (match Instance.export inst name with
-    | Some (Instance.ExternalGlobal v) -> [v]
+    | Some (Instance.ExternGlobal gl) -> [Global.load gl]
     | Some _ -> Assert.error act.at "export is not a global"
     | None -> Assert.error act.at "undefined export"
     )
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index 48ce87f74..e2efa7ee8 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -212,32 +212,35 @@ let empty_module =
 
 open Source
 
-let import_type (m : module_) (im : import) : external_type =
+let func_type_for (m : module_) (x : var) : func_type =
+  (Lib.List32.nth m.it.types x.it).it
+
+let import_type (m : module_) (im : import) : extern_type =
   let {idesc; _} = im.it in
   match idesc.it with
-  | FuncImport x -> ExternalFuncType (Lib.List32.nth m.it.types x.it).it
-  | TableImport t -> ExternalTableType t
-  | MemoryImport t -> ExternalMemoryType t
-  | GlobalImport t -> ExternalGlobalType t
+  | FuncImport x -> ExternFuncType (func_type_for m x)
+  | TableImport t -> ExternTableType t
+  | MemoryImport t -> ExternMemoryType t
+  | GlobalImport t -> ExternGlobalType t
 
-let export_type (m : module_) (ex : export) : external_type =
+let export_type (m : module_) (ex : export) : extern_type =
   let {edesc; _} = ex.it in
   let its = List.map (import_type m) m.it.imports in
   let open Lib.List32 in
   match edesc.it with
   | FuncExport x ->
     let fts =
-      funcs its @ List.map (fun f -> (nth m.it.types f.it.ftype.it).it) m.it.funcs
-    in ExternalFuncType (nth fts x.it)
+      funcs its @ List.map (fun f -> func_type_for m f.it.ftype) m.it.funcs
+    in ExternFuncType (nth fts x.it)
   | TableExport x ->
     let tts = tables its @ List.map (fun t -> t.it.ttype) m.it.tables in
-    ExternalTableType (nth tts x.it)
+    ExternTableType (nth tts x.it)
   | MemoryExport x ->
     let mts = memories its @ List.map (fun m -> m.it.mtype) m.it.memories in
-    ExternalMemoryType (nth mts x.it)
+    ExternMemoryType (nth mts x.it)
   | GlobalExport x ->
     let gts = globals its @ List.map (fun g -> g.it.gtype) m.it.globals in
-    ExternalGlobalType (nth gts x.it)
+    ExternGlobalType (nth gts x.it)
 
 let string_of_name n =
   let b = Buffer.create 16 in
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index 9dc6e25de..f708e4b89 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -10,11 +10,11 @@ type mutability = Immutable | Mutable
 type table_type = TableType of Int32.t limits * elem_type
 type memory_type = MemoryType of Int32.t limits
 type global_type = GlobalType of value_type * mutability
-type external_type =
-  | ExternalFuncType of func_type
-  | ExternalTableType of table_type
-  | ExternalMemoryType of memory_type
-  | ExternalGlobalType of global_type
+type extern_type =
+  | ExternFuncType of func_type
+  | ExternTableType of table_type
+  | ExternMemoryType of memory_type
+  | ExternGlobalType of global_type
 
 
 (* Attributes *)
@@ -24,27 +24,46 @@ let size = function
   | I64Type | F64Type -> 8
 
 
-(* Filters *)
+(* Subtyping *)
+
+let match_limits lim1 lim2 =
+  I32.ge_u lim1.min lim2.min &&
+  match lim1.max, lim2.max with
+  | _, None -> true
+  | None, Some _ -> false
+  | Some i, Some j -> I32.le_u i j
+
+let match_func_type ft1 ft2 =
+  ft1 = ft2
+
+let match_table_type (TableType (lim1, et1)) (TableType (lim2, et2)) =
+  et1 = et2 && match_limits lim1 lim2
 
-let rec funcs = function
-  | [] -> []
-  | ExternalFuncType ft :: ets -> ft :: funcs ets
-  | _ :: ets -> funcs ets
+let match_memory_type (MemoryType lim1) (MemoryType lim2) =
+  match_limits lim1 lim2
 
-let rec tables = function
-  | [] -> []
-  | ExternalTableType tt :: ets -> tt :: tables ets
-  | _ :: ets -> tables ets
+let match_global_type gt1 gt2 =
+  gt1 = gt2
 
-let rec memories = function
-  | [] -> []
-  | ExternalMemoryType mt :: ets -> mt :: memories ets
-  | _ :: ets -> memories ets
+let match_extern_type et1 et2 =
+  match et1, et2 with
+  | ExternFuncType ft1, ExternFuncType ft2 -> match_func_type ft1 ft2
+  | ExternTableType tt1, ExternTableType tt2 -> match_table_type tt1 tt2
+  | ExternMemoryType mt1, ExternMemoryType mt2 -> match_memory_type mt1 mt2
+  | ExternGlobalType gt1, ExternGlobalType gt2 -> match_global_type gt1 gt2
+  | _, _ -> false
 
-let rec globals = function
-  | [] -> []
-  | ExternalGlobalType ft :: ets -> ft :: globals ets
-  | _ :: ets -> globals ets
+
+(* Filters *)
+
+let funcs =
+  Lib.List.map_filter (function ExternFuncType t -> Some t | _ -> None)
+let tables =
+  Lib.List.map_filter (function ExternTableType t -> Some t | _ -> None)
+let memories =
+  Lib.List.map_filter (function ExternMemoryType t -> Some t | _ -> None)
+let globals =
+  Lib.List.map_filter (function ExternGlobalType t -> Some t | _ -> None)
 
 
 (* String conversion *)
@@ -81,3 +100,9 @@ let string_of_stack_type ts =
 
 let string_of_func_type (FuncType (ins, out)) =
   string_of_stack_type ins ^ " -> " ^ string_of_stack_type out
+
+let string_of_extern_type = function
+  | ExternFuncType ft -> "func " ^ string_of_func_type ft
+  | ExternTableType tt -> "table " ^ string_of_table_type tt
+  | ExternMemoryType mt -> "memory " ^ string_of_memory_type mt
+  | ExternGlobalType gt -> "global " ^ string_of_global_type gt
diff --git a/interpreter/text/parse.mli b/interpreter/text/parse.mli
index 4530edfae..89f8e5802 100644
--- a/interpreter/text/parse.mli
+++ b/interpreter/text/parse.mli
@@ -5,7 +5,7 @@ type 'a start =
 
 exception Syntax of Source.region * string
 
-val parse : string -> Lexing.lexbuf -> 'a start -> 'a (* raise Syntax *)
+val parse : string -> Lexing.lexbuf -> 'a start -> 'a (* raises Syntax *)
 
-val string_to_script : string -> Script.script (* raise Syntax *)
-val string_to_module : string -> Script.definition (* raise Syntax *)
+val string_to_script : string -> Script.script (* raises Syntax *)
+val string_to_module : string -> Script.definition (* raises Syntax *)
diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index 79b8eb632..1be774ba1 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -82,6 +82,13 @@ struct
     | x::xs' -> index_where' p xs' (i+1)
 
   let index_of x = index_where ((=) x)
+
+  let rec map_filter f = function
+    | [] -> []
+    | x::xs ->
+      match f x with
+      | None -> map_filter f xs
+      | Some y -> y :: map_filter f xs
 end
 
 module List32 =
diff --git a/interpreter/util/lib.mli b/interpreter/util/lib.mli
index 06573d8e8..5c3b80157 100644
--- a/interpreter/util/lib.mli
+++ b/interpreter/util/lib.mli
@@ -9,22 +9,23 @@ module List :
 sig
   val make : int -> 'a -> 'a list
   val table : int -> (int -> 'a) -> 'a list
-  val take : int -> 'a list -> 'a list (* raise Failure *)
-  val drop : int -> 'a list -> 'a list (* raise Failure *)
+  val take : int -> 'a list -> 'a list (* raises Failure *)
+  val drop : int -> 'a list -> 'a list (* raises Failure *)
 
-  val last : 'a list -> 'a (* raise Failure *)
-  val split_last : 'a list -> 'a list * 'a (* raise Failure *)
+  val last : 'a list -> 'a (* raises Failure *)
+  val split_last : 'a list -> 'a list * 'a (* raises Failure *)
 
   val index_of : 'a -> 'a list -> int option
   val index_where : ('a -> bool) -> 'a list -> int option
+  val map_filter : ('a -> 'b option) -> 'a list -> 'b list
 end
 
 module List32 :
 sig
   val length : 'a list -> int32
-  val nth : 'a list -> int32 -> 'a (* raise Failure *)
-  val take : int32 -> 'a list -> 'a list (* raise Failure *)
-  val drop : int32 -> 'a list -> 'a list (* raise Failure *)
+  val nth : 'a list -> int32 -> 'a (* raises Failure *)
+  val take : int32 -> 'a list -> 'a list (* raises Failure *)
+  val drop : int32 -> 'a list -> 'a list (* raises Failure *)
 end
 
 module Array32 :
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 385f2c344..3bdb5e282 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -16,7 +16,6 @@ let require b at s = if not b then error at s
 
 type context =
 {
-  module_ : module_;
   types : func_type list;
   funcs : func_type list;
   tables : table_type list;
@@ -27,8 +26,8 @@ type context =
   labels : stack_type list;
 }
 
-let context m =
-  { module_ = m; types = []; funcs = []; tables = []; memories = [];
+let empty_context =
+  { types = []; funcs = []; tables = []; memories = [];
     globals = []; locals = []; results = []; labels = [] }
 
 let lookup category list x =
@@ -37,11 +36,11 @@ let lookup category list x =
 
 let type_ (c : context) x = lookup "type" c.types x
 let func (c : context) x = lookup "function" c.funcs x
-let local (c : context) x = lookup "local" c.locals x
-let global (c : context) x = lookup "global" c.globals x
-let label (c : context) x = lookup "label" c.labels x
 let table (c : context) x = lookup "table" c.tables x
 let memory (c : context) x = lookup "memory" c.memories x
+let global (c : context) x = lookup "global" c.globals x
+let local (c : context) x = lookup "local" c.locals x
+let label (c : context) x = lookup "label" c.labels x
 
 
 (* Stack typing *)
@@ -306,6 +305,43 @@ and check_block (c : context) (es : instr list) (ts : stack_type) at =
      " but stack has " ^ string_of_infer_types (snd s))
 
 
+(* Types *)
+
+let check_limits {min; max} at =
+  match max with
+  | None -> ()
+  | Some max ->
+    require (I32.le_u min max) at
+      "size minimum must not be greater than maximum"
+
+let check_value_type (t : value_type) at =
+  ()
+
+let check_func_type (ft : func_type) at =
+  let FuncType (ins, out) = ft in
+  List.iter (fun t -> check_value_type t at) ins;
+  List.iter (fun t -> check_value_type t at) out;
+  check_arity (List.length out) at
+
+let check_table_type (tt : table_type) at =
+  let TableType (lim, _) = tt in
+  check_limits lim at
+
+let check_memory_size (sz : I32.t) at =
+  require (I32.le_u sz 65536l) at
+    "memory size must be at most 65536 pages (4GiB)"
+
+let check_memory_type (mt : memory_type) at =
+  let MemoryType lim = mt in
+  check_limits lim at;
+  check_memory_size lim.min at;
+  Lib.Option.app (fun max -> check_memory_size max at) lim.max
+
+let check_global_type (gt : global_type) at =
+  let GlobalType (t, mut) = gt in
+  check_value_type t at
+
+
 (* Functions & Constants *)
 
 (*
@@ -321,8 +357,7 @@ and check_block (c : context) (es : instr list) (ts : stack_type) at =
  *)
 
 let check_type (t : type_) =
-  let FuncType (ins, out) = t.it in
-  check_arity (List.length out) t.at
+  check_func_type t.it t.at
 
 let check_func (c : context) (f : func) =
   let {ftype; locals; body} = f.it in
@@ -345,30 +380,10 @@ let check_const (c : context) (const : const) (t : value_type) =
 
 (* Tables, Memories, & Globals *)
 
-let check_table_type (t : table_type) at =
-  let TableType ({min; max}, _) = t in
-  match max with
-  | None -> ()
-  | Some max ->
-    require (I32.le_u min max) at
-      "table size minimum must not be greater than maximum"
-
 let check_table (c : context) (tab : table) =
   let {ttype} = tab.it in
   check_table_type ttype tab.at
 
-let check_memory_type (t : memory_type) at =
-  let MemoryType {min; max} = t in
-  require (I32.le_u min 65536l) at
-    "memory size must be at most 65536 pages (4GiB)";
-  match max with
-  | None -> ()
-  | Some max ->
-    require (I32.le_u max 65536l) at
-      "memory size must be at most 65536 pages (4GiB)";
-    require (I32.le_u min max) at
-      "memory size minimum must not be greater than maximum"
-
 let check_memory (c : context) (mem : memory) =
   let {mtype} = mem.it in
   check_memory_type mtype mem.at
@@ -403,15 +418,18 @@ let check_import (im : import) (c : context) : context =
   match idesc.it with
   | FuncImport x ->
     {c with funcs = type_ c x :: c.funcs}
-  | TableImport t ->
-    check_table_type t idesc.at; {c with tables = t :: c.tables}
-  | MemoryImport t ->
-    check_memory_type t idesc.at; {c with memories = t :: c.memories}
-  | GlobalImport t ->
-    let GlobalType (_, mut) = t in
+  | TableImport tt ->
+    check_table_type tt idesc.at;
+    {c with tables = tt :: c.tables}
+  | MemoryImport mt ->
+    check_memory_type mt idesc.at;
+    {c with memories = mt :: c.memories}
+  | GlobalImport gt ->
+    check_global_type gt idesc.at;
+    let GlobalType (_, mut) = gt in
     require (mut = Immutable) idesc.at
       "mutable globals cannot be imported (yet)";
-    {c with globals = t :: c.globals}
+    {c with globals = gt :: c.globals}
 
 module NameSet = Set.Make(struct type t = Ast.name let compare = compare end)
 
@@ -436,7 +454,7 @@ let check_module (m : module_) =
   in
   let c0 =
     List.fold_right check_import imports
-      {(context m) with types = List.map (fun ty -> ty.it) types}
+      {empty_context with types = List.map (fun ty -> ty.it) types}
   in
   let c1 =
     { c0 with
diff --git a/interpreter/valid/valid.mli b/interpreter/valid/valid.mli
index 3db17e284..5827ae56e 100644
--- a/interpreter/valid/valid.mli
+++ b/interpreter/valid/valid.mli
@@ -1,3 +1,3 @@
 exception Invalid of Source.region * string
 
-val check_module : Ast.module_ -> unit (* raise Invalid *)
+val check_module : Ast.module_ -> unit (* raises Invalid *)
diff --git a/test/core/imports.wast b/test/core/imports.wast
index cb1a5fe2a..e9a28dcdc 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -106,92 +106,92 @@
 
 (assert_unlinkable
   (module (import "test" "func" (func (param i32))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func" (func (result i32))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func" (func (param i32) (result i32))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func-i32" (func)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func-i32" (func (result i32))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func-i32" (func (param f32))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func-i32" (func (param i64))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func-i32" (func (param i32) (result i32))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func->i32" (func)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func->i32" (func (param i32))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func->i32" (func (result f32))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func->i32" (func (result i64))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func->i32" (func (param i32) (result i32))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func-i32->i32" (func)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func-i32->i32" (func (param i32))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "func-i32->i32" (func (result i32))))
-  "type mismatch"
+  "incompatible import type"
 )
 
 (assert_unlinkable
   (module (import "test" "global-i32" (func (result i32))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "table-10-inf" (func)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "memory-2-inf" (func)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "global" (func)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "table" (func)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "memory" (func)))
-  "type mismatch"
+  "incompatible import type"
 )
 
 
@@ -234,27 +234,27 @@
 
 (assert_unlinkable
   (module (import "test" "func" (global i32)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "table-10-inf" (global i32)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "memory-2-inf" (global i32)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "print" (global i32)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "table" (global i32)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "memory" (global i32)))
-  "type mismatch"
+  "incompatible import type"
 )
 
 
@@ -330,36 +330,36 @@
 
 (assert_unlinkable
   (module (import "test" "table-10-inf" (table 12 anyfunc)))
-  "actual size smaller than declared"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "table-10-inf" (table 10 20 anyfunc)))
-  "maximum size larger than declared"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "table" (table 12 anyfunc)))
-  "actual size smaller than declared"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "table" (table 10 15 anyfunc)))
-  "maximum size larger than declared"
+  "incompatible import type"
 )
 
 (assert_unlinkable
   (module (import "test" "func" (table 10 anyfunc)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "global-i32" (table 10 anyfunc)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "memory-2-inf" (table 10 anyfunc)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "print" (table 10 anyfunc)))
-  "type mismatch"
+  "incompatible import type"
 )
 
 
@@ -423,53 +423,53 @@
 
 (assert_unlinkable
   (module (import "test" "memory-2-inf" (memory 3)))
-  "actual size smaller than declared"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "memory-2-inf" (memory 2 3)))
-  "maximum size larger than declared"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "memory" (memory 2)))
-  "actual size smaller than declared"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "memory" (memory 1 1)))
-  "maximum size larger than declared"
+  "incompatible import type"
 )
 
 (assert_unlinkable
   (module (import "test" "func-i32" (memory 1)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "global-i32" (memory 1)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "test" "table-10-inf" (memory 1)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "print" (memory 1)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "global" (memory 1)))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "table" (memory 1)))
-  "type mismatch"
+  "incompatible import type"
 )
 
 (assert_unlinkable
   (module (import "spectest" "memory" (memory 2)))
-  "actual size smaller than declared"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "spectest" "memory" (memory 1 1)))
-  "maximum size larger than declared"
+  "incompatible import type"
 )
 
 (module
diff --git a/test/core/linking.wast b/test/core/linking.wast
index 6a7dc3653..b2f0dd3db 100644
--- a/test/core/linking.wast
+++ b/test/core/linking.wast
@@ -26,11 +26,11 @@
 (register "reexport_f")
 (assert_unlinkable
   (module (import "reexport_f" "print" (func (param i64))))
-  "type mismatch"
+  "incompatible import type"
 )
 (assert_unlinkable
   (module (import "reexport_f" "print" (func (param i32) (result i32))))
-  "type mismatch"
+  "incompatible import type"
 )
 
 
@@ -162,6 +162,14 @@
   (func $f)
 )
 
+(module $G1 (global (export "g") i32 (i32.const 5)))
+(register "G1" $G1)
+(module $G2
+  (global (import "G1" "g") i32)
+  (global (export "g") i32 (get_global 0))
+)
+(assert_return (get $G2 "g") (i32.const 5))
+
 (assert_unlinkable
   (module
     (table (import "Mt" "tab") 0 anyfunc)
diff --git a/test/core/memory.wast b/test/core/memory.wast
index 346d8f8fb..b49ac4b2b 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -129,7 +129,7 @@
 
 (assert_invalid
   (module (memory 1 0))
-  "memory size minimum must not be greater than maximum"
+  "size minimum must not be greater than maximum"
 )
 (assert_invalid
   (module (memory 65537))

From 62e01e2298d535a1773b4919b1f408c57b0b4e8e Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 26 Sep 2017 18:12:13 +0200
Subject: [PATCH 089/329] [spec] Typo

---
 document/core/valid/types.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 8fbff90fc..76c6c7021 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -114,7 +114,7 @@ Global Types
 :math:`\mut~\valtype`
 .....................
 
-* Then the global type is valid.
+* The global type is valid.
 
 .. math::
    \frac{

From 881d85dc3426b5c6b276b5cd36a96f9d110ed824 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 4 Oct 2017 11:44:46 +0200
Subject: [PATCH 090/329] [interpreter] values should live in syntax/ dir

---
 interpreter/{runtime => syntax}/values.ml | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename interpreter/{runtime => syntax}/values.ml (100%)

diff --git a/interpreter/runtime/values.ml b/interpreter/syntax/values.ml
similarity index 100%
rename from interpreter/runtime/values.ml
rename to interpreter/syntax/values.ml

From ad2fe24c7350ecba9dd804c91a7a38d79a373a22 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 4 Oct 2017 13:10:15 +0200
Subject: [PATCH 091/329] [interpreter] Update winmake.bat

---
 interpreter/winmake.bat | 170 ++++++++++++++++++++--------------------
 1 file changed, 87 insertions(+), 83 deletions(-)

diff --git a/interpreter/winmake.bat b/interpreter/winmake.bat
index 634fbd390..bc915bc24 100644
--- a/interpreter/winmake.bat
+++ b/interpreter/winmake.bat
@@ -1,88 +1,92 @@
 rem Auto-generated from Makefile!
 set NAME=wasm
 if '%1' neq '' set NAME=%1
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/numeric_error.cmo exec/numeric_error.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/int.cmo exec/int.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i32.cmo exec/i32.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/float.cmo exec/float.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/types.cmo syntax/types.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f32.cmo exec/f32.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f64.cmo exec/f64.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i64.cmo exec/i64.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/values.cmo syntax/values.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/lib.cmi util/lib.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/memory.cmi exec/memory.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/source.cmi util/source.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/ast.cmo syntax/ast.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/table.cmi exec/table.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/instance.cmo exec/instance.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/eval.cmi exec/eval.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/utf8.cmi binary/utf8.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host -I util -I binary -I valid -I syntax -I script -I text -I main -I exec -o host/env.cmo host/env.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I main -I util -I binary -I valid -I syntax -I host -I script -I text -I exec -o main/flags.cmo main/flags.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/import.cmi script/import.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/run.cmi script/run.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I host -I util -I binary -I valid -I syntax -I script -I text -I main -I exec -o host/spectest.cmo host/spectest.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I main -I util -I binary -I valid -I syntax -I host -I script -I text -I exec -o main/main.cmo main/main.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I main -I util -I binary -I valid -I syntax -I host -I script -I text -I exec -o main/main.d.cmo main/main.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/error.cmi util/error.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/script.cmo script/script.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/decode.cmi binary/decode.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/encode.cmi binary/encode.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/js.cmi script/js.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/parse.cmi text/parse.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/print.cmi text/print.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I valid -I util -I binary -I syntax -I host -I script -I text -I main -I exec -o valid/valid.cmi valid/valid.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -I binary -I valid -I syntax -I script -I text -I main -I exec -o host/env.d.cmo host/env.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I main -I util -I binary -I valid -I syntax -I host -I script -I text -I exec -o main/flags.d.cmo main/flags.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/import.d.cmo script/import.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/run.d.cmo script/run.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I host -I util -I binary -I valid -I syntax -I script -I text -I main -I exec -o host/spectest.d.cmo host/spectest.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/utf8.d.cmo binary/utf8.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/eval_numeric.cmi exec/eval_numeric.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i64_convert.cmi exec/i64_convert.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/eval.d.cmo exec/eval.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/instance.d.cmo exec/instance.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/source.d.cmo util/source.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/types.d.cmo syntax/types.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/values.d.cmo syntax/values.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f32_convert.cmi exec/f32_convert.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f64_convert.cmi exec/f64_convert.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i32_convert.cmi exec/i32_convert.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/ast.d.cmo syntax/ast.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/error.d.cmo util/error.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/eval_numeric.d.cmo exec/eval_numeric.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i32.d.cmo exec/i32.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i64.d.cmo exec/i64.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i64_convert.d.cmo exec/i64_convert.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/lib.d.cmo util/lib.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/memory.d.cmo exec/memory.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/numeric_error.d.cmo exec/numeric_error.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/table.d.cmo exec/table.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f32.d.cmo exec/f32.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f64.d.cmo exec/f64.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/float.d.cmo exec/float.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/int.d.cmo exec/int.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f32_convert.d.cmo exec/f32_convert.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/f64_convert.d.cmo exec/f64_convert.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I exec -I util -I binary -I valid -I syntax -I host -I script -I text -I main -o exec/i32_convert.d.cmo exec/i32_convert.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/operators.cmo syntax/operators.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/numeric_error.cmo exec/numeric_error.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/int.cmo exec/int.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o util/lib.cmi util/lib.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/i32.cmo exec/i32.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/float.cmo exec/float.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I syntax -I util -I binary -I valid -I runtime -I host -I script -I text -I main -I exec -o syntax/types.cmo syntax/types.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/f32.cmo exec/f32.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/f64.cmo exec/f64.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/i64.cmo exec/i64.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I syntax -I util -I binary -I valid -I runtime -I host -I script -I text -I main -I exec -o syntax/values.cmo syntax/values.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I runtime -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o runtime/memory.cmi runtime/memory.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o util/source.cmi util/source.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I syntax -I util -I binary -I valid -I runtime -I host -I script -I text -I main -I exec -o syntax/ast.cmo syntax/ast.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I runtime -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o runtime/func.cmi runtime/func.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I runtime -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o runtime/global.cmi runtime/global.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I runtime -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o runtime/table.cmi runtime/table.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I runtime -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o runtime/instance.cmo runtime/instance.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/eval.cmi exec/eval.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I binary -I util -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o binary/utf8.cmi binary/utf8.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I host -I util -I binary -I valid -I syntax -I runtime -I script -I text -I main -I exec -o host/env.cmo host/env.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I main -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I exec -o main/flags.cmo main/flags.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I script -I util -I binary -I valid -I syntax -I runtime -I host -I text -I main -I exec -o script/import.cmi script/import.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I script -I util -I binary -I valid -I syntax -I runtime -I host -I text -I main -I exec -o script/run.cmi script/run.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I host -I util -I binary -I valid -I syntax -I runtime -I script -I text -I main -I exec -o host/spectest.cmo host/spectest.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I main -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I exec -o main/main.cmo main/main.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I main -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I exec -o main/main.d.cmo main/main.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o util/error.cmi util/error.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I script -I util -I binary -I valid -I syntax -I runtime -I host -I text -I main -I exec -o script/script.cmo script/script.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I binary -I util -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o binary/decode.cmi binary/decode.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I binary -I util -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o binary/encode.cmi binary/encode.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I script -I util -I binary -I valid -I syntax -I runtime -I host -I text -I main -I exec -o script/js.cmi script/js.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/parse.cmi text/parse.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/print.cmi text/print.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I valid -I util -I binary -I syntax -I runtime -I host -I script -I text -I main -I exec -o valid/valid.cmi valid/valid.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I host -I util -I binary -I valid -I syntax -I runtime -I script -I text -I main -I exec -o host/env.d.cmo host/env.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I main -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I exec -o main/flags.d.cmo main/flags.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I script -I util -I binary -I valid -I syntax -I runtime -I host -I text -I main -I exec -o script/import.d.cmo script/import.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I script -I util -I binary -I valid -I syntax -I runtime -I host -I text -I main -I exec -o script/run.d.cmo script/run.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I host -I util -I binary -I valid -I syntax -I runtime -I script -I text -I main -I exec -o host/spectest.d.cmo host/spectest.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I binary -I util -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o binary/utf8.d.cmo binary/utf8.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/eval_numeric.cmi exec/eval_numeric.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/i64_convert.cmi exec/i64_convert.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/eval.d.cmo exec/eval.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I runtime -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o runtime/func.d.cmo runtime/func.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I runtime -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o runtime/instance.d.cmo runtime/instance.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o util/source.d.cmo util/source.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I syntax -I util -I binary -I valid -I runtime -I host -I script -I text -I main -I exec -o syntax/types.d.cmo syntax/types.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I syntax -I util -I binary -I valid -I runtime -I host -I script -I text -I main -I exec -o syntax/values.d.cmo syntax/values.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/f32_convert.cmi exec/f32_convert.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/f64_convert.cmi exec/f64_convert.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/i32_convert.cmi exec/i32_convert.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I syntax -I util -I binary -I valid -I runtime -I host -I script -I text -I main -I exec -o syntax/ast.d.cmo syntax/ast.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o util/error.d.cmo util/error.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/eval_numeric.d.cmo exec/eval_numeric.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I runtime -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o runtime/global.d.cmo runtime/global.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/i32.d.cmo exec/i32.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/i64.d.cmo exec/i64.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/i64_convert.d.cmo exec/i64_convert.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o util/lib.d.cmo util/lib.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I runtime -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o runtime/memory.d.cmo runtime/memory.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/numeric_error.d.cmo exec/numeric_error.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I runtime -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o runtime/table.d.cmo runtime/table.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/f32.d.cmo exec/f32.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/f64.d.cmo exec/f64.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/float.d.cmo exec/float.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/int.d.cmo exec/int.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/f32_convert.d.cmo exec/f32_convert.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/f64_convert.d.cmo exec/f64_convert.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I exec -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -o exec/i32_convert.d.cmo exec/i32_convert.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I syntax -I util -I binary -I valid -I runtime -I host -I script -I text -I main -I exec -o syntax/operators.cmo syntax/operators.ml
 ocamlyacc text/parser.mly
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/parser.cmi text/parser.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/lexer.cmi text/lexer.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/sexpr.cmi util/sexpr.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/arrange.cmi text/arrange.mli
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/decode.d.cmo binary/decode.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I binary -I util -I valid -I syntax -I host -I script -I text -I main -I exec -o binary/encode.d.cmo binary/encode.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/js.d.cmo script/js.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/parse.d.cmo text/parse.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/print.d.cmo text/print.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I script -I util -I binary -I valid -I syntax -I host -I text -I main -I exec -o script/script.d.cmo script/script.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I valid -I util -I binary -I syntax -I host -I script -I text -I main -I exec -o valid/valid.d.cmo valid/valid.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I syntax -I util -I binary -I valid -I host -I script -I text -I main -I exec -o syntax/operators.d.cmo syntax/operators.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/parser.cmi text/parser.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/lexer.cmi text/lexer.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o util/sexpr.cmi util/sexpr.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/arrange.cmi text/arrange.mli
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I binary -I util -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o binary/decode.d.cmo binary/decode.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I binary -I util -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o binary/encode.d.cmo binary/encode.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I script -I util -I binary -I valid -I syntax -I runtime -I host -I text -I main -I exec -o script/js.d.cmo script/js.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/parse.d.cmo text/parse.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/print.d.cmo text/print.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I script -I util -I binary -I valid -I syntax -I runtime -I host -I text -I main -I exec -o script/script.d.cmo script/script.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I valid -I util -I binary -I syntax -I runtime -I host -I script -I text -I main -I exec -o valid/valid.d.cmo valid/valid.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I syntax -I util -I binary -I valid -I runtime -I host -I script -I text -I main -I exec -o syntax/operators.d.cmo syntax/operators.ml
 ocamllex.opt -q text/lexer.mll
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/lexer.d.cmo text/lexer.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/parser.d.cmo text/parser.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I text -I util -I binary -I valid -I syntax -I host -I script -I main -I exec -o text/arrange.d.cmo text/arrange.ml
-ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -bin-annot -I util -I binary -I valid -I syntax -I host -I script -I text -I main -I exec -o util/sexpr.d.cmo util/sexpr.ml
-ocamlc.opt bigarray.cma -g util/lib.d.cmo binary/utf8.d.cmo exec/float.d.cmo exec/f32.d.cmo exec/f64.d.cmo exec/numeric_error.d.cmo exec/int.d.cmo exec/i32.d.cmo exec/i64.d.cmo exec/i32_convert.d.cmo exec/f32_convert.d.cmo exec/i64_convert.d.cmo exec/f64_convert.d.cmo syntax/types.d.cmo syntax/values.d.cmo exec/memory.d.cmo util/source.d.cmo syntax/ast.d.cmo exec/eval_numeric.d.cmo exec/table.d.cmo exec/instance.d.cmo util/error.d.cmo exec/eval.d.cmo host/env.d.cmo host/spectest.d.cmo main/flags.d.cmo script/import.d.cmo binary/encode.d.cmo syntax/operators.d.cmo binary/decode.d.cmo script/script.d.cmo text/parser.d.cmo text/lexer.d.cmo text/parse.d.cmo script/js.d.cmo util/sexpr.d.cmo text/arrange.d.cmo text/print.d.cmo valid/valid.d.cmo script/run.d.cmo main/main.d.cmo -o main/main.d.byte
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/lexer.d.cmo text/lexer.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/parser.d.cmo text/parser.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/arrange.d.cmo text/arrange.ml
+ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o util/sexpr.d.cmo util/sexpr.ml
+ocamlc.opt bigarray.cma -g util/lib.d.cmo binary/utf8.d.cmo exec/float.d.cmo exec/f32.d.cmo exec/f64.d.cmo exec/numeric_error.d.cmo exec/int.d.cmo exec/i32.d.cmo exec/i64.d.cmo exec/i32_convert.d.cmo exec/f32_convert.d.cmo exec/i64_convert.d.cmo exec/f64_convert.d.cmo syntax/types.d.cmo syntax/values.d.cmo runtime/memory.d.cmo util/source.d.cmo syntax/ast.d.cmo exec/eval_numeric.d.cmo runtime/func.d.cmo runtime/global.d.cmo runtime/table.d.cmo runtime/instance.d.cmo util/error.d.cmo exec/eval.d.cmo host/env.d.cmo host/spectest.d.cmo main/flags.d.cmo script/import.d.cmo binary/encode.d.cmo syntax/operators.d.cmo binary/decode.d.cmo script/script.d.cmo text/parser.d.cmo text/lexer.d.cmo text/parse.d.cmo script/js.d.cmo util/sexpr.d.cmo text/arrange.d.cmo text/print.d.cmo valid/valid.d.cmo script/run.d.cmo main/main.d.cmo -o main/main.d.byte

From 8de14182ec8137ba862f5428afeff328e9e8e132 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 4 Oct 2017 14:18:22 +0200
Subject: [PATCH 092/329] [interpreter] Work around float parsing change in
 Ocaml

---
 interpreter/exec/float.ml | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/interpreter/exec/float.ml b/interpreter/exec/float.ml
index 75f276559..c189186e9 100644
--- a/interpreter/exec/float.ml
+++ b/interpreter/exec/float.ml
@@ -213,7 +213,8 @@ struct
       else
         Rep.logor x bare_nan
     else
-      let x = of_float (float_of_string s) in
+      let s' = String.concat "" (String.split_on_char '_' s) in
+      let x = of_float (float_of_string s') in
       if is_inf x then failwith "of_string" else x
 
   let of_string s =

From 4ef31648a6bfcfa8078cab0f1009a451d058d3ad Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Thu, 5 Oct 2017 15:36:51 -0700
Subject: [PATCH 093/329] Update install-ocaml script for ocaml 4.05.0 (#574)

---
 interpreter/meta/travis/install-ocaml.sh | 41 +++++++++++++++++-------
 1 file changed, 30 insertions(+), 11 deletions(-)

diff --git a/interpreter/meta/travis/install-ocaml.sh b/interpreter/meta/travis/install-ocaml.sh
index 044ef68e7..fa2c6c4f4 100755
--- a/interpreter/meta/travis/install-ocaml.sh
+++ b/interpreter/meta/travis/install-ocaml.sh
@@ -2,6 +2,20 @@
 
 set -e
 
+download_from_gh_archive() {
+  local project=$1;
+  local version=$2;
+  local sha=$3;
+
+  curl https://github.com/ocaml/${project}/archive/${version}.tar.gz -OL
+  CHECKSUM=$(shasum -a 256 ${version}.tar.gz | awk '{ print $1 }')
+  if [ ${CHECKSUM} != ${sha} ]; then
+    echo "Bad checksum ${project} download checksum!"
+    exit 1
+  fi
+  tar xfz ${version}.tar.gz
+}
+
 # Move to a location relative to the script so it runs
 # from anywhere. Go three levels down to get out of interpreter/
 # and into the top-level dir, since we'll run ocamlbuild
@@ -9,19 +23,24 @@ set -e
 # encounters ocaml's own build directory.
 cd $(dirname ${BASH_SOURCE[0]})/../../..
 
+PREFIX=$PWD/ocaml/install
+
 rm -rf ocaml
 mkdir ocaml
 cd ocaml
-curl https://wasm.storage.googleapis.com/ocaml-4.02.2.tar.gz -O
-CHECKSUM=$(shasum -a 256 ocaml-4.02.2.tar.gz | awk '{ print $1 }')
-if [ ${CHECKSUM} != \
-  9d50c91ba2d2040281c6e47254c0c2b74d91315dd85cc59b84c5138c3a7ba78c ]; then
-  echo "Bad checksum ocaml download checksum!"
-  exit 1
-fi
-tar xfz ocaml-4.02.2.tar.gz
-cd ocaml-4.02.2
-./configure -prefix $PWD/../install
+mkdir install
+
+download_from_gh_archive ocaml 4.05.0 e5d8a6f629020c580473d8afcfcb06c3966d01929f7b734f41dc0c737cd8ea3f
+cd ocaml-4.05.0
+./configure -prefix ${PREFIX}
 make world.opt
-mkdir ../install
+make install
+cd ..
+
+PATH=${PREFIX}/bin:${PATH}
+
+download_from_gh_archive ocamlbuild 0.11.0 1717edc841c9b98072e410f1b0bc8b84444b4b35ed3b4949ce2bec17c60103ee
+cd ocamlbuild-0.11.0
+make configure
+make
 make install

From 7b2e4cb7bf9ed7b70158a09fa9e9fcfb2ddadb35 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Mon, 9 Oct 2017 14:37:01 +0200
Subject: [PATCH 094/329] [interpreter] Fix for old Ocaml version

---
 interpreter/exec/float.ml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/interpreter/exec/float.ml b/interpreter/exec/float.ml
index c189186e9..3237959d8 100644
--- a/interpreter/exec/float.ml
+++ b/interpreter/exec/float.ml
@@ -213,7 +213,14 @@ struct
       else
         Rep.logor x bare_nan
     else
+      (* TODO: once we update past 4.02, replace buffer hack with this
       let s' = String.concat "" (String.split_on_char '_' s) in
+      *)
+      let buf = Buffer.create (String.length s) in
+      for i = 0 to String.length s - 1 do
+        if s.[i] <> '_' then Buffer.add_char buf s.[i]
+      done;
+      let s' = Buffer.contents buf in
       let x = of_float (float_of_string s') in
       if is_inf x then failwith "of_string" else x
 

From 087c4a243e5606583067a205b3fa9e6e49dd3ad3 Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Tue, 10 Oct 2017 11:53:48 +0200
Subject: [PATCH 095/329] [spec] Fix typo

---
 document/core/appendix/algorithm.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index c358a4a66..9191c864d 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -7,7 +7,7 @@ Validation Algorithm
 The specification of WebAssembly :ref:`validation <valid>` is purely *declarative*.
 It describes the constraints that must be met by a :ref:`module <valid-module>` or :ref:`instruction <valid-instr>` sequence to be valid.
 
-This section sketches the skeleton of a sound and complete *algorithm* for validating code, i.e., sequences of :ref:`instructions <syntax-instr>`, effectively.
+This section sketches the skeleton of a sound and complete *algorithm* for effectively validating code, i.e., sequences of :ref:`instructions <syntax-instr>`.
 (Other aspects of validation are straightforward to implement.)
 
 In fact, the algorithm is expressed over the flat sequence of opcodes as occurring in the :ref:`binary format <binary>`, and performs only a single pass over it.
@@ -64,7 +64,7 @@ However, these variables are not manipulated directly by the main checking funct
    func pop_opd() : val_type | Unknown =
      if (opds.size() = ctrls[0].height && ctrls[0].unreachable) return Unknown
      error_if(opds.size() = ctrls[0].height)
-     return opds.pop(type)
+     return opds.pop()
 
    func pop_opd(expect : val_type | Unknown) : val_type | Unknown =
      let actual = pop_opd()

From 89573ee3eabc690637deeb1b8dadec13a963ec30 Mon Sep 17 00:00:00 2001
From: Clemens Hammacher <clemensh@chromium.org>
Date: Tue, 10 Oct 2017 11:14:39 +0200
Subject: [PATCH 096/329] [test] Add tests for control instructions in
 unreachable code

The current tests allowed an implementation to either assume an else
block to be reachable, or inherit the reachability from it's parent
(which would be wrong).
This adds more tests for different control instructions in unreachable
code.
---
 test/core/unreached-invalid.wast | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/test/core/unreached-invalid.wast b/test/core/unreached-invalid.wast
index bd9d4f55b..e22b8b4c9 100644
--- a/test/core/unreached-invalid.wast
+++ b/test/core/unreached-invalid.wast
@@ -195,6 +195,18 @@
   ))
   "type mismatch"
 )
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-loop-after-unreachable
+    (unreachable) (loop (drop (i32.eqz (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-i32-loop-after-unreachable
+    (unreachable) (loop (result i32) (i32.eqz (nop)))
+  ))
+  "type mismatch"
+)
 (assert_invalid
   (module (func $type-unary-num-vs-num-after-unreachable
     (unreachable) (drop (i32.eqz (f32.const 1)))
@@ -249,6 +261,24 @@
   ))
   "type mismatch"
 )
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-if-after-unreachable
+    (unreachable) (if (i32.const 0) (then (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-else-after-unreachable
+    (unreachable) (if (i32.const 0) (then (nop)) (else (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-unary-num-vs-void-in-else-after-unreachable-if
+    (if (i32.const 0) (then (unreachable)) (else (drop (i32.eqz (nop)))))
+  ))
+  "type mismatch"
+)
 
 (assert_invalid
   (module (func $type-unary-num-vs-void-after-nested-unreachable

From 9fa2bf2e68b8c6d96db4979fcc1c36c0a13fc8aa Mon Sep 17 00:00:00 2001
From: rossberg-chromium <rossberg@chromium.org>
Date: Wed, 11 Oct 2017 17:53:35 +0200
Subject: [PATCH 097/329] Update description of extended module syntax in
 README

---
 interpreter/README.md | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 3c56ed6c1..39adb38a9 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -268,7 +268,6 @@ exkind:  ( func <var> )
          ( memory <var> )
 
 module:  ( module <name>? <typedef>* <func>* <import>* <export>* <table>? <memory>? <global>* <elem>* <data>* <start>? )
-         ( module <name>? <string>+ )
          <typedef>* <func>* <import>* <export>* <table>? <memory>? <global>* <elem>* <data>* <start>?  ;; =
          ( module <typedef>* <func>* <import>* <export>* <table>? <memory>? <global>* <elem>* <data>* <start>? )
 ```
@@ -279,8 +278,6 @@ For raw instructions, the syntax allows omitting the parentheses around the oper
 
 Any form of naming via `<name>` and `<var>` (including expression labels) is merely notational convenience of this text format. The actual AST has no names, and all bindings are referred to via ordered numeric indices; consequently, names are immediately resolved in the parser and replaced by indices. Indices can also be used directly in the text format.
 
-A module of the form `(module <string>+)` is given in binary form and will be decoded from the (concatenation of the) strings.
-
 The segment strings in the memory field are used to initialize the consecutive memory at the given offset.
 The `<size>` in the expansion of the two short-hand forms for `table` and `memory` is the minimal size that can hold the segment: the number of `<var>`s for tables, and the accumulative length of the strings rounded up to page size for memories.
 
@@ -312,6 +309,11 @@ module with given failure string
   <assertion>                                ;; assert result of an action
   <meta>                                     ;; meta command
 
+module:
+  ...
+  ( module <name>? binary <string>* )        ;; module in binary format (may be malformed)
+  ( module <name>? quote <string>* )         ;; module quoted in text (may be malformed)
+
 action:
   ( invoke <name>? <string> <expr>* )        ;; invoke function export
   ( get <name>? <string> )                   ;; get global export
@@ -336,6 +338,10 @@ Commands are executed in sequence. Commands taking an optional module name refer
 
 After a module is _registered_ under a string name it is available for importing in other modules.
 
+The script format supports additional syntax for defining modules.
+A module of the form `(module binary <string>*)` is given in binary form and will be decoded from the (concatenation of the) strings.
+A module of the form `(module quote <string>*)` is given in textual form and will be parsed from the (concatenation of the) strings. In both cases, decoding/parsing happens when the command is executed, not when the script is parsed, so that meta commands like `assert_malformed` can be used to check expected errors.
+
 There are also a number of meta commands.
 The `script` command is a simple mechanism to name sub-scripts themselves. This is mainly useful for converting scripts with the `output` command. Commands inside a `script` will be executed normally, but nested meta are expanded in place (`input`, recursively) or elided (`output`) in the named script.
 

From b3986ab01335b0dca4564830e2a97020fa8704fc Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 12 Oct 2017 18:33:02 +0200
Subject: [PATCH 098/329] [interpreter] Update result syntax

---
 interpreter/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 39adb38a9..0ddbb6647 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -233,7 +233,7 @@ func:    ( func <name>? <func_sig> <local>* <instr>* )
          ( func <name>? ( export <string> )+ <func_sig> <local>* <instr>* ) ;; = (export <string> (func <N>))+ (func <name>? <func_sig> <local>* <instr>*)
          ( func <name>? ( import <string> <string> ) <func_sig>)            ;; = (import <name>? <string> <string> (func <func_sig>))
 param:   ( param <type>* ) | ( param <name> <type> )
-result:  ( result <type> )
+result:  ( result <type>* )
 local:   ( local <type>* ) | ( local <name> <type> )
 
 global:  ( global <name>? <global_sig> <instr>* )

From b6f3db28de526a7b100701392df991aae7de34d4 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 13 Oct 2017 12:44:36 +0200
Subject: [PATCH 099/329] Update grammar of inline exports in README

---
 interpreter/README.md | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 0ddbb6647..fe4f2273a 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -161,8 +161,9 @@ WebAssemblyText.decode(binary)
 
 ## S-Expression Syntax
 
-The implementation consumes a WebAssembly AST given in S-expression syntax. Here is an overview of the grammar of types, expressions, functions, and modules, mirroring what's described in the [design doc](https://github.com/WebAssembly/design/blob/master/Semantics.md):
+The implementation consumes a WebAssembly AST given in S-expression syntax. Here is an overview of the grammar of types, expressions, functions, and modules, mirroring what's described in the [design doc](https://github.com/WebAssembly/design/blob/master/Semantics.md).
 
+Note: The grammar is shown here for convenience, the definite source is the [specification of the text format](https://webassembly.github.io/spec/text/).
 ```
 value: <int> | <float>
 var: <int> | <name>
@@ -230,23 +231,23 @@ op:
   <type>.<cvtop>/<type>
 
 func:    ( func <name>? <func_sig> <local>* <instr>* )
-         ( func <name>? ( export <string> )+ <func_sig> <local>* <instr>* ) ;; = (export <string> (func <N>))+ (func <name>? <func_sig> <local>* <instr>*)
+         ( func <name>? ( export <string> ) <...> )                         ;; = (export <string> (func <N>)) (func <name>? <...>)
          ( func <name>? ( import <string> <string> ) <func_sig>)            ;; = (import <name>? <string> <string> (func <func_sig>))
 param:   ( param <type>* ) | ( param <name> <type> )
 result:  ( result <type>* )
 local:   ( local <type>* ) | ( local <name> <type> )
 
 global:  ( global <name>? <global_sig> <instr>* )
-         ( global <name>? ( export <string> )+ <global_sig> <instr>* )      ;; = (export <string> (global <N>))+ (global <name>? <global_sig> <instr>*)
+         ( global <name>? ( export <string> ) <...> )                       ;; = (export <string> (global <N>)) (global <name>? <...>)
          ( global <name>? ( import <string> <string> ) <global_sig> )       ;; = (import <name>? <string> <string> (global <global_sig>))
 table:   ( table <name>? <table_sig> )
-         ( table <name>? ( export <string> )+ <table_sig> )                 ;; = (export <string> (table <N>))+ (table <name>? <table_sig>)
+         ( table <name>? ( export <string> ) <...> )                        ;; = (export <string> (table <N>)) (table <name>? <...>)
          ( table <name>? ( import <string> <string> ) <table_sig> )         ;; = (import <name>? <string> <string> (table <table_sig>))
          ( table <name>? ( export <string> )* <elem_type> ( elem <var>* ) ) ;; = (table <name>? ( export <string> )* <size> <size> <elem_type>) (elem (i32.const 0) <var>*)
 elem:    ( elem <var>? (offset <instr>* ) <var>* )
          ( elem <var>? <expr> <var>* )                                      ;; = (elem <var>? (offset <expr>) <var>*)
 memory:  ( memory <name>? <memory_sig> )
-         ( memory <name>? ( export <string> )+ <memory_sig> )               ;; = (export <string> (memory <N>))+ (memory <name>? <memory_sig>)
+         ( memory <name>? ( export <string> ) <...> )                       ;; = (export <string> (memory <N>))+ (memory <name>? <...>)
          ( memory <name>? ( import <string> <string> ) <memory_sig> )       ;; = (import <name>? <string> <string> (memory <memory_sig>))
          ( memory <name>? ( export <string> )* ( data <string>* )           ;; = (memory <name>? ( export <string> )* <size> <size>) (data (i32.const 0) <string>*)
 data:    ( data <var>? ( offset <instr>* ) <string>* )

From b3c6413c12b390dda25effd4f14f3c2f3a93da35 Mon Sep 17 00:00:00 2001
From: Dan Gohman <sunfish@mozilla.com>
Date: Fri, 13 Oct 2017 10:54:55 -0700
Subject: [PATCH 100/329] Add tests for invalid UTF-8 encoding in the text
 format (#474)

---
 test/core/utf8-invalid-encoding.wast | 176 +++++++++++++++++++++++++++
 1 file changed, 176 insertions(+)
 create mode 100644 test/core/utf8-invalid-encoding.wast

diff --git a/test/core/utf8-invalid-encoding.wast b/test/core/utf8-invalid-encoding.wast
new file mode 100644
index 000000000..3b3573098
--- /dev/null
+++ b/test/core/utf8-invalid-encoding.wast
@@ -0,0 +1,176 @@
+(assert_malformed (module quote "(func (export \"\\00\\00\\fe\\ff\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\8f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\90\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\9f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\a0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\bf\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c0\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c0\\bf\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c1\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c1\\bf\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\2e\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\c2\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\df\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\df\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\df\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\df\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\00\\a0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\7f\\a0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\80\\a0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\9f\\a0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\9f\\bf\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\a0\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\a0\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\a0\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\a0\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\c0\\a0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e0\\fd\\a0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\00\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\2e\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\7f\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\2e\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\80\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\c0\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\e1\\fd\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\00\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\7f\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\80\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\80\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\80\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\80\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\c0\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ec\\fd\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\00\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\7f\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\80\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\80\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\80\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\80\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\a0\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\a0\\bf\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\bf\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\bf\\bf\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\c0\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ed\\fd\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\00\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\7f\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\80\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\80\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\80\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\80\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\c0\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ee\\fd\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\00\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\7f\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\80\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\80\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\80\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\80\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\c0\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ef\\fd\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\00\\90\\90\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\7f\\90\\90\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\80\\90\\90\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\8f\\90\\90\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\8f\\bf\\bf\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\00\\90\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\7f\\90\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\90\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\c0\\90\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\90\\fd\\90\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\c0\\90\\90\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f0\\fd\\90\\90\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\00\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\7f\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\00\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\7f\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\80\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\c0\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\80\\fd\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\c0\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f1\\fd\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\00\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\7f\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\00\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\7f\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\80\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\c0\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\80\\fd\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\c0\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f3\\fd\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\00\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\7f\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\00\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\7f\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\7f\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\c0\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\80\\fd\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\c0\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\80\\fd\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\90\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\bf\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\c0\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f4\\fd\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f5\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f7\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f7\\bf\\bf\\bf\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\f8\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fb\\bf\\bf\\bf\\bf\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\\23\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\\80\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fc\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fd\\bf\\bf\\bf\\bf\\bf\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fe\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\fe\\ff\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ff\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ff\\fe\\00\\00\"))") "invalid UTF-8 encoding")
+(assert_malformed (module quote "(func (export \"\\ff\\fe\"))") "invalid UTF-8 encoding")

From 8fa1e6b8cd16b860ed5664479401b5ed126db3bc Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 17 Oct 2017 07:57:15 +0200
Subject: [PATCH 101/329] [spec] Add note regarding authorative role of
 standard dependencies (#582)

---
 document/core/intro/introduction.rst | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/document/core/intro/introduction.rst b/document/core/intro/introduction.rst
index a514fcea3..6c9b05897 100644
--- a/document/core/intro/introduction.rst
+++ b/document/core/intro/introduction.rst
@@ -89,3 +89,8 @@ WebAssembly depends on two existing standards:
 
 However, to make this specification self-contained, relevant aspects of the aforementioned standards are defined and formalized as part of this specification,
 such as the :ref:`binary representation <aux-fbits>` and :ref:`rounding <aux-ieee>` of floating-point values, and the :ref:`value range <syntax-codepoint>` and :ref:`UTF-8 encoding <binary-utf8>` of Unicode characters.
+
+.. note::
+   The aforementioned standards are the authorative source of all respective definitions.
+   Formalizations given in this specification are intended to match these definitions.
+   Any discrepancy in the syntax or semantics described is to be considered an error.

From db162d0b6739050836390bd0b1a9e6e5509cfaa1 Mon Sep 17 00:00:00 2001
From: Benjamin Beurdouche <beurdouche@users.noreply.github.com>
Date: Wed, 18 Oct 2017 12:52:50 +0200
Subject: [PATCH 102/329] [interpreter] Add missing dependency to install
 target (#588)

---
 interpreter/Makefile | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/interpreter/Makefile b/interpreter/Makefile
index 7cf198904..97b94f6e9 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -76,10 +76,10 @@ $(LIB).mlpack:	$(DIRS)
 		| sort | uniq \
 		>$@
 
-_build/$(LIB).cmo: $(LIB).mlpack
+_build/$(LIB).cmo: $(LIB).mlpack _tags
 		$(OCB) -quiet $(LIB).cmo
 
-_build/$(LIB).cmx: $(LIB).mlpack
+_build/$(LIB).cmx: $(LIB).mlpack _tags
 		$(OCB) -quiet $(LIB).cmx
 
 

From d9cfaf28f32227f3600b1c0372859bad5c78c1a7 Mon Sep 17 00:00:00 2001
From: Luke Wagner <mail@lukewagner.name>
Date: Thu, 19 Oct 2017 09:49:58 -0500
Subject: [PATCH 103/329] Mention suggested MIME type in Binary Format |
 Conventions (#589)

* Add MIME type
* Add link for Media Type
---
 document/core/binary/conventions.rst | 3 ++-
 document/core/util/macros.def        | 2 ++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/document/core/binary/conventions.rst b/document/core/binary/conventions.rst
index 08e9db793..5f6b2e226 100644
--- a/document/core/binary/conventions.rst
+++ b/document/core/binary/conventions.rst
@@ -20,7 +20,8 @@ Except for a few exceptions, the binary grammar closely mirrors the grammar of t
    Implementations of decoders must support all possible alternatives;
    implementations of encoders can pick any allowed encoding.
 
-The recommended extension for files containing WebAssembly modules in binary format is ":math:`\T{.wasm}`".
+The recommended extension for files containing WebAssembly modules in binary format is ":math:`\T{.wasm}`"
+and the recommended |MediaType|_ is ":math:`\T{application/wasm}`".
 
 .. [#compression]
    Additional encoding layers -- for example, introducing compression -- may be defined on top of the basic representation defined here.
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 800dc41f0..5ff53df7e 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -29,6 +29,8 @@
 .. |SExpressions| replace:: S-expressions
 .. _SExpressions: https://en.wikipedia.org/wiki/S-expression
 
+.. |MediaType| replace:: Media Type
+.. _MediaType: https://www.iana.org/assignments/media-types/media-types.xhtml
 
 .. Literature
 .. ----------

From 0f96f030d656ff26f9a6daa48caa9705e678b6c9 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 20 Oct 2017 11:22:04 +0200
Subject: [PATCH 104/329] [spec] Document `make publish` in README

---
 document/core/README.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/document/core/README.md b/document/core/README.md
index 310e5d3e0..5b40a1822 100644
--- a/document/core/README.md
+++ b/document/core/README.md
@@ -18,3 +18,8 @@ To make all:
 ```
 make all
 ```
+Finally, to make all and update webassembly.github.io/spec with it:
+```
+make publish
+```
+Please make sure to only use that once a change has approval.

From 9efed9e4df5a226d57fd86afd88e13c6e46daced Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 20 Oct 2017 11:36:23 +0200
Subject: [PATCH 105/329] [spec] Support reading and writing empty table
 entries (#587)

---
 document/core/appendix/embedding.rst | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index 1bbd32bdf..44f89c873 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -337,21 +337,19 @@ Tables
 
 4. If :math:`i` is larger than or equal to the length if :math:`\X{ti}.\TIELEM`, then return :math:`\ERROR`.
 
-5. If :math:`\X{ti}.\TIELEM[i]` contains a :ref:`function address <syntax-funcaddr>` :math:`\X{fa}`, then return :math:`\X{fa}`.
-
-6. Else :math:`\X{ti}.\TIELEM[i]` is empty, hence return :math:`\ERROR`.
+5. Else, return :math:`\X{ti}.\TIELEM[i]`.
 
 .. math::
    \begin{array}{lclll}
-   \F{read\_table}(S, a, i) &=& \X{fa} && (\iff S.\STABLES[a].\TIELEM[i] = \X{fa}) \\
+   \F{read\_table}(S, a, i) &=& \X{fa}^? && (\iff S.\STABLES[a].\TIELEM[i] = \X{fa}^?) \\
    \F{read\_table}(S, a, i) &=& \ERROR && (\otherwise) \\
    \end{array}
 
 
 .. _embed-write-table:
 
-:math:`\F{write\_table}(\store, \tableaddr, i, \funcaddr) : \store ~|~ \error`
-..............................................................................
+:math:`\F{write\_table}(\store, \tableaddr, i, \funcaddr^?) : \store ~|~ \error`
+................................................................................
 
 1. Assert: :math:`\store.\STABLES[\tableaddr]` exists.
 
@@ -361,14 +359,14 @@ Tables
 
 4. If :math:`i` is larger than or equal to the length if :math:`\X{ti}.\TIELEM`, then return :math:`\ERROR`.
 
-5. Replace :math:`\X{ti}.\TIELEM[i]` with the :ref:`function address <syntax-funcaddr>` :math:`\X{fa}`.
+5. Replace :math:`\X{ti}.\TIELEM[i]` with the optional :ref:`function address <syntax-funcaddr>` :math:`\X{fa}^?`.
 
 6. Return the updated store.
 
 .. math::
    \begin{array}{lclll}
-   \F{write\_table}(S, a, i, \X{fa}) &=& S' && (\iff S' = S \with \STABLES[a].\TIELEM[i] = \X{fa}) \\
-   \F{write\_table}(S, a, i, \X{fa}) &=& \ERROR && (\otherwise) \\
+   \F{write\_table}(S, a, i, \X{fa}^?) &=& S' && (\iff S' = S \with \STABLES[a].\TIELEM[i] = \X{fa}^?) \\
+   \F{write\_table}(S, a, i, \X{fa}^?) &=& \ERROR && (\otherwise) \\
    \end{array}
 
 

From 51fb7e39e9134b44ffb2c154a19efe60e5b56eb0 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 25 Oct 2017 11:52:42 +0200
Subject: [PATCH 106/329] [spec] Add size_{table,mem} to embedder interface
 (#592)

---
 document/core/appendix/embedding.rst | 36 ++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index 44f89c873..262517880 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -370,6 +370,24 @@ Tables
    \end{array}
 
 
+.. _embed-size-table:
+
+:math:`\F{size\_table}(\store, \tableaddr) : \i32`
+..................................................
+
+1. Assert: :math:`\store.\STABLES[\tableaddr]` exists.
+
+2. Return the length of :math:`\store.\STABLES[\tableaddr].\TIELEM`.
+
+.. math::
+   ~ \\
+   \begin{array}{lclll}
+   \F{size\_table}(S, a) &=& n &&
+     (\iff |S.\STABLES[a].\TIELEM| = n) \\
+   \end{array}
+
+
+
 .. _embed-grow-table:
 
 :math:`\F{grow\_table}(\store, \tableaddr, n) : \store ~|~ \error`
@@ -478,6 +496,24 @@ Memories
    \end{array}
 
 
+.. _embed-size-mem:
+
+:math:`\F{size\_mem}(\store, \memaddr) : \i32`
+..............................................
+
+1. Assert: :math:`\store.\SMEMS[\memaddr]` exists.
+
+2. Return the length of :math:`\store.\SMEMS[\memaddr].\MIDATA` divided by the :ref:`page size <page-size>`.
+
+.. math::
+   ~ \\
+   \begin{array}{lclll}
+   \F{size\_mem}(S, a) &=& n &&
+     (\iff |S.\SMEMS[a].\MIDATA| = n \cdot 64\,\F{Ki}) \\
+   \end{array}
+
+
+
 .. _embed-grow-mem:
 
 :math:`\F{grow\_mem}(\store, \memaddr, n) : \store ~|~ \error`

From 043aadd8783822df3c826d6faefb5bba0d9cf20a Mon Sep 17 00:00:00 2001
From: rossberg <rossberg@chromium.org>
Date: Wed, 25 Oct 2017 12:33:58 +0200
Subject: [PATCH 107/329] [spec] Fix Latex

---
 document/core/appendix/embedding.rst | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index 262517880..43d63997e 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -372,8 +372,8 @@ Tables
 
 .. _embed-size-table:
 
-:math:`\F{size\_table}(\store, \tableaddr) : \i32`
-..................................................
+:math:`\F{size\_table}(\store, \tableaddr) : \X{i32}`
+.....................................................
 
 1. Assert: :math:`\store.\STABLES[\tableaddr]` exists.
 
@@ -498,8 +498,8 @@ Memories
 
 .. _embed-size-mem:
 
-:math:`\F{size\_mem}(\store, \memaddr) : \i32`
-..............................................
+:math:`\F{size\_mem}(\store, \memaddr) : \X{i32}`
+.................................................
 
 1. Assert: :math:`\store.\SMEMS[\memaddr]` exists.
 

From 621ea96bdd590482b0abd2cb3bd51f9261ebb84b Mon Sep 17 00:00:00 2001
From: rossberg <rossberg@chromium.org>
Date: Fri, 27 Oct 2017 11:53:05 +0200
Subject: [PATCH 108/329] [interpreter] Minor Makefile clean-up

---
 interpreter/Makefile | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/interpreter/Makefile b/interpreter/Makefile
index 97b94f6e9..2973a5f23 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -136,10 +136,9 @@ $(ZIP):		$(WINMAKE)
 		git archive --format=zip --prefix=$(NAME)/ -o $@ HEAD
 
 clean:
-		rm -rf _build/jslib wasm.mlpack _tags
+		rm -rf _build/jslib $(LIB).mlpack _tags
 		$(OCB) -clean
 
-
 # Opam support
 
 .PHONY:		check install uninstall
@@ -150,9 +149,9 @@ check:
 		ocamlfind query $(LIBS)
 
 install:	_build/$(LIB).cmx _build/$(LIB).cmo
-		ocamlfind install wasm meta/findlib/META _build/wasm.o \
+		ocamlfind install $(LIB) meta/findlib/META _build/$(LIB).o \
 		  $(wildcard _build/$(LIB).cm*) \
 		  $(wildcard $(DIRS:%=%/*.mli))
 
 uninstall:
-		ocamlfind remove wasm
+		ocamlfind remove $(LIB)

From 96f3ba9af3e0d5e40e4a66548011c3d397512b29 Mon Sep 17 00:00:00 2001
From: Steve Klabnik <steve@steveklabnik.com>
Date: Wed, 1 Nov 2017 11:27:33 -0400
Subject: [PATCH 109/329] Fix a typo (#594)

---
 document/core/valid/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 3581cd0cb..fbc534785 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -19,7 +19,7 @@ Such a sequence has a :ref:`function types <syntax-functype>` :math:`[t_1^\ast]
 .. _polymorphism:
 
 For some instructions, the typing rules do not fully constrain the type,
-and therefor allow for multiple types.
+and therefore allow for multiple types.
 Such instructions are called *polymorphic*.
 Two degrees of polymorphism can be distinguished:
 

From d89a50ac655421cb49c9b2573e9287e98fe10f96 Mon Sep 17 00:00:00 2001
From: Steve Klabnik <steve@steveklabnik.com>
Date: Wed, 1 Nov 2017 11:27:42 -0400
Subject: [PATCH 110/329] Fix typo (#595)

---
 document/core/exec/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 6ddccce31..fe08bd197 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -986,7 +986,7 @@ When the end of a block is reached without a jump or trap aborting it, then the
 
 .. note::
    This semantics also applies to the instruction sequence contained in a |LOOP| instruction.
-   Therefor, execution of a loop falls off the end, unless a backwards branch is performed explicitly.
+   Therefore, execution of a loop falls off the end, unless a backwards branch is performed explicitly.
 
 
 .. index:: ! call, function, function instance, label, frame

From e75141e34fab735133ad13ebdb03c1a4d984b9e2 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 9 Nov 2017 08:42:55 +0100
Subject: [PATCH 111/329] [spec] Note on log2 representation for alignment
 (#601)

---
 document/core/syntax/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index c6663e88b..060933bf7 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -245,7 +245,7 @@ Instructions in this group are concerned with linear :ref:`memory <syntax-mem>`.
    \end{array}
 
 Memory is accessed with |LOAD| and |STORE| instructions for the different :ref:`value types <syntax-valtype>`.
-They all take a *memory immediate* |memarg| that contains an address *offset* and an *alignment* hint.
+They all take a *memory immediate* |memarg| that contains an address *offset* and an *alignment* hint (in base 2 logarithmic representation).
 Integer loads and stores can optionally specify a *storage size* that is smaller than the :ref:`bit width <syntax-valtype>` of the respective value type.
 In the case of loads, a sign extension mode |sx| is then required to select appropriate behavior.
 

From c247b6a655d1906bfd786507787769ed3a804567 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 9 Nov 2017 15:13:00 +0100
Subject: [PATCH 112/329] [spec] Use typeuse syntax for call_indirect and allow
 inline types (#599)

Instead of a simple type index, the call signature for `call_indirect` is specified using the existing `typeuse` syntax used e.g. in function declarations:
```
call_indirect (type $t)
call_indirect (param i32 i32)
call_indirect (param i32 i64) (result i32)
```
That makes it consistent with how types are/will be referenced elsewhere (besides function declarations, e.g. in block signatures in the [multi-value proposal](https://github.com/WebAssembly/multi-value/)). Furthermore, as the example shows, it implies that you can write the call signature inline, like for functions and blocks.

The expansion rules are like for function declarations. However, inline types for call_indirect must not include parameter names.
---
 document/core/text/instructions.rst | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 57723b6ab..a06aa981e 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -87,7 +87,7 @@ The same label identifier may optionally be repeated after the corresponding :ma
 All other control instruction are represented verbatim.
 
 .. math::
-   \begin{array}{llclll}
+   \begin{array}{llcllll}
    \production{plain instruction} & \Tplaininstr_I &::=&
      \text{unreachable} &\Rightarrow& \UNREACHABLE \\ &&|&
      \text{nop} &\Rightarrow& \NOP \\ &&|&
@@ -97,9 +97,13 @@ All other control instruction are represented verbatim.
        &\Rightarrow& \BRTABLE~l^\ast~l_N \\ &&|&
      \text{return} &\Rightarrow& \RETURN \\ &&|&
      \text{call}~~x{:}\Tfuncidx_I &\Rightarrow& \CALL~x \\ &&|&
-     \text{call\_indirect}~~x{:}\Ttypeidx_I &\Rightarrow& \CALLINDIRECT~x \\
+     \text{call\_indirect}~~x,I'{:}\Ttypeuse_I &\Rightarrow& \CALLINDIRECT~x
+       & (\iff I' = \{\}) \\
    \end{array}
 
+.. note::
+   The side condition stating that the :ref:`identifier context <text-context>` :math:`I'` must be empty in the rule for |CALLINDIRECT| enforces that no identifier can be bound in any |Tparam| declaration appearing in the type annotation.
+
 
 Abbreviations
 .............

From a7e226a92e660a3d5413cfea4269824f513259d2 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 10 Nov 2017 17:26:24 +0100
Subject: [PATCH 113/329] [interpreter/test] Allow typeuse syntax for
 call_indirect (#602)

Implement #599 in interpreter and adapt & add tests.
---
 interpreter/README.md        |   2 +-
 interpreter/text/arrange.ml  |   2 +-
 interpreter/text/parser.mly  |  58 ++++++++-
 test/core/br.wast            |   8 +-
 test/core/br_table.wast      |   8 +-
 test/core/call_indirect.wast | 234 +++++++++++++++++++++++++++++------
 test/core/elem.wast          |  14 +--
 test/core/func.wast          |  16 +--
 test/core/func_ptrs.wast     |   6 +-
 test/core/imports.wast       |  12 +-
 test/core/left-to-right.wast |   8 +-
 test/core/linking.wast       |   6 +-
 test/core/return.wast        |  16 ++-
 test/core/typecheck.wast     |   4 +-
 test/core/unreachable.wast   |  16 ++-
 15 files changed, 322 insertions(+), 88 deletions(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index fe4f2273a..dc34b0446 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -211,7 +211,7 @@ op:
   br_table <var>+
   return
   call <var>
-  call_indirect <var>
+  call_indirect <func_sig>
   drop
   select
   get_local <var>
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 5dcf9d715..c12d268b8 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -234,7 +234,7 @@ let rec instr e =
       "br_table " ^ String.concat " " (list var (xs @ [x])), []
     | Return -> "return", []
     | Call x -> "call " ^ var x, []
-    | CallIndirect x -> "call_indirect " ^ var x, []
+    | CallIndirect x -> "call_indirect", [Node ("type " ^ var x, [])]
     | Drop -> "drop", []
     | Select -> "select", []
     | GetLocal x -> "get_local " ^ var x, []
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 934bc59d2..b7c65a3d1 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -294,6 +294,7 @@ align_opt :
 
 instr :
   | plain_instr { let at = at () in fun c -> [$1 c @@ at] }
+  | call_instr { fun c -> let e, es = $1 c in e :: es }
   | block_instr { let at = at () in fun c -> [$1 c @@ at] }
   | expr { $1 } /* Sugar */
 
@@ -307,7 +308,6 @@ plain_instr :
       br_table xs x }
   | RETURN { fun c -> return }
   | CALL var { fun c -> call ($2 c func) }
-  | CALL_INDIRECT var { fun c -> call_indirect ($2 c type_) }
   | DROP { fun c -> drop }
   | SELECT { fun c -> select }
   | GET_LOCAL var { fun c -> get_local ($2 c local) }
@@ -326,6 +326,35 @@ plain_instr :
   | BINARY { fun c -> $1 }
   | CONVERT { fun c -> $1 }
 
+call_instr :
+  | CALL_INDIRECT call_instr_sig
+    { let at1 = ati 1 in
+      fun c -> let x, es = $2 c in call_indirect x @@ at1, es }
+
+call_instr_sig :
+  | type_use call_instr_params
+    { let at1 = ati 1 in
+      fun c ->
+      match $2 c with
+      | FuncType ([], []), es -> $1 c type_, es
+      | ft, es -> inline_type_explicit c ($1 c type_) ft at1, es }
+  | call_instr_params
+    { let at1 = ati 1 in
+      fun c -> let ft, es = $1 c in inline_type c ft at1, es }
+
+call_instr_params :
+  | LPAR PARAM value_type_list RPAR call_instr_params
+    { fun c ->
+      let FuncType (ts1, ts2), es = $5 c in FuncType ($3 @ ts1, ts2), es }
+  | call_instr_results
+    { fun c -> let ts, es = $1 c in FuncType ([], ts), es }
+
+call_instr_results :
+  | LPAR RESULT value_type_list RPAR call_instr_results
+    { fun c -> let ts, es = $5 c in $3 @ ts, es }
+  | instr
+    { fun c -> [], $1 c }
+
 block_instr :
   | BLOCK labeling_opt block END labeling_end_opt
     { fun c -> let c' = $2 c $5 in let ts, es = $3 c' in block ts es }
@@ -351,6 +380,8 @@ expr :  /* Sugar */
 
 expr1 :  /* Sugar */
   | plain_instr expr_list { fun c -> $2 c, $1 c }
+  | CALL_INDIRECT call_expr_sig
+    { fun c -> let x, es = $2 c in es, call_indirect x }
   | BLOCK labeling_opt block
     { fun c -> let c' = $2 c [] in let ts, es = $3 c' in [], block ts es }
   | LOOP labeling_opt block
@@ -359,6 +390,31 @@ expr1 :  /* Sugar */
     { fun c -> let c' = $2 c [] in
       let ts, (es, es1, es2) = $3 c c' in es, if_ ts es1 es2 }
 
+call_expr_sig :
+  | type_use call_expr_params
+    { let at1 = ati 1 in
+      fun c ->
+      match $2 c with
+      | FuncType ([], []), es -> $1 c type_, es
+      | ft, es -> inline_type_explicit c ($1 c type_) ft at1, es }
+  | call_expr_params
+    { let at1 = ati 1 in
+      fun c -> let ft, es = $1 c in inline_type c ft at1, es }
+
+call_expr_params :
+  | LPAR PARAM value_type_list RPAR call_expr_params
+    { fun c ->
+      let FuncType (ts1, ts2), es = $5 c in FuncType ($3 @ ts1, ts2), es }
+  | call_expr_results
+    { fun c -> let ts, es = $1 c in FuncType ([], ts), es }
+
+call_expr_results :
+  | LPAR RESULT value_type_list RPAR call_expr_results
+    { fun c -> let ts, es = $5 c in $3 @ ts, es }
+  | expr_list
+    { fun c -> [], $1 c }
+
+
 if_block :
   | block_sig if_block { fun c c' -> let ts, ess = $2 c c' in $1 @ ts, ess }
   | if_ { fun c c' -> [], $1 c c' }
diff --git a/test/core/br.wast b/test/core/br.wast
index 77f781d4d..5e99209c7 100644
--- a/test/core/br.wast
+++ b/test/core/br.wast
@@ -147,7 +147,7 @@
   (table anyfunc (elem $f))
   (func (export "as-call_indirect-func") (result i32)
     (block (result i32)
-      (call_indirect $sig
+      (call_indirect (type $sig)
         (br 0 (i32.const 20))
         (i32.const 1) (i32.const 2) (i32.const 3)
       )
@@ -155,7 +155,7 @@
   )
   (func (export "as-call_indirect-first") (result i32)
     (block (result i32)
-      (call_indirect $sig
+      (call_indirect (type $sig)
         (i32.const 0)
         (br 0 (i32.const 21)) (i32.const 2) (i32.const 3)
       )
@@ -163,7 +163,7 @@
   )
   (func (export "as-call_indirect-mid") (result i32)
     (block (result i32)
-      (call_indirect $sig
+      (call_indirect (type $sig)
         (i32.const 0)
         (i32.const 1) (br 0 (i32.const 22)) (i32.const 3)
       )
@@ -171,7 +171,7 @@
   )
   (func (export "as-call_indirect-last") (result i32)
     (block (result i32)
-      (call_indirect $sig
+      (call_indirect (type $sig)
         (i32.const 0)
         (i32.const 1) (i32.const 2) (br 0 (i32.const 23))
       )
diff --git a/test/core/br_table.wast b/test/core/br_table.wast
index c8d6082d7..986089239 100644
--- a/test/core/br_table.wast
+++ b/test/core/br_table.wast
@@ -989,7 +989,7 @@
   (table anyfunc (elem $f))
   (func (export "as-call_indirect-first") (result i32)
     (block (result i32)
-      (call_indirect $sig
+      (call_indirect (type $sig)
         (br_table 0 (i32.const 20) (i32.const 1)) (i32.const 1) (i32.const 2)
         (i32.const 3)
       )
@@ -997,7 +997,7 @@
   )
   (func (export "as-call_indirect-mid") (result i32)
     (block (result i32)
-      (call_indirect $sig
+      (call_indirect (type $sig)
         (i32.const 0) (br_table 0 (i32.const 21) (i32.const 1)) (i32.const 2)
         (i32.const 3)
       )
@@ -1005,7 +1005,7 @@
   )
   (func (export "as-call_indirect-last") (result i32)
     (block (result i32)
-      (call_indirect $sig
+      (call_indirect (type $sig)
         (i32.const 0) (i32.const 1) (br_table 0 (i32.const 22) (i32.const 1))
         (i32.const 3)
       )
@@ -1013,7 +1013,7 @@
   )
   (func (export "as-call_indirect-func") (result i32)
     (block (result i32)
-      (call_indirect $sig
+      (call_indirect (type $sig)
         (i32.const 0) (i32.const 1) (i32.const 2)
         (br_table 0 (i32.const 23) (i32.const 1))
       )
diff --git a/test/core/call_indirect.wast b/test/core/call_indirect.wast
index b9b152e82..db28f391d 100644
--- a/test/core/call_indirect.wast
+++ b/test/core/call_indirect.wast
@@ -52,51 +52,87 @@
     )
   )
 
+  ;; Syntax
+
+  (func
+    (call_indirect (i32.const 0))
+    (call_indirect (param i64) (i64.const 0) (i32.const 0))
+    (call_indirect (param i64) (param) (param f64 i32 i64)
+      (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+    )
+    (call_indirect (result) (i32.const 0))
+    (drop (i32.eqz (call_indirect (result i32) (i32.const 0))))
+    (drop (i32.eqz (call_indirect (result i32) (result) (i32.const 0))))
+    (drop (i32.eqz
+      (call_indirect (param i64) (result i32) (i64.const 0) (i32.const 0))
+    ))
+    (drop (i32.eqz
+      (call_indirect
+        (param) (param i64) (param) (param f64 i32 i64) (param) (param)
+        (result) (result i32) (result) (result)
+        (i64.const 0) (f64.const 0) (i32.const 0) (i64.const 0) (i32.const 0)
+      )
+    ))
+    (drop (i64.eqz
+      (call_indirect (type $over-i64) (param i64) (result i64)
+        (i64.const 0) (i32.const 0)
+      )
+    ))
+  )
+
   ;; Typing
 
-  (func (export "type-i32") (result i32) (call_indirect $out-i32 (i32.const 0)))
-  (func (export "type-i64") (result i64) (call_indirect $out-i64 (i32.const 1)))
-  (func (export "type-f32") (result f32) (call_indirect $out-f32 (i32.const 2)))
-  (func (export "type-f64") (result f64) (call_indirect $out-f64 (i32.const 3)))
+  (func (export "type-i32") (result i32)
+    (call_indirect (type $out-i32) (i32.const 0))
+  )
+  (func (export "type-i64") (result i64)
+    (call_indirect (type $out-i64) (i32.const 1))
+  )
+  (func (export "type-f32") (result f32)
+    (call_indirect (type $out-f32) (i32.const 2))
+  )
+  (func (export "type-f64") (result f64)
+    (call_indirect (type $out-f64) (i32.const 3))
+  )
 
   (func (export "type-index") (result i64)
-    (call_indirect $over-i64 (i64.const 100) (i32.const 5))
+    (call_indirect (type $over-i64) (i64.const 100) (i32.const 5))
   )
 
   (func (export "type-first-i32") (result i32)
-    (call_indirect $over-i32 (i32.const 32) (i32.const 4))
+    (call_indirect (type $over-i32) (i32.const 32) (i32.const 4))
   )
   (func (export "type-first-i64") (result i64)
-    (call_indirect $over-i64 (i64.const 64) (i32.const 5))
+    (call_indirect (type $over-i64) (i64.const 64) (i32.const 5))
   )
   (func (export "type-first-f32") (result f32)
-    (call_indirect $over-f32 (f32.const 1.32) (i32.const 6))
+    (call_indirect (type $over-f32) (f32.const 1.32) (i32.const 6))
   )
   (func (export "type-first-f64") (result f64)
-    (call_indirect $over-f64 (f64.const 1.64) (i32.const 7))
+    (call_indirect (type $over-f64) (f64.const 1.64) (i32.const 7))
   )
 
   (func (export "type-second-i32") (result i32)
-    (call_indirect $f32-i32 (f32.const 32.1) (i32.const 32) (i32.const 8))
+    (call_indirect (type $f32-i32) (f32.const 32.1) (i32.const 32) (i32.const 8))
   )
   (func (export "type-second-i64") (result i64)
-    (call_indirect $i32-i64 (i32.const 32) (i64.const 64) (i32.const 9))
+    (call_indirect (type $i32-i64) (i32.const 32) (i64.const 64) (i32.const 9))
   )
   (func (export "type-second-f32") (result f32)
-    (call_indirect $f64-f32 (f64.const 64) (f32.const 32) (i32.const 10))
+    (call_indirect (type $f64-f32) (f64.const 64) (f32.const 32) (i32.const 10))
   )
   (func (export "type-second-f64") (result f64)
-    (call_indirect $i64-f64 (i64.const 64) (f64.const 64.1) (i32.const 11))
+    (call_indirect (type $i64-f64) (i64.const 64) (f64.const 64.1) (i32.const 11))
   )
 
   ;; Dispatch
 
   (func (export "dispatch") (param i32 i64) (result i64)
-    (call_indirect $over-i64 (get_local 1) (get_local 0))
+    (call_indirect (type $over-i64) (get_local 1) (get_local 0))
   )
 
   (func (export "dispatch-structural") (param i32) (result i64)
-    (call_indirect $over-i64-duplicate (i64.const 9) (get_local 0))
+    (call_indirect (type $over-i64-duplicate) (i64.const 9) (get_local 0))
   )
 
   ;; Recursion
@@ -107,7 +143,7 @@
       (else
         (i64.mul
           (get_local 0)
-          (call_indirect $over-i64
+          (call_indirect (type $over-i64)
             (i64.sub (get_local 0) (i64.const 1))
             (i32.const 12)
           )
@@ -121,11 +157,11 @@
       (then (i64.const 1))
       (else
         (i64.add
-          (call_indirect $over-i64
+          (call_indirect (type $over-i64)
             (i64.sub (get_local 0) (i64.const 2))
             (i32.const 13)
           )
-          (call_indirect $over-i64
+          (call_indirect (type $over-i64)
             (i64.sub (get_local 0) (i64.const 1))
             (i32.const 13)
           )
@@ -138,7 +174,7 @@
     (if (result i32) (i32.eqz (get_local 0))
       (then (i32.const 44))
       (else
-        (call_indirect $over-i32
+        (call_indirect (type $over-i32)
           (i32.sub (get_local 0) (i32.const 1))
           (i32.const 15)
         )
@@ -149,7 +185,7 @@
     (if (result i32) (i32.eqz (get_local 0))
       (then (i32.const 99))
       (else
-        (call_indirect $over-i32
+        (call_indirect (type $over-i32)
           (i32.sub (get_local 0) (i32.const 1))
           (i32.const 14)
         )
@@ -166,10 +202,10 @@
   ;; implementations and be incompatible with implementations that don't do
   ;; it (or don't do it under the same circumstances).
 
-  (func $runaway (export "runaway") (call_indirect $proc (i32.const 16)))
+  (func $runaway (export "runaway") (call_indirect (type $proc) (i32.const 16)))
 
-  (func $mutual-runaway1 (export "mutual-runaway") (call_indirect $proc (i32.const 18)))
-  (func $mutual-runaway2 (call_indirect $proc (i32.const 17)))
+  (func $mutual-runaway1 (export "mutual-runaway") (call_indirect (type $proc) (i32.const 18)))
+  (func $mutual-runaway2 (call_indirect (type $proc) (i32.const 17)))
 )
 
 (assert_return (invoke "type-i32") (i32.const 0x132))
@@ -231,12 +267,134 @@
 (assert_exhaustion (invoke "mutual-runaway") "call stack exhausted")
 
 
+;; Invalid syntax
+
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 anyfunc)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (result i32) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 anyfunc)"
+    "(func (result i32)"
+    "  (call_indirect (param i32) (type $sig) (result i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 anyfunc)"
+    "(func (result i32)"
+    "  (call_indirect (param i32) (result i32) (type $sig)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 anyfunc)"
+    "(func (result i32)"
+    "  (call_indirect (result i32) (type $sig) (param i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 anyfunc)"
+    "(func (result i32)"
+    "  (call_indirect (result i32) (param i32) (type $sig)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(table 0 anyfunc)"
+    "(func (result i32)"
+    "  (call_indirect (result i32) (param i32) (i32.const 0) (i32.const 0))"
+    ")"
+  )
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(table 0 anyfunc)"
+    "(func (call_indirect (param $x i32) (i32.const 0) (i32.const 0)))"
+  )
+  "unexpected token"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func))"
+    "(table 0 anyfunc)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (result i32) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 anyfunc)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (result i32) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32) (result i32)))"
+    "(table 0 anyfunc)"
+    "(func"
+    "  (call_indirect (type $sig) (param i32) (i32.const 0) (i32.const 0))"
+    ")"
+  )
+  "inline function type"
+)
+(assert_malformed
+  (module quote
+    "(type $sig (func (param i32 i32) (result i32)))"
+    "(table 0 anyfunc)"
+    "(func (result i32)"
+    "  (call_indirect (type $sig) (param i32) (result i32)"
+    "    (i32.const 0) (i32.const 0)"
+    "  )"
+    ")"
+  )
+  "inline function type"
+)
+
 ;; Invalid typing
 
 (assert_invalid
   (module
     (type (func))
-    (func $no-table (call_indirect 0 (i32.const 0)))
+    (func $no-table (call_indirect (type 0) (i32.const 0)))
   )
   "unknown table"
 )
@@ -245,7 +403,7 @@
   (module
     (type (func))
     (table 0 anyfunc)
-    (func $type-void-vs-num (i32.eqz (call_indirect 0 (i32.const 0))))
+    (func $type-void-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
   )
   "type mismatch"
 )
@@ -253,7 +411,7 @@
   (module
     (type (func (result i64)))
     (table 0 anyfunc)
-    (func $type-num-vs-num (i32.eqz (call_indirect 0 (i32.const 0))))
+    (func $type-num-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
   )
   "type mismatch"
 )
@@ -262,7 +420,7 @@
   (module
     (type (func (param i32)))
     (table 0 anyfunc)
-    (func $arity-0-vs-1 (call_indirect 0 (i32.const 0)))
+    (func $arity-0-vs-1 (call_indirect (type 0) (i32.const 0)))
   )
   "type mismatch"
 )
@@ -270,7 +428,7 @@
   (module
     (type (func (param f64 i32)))
     (table 0 anyfunc)
-    (func $arity-0-vs-2 (call_indirect 0 (i32.const 0)))
+    (func $arity-0-vs-2 (call_indirect (type 0) (i32.const 0)))
   )
   "type mismatch"
 )
@@ -278,7 +436,7 @@
   (module
     (type (func))
     (table 0 anyfunc)
-    (func $arity-1-vs-0 (call_indirect 0 (i32.const 1) (i32.const 0)))
+    (func $arity-1-vs-0 (call_indirect (type 0) (i32.const 1) (i32.const 0)))
   )
   "type mismatch"
 )
@@ -287,7 +445,7 @@
     (type (func))
     (table 0 anyfunc)
     (func $arity-2-vs-0
-      (call_indirect 0 (f64.const 2) (i32.const 1) (i32.const 0))
+      (call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0))
     )
   )
   "type mismatch"
@@ -297,7 +455,7 @@
   (module
     (type (func (param i32)))
     (table 0 anyfunc)
-    (func $type-func-void-vs-i32 (call_indirect 0 (i32.const 1) (nop)))
+    (func $type-func-void-vs-i32 (call_indirect (type 0) (i32.const 1) (nop)))
   )
   "type mismatch"
 )
@@ -305,7 +463,7 @@
   (module
     (type (func (param i32)))
     (table 0 anyfunc)
-    (func $type-func-num-vs-i32 (call_indirect 0 (i32.const 0) (i64.const 1)))
+    (func $type-func-num-vs-i32 (call_indirect (type 0) (i32.const 0) (i64.const 1)))
   )
   "type mismatch"
 )
@@ -315,7 +473,7 @@
     (type (func (param i32 i32)))
     (table 0 anyfunc)
     (func $type-first-void-vs-num
-      (call_indirect 0 (nop) (i32.const 1) (i32.const 0))
+      (call_indirect (type 0) (nop) (i32.const 1) (i32.const 0))
     )
   )
   "type mismatch"
@@ -325,7 +483,7 @@
     (type (func (param i32 i32)))
     (table 0 anyfunc)
     (func $type-second-void-vs-num
-      (call_indirect 0 (i32.const 1) (nop) (i32.const 0))
+      (call_indirect (type 0) (i32.const 1) (nop) (i32.const 0))
     )
   )
   "type mismatch"
@@ -335,7 +493,7 @@
     (type (func (param i32 f64)))
     (table 0 anyfunc)
     (func $type-first-num-vs-num
-      (call_indirect 0 (f64.const 1) (i32.const 1) (i32.const 0))
+      (call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0))
     )
   )
   "type mismatch"
@@ -345,7 +503,7 @@
     (type (func (param f64 i32)))
     (table 0 anyfunc)
     (func $type-second-num-vs-num
-      (call_indirect 0 (i32.const 1) (f64.const 1) (i32.const 0))
+      (call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0))
     )
   )
   "type mismatch"
@@ -357,14 +515,14 @@
 (assert_invalid
   (module
     (table 0 anyfunc)
-    (func $unbound-type (call_indirect 1 (i32.const 0)))
+    (func $unbound-type (call_indirect (type 1) (i32.const 0)))
   )
   "unknown type"
 )
 (assert_invalid
   (module
     (table 0 anyfunc)
-    (func $large-type (call_indirect 1012321300 (i32.const 0)))
+    (func $large-type (call_indirect (type 1012321300) (i32.const 0)))
   )
   "unknown type"
 )
diff --git a/test/core/elem.wast b/test/core/elem.wast
index c75e07b23..da28f3f95 100644
--- a/test/core/elem.wast
+++ b/test/core/elem.wast
@@ -20,10 +20,10 @@
   (func $const-i32-a (type $out-i32) (i32.const 65))
   (func $const-i32-b (type $out-i32) (i32.const 66))
   (func (export "call-7") (type $out-i32)
-    (call_indirect $out-i32 (i32.const 7))
+    (call_indirect (type $out-i32) (i32.const 7))
   )
   (func (export "call-9") (type $out-i32)
-    (call_indirect $out-i32 (i32.const 9))
+    (call_indirect (type $out-i32) (i32.const 9))
   )
 )
 
@@ -40,7 +40,7 @@
   (func $const-i32-a (type $out-i32) (i32.const 65))
   (func $const-i32-b (type $out-i32) (i32.const 66))
   (func (export "call-overwritten-element") (type $out-i32)
-    (call_indirect $out-i32 (i32.const 9))
+    (call_indirect (type $out-i32) (i32.const 9))
   )
 )
 
@@ -108,7 +108,7 @@
   (func $const-i32-a (type $out-i32) (i32.const 65))
   (func $const-i32-b (type $out-i32) (i32.const 66))
   (func (export "call-overwritten-element") (type $out-i32)
-    (call_indirect $out-i32 (i32.const 9))
+    (call_indirect (type $out-i32) (i32.const 9))
   )
 )
 
@@ -172,13 +172,13 @@
   (func $const-i32-a (type $out-i32) (i32.const 65))
   (func $const-i32-b (type $out-i32) (i32.const 66))
   (func (export "call-7") (type $out-i32)
-    (call_indirect $out-i32 (i32.const 7))
+    (call_indirect (type $out-i32) (i32.const 7))
   )
   (func (export "call-8") (type $out-i32)
-    (call_indirect $out-i32 (i32.const 8))
+    (call_indirect (type $out-i32) (i32.const 8))
   )
   (func (export "call-9") (type $out-i32)
-    (call_indirect $out-i32 (i32.const 9))
+    (call_indirect (type $out-i32) (i32.const 9))
   )
 )
 
diff --git a/test/core/func.wast b/test/core/func.wast
index c60782f0e..768a924a2 100644
--- a/test/core/func.wast
+++ b/test/core/func.wast
@@ -333,24 +333,24 @@
   )
 
   (func (export "signature-explicit-reused")
-    (call_indirect $sig (i32.const 1))
-    (call_indirect $sig (i32.const 4))
+    (call_indirect (type $sig) (i32.const 1))
+    (call_indirect (type $sig) (i32.const 4))
   )
 
   (func (export "signature-implicit-reused")
     ;; The implicit index 3 in this test depends on the function and
     ;; type definitions, and may need adapting if they change.
-    (call_indirect 3
+    (call_indirect (type 3)
       (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
       (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
       (i32.const 0)
     )
-    (call_indirect 3
+    (call_indirect (type 3)
       (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
       (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
       (i32.const 2)
     )
-    (call_indirect 3
+    (call_indirect (type 3)
       (f64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
       (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
       (i32.const 3)
@@ -358,16 +358,16 @@
   )
 
   (func (export "signature-explicit-duplicate")
-    (call_indirect $empty-sig-duplicate (i32.const 1))
+    (call_indirect (type $empty-sig-duplicate) (i32.const 1))
   )
 
   (func (export "signature-implicit-duplicate")
-    (call_indirect $complex-sig-duplicate
+    (call_indirect (type $complex-sig-duplicate)
       (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
       (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
       (i32.const 5)
     )
-    (call_indirect $complex-sig-duplicate
+    (call_indirect (type $complex-sig-duplicate)
       (i64.const 0) (i64.const 0) (f64.const 0) (i64.const 0)
       (f64.const 0) (i64.const 0) (f32.const 0) (i32.const 0)
       (i32.const 6)
diff --git a/test/core/func_ptrs.wast b/test/core/func_ptrs.wast
index ef54c5da0..b8050a833 100644
--- a/test/core/func_ptrs.wast
+++ b/test/core/func_ptrs.wast
@@ -60,11 +60,11 @@
   (func $u2 (type $U) (i32.const 5))
 
   (func (export "callt") (param $i i32) (result i32)
-    (call_indirect $T (get_local $i))
+    (call_indirect (type $T) (get_local $i))
   )
 
   (func (export "callu") (param $i i32) (result i32)
-    (call_indirect $U (get_local $i))
+    (call_indirect (type $U) (get_local $i))
   )
 )
 
@@ -98,7 +98,7 @@
   (func $t2 (type $T) (i32.const 2))
 
   (func (export "callt") (param $i i32) (result i32)
-    (call_indirect $T (get_local $i))
+    (call_indirect (type $T) (get_local $i))
   )
 )
 
diff --git a/test/core/imports.wast b/test/core/imports.wast
index e9a28dcdc..f5a557dbc 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -64,7 +64,7 @@
     (call $print_i32 (get_local $i))
     (call $print_i32-2 (get_local $i))
     (call $print_f32 (get_local $x))
-    (call_indirect $func_i32 (get_local $i) (i32.const 0))
+    (call_indirect (type $func_i32) (get_local $i) (i32.const 0))
   )
 
   (func (export "print64") (param $i i64)
@@ -80,7 +80,7 @@
     ;; (call $print_i64 (get_local $i))
     (call $print_f64 (get_local $x))
     (call $print_f64-2 (get_local $x))
-    (call_indirect $func_f64 (get_local $x) (i32.const 1))
+    (call_indirect (type $func_f64) (get_local $x) (i32.const 1))
   )
 )
 
@@ -265,7 +265,9 @@
   (import "spectest" "table" (table 10 20 anyfunc))
   (elem 0 (i32.const 1) $f $g)
 
-  (func (export "call") (param i32) (result i32) (call_indirect 0 (get_local 0)))
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (get_local 0))
+  )
   (func $f (result i32) (i32.const 11))
   (func $g (result i32) (i32.const 22))
 )
@@ -282,7 +284,9 @@
   (table (import "spectest" "table") 10 20 anyfunc)
   (elem 0 (i32.const 1) $f $g)
 
-  (func (export "call") (param i32) (result i32) (call_indirect 0 (get_local 0)))
+  (func (export "call") (param i32) (result i32)
+    (call_indirect (type 0) (get_local 0))
+  )
   (func $f (result i32) (i32.const 11))
   (func $g (result i32) (i32.const 22))
 )
diff --git a/test/core/left-to-right.wast b/test/core/left-to-right.wast
index 6214d0d5b..65d3809ac 100644
--- a/test/core/left-to-right.wast
+++ b/test/core/left-to-right.wast
@@ -88,7 +88,7 @@
   (func (export "i32_store8") (result i32) (call $reset) (i32.store8 (call $i32_left) (call $i32_right)) (call $get))
   (func (export "i32_store16") (result i32) (call $reset) (i32.store16 (call $i32_left) (call $i32_right)) (call $get))
   (func (export "i32_call") (result i32) (call $reset) (call $i32_dummy (call $i32_left) (call $i32_right)) (call $get))
-  (func (export "i32_call_indirect") (result i32) (call $reset) (drop (call_indirect $i32_T (call $i32_left) (call $i32_right) (call $i32_callee))) (call $get))
+  (func (export "i32_call_indirect") (result i32) (call $reset) (drop (call_indirect (type $i32_T) (call $i32_left) (call $i32_right) (call $i32_callee))) (call $get))
   (func (export "i32_select") (result i32) (call $reset) (drop (select (call $i32_left) (call $i32_right) (call $i32_bool))) (call $get))
 
   (func (export "i64_add") (result i32) (call $reset) (drop (i64.add (call $i64_left) (call $i64_right))) (call $get))
@@ -119,7 +119,7 @@
   (func (export "i64_store16") (result i32) (call $reset) (i64.store16 (call $i32_left) (call $i64_right)) (call $get))
   (func (export "i64_store32") (result i32) (call $reset) (i64.store32 (call $i32_left) (call $i64_right)) (call $get))
   (func (export "i64_call") (result i32) (call $reset) (call $i64_dummy (call $i64_left) (call $i64_right)) (call $get))
-  (func (export "i64_call_indirect") (result i32) (call $reset) (drop (call_indirect $i64_T (call $i64_left) (call $i64_right) (call $i64_callee))) (call $get))
+  (func (export "i64_call_indirect") (result i32) (call $reset) (drop (call_indirect (type $i64_T) (call $i64_left) (call $i64_right) (call $i64_callee))) (call $get))
   (func (export "i64_select") (result i32) (call $reset) (drop (select (call $i64_left) (call $i64_right) (call $i64_bool))) (call $get))
 
   (func (export "f32_add") (result i32) (call $reset) (drop (f32.add (call $f32_left) (call $f32_right))) (call $get))
@@ -137,7 +137,7 @@
   (func (export "f32_max") (result i32) (call $reset) (drop (f32.max (call $f32_left) (call $f32_right))) (call $get))
   (func (export "f32_store") (result i32) (call $reset) (f32.store (call $i32_left) (call $f32_right)) (call $get))
   (func (export "f32_call") (result i32) (call $reset) (call $f32_dummy (call $f32_left) (call $f32_right)) (call $get))
-  (func (export "f32_call_indirect") (result i32) (call $reset) (drop (call_indirect $f32_T (call $f32_left) (call $f32_right) (call $f32_callee))) (call $get))
+  (func (export "f32_call_indirect") (result i32) (call $reset) (drop (call_indirect (type $f32_T) (call $f32_left) (call $f32_right) (call $f32_callee))) (call $get))
   (func (export "f32_select") (result i32) (call $reset) (drop (select (call $f32_left) (call $f32_right) (call $f32_bool))) (call $get))
 
   (func (export "f64_add") (result i32) (call $reset) (drop (f64.add (call $f64_left) (call $f64_right))) (call $get))
@@ -155,7 +155,7 @@
   (func (export "f64_max") (result i32) (call $reset) (drop (f64.max (call $f64_left) (call $f64_right))) (call $get))
   (func (export "f64_store") (result i32) (call $reset) (f64.store (call $i32_left) (call $f64_right)) (call $get))
   (func (export "f64_call") (result i32) (call $reset) (call $f64_dummy (call $f64_left) (call $f64_right)) (call $get))
-  (func (export "f64_call_indirect") (result i32) (call $reset) (drop (call_indirect $f64_T (call $f64_left) (call $f64_right) (call $f64_callee))) (call $get))
+  (func (export "f64_call_indirect") (result i32) (call $reset) (drop (call_indirect (type $f64_T) (call $f64_left) (call $f64_right) (call $f64_callee))) (call $get))
   (func (export "f64_select") (result i32) (call $reset) (drop (select (call $f64_left) (call $f64_right) (call $f64_bool))) (call $get))
 
   (func (export "br_if") (result i32)
diff --git a/test/core/linking.wast b/test/core/linking.wast
index b2f0dd3db..73fbb93ba 100644
--- a/test/core/linking.wast
+++ b/test/core/linking.wast
@@ -71,7 +71,7 @@
   (func (export "h") (result i32) (i32.const -4))
 
   (func (export "call") (param i32) (result i32)
-    (call_indirect 0 (get_local 0))
+    (call_indirect (type 0) (get_local 0))
   )
 )
 (register "Mt" $Mt)
@@ -91,7 +91,7 @@
     (call $f (get_local 0))
   )
   (func (export "call") (param i32) (result i32)
-    (call_indirect 1 (get_local 0))
+    (call_indirect (type 1) (get_local 0))
   )
 )
 
@@ -127,7 +127,7 @@
   (func $i (result i32) (i32.const 6))
 
   (func (export "call") (param i32) (result i32)
-    (call_indirect 0 (get_local 0))
+    (call_indirect (type 0) (get_local 0))
   )
 )
 
diff --git a/test/core/return.wast b/test/core/return.wast
index 48964cffc..d483b5e51 100644
--- a/test/core/return.wast
+++ b/test/core/return.wast
@@ -124,16 +124,24 @@
   (type $sig (func (param i32 i32 i32) (result i32)))
   (table anyfunc (elem $f))
   (func (export "as-call_indirect-func") (result i32)
-    (call_indirect $sig (return (i32.const 20)) (i32.const 1) (i32.const 2) (i32.const 3))
+    (call_indirect (type $sig)
+      (return (i32.const 20)) (i32.const 1) (i32.const 2) (i32.const 3)
+    )
   )
   (func (export "as-call_indirect-first") (result i32)
-    (call_indirect $sig (i32.const 0) (return (i32.const 21)) (i32.const 2) (i32.const 3))
+    (call_indirect (type $sig)
+      (i32.const 0) (return (i32.const 21)) (i32.const 2) (i32.const 3)
+    )
   )
   (func (export "as-call_indirect-mid") (result i32)
-    (call_indirect $sig (i32.const 0) (i32.const 1) (return (i32.const 22)) (i32.const 3))
+    (call_indirect (type $sig)
+      (i32.const 0) (i32.const 1) (return (i32.const 22)) (i32.const 3)
+    )
   )
   (func (export "as-call_indirect-last") (result i32)
-    (call_indirect $sig (i32.const 0) (i32.const 1) (i32.const 2) (return (i32.const 23)))
+    (call_indirect (type $sig)
+      (i32.const 0) (i32.const 1) (i32.const 2) (return (i32.const 23))
+    )
   )
 
   (func (export "as-set_local-value") (result i32) (local f32)
diff --git a/test/core/typecheck.wast b/test/core/typecheck.wast
index 72f6f621f..b322b526f 100644
--- a/test/core/typecheck.wast
+++ b/test/core/typecheck.wast
@@ -234,7 +234,7 @@
     (func (type 0))
     (table 0 anyfunc)
     (func
-      (call_indirect 0 (i32.const 0) (f32.const 0))))
+      (call_indirect (type 0) (i32.const 0) (f32.const 0))))
   "type mismatch")
 
 ;; call_indirect index
@@ -243,7 +243,7 @@
     (type (func))
     (func (type 0))
     (table 0 anyfunc)
-    (func (call_indirect 0 (f32.const 0))))
+    (func (call_indirect (type 0) (f32.const 0))))
   "type mismatch")
 
 ;; return
diff --git a/test/core/unreachable.wast b/test/core/unreachable.wast
index 30df789e2..f7fe4030f 100644
--- a/test/core/unreachable.wast
+++ b/test/core/unreachable.wast
@@ -131,16 +131,24 @@
   (type $sig (func (param i32 i32 i32)))
   (table anyfunc (elem $dummy3))
   (func (export "as-call_indirect-func")
-    (call_indirect $sig (unreachable) (i32.const 1) (i32.const 2) (i32.const 3))
+    (call_indirect (type $sig)
+      (unreachable) (i32.const 1) (i32.const 2) (i32.const 3)
+    )
   )
   (func (export "as-call_indirect-first")
-    (call_indirect $sig (i32.const 0) (unreachable) (i32.const 2) (i32.const 3))
+    (call_indirect (type $sig)
+      (i32.const 0) (unreachable) (i32.const 2) (i32.const 3)
+    )
   )
   (func (export "as-call_indirect-mid")
-    (call_indirect $sig (i32.const 0) (i32.const 1) (unreachable) (i32.const 3))
+    (call_indirect (type $sig)
+      (i32.const 0) (i32.const 1) (unreachable) (i32.const 3)
+    )
   )
   (func (export "as-call_indirect-last")
-    (call_indirect $sig (i32.const 0) (i32.const 1) (i32.const 2) (unreachable))
+    (call_indirect (type $sig)
+      (i32.const 0) (i32.const 1) (i32.const 2) (unreachable)
+    )
   )
 
   (func (export "as-set_local-value") (local f32)

From f4e29263cbcdf60267291186ddebd90f82512402 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 22 Nov 2017 17:59:18 +0100
Subject: [PATCH 114/329] [spec] Fix variable names in instantiation (#604)

---
 document/core/appendix/properties.rst |  9 ++++++---
 document/core/exec/modules.rst        | 16 ++++++++--------
 2 files changed, 14 insertions(+), 11 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 9bd4918e1..51fb922a2 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -712,7 +712,7 @@ Given the definition of :ref:`valid configurations <valid-config>`,
 the standard soundness theorems hold.
 
 **Theorem (Preservation).**
-If the :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]` (i.e., :math:`\vdashconfig S;T : [t^\ast]`),
+If a :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]` (i.e., :math:`\vdashconfig S;T : [t^\ast]`),
 and steps to :math:`S';T'` (i.e., :math:`S;T \stepto S';T'`),
 then :math:`S';T'` is a valid configuration with the same resulttype (i.e., :math:`\vdashconfig S';T' : [t^\ast]`).
 Furthermore, :math:`S'` is an :ref:`extension <extend-store>` of :math:`S` (i.e., :math:`\vdashstoreextends S \extendsto S'`).
@@ -721,15 +721,18 @@ A *terminal* :ref:`thread <syntax-thread>` is one whose sequence of :ref:`instru
 A terminal configuration is a configuration whose thread is terminal.
 
 **Theorem (Progress).**
-If the :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` (i.e., :math:`\vdashconfig S;T : [t^\ast]` with some :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`),
+If a :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` (i.e., :math:`\vdashconfig S;T : [t^\ast]` for some :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`),
 then either it is terminal,
 or it can step to some configuration :math:`S';T'` (i.e., :math:`S;T \stepto S';T'`).
 
 From Preservation and Progress the soundness of the WebAssembly type system follows directly.
 
 **Corollary (Soundness).**
-Every thread in a valid configuration either runs forever, traps, or terminates with a result that has the expected type.
+If a :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` (i.e., :math:`\vdashconfig S;T : [t^\ast]` for some :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`),
+then it either diverges or takes a finite number of steps to reach a terminal configuration :math:`S';T'` (i.e., :math:`S;T \stepto^\ast S';T'`) that is valid with the same resulttype (i.e., :math:`\vdashconfig S';T' : [t^\ast]`)
+and where :math:`S'` is an :ref:`extension <extend-store>` of :math:`S` (i.e., :math:`\vdashstoreextends S \extendsto S'`).
 
+In other words, every thread in a valid configuration either runs forever, traps, or terminates with a result that has the expected type.
 Consequently, given a :ref:`valid store <valid-store>`, no computation defined by :ref:`instantiation <exec-instantiation>` or :ref:`invocation <exec-invocation>` of a valid module can "crash" or otherwise (mis)behave in ways not covered by the :ref:`execution <exec>` semantics given in this specification.
 
 
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index bf0d8b2be..6c258b462 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -555,17 +555,17 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
    a. Fail.
 
-2. Assert: :math:`\module` is :ref:`valid <valid-module>` with :ref:`external types <syntax-externtype>` :math:`\externtype^m` classifying its :ref:`imports <syntax-import>`.
+2. Assert: :math:`\module` is :ref:`valid <valid-module>` with :ref:`external types <syntax-externtype>` :math:`\externtype_{\F{im}}^m` classifying its :ref:`imports <syntax-import>`.
 
 3. If the number :math:`m` of :ref:`imports <syntax-import>` is not equal to the number :math:`n` of provided :ref:`external values <syntax-externval>`, then:
 
    a. Fail.
 
-4. For each :ref:`external value <syntax-externval>` :math:`\externval_i` in :math:`\externval^n` and :ref:`external type <syntax-externtype>` :math:`\externtype_i` in :math:`\externtype^n`, do:
+4. For each :ref:`external value <syntax-externval>` :math:`\externval_i` in :math:`\externval^n` and :ref:`external type <syntax-externtype>` :math:`\externtype'_i` in :math:`\externtype_{\F{im}}^n`, do:
 
-   a. Assert: :math:`\externval_i` is :ref:`valid <valid-externval>` with :ref:`external type <syntax-externtype>` :math:`\externtype'_i` in store :math:`S`.
+   a. Assert: :math:`\externval_i` is :ref:`valid <valid-externval>` with :ref:`external type <syntax-externtype>` :math:`\externtype_i` in store :math:`S`.
 
-   b. If :math:`\externtype'_i` does not :ref:`match <match-externtype>` :math:`\externtype_i`, then:
+   b. If :math:`\externtype_i` does not :ref:`match <match-externtype>` :math:`\externtype'_i`, then:
 
       i. Fail.
 
@@ -676,14 +676,14 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
      (\INVOKE~\funcaddr)^? \\
      \end{array} \\
    &(\iff
-     & \vdashmodule \module : \externtype^n \to {\externtype'}^\ast \\
-     &\wedge& (\vdashexternval \externval : \externtype')^n \\
-     &\wedge& (\vdashexterntypematch \externtype' \matches \externtype)^n \\[1ex]
+     & \vdashmodule \module : \externtype_{\F{im}}^n \to \externtype_{\F{ex}}^\ast \\
+     &\wedge& (\vdashexternval \externval : \externtype)^n \\
+     &\wedge& (\vdashexterntypematch \externtype \matches \externtype_{\F{im}})^n \\[1ex]
      &\wedge& \module.\MGLOBALS = \global^k \\
      &\wedge& \module.\MELEM = \elem^\ast \\
      &\wedge& \module.\MDATA = \data^\ast \\
      &\wedge& \module.\MSTART = \start^? \\[1ex]
-     &\wedge& S', \moduleinst = \F{allocmodule}(S, \module, \externval^n, v^\ast) \\
+     &\wedge& S', \moduleinst = \allocmodule(S, \module, \externval^n, v^\ast) \\
      &\wedge& F = \{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \} \\[1ex]
      &\wedge& (S'; F; \global.\GINIT \stepto^\ast S'; F; v)^\ast \\
      &\wedge& (S'; F; \elem.\EOFFSET \stepto^\ast S'; F; \I32.\CONST~\X{eo})^\ast \\

From 0a3c333e0b23e16441479f542c45425becbf325b Mon Sep 17 00:00:00 2001
From: Hugo Guiroux <gx.hugo@gmail.com>
Date: Mon, 27 Nov 2017 08:00:25 +0100
Subject: [PATCH 115/329] [spec] Typo in exec/modules (#606)

glboal => global
---
 document/core/exec/modules.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 6c258b462..5fb160f85 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -639,7 +639,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
 13. Pop the frame from the stack.
 
-14. Let :math:`\moduleinst` be a new module instance :ref:`allocated <alloc-module>` from :math:`\module` in store :math:`S` with imports :math:`\externval^\ast` and glboal initializer values :math:`\val^\ast`.
+14. Let :math:`\moduleinst` be a new module instance :ref:`allocated <alloc-module>` from :math:`\module` in store :math:`S` with imports :math:`\externval^\ast` and global initializer values :math:`\val^\ast`.
 
 15. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEM`, do:
 

From c5958edac541b1f63ccb79f73c30d54188ee7cc6 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Mon, 27 Nov 2017 14:41:30 +0100
Subject: [PATCH 116/329] Use the old subprocess API in test/build.py (#605)

---
 test/build.py | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/test/build.py b/test/build.py
index 2448f2e37..a3cf7f334 100755
--- a/test/build.py
+++ b/test/build.py
@@ -22,10 +22,10 @@
 
 # Helpers.
 def run(*cmd):
-    return subprocess.run(cmd,
-                          stdout=subprocess.PIPE,
-                          stderr=subprocess.STDOUT,
-                          universal_newlines=True)
+    return subprocess.call(cmd,
+                           stdout=subprocess.PIPE,
+                           stderr=subprocess.STDOUT,
+                           universal_newlines=True)
 
 # Preconditions.
 def ensure_remove_dir(path):
@@ -38,8 +38,8 @@ def ensure_empty_dir(path):
 
 def compile_wasm_interpreter():
     print("Recompiling the wasm interpreter...")
-    result = run('make', '-C', INTERPRETER_DIR)
-    if result.returncode != 0:
+    result = run('make', '-C', INTERPRETER_DIR, 'clean', 'default')
+    if result != 0:
         print("Couldn't recompile wasm spec interpreter")
         sys.exit(1)
     print("Done!")
@@ -49,7 +49,7 @@ def ensure_wasm_executable(path_to_wasm):
     Ensure we have built the wasm spec interpreter.
     """
     result = run(path_to_wasm, '-v', '-e', '')
-    if result.returncode != 0:
+    if result != 0:
         print('Unable to run the wasm executable')
         sys.exit(1)
 
@@ -75,7 +75,7 @@ def convert_wast_to_js(out_js_dir):
 
     pool = mp.Pool(processes=8)
     for result in pool.imap_unordered(convert_one_wast_file, inputs):
-        if result.returncode != 0:
+        if result != 0:
             print('Error when compiling {} to JS: {}', wast_file, result.stdout)
 
 def build_js(out_js_dir, include_harness=False):

From 5130369da8f8d925c339bf4ff3a35e531b72c9ad Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 30 Nov 2017 19:32:34 +0100
Subject: [PATCH 117/329] [spec] Fix block values (#609)

---
 document/core/exec/instructions.rst | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index fe08bd197..188c69328 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -964,24 +964,22 @@ Exiting :math:`\instr^\ast` with label :math:`L`
 
 When the end of a block is reached without a jump or trap aborting it, then the following steps are performed.
 
-1. Let :math:`n` be the arity of :math:`L`.
+1. Let :math:`m` be the number of values on the top of the stack.
 
-2. Assert: due to :ref:`validation <valid-instr-seq>`, there are :math:`n` values on the top of the stack.
+2. Pop the values :math:`\val^m` from the stack.
 
-3. Pop the results :math:`\val^n` from the stack.
+3. Assert: due to :ref:`validation <valid-instr-seq>`, the label :math:`L` is now on the top of the stack.
 
-4. Assert: due to :ref:`validation <valid-instr-seq>`, the label :math:`L` is now on the top of the stack.
+4. Pop the label from the stack.
 
-5. Pop the label from the stack.
+5. Push :math:`\val^m` back to the stack.
 
-6. Push :math:`\val^n` back to the stack.
-
-7. Jump to the position after the |END| of the :ref:`structured control instruction <syntax-instr-control>` associated with the label :math:`L`.
+6. Jump to the position after the |END| of the :ref:`structured control instruction <syntax-instr-control>` associated with the label :math:`L`.
 
 .. math::
    ~\\[-1ex]
    \begin{array}{lcl@{\qquad}l}
-   \LABEL_n\{\instr^\ast\}~\val^n~\END &\stepto& \val^n
+   \LABEL_n\{\instr^\ast\}~\val^m~\END &\stepto& \val^m
    \end{array}
 
 .. note::

From c607272d5564056f74930dccf6eca479bb647fee Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Mon, 4 Dec 2017 10:59:27 -0800
Subject: [PATCH 118/329] [spec] Fix validation of `call_indirect` (#615)

See issue #612.
---
 document/core/valid/instructions.rst | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index fbc534785..b95aa018f 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -667,7 +667,9 @@ Control Instructions
 
 * The type :math:`C.\CTYPES[x]` must be defined in the context.
 
-* Then the instruction is valid with type :math:`C.\CTYPES[x]`.
+* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`C.\CTYPES[x]`.
+
+* Then the instruction is valid with type :math:`[t_1^\ast~\I32] \to [t_2^\ast]`.
 
 .. math::
    \frac{
@@ -675,7 +677,7 @@ Control Instructions
      \qquad
      C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
    }{
-     C \vdashinstr \CALLINDIRECT~x : [t_1^\ast] \to [t_2^\ast]
+     C \vdashinstr \CALLINDIRECT~x : [t_1^\ast~\I32] \to [t_2^\ast]
    }
 
 

From 16d3cdd8f17984c5d552f25a1d5c0e34e38df95e Mon Sep 17 00:00:00 2001
From: Hugo Guiroux <gx.hugo@gmail.com>
Date: Tue, 5 Dec 2017 10:59:53 +0100
Subject: [PATCH 119/329] [spec] read_table returns an optional function
 address (#614)

---
 document/core/appendix/embedding.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index 43d63997e..12a329514 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -326,8 +326,8 @@ Tables
 
 .. _embed-read-table:
 
-:math:`\F{read\_table}(\store, \tableaddr, i) : \funcaddr ~|~ \error`
-.....................................................................
+:math:`\F{read\_table}(\store, \tableaddr, i) : \funcaddr^? ~|~ \error`
+.......................................................................
 
 1. Assert: :math:`\store.\STABLES[\tableaddr]` exists.
 

From d15cabb244420016058d826cbcf8e469c14782fe Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 6 Dec 2017 22:04:31 +0100
Subject: [PATCH 120/329] WebAssembly JS and Web integration spec in Bikeshed
 (#591)

* WebAssembly JS integraton spec in Bikeshed

Initial checkin, JS.bs is converted from JS.md with
updates to reference the current Wasm specification.

* Various cleanups/fixes:

- Ensure that not passing a maximum Memory size in the object will not
  create a maximum in Wasm.
- Clean up notes about object deduplication in instantiate.
- Refer to Promises guide everywhere.
- Remove duplicate buffer cloning.

* Improve threading

* Initial checkin of web interface

* Name WebAssembly CG as the editor (I'm not sure who should be editor)

* Fix formatting and queue instantiate(module) tasks appropriately

* Changes based on review from @domenic, @rossberg and @binji

* More changes from review by @domenic and @rossberg

* More changes from review

* Move

* More changes from review

- Formalize the process of getting a name for exported functions (including
  passing on the name of re-exported host functions)
- Link to ECMAScript bug for Memory detach behavior
- Some wording clarifications
- Extract out creation of a host function for clarity

* More precise wording for decoding success assertion

* Move specs to index.bs

* Respond to review feedback

* Respond to review from @annevk

* Respond to review from @lukewagner
---
 document/js-api/index.bs | 866 +++++++++++++++++++++++++++++++++++++++
 document/web/index.bs    | 189 +++++++++
 2 files changed, 1055 insertions(+)
 create mode 100644 document/js-api/index.bs
 create mode 100644 document/web/index.bs

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
new file mode 100644
index 000000000..ced1e3b34
--- /dev/null
+++ b/document/js-api/index.bs
@@ -0,0 +1,866 @@
+<pre class='metadata'>
+Title: WebAssembly JavaScript Interface
+Shortname: wasmjs
+Group: WebAssembly CG
+Status: w3c/CG-DRAFT
+Level: 1
+ED: https://webassembly.github.io/spec/js-api/
+Editor: WebAssembly Community Group
+Repository: WebAssembly/spec
+Abstract: This document provides an explicit JavaScript API for interacting with WebAssembly.
+Markup Shorthands: css no, markdown yes
+</pre>
+
+<pre class='biblio'>
+{
+  "WEBASSEMBLY": {
+    "href": "https://webassembly.github.io/spec/",
+    "title": "WebAssembly Specification",
+    "publisher": "W3C WebAssembly Community Group",
+    "status": "Draft"
+  }
+}
+</pre>
+
+<pre class="anchors">
+urlPrefix: https://tc39.github.io/ecma262/; spec: ECMASCRIPT
+    type: interface; for: ECMAScript
+        text: ArrayBuffer; url: sec-arraybuffer-objects
+    type: exception; for: ECMAScript
+        text: Error; url: sec-error-objects
+        text: NativeError; url: sec-nativeerror-constructors
+        text: TypeError; url: sec-native-error-types-used-in-this-standard-typeerror
+        text: RangeError; url: sec-native-error-types-used-in-this-standard-rangeerror
+    type: dfn
+        text: agent cluster; url: sec-agent-clusters
+        text: agent; url: agent
+        text: data block; url: sec-data-blocks
+        text: Bound Function; url: sec-bound-function-exotic-objects
+        text: NumericLiteral; url: sec-literals-numeric-literals
+        text: ToNumber; url: sec-tonumber
+        text: ToInt32; url: sec-toint32
+        text: ToString; url: sec-tostring
+        url: sec-ecmascript-data-types-and-values
+            text: Type
+            text: Type(x)
+        url: sec-iscallable
+            text: IsCallable
+            text: callable; for: ECMAScript
+        url: sec-well-known-intrinsic-objects
+            text: %ErrorPrototype%
+        text: %ObjectPrototype%; url: sec-properties-of-the-object-prototype-object
+        text: %FunctionPrototype%; url: sec-properties-of-the-function-prototype-object
+        text: %Promise%; url: sec-promise-constructor
+        text: Property Descriptor; url: sec-property-descriptor-specification-type
+        text: array index; url: sec-array-exotic-objects
+        text: OrdinaryGetOwnProperty; url: sec-ordinarygetownproperty
+        text: OrdinaryDefineOwnProperty; url: sec-ordinarydefineownproperty
+        text: OrdinaryPreventExtensions; url: sec-ordinarypreventextensions
+        text: OrdinarySet; url: sec-ordinaryset
+        text: equally close values; url: sec-ecmascript-language-types-number-type
+        text: internal slot; url: sec-object-internal-methods-and-internal-slots
+        text: JavaScript execution context stack; url: execution-context-stack
+        text: running JavaScript execution context; url: running-execution-context
+        text: GetIterator; url: sec-getiterator
+        text: IteratorStep; url: sec-iteratorstep
+        text: NormalCompletion; url: sec-normalcompletion
+        text: IteratorValue; url: sec-iteratorvalue
+        url: sec-well-known-symbols
+            text: @@iterator
+            text: @@toStringTag
+        text: CreateDataProperty; url: sec-createdataproperty
+        text: DetachArrayBuffer; url: sec-detacharraybuffer
+        text: SetIntegrityLevel; url: sec-setintegritylevel
+        text: Call; url: sec-call
+        text: Get; url: sec-get-o-p
+        text: DefinePropertyOrThrow; url: sec-definepropertyorthrow
+        text: current Realm; url: current-realm
+        text: ObjectCreate; url: sec-objectcreate
+        text: CreateBuiltinFunction; url: sec-createbuiltinfunction
+        text: SetFunctionName; url: sec-setfunctionname
+        text: the Number value; url: sec-ecmascript-language-types-number-type
+        text: NumberToRawBytes; url: sec-numbertorawbytes
+        text: Built-in Function Objects; url: sec-built-in-function-objects
+urlPrefix: https://webassembly.github.io/spec/; spec: WebAssembly; type: dfn
+    url: valid/modules.html#valid-module
+        text: valid
+        text: WebAssembly module validation
+    text: binary format of a module; url: binary/modules.html
+    text: custom section; url: binary/modules.html#custom-section
+    text: customsec; url: binary/modules.html#binary-customsec
+    text: memory instance; url: exec/runtime.html#memory-instances
+    text: table instance; url: exec/runtime.html#table-instances
+    text: trap; url: exec/runtime.html#syntax-trap
+    url: exec/runtime.html#values
+        text: WebAssembly value
+        text: 𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍
+        text: 𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍
+        text: 𝖿𝟥𝟤.𝖼𝗈𝗇𝗌𝗍
+        text: 𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍
+    text: function index; url: syntax/modules.html#syntax-funcidx
+    text: function instance; url: exec/runtime.html#function-instances
+    text: init_store; url: appendix/embedding.html#embed-init-store
+    text: decode_module; url: appendix/embedding.html#embed-decode-module
+    text: validate_module; url: appendix/embedding.html#embed-validate-module
+    text: instantiate_module; url: appendix/embedding.html#embed-instantiate-module
+    text: module_imports; url: appendix/embedding.html#embed-imports
+    text: get_export; url: appendix/embedding.html#embed-get-export
+    text: alloc_func; url: appendix/embedding.html#embed-alloc-func
+    text: type_func; url: appendix/embedding.html#embed-type-func
+    text: invoke_func; url: appendix/embedding.html#embed-invoke-func
+    text: alloc_table; url: appendix/embedding.html#embed-alloc-table
+    text: type_table; url: appendix/embedding.html#embed-type-table
+    text: read_table; url: appendix/embedding.html#embed-read-table
+    text: write_table; url: appendix/embedding.html#embed-write-table
+    text: grow_table; url: appendix/embedding.html#embed-grow-table
+    text: alloc_mem; url: appendix/embedding.html#embed-alloc-mem
+    text: type_mem; url: appendix/embedding.html#embed-type-mem
+    text: read_mem; url: appendix/embedding.html#embed-read-mem
+    text: write_mem; url: appendix/embedding.html#embed-write-mem
+    text: grow_mem; url: appendix/embedding.html#embed-grow-mem
+    text: alloc_global; url: appendix/embedding.html#embed-alloc-global
+    text: type_global; url: appendix/embedding.html#embed-type-global
+    text: read_global; url: appendix/embedding.html#embed-read-global
+    text: write_global; url: appendix/embedding.html#embed-write-global
+    text: module_exports; url: appendix/embedding.html#embed-exports
+    text: error; url: appendix/embedding.html#embed-error
+    text: store; url: exec/runtime.html#syntax-store
+    text: table type; url: syntax/types.html#syntax-tabletype
+    text: table address; url: exec/runtime.html#syntax-tableaddr
+    text: function address; url: exec/runtime.html#syntax-funcaddr
+    text: memory address; url: exec/runtime.html#syntax-memaddr
+    url: syntax/types.html#syntax-valtype
+        text: 𝗂𝟥𝟤
+        text: 𝗂𝟨𝟦
+        text: 𝖿𝟥𝟤
+        text: 𝖿𝟨𝟦
+    text: function element; url: exec/runtime.html#syntax-funcelem
+    text: import component; url: syntax/modules.html#imports
+    text: external value; url: exec/runtime.html#syntax-externval
+    text: host function; url: exec/runtime.html#syntax-hostfunc
+    text: the instantiation algorithm; url: exec/modules.html#instantiation
+    text: size_table; url: appendix/embedding.html#embed-size-table
+    text: size_mem; url: appendix/embedding.html#embed-size-mem
+    text: module; url: syntax/modules.html#syntax-module
+    text: 𝗂𝗆𝗉𝗈𝗋𝗍𝗌; url: syntax/modules.html#syntax-module
+    url: syntax/types.html#external-types
+        text: external type
+        text: 𝖿𝗎𝗇𝖼
+        text: 𝗍𝖺𝖻𝗅𝖾
+        text: 𝗆𝖾𝗆
+        text: 𝗀𝗅𝗈𝖻𝖺𝗅
+    text: global type; url: syntax/types.html#syntax-globaltype
+</pre>
+
+<pre class='link-defaults'>
+spec:infra; type:dfn; text:list
+spec:ecma-262; type:exception; for:ECMAScript; text:Error
+spec:infra; type:dfn; for:set; text:append
+spec:ecmascript; type:exception; for:ECMAScript; text:TypeError
+spec:ecmascript; type:exception; for:ECMAScript; text:RangeError
+spec:ecmascript; type:interface; for:ECMAScript; text:ArrayBuffer
+</pre>
+
+Issue: This document is an early draft, porting <a href="https://github.com/WebAssembly/design/blob/master/JS.md">the official JS/WebAssembly interface specification</a> to WebIDL and Bikeshed. It should currently not be used as the WebAssembly specification.
+
+This API is, initially, the only API for accessing WebAssembly [[WEBASSEMBLY]] from the web platform, through a bridge to explicitly construct modules from ECMAScript [[ECMASCRIPT]].
+
+Issue: In future versions, WebAssembly may
+be loaded and run directly from an HTML `<script type='module'>` tag—and
+any other Web API that loads ES6 modules via URL—as part of
+[ES6 Module integration](https://github.com/WebAssembly/design/issues/1087).)
+
+Note: WebAssembly JS API declaration file for TypeScript can be found [here](https://github.com/01alchemist/webassembly-types/blob/master/webassembly.d.ts) which enable autocompletion and make TypeScript compiler happy.
+
+<h2 id="sample">Sample API Usage</h2>
+
+<p><em>This section is non-normative.</em></p>
+
+Given `demo.wat` (encoded to `demo.wasm`):
+
+```lisp
+(module
+    (import "js" "import1" (func $i1))
+    (import "js" "import2" (func $i2))
+    (func $main (call $i1))
+    (start $main)
+    (func (export "f") (call $i2))
+)
+```
+
+and the following JavaScript, run in a browser:
+
+```javascript
+var importObj = {js: {
+    import1: () => console.log("hello,"),
+    import2: () => console.log("world!")
+}};
+fetch('demo.wasm').then(response =>
+    response.arrayBuffer()
+).then(buffer =>
+    WebAssembly.instantiate(buffer, importObj)
+).then(({module, instance}) =>
+    instance.exports.f()
+);
+```
+
+<h2 id="webassembly-namespace">The WebAssembly Namespace</h2>
+
+<pre class="idl">
+dictionary WebAssemblyInstantiatedSource {
+    required Module module;
+    required Instance instance;
+};
+
+[Exposed=(Window,Worker,Worklet)]
+namespace WebAssembly {
+    boolean validate(BufferSource bytes);
+    Promise&lt;Module> compile(BufferSource bytes);
+
+    Promise&lt;WebAssemblyInstantiatedSource> instantiate(
+        BufferSource bytes, optional object importObject);
+
+    Promise&lt;Instance> instantiate(
+        Module moduleObject, optional object importObject);
+};
+</pre>
+
+<!--
+Should we include notes describing what the functions do, as the HTML spec does? It could look like this:
+
+Note:
+  WebAssembly.validate(|bytes|) synchronously validates bytes of WebAssembly, returning true if the validation was successful.
+  WebAssembly.compile(|bytes|) asynchronously validates and complies bytes of WebAssembly into a Module.
+  WebAssembly.instantiate(|bytes|, |importObject|) asynchronously compiles and instantiates a WebAssembly module from bytes of source.
+  The WebAssembly.instantiate(|moduleObject|, |importObject|) asynchronously instantiates a compiled module.
+-->
+
+<div algorithm>
+  To <dfn>compile a WebAssembly module</dfn> from a {{BufferSource}} |bytes|, perform the following steps:
+    1. Let |module| be [=decode_module=](|bytes|). If |module| is [=error=], return [=error=].
+    1. If [=validate_module=](|module|) is [=error=], return [=error=].
+    1. Return |module|.
+</div>
+
+<div algorithm>
+  The <dfn method for="WebAssembly">validate(bytes)</dfn> method, when invoked, performs the following steps:
+    1. [=Compile a WebAssembly module|Compile=] |bytes| as a WebAssembly module and store the results as |module|.
+    1. If |module| is [=error=], return false.
+    1. Return true.
+</div>
+
+<div>
+A {{Module}} object represents a single WebAssembly module. Each {{Module}} object has two internal slots:
+
+    * \[[Module]] : a WebAssembly [=module=]
+    * \[[Bytes]] : an {{ArrayBuffer}} which is source bytes of \[[Module]].
+</div>
+
+<div algorithm>
+  To <dfn>construct a WebAssembly module object</dfn> from a module |module| and source bytes |bytes|, perform the following steps:
+
+    1. Let |moduleObject| be a new {{Module}} object.
+    1. Set |moduleObject|.\[[Module]] to |module|.
+    1. Set |moduleObject|.\[[Bytes]] to |bytes|.
+    1. Return |moduleObject|.
+</div>
+
+<div algorithm>
+  To <dfn>asynchronously compile a WebAssembly module</dfn> from a {{BufferSource}} |bytes|, with the promise |promise|, using optional [=task source=] |taskSource|, perform the following steps:
+
+    1. In parallel, [=compile a WebAssembly module|compile the WebAssembly module=] |bytes| and store the result as |module|.
+    1. When the above operation completes, [=queue a task=] to perform the following steps. If |taskSource| was provided, queue the task on that task source.
+        1. If |module| is [=error=], reject |promise| with a {{CompileError}} exception.
+        1. Otherwise,
+            1. [=Construct a WebAssembly module object=] from |module| and |bytes|, and let |moduleObject| be the result.
+            1. [=Resolve=] |promise| with |moduleObject|.
+</div>
+
+<div algorithm>
+    The <dfn method for="WebAssembly">compile(bytes)</dfn> method, when invoked, performs the following steps:
+    1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes|.
+    1. Let |promise| be [=a new promise=].
+    1. [=Asynchronously compile a WebAssembly module=] from |stableBytes| with |promise|.
+    1. Return |promise|.
+</div>
+
+<div algorithm>
+  To <dfn>instantiate a WebAssembly module</dfn> from a {{Module}} |moduleObject| and imports |importObject|, perform the following steps:
+    1. Let |module| be |moduleObject|.\[[Module]].
+    1. If |module|.[=𝗂𝗆𝗉𝗈𝗋𝗍𝗌=] is not an empty list, and |importObject| is undefined, throw a {{TypeError}} exception.
+    1. Let |funcs| be an empty [=list=] of callable JavaScript objects.
+    1. Let |memories| be an empty [=list=] of {{Memory}} objects.
+    1. Let |tables| be an empty [=list=] of {{Table}} objects.
+
+        Note: The |funcs|, |memories| and |tables| lists are collected and used in order to cache the JavaScript objects corresponding to WebAssembly objects. If a WebAssembly object is exported multiple times, it will appear in exports as the same object instance. Moreover, if a JavaScript wrapper of a WebAssembly object was imported, and then present on the export, a new wrapper will not need to be created. However, if an ordinary JS function is imported, it will appear as wrapped by an [=Exported Function=].
+
+    6. Let |imports| be an empty [=list=] of [=external value=]s.
+    1. For each (|moduleName|, |componentName|, |externtype|) in [=module_imports=](|module|), do
+        1. Let |o| be ? [=Get=](|importObject|, |moduleName|).
+        1. If [=Type=](|o|) is not [=Object=], throw a {{TypeError}} exception.
+        1. Let |v| be ? [=Get=](|o|, |componentName|)
+        1. If |externtype| is of the form [=𝖿𝗎𝗇𝖼=] |functype|,
+            1. If [=IsCallable=](|v|) is false, throw a {{LinkError}} exception.
+            1. If |v| has a \[[FunctionAddress]] internal slot, and therefore is an [=Exported Function=],
+                1. Let |funcaddr| be the value of |v|'s \[[FunctionAddress]] internal slot.
+
+                Note: The signature is checked by [=instantiate_module=] invoked below.
+
+                2. [=Append=] |v| to |funcs|.
+            1. Otherwise,
+                1. [=Create a host function=] from |v| and let |funcaddr| be the result.
+            1. Let |externfunc| be the [=external value=] [=external value|𝖿𝗎𝗇𝖼=] |funcaddr|
+            1. [=Append=] |externfunc| to |imports|.
+        1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] |globaltype|,
+            1. If |globaltype| is [=𝗂𝟨𝟦=] or [=Type=](|v|) is not [=Number=], throw a {{LinkError}} exception.
+            1. Let |value| be [=ToWebAssemblyValue=](|v|, |globaltype|.<em>[=global type|valtype=]</em>)
+            1. Assert: |globaltype|.<em>[=global type|mut=]</em> is [=global type|𝖼𝗈𝗇𝗌𝗍=], as verified by WebAssembly validation.
+            1. Let |store| be the current agent's [=associated store=].
+            1. Let (|store|, |globaladdr|) be [=alloc_global=](|store|, |globaltype|, |value|).
+            1. Set the current agent's [=associated store=] to |store|.
+            1. Let |externglobal| be [=external value|𝗀𝗅𝗈𝖻𝖺𝗅=] |globaladdr|.
+            1. [=Append=] |externglobal| to |imports|.
+        1. If |externtype| is of the form [=𝗆𝖾𝗆=] |memtype|,
+            1. If |v| is not a {{Memory}} object, throw a {{LinkError}} exception.
+
+            Note: [=instantiate_module=] invoked below will check the imported {{Memory}}'s size against the importing module's requirements.
+
+            2. [=Append=] |v| to |memories|.
+            1. Let |externmem| be the [=external value=] [=external value|𝗆𝖾𝗆=]  |v|.\[[Memory]].
+            1. [=Append=] |externmem| to |imports|.
+        1. Otherwise, |externtype| is of the form [=𝗍𝖺𝖻𝗅𝖾=] |tabletype|,
+            1. If |v| is not a {{Table}} instance, throw a {{LinkError}} exception.
+
+            Note: The table's length, etc. is checked by [=instantiate_module=] invoked below.
+
+            2. [=Append=] |v| to |tables|.
+            1. Let |tableaddr| be |v|.\[[Table]]
+            1. Let |externtable| be the [=external value=] [=external value|𝗍𝖺𝖻𝗅𝖾=] |tableaddr|.
+            1. [=Append=] |externtable| to |imports|.
+            1. For each element |func| of |v|.\[[Values]],
+                1. If |func| is not null, append |func| to |funcs|.
+    1. Let (|store|, |instance|) be [=instantiate_module=](|store|, |module|, |imports|), up through step 16 of [=the instantiation algorithm=], but omitting execution of the start function.
+    1. If |instance| is [=error=], throw a {{LinkError}} exception, or other <a href="#errors">appropriate exception type</a>.
+    1. For each |tableaddr| in |instance|.𝗍𝖺𝖻𝗅𝖾𝖺𝖽𝖽𝗋𝗌,
+        1. If there is no element in |tables| whose |table|.\[[Table]] is |tableaddr|:
+            1. Let |table| be [=create a table object|a new table object=] from |tableaddr|.
+            1. [=Append=] |table| to |tables|.
+        1. Otherwise:
+            1. Let |table| be the element in |tables| where |table|.\[[Table]] is |tableaddr|.
+        1. For each index |i| from 0 to the length of |table|.\[[Values]] &minus; 1, do
+            1. Let |funcaddr| be [=read_table=](|store|, |tableaddr|, |i|).
+            1. Assert: |funcaddr| is not [=error=] because this read is in bounds.
+            1. If |funcaddr| is not empty,
+                1. If |funcs| contains any |func| where |func|.\[[ExportedAddress]] is |funcaddr|,
+                    1. Let |func| be that function object.
+                1. Otherwise:
+                    1. Let |func| be a [=a new Exported Function=] created from |funcaddr|.
+                    1. [=Append=] |func| to |funcs|.
+                1. Set the |table|.\[[Values]][|i|] to |func|.
+
+                Note: The table and function objects created by the above steps are only observable for tables that are either imported or exported.
+
+    1. Let |startfuncaddr| be the start function of |instance|.
+    1. Let (|store|, |ret|) be [=invoke_func=](|store|, |startfuncaddr|, empty).
+    1. If |ret| is [=error=], throw an exception. This exception should be a WebAssembly {{RuntimeError}} exception, unless otherwise indicated by <a href="#errors">the WebAssembly error mapping</a>.
+    1. Assert: |ret| is empty.
+    1. Let |exportsObject| be ! [=ObjectCreate=](null).
+    1. For each pair (|nameBytes|, |externtype|) in [=module_exports=](|module|),
+        1. Let |name| be |nameBytes| [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
+        1. Assert: |name| is not failure (|module| is [=valid=]).
+        1. Let |externval| be [=get_export=](|instance|, |name|).
+        1. If |externtype| is of the form [=𝖿𝗎𝗇𝖼=] |functype|,
+            1. If |funcs| contains an entry |func| where 𝖿𝗎𝗇𝖼 |func|.\[[FunctionAddress]] is |externval|, let |value| be |func|
+            1. Otherwise,
+                1. Let |func| be the result of [=a new Exported Function=] from |externval|.
+                1. [=Append=] |func| to |funcs|.
+                1. Let |value| be |func|.
+        1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] |globaltype|,
+            1. If |globaltype|.<em>[=global type|valtype=]</em>) is [=𝗂𝟨𝟦=], throw a {{LinkError}} exception.
+            1. Assert: |globaltype|.<em>[=global type|mut=]</em> is [=global type|𝖼𝗈𝗇𝗌𝗍=], as verified by WebAssembly validation.
+            1. Let |value| be [=ToJSValue=]([=read_global=](|store|, |externval|)).
+        1. If |externtype| is of the form [=𝗆𝖾𝗆=] |memtype|,
+            1. If there is an element |memory| in |memories| such that 𝗆𝖾𝗆  |memory|.\[[Memory]] is |externval|, then let |value| be |memory|
+            1. Otherwise:
+                1. Let |memory| be [=create a memory object|a new Memory object=] from |externval|.
+                1. [=Append=] |memory| to |memories|.
+                1. Let |value| be |memory|.
+        1. Otherwise, |externtype| is of the form [=𝗍𝖺𝖻𝗅𝖾=] |tabletype|,
+            1. Let |value| be the unique |table| in |tables| such that 𝗍𝖺𝖻𝗅𝖾 |table|.\[[Table]] is |externval|.
+        1. Let |status| be ! [=CreateDataProperty=](|exportsObject|, |name|, |value|).
+        1. Assert: |status| is true.
+
+        Note: the validity and uniqueness checks performed during [=WebAssembly module validation=] ensure that each property name is valid and no properties are defined twice.
+
+    33. Perform ! [=SetIntegrityLevel=](|exportsObject|, `"frozen"`).
+    1. Let |instanceObject| be a new {{Instance}} object whose internal \[[Instance]] slot is set to |instance| and the \[[Exports]] slot to |exportsObject|.
+    1. Return |instanceObject|.
+</div>
+
+<div algorithm>
+  To <dfn>instantiate a promise of a module</dfn> |promiseOfModule| with imports |importObject|, perform the following steps:
+
+    1. Let |promise| be [=a new promise=]
+    1. [=Upon fulfillment=] of |promiseOfModule| with value |module|:
+        1. [=instantiate a WebAssembly module|Instantiate the WebAssembly module=] |module| importing |importObject|, and let |instance| be the result.  If this throws an exception, catch it, [=reject=] |promise| with the exception, and abort these substeps.
+        1. Let |result| be a {{WebAssemblyInstantiatedSource}} dictionary with {{WebAssemblyInstantiatedSource/module}} set to |module| and {{WebAssemblyInstantiatedSource/instance}} set to |instance|.
+        1. [=Resolve=] |promise| with |result|.
+    1. [=Upon rejection=] of |promiseOfModule| with reason |reason|:
+        1. [=Reject=] |promise| with |reason|.
+    1. Return |promise|.
+
+    Note: It would be valid to perform certain parts of the instantiation [=in parallel=], but several parts need to happen in the event loop, including JavaScript operations to access the |importObject| and execution of the start function.
+</div>
+
+<div algorithm>
+  The <dfn method for="WebAssembly">instantiate(bytes, importObject)</dfn> method, when invoked, performs the following steps:
+    1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes|.
+    1. Let |promiseOfModule| be [=a new promise=].
+    1. [=Asynchronously compile a WebAssembly module=] from |stableBytes| with |promiseOfModule|.
+    1. [=Instantiate a promise of a module|Instantiate=] |promiseOfModule| with imports |importObject| and return the result.
+</div>
+
+<div algorithm>
+  The <dfn method for="WebAssembly">instantiate(moduleObject, importObject)</dfn> method, when invoked, performs the following steps:
+    1. Let |promise| be [=a new promise=].
+    1. [=Queue a task=] to perform the following steps:
+        1. [=instantiate a WebAssembly module|Instantiate the WebAssembly module=] |module| importing |importObject|, and let |instance| be the result.  If this throws an exception, catch it, and [=reject=] |promise| with the exception.
+        1. [=Resolve=] |promise| with |instance|.
+    1. Return |promise|
+</div>
+
+Note: A follow-on streaming API is documented in the <a href="https://webassembly.github.io/spec/document/web/index.html">WebAssembly Web API</a>.
+
+<h3 id="modules">Modules</h3>
+
+<pre class="idl">
+enum ImportExportKind {
+  "function",
+  "table",
+  "memory",
+  "global"
+};
+
+dictionary ModuleExportDescriptor {
+  required DOMString name;
+  required ImportExportKind kind;
+  // Note: Other fields such as signature may be added in the future.
+};
+
+dictionary ModuleImportDescriptor {
+  required DOMString module;
+  required DOMString name;
+  required ImportExportKind kind;
+};
+
+[LegacyNamespace=WebAssembly, Constructor(BufferSource bytes), Exposed=(Window,Worker,Worklet)]
+interface Module {
+  static sequence&lt;ModuleExportDescriptor> exports(Module module);
+  static sequence&lt;ModuleImportDescriptor> imports(Module module);
+  static sequence&lt;ArrayBuffer> customSections(Module module, DOMString sectionName);
+};
+</pre>
+
+<div algorithm>
+  The <dfn>string value of the extern type</dfn> |type| is
+    * "function" if |type| is of the form [=𝖿𝗎𝗇𝖼=] functype
+    * "table" if |type| is of the form [=𝗍𝖺𝖻𝗅𝖾=] tabletype
+    * "memory" if |type| is of the form [=𝗆𝖾𝗆=] memtype
+    * "global" if |type| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] globaltype
+</div>
+
+<div algorithm>
+    The <dfn method for="Module">exports(moduleObject)</dfn> method, when invoked, performs the following steps:
+    1. Let |module| be |moduleObject|.\[[Module]].
+    1. Let |exports| be an empty [=list=].
+    1. For each (|nameBytes|, |type|) in [=module_exports=](|module|)
+        1. Let |name| be |nameBytes| [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
+        1. Assert: |name| is not failure (|module| is [=valid=]).
+        1. Let |kind| be the [=string value of the extern type=] |type|.
+        1. Let |obj| be a new {{ModuleExportDescriptor}} dictionary with {{ModuleExportDescriptor/name}} |name| and {{ModuleExportDescriptor/kind}} |kind|.
+        1. [=Append=] |obj| to the end of |exports|.
+    1. Return |exports|.
+</div>
+
+<div algorithm>
+    The <dfn method for="Module">imports(moduleObject)</dfn> method, when invoked, performs the following steps:
+    1. Let |module| be |moduleObject|.\[[Module]].
+    1. Let |imports| be an empty [=list=].
+    1. For each (|moduleBytes|, |nameBytes|, |type|) in [=module_imports=](|module|),
+        1. Let |moduleName| be |moduleBytes| [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
+        1. Let |name| be |nameBytes| [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
+        1. Assert: The previous operations are not failure, as |module| is [=valid=].
+        1. Let |kind| be the [=string value of the extern type=] |type|.
+        1. Let |obj| be a new {{ModuleImportDescriptor}} dictionary with {{ModuleImportDescriptor/module}} |moduleName|, {{ModuleImportDescriptor/name}} |name| and {{ModuleImportDescriptor/kind}} |kind|.
+        1. [=Append=] |obj| to the end of |imports|.
+    1. Return |imports|.
+</div>
+
+<div algorithm>
+    The <dfn method for="Module">customSections(moduleObject, sectionName)</dfn> method, when invoked, performs the following steps:
+    1. Let |bytes| be |moduleObject|.\[[Bytes]].
+    1. Let |customSections| be an empty [=list=] of {{ArrayBuffer}}s.
+    1. For each [=custom section=] |customSection| in the binary format of |bytes|,
+        1. Let |name| be the <code>name</code> of the custom section, [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
+        1. Assert: |name| is not failure (|moduleObject|.\[[Module]] is [=valid=]).
+        1. If |name| equals |secondName| as string values,
+            1. [=Append=] a new {{ArrayBuffer}} containing a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes| for the range matched by this [=customsec=] production.
+    1. Return |customSections|.
+</div>
+
+<div algorithm>
+    The <dfn constructor for="Module">Module(bytes)</dfn> constructor, when invoked, performs the follwing steps:
+
+    1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes|.
+    1. [=Compile a WebAssembly module|Compile the WebAssembly module=] |stableBytes| and store the result as |module|.
+    1. If |module| is [=error=], throw a {{CompileError}} exception.
+    1. [=Construct a WebAssembly module object=] from |module| and |bytes|, and return the result.
+</div>
+
+<h3 id="instances">Instances</h3>
+
+<pre class="idl">
+[LegacyNamespace=WebAssembly, Constructor(Module module, optional object importObject), Exposed=(Window,Worker,Worklet)]
+interface Instance {
+  readonly attribute object exports;
+};
+</pre>
+
+<div algorithm>
+    The <dfn constructor for="Instance">Instance(module, importObject)</dfn> constructor, when invoked, [=instantiate a WebAssembly module|instantiates the WebAssembly module=] |module| importing |importObject| and returns the result.
+</div>
+
+<div algorithm>
+    The getter of the <dfn attribute for="Instance">exports</dfn> attribute of {{Instance}} returns the receiver's \[[Exports]] internal slot.
+</div>
+
+<h3 id="memories">Memories</h3>
+
+<pre class="idl">
+dictionary MemoryDescriptor {
+  required [EnforceRange] unsigned long initial;
+  [EnforceRange] unsigned long maximum;
+};
+
+[LegacyNamespace=WebAssembly, Constructor(MemoryDescriptor descriptor), Exposed=(Window,Worker,Worklet)]
+interface Memory {
+  unsigned long grow([EnforceRange] unsigned long delta);
+  readonly attribute ArrayBuffer buffer;
+};
+</pre>
+
+<div>
+A {{Memory}} object represents a single [=memory instance=]
+which can be simultaneously referenced by multiple {{Instance}} objects. Each
+{{Memory}} object has two internal slots:
+
+    * \[[Memory]] : a [=memory address=]
+    * \[[BufferObject]] : an {{ArrayBuffer}} whose [=Data Block=] is [=identified with=] the above memory address
+</div>
+
+<div algorithm>
+    To <dfn>create a memory object</dfn> from a [=memory address=] |memaddr|, perform the following steps:
+
+    1. Let |block| be a Data Block which is [=identified with=] the underlying memory of |memaddr|
+    1. Let |buffer| be a new {{ArrayBuffer}} whose \[[ArrayBufferData]] is |block| and \[[ArrayBufferByteLength]] is set to the length of |block|.
+    1. Return a new {{Memory}} instance with \[[Memory]] set to |memaddr| and \[[BufferObject]] set to |buffer|.
+
+    Issue: Any attempts to [=DetachArrayBuffer|detach=] |buffer|, other than the detachment performed by {{Memory/grow(delta)}}, will throw a {{TypeError}} exception. Specifying this behavior <a href="https://github.com/tc39/ecma262/issues/1024">requires changes to the ECMAScript specification</a>.
+</div>
+
+<div algorithm>
+    The <dfn constructor for="Memory">Memory(descriptor)</dfn> constructor, when invoked, performs the following steps:
+    1. If |descriptor|\["initial"] is [=present=], let |initial| be |descriptor|\["initial"]; otherwise, let |initial| be 0.
+    1. If |descriptor|\["maximum"] is [=present=], let |maximum| be |descriptor|\["maximum"]; otherwise, let |maximum| be empty.
+    1. Let |memtype| be { min |initial|, max |maximum| }
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let (|store|, |memaddr|) be [=alloc_mem=](|store|, |memtype|). If allocation fails, throw a {{RangeError}} exception.
+    1. Set the current agent's [=associated store=] to |store|.
+    1. [=Create a memory object=] from the memory address |memaddr| and return the result.
+</div>
+
+<div algorithm>
+    The <dfn method for="Memory">grow(delta)</dfn> method, when invoked, performs the following steps:
+    1. Let |memory| be the Memory instance.
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let |memaddr| be |memory|.\[[Memory]].
+    1. Let |ret| be the [=size_mem=](|store|, |memaddr|).
+    1. Let |store| be [=grow_mem=](|store|, |memaddr|, |delta|).
+    1. If |store| is [=error=], throw a {{RangeError}} exception.
+    1. Set the current agent's [=associated store=] to |store|.
+    1. Perform ! [=DetachArrayBuffer=](|memory|.\[[BufferObject]]).
+    1. Let |block| be a [=Data Block=] which is [=identified with=] the underlying memory of |memaddr|.
+    1. Assert: The size of |block| is the same as [=size_mem=](|store|, |memaddr|) * 64 Ki
+    1. Let |buffer| be a new {{ArrayBuffer}} whose \[[ArrayBufferData]] is |block| and \[[ArrayBufferByteLength]] is set to the length of |block|.
+    1. Set |memory|.\[[BufferObject]] to |buffer|.
+    1. Return |ret|.
+</div>
+
+<h3 id="tables">Tables</h3>
+
+<pre class="idl">
+enum TableKind {
+  "anyfunc",
+  // Note: More values may be added in future iterations
+};
+
+dictionary TableDescriptor {
+  required TableKind element;
+  required [EnforceRange] unsigned long initial;
+  [EnforceRange] unsigned long maximum;
+};
+
+[LegacyNamespace=WebAssembly, Constructor(TableDescriptor descriptor), Exposed=(Window,Worker,Worklet)]
+interface Table {
+  unsigned long grow([EnforceRange] unsigned long delta);
+  Function? get([EnforceRange] unsigned long delta);
+  void set([EnforceRange] unsigned long delta, Function? value);
+  readonly attribute unsigned long length;
+};
+</pre>
+
+<div>
+A {{Table}} object represents a single [=table instance=]
+which can be simultaneously referenced by multiple {{Instance}} objects. Each
+{{Table}} object has one internal slots:
+
+    * \[[Table]] : a [=table address=]
+    * \[[Values]] : a List whose elements are either null or [=Exported Function=]s.
+</div>
+
+<div algorithm>
+    To <dfn>create a table object</dfn> from a [=table address=] |tableaddr|, perform the following steps:
+    1. Let |values| be a list whose length is [=size_table=](|store|, |tableaddr|) where each element is null.
+    1. Return a new {{Table}} instance with \[[Table]] set to |tableaddr| and \[[Values]] set to |values|.
+</div>
+
+<div algorithm>
+    The <dfn constructor for="Table">Table(descriptor)</dfn> constructor, when invoked, performs the following steps:
+    1. If |descriptor|["initial"] is [=present=], let |n| be |descriptor|["initial"]; otherwise, let |n| be 0.
+    1. If |descriptor|["maximum"] is [=present=], let |m| be |descriptor|["maximum"]; otherwise, let |m| be empty.
+    1. If |m| is not empty and |m| &lt; |n|, throw a {{RangeError}} exception.
+    1. Let |type| be the [=table type=] {[=table type|𝗆𝗂𝗇=] n, [=table type|𝗆𝖺𝗑=] |m|} [=table type|𝖺𝗇𝗒𝖿𝗎𝗇𝖼=].
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let (|store|, |tableaddr|) be [=alloc_table=](|store|, |type|). <!-- TODO(littledan): Report allocation failure https://github.com/WebAssembly/spec/issues/584 -->
+    1. Set the current agent's [=associated store=] to |store|.
+    1. [=Create a table object=] from the table address |tableaddr| and return the result.
+</div>
+
+<div algorithm>
+    The <dfn method for="Table">grow(d)</dfn> method, when invoked, performs the following steps:
+    1. Let |tableaddr| be the Table instance's \[[Table]] internal slot.
+    1. Let |initialSize| be the length of the Table instance's \[[Values]] internal slot.
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let |result| be [=grow_table=](|store|, |tableaddr|, |d|).
+    1. If |result| is [=error=], throw a {{RangeError}} exception.
+
+        Note: The above exception may happen due to either insufficient memory or an invalid size parameter.
+
+    6. Set the current agent's [=associated store=] to |store|.
+    1. [=Append=] null to the Table instance's \[[Values]] internal slot |d| times.
+    1. Return |initialSize|.
+</div>
+
+<div algorithm>
+  The getter of the <dfn attribute for="Table">length</dfn> attribute of {{Table}} returns the length of the table's \[[Values]] internal slot.
+</div>
+
+<div algorithm>
+    The <dfn method for="Table">get(index)</dfn> method, when invoked, performs the following steps:
+    1. Let |values| be the Table instance's \[[Values]] internal slot.
+    1. Let |size| be the length of |values|.
+    1. If |index| &ge; |size|, throw a {{RangeError}} exception.
+    1. Return |values|[|index|].
+</div>
+
+<div algorithm>
+    The <dfn method for="Table">set(index, value)</dfn> method, when invoked, performs the following steps:
+    1. Let |tableaddr| be the Table instance's \[[Table]] internal slot.
+    1. Let |values| be the Table instance's \[[Values]] internal slot.
+    1. If |value| is null, let |funcaddr| be an empty [=function element=].
+    1. Otherwise,
+        1. If |value| does not have a \[[FunctionAddress]] internal slot, throw a {{TypeError}} exception.
+        1. Let |funcaddr| be |value|.\[[FunctionAddress]].
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let |store| be [=write_table=](|store|, |tableaddr|, |index|, |funcaddr|).
+    1. If |store| is [=error=], throw a {{RangeError}} exception.
+    1. Set the current agent's [=associated store=] to |store|.
+    1. Set |values|[|index|] to |value|.
+    1. Return undefined.
+</div>
+
+<h3 id="exported-function-exotic-objects">Exported Functions</h3>
+
+A WebAssembly function is made available in JavaScript as an <dfn>Exported Function</dfn>.
+Exported Functions are [=Built-in Function Objects=] which are not constructors, and which have a \[[FunctionAddress]] internal slot.
+This slot holds a [=function address=] relative to the current agent's [=associated store=].
+
+<div algorithm>
+  The <dfn>name of the WebAssembly function</dfn> |funcaddr| is found by performing the following steps:
+
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let |funcinst| be |store|.𝖿𝗎𝗇𝖼𝗌[|funcaddr|].
+    1. If |funcinst| is of the form {𝗍𝗒𝗉𝖾 |functype|, 𝗁𝗈𝗌𝗍𝖼𝗈𝖽𝖾 |hostfunc|},
+      1. Assert: |hostfunc| is a JavaScript object and [=IsCallable=](|hostfunc|) is true.
+      1. Let |name| be ? [=Get=](|hostfunc|, "name").
+      1. Return ? [=ToString=](|name|).
+    1. Otherwise,
+      1. Let |moduleinst| be |funcinst|.𝗆𝗈𝖽𝗎𝗅𝖾.
+      1. Assert: |funcaddr| is contained in |moduleinst|.𝖿𝗎𝗇𝖼𝖺𝖽𝖽𝗋𝗌.
+      1. Let |index| be the index of |moduleinst|.𝖿𝗎𝗇𝖼𝖺𝖽𝖽𝗋𝗌 where |funcaddr| is found.
+      1. Return ! [=ToString=](|index|).
+</div>
+
+<div algorithm>
+  To create <dfn>a new Exported Function</dfn> from a WebAssembly [=function address=] |funcaddr|, perform the following steps:
+
+    1. Let |steps| be "[=call an Exported Function|call the Exported Function=] |funcaddr| with arguments."
+    1. Let |realm| be the [=current Realm=].
+    1. Let |function| be [=CreateBuiltinFunction=](|realm|, |steps|, [=%FunctionPrototype%=], &laquo; \[[FunctionAddress]]).
+    1. Set |function|.\[[FunctionAddress]] to |funcaddr|.
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let |functype| be [=type_func=](|store|, |funcaddr|).
+    1. Let [|arguments|] → [|results|] be |functype|.
+    1. Let |arity| be the length of |arguments|.
+    1. Perform ! [=DefinePropertyOrThrow=](|function|, `"length"`, PropertyDescriptor {\[[Value]]: |arity|, \[[Writable]]: false, \[[Enumerable]]: false, \[[Configurable]]: true}).
+    1. Let |name| be the [=name of the WebAssembly function=] |funcaddr|.
+    1. Perform ! [=SetFunctionName=](|function|, |name|).
+    1. Return |function|.
+</div>
+
+<div algorithm>
+  To <dfn>call an Exported Function</dfn> with [=function address=] |funcaddr| and a [=list=] of JavaScript arguments |argValues|, perform the following steps:
+
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let |functype| be [=type_func=](|store|, |funcaddr|).
+    1. Let [|parameters|] → [|results|] be |functype|.
+    1. If |parameters| or |results| contains an [=𝗂𝟨𝟦=], throw a {{TypeError}}.
+
+        Note: the above error is thrown each time the \[[Call]] method is invoked.
+
+    5. Let |args| be an empty list of WebAssembly values.
+    1. Let |i| be 0.
+    1. For each type |t| of |parameters|,
+        1. If the length of |argValues| &gt; |i|, let |arg| be |argValues|[i].
+        1. Otherwise, let |arg| be undefined.
+        1. [=Append=] [=ToWebAssemblyValue=](|arg|, |t|) to |args|.
+        1. Set |i| to |i| + 1.
+    1. Let (|store|, |ret|) be the result of [=invoke_func=](|store|, |funcaddr|, |args|).
+    1. Set the current agent's [=associated store=] to |store|.
+    1. If |ret| is [=error=], throw an exception. This exception should be a WebAssembly {{RuntimeError}} exception, unless otherwise indicated by <a href="#errors">the WebAssembly error mapping</a>.
+    1. If |outArity| is 0, return undefined.
+    1. Otherwise, return [=ToJSValue=](|v|), where |v| is the singular element of |ret|.
+</div>
+
+Note: [=call an Exported Function|Calling an Exported Function=] executes in the \[[Realm]] of the callee Exported Function, as per the definition of [=built-in function objects=].
+
+Note: Exported Functions do not have a \[[Construct]] method and thus it is not possible to call one with the `new` operator.
+
+<div algorithm>
+  To <dfn>create a host function</dfn> from the JavaScript object |func|, perform the following steps:
+
+    1. Let |hostfunc| be a [=host function=] which performs the following steps when called:
+        1. If the signature contains an [=𝗂𝟨𝟦=] (as argument or result), the host function throws a {{TypeError}} when called.
+        1. Let |arguments| be a [=list=] of the arguments of the invocation of this function.
+        1. Let |jsArguments| be an empty [=list=].
+        1. For each |arg| in |arguments|,
+            1. [=Append=] [=ToJSValue=](|arg|) to |jsArguments|.
+        1. Let |ret| be ? [=Call=](|func|, undefined, |jsArguments|). If an exception is thrown, trigger a WebAssembly trap, and propagate the exception to the enclosing JavaScript.
+        1. Let [|parameters|] → [|results|] be |functype|.
+        1. If |results| is empty, return undefined.
+        1. Otherwise, return [=ToWebAssemblyValue=](|ret|, |results|[0]).
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let (|store|, |funcaddr|) be [=alloc_func=](|store|, |functype|, |hostfunc|).
+    1. Set the current agent cluster's [=associated store=] to |store|.
+    1. Return |funcaddr|
+</div>
+
+<div algorithm>
+The algorithm <dfn>ToJSValue</dfn>(|w|) coerces a [=WebAssembly value=] to a JavaScript value performs the following steps:
+
+Assert: |w| is not of the form [=𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] |i64|.
+1. If |w| is of the form [=𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |i32|, return [=the Number value=] for |i32|.
+1. If |w| is of the form [=𝖿𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |f32|, return [=the Number value=] for |f32|.
+1. If |w| is of the form [=𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] |f64|, return [=the Number value=] for |f64|.
+
+<!-- If the WebAssembly value is optional, then given `None`, return JavaScript value `undefined`. -->
+
+Note: Implementations may optionally replace the NaN payload with any other NaN payload at this point in the f32 or f64 cases; such a change would not be observable through [=NumberToRawBytes=].
+</div>
+
+<div algorithm>
+The algorithm <dfn>ToWebAssemblyValue</dfn>(|v|, |type|) coerce a JavaScript value to a [=WebAssembly value=]  performs the following steps:
+
+
+Assert: |type| is not [=𝗂𝟨𝟦=].
+1. If |type| is [=𝗂𝟥𝟤=],
+    1. Let |i32| be ? [=ToInt32=](|v|).
+    1. Return [=𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |i32|.
+1. If |type| is [=𝖿𝟥𝟤=],
+    1. Let |f32| be ? [=ToNumber=](|v|) rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode.
+    1. Return [=𝖿𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |f32|.
+1. If |type| is [=𝖿𝟨𝟦=],
+    1. Let |f64| be ? [=ToNumber=](|v|).
+    1. Return [=𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] |f64|.
+
+</div>
+
+<h3 id="error-objects">Error Objects</h3>
+
+WebAssembly defines three Error classes. WebAssembly errors have the following custom bindings:
+- Unlike normal interface types, the interface prototype object for these exception classes must have as its \[[Prototype]] the intrinsic object [=%ErrorPrototype%=].
+- The constructor and properties of WebAssembly errors is as specified for {{NativeError}}.
+- If an implementation gives native Error objects special powers or nonstandard properties (such as a stack property), it should also expose those on these exception instances.
+
+<pre class='idl'>
+[LegacyNamespace=WebAssembly]
+interface CompileError { };
+
+[LegacyNamespace=WebAssembly]
+interface LinkError { };
+
+[LegacyNamespace=WebAssembly]
+interface RuntimeError { };
+</pre>
+
+<h2 id="errors">Error Condition Mappings to JavaScript</h2>
+
+Running WebAssembly programs encounter certain events which halt execution of the WebAssembly code.
+WebAssembly code (currently)
+has no way to catch these conditions and thus an exception will necessarily
+propagate to the enclosing non-WebAssembly caller (whether it is a browser,
+JavaScript or another runtime system) where it is handled like a normal JavaScript exception.
+
+If WebAssembly calls JavaScript via import and the JavaScript throws an
+exception, the exception is propagated through the WebAssembly activation to the
+enclosing caller.
+
+Because JavaScript exceptions can be handled, and JavaScript can continue to
+call WebAssembly exports after a trap has been handled, traps do not, in
+general, prevent future execution.
+
+<h3 id="stack-overflow">Stack Overflow</h3>
+
+Whenever a stack overflow occurs in
+WebAssembly code, the same class of exception is thrown as for a stack overflow in
+JavaScript. The particular exception here is implementation-defined in both cases.
+
+Note: ECMAScript doesn't specify any sort of behavior on stack overflow; implementations have been observed to throw {{RangeError}}, InternalError or Error. Any is valid here.
+
+<h3 id="out-of-memory">Out of Memory</h3>
+
+Whenever validation, compilation or instantiation run out of memory, the
+same class of exception is thrown as for out of memory conditions in JavaScript.
+The particular exception here is implementation-defined in both cases.
+
+Note: ECMAScript doesn't specify any sort of behavior on out-of-memory conditions; implementations have been observed to throw OOMError and to crash. Either is valid here.
+
+<h2 id="store">Interaction of the WebAssembly Store with JavaScript</h2>
+
+Note: WebAssembly semantics are defined in terms of a [=store=], representing the state of the world, or "memory". WebAssembly operations take a store and return a new store.
+
+Each [=agent=] has an <dfn>associated store</dfn>. When a new agent is created, its associated store is set to the result of [=init_store=]().
+
+Note: In this specification, no WebAssembly-related objects, memory or addresses can be shared among agents in an [=agent cluster=]. In a future version of WebAssembly, the <a href="https://github.com/WebAssembly/threads">threads proposal</a> will add such sharing. For the JS binding, this will likely mean that there will be a store per agent cluster, rather than per agent. This specification uses a store per agent in order to limit semantics to how a store operates in a single-threaded manner, as the WebAssembly specification without threads only deals with that case.
+
+Elements of the WebAssembly store may be <dfn>identified with</dfn> JavaScript values. In particular, each WebAssembly [=memory instance=] with a corresponding {{Memory}} object is identified with a JavaScript [=Data Block=]; modifications to this Data Block are identified to updating the agent's store to a store which reflects those changes, and vice versa.
diff --git a/document/web/index.bs b/document/web/index.bs
new file mode 100644
index 000000000..815f5e871
--- /dev/null
+++ b/document/web/index.bs
@@ -0,0 +1,189 @@
+<pre class='metadata'>
+Title: WebAssembly Web API
+Shortname: wasmweb
+Group: WebAssembly CG
+Status: w3c/CG-DRAFT
+Level: 1
+ED: https://webassembly.github.io/spec/web/
+Editor: WebAssembly Community Group
+Repository: WebAssembly/spec
+Abstract: This document describes the integration of WebAssembly with the broader web platform.
+Markup Shorthands: css no, markdown yes
+</pre>
+
+<pre class='biblio'>
+{
+  "ECMA-262": {
+    "href": "https://tc39.github.io/ecma262",
+    "title": "ECMAScript® 2018 Language Specification",
+    "publisher": "ECMA TC39",
+    "status": "Current Editor's Draft"
+  },
+  "WEBASSEMBLY": {
+    "href": "https://webassembly.github.io/spec/",
+    "title": "WebAssembly Specification",
+    "publisher": "W3C WebAssembly Community Group",
+    "status": "Draft"
+  },
+  "WASMJS": {
+    "href": "https://webassembly.github.io/spec/document/js-api/",
+    "title": "WebAssembly JS Integration Specification",
+    "publisher": "W3C WebAssembly Community Group",
+    "status": "Draft"
+  }
+}
+</pre>
+
+<pre class="anchors">
+urlPrefix: https://tc39.github.io/ecma262/; spec: ECMA-262
+    type: exception; for: ECMAScript
+        text: TypeError; url: sec-native-error-types-used-in-this-standard-typeerror
+    type: interface
+        text: ArrayBuffer; url: sec-arraybuffer-objects
+urlPrefix: https://webassembly.github.io/spec/; spec: WebAssembly; type: dfn
+    text: function index; url: syntax/modules.html#syntax-funcidx
+urlPrefix: https://webassembly.github.io/spec/document/js-api/; spec: WASMJS
+    type: namespace
+        text: WebAssembly; url: #namespacedef-webassembly
+    type: interface
+        text: CompileError; url: #compileerror
+        text: Module; url: #module
+        text: WebAssemblyInstantiatedSource; url: #dictdef-webassemblyinstantiatedsource
+    type: dfn
+        text: compile a WebAssembly module; url: #compile-a-webassembly-module
+        text: instantiate a WebAssembly module; url: #instantiate-a-webassembly-module
+        text: instantiate; url: #dom-webassembly-instantiate
+        text: asynchronously compile a webassembly module; url: #asynchronously-compile-a-webassembly-module
+        text: instantiate a promise of a module; url: #instantiate-a-promise-of-a-module
+        text: Exported Function; url: #exported-function
+url:https://html.spec.whatwg.org/#cors-same-origin;text:CORS-same-origin;type:dfn;spec:HTML
+url:https://fetch.spec.whatwg.org/#concept-body-consume-body;text:consume body;type:dfn;spec:FETCH
+</pre>
+
+<pre class='link-defaults'>
+spec:ecma-262; type:exception; for:ECMAScript; text:TypeError
+</pre>
+
+This document builds off of the WebAssembly specification [[WEBASSEMBLY]] and the WebAssembly JavaScript embedding [[WASMJS]].
+
+<h2 id="streaming-modules">Streaming Module Compilation and Instantiation</h2>
+
+<pre class="idl">
+partial namespace WebAssembly {
+  Promise&lt;Module> compileStreaming(Promise&lt;Response> source);
+  Promise&lt;WebAssemblyInstantiatedSource> instantiateStreaming(
+      Promise&lt;Response> source, optional object importObject);
+};
+</pre>
+
+<div algorithm>
+The <dfn method for="WebAssembly">compileStreaming(source)</dfn> method, when invoked, returns the result of [=compile a potential WebAssembly response|compiling a potential WebAssembly response=] with |source|.
+</div>
+
+<div algorithm>
+The <dfn method for="WebAssembly">instantiateStreaming(source, importObject)</dfn> method, when invoked, performs the following steps:
+
+    1. Let |promiseOfModule| be the result of [=compile a potential WebAssembly response|compiling a potential WebAssembly response=] with |source|.
+    1. Return the result of [=instantiate a promise of a module|instantiating the promise of a module=] |promiseOfModule| with imports |importObject|.
+</div>
+
+<div algorithm>
+To <dfn>compile a potential WebAssembly response</dfn> with a promise of a {{Response}} |source|, perform the following steps:
+
+Note: This algorithm accepts a {{Response}} object, or a
+    promise for one, and compiles and instantiates the resulting bytes of the response. This compilation
+    can be performed in the background and in a streaming manner. If the {{Response}} is not
+    [=CORS-same-origin=], does not represent an [=ok status=], or does not match the
+    `` `application/wasm` `` MIME type, the returned promise will be rejected with a {{TypeError}}; if
+    compilation or instantiation fails, the returned promise will be rejected with a
+    {{CompileError}} or other relevant error type, depending on the cause of failure.
+
+
+    1. Let |returnValue| be [=a new promise=]
+    1. [=Upon fulfillment=] of |source| with value |unwrappedSource|:
+        1. Let |response| be |unwrappedSource|'s [=Response/response=].
+        1. Let |mimeType| be the result of [=extracting a MIME type=] from |response|'s [=response/header list=].
+        1. If |mimeType| is not `` `application/wasm` ``, reject |returnValue| with a {{TypeError}} and abort these substeps.
+
+        Note: extra parameters are not allowed, including the empty `` `application/wasm;` ``.
+
+        4. If |response| is not [=CORS-same-origin=], [=reject=] |returnValue| with a {{TypeError}} and abort these substeps.
+        1. If |response|'s [=response/status=] is not an [=ok status=], [=reject=] |returnValue| with a {{TypeError}} and abort these substeps.
+        1. [=Consume body|consume=] |response|'s body as an {{ArrayBuffer}}, and let |bodyPromise| be the result.
+
+        Note: Although it is specified here that the response is consumed entirely before compilation proceeds, that is purely for ease of specification; implementations are likely to instead perform processing in a streaming fashion. The different is unobservable, and thus the simpler model is specified. <!-- Using consume is a bit silly as it creates an ArrayBuffer but then we just want the underlying bytes. This is because of how streams is specced in terms of promises and JS objects whereas we want to operate more directly on the underlying concept. We can revisit this if things change in the Streams/Fetch specs. -->
+
+        7. [=Upon fulfillment=] of |bodyPromise| with value |bodyArrayBuffer|:
+            1. [=Asynchronously compile a WebAssembly module|Asynchronously compile the WebAssembly module=] |bodyArrayBuffer| with |returnValue| using the [=networking task source=].
+        1. [=Upon rejection=] of |bodyPromise| with reason |reason|:
+            1. [=Reject=] |returnValue| with |reason|.
+     1. [=Upon rejection=] of |source| with reason |reason|:
+         1. [=Reject=] |returnValue| with |reason|.
+     1. Return |returnValue|.
+</div>
+
+<h2 id="conventions">Developer-Facing Display Conventions</h2>
+
+Browsers, JavaScript engines, and offline tools have common ways of referring to
+JavaScript artifacts and language constructs. For example, locations in
+JavaScript source code are printed in stack traces or error messages, and are
+represented naturally as decimal-format lines and columns in text files. Names
+of functions and variables are taken directly from the sources. Therefore (for
+example) even though the exact format of implementation-dependent stack trace
+strings does not always match, the locations are easily understandable and the
+same across browsers.
+
+To achive the same goal of a common representations for WebAssembly constructs, the
+following conventions are adopted.
+
+A WebAssembly location is a reference to a particular instruction in the binary, and may be
+displayed by a browser or engine in similar contexts as JavaScript source locations.
+It has the following format:
+
+`${url}:wasm-function[${funcIndex}]:${pcOffset}`
+
+Where
+* `${url}` is the URL associated with the module, if applicable (see notes).
+* `${funcIndex}` is the [=function index=] relative to the module.
+* `${pcOffset}` is the offset in the module binary of the first byte of the instruction, printed in hexadecimal with lower-case digits, with a leading `0x` prefix.
+
+Notes:
+* The URL field may be interpreted differently depending on the
+    context. When the response-based
+    instantiation <a href="#streaming-modules">API</a> is used in a
+    browser, the associated URL should be used; or when the
+    {{ArrayBuffer}}-based instantiation
+    [=instantiate|API=] is used, the browser should represent
+    the location of the API call. This kind of instantiation is analagous to
+    executing JavaScript using `eval`; therefore if the browser has an existing
+    method to represent the location of the `eval` call it can use a similar
+    one for `WebAssembly.instantiate`. For example if the browser uses
+    `foo.js line 10 > eval` or `eval at bar (foo.js:10:3)` for `eval`, it could
+    use `foo.js line 10 > WebAssembly.instantiate` or
+    `WebAssembly.instantiate at bar (foo.js:10:3)`, respectively.
+    Offline tools may use a filename instead.
+* Using hexadecimal for module offsets matches common conventions in native tools
+    such as objdump (where addresses are printed in hex) and makes them visually
+    distinct from JavaScript line numbers. Other numbers are represented in decimal.
+
+While the "name" property of an [=Exported Function=] instance
+is specified by the [[WASMJS|JS API]], synthesized function names are also
+displayed in other contexts like call stacks in debuggers and string representations
+of stack traces.
+If a WebAssembly module contains a ["name" section](BinaryEncoding.md#name-section),
+these names should be used to synthesize a function name as follows:
+* If a function name subsection is present, the displayed name should
+      be `${module_name}.${function_name}` or `${function_name}`, depending
+      on whether the module name is present.
+* Otherwise, the output can be context-dependent:
+  * If the function name is shown alongside its location in a
+    stack trace, then just the module name (if present) or an empty string
+    can be used (because the function index is already in the location).
+  * Otherwise, `${module_name}.wasm-function[${funcIndex}]` or
+    `wasm-function[${funcIndex}]` should be used to convey the function index.
+
+Note that this document does not specify the full format of strings such as
+stack frame representations; this allows engines to continue using their
+existing formats for JavaScript (which existing code may already be depending
+on) while still printing WebAssembly frames in a format consistent with
+JavaScript.

From fb7e7e1e381ffc283c923a87fdfea5ebbd213737 Mon Sep 17 00:00:00 2001
From: Hugo Guiroux <gx.hugo@gmail.com>
Date: Fri, 8 Dec 2017 08:36:05 +0100
Subject: [PATCH 121/329] [spec] Fix validation for `br_table` (#619)

---
 document/core/valid/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index b95aa018f..b9fa141b2 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -586,7 +586,7 @@ Control Instructions
 :math:`\BRTABLE~l^\ast~l_N`
 ...........................
 
-* The label :math:`C.\CLABELS[l]` must be defined in the context.
+* The label :math:`C.\CLABELS[l_N]` must be defined in the context.
 
 * Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` :math:`C.\CLABELS[l_N]`.
 

From 5afc0fdde1eda1c0f1bb7aac761ca8aadf5b0420 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 15 Dec 2017 14:47:55 +0100
Subject: [PATCH 122/329] [spec] Add document index and makefiles (#624)

---
 document/Makefile                  | 59 ++++++++++++++++++++++++++++++
 document/README.md                 | 23 ++++++++++++
 document/core/Makefile             | 10 ++---
 document/core/README.md            |  4 +-
 document/{core/util => }/deploy.sh | 15 ++++++--
 document/index.html                | 47 ++++++++++++++++++++++++
 document/js-api/Makefile           | 20 ++++++++++
 document/web-api/Makefile          | 20 ++++++++++
 document/{web => web-api}/index.bs |  0
 9 files changed, 187 insertions(+), 11 deletions(-)
 create mode 100644 document/Makefile
 create mode 100644 document/README.md
 rename document/{core/util => }/deploy.sh (93%)
 create mode 100644 document/index.html
 create mode 100644 document/js-api/Makefile
 create mode 100644 document/web-api/Makefile
 rename document/{web => web-api}/index.bs (100%)

diff --git a/document/Makefile b/document/Makefile
new file mode 100644
index 000000000..3c666dd75
--- /dev/null
+++ b/document/Makefile
@@ -0,0 +1,59 @@
+DIRS     = core js-api web-api
+FILES    = index.html
+BUILDDIR = _build
+
+# Global targets.
+
+.PHONY: all
+all: $(DIRS)
+
+$(BUILDDIR):
+	mkdir -p $@
+	cp -f $(FILES) $(BUILDDIR)/
+	touch $(BUILDDIR)/.nojekyll
+
+.PHONY: deploy
+deploy:
+	GIT_DEPLOY_DIR=$(BUILDDIR) sh deploy.sh
+
+.PHONY: publish
+publish: all deploy
+
+.PHONY: clean
+clean: $(DIRS:%=clean-%)
+	rm -rf $(BUILDDIR)
+
+
+# Directory-specific targets.
+
+.PHONY: $(DIRS)
+$(DIRS): %: $(BUILDDIR)
+	(cd $@; make BUILDDIR=$(BUILDDIR) all)
+	mkdir -p $(BUILDDIR)/$@
+	cp -R $@/$(BUILDDIR)/html/* $(BUILDDIR)/$@/
+
+.PHONY: $(DIRS:%=deploy-%)
+$(DIRS:%=deploy-%):
+	GIT_DEPLOY_DIR=$(BUILDDIR) GIT_DEPLOY_SUBDIR=$(@:deploy-%=%) sh deploy.sh
+
+.PHONY: $(DIRS:%=publish-%)
+$(DIRS:%=publish-%): publish-%: % deploy-%
+
+.PHONY: $(DIRS:%=clean-%)
+$(DIRS:%=clean-%):
+	(cd $(@:clean-%=%); make BUILDDIR=$(BUILDDIR) clean)
+	rm -rf $(BUILDDIR)/$(@:clean-%=%)
+
+
+# Help.
+
+.PHONY: help
+help:
+	@echo "Please use \`make <target>' where <target> is one of"
+	@echo "  all             to build all documents"
+	@echo "  publish         to make all and push to gh-pages"
+	@echo "  <dir>           to build a specific subdirectory"
+	@echo "  publish-<dir>   to build and push a specific subdirectory"
+
+.PHONY: usage
+usage: help
diff --git a/document/README.md b/document/README.md
new file mode 100644
index 000000000..e8312f429
--- /dev/null
+++ b/document/README.md
@@ -0,0 +1,23 @@
+# WebAssembly Specifications
+
+This directory contains the source code for the WebAssembly spec documents, as served from the [webassembly.github.io/spec](https://webassembly.github.io/spec) pages.
+It uses [Sphinx](http://www.sphinx-doc.org/) and [Bikeshed](https://github.com/tabatkins/bikeshed).
+
+To install Sphinx:
+```
+pip install sphinx
+```
+
+To install Bikeshed, see the instructions [here](https://tabatkins.github.io/bikeshed/#installing).
+
+
+To build everything locally (result appears in `_build/`):
+```
+make all
+```
+
+To build everything and update [webassembly.github.io/spec](https://webassembly.github.io/spec) with it:
+```
+make publish
+```
+Please make sure to only use that once a change has approval.
diff --git a/document/core/Makefile b/document/core/Makefile
index 8dbafcff9..1463bf2c3 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -8,7 +8,6 @@ PAPER         = a4
 BUILDDIR      = _build
 STATICDIR     = _static
 DOWNLOADDIR   = _download
-GHPAGESDIR    = ../docs
 NAME          = WebAssembly
 
 # Hack until we have moved to more recent Sphinx.
@@ -64,12 +63,13 @@ help:
 	@echo "  coverage   to run coverage check of the documentation (if enabled)"
 	@echo "  dummy      to check syntax errors of document sources"
 
-.PHONY: publish
-publish: all deploy
-
 .PHONY: deploy
 deploy:
-	GIT_DEPLOY_DIR=$(BUILDDIR)/html sh util/deploy.sh
+	(cd ..; make deploy-core)
+
+.PHONY: publish
+publish:
+	(cd ..; make publish-core)
 
 .PHONY: all
 all:	pdf html
diff --git a/document/core/README.md b/document/core/README.md
index 5b40a1822..299b7a3a1 100644
--- a/document/core/README.md
+++ b/document/core/README.md
@@ -1,6 +1,6 @@
-# WebAssembly Specification
+# WebAssembly Core Specification
 
-This is (meant to become) the official WebAssembly "language" specification.
+This is the official WebAssembly "language" specification.
 
 It uses [Sphinx](http://www.sphinx-doc.org/). To install that:
 ```
diff --git a/document/core/util/deploy.sh b/document/deploy.sh
similarity index 93%
rename from document/core/util/deploy.sh
rename to document/deploy.sh
index 4507b6d87..f91205bcd 100755
--- a/document/core/util/deploy.sh
+++ b/document/deploy.sh
@@ -25,6 +25,7 @@ Options:
 Variables:
 
   GIT_DEPLOY_DIR      Folder path containing the files to deploy.
+  GIT_DEPLOY_SUBDIR   Subdirectory to deploy.
   GIT_DEPLOY_BRANCH   Commit deployable files to this branch.
   GIT_DEPLOY_REPO     Push the deploy branch to this repository.
 
@@ -74,6 +75,7 @@ parse_args() {
 
 	# Source directory & target branch.
 	deploy_directory=${GIT_DEPLOY_DIR:-dist}
+	deploy_subdirectory=${GIT_DEPLOY_SUBDIR:-}
 	deploy_branch=${GIT_DEPLOY_BRANCH:-gh-pages}
 
 	#if no user identity is already set in the current git environment, use this:
@@ -141,9 +143,14 @@ main() {
 }
 
 initial_deploy() {
-	git --work-tree "$deploy_directory" checkout --orphan $deploy_branch
-	git --work-tree "$deploy_directory" add --all
-	commit_and_push
+	if [[ -z $deploy_subdirectory ]]; then
+		git --work-tree "$deploy_directory" checkout --orphan $deploy_branch
+		git --work-tree "$deploy_directory" add --all
+		commit_and_push
+	else
+		echo "Subdirectory '$deploy_subdirectory' does not exist. Aborting." >&2
+		return 1
+	fi
 }
 
 incremental_deploy() {
@@ -151,7 +158,7 @@ incremental_deploy() {
 	git symbolic-ref HEAD refs/heads/$deploy_branch
 	#put the previously committed contents of deploy_branch into the index
 	git --work-tree "$deploy_directory" reset --mixed --quiet
-	git --work-tree "$deploy_directory" add --all
+	git --work-tree "$deploy_directory" add --all $deploy_subdirectory
 
 	set +o errexit
 	diff=$(git --work-tree "$deploy_directory" diff --exit-code --quiet HEAD --)$?
diff --git a/document/index.html b/document/index.html
new file mode 100644
index 000000000..333705a11
--- /dev/null
+++ b/document/index.html
@@ -0,0 +1,47 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+
+<html>
+
+<head>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+  <title>WebAssembly Specifications</title>
+
+  <link crossorigin="anonymous" href="https://assets-cdn.github.com/assets/frameworks-c9193575f18b28be82c0a963e144ff6fa7a809dd8ae003a1d1e5979bed3f7f00.css" integrity="sha256-yRk1dfGLKL6CwKlj4UT/b6eoCd2K4AOh0eWXm+0/fwA=" media="all" rel="stylesheet">
+  <link crossorigin="anonymous" href="https://assets-cdn.github.com/assets/github-8ffe4331a8d2d413bfa465c56c4cc7466b011bcb5a8f74aab9081362ee31f862.css" integrity="sha256-j/5DMajS1BO/pGXFbEzHRmsBG8taj3SquQgTYu4x+GI=" media="all" rel="stylesheet">
+</head>
+
+<body>
+<div id="readme" class="readme blob isntapaper_body">
+<article class="markdown-body entry-content">
+
+<h1>WebAssembly Specifications</h1>
+
+<p>
+To support the <em>embedding</em> of WebAssembly into different environments, its specification is split into <em>layers</em> that are specified in separate documents.
+</p>
+
+<h3>Core specification</h3>
+
+<p>Defines the semantics of WebAssembly modules and its instruction set, independent from a concrete embedding.
+  The WebAssembly core is specified in a single document:</p>
+
+  <ul>
+  <li><p><a href="core/index.html">Core</a>: defines the structure of WebAssembly modules and its representation in binary and text format, as well as the semantics of validation, instantiation, and execution.</p></li>
+  </ul>
+
+<h3>API specifications</h3>
+
+<p>Define <em>application programming interfaces</em> enabling the use of WebAssembly modules in concrete embedding environments.
+  Currently, two APIs are specified:</p>
+
+  <ul>
+  <li><p><a href="js-api/index.html">JavaScript API</a>: defines JavaScript classes and objects for accessing WebAssembly from within JavaScript, including methods for validation, compilation, instantiation, and classes for representing and manipulating imports and exports as JavaScript objects.</p></li>
+
+  <li><p><a href="web-api/index.html">Web API</a>: defines extensions to the JavaScript API made available specifically in web browsers, in particular, an interface for streaming compilation and instantiation from origin-bound `Response` types.</p></li>
+  </ul>
+
+</article>
+</div>
+</body>
+
+</html>
diff --git a/document/js-api/Makefile b/document/js-api/Makefile
new file mode 100644
index 000000000..283c9360b
--- /dev/null
+++ b/document/js-api/Makefile
@@ -0,0 +1,20 @@
+BUILDDIR      = _build
+STATICDIR     = _static
+DOWNLOADDIR   = _download
+NAME          = WebAssembly
+
+.PHONY: all
+all:
+	mkdir -p $(BUILDDIR)/html
+	# TODO(littledan): remove dummy and properly build into $(BUILDDIR)/html
+	touch $(BUILDDIR)/html/index.html
+	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html."
+
+.PHONY: publish
+publish:
+	(cd ..; make publish-js-api)
+
+.PHONY: clean
+clean:
+	rm -rf $(BUILDDIR)
+	rm -rf $(STATICDIR)
diff --git a/document/web-api/Makefile b/document/web-api/Makefile
new file mode 100644
index 000000000..eaac6549b
--- /dev/null
+++ b/document/web-api/Makefile
@@ -0,0 +1,20 @@
+BUILDDIR      = _build
+STATICDIR     = _static
+DOWNLOADDIR   = _download
+NAME          = WebAssembly
+
+.PHONY: all
+all:
+	mkdir -p $(BUILDDIR)/html
+	# TODO(littledan): remove dummy and properly build into $(BUILDDIR)/html
+	touch $(BUILDDIR)/html/index.html
+	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html."
+
+.PHONY: publish
+publish:
+	(cd ..; make publish-web-api)
+
+.PHONY: clean
+clean:
+	rm -rf $(BUILDDIR)
+	rm -rf $(STATICDIR)
diff --git a/document/web/index.bs b/document/web-api/index.bs
similarity index 100%
rename from document/web/index.bs
rename to document/web-api/index.bs

From e04dfa5afc895fbca676c6a110b096413d283915 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 3 Jan 2018 14:21:47 +0100
Subject: [PATCH 123/329] [spec] Minor tweak to op mapping (#635)

---
 document/core/exec/instructions.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 188c69328..5f9447c8f 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -20,8 +20,8 @@ The mapping of numeric instructions to their underlying operators is expressed b
 
 .. math::
    \begin{array}{lll@{\qquad}l}
-   \X{op}_{\K{i}N}(n) &=& \F{i}\X{op}_N(n) \\
-   \X{op}_{\K{f}N}(z) &=& \F{f}\X{op}_N(z) \\
+   \X{op}_{\K{i}N}(n_1,\dots,n_k) &=& \F{i}\X{op}_N(n_1,\dots,n_k) \\
+   \X{op}_{\K{f}N}(z_1,\dots,z_k) &=& \F{f}\X{op}_N(z_1,\dots,z_k) \\
    \end{array}
 
 And for :ref:`conversion operators <exec-cvtop>`:

From 3e76fcb987ba97ba69a69fb090e7358693e5a184 Mon Sep 17 00:00:00 2001
From: David Swasey <swasey@mpi-sws.org>
Date: Wed, 3 Jan 2018 16:02:29 +0100
Subject: [PATCH 124/329] [spec] Typos (#631)

* [spec] Fix some typos

* [spec] Fix variable names in valid/modules

The same metavariable had been used for two purposes.
---
 document/core/appendix/embedding.rst | 2 +-
 document/core/exec/modules.rst       | 5 ++---
 document/core/exec/numerics.rst      | 4 ++--
 document/core/valid/instructions.rst | 2 +-
 document/core/valid/modules.rst      | 2 +-
 5 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index 12a329514..15832df3c 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -262,7 +262,7 @@ Functions
 .. index:: invocation, value, result
 .. _embed-invoke-func:
 
-:math:`\F{invoke\_func}(\store, \funcaddr, \val^\ast) : (\store, \val^\ast ~|~ \error`)`
+:math:`\F{invoke\_func}(\store, \funcaddr, \val^\ast) : (\store, \val^\ast ~|~ \error)`
 ........................................................................................
 
 1. Assert: :math:`\store.\SFUNCS[\funcaddr]` exists.
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 5fb160f85..dc69959f8 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -546,7 +546,7 @@ Instantiation
 
 Given a :ref:`store <syntax-store>` :math:`S`, a :ref:`module <syntax-module>` :math:`\module` is instantiated with a list of :ref:`external values <syntax-externval>` :math:`\externval^n` supplying the required imports as follows.
 
-Instantiation assumes that the module is :ref:`valid <valid>` and the provided imports :ref:`match <match-externtype>` the declared types,
+Instantiation checks that the module is :ref:`valid <valid>` and the provided imports :ref:`match <match-externtype>` the declared types,
 and may *fail* with an error otherwise.
 Instantiation can also result in a :ref:`trap <trap>` from executing the start function.
 It is up to the :ref:`embedder <embedder>` to define how such conditions are reported.
@@ -677,7 +677,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
      \end{array} \\
    &(\iff
      & \vdashmodule \module : \externtype_{\F{im}}^n \to \externtype_{\F{ex}}^\ast \\
-     &\wedge& (\vdashexternval \externval : \externtype)^n \\
+     &\wedge& (S \vdashexternval \externval : \externtype)^n \\
      &\wedge& (\vdashexterntypematch \externtype \matches \externtype_{\F{im}})^n \\[1ex]
      &\wedge& \module.\MGLOBALS = \global^k \\
      &\wedge& \module.\MELEM = \elem^\ast \\
@@ -690,7 +690,6 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
      &\wedge& (S'; F; \data.\DOFFSET \stepto^\ast S'; F; \I32.\CONST~\X{do})^\ast \\[1ex]
      &\wedge& (\X{eo} + |\elem.\EINIT| \leq |S'.\STABLES[\tableaddr].\TIELEM|)^\ast \\
      &\wedge& (\X{do} + |\data.\DINIT| \leq |S'.\SMEMS[\memaddr].\MIDATA|)^\ast
-     )
    \\[1ex]
      &\wedge& \globaladdr^\ast = \moduleinst.\MIGLOBALS[|\moduleinst.\MIGLOBALS|-k \slice k] \\
      &\wedge& (\tableaddr = \moduleinst.\MITABLES[\elem.\ETABLE])^\ast \\
diff --git a/document/core/exec/numerics.rst b/document/core/exec/numerics.rst
index 01c4b5482..16914d5f6 100644
--- a/document/core/exec/numerics.rst
+++ b/document/core/exec/numerics.rst
@@ -721,7 +721,7 @@ NaN Propagation
 ...............
 
 When the result of a floating-point operator other than |fneg|, |fabs|, or |fcopysign| is a :ref:`NaN <syntax-nan>`,
-then its sign is non-deterministic and the :ref:`payload <syntax-payload>` computed as follows:
+then its sign is non-deterministic and the :ref:`payload <syntax-payload>` is computed as follows:
 
 * If the payload of all NaN inputs to the operator is :ref:`canonical <canonical-nan>` (including the case that there are no NaN inputs), then the payload of the output is canonical as well.
 
@@ -1403,7 +1403,7 @@ Conversions
 :math:`\wrap_{M,N}(i)`
 ......................
 
-* Return :math:`i` modulo :math:`N`.
+* Return :math:`i` modulo :math:`2^N`.
 
 .. math::
    \begin{array}{lll@{\qquad}l}
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index b9fa141b2..ffc308ff2 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -516,7 +516,7 @@ Control Instructions
 :math:`\IF~[t^?]~\instr_1^\ast~\ELSE~\instr_2^\ast~\END`
 ........................................................
 
-* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the empty :ref:`result type <syntax-resulttype>` :math:`[t^?]` prepended to the |CLABELS| vector.
+* Let :math:`C'` be the same :ref:`context <context>` as :math:`C`, but with the :ref:`result type <syntax-resulttype>` :math:`[t^?]` prepended to the |CLABELS| vector.
 
 * Under context :math:`C'`,
   the instruction sequence :math:`\instr_1^\ast` must be :ref:`valid <valid-instr-seq>` with type :math:`[] \to [t^?]`.
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index e82ee2e57..022792c85 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -473,7 +473,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
     the :ref:`function type <syntax-functype>` :math:`\functype_i` must be :ref:`valid <valid-functype>`.
 
   * For each :math:`\func_i` in :math:`\module.\MFUNCS`,
-    the definition :math:`\func_i` must be :ref:`valid <valid-func>` with a :ref:`function type <syntax-functype>` :math:`\functype_i`.
+    the definition :math:`\func_i` must be :ref:`valid <valid-func>` with a :ref:`function type <syntax-functype>` :math:`\X{ft}_i`.
 
   * For each :math:`\table_i` in :math:`\module.\MTABLES`,
     the definition :math:`\table_i` must be :ref:`valid <valid-table>` with a :ref:`table type <syntax-tabletype>` :math:`\tabletype_i`.

From d1092d40b8b77aef823009d305eb4c35c05c56e4 Mon Sep 17 00:00:00 2001
From: David Swasey <swasey@mpi-sws.org>
Date: Wed, 3 Jan 2018 16:03:05 +0100
Subject: [PATCH 125/329] [spec] Clarify that `ea` in load/store cannot
 overflow (#632)

---
 document/core/exec/instructions.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 5f9447c8f..799717e4c 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -400,7 +400,7 @@ Memory Instructions
 
 7. Pop the value :math:`\I32.\CONST~i` from the stack.
 
-8. Let :math:`\X{ea}` be :math:`i + \memarg.\OFFSET`.
+8. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
 
 9. If :math:`N` is not part of the instruction, then:
 
@@ -480,7 +480,7 @@ Memory Instructions
 
 9. Pop the value :math:`\I32.\CONST~i` from the stack.
 
-10. Let :math:`\X{ea}` be :math:`i + \memarg.\OFFSET`.
+10. Let :math:`\X{ea}` be the integer :math:`i + \memarg.\OFFSET`.
 
 11. If :math:`N` is not part of the instruction, then:
 

From 3160713a60dc24ad755072baa46ea1bd7dc76649 Mon Sep 17 00:00:00 2001
From: David Swasey <swasey@mpi-sws.org>
Date: Wed, 3 Jan 2018 16:03:38 +0100
Subject: [PATCH 126/329] [spec] Make the `invoke` function return a full
 machine configuration (#633)

The old rule returned a frameless configuration, which did not match
how `invoke` is used. (The `invoke_func` function in the appendix
simply starts reducing from whatever `invoke` returns.)

Any frame will do.
---
 document/core/exec/modules.rst | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index dc69959f8..dd0280b5e 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -768,7 +768,8 @@ The values :math:`\val_{\F{res}}^m` are returned as the results of the invocatio
 .. math::
    ~\\[-1ex]
    \begin{array}{@{}lcl}
-   \invoke(S, \funcaddr, \val^n) &=& S; \val^n~(\INVOKE~\funcaddr) \\
+   \invoke(S, \funcaddr, \val^n) &=& S; F; \val^n~(\INVOKE~\funcaddr) \\
      &(\iff & S.\SFUNCS[\funcaddr].\FITYPE = [t_1^n] \to [t_2^m] \\
      &\wedge& \val^n = (t_1.\CONST~c)^n) \\
+     &\wedge& F = \{ \AMODULE~\{\}, \ALOCALS~\epsilon \} \\
    \end{array}

From ab40b1bc9473c0e2224ec437e541f4fe0887e183 Mon Sep 17 00:00:00 2001
From: David Swasey <swasey@mpi-sws.org>
Date: Wed, 3 Jan 2018 16:04:19 +0100
Subject: [PATCH 127/329] [spec] Simple fixes to `call` and `grow_memory`
 (#634)

* Adjust reduction of `call` (at most one return value)
* Adjust reduction of `grow_memory` (return old size)
---
 document/core/exec/instructions.rst | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 799717e4c..356b8665a 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -600,6 +600,7 @@ Memory Instructions
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & F.\AMODULE.\MIMEMS[0] = a \\
+     \wedge & \X{sz} = |S.\SMEMS[a].\MIDATA|/64\,\F{Ki} \\
      \wedge & S' = S \with \SMEMS[a] = \growmem(S.\SMEMS[a], n)) \\
      \end{array}
    \\[1ex]
@@ -1008,21 +1009,23 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 
 3. Let :math:`[t_1^n] \to [t_2^m]` be the :ref:`function type <syntax-functype>` :math:`f.\FITYPE`.
 
-4. Let :math:`t^\ast` be the list of :ref:`value types <syntax-valtype>` :math:`f.\FICODE.\FLOCALS`.
+4. Assert: due to :ref:`validation <valid-call>`, :math:`m \leq 1`.
 
-5. Let :math:`\instr^\ast~\END` be the :ref:`expression <syntax-expr>` :math:`f.\FICODE.\FBODY`.
+5. Let :math:`t^\ast` be the list of :ref:`value types <syntax-valtype>` :math:`f.\FICODE.\FLOCALS`.
 
-6. Assert: due to :ref:`validation <valid-call>`, :math:`n` values are on the top of the stack.
+6. Let :math:`\instr^\ast~\END` be the :ref:`expression <syntax-expr>` :math:`f.\FICODE.\FBODY`.
 
-7. Pop the values :math:`\val^n` from the stack.
+7. Assert: due to :ref:`validation <valid-call>`, :math:`n` values are on the top of the stack.
 
-8. Let :math:`\val_0^\ast` be the list of zero values of types :math:`t^\ast`.
+8. Pop the values :math:`\val^n` from the stack.
 
-9. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~f.\FIMODULE, \ALOCALS~\val^n~\val_0^\ast \}`.
+9. Let :math:`\val_0^\ast` be the list of zero values of types :math:`t^\ast`.
 
-10. Push the activation of :math:`F` with arity :math:`m` to the stack.
+10. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~f.\FIMODULE, \ALOCALS~\val^n~\val_0^\ast \}`.
 
-11. :ref:`Execute <exec-block>` the instruction :math:`\BLOCK~[t_2^m]~\instr^\ast~\END`.
+11. Push the activation of :math:`F` with arity :math:`m` to the stack.
+
+12. :ref:`Execute <exec-block>` the instruction :math:`\BLOCK~[t_2^m]~\instr^\ast~\END`.
 
 .. math::
    ~\\[-1ex]
@@ -1034,6 +1037,7 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & S.\SFUNCS[a] = f \\
      \wedge & f.\FITYPE = [t_1^n] \to [t_2^m] \\
+     \wedge & m \leq 1 \\
      \wedge & f.\FICODE = \{ \FTYPE~x, \FLOCALS~t^k, \FBODY~\instr^\ast~\END \} \\
      \wedge & F = \{ \AMODULE~f.\FIMODULE, ~\ALOCALS~\val^n~(t.\CONST~0)^k \})
      \end{array} \\

From bb329a671b50dbac5769ef8cd25843a7a16b14bb Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 3 Jan 2018 19:38:46 +0100
Subject: [PATCH 128/329] Improve build and fix typos (#628)

* Fix links to the web-api specification

* Remove Markdown use in an HTML page

* [spec] Implement spec deployment for JS specs

- Call out to bikeshed explicitly
- Run deploy.sh with bash (it doesn't work with other shells anyway)

* Use Bikeshed web service

* Travis deploy script for bikeshed specs

* Move deployment script to document directory

* Add Travis CI deploy key
---
 .travis.yml               |   9 ++++-
 deploy_key.enc            | Bin 0 -> 3248 bytes
 document/Makefile         |   4 +-
 document/index.html       |   2 +-
 document/js-api/Makefile  |   3 +-
 document/js-api/index.bs  |   2 +-
 document/travis-deploy.sh |  80 ++++++++++++++++++++++++++++++++++++++
 document/web-api/Makefile |   3 +-
 document/web-api/index.bs |   2 +-
 9 files changed, 95 insertions(+), 10 deletions(-)
 create mode 100644 deploy_key.enc
 create mode 100755 document/travis-deploy.sh

diff --git a/.travis.yml b/.travis.yml
index 4a06354cb..0b6aab315 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,8 +4,15 @@ sudo: off
 
 install: ./interpreter/meta/travis/install-ocaml.sh
 
-script: ./interpreter/meta/travis/build-test.sh
+script:
+  - ./interpreter/meta/travis/build-test.sh
+  - bash ./document/travis-deploy.sh
 
 os:
   - linux
   - osx
+
+env:
+  global:
+    - ENCRYPTION_LABEL: "304454be9d6c"
+    - COMMIT_AUTHOR_EMAIL: "noreply@webassembly.org"
diff --git a/deploy_key.enc b/deploy_key.enc
new file mode 100644
index 0000000000000000000000000000000000000000..b6d3e2f19771652a9711760b1712a77fe1b4e579
GIT binary patch
literal 3248
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

literal 0
HcmV?d00001

diff --git a/document/Makefile b/document/Makefile
index 3c666dd75..17b6756c9 100644
--- a/document/Makefile
+++ b/document/Makefile
@@ -14,7 +14,7 @@ $(BUILDDIR):
 
 .PHONY: deploy
 deploy:
-	GIT_DEPLOY_DIR=$(BUILDDIR) sh deploy.sh
+	GIT_DEPLOY_DIR=$(BUILDDIR) bash deploy.sh
 
 .PHONY: publish
 publish: all deploy
@@ -34,7 +34,7 @@ $(DIRS): %: $(BUILDDIR)
 
 .PHONY: $(DIRS:%=deploy-%)
 $(DIRS:%=deploy-%):
-	GIT_DEPLOY_DIR=$(BUILDDIR) GIT_DEPLOY_SUBDIR=$(@:deploy-%=%) sh deploy.sh
+	GIT_DEPLOY_DIR=$(BUILDDIR) GIT_DEPLOY_SUBDIR=$(@:deploy-%=%) bash deploy.sh
 
 .PHONY: $(DIRS:%=publish-%)
 $(DIRS:%=publish-%): publish-%: % deploy-%
diff --git a/document/index.html b/document/index.html
index 333705a11..90af7c147 100644
--- a/document/index.html
+++ b/document/index.html
@@ -37,7 +37,7 @@ <h3>API specifications</h3>
   <ul>
   <li><p><a href="js-api/index.html">JavaScript API</a>: defines JavaScript classes and objects for accessing WebAssembly from within JavaScript, including methods for validation, compilation, instantiation, and classes for representing and manipulating imports and exports as JavaScript objects.</p></li>
 
-  <li><p><a href="web-api/index.html">Web API</a>: defines extensions to the JavaScript API made available specifically in web browsers, in particular, an interface for streaming compilation and instantiation from origin-bound `Response` types.</p></li>
+  <li><p><a href="web-api/index.html">Web API</a>: defines extensions to the JavaScript API made available specifically in web browsers, in particular, an interface for streaming compilation and instantiation from origin-bound <code>Response</code> types.</p></li>
   </ul>
 
 </article>
diff --git a/document/js-api/Makefile b/document/js-api/Makefile
index 283c9360b..e94623501 100644
--- a/document/js-api/Makefile
+++ b/document/js-api/Makefile
@@ -6,8 +6,7 @@ NAME          = WebAssembly
 .PHONY: all
 all:
 	mkdir -p $(BUILDDIR)/html
-	# TODO(littledan): remove dummy and properly build into $(BUILDDIR)/html
-	touch $(BUILDDIR)/html/index.html
+	curl https://api.csswg.org/bikeshed/ -F file=@index.bs > $(BUILDDIR)/html/index.html
 	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html."
 
 .PHONY: publish
diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index ced1e3b34..d1cfb75ad 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -429,7 +429,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
     1. Return |promise|
 </div>
 
-Note: A follow-on streaming API is documented in the <a href="https://webassembly.github.io/spec/document/web/index.html">WebAssembly Web API</a>.
+Note: A follow-on streaming API is documented in the <a href="https://webassembly.github.io/spec/document/web-api/index.html">WebAssembly Web API</a>.
 
 <h3 id="modules">Modules</h3>
 
diff --git a/document/travis-deploy.sh b/document/travis-deploy.sh
new file mode 100755
index 000000000..afac17a8f
--- /dev/null
+++ b/document/travis-deploy.sh
@@ -0,0 +1,80 @@
+#!/bin/bash
+
+# Adapted from https://github.com/heycam/webidl/blob/master/deploy.sh
+
+set -e # Exit with nonzero exit code if anything fails
+
+SOURCE_BRANCH="master"
+TARGET_BRANCH="gh-pages"
+
+function doCompile {
+  # TODO(littledan): Integrate with document/deploy.sh
+  cd document/js-api
+  make
+  cd ../web-api
+  make
+  cd ../../out
+  if [[ ! -e js-api ]]; then mkdir js-api; fi
+  mv ../document/js-api/_build/html/index.html js-api/index.html
+  git add js-api/index.html
+  if [[ ! -e web-api ]]; then mkdir web-api; fi
+  mv ../document/web-api/_build/html/index.html web-api/index.html
+  git add web-api/index.html
+  cd ../
+}
+
+# Pull requests and commits to other branches shouldn't try to deploy, just build to verify
+if [[ "$TRAVIS_PULL_REQUEST" != "false" || "$TRAVIS_BRANCH" != "$SOURCE_BRANCH" ]]; then
+  echo "Skipping deploy; just doing a build."
+  mkdir out
+  doCompile
+  exit 0
+fi
+
+# Save some useful information
+REPO=`git config remote.origin.url`
+SSH_REPO=${REPO/https:\/\/github.com\//git@github.com:}
+SHA=`git rev-parse --verify HEAD`
+
+# Get the deploy key by using Travis's stored variables to decrypt deploy_key.enc
+ENCRYPTED_KEY_VAR="encrypted_${ENCRYPTION_LABEL}_key"
+ENCRYPTED_IV_VAR="encrypted_${ENCRYPTION_LABEL}_iv"
+ENCRYPTED_KEY=${!ENCRYPTED_KEY_VAR}
+ENCRYPTED_IV=${!ENCRYPTED_IV_VAR}
+openssl aes-256-cbc -K $ENCRYPTED_KEY -iv $ENCRYPTED_IV -in deploy_key.enc -out deploy_key -d || true
+chmod 600 deploy_key
+eval `ssh-agent -s`
+ssh-add deploy_key || true
+
+# Clone the existing gh-pages for this repo into out/
+# Create a new empty branch if gh-pages doesn't exist yet (should only happen on first deply)
+git clone $REPO out
+cd out
+git checkout $TARGET_BRANCH || git checkout --orphan $TARGET_BRANCH
+
+# Clean out existing contents
+git reset --hard
+
+# Run our compile script
+cd ..
+doCompile
+
+# Now let's go have some fun with the cloned repo
+cd out
+git config user.name "Travis CI"
+git config user.email "$COMMIT_AUTHOR_EMAIL"
+
+# If there are no changes to the compiled out (e.g. this is a README update) then just bail.
+if [[ -z "$(git status --porcelain)" ]]; then
+  echo "No changes to the output on this push; exiting."
+  exit 0
+fi
+
+# Commit the "changes", i.e. the new version.
+# The delta will show diffs between new and old versions.
+git add --all .
+git commit -m "Deploy to GitHub Pages: ${SHA}"
+
+# Now that we're all set up, we can push.
+git push $SSH_REPO $TARGET_BRANCH
+bash
diff --git a/document/web-api/Makefile b/document/web-api/Makefile
index eaac6549b..1054a6da1 100644
--- a/document/web-api/Makefile
+++ b/document/web-api/Makefile
@@ -6,8 +6,7 @@ NAME          = WebAssembly
 .PHONY: all
 all:
 	mkdir -p $(BUILDDIR)/html
-	# TODO(littledan): remove dummy and properly build into $(BUILDDIR)/html
-	touch $(BUILDDIR)/html/index.html
+	curl https://api.csswg.org/bikeshed/ -F file=@index.bs > $(BUILDDIR)/html/index.html
 	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html."
 
 .PHONY: publish
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 815f5e871..1b787856c 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -4,7 +4,7 @@ Shortname: wasmweb
 Group: WebAssembly CG
 Status: w3c/CG-DRAFT
 Level: 1
-ED: https://webassembly.github.io/spec/web/
+ED: https://webassembly.github.io/spec/web-api/
 Editor: WebAssembly Community Group
 Repository: WebAssembly/spec
 Abstract: This document describes the integration of WebAssembly with the broader web platform.

From 373b6d772dd25e52cfe12eabe30f25098611ceea Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 3 Jan 2018 20:55:52 +0100
Subject: [PATCH 129/329] Some editorial improvements to the Wasm/JS spec
 (#623)

* Editorial: Use USVString rather than DOMString to explain encoding

WebAssembly names are in the AST as strings of Unicode code points,
rather than UTF-8-encoded byte sequences. This patch uses WebIDL's
USVString type to encode this--the type is sequences of code points
in IDL-land, which is then converted to an ECMAScript value by
encoding in UTF-16. The place where this is inapplicable is custom
sections, which don't have a decoded name, but whose name is still
validated as UTF-8.

Thanks to @lukewagner for pointing this out in
https://github.com/WebAssembly/spec/pull/591#discussion_r151427259

* Editorial: Clean up caching JS objects

Previously, the instantiate function had some kind of complicated logic
to make it so just one JS object per memory, table or exported function
would be created per address in the store without having a global mapping.
This patch switches to a global mapping to make the specification
easier to read and modify over time.

The change here was discussed in this comment thread:
https://github.com/WebAssembly/spec/pull/591#discussion_r151598115

* Editorial: Improve comment

* Editorial: Further wording improvements

Suggested by @rossberg

* Editorial: Consolidate storage sections

* Editorial: Fix link to the moved core WebAssembly specification

* Editorial: Further changes from @rossberg's review
---
 document/js-api/index.bs | 161 ++++++++++++++++++---------------------
 1 file changed, 76 insertions(+), 85 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index d1cfb75ad..5bb5d54fb 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -81,7 +81,7 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMASCRIPT
         text: the Number value; url: sec-ecmascript-language-types-number-type
         text: NumberToRawBytes; url: sec-numbertorawbytes
         text: Built-in Function Objects; url: sec-built-in-function-objects
-urlPrefix: https://webassembly.github.io/spec/; spec: WebAssembly; type: dfn
+urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: dfn
     url: valid/modules.html#valid-module
         text: valid
         text: WebAssembly module validation
@@ -150,6 +150,7 @@ urlPrefix: https://webassembly.github.io/spec/; spec: WebAssembly; type: dfn
         text: 𝗆𝖾𝗆
         text: 𝗀𝗅𝗈𝖻𝖺𝗅
     text: global type; url: syntax/types.html#syntax-globaltype
+    text: address; url: exec/runtime.html#addresses
 </pre>
 
 <pre class='link-defaults'>
@@ -204,6 +205,27 @@ fetch('demo.wasm').then(response =>
 );
 ```
 
+<h2 id="webassembly-storage">Internal storage</h2>
+
+<h3 id="store">Interaction of the WebAssembly Store with JavaScript</h3>
+
+Note: WebAssembly semantics are defined in terms of an abstract [=store=], representing the state of the WebAssembly abstract machine. WebAssembly operations take a store and return an updated store.
+
+Each [=agent=] has an <dfn>associated store</dfn>. When a new agent is created, its associated store is set to the result of [=init_store=]().
+
+Note: In this specification, no WebAssembly-related objects, memory or addresses can be shared among agents in an [=agent cluster=]. In a future version of WebAssembly, this may change.
+
+Elements of the WebAssembly store may be <dfn>identified with</dfn> JavaScript values. In particular, each WebAssembly [=memory instance=] with a corresponding {{Memory}} object is identified with a JavaScript [=Data Block=]; modifications to this Data Block are identified to updating the agent's store to a store which reflects those changes, and vice versa.
+
+<h3 id="object-caches">WebAssembly JS Object Caches</h3>
+
+Note: There are several WebAssembly objects that may have a corresponding JavaScript object. The correspondence is stored in a per-agent mapping from WebAssembly [=address=]es to JavaScript objects. This mapping is used to ensure that, for a given [=agent=], there exists at most one JavaScript object for a particular WebAssembly address.
+
+Each [=agent=] is associated with the following three [=ordered map=]s:
+    * The <dfn>Memory object cache</dfn>, mapping [=memory address=]es to {{Memory}} objects.
+    * The <dfn>Table object cache</dfn>, mapping [=table address=]es to {{Table}} objects.
+    * The <dfn>Exported Function cache</dfn>, mapping [=function address=]es to [=Exported Function=] objects.
+
 <h2 id="webassembly-namespace">The WebAssembly Namespace</h2>
 
 <pre class="idl">
@@ -288,13 +310,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
   To <dfn>instantiate a WebAssembly module</dfn> from a {{Module}} |moduleObject| and imports |importObject|, perform the following steps:
     1. Let |module| be |moduleObject|.\[[Module]].
     1. If |module|.[=𝗂𝗆𝗉𝗈𝗋𝗍𝗌=] is not an empty list, and |importObject| is undefined, throw a {{TypeError}} exception.
-    1. Let |funcs| be an empty [=list=] of callable JavaScript objects.
-    1. Let |memories| be an empty [=list=] of {{Memory}} objects.
-    1. Let |tables| be an empty [=list=] of {{Table}} objects.
-
-        Note: The |funcs|, |memories| and |tables| lists are collected and used in order to cache the JavaScript objects corresponding to WebAssembly objects. If a WebAssembly object is exported multiple times, it will appear in exports as the same object instance. Moreover, if a JavaScript wrapper of a WebAssembly object was imported, and then present on the export, a new wrapper will not need to be created. However, if an ordinary JS function is imported, it will appear as wrapped by an [=Exported Function=].
-
-    6. Let |imports| be an empty [=list=] of [=external value=]s.
+    1. Let |imports| be an empty [=list=] of [=external value=]s.
     1. For each (|moduleName|, |componentName|, |externtype|) in [=module_imports=](|module|), do
         1. Let |o| be ? [=Get=](|importObject|, |moduleName|).
         1. If [=Type=](|o|) is not [=Object=], throw a {{TypeError}} exception.
@@ -305,11 +321,9 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
                 1. Let |funcaddr| be the value of |v|'s \[[FunctionAddress]] internal slot.
 
                 Note: The signature is checked by [=instantiate_module=] invoked below.
-
-                2. [=Append=] |v| to |funcs|.
             1. Otherwise,
                 1. [=Create a host function=] from |v| and let |funcaddr| be the result.
-            1. Let |externfunc| be the [=external value=] [=external value|𝖿𝗎𝗇𝖼=] |funcaddr|
+            1. Let |externfunc| be the [=external value=] [=external value|𝖿𝗎𝗇𝖼=] |funcaddr|.
             1. [=Append=] |externfunc| to |imports|.
         1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] |globaltype|,
             1. If |globaltype| is [=𝗂𝟨𝟦=] or [=Type=](|v|) is not [=Number=], throw a {{LinkError}} exception.
@@ -325,74 +339,51 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
 
             Note: [=instantiate_module=] invoked below will check the imported {{Memory}}'s size against the importing module's requirements.
 
-            2. [=Append=] |v| to |memories|.
-            1. Let |externmem| be the [=external value=] [=external value|𝗆𝖾𝗆=]  |v|.\[[Memory]].
+            2. Let |externmem| be the [=external value=] [=external value|𝗆𝖾𝗆=]  |v|.\[[Memory]].
             1. [=Append=] |externmem| to |imports|.
         1. Otherwise, |externtype| is of the form [=𝗍𝖺𝖻𝗅𝖾=] |tabletype|,
             1. If |v| is not a {{Table}} instance, throw a {{LinkError}} exception.
 
             Note: The table's length, etc. is checked by [=instantiate_module=] invoked below.
 
-            2. [=Append=] |v| to |tables|.
-            1. Let |tableaddr| be |v|.\[[Table]]
+            2. Let |tableaddr| be |v|.\[[Table]]
             1. Let |externtable| be the [=external value=] [=external value|𝗍𝖺𝖻𝗅𝖾=] |tableaddr|.
             1. [=Append=] |externtable| to |imports|.
-            1. For each element |func| of |v|.\[[Values]],
-                1. If |func| is not null, append |func| to |funcs|.
-    1. Let (|store|, |instance|) be [=instantiate_module=](|store|, |module|, |imports|), up through step 16 of [=the instantiation algorithm=], but omitting execution of the start function.
-    1. If |instance| is [=error=], throw a {{LinkError}} exception, or other <a href="#errors">appropriate exception type</a>.
-    1. For each |tableaddr| in |instance|.𝗍𝖺𝖻𝗅𝖾𝖺𝖽𝖽𝗋𝗌,
-        1. If there is no element in |tables| whose |table|.\[[Table]] is |tableaddr|:
-            1. Let |table| be [=create a table object|a new table object=] from |tableaddr|.
-            1. [=Append=] |table| to |tables|.
-        1. Otherwise:
-            1. Let |table| be the element in |tables| where |table|.\[[Table]] is |tableaddr|.
-        1. For each index |i| from 0 to the length of |table|.\[[Values]] &minus; 1, do
-            1. Let |funcaddr| be [=read_table=](|store|, |tableaddr|, |i|).
-            1. Assert: |funcaddr| is not [=error=] because this read is in bounds.
-            1. If |funcaddr| is not empty,
-                1. If |funcs| contains any |func| where |func|.\[[ExportedAddress]] is |funcaddr|,
-                    1. Let |func| be that function object.
-                1. Otherwise:
-                    1. Let |func| be a [=a new Exported Function=] created from |funcaddr|.
-                    1. [=Append=] |func| to |funcs|.
-                1. Set the |table|.\[[Values]][|i|] to |func|.
-
-                Note: The table and function objects created by the above steps are only observable for tables that are either imported or exported.
-
-    1. Let |startfuncaddr| be the start function of |instance|.
-    1. Let (|store|, |ret|) be [=invoke_func=](|store|, |startfuncaddr|, empty).
-    1. If |ret| is [=error=], throw an exception. This exception should be a WebAssembly {{RuntimeError}} exception, unless otherwise indicated by <a href="#errors">the WebAssembly error mapping</a>.
-    1. Assert: |ret| is empty.
+    1. Let (|store|, |instance|) be [=instantiate_module=](|store|, |module|, |imports|).
+    1. If |instance| is [=error=], throw an appropriate exception type:
+        * A {{LinkError}} exception for most cases which occur during linking.
+        * If the error came when running the start function, throw a {{RuntimeError}} for most errors which occur from WebAssembly, or the error object propagated from inner ECMAScript code.
+        * Another error type if appropriate, for example an out-of-memory exception, as documented in <a href="#errors">the WebAssembly error mapping</a>.
     1. Let |exportsObject| be ! [=ObjectCreate=](null).
-    1. For each pair (|nameBytes|, |externtype|) in [=module_exports=](|module|),
-        1. Let |name| be |nameBytes| [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
-        1. Assert: |name| is not failure (|module| is [=valid=]).
+    1. For each pair (|name|, |externtype|) in [=module_exports=](|module|),
         1. Let |externval| be [=get_export=](|instance|, |name|).
+        1. Assert: |externval| is not [=error=].
         1. If |externtype| is of the form [=𝖿𝗎𝗇𝖼=] |functype|,
-            1. If |funcs| contains an entry |func| where 𝖿𝗎𝗇𝖼 |func|.\[[FunctionAddress]] is |externval|, let |value| be |func|
-            1. Otherwise,
-                1. Let |func| be the result of [=a new Exported Function=] from |externval|.
-                1. [=Append=] |func| to |funcs|.
-                1. Let |value| be |func|.
+            1. Assert: |externval| is of the form [=external value|𝖿𝗎𝗇𝖼=] |funcaddr|.
+            1. Let [=external value|𝖿𝗎𝗇𝖼=] |funcaddr| be |externval|.
+            1. Let |func| be the result of creating [=a new Exported Function=] from |funcaddr|.
+            1. Let |value| be |func|.
         1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] |globaltype|,
             1. If |globaltype|.<em>[=global type|valtype=]</em>) is [=𝗂𝟨𝟦=], throw a {{LinkError}} exception.
             1. Assert: |globaltype|.<em>[=global type|mut=]</em> is [=global type|𝖼𝗈𝗇𝗌𝗍=], as verified by WebAssembly validation.
-            1. Let |value| be [=ToJSValue=]([=read_global=](|store|, |externval|)).
+            1. Assert: |externval| is of the form [=external value|𝗀𝗅𝗈𝖻𝖺𝗅=] |globaladdr|.
+            1. Let [=external value|𝗀𝗅𝗈𝖻𝖺𝗅=] |globaladdr| be |externval|.
+            1. Let |value| be [=ToJSValue=]([=read_global=](|store|, |globaladdr|)).
         1. If |externtype| is of the form [=𝗆𝖾𝗆=] |memtype|,
-            1. If there is an element |memory| in |memories| such that 𝗆𝖾𝗆  |memory|.\[[Memory]] is |externval|, then let |value| be |memory|
-            1. Otherwise:
-                1. Let |memory| be [=create a memory object|a new Memory object=] from |externval|.
-                1. [=Append=] |memory| to |memories|.
-                1. Let |value| be |memory|.
+            1. Assert: |externval| is of the form [=external value|𝗆𝖾𝗆=] |memaddr|.
+            1. Let [=external value|𝗆𝖾𝗆=] |memaddr| be |externval|.
+            1. Let |memory| be [=create a memory object|a new Memory object=] created from |memaddr|.
+            1. Let |value| be |memory|.
         1. Otherwise, |externtype| is of the form [=𝗍𝖺𝖻𝗅𝖾=] |tabletype|,
-            1. Let |value| be the unique |table| in |tables| such that 𝗍𝖺𝖻𝗅𝖾 |table|.\[[Table]] is |externval|.
+            1. Assert: |externval| is of the form [=external value|𝗍𝖺𝖻𝗅𝖾=] |tableaddr|.
+            1. Let [=external value|𝗍𝖺𝖻𝗅𝖾=] |tableaddr| be |externval|.
+            1. Let |table| be [=create a Table object|a new Table object=] created from |tableaddr|.
+            1. Let |value| be |table|.
         1. Let |status| be ! [=CreateDataProperty=](|exportsObject|, |name|, |value|).
         1. Assert: |status| is true.
 
         Note: the validity and uniqueness checks performed during [=WebAssembly module validation=] ensure that each property name is valid and no properties are defined twice.
-
-    33. Perform ! [=SetIntegrityLevel=](|exportsObject|, `"frozen"`).
+    1. Perform ! [=SetIntegrityLevel=](|exportsObject|, `"frozen"`).
     1. Let |instanceObject| be a new {{Instance}} object whose internal \[[Instance]] slot is set to |instance| and the \[[Exports]] slot to |exportsObject|.
     1. Return |instanceObject|.
 </div>
@@ -442,14 +433,14 @@ enum ImportExportKind {
 };
 
 dictionary ModuleExportDescriptor {
-  required DOMString name;
+  required USVString name;
   required ImportExportKind kind;
   // Note: Other fields such as signature may be added in the future.
 };
 
 dictionary ModuleImportDescriptor {
-  required DOMString module;
-  required DOMString name;
+  required USVString module;
+  required USVString name;
   required ImportExportKind kind;
 };
 
@@ -457,7 +448,7 @@ dictionary ModuleImportDescriptor {
 interface Module {
   static sequence&lt;ModuleExportDescriptor> exports(Module module);
   static sequence&lt;ModuleImportDescriptor> imports(Module module);
-  static sequence&lt;ArrayBuffer> customSections(Module module, DOMString sectionName);
+  static sequence&lt;ArrayBuffer> customSections(Module module, USVString sectionName);
 };
 </pre>
 
@@ -473,9 +464,7 @@ interface Module {
     The <dfn method for="Module">exports(moduleObject)</dfn> method, when invoked, performs the following steps:
     1. Let |module| be |moduleObject|.\[[Module]].
     1. Let |exports| be an empty [=list=].
-    1. For each (|nameBytes|, |type|) in [=module_exports=](|module|)
-        1. Let |name| be |nameBytes| [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
-        1. Assert: |name| is not failure (|module| is [=valid=]).
+    1. For each (|name|, |type|) in [=module_exports=](|module|)
         1. Let |kind| be the [=string value of the extern type=] |type|.
         1. Let |obj| be a new {{ModuleExportDescriptor}} dictionary with {{ModuleExportDescriptor/name}} |name| and {{ModuleExportDescriptor/kind}} |kind|.
         1. [=Append=] |obj| to the end of |exports|.
@@ -486,10 +475,7 @@ interface Module {
     The <dfn method for="Module">imports(moduleObject)</dfn> method, when invoked, performs the following steps:
     1. Let |module| be |moduleObject|.\[[Module]].
     1. Let |imports| be an empty [=list=].
-    1. For each (|moduleBytes|, |nameBytes|, |type|) in [=module_imports=](|module|),
-        1. Let |moduleName| be |moduleBytes| [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
-        1. Let |name| be |nameBytes| [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
-        1. Assert: The previous operations are not failure, as |module| is [=valid=].
+    1. For each (|moduleName|, |name|, |type|) in [=module_imports=](|module|),
         1. Let |kind| be the [=string value of the extern type=] |type|.
         1. Let |obj| be a new {{ModuleImportDescriptor}} dictionary with {{ModuleImportDescriptor/module}} |moduleName|, {{ModuleImportDescriptor/name}} |name| and {{ModuleImportDescriptor/kind}} |kind|.
         1. [=Append=] |obj| to the end of |imports|.
@@ -561,17 +547,22 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 <div algorithm>
     To <dfn>create a memory object</dfn> from a [=memory address=] |memaddr|, perform the following steps:
 
+    1. Let |map| be the current [=agent=]'s associated [=Memory object cache=].
+    1. If |map|[|memaddr|] [=map/exists=],
+        1. Return |map|[|memaddr|].
     1. Let |block| be a Data Block which is [=identified with=] the underlying memory of |memaddr|
     1. Let |buffer| be a new {{ArrayBuffer}} whose \[[ArrayBufferData]] is |block| and \[[ArrayBufferByteLength]] is set to the length of |block|.
-    1. Return a new {{Memory}} instance with \[[Memory]] set to |memaddr| and \[[BufferObject]] set to |buffer|.
+    1. Let |memory| be a new {{Memory}} instance with \[[Memory]] set to |memaddr| and \[[BufferObject]] set to |buffer|.
+    1. [=map/Set=] |map|[|memaddr|] to |memory|.
+    1. Return |memory|.
 
     Issue: Any attempts to [=DetachArrayBuffer|detach=] |buffer|, other than the detachment performed by {{Memory/grow(delta)}}, will throw a {{TypeError}} exception. Specifying this behavior <a href="https://github.com/tc39/ecma262/issues/1024">requires changes to the ECMAScript specification</a>.
 </div>
 
 <div algorithm>
     The <dfn constructor for="Memory">Memory(descriptor)</dfn> constructor, when invoked, performs the following steps:
-    1. If |descriptor|\["initial"] is [=present=], let |initial| be |descriptor|\["initial"]; otherwise, let |initial| be 0.
-    1. If |descriptor|\["maximum"] is [=present=], let |maximum| be |descriptor|\["maximum"]; otherwise, let |maximum| be empty.
+    1. If |descriptor|["initial"] is [=present=], let |initial| be |descriptor|["initial"]; otherwise, let |initial| be 0.
+    1. If |descriptor|["maximum"] is [=present=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
     1. Let |memtype| be { min |initial|, max |maximum| }
     1. Let |store| be the current agent's [=associated store=].
     1. Let (|store|, |memaddr|) be [=alloc_mem=](|store|, |memtype|). If allocation fails, throw a {{RangeError}} exception.
@@ -601,7 +592,8 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 <pre class="idl">
 enum TableKind {
   "anyfunc",
-  // Note: More values may be added in future iterations
+  // Note: More values may be added in future iterations,
+  // e.g., typed function references, typed GC references
 };
 
 dictionary TableDescriptor {
@@ -630,8 +622,13 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 
 <div algorithm>
     To <dfn>create a table object</dfn> from a [=table address=] |tableaddr|, perform the following steps:
+    1. Let |map| be the current [=agent=]'s associated [=Table object cache=].
+    1. If |map|[|tableaddr|] [=map/exists=],
+        1. Return |map|[|tableaddr|].
     1. Let |values| be a list whose length is [=size_table=](|store|, |tableaddr|) where each element is null.
-    1. Return a new {{Table}} instance with \[[Table]] set to |tableaddr| and \[[Values]] set to |values|.
+    1. Let |table| be a new {{Table}} instance with \[[Table]] set to |tableaddr| and \[[Values]] set to |values|.
+    1. [=map/Set=] |map|[|tableaddr|] to |table|.
+    1. Return |table|.
 </div>
 
 <div algorithm>
@@ -714,6 +711,9 @@ This slot holds a [=function address=] relative to the current agent's [=associa
 <div algorithm>
   To create <dfn>a new Exported Function</dfn> from a WebAssembly [=function address=] |funcaddr|, perform the following steps:
 
+    1. Let |map| be the current [=agent=]'s associated [=Exported Function cache=].
+    1. If |map|[|funcaddr|] [=map/exists=],
+        1. Return |map|[|funcaddr|].
     1. Let |steps| be "[=call an Exported Function|call the Exported Function=] |funcaddr| with arguments."
     1. Let |realm| be the [=current Realm=].
     1. Let |function| be [=CreateBuiltinFunction=](|realm|, |steps|, [=%FunctionPrototype%=], &laquo; \[[FunctionAddress]]).
@@ -725,6 +725,7 @@ This slot holds a [=function address=] relative to the current agent's [=associa
     1. Perform ! [=DefinePropertyOrThrow=](|function|, `"length"`, PropertyDescriptor {\[[Value]]: |arity|, \[[Writable]]: false, \[[Enumerable]]: false, \[[Configurable]]: true}).
     1. Let |name| be the [=name of the WebAssembly function=] |funcaddr|.
     1. Perform ! [=SetFunctionName=](|function|, |name|).
+    1. [=map/Set=] |map|[|funcaddr|] to |function|.
     1. Return |function|.
 </div>
 
@@ -854,13 +855,3 @@ same class of exception is thrown as for out of memory conditions in JavaScript.
 The particular exception here is implementation-defined in both cases.
 
 Note: ECMAScript doesn't specify any sort of behavior on out-of-memory conditions; implementations have been observed to throw OOMError and to crash. Either is valid here.
-
-<h2 id="store">Interaction of the WebAssembly Store with JavaScript</h2>
-
-Note: WebAssembly semantics are defined in terms of a [=store=], representing the state of the world, or "memory". WebAssembly operations take a store and return a new store.
-
-Each [=agent=] has an <dfn>associated store</dfn>. When a new agent is created, its associated store is set to the result of [=init_store=]().
-
-Note: In this specification, no WebAssembly-related objects, memory or addresses can be shared among agents in an [=agent cluster=]. In a future version of WebAssembly, the <a href="https://github.com/WebAssembly/threads">threads proposal</a> will add such sharing. For the JS binding, this will likely mean that there will be a store per agent cluster, rather than per agent. This specification uses a store per agent in order to limit semantics to how a store operates in a single-threaded manner, as the WebAssembly specification without threads only deals with that case.
-
-Elements of the WebAssembly store may be <dfn>identified with</dfn> JavaScript values. In particular, each WebAssembly [=memory instance=] with a corresponding {{Memory}} object is identified with a JavaScript [=Data Block=]; modifications to this Data Block are identified to updating the agent's store to a store which reflects those changes, and vice versa.

From 5825ece36fa2a9f4eb26f5f8004b3de95358eda4 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Thu, 4 Jan 2018 00:39:15 +0100
Subject: [PATCH 130/329] [spec] Fix build issue (#636)

There was an errant call to "bash" at the end of the Travis CI deploy
script, leading deploys to stall and appear to be failing. This patch
removes the line.
---
 document/travis-deploy.sh | 1 -
 1 file changed, 1 deletion(-)

diff --git a/document/travis-deploy.sh b/document/travis-deploy.sh
index afac17a8f..44c88fef3 100755
--- a/document/travis-deploy.sh
+++ b/document/travis-deploy.sh
@@ -77,4 +77,3 @@ git commit -m "Deploy to GitHub Pages: ${SHA}"
 
 # Now that we're all set up, we can push.
 git push $SSH_REPO $TARGET_BRANCH
-bash

From 5041628a97af3e19438bef96dea7912226d93096 Mon Sep 17 00:00:00 2001
From: David Swasey <swasey@mpi-sws.org>
Date: Thu, 4 Jan 2018 15:39:51 +0100
Subject: [PATCH 131/329] [spec] Fix evaluation contexts and structural rules
 (#637)

* [spec] Fix evaluation contexts and structural rules

Replace frame instructions in evaluation contexts with a
context-sensitive structural rule.

Clarify the side-condition in the trap propagation rule.
---
 document/core/exec/runtime.rst | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index cf20bc33d..c4ad03390 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -562,28 +562,40 @@ Finally, the following definition of *evaluation context* and associated structu
    \production{(evaluation contexts)} & E &::=&
      [\_] ~|~
      \val^\ast~E~\instr^\ast ~|~
-     \LABEL_n\{\instr^\ast\}~E~\END ~|~
-     \FRAME_n\{\frame\}~E~\END \\
+     \LABEL_n\{\instr^\ast\}~E~\END \\
    \end{array}
 
 .. math::
+   \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
    S; F; E[\instr^\ast] &\stepto& S'; F'; E[{\instr'}^\ast]
-     & (\iff S; F; \instr^\ast \stepto S'; F'; {\instr'}^\ast) \\
+   \end{array}
+   \\ \qquad
+     (\iff S; F; \instr^\ast \stepto S'; F'; {\instr'}^\ast) \\
+   \begin{array}{lcl@{\qquad}l}
+   S; F; \FRAME_n\{F'\}~\instr^\ast~\END &\stepto& S'; F; \FRAME_n\{F''\}~\instr'^\ast~\END
+   \end{array}
+   \\ \qquad
+     (\iff S; F'; \instr^\ast \stepto S'; F''; {\instr'}^\ast) \\[1ex]
+   \begin{array}{lcl@{\qquad}l}
    S; F; E[\TRAP] &\stepto& S; F; \TRAP
-     & (\iff E \neq [\_]) \\
+     &(\iff E \neq [\_]) \\
+   S; F; \FRAME_n\{F'\}~\TRAP~\END &\stepto& S; F; \TRAP
+   \end{array} \\
    \end{array}
 
 Reduction terminates when a thread's instruction sequence has been reduced to a :ref:`result <syntax-result>`,
 that is, either a sequence of :ref:`values <syntax-val>` or to a |TRAP|.
 
 .. note::
-   For example, the following instruction sequence,
+   The restriction on evaluation contexts rules out contexts like :math:`[\_]` and :math:`\epsilon~[\_]~\epsilon` for which :math:`E[\TRAP] = \TRAP`.
+
+   For an example of reduction under evaluation contexts, consider the following instruction sequence.
 
    .. math::
        (\F64.\CONST~x_1)~(\F64.\CONST~x_2)~\F64.\NEG~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL
 
-   can be decomposed into :math:`E[(\F64.\CONST~x_2)~\F64.\NEG]` where
+   This can be decomposed into :math:`E[(\F64.\CONST~x_2)~\F64.\NEG]` where
 
    .. math::
       E = (\F64.\CONST~x_1)~[\_]~(\F64.\CONST~x_3)~\F64.\ADD~\F64.\MUL

From 1c9f6f27fc9052ee9d0edf77ac468aa07f69b842 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Fri, 5 Jan 2018 15:59:34 +0100
Subject: [PATCH 132/329] Travis-CI integration for building the core HTML spec
 (#638)

* Travis-CI integration for building the core HTML spec

* Use sudo for installing sphinx :(

* Use Makefile for CI build, including pdf

TeX is installed with texlive-full package; maybe there is a smaller
package that would be adequate.

* Apply @rossberg's makefile code review advice
---
 .travis.yml               | 11 ++++++-----
 document/travis-deploy.sh | 29 +++++++++--------------------
 2 files changed, 15 insertions(+), 25 deletions(-)

diff --git a/.travis.yml b/.travis.yml
index 0b6aab315..556c2b2a1 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,16 +1,17 @@
 language: c++
 
-sudo: off
+sudo: on
 
-install: ./interpreter/meta/travis/install-ocaml.sh
+install:
+  - ./interpreter/meta/travis/install-ocaml.sh
+  - sudo pip install sphinx
+  - sudo apt-get install texlive-full
 
 script:
   - ./interpreter/meta/travis/build-test.sh
   - bash ./document/travis-deploy.sh
 
-os:
-  - linux
-  - osx
+os: linux
 
 env:
   global:
diff --git a/document/travis-deploy.sh b/document/travis-deploy.sh
index 44c88fef3..323c1eba2 100755
--- a/document/travis-deploy.sh
+++ b/document/travis-deploy.sh
@@ -9,24 +9,12 @@ TARGET_BRANCH="gh-pages"
 
 function doCompile {
   # TODO(littledan): Integrate with document/deploy.sh
-  cd document/js-api
-  make
-  cd ../web-api
-  make
-  cd ../../out
-  if [[ ! -e js-api ]]; then mkdir js-api; fi
-  mv ../document/js-api/_build/html/index.html js-api/index.html
-  git add js-api/index.html
-  if [[ ! -e web-api ]]; then mkdir web-api; fi
-  mv ../document/web-api/_build/html/index.html web-api/index.html
-  git add web-api/index.html
-  cd ../
+  (cd document; make)
 }
 
 # Pull requests and commits to other branches shouldn't try to deploy, just build to verify
 if [[ "$TRAVIS_PULL_REQUEST" != "false" || "$TRAVIS_BRANCH" != "$SOURCE_BRANCH" ]]; then
   echo "Skipping deploy; just doing a build."
-  mkdir out
   doCompile
   exit 0
 fi
@@ -48,19 +36,20 @@ ssh-add deploy_key || true
 
 # Clone the existing gh-pages for this repo into out/
 # Create a new empty branch if gh-pages doesn't exist yet (should only happen on first deply)
-git clone $REPO out
-cd out
-git checkout $TARGET_BRANCH || git checkout --orphan $TARGET_BRANCH
+git clone $REPO document/_build
+(
+  cd document/_build
+  git checkout $TARGET_BRANCH || git checkout --orphan $TARGET_BRANCH
 
-# Clean out existing contents
-git reset --hard
+  # Clean out existing contents
+  git reset --hard
+)
 
 # Run our compile script
-cd ..
 doCompile
 
 # Now let's go have some fun with the cloned repo
-cd out
+cd document/_build
 git config user.name "Travis CI"
 git config user.email "$COMMIT_AUTHOR_EMAIL"
 

From 378fcb271cbae648afed2912b08c0c5e20b1fc24 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 8 Jan 2018 10:31:40 +0100
Subject: [PATCH 133/329] [interpreter] Remove remnants of assert_soft_invalid
 (#641)

---
 interpreter/README.md |  3 ---
 test/harness/index.js | 15 ---------------
 2 files changed, 18 deletions(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index dc34b0446..972a7c5f7 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -107,7 +107,6 @@ The first creates a new test scripts where all embedded modules are converted to
 The last invocation produces an equivalent, self-contained JavaScript test file.
 The flag `-h` can be used to omit the test harness from the converted file;
 it then is the client's responsibility to provide versions of the necessary functions.
-By default, the generated script will not require `assert_soft_invalid` (see below) to detect validation failures. Use the `-c` flag ("checked hard") to activate these assertions for full validity checks.
 
 #### Command Line Expressions
 
@@ -326,7 +325,6 @@ assertion:
   ( assert_trap <action> <failure> )         ;; assert action traps with given failure string
   ( assert_malformed <module> <failure> )    ;; assert module cannot be decoded with given failure string
   ( assert_invalid <module> <failure> )      ;; assert module is invalid with given failure string
-  ( assert_soft_invalid <module> <failure> ) ;; assert module is for cases that are not required to be checked
   ( assert_unlinkable <module> <failure> )   ;; assert module fails to link
   ( assert_trap <module> <failure> )         ;; assert module traps on instantiation
 
@@ -350,7 +348,6 @@ The `input` and `output` meta commands determine the requested file format from
 
 The interpreter supports a "dry" mode (flag `-d`), in which modules are only validated. In this mode, all actions and assertions are ignored.
 It also supports an "unchecked" mode (flag `-u`), in which module definitions are not validated before use.
-Finally, "checked hard" mode (flag `-c`), will require `assert_soft_valid` assertions to succeed. When outputing JavaScript scripts, this flag also controls how the created script implements this assertions.
 
 ## Abstract Syntax
 
diff --git a/test/harness/index.js b/test/harness/index.js
index a3134b18e..dbac4bd65 100644
--- a/test/harness/index.js
+++ b/test/harness/index.js
@@ -66,8 +66,6 @@ const EXPECT_INVALID = false;
 
 /* DATA **********************************************************************/
 
-let soft_validate = true;
-
 let $$;
 
 // Default imports.
@@ -156,19 +154,6 @@ function assert_invalid(bytes) {
 
 const assert_malformed = assert_invalid;
 
-function assert_soft_invalid(bytes) {
-    uniqueTest(() => {
-        try {
-            module(bytes, /* valid */ soft_validate);
-            if (soft_validate)
-                throw new Error('did not fail');
-        } catch(e) {
-            if (soft_validate)
-                assert_true(e instanceof WebAssembly.CompileError, "expected soft invalid failure:");
-        }
-    }, "A wast module that *could* be invalid under certain engines.");
-}
-
 function instance(bytes, imports = registry, valid = true) {
     if (imports instanceof Result) {
         if (imports.isError())

From a25083ac7076b05e3f304ec9e093ef1b1ee09422 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 8 Jan 2018 18:03:27 +0100
Subject: [PATCH 134/329] [interpreter] Add number grammar to README

---
 interpreter/README.md | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 972a7c5f7..36ccf2754 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -164,18 +164,24 @@ The implementation consumes a WebAssembly AST given in S-expression syntax. Here
 
 Note: The grammar is shown here for convenience, the definite source is the [specification of the text format](https://webassembly.github.io/spec/text/).
 ```
-value: <int> | <float>
-var: <int> | <name>
-name: $(<letter> | <digit> | _ | . | + | - | * | / | \ | ^ | ~ | = | < | > | ! | ? | @ | # | $ | % | & | | | : | ' | `)+
+num:    <digit> (_? <digit>)*
+hexnum: <hexdigit> (_? <hexdigit>)*
+nat:    <num> | 0x<hexnum>
+int:    <nat> | +<nat> | -<nat>
+float:  <num>.<num>?(e|E <num>)? | 0x<hexnum>.<hexnum>?(p|P <num>)?
+name:   $(<letter> | <digit> | _ | . | + | - | * | / | \ | ^ | ~ | = | < | > | ! | ? | @ | # | $ | % | & | | | : | ' | `)+
 string: "(<char> | \n | \t | \\ | \' | \" | \<hex><hex> | \u{<hex>+})*"
 
+value:  <int> | <float>
+var:    <nat> | <name>
+
 type: i32 | i64 | f32 | f64
 elem_type: anyfunc
 
 unop:  ctz | clz | popcnt | ...
 binop: add | sub | mul | ...
 relop: eq | ne | lt | ...
-sign: s|u
+sign:  s|u
 offset: offset=<nat>
 align: align=(1|2|4|8|...)
 cvtop: trunc_s | trunc_u | extend_s | extend_u | ...

From 59f6199d18f584bc64bfaddeb57161950371ee97 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Tue, 9 Jan 2018 17:04:25 +0100
Subject: [PATCH 135/329] [test] JS API tests for caching and function names

This patch add tests against the WebAssembly JS API for
- Memory, tables and functions, including JS FFI functions, are
  cached and reused between imports and exports.
- The name property of functions is determined by the index where
  they are defined; for JS functions, this is the index where
  they are imported.

These tests pass on SpiderMonkey but have certain failures
in JSC and V8.
---
 test/js-api/jsapi.js | 91 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 91 insertions(+)

diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 8e0f1cec8..7d560b150 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -791,4 +791,95 @@ test(() => {
         g:{'⚡':1}});
 }, "'WebAssembly.instantiate' function");
 
+const complexReExportingModuleBinary = (() => {
+    let builder = new WasmModuleBuilder();
+
+    let fIndex = builder.addImport('a', 'f', kSig_i_i);
+    let gIndex = builder.addImport('a', 'g', kSig_i_v);
+    builder.addImportedMemory('c', 'd');
+    builder.addImportedTable('e', 'f');
+
+    builder.addExport('x', fIndex)
+    builder.addExport('y', gIndex)
+    builder.addExportOfKind('z', kExternalMemory, 0)
+    builder.addExportOfKind('w', kExternalTable, 0)
+
+    return builder.toBuffer();
+})();
+
+const complexTableReExportingModuleBinary = (() => {
+    let builder = new WasmModuleBuilder();
+
+    builder.addImport('a', '_', kSig_v_v);
+    let gIndex = builder.addImport('a', 'g', kSig_i_v);
+    let fIndex = builder.addImport('a', 'f', kSig_i_i);
+    let hIndex = builder
+        .addFunction('h', kSig_i_v)
+        .addBody([
+            kExprI32Const,
+            46,
+            kExprEnd
+        ]).index;
+
+    builder.setFunctionTableLength(3);
+    builder.appendToTable([fIndex, gIndex, hIndex]);
+    builder.addExportOfKind('tab', kExternalTable, 0);
+
+    return builder.toBuffer();
+})();
+
+
+test(() => {
+  let module = new WebAssembly.Module(complexReExportingModuleBinary);
+  let memory = new WebAssembly.Memory({initial: 0});
+  let table = new WebAssembly.Table({initial: 0, element: 'anyfunc'});
+  let imports = {
+    a: { f(x) { return x+1; }, g: exportingInstance.exports.f },
+    c: { d: memory },
+    e: { f: table },
+  };
+  let instance = reExportingInstance =
+      new WebAssembly.Instance(module, imports);
+
+  assert_equals(instance.exports.x.name, "0");
+  assert_false(instance.exports.x === imports.a.f);
+
+  // Previously exported Wasm functions are re-exported with the same value
+  assert_equals(instance.exports.y, exportingInstance.exports.f);
+  assert_equals(instance.exports.y.name, "0");
+
+  // Re-exported Memory and Table objects have the same value
+  assert_equals(instance.exports.z, memory);
+  assert_equals(instance.exports.w, table);
+
+  // Importing the same JS function object results in a distinct exported
+  // function object, whereas previously exported Wasm functions are
+  // re-exported with the same identity.
+  let instance2 = new WebAssembly.Instance(module, imports);
+  assert_false(instance.exports.x === instance2.exports.x);
+  assert_equals(instance.exports.y, instance2.exports.y);
+}, "Exported values have cached JS objects");
+
+test(() => {
+  let module = new WebAssembly.Module(complexTableReExportingModuleBinary);
+  let instance = new WebAssembly.Instance(module,
+      { a: { _() { }, f: reExportingInstance.exports.x,
+             g: exportingInstance.exports.f } });
+  let table = instance.exports.tab;
+
+  // The functions that were put in come right back out
+  assert_equals(table.get(0), reExportingInstance.exports.x);
+  assert_equals(table.get(1), exportingInstance.exports.f);
+
+  // The original function indices are reflected in the name
+  assert_equals(table.get(0).name, "0");
+  assert_equals(table.get(1).name, "0");
+  assert_equals(table.get(2).name, "3");
+
+  // All of the functions work
+  assert_equals(table.get(0)(5), 6);
+  assert_equals(table.get(1)(), 42);
+  assert_equals(table.get(2)(), 46);
+}, "Tables export cached ");
+
 })();

From 40d27eb6045b7439d47266ae976f5092befd7c69 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Tue, 9 Jan 2018 17:42:58 +0100
Subject: [PATCH 136/329] Normative: Re-exported host functions are numbered

This patch makes the names of exported functions which come from
imported host functions be the index of the import. Although it
was a bit implicit in the original JS.md specification, this are
probably the originally indended behavior.

These semantics seem to be implemented by V8 and SpiderMonkey, but
JSC supports different semantics for exported function names.
---
 document/js-api/index.bs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 5bb5d54fb..c4c41140e 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -306,7 +306,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
     1. Return |promise|.
 </div>
 
-<div algorithm>
+<div algorithm="instantiate">
   To <dfn>instantiate a WebAssembly module</dfn> from a {{Module}} |moduleObject| and imports |importObject|, perform the following steps:
     1. Let |module| be |moduleObject|.\[[Module]].
     1. If |module|.[=𝗂𝗆𝗉𝗈𝗋𝗍𝗌=] is not an empty list, and |importObject| is undefined, throw a {{TypeError}} exception.
@@ -323,6 +323,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
                 Note: The signature is checked by [=instantiate_module=] invoked below.
             1. Otherwise,
                 1. [=Create a host function=] from |v| and let |funcaddr| be the result.
+                1. Let |index| be the number of external functions in |imports|. This value |index| is known as the <dfn>index of the host function</dfn> |funcaddr|.
             1. Let |externfunc| be the [=external value=] [=external value|𝖿𝗎𝗇𝖼=] |funcaddr|.
             1. [=Append=] |externfunc| to |imports|.
         1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] |globaltype|,
@@ -698,14 +699,13 @@ This slot holds a [=function address=] relative to the current agent's [=associa
     1. Let |store| be the current agent's [=associated store=].
     1. Let |funcinst| be |store|.𝖿𝗎𝗇𝖼𝗌[|funcaddr|].
     1. If |funcinst| is of the form {𝗍𝗒𝗉𝖾 |functype|, 𝗁𝗈𝗌𝗍𝖼𝗈𝖽𝖾 |hostfunc|},
-      1. Assert: |hostfunc| is a JavaScript object and [=IsCallable=](|hostfunc|) is true.
-      1. Let |name| be ? [=Get=](|hostfunc|, "name").
-      1. Return ? [=ToString=](|name|).
+        1. Assert: |hostfunc| is a JavaScript object and [=IsCallable=](|hostfunc|) is true.
+        1. Let |index| be the [=index of the host function=] |funcaddr|.
     1. Otherwise,
-      1. Let |moduleinst| be |funcinst|.𝗆𝗈𝖽𝗎𝗅𝖾.
-      1. Assert: |funcaddr| is contained in |moduleinst|.𝖿𝗎𝗇𝖼𝖺𝖽𝖽𝗋𝗌.
-      1. Let |index| be the index of |moduleinst|.𝖿𝗎𝗇𝖼𝖺𝖽𝖽𝗋𝗌 where |funcaddr| is found.
-      1. Return ! [=ToString=](|index|).
+        1. Let |moduleinst| be |funcinst|.𝗆𝗈𝖽𝗎𝗅𝖾.
+        1. Assert: |funcaddr| is contained in |moduleinst|.𝖿𝗎𝗇𝖼𝖺𝖽𝖽𝗋𝗌.
+        1. Let |index| be the index of |moduleinst|.𝖿𝗎𝗇𝖼𝖺𝖽𝖽𝗋𝗌 where |funcaddr| is found.
+    1. Return ! [=ToString=](|index|).
 </div>
 
 <div algorithm>

From 9d789ca5a42bceae3f50216e8fb93069d54ca283 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Mon, 15 Jan 2018 14:31:29 +0100
Subject: [PATCH 137/329] [spec] Makefile tweak

---
 document/Makefile | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/document/Makefile b/document/Makefile
index 17b6756c9..8a1544477 100644
--- a/document/Makefile
+++ b/document/Makefile
@@ -5,12 +5,10 @@ BUILDDIR = _build
 # Global targets.
 
 .PHONY: all
-all: $(DIRS)
+all: $(BUILDDIR) root $(DIRS)
 
 $(BUILDDIR):
 	mkdir -p $@
-	cp -f $(FILES) $(BUILDDIR)/
-	touch $(BUILDDIR)/.nojekyll
 
 .PHONY: deploy
 deploy:
@@ -26,6 +24,11 @@ clean: $(DIRS:%=clean-%)
 
 # Directory-specific targets.
 
+.PHONY: root
+root: $(BUILDDIR)
+	touch $(BUILDDIR)/.nojekyll
+	cp -f $(FILES) $(BUILDDIR)/
+
 .PHONY: $(DIRS)
 $(DIRS): %: $(BUILDDIR)
 	(cd $@; make BUILDDIR=$(BUILDDIR) all)

From 21f09e25a12a877aa3b9740fbfc623d463eb9f93 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Wed, 24 Jan 2018 15:34:05 +0100
Subject: [PATCH 138/329] Remove trailing whitespace (#651)

---
 test/js-api/jsapi.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 7d560b150..6701a418d 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -880,6 +880,6 @@ test(() => {
   assert_equals(table.get(0)(5), 6);
   assert_equals(table.get(1)(), 42);
   assert_equals(table.get(2)(), 46);
-}, "Tables export cached ");
+}, "Tables export cached");
 
 })();

From 921537bfa037f47218d9eb87ad57869d5d78e44e Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Fri, 26 Jan 2018 17:16:12 -0800
Subject: [PATCH 139/329] Fix typo in JS API index.bs

---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index c4c41140e..1da8ea703 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -615,7 +615,7 @@ interface Table {
 <div>
 A {{Table}} object represents a single [=table instance=]
 which can be simultaneously referenced by multiple {{Instance}} objects. Each
-{{Table}} object has one internal slots:
+{{Table}} object has two internal slots:
 
     * \[[Table]] : a [=table address=]
     * \[[Values]] : a List whose elements are either null or [=Exported Function=]s.

From 3e323dc13251b59fb494122124282cea093f1192 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 30 Jan 2018 04:17:13 +0100
Subject: [PATCH 140/329] [interpreter] match spec style of implementing return
 (#658)

---
 interpreter/exec/eval.ml     | 93 ++++++++++++++++++++----------------
 test/core/call_indirect.wast |  8 ++--
 2 files changed, 55 insertions(+), 46 deletions(-)

diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index eb8f0b8da..6409cf0a3 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -50,23 +50,22 @@ type code = value stack * admin_instr list
 and admin_instr = admin_instr' phrase
 and admin_instr' =
   | Plain of instr'
-  | Trapped of string
-  | Break of int32 * value stack
-  | Label of stack_type * instr list * code
-  | Frame of frame * code
+  | Trapping of string
+  | Returning of value stack
+  | Breaking of int32 * value stack
+  | Label of int * instr list * code
+  | Frame of int * frame * code
   | Invoke of func_inst
 
 type config =
 {
   frame : frame;
   code : code;
-  depth : int;   (* needed for return *)
-  budget : int;  (* needed to model stack overflow *)
+  budget : int;  (* to model stack overflow *)
 }
 
 let frame inst locals = {inst; locals}
-let config inst vs es =
-  {frame = frame inst []; code = vs, es; depth = 0; budget = 300}
+let config inst vs es = {frame = frame inst []; code = vs, es; budget = 300}
 
 let plain e = Plain e.it @@ e.at
 
@@ -120,16 +119,16 @@ let rec step (c : config) : config =
     | Plain e', vs ->
       (match e', vs with
       | Unreachable, vs ->
-        vs, [Trapped "unreachable executed" @@ e.at]
+        vs, [Trapping "unreachable executed" @@ e.at]
 
       | Nop, vs ->
         vs, []
 
       | Block (ts, es'), vs ->
-        vs, [Label (ts, [], ([], List.map plain es')) @@ e.at]
+        vs, [Label (List.length ts, [], ([], List.map plain es')) @@ e.at]
 
       | Loop (ts, es'), vs ->
-        vs, [Label ([], [e' @@ e.at], ([], List.map plain es')) @@ e.at]
+        vs, [Label (0, [e' @@ e.at], ([], List.map plain es')) @@ e.at]
 
       | If (ts, es1, es2), I32 0l :: vs' ->
         vs', [Plain (Block (ts, es2)) @@ e.at]
@@ -138,7 +137,7 @@ let rec step (c : config) : config =
         vs', [Plain (Block (ts, es1)) @@ e.at]
 
       | Br x, vs ->
-        [], [Break (x.it, vs) @@ e.at]
+        [], [Breaking (x.it, vs) @@ e.at]
 
       | BrIf x, I32 0l :: vs' ->
         vs', []
@@ -153,7 +152,7 @@ let rec step (c : config) : config =
         vs', [Plain (Br (Lib.List32.nth xs i)) @@ e.at]
 
       | Return, vs ->
-        vs, [Plain (Br ((Int32.of_int (c.depth - 1)) @@ e.at)) @@ e.at]
+        vs, [Returning vs @@ e.at]
 
       | Call x, vs ->
         vs, [Invoke (func frame.inst x) @@ e.at]
@@ -161,8 +160,9 @@ let rec step (c : config) : config =
       | CallIndirect x, I32 i :: vs ->
         let func = func_elem frame.inst (0l @@ e.at) i e.at in
         if type_ frame.inst x <> Func.type_of func then
-          Trap.error e.at "indirect call signature mismatch";
-        vs, [Invoke func @@ e.at]
+          vs, [Trapping "indirect call type mismatch" @@ e.at]
+        else
+          vs, [Invoke func @@ e.at]
 
       | Drop, v :: vs' ->
         vs', []
@@ -201,7 +201,7 @@ let rec step (c : config) : config =
             | None -> Memory.load_value mem addr offset ty
             | Some (sz, ext) -> Memory.load_packed sz ext mem addr offset ty
           in v :: vs', []
-        with exn -> vs', [Trapped (memory_error e.at exn) @@ e.at])
+        with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at])
 
       | Store {offset; sz; _}, v :: I32 i :: vs' ->
         let mem = memory frame.inst (0l @@ e.at) in
@@ -212,7 +212,7 @@ let rec step (c : config) : config =
           | Some sz -> Memory.store_packed sz mem addr offset v
           );
           vs', []
-        with exn -> vs', [Trapped (memory_error e.at exn) @@ e.at]);
+        with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at]);
 
       | CurrentMemory, vs ->
         let mem = memory frame.inst (0l @@ e.at) in
@@ -231,23 +231,23 @@ let rec step (c : config) : config =
 
       | Test testop, v :: vs' ->
         (try value_of_bool (Eval_numeric.eval_testop testop v) :: vs', []
-        with exn -> vs', [Trapped (numeric_error e.at exn) @@ e.at])
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Compare relop, v2 :: v1 :: vs' ->
         (try value_of_bool (Eval_numeric.eval_relop relop v1 v2) :: vs', []
-        with exn -> vs', [Trapped (numeric_error e.at exn) @@ e.at])
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Unary unop, v :: vs' ->
         (try Eval_numeric.eval_unop unop v :: vs', []
-        with exn -> vs', [Trapped (numeric_error e.at exn) @@ e.at])
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Binary binop, v2 :: v1 :: vs' ->
         (try Eval_numeric.eval_binop binop v1 v2 :: vs', []
-        with exn -> vs', [Trapped (numeric_error e.at exn) @@ e.at])
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | Convert cvtop, v :: vs' ->
         (try Eval_numeric.eval_cvtop cvtop v :: vs', []
-        with exn -> vs', [Trapped (numeric_error e.at exn) @@ e.at])
+        with exn -> vs', [Trapping (numeric_error e.at exn) @@ e.at])
 
       | _ ->
         let s1 = string_of_values (List.rev vs) in
@@ -256,37 +256,46 @@ let rec step (c : config) : config =
           ("missing or ill-typed operand on stack (" ^ s1 ^ " : " ^ s2 ^ ")")
       )
 
-    | Trapped msg, vs ->
+    | Trapping msg, vs ->
       assert false
 
-    | Break (k, vs'), vs ->
+    | Returning vs', vs ->
+      Crash.error e.at "undefined frame"
+
+    | Breaking (k, vs'), vs ->
       Crash.error e.at "undefined label"
 
-    | Label (ts, es0, (vs', [])), vs ->
+    | Label (n, es0, (vs', [])), vs ->
       vs' @ vs, []
 
-    | Label (ts, es0, (vs', {it = Trapped msg; at} :: es')), vs ->
-      vs, [Trapped msg @@ at]
+    | Label (n, es0, (vs', {it = Trapping msg; at} :: es')), vs ->
+      vs, [Trapping msg @@ at]
+
+    | Label (n, es0, (vs', {it = Returning vs0; at} :: es')), vs ->
+      vs, [Returning vs0 @@ at]
 
-    | Label (ts, es0, (vs', {it = Break (0l, vs0); at} :: es')), vs ->
-      take (List.length ts) vs0 e.at @ vs, List.map plain es0
+    | Label (n, es0, (vs', {it = Breaking (0l, vs0); at} :: es')), vs ->
+      take n vs0 e.at @ vs, List.map plain es0
 
-    | Label (ts, es0, (vs', {it = Break (k, vs0); at} :: es')), vs ->
-      vs, [Break (Int32.sub k 1l, vs0) @@ at]
+    | Label (n, es0, (vs', {it = Breaking (k, vs0); at} :: es')), vs ->
+      vs, [Breaking (Int32.sub k 1l, vs0) @@ at]
 
-    | Label (ts, es0, code'), vs ->
-      let c' = step {c with code = code'; depth = c.depth + 1} in
-      vs, [Label (ts, es0, c'.code) @@ e.at]
+    | Label (n, es0, code'), vs ->
+      let c' = step {c with code = code'} in
+      vs, [Label (n, es0, c'.code) @@ e.at]
 
-    | Frame (frame', (vs', [])), vs ->
+    | Frame (n, frame', (vs', [])), vs ->
       vs' @ vs, []
 
-    | Frame (frame', (vs', {it = Trapped msg; at} :: es')), vs ->
-      vs, [Trapped msg @@ at]
+    | Frame (n, frame', (vs', {it = Trapping msg; at} :: es')), vs ->
+      vs, [Trapping msg @@ at]
+
+    | Frame (n, frame', (vs', {it = Returning vs0; at} :: es')), vs ->
+      take n vs0 e.at @ vs, []
 
-    | Frame (frame', code'), vs ->
-      let c' = step {frame = frame'; code = code'; depth = 0; budget = c.budget - 1} in
-      vs, [Frame (c'.frame, c'.code) @@ e.at]
+    | Frame (n, frame', code'), vs ->
+      let c' = step {frame = frame'; code = code'; budget = c.budget - 1} in
+      vs, [Frame (n, c'.frame, c'.code) @@ e.at]
 
     | Invoke func, vs when c.budget = 0 ->
       Exhaustion.error e.at "call stack exhausted"
@@ -300,7 +309,7 @@ let rec step (c : config) : config =
         let locals' = List.rev args @ List.map default_value f.it.locals in
         let code' = [], [Plain (Block (out, f.it.body)) @@ f.at] in
         let frame' = {inst = !inst'; locals = List.map ref locals'} in
-        vs', [Frame (frame', code') @@ e.at]
+        vs', [Frame (List.length out, frame', code') @@ e.at]
 
       | Func.HostFunc (t, f) ->
         try List.rev (f (List.rev args)) @ vs', []
@@ -314,7 +323,7 @@ let rec eval (c : config) : value stack =
   | vs, [] ->
     vs
 
-  | vs, {it = Trapped msg; at} :: _ ->
+  | vs, {it = Trapping msg; at} :: _ ->
     Trap.error at msg
 
   | vs, es ->
diff --git a/test/core/call_indirect.wast b/test/core/call_indirect.wast
index db28f391d..e1fa41701 100644
--- a/test/core/call_indirect.wast
+++ b/test/core/call_indirect.wast
@@ -230,8 +230,8 @@
 (assert_return (invoke "dispatch" (i32.const 12) (i64.const 5)) (i64.const 120))
 (assert_return (invoke "dispatch" (i32.const 13) (i64.const 5)) (i64.const 8))
 (assert_return (invoke "dispatch" (i32.const 20) (i64.const 2)) (i64.const 2))
-(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call signature mismatch")
-(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call signature mismatch")
+(assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call type mismatch")
 (assert_trap (invoke "dispatch" (i32.const 23) (i64.const 2)) "undefined element")
 (assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined element")
 (assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined element")
@@ -240,8 +240,8 @@
 (assert_return (invoke "dispatch-structural" (i32.const 5)) (i64.const 9))
 (assert_return (invoke "dispatch-structural" (i32.const 12)) (i64.const 362880))
 (assert_return (invoke "dispatch-structural" (i32.const 20)) (i64.const 9))
-(assert_trap (invoke "dispatch-structural" (i32.const 11)) "indirect call signature mismatch")
-(assert_trap (invoke "dispatch-structural" (i32.const 22)) "indirect call signature mismatch")
+(assert_trap (invoke "dispatch-structural" (i32.const 11)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural" (i32.const 22)) "indirect call type mismatch")
 
 (assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
 (assert_return (invoke "fac" (i64.const 1)) (i64.const 1))

From e04f14a32be8960996f7980607e76d3039cd9ac9 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Tue, 30 Jan 2018 16:17:54 -0800
Subject: [PATCH 141/329] Remove explicit counts in JS API spec (#657)

This way the counts won't go out-of-sync with their associated lists.

See comment here: https://github.com/WebAssembly/spec/pull/653#discussion_r164284778.
---
 document/js-api/index.bs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 1da8ea703..b1669ab9e 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -221,7 +221,7 @@ Elements of the WebAssembly store may be <dfn>identified with</dfn> JavaScript v
 
 Note: There are several WebAssembly objects that may have a corresponding JavaScript object. The correspondence is stored in a per-agent mapping from WebAssembly [=address=]es to JavaScript objects. This mapping is used to ensure that, for a given [=agent=], there exists at most one JavaScript object for a particular WebAssembly address.
 
-Each [=agent=] is associated with the following three [=ordered map=]s:
+Each [=agent=] is associated with the following [=ordered map=]s:
     * The <dfn>Memory object cache</dfn>, mapping [=memory address=]es to {{Memory}} objects.
     * The <dfn>Table object cache</dfn>, mapping [=table address=]es to {{Table}} objects.
     * The <dfn>Exported Function cache</dfn>, mapping [=function address=]es to [=Exported Function=] objects.
@@ -272,7 +272,7 @@ Note:
 </div>
 
 <div>
-A {{Module}} object represents a single WebAssembly module. Each {{Module}} object has two internal slots:
+A {{Module}} object represents a single WebAssembly module. Each {{Module}} object has the following internal slots:
 
     * \[[Module]] : a WebAssembly [=module=]
     * \[[Bytes]] : an {{ArrayBuffer}} which is source bytes of \[[Module]].
@@ -539,7 +539,7 @@ interface Memory {
 <div>
 A {{Memory}} object represents a single [=memory instance=]
 which can be simultaneously referenced by multiple {{Instance}} objects. Each
-{{Memory}} object has two internal slots:
+{{Memory}} object has the following internal slots:
 
     * \[[Memory]] : a [=memory address=]
     * \[[BufferObject]] : an {{ArrayBuffer}} whose [=Data Block=] is [=identified with=] the above memory address
@@ -615,7 +615,7 @@ interface Table {
 <div>
 A {{Table}} object represents a single [=table instance=]
 which can be simultaneously referenced by multiple {{Instance}} objects. Each
-{{Table}} object has two internal slots:
+{{Table}} object has the following internal slots:
 
     * \[[Table]] : a [=table address=]
     * \[[Values]] : a List whose elements are either null or [=Exported Function=]s.
@@ -808,7 +808,7 @@ Assert: |type| is not [=𝗂𝟨𝟦=].
 
 <h3 id="error-objects">Error Objects</h3>
 
-WebAssembly defines three Error classes. WebAssembly errors have the following custom bindings:
+WebAssembly defines the following Error classes: {{CompileError}}, {{LinkError}}, and {{RuntimeError}}. WebAssembly errors have the following custom bindings:
 - Unlike normal interface types, the interface prototype object for these exception classes must have as its \[[Prototype]] the intrinsic object [=%ErrorPrototype%=].
 - The constructor and properties of WebAssembly errors is as specified for {{NativeError}}.
 - If an implementation gives native Error objects special powers or nonstandard properties (such as a stack property), it should also expose those on these exception instances.

From d2fd48e94f8df050b89487c2b9049b845597c9d2 Mon Sep 17 00:00:00 2001
From: Sergey Pepyakin <s.pepyakin@gmail.com>
Date: Wed, 31 Jan 2018 03:23:24 +0300
Subject: [PATCH 142/329] Test the difference between label and result types in
 a loop (#610)

---
 test/core/labels.wast | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/core/labels.wast b/test/core/labels.wast
index 02fea5f27..3df5006ba 100644
--- a/test/core/labels.wast
+++ b/test/core/labels.wast
@@ -73,6 +73,13 @@
     )
   )
 
+  (func (export "loop6") (result i32)
+    (loop (result i32)
+      (br_if 0 (i32.const 0))
+      (i32.const 3)
+    )
+  )
+
   (func (export "if") (result i32)
     (local $i i32)
     (set_local $i (i32.const 0))
@@ -280,6 +287,7 @@
 (assert_return (invoke "loop3") (i32.const 1))
 (assert_return (invoke "loop4" (i32.const 8)) (i32.const 16))
 (assert_return (invoke "loop5") (i32.const 2))
+(assert_return (invoke "loop6") (i32.const 3))
 (assert_return (invoke "if") (i32.const 5))
 (assert_return (invoke "if2") (i32.const 5))
 (assert_return (invoke "switch" (i32.const 0)) (i32.const 50))

From 56caec8360b7d3e4ab9985fc6d77b1c6e4aa395e Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Tue, 30 Jan 2018 16:32:37 -0800
Subject: [PATCH 143/329] Use "surrounding agent" instead of "current agent"
 (#659)

---
 document/js-api/index.bs | 45 ++++++++++++++++++++--------------------
 1 file changed, 23 insertions(+), 22 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index b1669ab9e..839e0945b 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -37,6 +37,7 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMASCRIPT
         text: data block; url: sec-data-blocks
         text: Bound Function; url: sec-bound-function-exotic-objects
         text: NumericLiteral; url: sec-literals-numeric-literals
+        text: surrounding agent; url: surrounding-agent
         text: ToNumber; url: sec-tonumber
         text: ToInt32; url: sec-toint32
         text: ToString; url: sec-tostring
@@ -330,9 +331,9 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
             1. If |globaltype| is [=𝗂𝟨𝟦=] or [=Type=](|v|) is not [=Number=], throw a {{LinkError}} exception.
             1. Let |value| be [=ToWebAssemblyValue=](|v|, |globaltype|.<em>[=global type|valtype=]</em>)
             1. Assert: |globaltype|.<em>[=global type|mut=]</em> is [=global type|𝖼𝗈𝗇𝗌𝗍=], as verified by WebAssembly validation.
-            1. Let |store| be the current agent's [=associated store=].
+            1. Let |store| be the [=surrounding agent=]'s [=associated store=].
             1. Let (|store|, |globaladdr|) be [=alloc_global=](|store|, |globaltype|, |value|).
-            1. Set the current agent's [=associated store=] to |store|.
+            1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
             1. Let |externglobal| be [=external value|𝗀𝗅𝗈𝖻𝖺𝗅=] |globaladdr|.
             1. [=Append=] |externglobal| to |imports|.
         1. If |externtype| is of the form [=𝗆𝖾𝗆=] |memtype|,
@@ -548,7 +549,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 <div algorithm>
     To <dfn>create a memory object</dfn> from a [=memory address=] |memaddr|, perform the following steps:
 
-    1. Let |map| be the current [=agent=]'s associated [=Memory object cache=].
+    1. Let |map| be the [=surrounding agent=]'s associated [=Memory object cache=].
     1. If |map|[|memaddr|] [=map/exists=],
         1. Return |map|[|memaddr|].
     1. Let |block| be a Data Block which is [=identified with=] the underlying memory of |memaddr|
@@ -565,21 +566,21 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. If |descriptor|["initial"] is [=present=], let |initial| be |descriptor|["initial"]; otherwise, let |initial| be 0.
     1. If |descriptor|["maximum"] is [=present=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
     1. Let |memtype| be { min |initial|, max |maximum| }
-    1. Let |store| be the current agent's [=associated store=].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let (|store|, |memaddr|) be [=alloc_mem=](|store|, |memtype|). If allocation fails, throw a {{RangeError}} exception.
-    1. Set the current agent's [=associated store=] to |store|.
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
     1. [=Create a memory object=] from the memory address |memaddr| and return the result.
 </div>
 
 <div algorithm>
     The <dfn method for="Memory">grow(delta)</dfn> method, when invoked, performs the following steps:
     1. Let |memory| be the Memory instance.
-    1. Let |store| be the current agent's [=associated store=].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |memaddr| be |memory|.\[[Memory]].
     1. Let |ret| be the [=size_mem=](|store|, |memaddr|).
     1. Let |store| be [=grow_mem=](|store|, |memaddr|, |delta|).
     1. If |store| is [=error=], throw a {{RangeError}} exception.
-    1. Set the current agent's [=associated store=] to |store|.
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
     1. Perform ! [=DetachArrayBuffer=](|memory|.\[[BufferObject]]).
     1. Let |block| be a [=Data Block=] which is [=identified with=] the underlying memory of |memaddr|.
     1. Assert: The size of |block| is the same as [=size_mem=](|store|, |memaddr|) * 64 Ki
@@ -623,7 +624,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 
 <div algorithm>
     To <dfn>create a table object</dfn> from a [=table address=] |tableaddr|, perform the following steps:
-    1. Let |map| be the current [=agent=]'s associated [=Table object cache=].
+    1. Let |map| be the [=surrounding agent=]'s associated [=Table object cache=].
     1. If |map|[|tableaddr|] [=map/exists=],
         1. Return |map|[|tableaddr|].
     1. Let |values| be a list whose length is [=size_table=](|store|, |tableaddr|) where each element is null.
@@ -638,9 +639,9 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. If |descriptor|["maximum"] is [=present=], let |m| be |descriptor|["maximum"]; otherwise, let |m| be empty.
     1. If |m| is not empty and |m| &lt; |n|, throw a {{RangeError}} exception.
     1. Let |type| be the [=table type=] {[=table type|𝗆𝗂𝗇=] n, [=table type|𝗆𝖺𝗑=] |m|} [=table type|𝖺𝗇𝗒𝖿𝗎𝗇𝖼=].
-    1. Let |store| be the current agent's [=associated store=].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let (|store|, |tableaddr|) be [=alloc_table=](|store|, |type|). <!-- TODO(littledan): Report allocation failure https://github.com/WebAssembly/spec/issues/584 -->
-    1. Set the current agent's [=associated store=] to |store|.
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
     1. [=Create a table object=] from the table address |tableaddr| and return the result.
 </div>
 
@@ -648,13 +649,13 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     The <dfn method for="Table">grow(d)</dfn> method, when invoked, performs the following steps:
     1. Let |tableaddr| be the Table instance's \[[Table]] internal slot.
     1. Let |initialSize| be the length of the Table instance's \[[Values]] internal slot.
-    1. Let |store| be the current agent's [=associated store=].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |result| be [=grow_table=](|store|, |tableaddr|, |d|).
     1. If |result| is [=error=], throw a {{RangeError}} exception.
 
         Note: The above exception may happen due to either insufficient memory or an invalid size parameter.
 
-    6. Set the current agent's [=associated store=] to |store|.
+    6. Set the [=surrounding agent=]'s [=associated store=] to |store|.
     1. [=Append=] null to the Table instance's \[[Values]] internal slot |d| times.
     1. Return |initialSize|.
 </div>
@@ -679,10 +680,10 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Otherwise,
         1. If |value| does not have a \[[FunctionAddress]] internal slot, throw a {{TypeError}} exception.
         1. Let |funcaddr| be |value|.\[[FunctionAddress]].
-    1. Let |store| be the current agent's [=associated store=].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |store| be [=write_table=](|store|, |tableaddr|, |index|, |funcaddr|).
     1. If |store| is [=error=], throw a {{RangeError}} exception.
-    1. Set the current agent's [=associated store=] to |store|.
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
     1. Set |values|[|index|] to |value|.
     1. Return undefined.
 </div>
@@ -691,12 +692,12 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 
 A WebAssembly function is made available in JavaScript as an <dfn>Exported Function</dfn>.
 Exported Functions are [=Built-in Function Objects=] which are not constructors, and which have a \[[FunctionAddress]] internal slot.
-This slot holds a [=function address=] relative to the current agent's [=associated store=].
+This slot holds a [=function address=] relative to the [=surrounding agent=]'s [=associated store=].
 
 <div algorithm>
   The <dfn>name of the WebAssembly function</dfn> |funcaddr| is found by performing the following steps:
 
-    1. Let |store| be the current agent's [=associated store=].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |funcinst| be |store|.𝖿𝗎𝗇𝖼𝗌[|funcaddr|].
     1. If |funcinst| is of the form {𝗍𝗒𝗉𝖾 |functype|, 𝗁𝗈𝗌𝗍𝖼𝗈𝖽𝖾 |hostfunc|},
         1. Assert: |hostfunc| is a JavaScript object and [=IsCallable=](|hostfunc|) is true.
@@ -711,14 +712,14 @@ This slot holds a [=function address=] relative to the current agent's [=associa
 <div algorithm>
   To create <dfn>a new Exported Function</dfn> from a WebAssembly [=function address=] |funcaddr|, perform the following steps:
 
-    1. Let |map| be the current [=agent=]'s associated [=Exported Function cache=].
+    1. Let |map| be the [=surrounding agent=]'s associated [=Exported Function cache=].
     1. If |map|[|funcaddr|] [=map/exists=],
         1. Return |map|[|funcaddr|].
     1. Let |steps| be "[=call an Exported Function|call the Exported Function=] |funcaddr| with arguments."
     1. Let |realm| be the [=current Realm=].
     1. Let |function| be [=CreateBuiltinFunction=](|realm|, |steps|, [=%FunctionPrototype%=], &laquo; \[[FunctionAddress]]).
     1. Set |function|.\[[FunctionAddress]] to |funcaddr|.
-    1. Let |store| be the current agent's [=associated store=].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |functype| be [=type_func=](|store|, |funcaddr|).
     1. Let [|arguments|] → [|results|] be |functype|.
     1. Let |arity| be the length of |arguments|.
@@ -732,7 +733,7 @@ This slot holds a [=function address=] relative to the current agent's [=associa
 <div algorithm>
   To <dfn>call an Exported Function</dfn> with [=function address=] |funcaddr| and a [=list=] of JavaScript arguments |argValues|, perform the following steps:
 
-    1. Let |store| be the current agent's [=associated store=].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |functype| be [=type_func=](|store|, |funcaddr|).
     1. Let [|parameters|] → [|results|] be |functype|.
     1. If |parameters| or |results| contains an [=𝗂𝟨𝟦=], throw a {{TypeError}}.
@@ -747,7 +748,7 @@ This slot holds a [=function address=] relative to the current agent's [=associa
         1. [=Append=] [=ToWebAssemblyValue=](|arg|, |t|) to |args|.
         1. Set |i| to |i| + 1.
     1. Let (|store|, |ret|) be the result of [=invoke_func=](|store|, |funcaddr|, |args|).
-    1. Set the current agent's [=associated store=] to |store|.
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
     1. If |ret| is [=error=], throw an exception. This exception should be a WebAssembly {{RuntimeError}} exception, unless otherwise indicated by <a href="#errors">the WebAssembly error mapping</a>.
     1. If |outArity| is 0, return undefined.
     1. Otherwise, return [=ToJSValue=](|v|), where |v| is the singular element of |ret|.
@@ -770,9 +771,9 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
         1. Let [|parameters|] → [|results|] be |functype|.
         1. If |results| is empty, return undefined.
         1. Otherwise, return [=ToWebAssemblyValue=](|ret|, |results|[0]).
-    1. Let |store| be the current agent's [=associated store=].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let (|store|, |funcaddr|) be [=alloc_func=](|store|, |functype|, |hostfunc|).
-    1. Set the current agent cluster's [=associated store=] to |store|.
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
     1. Return |funcaddr|
 </div>
 

From 992d3dda1564ff6704e1f09101918776bc33ceac Mon Sep 17 00:00:00 2001
From: Julian Laubstein <contact@julianlaubstein.de>
Date: Wed, 31 Jan 2018 20:48:09 +0100
Subject: [PATCH 144/329] [spec] Added missing "be" (#660)

---
 document/core/text/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index a06aa981e..dadd435b0 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -423,7 +423,7 @@ Folded Instructions
 Instructions can be written as S-expressions by grouping them into *folded* form. In that notation, an instruction is wrapped in parentheses and optionally includes nested folded instructions to indicate its operands.
 
 In the case of :ref:`block instructions <text-instr-block>`, the folded form omits the :math:`\text{end}` delimiter.
-For |IF| instructions, both branches have to wrapped into nested S-expressions, headed by the keywords :math:`\text{then}` and :math:`\text{else}`.
+For |IF| instructions, both branches have to be wrapped into nested S-expressions, headed by the keywords :math:`\text{then}` and :math:`\text{else}`.
 
 The set of all phrases defined by the following abbreviations recursively forms the auxiliary syntactic class |Tfoldedinstr|.
 Such a folded instruction can appear anywhere a regular instruction can.

From 4f078ff69de51d07c1c265273e396f42b2fb2dd3 Mon Sep 17 00:00:00 2001
From: Dan Gohman <sunfish@mozilla.com>
Date: Tue, 6 Feb 2018 10:06:25 -0800
Subject: [PATCH 145/329] Rename spectest imports to avoid depending on
 overloading. (#652)

* Rename spectest imports to avoid depending on overloading.
* Add a validate-only test for overloaded imports.
* Implement spectest print_* and global_* imports
* Update the JS test harness for spectest renames.
---
 interpreter/host/spectest.ml | 16 ++++---
 test/core/func_ptrs.wast     |  4 +-
 test/core/globals.wast       |  6 +--
 test/core/imports.wast       | 83 +++++++++++++++++++++++-------------
 test/core/linking.wast       |  2 +-
 test/core/memory.wast        |  6 +--
 test/core/names.wast         |  4 +-
 test/core/start.wast         |  4 +-
 test/harness/index.js        |  9 +++-
 9 files changed, 86 insertions(+), 48 deletions(-)

diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index e29c8c8b6..ae543f91e 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -32,11 +32,17 @@ let print (FuncType (_, out)) vs =
 
 let lookup name t =
   match Utf8.encode name, t with
-  | "print", ExternFuncType t -> ExternFunc (func print t)
-  | "print", _ ->
-    let t = FuncType ([], []) in ExternFunc (func print t)
-  | "global", ExternGlobalType t -> ExternGlobal (global t)
-  | "global", _ -> ExternGlobal (global (GlobalType (I32Type, Immutable)))
+  | "print", _ -> ExternFunc (func print (FuncType ([], [])))
+  | "print_i32", _ -> ExternFunc (func print (FuncType ([I32Type], [])))
+  | "print_i32_f32", _ ->
+    ExternFunc (func print (FuncType ([I32Type; F32Type], [])))
+  | "print_f64_f64", _ ->
+    ExternFunc (func print (FuncType ([F64Type; F64Type], [])))
+  | "print_f32", _ -> ExternFunc (func print (FuncType ([F32Type], [])))
+  | "print_f64", _ -> ExternFunc (func print (FuncType ([F64Type], [])))
+  | "global_i32", _ -> ExternGlobal (global (GlobalType (I32Type, Immutable)))
+  | "global_f32", _ -> ExternGlobal (global (GlobalType (F32Type, Immutable)))
+  | "global_f64", _ -> ExternGlobal (global (GlobalType (F64Type, Immutable)))
   | "table", _ -> ExternTable table
   | "memory", _ -> ExternMemory memory
   | _ -> raise Not_found
diff --git a/test/core/func_ptrs.wast b/test/core/func_ptrs.wast
index b8050a833..2b74869d7 100644
--- a/test/core/func_ptrs.wast
+++ b/test/core/func_ptrs.wast
@@ -7,7 +7,7 @@
   (type $T (func (param i32) (result i32)))  ;; 5: i32 -> i32
   (type $U (func (param i32)))               ;; 6: i32 -> void
 
-  (func $print (import "spectest" "print") (type 6))
+  (func $print (import "spectest" "print_i32") (type 6))
 
   (func (type 0))
   (func (type $S))
@@ -46,7 +46,7 @@
 )
 
 (assert_invalid (module (func (type 42))) "unknown type")
-(assert_invalid (module (import "spectest" "print" (func (type 43)))) "unknown type")
+(assert_invalid (module (import "spectest" "print_i32" (func (type 43)))) "unknown type")
 
 (module
   (type $T (func (param) (result i32)))
diff --git a/test/core/globals.wast b/test/core/globals.wast
index b8f9c8f54..c4edfed3e 100644
--- a/test/core/globals.wast
+++ b/test/core/globals.wast
@@ -122,7 +122,7 @@
 )
 
 (module
-  (import "spectest" "global" (global i32))
+  (import "spectest" "global_i32" (global i32))
 )
 (assert_malformed
   (module binary
@@ -130,7 +130,7 @@
     "\02\94\80\80\80\00"             ;; import section
       "\01"                          ;; length 1
       "\08\73\70\65\63\74\65\73\74"  ;; "spectest"
-      "\06\67\6c\6f\62\61\6c"        ;; "global"
+      "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32"
       "\03"                          ;; GlobalImport
       "\7f"                          ;; i32
       "\02"                          ;; invalid mutability
@@ -143,7 +143,7 @@
     "\02\94\80\80\80\00"             ;; import section
       "\01"                          ;; length 1
       "\08\73\70\65\63\74\65\73\74"  ;; "spectest"
-      "\06\67\6c\6f\62\61\6c"        ;; "global"
+      "\0a\67\6c\6f\62\61\6c\5f\69\33\32" ;; "global_i32"
       "\03"                          ;; GlobalImport
       "\7f"                          ;; i32
       "\ff"                          ;; invalid mutability
diff --git a/test/core/imports.wast b/test/core/imports.wast
index f5a557dbc..7c17f805b 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -27,28 +27,28 @@
   (type $func_f32 (func (param f32)))
   (type $func_f64 (func (param f64)))
 
-  (import "spectest" "print" (func (param i32)))
+  (import "spectest" "print_i32" (func (param i32)))
   ;; JavaScript can't handle i64 yet.
-  ;; (func (import "spectest" "print") (param i64))
-  (import "spectest" "print" (func $print_i32 (param i32)))
+  ;; (func (import "spectest" "print_i64") (param i64))
+  (import "spectest" "print_i32" (func $print_i32 (param i32)))
   ;; JavaScript can't handle i64 yet.
-  ;; (import "spectest" "print" (func $print_i64 (param i64)))
-  (import "spectest" "print" (func $print_f32 (param f32)))
-  (import "spectest" "print" (func $print_f64 (param f64)))
-  (import "spectest" "print" (func $print_i32_f32 (param i32 f32)))
-  (import "spectest" "print" (func $print_f64_f64 (param f64 f64)))
-  (func $print_i32-2 (import "spectest" "print") (param i32))
-  (func $print_f64-2 (import "spectest" "print") (param f64))
+  ;; (import "spectest" "print_i64" (func $print_i64 (param i64)))
+  (import "spectest" "print_f32" (func $print_f32 (param f32)))
+  (import "spectest" "print_f64" (func $print_f64 (param f64)))
+  (import "spectest" "print_i32_f32" (func $print_i32_f32 (param i32 f32)))
+  (import "spectest" "print_f64_f64" (func $print_f64_f64 (param f64 f64)))
+  (func $print_i32-2 (import "spectest" "print_i32") (param i32))
+  (func $print_f64-2 (import "spectest" "print_f64") (param f64))
   (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64)))
 
-  (func (export "p1") (import "spectest" "print") (param i32))
-  (func $p (export "p2") (import "spectest" "print") (param i32))
-  (func (export "p3") (export "p4") (import "spectest" "print") (param i32))
-  (func (export "p5") (import "spectest" "print") (type 0))
-  (func (export "p6") (import "spectest" "print") (type 0) (param i32) (result))
+  (func (export "p1") (import "spectest" "print_i32") (param i32))
+  (func $p (export "p2") (import "spectest" "print_i32") (param i32))
+  (func (export "p3") (export "p4") (import "spectest" "print_i32") (param i32))
+  (func (export "p5") (import "spectest" "print_i32") (type 0))
+  (func (export "p6") (import "spectest" "print_i32") (type 0) (param i32) (result))
 
-  (import "spectest" "print" (func (type $forward)))
-  (func (import "spectest" "print") (type $forward))
+  (import "spectest" "print_i32" (func (type $forward)))
+  (func (import "spectest" "print_i32") (type $forward))
   (type $forward (func (param i32)))
 
   (table anyfunc (elem $print_i32 $print_f64))
@@ -182,7 +182,7 @@
   "incompatible import type"
 )
 (assert_unlinkable
-  (module (import "spectest" "global" (func)))
+  (module (import "spectest" "global_i32" (func)))
   "incompatible import type"
 )
 (assert_unlinkable
@@ -198,16 +198,16 @@
 ;; Globals
 
 (module
-  (import "spectest" "global" (global i32))
-  (global (import "spectest" "global") i32)
+  (import "spectest" "global_i32" (global i32))
+  (global (import "spectest" "global_i32") i32)
 
-  (import "spectest" "global" (global $x i32))
-  (global $y (import "spectest" "global") i32)
+  (import "spectest" "global_i32" (global $x i32))
+  (global $y (import "spectest" "global_i32") i32)
 
   ;; JavaScript can't handle i64 yet.
-  ;; (import "spectest" "global" (global i64))
-  (import "spectest" "global" (global f32))
-  (import "spectest" "global" (global f64))
+  ;; (import "spectest" "global_i64" (global i64))
+  (import "spectest" "global_f32" (global f32))
+  (import "spectest" "global_f64" (global f64))
 
   (func (export "get-0") (result i32) (get_global 0))
   (func (export "get-1") (result i32) (get_global 1))
@@ -245,7 +245,7 @@
   "incompatible import type"
 )
 (assert_unlinkable
-  (module (import "spectest" "print" (global i32)))
+  (module (import "spectest" "print_i32" (global i32)))
   "incompatible import type"
 )
 (assert_unlinkable
@@ -362,7 +362,7 @@
   "incompatible import type"
 )
 (assert_unlinkable
-  (module (import "spectest" "print" (table 10 anyfunc)))
+  (module (import "spectest" "print_i32" (table 10 anyfunc)))
   "incompatible import type"
 )
 
@@ -455,11 +455,11 @@
   "incompatible import type"
 )
 (assert_unlinkable
-  (module (import "spectest" "print" (memory 1)))
+  (module (import "spectest" "print_i32" (memory 1)))
   "incompatible import type"
 )
 (assert_unlinkable
-  (module (import "spectest" "global" (memory 1)))
+  (module (import "spectest" "global_i32" (memory 1)))
   "incompatible import type"
 )
 (assert_unlinkable
@@ -556,3 +556,28 @@
   (module quote "(memory 0) (import \"\" \"\" (memory 1 2))")
   "import after memory"
 )
+
+;; This module is required to validate, regardless of whether it can be
+;; linked. Overloading is not possible in wasm itself, but it is possible
+;; in modules from which wasm can import.
+(assert_unlinkable
+  (module
+    (import "not wasm" "overloaded" (func))
+    (import "not wasm" "overloaded" (func (param i32)))
+    (import "not wasm" "overloaded" (func (param i32 i32)))
+    (import "not wasm" "overloaded" (func (param i64)))
+    (import "not wasm" "overloaded" (func (param f32)))
+    (import "not wasm" "overloaded" (func (param f64)))
+    (import "not wasm" "overloaded" (func (result i32)))
+    (import "not wasm" "overloaded" (func (result i64)))
+    (import "not wasm" "overloaded" (func (result f32)))
+    (import "not wasm" "overloaded" (func (result f64)))
+    (import "not wasm" "overloaded" (global i32))
+    (import "not wasm" "overloaded" (global i64))
+    (import "not wasm" "overloaded" (global f32))
+    (import "not wasm" "overloaded" (global f64))
+    (import "not wasm" "overloaded" (table 0 anyfunc))
+    (import "not wasm" "overloaded" (memory 0))
+  )
+  "unknown import"
+)
diff --git a/test/core/linking.wast b/test/core/linking.wast
index 73fbb93ba..898d5a215 100644
--- a/test/core/linking.wast
+++ b/test/core/linking.wast
@@ -20,7 +20,7 @@
 (assert_return (invoke $Nf "call Mf.call") (i32.const 2))
 
 (module
-  (import "spectest" "print" (func $f (param i32)))
+  (import "spectest" "print_i32" (func $f (param i32)))
   (export "print" (func $f))
 )
 (register "reexport_f")
diff --git a/test/core/memory.wast b/test/core/memory.wast
index b49ac4b2b..ee39b3a04 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -10,8 +10,8 @@
 (module (memory 1 2)
   (data (i32.const 0) "a") (data (i32.const 1) "b") (data (i32.const 2) "c")
 )
-(module (global (import "spectest" "global") i32) (memory 1) (data (get_global 0) "a"))
-(module (global $g (import "spectest" "global") i32) (memory 1) (data (get_global $g) "a"))
+(module (global (import "spectest" "global_i32") i32) (memory 1) (data (get_global 0) "a"))
+(module (global $g (import "spectest" "global_i32") i32) (memory 1) (data (get_global $g) "a"))
 ;; Use of internal globals in constant expressions is not allowed in MVP.
 ;; (module (memory 1) (data (get_global 0) "a") (global i32 (i32.const 0)))
 ;; (module (memory 1) (data (get_global $g) "a") (global $g i32 (i32.const 0)))
@@ -112,7 +112,7 @@
 ;)
 (assert_unlinkable
   (module
-    (global (import "spectest" "global") i32)
+    (global (import "spectest" "global_i32") i32)
     (memory 0) (data (get_global 0) "a")
   )
   "data segment does not fit"
diff --git a/test/core/names.wast b/test/core/names.wast
index b58e4d4c6..97f28f3b4 100644
--- a/test/core/names.wast
+++ b/test/core/names.wast
@@ -1075,8 +1075,8 @@
 (module
   ;; Test that we can use indices instead of names to reference imports,
   ;; exports, functions and parameters.
-  (import "spectest" "print" (func (param i32)))
-  (func (import "spectest" "print") (param i32))
+  (import "spectest" "print_i32" (func (param i32)))
+  (func (import "spectest" "print_i32") (param i32))
   (func (param i32) (param i32)
     (call 0 (get_local 0))
     (call 1 (get_local 1))
diff --git a/test/core/start.wast b/test/core/start.wast
index a94dfa16b..6719edba8 100644
--- a/test/core/start.wast
+++ b/test/core/start.wast
@@ -78,13 +78,13 @@
 (assert_return (invoke "get") (i32.const 70))
 
 (module
-  (func $print_i32 (import "spectest" "print") (param i32))
+  (func $print_i32 (import "spectest" "print_i32") (param i32))
   (func $main (call $print_i32 (i32.const 1)))
   (start 1)
 )
 
 (module
-  (func $print_i32 (import "spectest" "print") (param i32))
+  (func $print_i32 (import "spectest" "print_i32") (param i32))
   (func $main (call $print_i32 (i32.const 2)))
   (start $main)
 )
diff --git a/test/harness/index.js b/test/harness/index.js
index dbac4bd65..8ac8909ed 100644
--- a/test/harness/index.js
+++ b/test/harness/index.js
@@ -79,7 +79,14 @@ function reinitializeRegistry() {
     registry = {
         spectest: {
             print: console.log.bind(console),
-            global: 666,
+            print_i32: console.log.bind(console),
+            print_i32_f32: console.log.bind(console),
+            print_f64_f64: console.log.bind(console),
+            print_f32: console.log.bind(console),
+            print_f64: console.log.bind(console),
+            global_i32: 666,
+            global_f32: 666,
+            global_f64: 666,
             table: new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'}),
             memory: new WebAssembly.Memory({initial: 1, maximum: 2})
         }

From 933f31e66ca1c962bf631e789d65203e7d1ca874 Mon Sep 17 00:00:00 2001
From: David Swasey <swasey@mpi-sws.org>
Date: Fri, 9 Feb 2018 14:47:28 +0100
Subject: [PATCH 146/329] [spec] Clean up instantiation and expression
 evaluation. (#661)

Change expression evaluation to reduction. The use of `\stepto^\ast`
in the evaluation rule's conclusion had been confusing, being syntax
rather than the usual RTC operator.

Fix a typo in `_index-rules`. The instruction reduction judgment
lacked an `^\ast`.

Remove unused details from the rules for `\instantiate`. Neither
`\globaladdr^\ast` nor `k` was used.

Make `\instantiate` prose and rules agree on when to trap by dropping
the generic "otherwise" rule that trapped. The rules no longer relate
inputs to outputs where the prose specified "Fail". (Aside: nothing
had to change in the embedding, where instantiation is used.)

Make `\instantiate` check, rather than assume, validity of inputs.

Update `\instantiate` prose to use `allocmodule`.

Note the mutual recursion between instantiation's module allocation
and execution of global initializers. (Left a sketch of the pre-pass
needed to break the recursion in prose step (5) because it's easy to
miss or forget that global initializers depend only on imported
globals.)

Prefer `\val` to `v` in the rule for `\instantiate`.
---
 document/core/appendix/index-rules.rst |  4 +-
 document/core/appendix/properties.rst  |  2 +-
 document/core/exec/instructions.rst    | 12 +++--
 document/core/exec/modules.rst         | 72 +++++++++++++-------------
 4 files changed, 48 insertions(+), 42 deletions(-)

diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
index 7ff47bdfc..281548063 100644
--- a/document/core/appendix/index-rules.rst
+++ b/document/core/appendix/index-rules.rst
@@ -102,6 +102,6 @@ Execution
 ===============================================  ===============================================================================
 Construct                                        Judgement
 ===============================================  ===============================================================================
-:ref:`Instruction <exec-instr>`                  :math:`S;F;\instr \stepto S';F';{\instr'}^\ast`
-:ref:`Expression <exec-expr>`                    :math:`S;F;\expr \stepto^\ast S';F';\val^\ast`
+:ref:`Instruction <exec-instr>`                  :math:`S;F;\instr^\ast \stepto S';F';{\instr'}^\ast`
+:ref:`Expression <exec-expr>`                    :math:`S;F;\expr \stepto  S';F';\expr'`
 ===============================================  ===============================================================================
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 51fb922a2..b22bd8687 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -7,7 +7,7 @@ Soundness
 The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *type safety* and *memory safety* with respect to the WebAssembly semantics. For example:
 
 * All types declared and derived during validation are respected at run time;
-  e.g., every :ref:`local <syntax-local>` or :ref:`global <syntax-global>` variable will only contain type-correct values, every :ref:`instruction <syntax-instr>` will only be applied to operands of the expected type, and every :ref:`function <syntax-func>` :ref:`invocation <exec-invocation>` always evaluates to a result of the right type.
+  e.g., every :ref:`local <syntax-local>` or :ref:`global <syntax-global>` variable will only contain type-correct values, every :ref:`instruction <syntax-instr>` will only be applied to operands of the expected type, and every :ref:`function <syntax-func>` :ref:`invocation <exec-invocation>` always evaluates to a result of the right type (if it does not :ref:`trap <trap>`).
 
 * No memory location will be read or written except those explicitly defined by the program, i.e., as a :ref:`local <syntax-local>`, a :ref:`global <syntax-global>`, an element in a :ref:`table <syntax-table>`, or a location within a linear :ref:`memory <syntax-mem>`.
 
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 356b8665a..f0990ad26 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1130,17 +1130,21 @@ An :ref:`expression <syntax-expr>` is *evaluated* relative to a :ref:`current <e
 
 1. Jump to the start of the instruction sequence :math:`\instr^\ast` of the expression.
 
-2. Execute of the instruction sequence.
+2. Execute the instruction sequence.
 
 3. Assert: due to :ref:`validation <valid-expr>`, the top of the stack contains a :ref:`value <syntax-val>`.
 
-4. Pop the the :ref:`value <syntax-val>` :math:`\val` from the stack.
+4. Pop the :ref:`value <syntax-val>` :math:`\val` from the stack.
 
 The value :math:`\val` is the result of the evaluation.
 
 .. math::
    \frac{
-     S; F; \instr^\ast \stepto^\ast S'; F'; v
+     S; F; \instr^\ast \stepto S'; F'; \instr'^\ast
    }{
-     S; F; \instr^\ast~\END \stepto^\ast S'; F'; v
+     S; F; \instr^\ast~\END \stepto S'; F'; \instr'^\ast~\END
    }
+
+.. note::
+   Evaluation iterates this reduction rule until reaching a value.
+   Expressions constituting :ref:`function <syntax-func>` bodies are executed during function :ref:`invocation <exec-invoke>`.
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index dd0280b5e..bc772ddcc 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -563,35 +563,39 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
 4. For each :ref:`external value <syntax-externval>` :math:`\externval_i` in :math:`\externval^n` and :ref:`external type <syntax-externtype>` :math:`\externtype'_i` in :math:`\externtype_{\F{im}}^n`, do:
 
-   a. Assert: :math:`\externval_i` is :ref:`valid <valid-externval>` with :ref:`external type <syntax-externtype>` :math:`\externtype_i` in store :math:`S`.
+   a. If :math:`\externval_i` is not :ref:`valid <valid-externval>` with an :ref:`external type <syntax-externtype>` :math:`\externtype_i` in store :math:`S`, then:
+
+      i. Fail.
 
    b. If :math:`\externtype_i` does not :ref:`match <match-externtype>` :math:`\externtype'_i`, then:
 
       i. Fail.
 
-5. Let :math:`\moduleinst_{\F{im}}` be the auxiliary module instance :math:`\{\MIGLOBALS~\evglobals(\externval^\ast)\}` that only consists of the imported globals.
+.. _exec-initvals:
+
+5. Let :math:`\val^\ast` be the vector of :ref:`global <syntax-global>` initialization :ref:`values <syntax-val>` determined by :math:`\module` and :math:`\externval^n`. These may be calculated as follows.
 
-6. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~\moduleinst_{\F{im}}, \ALOCALS~\epsilon \}`.
+   a. Let :math:`\moduleinst_{\F{im}}` be the auxiliary module :ref:`instance <syntax-moduleinst>` :math:`\{\MIGLOBALS~\evglobals(\externval^n)\}` that only consists of the imported globals.
 
-7. Push the frame :math:`F` to the stack.
+   b. Let :math:`F_{\F{im}}` be the auxiliary :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~\moduleinst_{\F{im}}, \ALOCALS~\epsilon \}`.
 
-8. Let :math:`\globalidx_{\F{new}}` be the :ref:`global index <syntax-globalidx>` that corresponds to the number of global :ref:`imports <syntax-import>` in :math:`\module.\MIMPORTS` (i.e., the index of the first non-imported global).
+   c. Push the frame :math:`F_{\F{im}}` to the stack.
 
-9. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
+   d. For each :ref:`global <syntax-global>` :math:`\global_i` in :math:`\module.\MGLOBALS`, do:
 
-   a. Let :math:`\val_i` be the result of :ref:`evaluating <exec-expr>` the initializer expression :math:`\global_i.\GINIT`.
+      i. Let :math:`\val_i` be the result of :ref:`evaluating <exec-expr>` the initializer expression :math:`\global_i.\GINIT`.
 
-   b. Let :math:`\globalidx_i` be the :ref:`global index <syntax-globalidx>` :math:`\globalidx_{\F{new}} + i`.
+   e. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F_{\F{im}}` is now on the top of the stack.
 
-   c. Assert: due to :ref:`validation <valid-global>`, :math:`\moduleinst.\MIGLOBALS[\globalidx_i]` exists.
+   f. Pop the frame :math:`F_{\F{im}}` from the stack.
 
-   d. Let :math:`\globaladdr_i` be the :ref:`global address <syntax-globaladdr>` :math:`\moduleinst.\MIGLOBALS[\globalidx_i]`.
+6. Let :math:`\moduleinst` be a new module instance :ref:`allocated <alloc-module>` from :math:`\module` in store :math:`S` with imports :math:`\externval^n` and global initializer values :math:`\val^\ast`, and let :math:`S'` be the extended store produced by module allocation.
 
-   e. Assert: due to :ref:`validation <valid-global>`, :math:`S.\SGLOBALS[\globaladdr_i]` exists.
+7. Let :math:`F` be the :ref:`frame <syntax-frame>` :math:`\{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \}`.
 
-   f. Let :math:`\globalinst_i` be the :ref:`global instance <syntax-globalinst>` :math:`S.\SGLOBALS[\globaladdr_i]`.
+8. Push the frame :math:`F` to the stack.
 
-10. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEM`, do:
+9. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEM`, do:
 
     a. Let :math:`\X{eoval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\elem_i.\EOFFSET`.
 
@@ -603,9 +607,9 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
     e. Let :math:`\tableaddr_i` be the :ref:`table address <syntax-tableaddr>` :math:`\moduleinst.\MITABLES[\tableidx_i]`.
 
-    f. Assert: due to :ref:`validation <valid-elem>`, :math:`S.\STABLES[\tableaddr_i]` exists.
+    f. Assert: due to :ref:`validation <valid-elem>`, :math:`S'.\STABLES[\tableaddr_i]` exists.
 
-    g. Let :math:`\tableinst_i` be the :ref:`table instance <syntax-tableinst>` :math:`S.\STABLES[\tableaddr_i]`.
+    g. Let :math:`\tableinst_i` be the :ref:`table instance <syntax-tableinst>` :math:`S'.\STABLES[\tableaddr_i]`.
 
     h. Let :math:`\X{eend}_i` be :math:`\X{eo}_i` plus the length of :math:`\elem_i.\EINIT`.
 
@@ -613,7 +617,7 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
        i. Fail.
 
-11. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATA`, do:
+10. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATA`, do:
 
     a. Let :math:`\X{doval}_i` be the result of :ref:`evaluating <exec-expr>` the expression :math:`\data_i.\DOFFSET`.
 
@@ -625,9 +629,9 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
     e. Let :math:`\memaddr_i` be the :ref:`memory address <syntax-memaddr>` :math:`\moduleinst.\MIMEMS[\memidx_i]`.
 
-    f. Assert: due to :ref:`validation <valid-data>`, :math:`S.\SMEMS[\memaddr_i]` exists.
+    f. Assert: due to :ref:`validation <valid-data>`, :math:`S'.\SMEMS[\memaddr_i]` exists.
 
-    g. Let :math:`\meminst_i` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[\memaddr_i]`.
+    g. Let :math:`\meminst_i` be the :ref:`memory instance <syntax-meminst>` :math:`S'.\SMEMS[\memaddr_i]`.
 
     h. Let :math:`\X{dend}_i` be :math:`\X{do}_i` plus the length of :math:`\data_i.\DINIT`.
 
@@ -635,13 +639,11 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
        i. Fail.
 
-12. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F` is now on the top of the stack.
+11. Assert: due to :ref:`validation <valid-module>`, the frame :math:`F` is now on the top of the stack.
 
-13. Pop the frame from the stack.
+12. Pop the frame from the stack.
 
-14. Let :math:`\moduleinst` be a new module instance :ref:`allocated <alloc-module>` from :math:`\module` in store :math:`S` with imports :math:`\externval^\ast` and global initializer values :math:`\val^\ast`.
-
-15. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEM`, do:
+13. For each :ref:`element segment <syntax-elem>` :math:`\elem_i` in :math:`\module.\MELEM`, do:
 
     a. For each :ref:`function index <syntax-funcidx>` :math:`\funcidx_{ij}` in :math:`\elem_i.\EINIT` (starting with :math:`j = 0`), do:
 
@@ -651,13 +653,13 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
 
        iii. Replace :math:`\tableinst_i.\TIELEM[\X{eo}_i + j]` with :math:`\funcaddr_{ij}`.
 
-16. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATA`, do:
+14. For each :ref:`data segment <syntax-data>` :math:`\data_i` in :math:`\module.\MDATA`, do:
 
     a. For each :ref:`byte <syntax-byte>` :math:`b_{ij}` in :math:`\data_i.\DINIT` (starting with :math:`j = 0`), do:
 
        i. Replace :math:`\meminst_i.\MIDATA[\X{do}_i + j]` with :math:`b_{ij}`.
 
-17. If the :ref:`start function <syntax-start>` :math:`\module.\MSTART` is not empty, then:
+15. If the :ref:`start function <syntax-start>` :math:`\module.\MSTART` is not empty, then:
 
     a. Assert: due to :ref:`validation <valid-start>`, :math:`\moduleinst.\MIFUNCS[\module.\MSTART.\SFUNC]` exists.
 
@@ -679,25 +681,21 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
      & \vdashmodule \module : \externtype_{\F{im}}^n \to \externtype_{\F{ex}}^\ast \\
      &\wedge& (S \vdashexternval \externval : \externtype)^n \\
      &\wedge& (\vdashexterntypematch \externtype \matches \externtype_{\F{im}})^n \\[1ex]
-     &\wedge& \module.\MGLOBALS = \global^k \\
+     &\wedge& \module.\MGLOBALS = \global^\ast \\
      &\wedge& \module.\MELEM = \elem^\ast \\
      &\wedge& \module.\MDATA = \data^\ast \\
      &\wedge& \module.\MSTART = \start^? \\[1ex]
-     &\wedge& S', \moduleinst = \allocmodule(S, \module, \externval^n, v^\ast) \\
+     &\wedge& S', \moduleinst = \allocmodule(S, \module, \externval^n, \val^\ast) \\
      &\wedge& F = \{ \AMODULE~\moduleinst, \ALOCALS~\epsilon \} \\[1ex]
-     &\wedge& (S'; F; \global.\GINIT \stepto^\ast S'; F; v)^\ast \\
-     &\wedge& (S'; F; \elem.\EOFFSET \stepto^\ast S'; F; \I32.\CONST~\X{eo})^\ast \\
-     &\wedge& (S'; F; \data.\DOFFSET \stepto^\ast S'; F; \I32.\CONST~\X{do})^\ast \\[1ex]
+     &\wedge& (S'; F; \global.\GINIT \stepto^\ast S'; F; \val~\END)^\ast \\
+     &\wedge& (S'; F; \elem.\EOFFSET \stepto^\ast S'; F; \I32.\CONST~\X{eo}~\END)^\ast \\
+     &\wedge& (S'; F; \data.\DOFFSET \stepto^\ast S'; F; \I32.\CONST~\X{do}~\END)^\ast \\[1ex]
      &\wedge& (\X{eo} + |\elem.\EINIT| \leq |S'.\STABLES[\tableaddr].\TIELEM|)^\ast \\
      &\wedge& (\X{do} + |\data.\DINIT| \leq |S'.\SMEMS[\memaddr].\MIDATA|)^\ast
    \\[1ex]
-     &\wedge& \globaladdr^\ast = \moduleinst.\MIGLOBALS[|\moduleinst.\MIGLOBALS|-k \slice k] \\
      &\wedge& (\tableaddr = \moduleinst.\MITABLES[\elem.\ETABLE])^\ast \\
      &\wedge& (\memaddr = \moduleinst.\MIMEMS[\data.\DMEM])^\ast \\
      &\wedge& (\funcaddr = \moduleinst.\MIFUNCS[\start.\SFUNC])^?)
-   \\[1ex]
-   \instantiate(S, \module, \externval^n) &=& S; \{\AMODULE~\{\}, \ALOCALS~\epsilon\}; \TRAP
-     \qquad (\otherwise)
    \\[2ex]
    S; F; \INITELEM~a~i~\epsilon &\stepto&
      S; F; \epsilon \\
@@ -713,11 +711,15 @@ It is up to the :ref:`embedder <embedder>` to define how such conditions are rep
    \end{array}
 
 .. note::
+   Module :ref:`allocation <alloc-module>` and the :ref:`evaluation <exec-expr>` of :ref:`global <syntax-global>` initializers are mutually recursive because the global initialization :ref:`values <syntax-val>` :math:`\val^\ast` are passed to the module allocator but depend on the store :math:`S'` and module instance :math:`\moduleinst` returned by allocation.
+   However, this recursion is just a specification device.
+   Due to :ref:`validation <valid-module>`, the initialization values can easily :ref:`be determined <exec-initvals>` from a simple pre-pass that evaluates global initializers in the initial store.
+
    All failure conditions are checked before any observable mutation of the store takes place.
    Store mutation is not atomic;
    it happens in individual steps that may be interleaved with other threads.
 
-   Evaluation of :ref:`constant expressions <valid-constant>` does not affect the store.
+   :ref:`Evaluation <exec-expr>` of :ref:`constant expressions <valid-constant>` does not affect the store.
 
 
 .. index:: ! invocation, module, module instance, function, export, function address, function instance, function type, value, stack, trap, store

From 17c445d11d10fe93b8dae65674dfb50f4b0286bf Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Mon, 12 Feb 2018 18:40:30 +0100
Subject: [PATCH 147/329] Remove redundant kExprEnd in test (#664)

---
 test/js-api/jsapi.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 6701a418d..90a8618ce 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -817,8 +817,7 @@ const complexTableReExportingModuleBinary = (() => {
         .addFunction('h', kSig_i_v)
         .addBody([
             kExprI32Const,
-            46,
-            kExprEnd
+            46
         ]).index;
 
     builder.setFunctionTableLength(3);

From 9b5f6620994c253084137bbc825af911eea47930 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Mon, 12 Feb 2018 15:26:39 -0800
Subject: [PATCH 148/329] Revising specs in preparation for FPWD. (#626)

Adding single page bikeshed wrapper build of core spec.
Adding katex conversion.
Adding front matter.
Switching to more current version of bikeshed.
---
 .gitmodules                         |   3 +
 .travis.yml                         |   6 +
 document/core/Makefile              |  37 ++-
 document/core/copyright.include     |   1 +
 document/core/footer.include        |  34 ++
 document/core/header.include        |  31 ++
 document/core/index.bs              |  65 ++++
 document/core/util/bikeshed/conf.py | 470 ++++++++++++++++++++++++++++
 document/core/util/katex            |   1 +
 document/core/util/katex_fix.patch  |  29 ++
 document/core/util/macros.def       |   2 +-
 document/core/util/mathjax2katex.py | 202 ++++++++++++
 document/index.html                 |  14 +-
 document/js-api/Makefile            |   2 +-
 document/js-api/copyright.include   |   1 +
 document/js-api/footer.include      |  34 ++
 document/js-api/header.include      |  31 ++
 document/js-api/index.bs            |  51 ++-
 document/web-api/Makefile           |   2 +-
 document/web-api/copyright.include  |   1 +
 document/web-api/footer.include     |  34 ++
 document/web-api/header.include     |  31 ++
 document/web-api/index.bs           |  49 ++-
 23 files changed, 1106 insertions(+), 25 deletions(-)
 create mode 100644 .gitmodules
 create mode 100644 document/core/copyright.include
 create mode 100644 document/core/footer.include
 create mode 100644 document/core/header.include
 create mode 100644 document/core/index.bs
 create mode 100644 document/core/util/bikeshed/conf.py
 create mode 160000 document/core/util/katex
 create mode 100644 document/core/util/katex_fix.patch
 create mode 100755 document/core/util/mathjax2katex.py
 create mode 100644 document/js-api/copyright.include
 create mode 100644 document/js-api/footer.include
 create mode 100644 document/js-api/header.include
 create mode 100644 document/web-api/copyright.include
 create mode 100644 document/web-api/footer.include
 create mode 100644 document/web-api/header.include

diff --git a/.gitmodules b/.gitmodules
new file mode 100644
index 000000000..316660d9e
--- /dev/null
+++ b/.gitmodules
@@ -0,0 +1,3 @@
+[submodule "document/core/util/katex"]
+	path = document/core/util/katex
+	url = https://github.com/Khan/KaTeX.git
diff --git a/.travis.yml b/.travis.yml
index 556c2b2a1..a90c23084 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,4 +1,7 @@
 language: c++
+language: python
+python:
+  - "2.7"
 
 sudo: on
 
@@ -6,6 +9,9 @@ install:
   - ./interpreter/meta/travis/install-ocaml.sh
   - sudo pip install sphinx
   - sudo apt-get install texlive-full
+  - git clone https://github.com/tabatkins/bikeshed.git
+  - pip install --editable $PWD/bikeshed
+  - bikeshed update
 
 script:
   - ./interpreter/meta/travis/build-test.sh
diff --git a/document/core/Makefile b/document/core/Makefile
index 1463bf2c3..90cd7ae0e 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -26,7 +26,8 @@ usage:
 	@echo "Please use \`make <target>' where <target> is one of"
 	@echo "  html       to make standalone HTML files"
 	@echo "  pdf        to make standalone PDF file"
-	@echo "  all        to make both"
+	@echo "  bikeshed   to make a bikeshed wrapped single large HTML file"
+	@echo "  all        to make all 3"
 	@echo "  publish    to make all and push to gh-pages"
 	@echo "  help       to see more options"
 
@@ -35,7 +36,8 @@ help:
 	@echo "Usage: \`make <target>' where <target> is one of"
 	@echo "  html       to make standalone HTML files"
 	@echo "  pdf        to make standalone PDF file"
-	@echo "  all        to make both"
+	@echo "  bikeshed   to make a bikeshed wrapped single large HTML file"
+	@echo "  all        to make all 3"
 	@echo "  publish    to make all and push to gh-pages"
 	@echo "  dirhtml    to make HTML files named index.html in directories"
 	@echo "  singlehtml to make a single large HTML file"
@@ -72,12 +74,12 @@ publish:
 	(cd ..; make publish-core)
 
 .PHONY: all
-all:	pdf html
+all:	pdf html bikeshed
 
 .PHONY: pdf
 pdf:	latexpdf
-	mkdir -p $(BUILDDIR)/html/$(DOWNLOADDIR)
-	ln -f $(BUILDDIR)/latex/$(NAME).pdf $(BUILDDIR)/html/$(DOWNLOADDIR)/$(NAME).pdf
+	mkdir -p $(BUILDDIR)/html/multipage/$(DOWNLOADDIR)
+	ln -f $(BUILDDIR)/latex/$(NAME).pdf $(BUILDDIR)/html/multipage/$(DOWNLOADDIR)/$(NAME).pdf
 
 
 .PHONY: clean
@@ -87,15 +89,15 @@ clean:
 
 .PHONY: html
 html:
-	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
-	for file in `ls $(BUILDDIR)/html/*.html`; \
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html/multipage
+	for file in `ls $(BUILDDIR)/html/multipage/*.html`; \
 	do \
 	  sed s:BASEDIR:.:g <$$file >$$file.out; \
 	  mv -f $$file.out $$file; \
 	  sed s~$(OLDMATHJAX)~$(NEWMATHJAX)~g <$$file >$$file.out; \
 	  mv -f $$file.out $$file; \
 	done
-	for file in `ls $(BUILDDIR)/html/*/*.html`; \
+	for file in `ls $(BUILDDIR)/html/multipage/*/*.html`; \
 	do \
 	  sed s:BASEDIR:..:g <$$file >$$file.out; \
 	  sed 's; <body; <script type="text/javascript">MathJax.Hub.Config({TeX: {MAXBUFFER: 30*1024}})</script><body;' \
@@ -105,7 +107,7 @@ html:
 	  mv -f $$file.out $$file; \
 	done
 	@echo
-	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html."
+	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html/multipage."
 
 .PHONY: dirhtml
 dirhtml:
@@ -119,6 +121,23 @@ singlehtml:
 	@echo
 	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
 
+.PHONY: bikeshed
+bikeshed:
+	$(SPHINXBUILD) -b singlehtml -c util/bikeshed \
+		$(ALLSPHINXOPTS) $(BUILDDIR)/bikeshed_singlehtml
+	mkdir -p $(BUILDDIR)/bikeshed_mathjax/
+	cp index.bs $(BUILDDIR)/bikeshed_mathjax/
+	bikeshed spec index.bs $(BUILDDIR)/bikeshed_mathjax/index.html
+	mkdir -p $(BUILDDIR)/html/bikeshed/
+	python util/mathjax2katex.py $(BUILDDIR)/bikeshed_mathjax/index.html \
+		>$(BUILDDIR)/html/bikeshed/index.html
+	mkdir -p $(BUILDDIR)/html/bikeshed/katex/dist/
+	cp -r util/katex/dist/* $(BUILDDIR)/html/bikeshed/katex/dist/
+	patch -p0 $(BUILDDIR)/html/bikeshed/katex/dist/katex.css \
+		< util/katex_fix.patch
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/html/bikeshed."
+
 .PHONY: pickle
 pickle:
 	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
diff --git a/document/core/copyright.include b/document/core/copyright.include
new file mode 100644
index 000000000..90c193831
--- /dev/null
+++ b/document/core/copyright.include
@@ -0,0 +1 @@
+<a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright">Copyright</a> © [YEAR] <a href="http://www.w3.org/"><abbr title="World Wide Web Consortium">W3C</abbr></a><sup>®</sup> (<a href="http://www.csail.mit.edu/"><abbr title="Massachusetts Institute of Technology">MIT</abbr></a>, <a href="http://www.ercim.eu/"><abbr title="European Research Consortium for Informatics and Mathematics">ERCIM</abbr></a>, <a href="http://www.keio.ac.jp/">Keio</a>, <a href="http://ev.buaa.edu.cn/">Beihang</a>). W3C <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>, <a href="http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a> and <a href="http://www.w3.org/Consortium/Legal/2015/copyright-software-and-document">permissive document license</a> rules apply.
diff --git a/document/core/footer.include b/document/core/footer.include
new file mode 100644
index 000000000..21c351334
--- /dev/null
+++ b/document/core/footer.include
@@ -0,0 +1,34 @@
+</main>
+<h2 id="conformance" class="no-ref no-num">
+Conformance</h2>
+
+<h3 id="document-conventions">
+Document conventions</h3>
+
+	<p>Conformance requirements are expressed with a combination of
+	descriptive assertions and RFC 2119 terminology. The key words “MUST”,
+	“MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”,
+	“RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this
+	document are to be interpreted as described in RFC 2119.
+	However, for readability, these words do not appear in all uppercase
+	letters in this specification.
+
+	<p>All of the text of this specification is normative except sections
+	explicitly marked as non-normative, examples, and notes. [[!RFC2119]]
+
+	<p>Examples in this specification are introduced with the words “for example”
+	or are set apart from the normative text with <code>class="example"</code>,
+	like this:
+
+	<div class="example">
+		<p>This is an example of an informative example.
+	</div>
+
+	<p>Informative notes begin with the word “Note” and are set apart from the
+	normative text with <code>class="note"</code>, like this:
+
+	<p class="note">Note, this is an informative note.
+
+</body>
+<script src="https://www.w3.org/scripts/TR/2016/fixup.js"></script>
+</html>
diff --git a/document/core/header.include b/document/core/header.include
new file mode 100644
index 000000000..6ea66915e
--- /dev/null
+++ b/document/core/header.include
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+  <title>[TITLE]</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+  <meta name="w3c-status" content="[STATUS]">
+  <meta name="abstract" content="[ABSTRACTATTR]">
+  <link href="../default.css" rel=stylesheet type="text/css">
+  <link href="[W3C-STYLESHEET-URL]" rel=stylesheet type="text/css">
+</head>
+<body class="h-entry">
+<div class="head">
+  <p data-fill-with="logo"></p>
+  <h1 id="title" class="p-name no-ref">[TITLE]</h1>
+  <h2 id="subtitle" class="no-num no-toc no-ref">[LONGSTATUS],
+    <time class="dt-updated" datetime="[ISODATE]">[DATE]</time></h2>
+  <div data-fill-with="spec-metadata"></div>
+  <div data-fill-with="warning"></div>
+  <p class='copyright' data-fill-with='copyright'></p>
+  <hr title="Separator for header">
+</div>
+
+<div class="p-summary" data-fill-with="abstract"></div>
+
+<h2 class='no-num no-toc no-ref' id='status'>Status of this document</h2>
+<div data-fill-with="status"></div>
+<div data-fill-with="at-risk"></div>
+
+<nav data-fill-with="table-of-contents" id="toc"></nav>
+<main>
diff --git a/document/core/index.bs b/document/core/index.bs
new file mode 100644
index 000000000..750ec2fc6
--- /dev/null
+++ b/document/core/index.bs
@@ -0,0 +1,65 @@
+<pre class='metadata'>
+Title: WebAssembly Core Specification
+Shortname: wasm-core
+Group: WebAssembly Working Group
+Status: w3c/FPWD
+Level: 1
+TR: https://www.w3.org/TR/2018/WD-wasm-core-1/
+ED: https://webassembly.github.io/spec/core/
+Editor: Andreas Rossberg (Dfinity Stiftung)
+Repository: WebAssembly/spec
+Markup Shorthands: css no, markdown yes, algorithm no
+Abstract: This document describes version 1.0 of the core WebAssembly standard, a safe, portable, low-level code format designed for efficient execution and compact representation. To be used in coordination with the <a href="https://www.w3.org/TR/2018/WD-wasm-js-api-1/">WebAssembly JavaScript Interface</a> and the <a href="https://www.w3.org/TR/2018/WD-wasm-web-api-1/">WebAssembly Web API</a>.
+</pre>
+
+<pre class='biblio'>
+{
+  "WEBASSEMBLY": {
+    "href": "https://webassembly.github.io/spec/",
+    "title": "WebAssembly Specification",
+    "publisher": "W3C WebAssembly Community Group",
+    "status": "Draft"
+  }
+}
+</pre>
+
+<div boilerplate='status'>
+<p>
+  This section describes the status of this document at the time of
+  its publication. Other documents may supersede this document. A list of
+  current W3C publications and the latest revision of this technical report
+  can be found in the <a href="https://www.w3.org/TR/">W3C technical reports
+  index at https://www.w3.org/TR/</a>.
+</p>
+
+<p>This document is a <b>First Public Working Draft</b>.</p>
+<p>
+  Publication as a First Public Working Draft does not imply endorsement
+  by the W3C Membership. This is a draft document and may be updated,
+  replaced or obsoleted by other documents at any time. It is inappropriate
+  to cite this document as other than work in progress.
+</p>
+<p>
+  <a href="https://github.com/WebAssembly/spec/issues">GitHub Issues</a>
+  are preferred for discussion of this specification.
+  All issues and comments are
+  <a href="https://github.com/WebAssembly/spec/issues?utf8=%E2%9C%93&q=is%3Aissue++">archived</a>.
+</p>
+<p>This document was produced by the <a href="https://www.w3.org/wasm/">WebAssembly Working Group</a>.</p>
+<p>This document was produced by a group operating under the
+  <a href="https://www.w3.org/Consortium/Patent-Policy/">W3C Patent Policy</a>.
+  W3C maintains a <a href="https://www.w3.org/2004/01/pp-impl/101196/status" rel="disclosure">public list of any patent disclosures</a> made in
+  connection with the deliverables of the group; that page also includes
+  instructions for disclosing a patent. An individual who has actual
+  knowledge of a patent which the individual believes contains
+  <a href="https://www.w3.org/Consortium/Patent-Policy/#def-essential">Essential Claim(s)</a> must disclose the information in accordance with <a href="https://www.w3.org/Consortium/Patent-Policy/#sec-Disclosure">section
+  6 of the W3C Patent Policy</a>.
+</p>
+<p>This document is governed by the <a href="https://www.w3.org/2018/Process-20180201/" id="w3c_process_revision">1 February 2018 W3C Process Document</a>. </p>
+<p></p>
+
+</div>
+
+<pre class=include>
+path: _build/bikeshed_singlehtml/index.html
+</pre>
diff --git a/document/core/util/bikeshed/conf.py b/document/core/util/bikeshed/conf.py
new file mode 100644
index 000000000..db264f5fa
--- /dev/null
+++ b/document/core/util/bikeshed/conf.py
@@ -0,0 +1,470 @@
+# -*- coding: utf-8 -*-
+#
+# WebAssembly documentation build configuration file, created by
+# sphinx-quickstart on Mon Nov 21 11:32:49 2016.
+#
+# This file is execfile()d with the current directory set to its
+# containing dir.
+#
+# Note that not all possible configuration values are present in this
+# autogenerated file.
+#
+# All configuration values have a default; values that are commented out
+# serve to show the default.
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+import os
+import sys
+pwd = os.path.abspath('../..')
+sys.path.insert(0, pwd + '/util')
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+needs_sphinx = '1.4'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+  'sphinx.ext.todo',
+  'sphinx.ext.coverage',
+  'sphinx.ext.mathjax',
+  'sphinx.ext.ifconfig',
+  'sphinx.ext.githubpages',
+  'mathdef',
+  'pseudo-lexer'
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+source_suffix = ['.rst']
+
+# The encoding of source files.
+#
+# source_encoding = 'utf-8-sig'
+
+# The master toctree document.
+master_doc = 'index'
+
+# General information about the project.
+name = 'WebAssembly'
+project = u'WebAssembly'
+title = u'WebAssembly Specification'
+copyright = u'2017, WebAssembly Community Group'
+author = u'WebAssembly Community Group'
+logo = 'static/webassembly.png'
+
+# The version info for the project you're documenting, acts as replacement for
+# |version| and |release|, also used in various other places throughout the
+# built documents.
+#
+# The short X.Y version.
+version = u'1.0'
+# The full version, including alpha/beta/rc tags.
+release = version + ''
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# There are two options for replacing |today|: either, you set today to some
+# non-false value, then it is used:
+#
+# today = ''
+#
+# Else, today_fmt is used as the format for a strftime call.
+#
+# today_fmt = '%B %d, %Y'
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This patterns also effect to html_static_path and html_extra_path
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# The reST default role (used for this markup: `text`) to use for all
+# documents.
+#
+# default_role = None
+
+# If true, '()' will be appended to :func: etc. cross-reference text.
+#
+# add_function_parentheses = True
+
+# If true, the current module name will be prepended to all description
+# unit titles (such as .. function::).
+#
+# add_module_names = True
+
+# If true, sectionauthor and moduleauthor directives will be shown in the
+# output. They are ignored by default.
+#
+# show_authors = False
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+# A list of ignored prefixes for module index sorting.
+# modindex_common_prefix = []
+
+# If true, keep warnings as "system message" paragraphs in the built documents.
+# keep_warnings = False
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = True
+
+
+# -- Options for HTML output ----------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'classic'
+html_add_permalinks = None
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+html_theme_options = {
+  'nosidebar': True,
+}
+
+html_sidebars = {
+  '**': [
+    # 'about.html',
+    'navigation.html',
+    # 'relations.html',
+    'searchbox.html',
+  ]
+}
+
+
+# Add any paths that contain custom themes here, relative to this directory.
+# html_theme_path = []
+
+# The name for this set of Sphinx documents.
+# "<project> v<release> documentation" by default.
+#
+html_title = project + u' ' + release
+
+# A shorter title for the navigation bar.  Default is the same as html_title.
+#
+# html_short_title = None
+
+# The name of an image file (relative to this directory) to place at the top
+# of the sidebar.
+#
+html_logo = logo
+
+# The name of an image file (relative to this directory) to use as a favicon of
+# the docs.  This file should be a Windows icon file (.ico) being 16x16 or 32x32
+# pixels large.
+#
+# html_favicon = None
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = ['_static', 'static/custom.css']
+
+# Add any extra paths that contain custom files (such as robots.txt or
+# .htaccess) here, relative to this directory. These files are copied
+# directly to the root of the documentation.
+#
+# html_extra_path = []
+
+# If not None, a 'Last updated on:' timestamp is inserted at every page
+# bottom, using the given strftime format.
+# The empty string is equivalent to '%b %d, %Y'.
+#
+# html_last_updated_fmt = None
+
+# If true, SmartyPants will be used to convert quotes and dashes to
+# typographically correct entities.
+#
+# html_use_smartypants = True
+
+# Additional templates that should be rendered to pages, maps page names to
+# template names.
+#
+# html_additional_pages = {}
+
+# If false, no module index is generated.
+#
+html_domain_indices = False
+
+# If false, no index is generated.
+#
+html_use_index = True
+
+# If true, the index is split into individual pages for each letter.
+#
+html_split_index = False
+
+# If true, the reST sources are included in the HTML build as _sources/name. The default is True.
+#
+html_copy_source = False
+
+# If true, links to the reST sources are added to the pages.
+#
+html_show_sourcelink = False
+
+# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
+#
+html_show_sphinx = False
+
+# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
+#
+html_show_copyright = True
+
+# If this is not None, a ‘Last updated on:’ timestamp is inserted at every
+# page bottom, using the given strftime() format.
+#
+html_last_updated_fmt = '%F'
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a <link> tag referring to it.  The value of this option must be the
+# base URL from which the finished HTML is served.
+#
+# html_use_opensearch = ''
+
+# This is the file name suffix for HTML files (e.g. ".xhtml").
+#
+# html_file_suffix = None
+
+# Language to be used for generating the HTML full-text search index.
+# Sphinx supports the following languages:
+#   'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
+#   'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr', 'zh'
+#
+# html_search_language = 'en'
+
+# A dictionary with options for the search language support, empty by default.
+# 'ja' uses this config value.
+# 'zh' user can custom change `jieba` dictionary path.
+#
+# html_search_options = {'type': 'default'}
+
+# The name of a javascript file (relative to the configuration directory) that
+# implements a search results scorer. If empty, the default will be used.
+#
+# html_search_scorer = 'scorer.js'
+
+# Output file base name for HTML help builder.
+#
+htmlhelp_basename = 'WebAssemblydoc'
+
+
+# -- Options for LaTeX output ---------------------------------------------
+
+latex_elements = {
+   # The paper size ('a4paper' or 'letterpaper').
+  'papersize': 'a4paper',
+
+   # The font size ('10pt', '11pt' or '12pt').
+  'pointsize': '10pt',
+
+   # Additional stuff for the LaTeX preamble.
+   'preamble': '',
+
+   # Latex figure (float) alignment
+  'figure_align': 'htbp',
+
+   # Fancy chapters [Bjarne, Sonny, Lenny, Glenn, Conny, Rejne]
+   'fncychap': '\\usepackage[Sonny]{fncychap}',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+  ( master_doc,
+    name + '.tex',
+    title,
+    author,
+    'manual'
+  ),
+]
+
+# The name of an image file (relative to this directory) to place at the top of
+# the title page.
+#
+latex_logo = logo
+
+# For "manual" documents [part, chapter, or section].
+#
+latex_toplevel_sectioning = 'chapter'
+
+# If true, show page references after internal links.
+#
+latex_show_pagerefs = False
+
+# How to show URL addresses after external links [no, footnote, inline].
+#
+latex_show_urls = 'footnote'
+
+# Documents to append as an appendix to all manuals.
+#
+# latex_appendices = []
+
+# It false, will not define \strong, \code, \titleref, \crossref ... but only
+# \sphinxstrong, ..., \sphinxtitleref, ... To help avoid clash with user added
+# packages.
+#
+# latex_keep_old_macro_names = True
+
+# If false, no module index is generated.
+#
+latex_domain_indices = False
+
+
+# -- Options for manual page output ---------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+  ( master_doc,
+    name,
+    title,
+    [author],
+    1
+  )
+]
+
+# If true, show URL addresses after external links.
+#
+# man_show_urls = False
+
+
+# -- Options for Texinfo output -------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+  ( master_doc,
+    name,
+    title,
+    author,
+    name,
+    'A portable low-level execution format.',
+    'Virtual Machine'
+  ),
+]
+
+# Documents to append as an appendix to all manuals.
+#
+# texinfo_appendices = []
+
+# If false, no module index is generated.
+#
+texinfo_domain_indices = False
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#
+# texinfo_show_urls = 'footnote'
+
+# If true, do not generate a @detailmenu in the "Top" node's menu.
+#
+# texinfo_no_detailmenu = False
+
+
+# -- Options for Epub output ----------------------------------------------
+
+# Bibliographic Dublin Core info.
+epub_title = project
+epub_author = author
+epub_publisher = author
+epub_copyright = copyright
+
+# The basename for the epub file. It defaults to the project name.
+# epub_basename = project
+
+# The HTML theme for the epub output. Since the default themes are not
+# optimized for small screen space, using the same theme for HTML and epub
+# output is usually not wise. This defaults to 'epub', a theme designed to save
+# visual space.
+#
+# epub_theme = 'epub'
+
+# The language of the text. It defaults to the language option
+# or 'en' if the language is not set.
+#
+# epub_language = ''
+
+# The scheme of the identifier. Typical schemes are ISBN or URL.
+# epub_scheme = ''
+
+# The unique identifier of the text. This can be a ISBN number
+# or the project homepage.
+#
+# epub_identifier = ''
+
+# A unique identification for the text.
+#
+# epub_uid = ''
+
+# A tuple containing the cover image and cover page html template filenames.
+#
+# epub_cover = ()
+
+# A sequence of (type, uri, title) tuples for the guide element of content.opf.
+#
+# epub_guide = ()
+
+# HTML files that should be inserted before the pages created by sphinx.
+# The format is a list of tuples containing the path and title.
+#
+# epub_pre_files = []
+
+# HTML files that should be inserted after the pages created by sphinx.
+# The format is a list of tuples containing the path and title.
+#
+# epub_post_files = []
+
+# A list of files that should not be packed into the epub file.
+epub_exclude_files = ['search.html']
+
+# The depth of the table of contents in toc.ncx.
+#
+# epub_tocdepth = 3
+
+# Allow duplicate toc entries.
+#
+# epub_tocdup = True
+
+# Choose between 'default' and 'includehidden'.
+#
+# epub_tocscope = 'default'
+
+# Fix unsupported image types using the Pillow.
+#
+# epub_fix_images = False
+
+# Scale large images.
+#
+# epub_max_image_width = 0
+
+# How to display URL addresses: 'footnote', 'no', or 'inline'.
+#
+# epub_show_urls = 'inline'
+
+# If false, no index is generated.
+#
+# epub_use_index = True
+
+# Macros
+rst_prolog = """
+.. include:: /""" + pwd + """/util/macros.def
+"""
diff --git a/document/core/util/katex b/document/core/util/katex
new file mode 160000
index 000000000..38a1bfafe
--- /dev/null
+++ b/document/core/util/katex
@@ -0,0 +1 @@
+Subproject commit 38a1bfafed3a9db3c478003909976648c4241939
diff --git a/document/core/util/katex_fix.patch b/document/core/util/katex_fix.patch
new file mode 100644
index 000000000..7cfe9580e
--- /dev/null
+++ b/document/core/util/katex_fix.patch
@@ -0,0 +1,29 @@
+diff --git a/dist/katex.css b/dist/katex.css
+index f0c5040..0edb55a 100644
+--- a/dist/katex.css
++++ b/dist/katex.css
+@@ -111,12 +111,14 @@
+   font-style: normal;
+ }
+ .katex-display {
++  /*
+   display: block;
+   margin: 1em 0;
+   text-align: center;
++  */
+ }
+ .katex-display > .katex {
+-  display: inline-block;
++/*  display: inline-block; */
+   text-align: initial;
+ }
+ .katex {
+@@ -130,7 +132,7 @@
+   -ms-high-contrast-adjust: none !important;
+ }
+ .katex .katex-html {
+-  display: inline-block;
++/*  display: inline-block; */
+ }
+ .katex .katex-mathml {
+   position: absolute;
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 5ff53df7e..ebb373fcb 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -36,7 +36,7 @@
 .. ----------
 
 .. |PLDI2017| replace:: Bringing the Web up to Speed with WebAssembly
-.. _PLDI2017: https://dl.acm.org/citation.cfm?doid=3062341.3062363>
+.. _PLDI2017: https://dl.acm.org/citation.cfm?doid=3062341.3062363
 
 .. |TAPL| replace:: Types and Programming Languages
 .. _TAPL: https://www.cis.upenn.edu/~bcpierce/tapl/
diff --git a/document/core/util/mathjax2katex.py b/document/core/util/mathjax2katex.py
new file mode 100755
index 000000000..ae2bab5e9
--- /dev/null
+++ b/document/core/util/mathjax2katex.py
@@ -0,0 +1,202 @@
+#! /usr/bin/env python
+# -*- coding: latin-1 -*-
+
+import Queue
+import os
+import re
+import shelve
+import subprocess
+import sys
+import threading
+
+
+SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
+
+
+def FindMatching(data, prefix):
+  start = data.find(prefix)
+  if start < 0:
+    return (None, None)
+  end = start + 1
+  total = 0
+  while True:
+    if data[end] == '{':
+      total += 1
+    elif data[end] == '}':
+      total -= 1
+      if total == 0:
+        end += 1
+        break
+    end += 1
+  return (start, end)
+
+
+def ReplaceMath(cache, data):
+  if cache.has_key(data):
+    return cache[data]
+  old = data
+  data = data.replace('\\\\', '\\DOUBLESLASH')
+  data = data.replace('\\(', '')
+  data = data.replace('\\)', '')
+  data = data.replace('\\[', '')
+  data = data.replace('\\]', '')
+  data = data.replace('\\DOUBLESLASH', '\\\\')
+  data = data.replace('’', '\\text{’}')
+  data = data.replace('‘', '\\text{‘}')
+  data = data.replace('\\hfill', '')
+  data = data.replace('\\mbox', '')
+  data = data.replace('\\begin{split}', '\\begin{aligned}')
+  data = data.replace('\\end{split}', '\\end{aligned}')
+  data = data.replace('&amp;', '&')
+  data = data.replace('&lt;', '<')
+  data = data.replace('&gt;', '>')
+  data = data.replace('{array}[t]', '{array}')
+  data = data.replace('{array}[b]', '{array}')
+  data = data.replace('@{~}', '')
+  data = data.replace('@{}', '')
+  data = data.replace('@{\\qquad}', '')
+  data = data.replace('@{\\qquad\\qquad}', '')
+  data = re.sub('([^\\\\])[$]', '\\1', data)
+  data = re.sub('[\\\\]href{[^}]*}', '', data)
+  macros = {}
+  while True:
+    start, end = FindMatching(data, '\\def\\')
+    if start is None:
+      break
+    parts = data[start:end]
+    name_end = parts.find('#')
+    assert name_end > 0
+    name = parts[len('\\def'):name_end]
+    value = parts[name_end+len('#1'):end]
+    macros[name] = value
+    data = data[:start] + data[end:]
+  for k, v in macros.iteritems():
+    while True:
+      start, end = FindMatching(data, k + '{')
+      if start is None:
+        break
+      data = data[:start] + v.replace('#1', data[start+len(k):end]) + data[end:]
+  p = subprocess.Popen(
+      ['node', os.path.join(SCRIPT_DIR, 'katex/cli.js')],
+      stdin=subprocess.PIPE, stdout=subprocess.PIPE)
+  ret = p.communicate(input=data)[0]
+  if p.returncode != 0:
+    sys.stderr.write('BEFORE:\n' + old + '\n')
+    sys.stderr.write('AFTER:\n' + data + '\n')
+    return ''
+  ret = ret[ret.find('<span class="katex-html"'):]
+  ret = '<span class="katex-display"><span class="katex">' + ret + '</span>'
+  # w3c validator does not like negative em.
+  ret = re.sub('height:[-][0-9][.][0-9]+em', 'height:0em', ret)
+  cache[old] = ret
+  return ret
+
+
+def Main():
+  fixups = []
+
+  def ExtractMath(match):
+    fixups.append(
+        (match.group(1), match.group(2), match.group(3),
+         match.start(), match.end()))
+    return 'x' * len(match.group())
+
+  data = open(sys.argv[1]).read()
+  cache = shelve.open(sys.argv[1] + '.cache')
+  # Drop index + search links.
+  data = data.replace(
+      '<link href="genindex.html" rel="index" title="Index">', '')
+  data = data.replace(
+      '<link href="search.html" rel="search" title="Search">', '')
+  # Drop Navigation.
+  data = data.replace(
+      '<h3 class="heading settled" id="navigation">'
+      '<span class="content">Navigation</span></h3>', '')
+  data = data.replace(
+      '<li class="nav-item nav-item-0"><a href="index.html#document-index">'
+      'WebAssembly 1.0</a> »', '')
+  # Drop Index links.
+  data = data.replace(
+      '<li><a class="reference internal" href="index.html#index-type">'
+      '<span class="std std-ref">Index of Types</span></a>', '')
+  data = data.replace(
+      '<li><a class="reference internal" href="index.html#index-instr">'
+      '<span class="std std-ref">Index of Instructions</span></a>', '')
+  data = data.replace(
+      '<li><a class="reference internal" href="index.html#index-rules">'
+      '<span class="std std-ref">Index of Semantic Rules</span></a>', '')
+  data = data.replace(
+      '<li><a class="reference internal" href="genindex.html">'
+      '<span class="std std-ref">Index</span></a>', '')
+  # Drop sphinx css.
+  data = data.replace(
+      '<link href="_static/classic.css" rel="stylesheet" type="text/css">', '')
+  data = data.replace(
+      '<link href="_static/pygments.css" rel="stylesheet" type="text/css">',
+      '')
+  # Bad duplicate meta.
+  data = ''.join(data.rsplit(
+      '<meta content="text/html; charset=utf-8" http-equiv="Content-Type">', 1))
+  # Drop all scripts.
+  data = re.sub('<script[^>]*>[^<]*</script>', '', data)
+  data = data.replace(
+      '<head>\n', '<head>\n<link rel="stylesheet" href="katex/dist/katex.css">')
+  # Drop duplicate title.
+  data = data.replace(
+      '<title>WebAssembly 1.0</title>', '')
+  # valign="top"/"bottom" fails w3c validator.
+  data = data.replace(' valign="top"', '')
+  data = data.replace(' valign="bottom"', '')
+  # frame="void" fails w3c validator.
+  data = data.replace(' frame="void"', '')
+  # rules="none" fails w3c validator.
+  data = data.replace(' rules="none"', '')
+  # <pre> makes w3c valdiator angry (w/ <p> nested)
+  data = data.replace('<pre>', '<div>')
+  data = data.replace('</pre>', '</div>')
+  # width="*" angers w3c validator.
+  data = re.sub(' width="[0-9]+%"', '', data)
+  # border="1" angers w3c validator.
+  data = data.replace(' border="1"', '')
+
+  # Pull out math fragments.
+  data = re.sub(
+      'class="([^"]*)math"[^>]*>((?:[ ]*<span[^>]*>[^<]*</span>)*)([^<]*)<',
+      ExtractMath, data)
+
+  done_fixups = []
+
+  def Worker():
+    while True:
+      cls, spans, mth, start, end = q.get()
+      fixed = 'class="' + cls + '">' + spans + ReplaceMath(cache, mth) + '<'
+      done_fixups.append((start, end, fixed))
+      q.task_done()
+      left = q.qsize()
+      if left > 0:
+        sys.stderr.write('Remaining: ' + str(left) + '            \r')
+
+  q = Queue.Queue()
+  for i in range(40):
+    t = threading.Thread(target=Worker)
+    t.daemon = True
+    t.start()
+
+  for item in fixups:
+    q.put(item)
+  q.join()
+
+  result = []
+  last = 0
+  for start, end, value in sorted(done_fixups):
+    result.append(data[last:start])
+    result.append(value)
+    last = end
+  result.append(data[last:])
+
+  sys.stderr.write('Done.             \n')
+  sys.stdout.write(''.join(result))
+  cache.close()
+
+
+Main()
diff --git a/document/index.html b/document/index.html
index 90af7c147..2fad9247e 100644
--- a/document/index.html
+++ b/document/index.html
@@ -26,7 +26,16 @@ <h3>Core specification</h3>
   The WebAssembly core is specified in a single document:</p>
 
   <ul>
-  <li><p><a href="core/index.html">Core</a>: defines the structure of WebAssembly modules and its representation in binary and text format, as well as the semantics of validation, instantiation, and execution.</p></li>
+    <li>
+      <p><a href="core/multipage/index.html">Core</a>:
+      defines the structure of WebAssembly modules and its representation
+      in binary and text format, as well as the semantics of validation,
+      instantiation, and execution.
+      Alternate versions:
+      <a href="core/bikeshed/index.html">W3C Editor's Draft</a>,
+      <a href="core/multipage/_download/WebAssembly.pdf">PDF</a>.
+      </p>
+    </li>
   </ul>
 
 <h3>API specifications</h3>
@@ -40,6 +49,9 @@ <h3>API specifications</h3>
   <li><p><a href="web-api/index.html">Web API</a>: defines extensions to the JavaScript API made available specifically in web browsers, in particular, an interface for streaming compilation and instantiation from origin-bound <code>Response</code> types.</p></li>
   </ul>
 
+<p>Source for these documents is available
+<a href="https://github.com/WebAssembly/spec/">here</a></p>.
+
 </article>
 </div>
 </body>
diff --git a/document/js-api/Makefile b/document/js-api/Makefile
index e94623501..e7783ff93 100644
--- a/document/js-api/Makefile
+++ b/document/js-api/Makefile
@@ -6,7 +6,7 @@ NAME          = WebAssembly
 .PHONY: all
 all:
 	mkdir -p $(BUILDDIR)/html
-	curl https://api.csswg.org/bikeshed/ -F file=@index.bs > $(BUILDDIR)/html/index.html
+	bikeshed spec index.bs $(BUILDDIR)/html/index.html
 	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html."
 
 .PHONY: publish
diff --git a/document/js-api/copyright.include b/document/js-api/copyright.include
new file mode 100644
index 000000000..90c193831
--- /dev/null
+++ b/document/js-api/copyright.include
@@ -0,0 +1 @@
+<a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright">Copyright</a> © [YEAR] <a href="http://www.w3.org/"><abbr title="World Wide Web Consortium">W3C</abbr></a><sup>®</sup> (<a href="http://www.csail.mit.edu/"><abbr title="Massachusetts Institute of Technology">MIT</abbr></a>, <a href="http://www.ercim.eu/"><abbr title="European Research Consortium for Informatics and Mathematics">ERCIM</abbr></a>, <a href="http://www.keio.ac.jp/">Keio</a>, <a href="http://ev.buaa.edu.cn/">Beihang</a>). W3C <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>, <a href="http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a> and <a href="http://www.w3.org/Consortium/Legal/2015/copyright-software-and-document">permissive document license</a> rules apply.
diff --git a/document/js-api/footer.include b/document/js-api/footer.include
new file mode 100644
index 000000000..21c351334
--- /dev/null
+++ b/document/js-api/footer.include
@@ -0,0 +1,34 @@
+</main>
+<h2 id="conformance" class="no-ref no-num">
+Conformance</h2>
+
+<h3 id="document-conventions">
+Document conventions</h3>
+
+	<p>Conformance requirements are expressed with a combination of
+	descriptive assertions and RFC 2119 terminology. The key words “MUST”,
+	“MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”,
+	“RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this
+	document are to be interpreted as described in RFC 2119.
+	However, for readability, these words do not appear in all uppercase
+	letters in this specification.
+
+	<p>All of the text of this specification is normative except sections
+	explicitly marked as non-normative, examples, and notes. [[!RFC2119]]
+
+	<p>Examples in this specification are introduced with the words “for example”
+	or are set apart from the normative text with <code>class="example"</code>,
+	like this:
+
+	<div class="example">
+		<p>This is an example of an informative example.
+	</div>
+
+	<p>Informative notes begin with the word “Note” and are set apart from the
+	normative text with <code>class="note"</code>, like this:
+
+	<p class="note">Note, this is an informative note.
+
+</body>
+<script src="https://www.w3.org/scripts/TR/2016/fixup.js"></script>
+</html>
diff --git a/document/js-api/header.include b/document/js-api/header.include
new file mode 100644
index 000000000..6ea66915e
--- /dev/null
+++ b/document/js-api/header.include
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+  <title>[TITLE]</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+  <meta name="w3c-status" content="[STATUS]">
+  <meta name="abstract" content="[ABSTRACTATTR]">
+  <link href="../default.css" rel=stylesheet type="text/css">
+  <link href="[W3C-STYLESHEET-URL]" rel=stylesheet type="text/css">
+</head>
+<body class="h-entry">
+<div class="head">
+  <p data-fill-with="logo"></p>
+  <h1 id="title" class="p-name no-ref">[TITLE]</h1>
+  <h2 id="subtitle" class="no-num no-toc no-ref">[LONGSTATUS],
+    <time class="dt-updated" datetime="[ISODATE]">[DATE]</time></h2>
+  <div data-fill-with="spec-metadata"></div>
+  <div data-fill-with="warning"></div>
+  <p class='copyright' data-fill-with='copyright'></p>
+  <hr title="Separator for header">
+</div>
+
+<div class="p-summary" data-fill-with="abstract"></div>
+
+<h2 class='no-num no-toc no-ref' id='status'>Status of this document</h2>
+<div data-fill-with="status"></div>
+<div data-fill-with="at-risk"></div>
+
+<nav data-fill-with="table-of-contents" id="toc"></nav>
+<main>
diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 839e0945b..d0a17df30 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -1,14 +1,15 @@
 <pre class='metadata'>
 Title: WebAssembly JavaScript Interface
-Shortname: wasmjs
-Group: WebAssembly CG
-Status: w3c/CG-DRAFT
+Shortname: wasm-js-api
+Group: WebAssembly Working Group
+Status: w3c/FPWD
 Level: 1
+TR: https://www.w3.org/TR/2018/WD-wasm-js-api-1/
 ED: https://webassembly.github.io/spec/js-api/
-Editor: WebAssembly Community Group
+Editor: Daniel Ehrenberg (Igalia)
 Repository: WebAssembly/spec
-Abstract: This document provides an explicit JavaScript API for interacting with WebAssembly.
 Markup Shorthands: css no, markdown yes
+Abstract: This document provides an explicit JavaScript API for interacting with WebAssembly. To be used in coordination with the <a href="https://www.w3.org/TR/2018/WD-wasm-core-1/">Core WebAssembly Specification</a> and the <a href="https://www.w3.org/TR/2018/WD-wasm-web-api-1/">WebAssembly Web API</a>.
 </pre>
 
 <pre class='biblio'>
@@ -163,6 +164,41 @@ spec:ecmascript; type:exception; for:ECMAScript; text:RangeError
 spec:ecmascript; type:interface; for:ECMAScript; text:ArrayBuffer
 </pre>
 
+<div boilerplate='status'>
+<p>
+  This section describes the status of this document at the time of
+  its publication. Other documents may supersede this document. A list of
+  current W3C publications and the latest revision of this technical report
+  can be found in the <a href="https://www.w3.org/TR/">W3C technical reports
+  index at https://www.w3.org/TR/</a>.
+</p>
+
+<p>This document is a <b>First Public Working Draft</b>.</p>
+<p>
+  Publication as a First Public Working Draft does not imply endorsement
+  by the W3C Membership. This is a draft document and may be updated,
+  replaced or obsoleted by other documents at any time. It is inappropriate
+  to cite this document as other than work in progress.
+</p>
+<p>
+  <a href="https://github.com/WebAssembly/spec/issues">GitHub Issues</a>
+  are preferred for discussion of this specification.
+  All issues and comments are
+  <a href="https://github.com/WebAssembly/spec/issues?utf8=%E2%9C%93&q=is%3Aissue++">archived</a>.
+</p>
+<p>This document was produced by the <a href="https://www.w3.org/wasm/">WebAssembly Working Group</a>.</p>
+<p>This document was produced by a group operating under the
+  <a href="https://www.w3.org/Consortium/Patent-Policy/">W3C Patent Policy</a>.
+  W3C maintains a <a href="https://www.w3.org/2004/01/pp-impl/101196/status" rel="disclosure">public list of any patent disclosures</a> made in
+  connection with the deliverables of the group; that page also includes
+  instructions for disclosing a patent. An individual who has actual
+  knowledge of a patent which the individual believes contains
+  <a href="https://www.w3.org/Consortium/Patent-Policy/#def-essential">Essential Claim(s)</a> must disclose the information in accordance with <a href="https://www.w3.org/Consortium/Patent-Policy/#sec-Disclosure">section
+  6 of the W3C Patent Policy</a>.
+</p>
+<p>This document is governed by the <a href="https://www.w3.org/2018/Process-20180201/" id="w3c_process_revision">1 February 2018 W3C Process Document</a>. </p>
+<p></p>
+
 Issue: This document is an early draft, porting <a href="https://github.com/WebAssembly/design/blob/master/JS.md">the official JS/WebAssembly interface specification</a> to WebIDL and Bikeshed. It should currently not be used as the WebAssembly specification.
 
 This API is, initially, the only API for accessing WebAssembly [[WEBASSEMBLY]] from the web platform, through a bridge to explicitly construct modules from ECMAScript [[ECMASCRIPT]].
@@ -174,6 +210,9 @@ any other Web API that loads ES6 modules via URL—as part of
 
 Note: WebAssembly JS API declaration file for TypeScript can be found [here](https://github.com/01alchemist/webassembly-types/blob/master/webassembly.d.ts) which enable autocompletion and make TypeScript compiler happy.
 
+<p>See the [[#issues-index]] for complete list of issues.</p>
+</div>
+
 <h2 id="sample">Sample API Usage</h2>
 
 <p><em>This section is non-normative.</em></p>
@@ -422,7 +461,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
     1. Return |promise|
 </div>
 
-Note: A follow-on streaming API is documented in the <a href="https://webassembly.github.io/spec/document/web-api/index.html">WebAssembly Web API</a>.
+Note: A follow-on streaming API is documented in the <a href="https://webassembly.github.io/spec/web-api/index.html">WebAssembly Web API</a>.
 
 <h3 id="modules">Modules</h3>
 
diff --git a/document/web-api/Makefile b/document/web-api/Makefile
index 1054a6da1..5166f7c12 100644
--- a/document/web-api/Makefile
+++ b/document/web-api/Makefile
@@ -6,7 +6,7 @@ NAME          = WebAssembly
 .PHONY: all
 all:
 	mkdir -p $(BUILDDIR)/html
-	curl https://api.csswg.org/bikeshed/ -F file=@index.bs > $(BUILDDIR)/html/index.html
+	bikeshed spec index.bs $(BUILDDIR)/html/index.html
 	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html."
 
 .PHONY: publish
diff --git a/document/web-api/copyright.include b/document/web-api/copyright.include
new file mode 100644
index 000000000..90c193831
--- /dev/null
+++ b/document/web-api/copyright.include
@@ -0,0 +1 @@
+<a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright">Copyright</a> © [YEAR] <a href="http://www.w3.org/"><abbr title="World Wide Web Consortium">W3C</abbr></a><sup>®</sup> (<a href="http://www.csail.mit.edu/"><abbr title="Massachusetts Institute of Technology">MIT</abbr></a>, <a href="http://www.ercim.eu/"><abbr title="European Research Consortium for Informatics and Mathematics">ERCIM</abbr></a>, <a href="http://www.keio.ac.jp/">Keio</a>, <a href="http://ev.buaa.edu.cn/">Beihang</a>). W3C <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>, <a href="http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a> and <a href="http://www.w3.org/Consortium/Legal/2015/copyright-software-and-document">permissive document license</a> rules apply.
diff --git a/document/web-api/footer.include b/document/web-api/footer.include
new file mode 100644
index 000000000..21c351334
--- /dev/null
+++ b/document/web-api/footer.include
@@ -0,0 +1,34 @@
+</main>
+<h2 id="conformance" class="no-ref no-num">
+Conformance</h2>
+
+<h3 id="document-conventions">
+Document conventions</h3>
+
+	<p>Conformance requirements are expressed with a combination of
+	descriptive assertions and RFC 2119 terminology. The key words “MUST”,
+	“MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”,
+	“RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this
+	document are to be interpreted as described in RFC 2119.
+	However, for readability, these words do not appear in all uppercase
+	letters in this specification.
+
+	<p>All of the text of this specification is normative except sections
+	explicitly marked as non-normative, examples, and notes. [[!RFC2119]]
+
+	<p>Examples in this specification are introduced with the words “for example”
+	or are set apart from the normative text with <code>class="example"</code>,
+	like this:
+
+	<div class="example">
+		<p>This is an example of an informative example.
+	</div>
+
+	<p>Informative notes begin with the word “Note” and are set apart from the
+	normative text with <code>class="note"</code>, like this:
+
+	<p class="note">Note, this is an informative note.
+
+</body>
+<script src="https://www.w3.org/scripts/TR/2016/fixup.js"></script>
+</html>
diff --git a/document/web-api/header.include b/document/web-api/header.include
new file mode 100644
index 000000000..6ea66915e
--- /dev/null
+++ b/document/web-api/header.include
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
+  <title>[TITLE]</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+  <meta name="w3c-status" content="[STATUS]">
+  <meta name="abstract" content="[ABSTRACTATTR]">
+  <link href="../default.css" rel=stylesheet type="text/css">
+  <link href="[W3C-STYLESHEET-URL]" rel=stylesheet type="text/css">
+</head>
+<body class="h-entry">
+<div class="head">
+  <p data-fill-with="logo"></p>
+  <h1 id="title" class="p-name no-ref">[TITLE]</h1>
+  <h2 id="subtitle" class="no-num no-toc no-ref">[LONGSTATUS],
+    <time class="dt-updated" datetime="[ISODATE]">[DATE]</time></h2>
+  <div data-fill-with="spec-metadata"></div>
+  <div data-fill-with="warning"></div>
+  <p class='copyright' data-fill-with='copyright'></p>
+  <hr title="Separator for header">
+</div>
+
+<div class="p-summary" data-fill-with="abstract"></div>
+
+<h2 class='no-num no-toc no-ref' id='status'>Status of this document</h2>
+<div data-fill-with="status"></div>
+<div data-fill-with="at-risk"></div>
+
+<nav data-fill-with="table-of-contents" id="toc"></nav>
+<main>
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 1b787856c..5ed74a971 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -1,13 +1,14 @@
 <pre class='metadata'>
 Title: WebAssembly Web API
-Shortname: wasmweb
-Group: WebAssembly CG
-Status: w3c/CG-DRAFT
+Shortname: wasm-web-api
+Group: WebAssembly Working Group
+Status: w3c/FPWD
 Level: 1
+TR: https://www.w3.org/TR/2018/WD-wasm-web-api-1/
 ED: https://webassembly.github.io/spec/web-api/
-Editor: WebAssembly Community Group
+Editor: Daniel Ehrenberg (Igalia)
 Repository: WebAssembly/spec
-Abstract: This document describes the integration of WebAssembly with the broader web platform.
+Abstract: This document describes the integration of WebAssembly with the broader web platform. To be used in coordination with the <a href="https://www.w3.org/TR/2018/WD-wasm-core-1/">WebAssembly Core Specification</a> and the <a href="https://www.w3.org/TR/2018/WD-wasm-js-api-1/">WebAssembly JavaScript Interface</a>.
 Markup Shorthands: css no, markdown yes
 </pre>
 
@@ -26,7 +27,7 @@ Markup Shorthands: css no, markdown yes
     "status": "Draft"
   },
   "WASMJS": {
-    "href": "https://webassembly.github.io/spec/document/js-api/",
+    "href": "https://webassembly.github.io/spec/js-api/",
     "title": "WebAssembly JS Integration Specification",
     "publisher": "W3C WebAssembly Community Group",
     "status": "Draft"
@@ -64,6 +65,42 @@ url:https://fetch.spec.whatwg.org/#concept-body-consume-body;text:consume body;t
 spec:ecma-262; type:exception; for:ECMAScript; text:TypeError
 </pre>
 
+<div boilerplate='status'>
+<p>
+  This section describes the status of this document at the time of
+  its publication. Other documents may supersede this document. A list of
+  current W3C publications and the latest revision of this technical report
+  can be found in the <a href="https://www.w3.org/TR/">W3C technical reports
+  index at https://www.w3.org/TR/</a>.
+</p>
+
+<p>This document is a <b>First Public Working Draft</b>.</p>
+<p>
+  Publication as a First Public Working Draft does not imply endorsement
+  by the W3C Membership. This is a draft document and may be updated,
+  replaced or obsoleted by other documents at any time. It is inappropriate
+  to cite this document as other than work in progress.
+</p>
+<p>
+  <a href="https://github.com/WebAssembly/spec/issues">GitHub Issues</a>
+  are preferred for discussion of this specification.
+  All issues and comments are
+  <a href="https://github.com/WebAssembly/spec/issues?utf8=%E2%9C%93&q=is%3Aissue++">archived</a>.
+</p>
+<p>This document was produced by the <a href="https://www.w3.org/wasm/">WebAssembly Working Group</a>.</p>
+<p>This document was produced by a group operating under the
+  <a href="https://www.w3.org/Consortium/Patent-Policy/">W3C Patent Policy</a>.
+  W3C maintains a <a href="https://www.w3.org/2004/01/pp-impl/101196/status" rel="disclosure">public list of any patent disclosures</a> made in
+  connection with the deliverables of the group; that page also includes
+  instructions for disclosing a patent. An individual who has actual
+  knowledge of a patent which the individual believes contains
+  <a href="https://www.w3.org/Consortium/Patent-Policy/#def-essential">Essential Claim(s)</a> must disclose the information in accordance with <a href="https://www.w3.org/Consortium/Patent-Policy/#sec-Disclosure">section
+  6 of the W3C Patent Policy</a>.
+</p>
+<p>This document is governed by the <a href="https://www.w3.org/2018/Process-20180201/" id="w3c_process_revision">1 February 2018 W3C Process Document</a>. </p>
+<p></p>
+</div>
+
 This document builds off of the WebAssembly specification [[WEBASSEMBLY]] and the WebAssembly JavaScript embedding [[WASMJS]].
 
 <h2 id="streaming-modules">Streaming Module Compilation and Instantiation</h2>

From 4653fc002a510b4f207af07f2c7c61b13dba78d9 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 13 Feb 2018 10:25:37 +0100
Subject: [PATCH 149/329] [spec] Cite mechanisation paper (#666)

Cite Conrad Watt's CPP 2018 paper describing the Isabelle mechanisation of the soundness proof.
---
 document/core/appendix/properties.rst | 6 +++++-
 document/core/util/macros.def         | 3 +++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index b22bd8687..a584516e8 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -709,7 +709,7 @@ Theorems
 ~~~~~~~~
 
 Given the definition of :ref:`valid configurations <valid-config>`,
-the standard soundness theorems hold.
+the standard soundness theorems hold. [#cite-cpp2018]_
 
 **Theorem (Preservation).**
 If a :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]` (i.e., :math:`\vdashconfig S;T : [t^\ast]`),
@@ -739,3 +739,7 @@ Consequently, given a :ref:`valid store <valid-store>`, no computation defined b
 .. [#cite-pldi2017]
    The formalization and theorems are derived from the following article:
    Andreas Haas, Andreas Rossberg, Derek Schuff, Ben Titzer, Dan Gohman, Luke Wagner, Alon Zakai, JF Bastien, Michael Holman. |PLDI2017|_. Proceedings of the 38th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2017). ACM 2017.
+
+.. [#cite-cpp2018]
+   A machine-verified version of the formalization and soundness proof is described in the following article:
+   Conrad Watt. |CPP2018|_. Proceedings of the 7th ACM SIGPLAN Conference on Certified Programs and Proofs (CPP 2018). ACM 2018.
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index ebb373fcb..2216694b1 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -38,6 +38,9 @@
 .. |PLDI2017| replace:: Bringing the Web up to Speed with WebAssembly
 .. _PLDI2017: https://dl.acm.org/citation.cfm?doid=3062341.3062363
 
+.. |CPP2018| replace:: Mechanising and Verifying the WebAssembly Specification
+.. _CPP2018: https://dl.acm.org/citation.cfm?id=3167082
+
 .. |TAPL| replace:: Types and Programming Languages
 .. _TAPL: https://www.cis.upenn.edu/~bcpierce/tapl/
 

From 22e836bedc250e40a895c2c52fbf93ff06a73e48 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Tue, 13 Feb 2018 07:58:42 -0800
Subject: [PATCH 150/329] Fixing broken formatting in katex version. (#672)

---
 document/core/header.include    | 1 -
 document/js-api/header.include  | 1 -
 document/travis-deploy.sh       | 1 +
 document/web-api/header.include | 1 -
 4 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/document/core/header.include b/document/core/header.include
index 6ea66915e..d99feba0a 100644
--- a/document/core/header.include
+++ b/document/core/header.include
@@ -6,7 +6,6 @@
   <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
   <meta name="w3c-status" content="[STATUS]">
   <meta name="abstract" content="[ABSTRACTATTR]">
-  <link href="../default.css" rel=stylesheet type="text/css">
   <link href="[W3C-STYLESHEET-URL]" rel=stylesheet type="text/css">
 </head>
 <body class="h-entry">
diff --git a/document/js-api/header.include b/document/js-api/header.include
index 6ea66915e..d99feba0a 100644
--- a/document/js-api/header.include
+++ b/document/js-api/header.include
@@ -6,7 +6,6 @@
   <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
   <meta name="w3c-status" content="[STATUS]">
   <meta name="abstract" content="[ABSTRACTATTR]">
-  <link href="../default.css" rel=stylesheet type="text/css">
   <link href="[W3C-STYLESHEET-URL]" rel=stylesheet type="text/css">
 </head>
 <body class="h-entry">
diff --git a/document/travis-deploy.sh b/document/travis-deploy.sh
index 323c1eba2..8a47dbff7 100755
--- a/document/travis-deploy.sh
+++ b/document/travis-deploy.sh
@@ -9,6 +9,7 @@ TARGET_BRANCH="gh-pages"
 
 function doCompile {
   # TODO(littledan): Integrate with document/deploy.sh
+  (cd document; make clean)
   (cd document; make)
 }
 
diff --git a/document/web-api/header.include b/document/web-api/header.include
index 6ea66915e..d99feba0a 100644
--- a/document/web-api/header.include
+++ b/document/web-api/header.include
@@ -6,7 +6,6 @@
   <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
   <meta name="w3c-status" content="[STATUS]">
   <meta name="abstract" content="[ABSTRACTATTR]">
-  <link href="../default.css" rel=stylesheet type="text/css">
   <link href="[W3C-STYLESHEET-URL]" rel=stylesheet type="text/css">
 </head>
 <body class="h-entry">

From 28b90a79b8a7167dfc44de1028a8b9c9c43c2f2c Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Tue, 13 Feb 2018 09:43:57 -0800
Subject: [PATCH 151/329] Actually clobber travis push repo to get subdir
 update. (#681)

---
 document/travis-deploy.sh | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/document/travis-deploy.sh b/document/travis-deploy.sh
index 8a47dbff7..0e361db1a 100755
--- a/document/travis-deploy.sh
+++ b/document/travis-deploy.sh
@@ -35,21 +35,27 @@ chmod 600 deploy_key
 eval `ssh-agent -s`
 ssh-add deploy_key || true
 
-# Clone the existing gh-pages for this repo into out/
-# Create a new empty branch if gh-pages doesn't exist yet (should only happen on first deply)
+# Clone the existing gh-pages for this repo into _build/
+# Create a new empty branch if gh-pages doesn't exist yet (should only happen
+# on first deploy).
+# Ensure no checkout in _build.
+rm -rf document/_build
+# Clone a second checkout of our repo to _build.
 git clone $REPO document/_build
 (
+  # Checkout a parentless branch of gh-pages.
   cd document/_build
   git checkout $TARGET_BRANCH || git checkout --orphan $TARGET_BRANCH
 
-  # Clean out existing contents
-  git reset --hard
+  # Clean out existing contents (to be replaced with output from the build
+  # that happens after this).
+  rm -rf ./*
 )
 
-# Run our compile script
+# Run our compile script (output into _build).
 doCompile
 
-# Now let's go have some fun with the cloned repo
+# Set user info on the gh-pages repo in _build.
 cd document/_build
 git config user.name "Travis CI"
 git config user.email "$COMMIT_AUTHOR_EMAIL"

From 4a3b76c640ddfd1906a3a52835cda149856659e0 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Tue, 13 Feb 2018 10:53:07 -0800
Subject: [PATCH 152/329] Turn on logging to help debug travis failures. (#682)

---
 document/travis-deploy.sh | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/document/travis-deploy.sh b/document/travis-deploy.sh
index 0e361db1a..e67c05589 100755
--- a/document/travis-deploy.sh
+++ b/document/travis-deploy.sh
@@ -35,6 +35,10 @@ chmod 600 deploy_key
 eval `ssh-agent -s`
 ssh-add deploy_key || true
 
+# DON'T MOVE ABOVE AS IT WILL REVEAL KEYS!
+# Turn on logging from here on.
+set -x
+
 # Clone the existing gh-pages for this repo into _build/
 # Create a new empty branch if gh-pages doesn't exist yet (should only happen
 # on first deploy).

From 21fc874bdf5b8d93ed26970831c88d3013dcad97 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Wed, 14 Feb 2018 11:41:22 +0100
Subject: [PATCH 153/329] [test] Sync JS test harness with recent changes to
 spectest module (#683)

---
 interpreter/script/js.ml | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index ebe308dd3..9d62a71a3 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -10,11 +10,17 @@ let harness =
   "'use strict';\n" ^
   "\n" ^
   "let spectest = {\n" ^
-  "  print: print || ((...xs) => console.log(...xs)),\n" ^
-  "  global: 666,\n" ^
-  "  table: " ^
-  "new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'})," ^
-  "  memory: new WebAssembly.Memory({initial: 1, maximum: 2})," ^
+  "  print: console.log.bind(console)," ^
+  "  print_i32: console.log.bind(console)," ^
+  "  print_i32_f32: console.log.bind(console)," ^
+  "  print_f64_f64: console.log.bind(console)," ^
+  "  print_f32: console.log.bind(console)," ^
+  "  print_f64: console.log.bind(console)," ^
+  "  global_i32: 666," ^
+  "  global_f32: 666," ^
+  "  global_f64: 666," ^
+  "  table: new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'})," ^
+  "  memory: new WebAssembly.Memory({initial: 1, maximum: 2})" ^
   "};\n" ^
   "\n" ^
   "let registry = {spectest};\n" ^

From 5e2e276a25f2c6337f17b7cda1a2fef09bfc8011 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Wed, 14 Feb 2018 16:12:24 +0100
Subject: [PATCH 154/329] [test] Wrap the default imports in a proxy to avoid
 TypeErrors (#685)

---
 interpreter/script/js.ml | 30 +++++++++++++++++-------------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 9d62a71a3..3165756b4 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -10,20 +10,24 @@ let harness =
   "'use strict';\n" ^
   "\n" ^
   "let spectest = {\n" ^
-  "  print: console.log.bind(console)," ^
-  "  print_i32: console.log.bind(console)," ^
-  "  print_i32_f32: console.log.bind(console)," ^
-  "  print_f64_f64: console.log.bind(console)," ^
-  "  print_f32: console.log.bind(console)," ^
-  "  print_f64: console.log.bind(console)," ^
-  "  global_i32: 666," ^
-  "  global_f32: 666," ^
-  "  global_f64: 666," ^
-  "  table: new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'})," ^
-  "  memory: new WebAssembly.Memory({initial: 1, maximum: 2})" ^
+  "  print: console.log.bind(console),\n" ^
+  "  print_i32: console.log.bind(console),\n" ^
+  "  print_i32_f32: console.log.bind(console),\n" ^
+  "  print_f64_f64: console.log.bind(console),\n" ^
+  "  print_f32: console.log.bind(console),\n" ^
+  "  print_f64: console.log.bind(console),\n" ^
+  "  global_i32: 666,\n" ^
+  "  global_f32: 666,\n" ^
+  "  global_f64: 666,\n" ^
+  "  table: new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'}),\n" ^
+  "  memory: new WebAssembly.Memory({initial: 1, maximum: 2})\n" ^
   "};\n" ^
-  "\n" ^
-  "let registry = {spectest};\n" ^
+  "let handler = {\n" ^
+  "  get(target, prop) {\n" ^
+  "    return (prop in target) ?  target[prop] : {};\n" ^
+  "  }\n" ^
+  "};\n" ^
+  "let registry = new Proxy({spectest}, handler);\n" ^
   "\n" ^
   "function register(name, instance) {\n" ^
   "  registry[name] = instance.exports;\n" ^

From 5f55a2301fc174a029ee5ecfaeda231c247e33fd Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Wed, 14 Feb 2018 08:21:12 -0800
Subject: [PATCH 155/329] Fixing when cleanup happens in travis build. (#686)

---
 document/travis-deploy.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/document/travis-deploy.sh b/document/travis-deploy.sh
index e67c05589..832d025b5 100755
--- a/document/travis-deploy.sh
+++ b/document/travis-deploy.sh
@@ -9,7 +9,6 @@ TARGET_BRANCH="gh-pages"
 
 function doCompile {
   # TODO(littledan): Integrate with document/deploy.sh
-  (cd document; make clean)
   (cd document; make)
 }
 
@@ -42,6 +41,8 @@ set -x
 # Clone the existing gh-pages for this repo into _build/
 # Create a new empty branch if gh-pages doesn't exist yet (should only happen
 # on first deploy).
+# Clean document/*/_build.
+(cd document; make clean)
 # Ensure no checkout in _build.
 rm -rf document/_build
 # Clone a second checkout of our repo to _build.

From 6700fd992e907061a6c5136c79504acbc0b3a7f7 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Wed, 14 Feb 2018 09:52:19 -0800
Subject: [PATCH 156/329] Fixing sidebar in bikeshed version of the spec.
 (#688)

---
 document/core/Makefile              | 1 -
 document/core/util/mathjax2katex.py | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/document/core/Makefile b/document/core/Makefile
index 90cd7ae0e..67ce89944 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -126,7 +126,6 @@ bikeshed:
 	$(SPHINXBUILD) -b singlehtml -c util/bikeshed \
 		$(ALLSPHINXOPTS) $(BUILDDIR)/bikeshed_singlehtml
 	mkdir -p $(BUILDDIR)/bikeshed_mathjax/
-	cp index.bs $(BUILDDIR)/bikeshed_mathjax/
 	bikeshed spec index.bs $(BUILDDIR)/bikeshed_mathjax/index.html
 	mkdir -p $(BUILDDIR)/html/bikeshed/
 	python util/mathjax2katex.py $(BUILDDIR)/bikeshed_mathjax/index.html \
diff --git a/document/core/util/mathjax2katex.py b/document/core/util/mathjax2katex.py
index ae2bab5e9..063667f00 100755
--- a/document/core/util/mathjax2katex.py
+++ b/document/core/util/mathjax2katex.py
@@ -137,8 +137,8 @@ def ExtractMath(match):
   # Bad duplicate meta.
   data = ''.join(data.rsplit(
       '<meta content="text/html; charset=utf-8" http-equiv="Content-Type">', 1))
-  # Drop all scripts.
-  data = re.sub('<script[^>]*>[^<]*</script>', '', data)
+  # Drop several scripts.
+  data = re.sub('<script[^>]*text/javascript[^>]*>[^<]*</script>', '', data)
   data = data.replace(
       '<head>\n', '<head>\n<link rel="stylesheet" href="katex/dist/katex.css">')
   # Drop duplicate title.

From 1a0384476e36251fde96c7375b23d8b6f1315079 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 14 Feb 2018 20:34:17 +0100
Subject: [PATCH 157/329] [spec/interpreter] Correct and test segment offset
 syntax (#663)

---
 document/core/text/modules.rst |  22 ++-
 test/core/data.wast            | 335 +++++++++++++++++++++++++++++++++
 test/core/elem.wast            | 280 +++++++++++++++++++++------
 test/core/memory.wast          |  84 +--------
 4 files changed, 579 insertions(+), 142 deletions(-)
 create mode 100644 test/core/data.wast

diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index d951fc92d..24e66ff81 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -489,7 +489,16 @@ When omitted, :math:`\T{0}` is assumed.
 Abbreviations
 .............
 
-As an abbreviation, element segments may also be specified inline with :ref:`table <text-table>` definitions; see the respective section.
+As an abbreviation, a single instruction may occur in place of the offset:
+
+.. math:
+   \begin{array}{llcll}
+   \production{element offset} &
+     \Tinstr &\equiv&
+     \text{(}~\text{offset}~~\Tinstr~\text{)}
+   \end{array}
+
+As another abbreviation, element segments may also be specified inline with :ref:`table <text-table>` definitions; see the respective section.
 
 
 .. index:: data, memory, memory index, expression, byte
@@ -524,7 +533,16 @@ The data is written as a :ref:`string <text-string>`, which may be split up into
 Abbreviations
 .............
 
-As an abbreviation, data segments may also be specified inline with :ref:`memory <text-mem>` definitions; see the respective section.
+As an abbreviation, a single instruction may occur in place of the offset:
+
+.. math:
+   \begin{array}{llcll}
+   \production{data offset} &
+     \Tinstr &\equiv&
+     \text{(}~\text{offset}~~\Tinstr~\text{)}
+   \end{array}
+
+As another abbreviation, data segments may also be specified inline with :ref:`memory <text-mem>` definitions; see the respective section.
 
 
 .. index:: module, type definition, function type, function, table, memory, global, element, data, start function, import, export, identifier context, identifier, name section
diff --git a/test/core/data.wast b/test/core/data.wast
new file mode 100644
index 000000000..46b95436f
--- /dev/null
+++ b/test/core/data.wast
@@ -0,0 +1,335 @@
+;; Test the data section
+
+;; Syntax
+
+(module
+  (memory $m 1)
+  (data (i32.const 0))
+  (data (i32.const 1) "a" "" "bcd")
+  (data (offset (i32.const 0)))
+  (data (offset (i32.const 0)) "" "a" "bc" "")
+  (data 0 (i32.const 0))
+  (data 0x0 (i32.const 1) "a" "" "bcd")
+  (data 0x000 (offset (i32.const 0)))
+  (data 0 (offset (i32.const 0)) "" "a" "bc" "")
+  (data $m (i32.const 0))
+  (data $m (i32.const 1) "a" "" "bcd")
+  (data $m (offset (i32.const 0)))
+  (data $m (offset (i32.const 0)) "" "a" "bc" "")
+)
+
+;; Basic use
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+  (data (i32.const 3) "b")
+  (data (i32.const 100) "cde")
+  (data (i32.const 5) "x")
+  (data (i32.const 3) "c")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+  (data (i32.const 1) "b")
+  (data (i32.const 2) "cde")
+  (data (i32.const 3) "f")
+  (data (i32.const 2) "g")
+  (data (i32.const 1) "h")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (memory 1)
+  (data (get_global 0) "a")
+)
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 1))
+  (data (get_global 0) "a")
+)
+
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (memory 1)
+  (data (get_global $g) "a")
+)
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 1))
+  (data (get_global $g) "a")
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (module (memory 1) (data (get_global 0) "a") (global i32 (i32.const 0)))
+;; (module (memory 1) (data (get_global $g) "a") (global $g i32 (i32.const 0)))
+
+;; Corner cases
+
+(module
+  (memory 1)
+  (data (i32.const 0) "a")
+  (data (i32.const 0xffff) "b")
+)
+(module
+  (import "spectest" "memory" (memory 1))
+  (data (i32.const 0) "a")
+  (data (i32.const 0xffff) "b")
+)
+
+(module
+  (memory 2)
+  (data (i32.const 0x1_ffff) "a")
+)
+
+(module
+  (memory 0)
+  (data (i32.const 0))
+)
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0))
+)
+
+(module
+  (memory 0 0)
+  (data (i32.const 0))
+)
+
+(module
+  (memory 1)
+  (data (i32.const 0x1_0000) "")
+)
+
+(module
+  (memory 0)
+  (data (i32.const 0) "" "")
+)
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0) "" "")
+)
+
+(module
+  (memory 0 0)
+  (data (i32.const 0) "" "")
+)
+
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))
+  (data (i32.const 0) "a")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 0))
+  (data (get_global 0) "a")
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (import "spectest" "memory" (memory 0 3))
+  (data (get_global 0) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0))
+  (data (i32.const 1) "a")
+)
+
+(module
+  (import "spectest" "memory" (memory 0 3))
+  (data (i32.const 1) "a")
+)
+
+;; Invalid bounds for data
+
+(assert_unlinkable
+  (module
+    (memory 0)
+    (data (i32.const 0) "a")
+  )
+  "data segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (memory 0 0)
+    (data (i32.const 0) "a")
+  )
+  "data segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (memory 0 1)
+    (data (i32.const 0) "a")
+  )
+  "data segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (memory 0)
+    (data (i32.const 1))
+  )
+  "data segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (memory 0 1)
+    (data (i32.const 1))
+  )
+  "data segment does not fit"
+)
+
+;; This seems to cause a time-out on Travis.
+(;assert_unlinkable
+  (module
+    (memory 0x10000)
+    (data (i32.const 0xffffffff) "ab")
+  )
+  ""  ;; either out of memory or segment does not fit
+;)
+
+(assert_unlinkable
+  (module
+    (global (import "spectest" "global_i32") i32)
+    (memory 0)
+    (data (get_global 0) "a")
+  )
+  "data segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (memory 1 2)
+    (data (i32.const 0x1_0000) "a")
+  )
+  "data segment does not fit"
+)
+(assert_unlinkable
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const 0x1_0000) "a")
+  )
+  "data segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (memory 2)
+    (data (i32.const 0x2_0000) "a")
+  )
+  "data segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (memory 2 3)
+    (data (i32.const 0x2_0000) "a")
+  )
+  "data segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (memory 1)
+    (data (i32.const -1) "a")
+  )
+  "data segment does not fit"
+)
+(assert_unlinkable
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const -1) "a")
+  )
+  "data segment does not fit"
+)
+
+(assert_unlinkable
+  (module
+    (memory 2)
+    (data (i32.const -100) "a")
+  )
+  "data segment does not fit"
+)
+(assert_unlinkable
+  (module
+    (import "spectest" "memory" (memory 1))
+    (data (i32.const -100) "a")
+  )
+  "data segment does not fit"
+)
+
+;; Data without memory
+
+(assert_invalid
+  (module
+    (data (i32.const 0) "")
+  )
+  "unknown memory 0"
+)
+
+;; Invalid offsets
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (i64.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (i32.ctz (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (nop))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (nop) (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (memory 1)
+    (data (offset (i32.const 0) (nop)))
+  )
+  "constant expression required"
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (assert_invalid
+;;   (module (memory 1) (data (get_global $g)) (global $g (mut i32) (i32.const 0)))
+;;   "constant expression required"
+;; )
diff --git a/test/core/elem.wast b/test/core/elem.wast
index da28f3f95..3c204c073 100644
--- a/test/core/elem.wast
+++ b/test/core/elem.wast
@@ -1,15 +1,67 @@
 ;; Test the element section
 
+;; Syntax
+(module
+  (table $t 10 anyfunc)
+  (func $f)
+  (elem (i32.const 0))
+  (elem (i32.const 0) $f $f)
+  (elem (offset (i32.const 0)))
+  (elem (offset (i32.const 0)) $f $f)
+  (elem 0 (i32.const 0))
+  (elem 0x0 (i32.const 0) $f $f)
+  (elem 0x000 (offset (i32.const 0)))
+  (elem 0 (offset (i32.const 0)) $f $f)
+  (elem $t (i32.const 0))
+  (elem $t (i32.const 0) $f $f)
+  (elem $t (offset (i32.const 0)))
+  (elem $t (offset (i32.const 0)) $f $f)
+)
+
+;; Basic use
+
 (module
   (table 10 anyfunc)
+  (func $f)
   (elem (i32.const 0) $f)
+)
+(module
+  (import "spectest" "table" (table 10 anyfunc))
   (func $f)
+  (elem (i32.const 0) $f)
 )
 
 (module
   (table 10 anyfunc)
+  (func $f)
+  (elem (i32.const 0) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 7) $f)
+  (elem (i32.const 5) $f)
+  (elem (i32.const 3) $f)
+)
+(module
+  (import "spectest" "table" (table 10 anyfunc))
+  (func $f)
   (elem (i32.const 9) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 7) $f)
+  (elem (i32.const 3) $f)
+  (elem (i32.const 5) $f)
+)
+
+(module
+  (global (import "spectest" "global_i32") i32)
+  (table 1000 anyfunc)
   (func $f)
+  (elem (get_global 0) $f)
+)
+
+(module
+  (global $g (import "spectest" "global_i32") i32)
+  (table 1000 anyfunc)
+  (func $f)
+  (elem (get_global $g) $f)
 )
 
 (module
@@ -26,128 +78,166 @@
     (call_indirect (type $out-i32) (i32.const 9))
   )
 )
-
 (assert_return (invoke "call-7") (i32.const 65))
 (assert_return (invoke "call-9") (i32.const 66))
 
-;; Two elements target the same slot
+;; Corner cases
 
 (module
-  (type $out-i32 (func (result i32)))
   (table 10 anyfunc)
-  (elem (i32.const 9) $const-i32-a)
-  (elem (i32.const 9) $const-i32-b)
-  (func $const-i32-a (type $out-i32) (i32.const 65))
-  (func $const-i32-b (type $out-i32) (i32.const 66))
-  (func (export "call-overwritten-element") (type $out-i32)
-    (call_indirect (type $out-i32) (i32.const 9))
-  )
+  (func $f)
+  (elem (i32.const 9) $f)
+)
+(module
+  (import "spectest" "table" (table 10 anyfunc))
+  (func $f)
+  (elem (i32.const 9) $f)
 )
 
-(assert_return (invoke "call-overwritten-element") (i32.const 66))
+(module
+  (table 0 anyfunc)
+  (elem (i32.const 0))
+)
+(module
+  (import "spectest" "table" (table 0 anyfunc))
+  (elem (i32.const 0))
+)
+
+(module
+  (table 0 0 anyfunc)
+  (elem (i32.const 0))
+)
+
+(module
+  (table 20 anyfunc)
+  (elem (i32.const 20))
+)
+
+(module
+  (import "spectest" "table" (table 0 anyfunc))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 100 anyfunc))
+  (func $f)
+  (elem (i32.const 0) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 anyfunc))
+  (func $f)
+  (elem (i32.const 1) $f)
+)
+
+(module
+  (import "spectest" "table" (table 0 30 anyfunc))
+  (func $f)
+  (elem (i32.const 1) $f)
+)
 
 ;; Invalid bounds for elements
 
 (assert_unlinkable
   (module
-    (table 10 anyfunc)
-    (elem (i32.const 10) $f)
+    (table 0 anyfunc)
     (func $f)
+    (elem (i32.const 0) $f)
   )
   "elements segment does not fit"
 )
 
 (assert_unlinkable
   (module
-    (table 10 20 anyfunc)
-    (elem (i32.const 10) $f)
+    (table 0 0 anyfunc)
     (func $f)
+    (elem (i32.const 0) $f)
   )
   "elements segment does not fit"
 )
 
 (assert_unlinkable
   (module
-    (table 10 anyfunc)
-    (elem (i32.const -1) $f)
+    (table 0 1 anyfunc)
     (func $f)
+    (elem (i32.const 0) $f)
   )
   "elements segment does not fit"
 )
 
 (assert_unlinkable
   (module
-    (table 10 anyfunc)
-    (elem (i32.const -10) $f)
-    (func $f)
+    (table 0 anyfunc)
+    (elem (i32.const 1))
   )
   "elements segment does not fit"
 )
 
-;; Tests with an imported table
-
-(module
-  (import "spectest" "table" (table 10 anyfunc))
-  (elem (i32.const 0) $f)
-  (func $f)
-)
-
-(module
-  (import "spectest" "table" (table 10 anyfunc))
-  (elem (i32.const 9) $f)
-  (func $f)
-)
-
-;; Two elements target the same slot
-
-(module
-  (type $out-i32 (func (result i32)))
-  (import "spectest" "table" (table 10 anyfunc))
-  (elem (i32.const 9) $const-i32-a)
-  (elem (i32.const 9) $const-i32-b)
-  (func $const-i32-a (type $out-i32) (i32.const 65))
-  (func $const-i32-b (type $out-i32) (i32.const 66))
-  (func (export "call-overwritten-element") (type $out-i32)
-    (call_indirect (type $out-i32) (i32.const 9))
+(assert_unlinkable
+  (module
+    (table 10 anyfunc)
+    (func $f)
+    (elem (i32.const 10) $f)
   )
+  "elements segment does not fit"
 )
-
-(assert_return (invoke "call-overwritten-element") (i32.const 66))
-
-;; Invalid bounds for elements
-
 (assert_unlinkable
   (module
-  (import "spectest" "table" (table 10 anyfunc))
-    (elem (i32.const 10) $f)
+    (import "spectest" "table" (table 10 anyfunc))
     (func $f)
+    (elem (i32.const 10) $f)
   )
   "elements segment does not fit"
 )
 
 (assert_unlinkable
   (module
-  (import "spectest" "table" (table 10 20 anyfunc))
+    (table 10 20 anyfunc)
+    (func $f)
     (elem (i32.const 10) $f)
+  )
+  "elements segment does not fit"
+)
+(assert_unlinkable
+  (module
+    (import "spectest" "table" (table 10 anyfunc))
     (func $f)
+    (elem (i32.const 10) $f)
   )
   "elements segment does not fit"
 )
 
 (assert_unlinkable
   (module
-  (import "spectest" "table" (table 10 anyfunc))
+    (table 10 anyfunc)
+    (func $f)
     (elem (i32.const -1) $f)
+  )
+  "elements segment does not fit"
+)
+(assert_unlinkable
+  (module
+    (import "spectest" "table" (table 10 anyfunc))
     (func $f)
+    (elem (i32.const -1) $f)
   )
   "elements segment does not fit"
 )
 
 (assert_unlinkable
   (module
-  (import "spectest" "table" (table 10 anyfunc))
+    (table 10 anyfunc)
+    (func $f)
     (elem (i32.const -10) $f)
+  )
+  "elements segment does not fit"
+)
+(assert_unlinkable
+  (module
+    (import "spectest" "table" (table 10 anyfunc))
     (func $f)
+    (elem (i32.const -10) $f)
   )
   "elements segment does not fit"
 )
@@ -156,13 +246,89 @@
 
 (assert_invalid
   (module
-    (elem (i32.const 0) $f)
     (func $f)
+    (elem (i32.const 0) $f)
   )
   "unknown table 0"
 )
 
-;; Test element sections across multiple modules change the same table
+;; Invalid offsets
+
+(assert_invalid
+  (module
+    (table 1 anyfunc)
+    (elem (i64.const 0))
+  )
+  "type mismatch"
+)
+
+(assert_invalid
+  (module
+    (table 1 anyfunc)
+    (elem (i32.ctz (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 anyfunc)
+    (elem (nop))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 anyfunc)
+    (elem (offset (nop) (i32.const 0)))
+  )
+  "constant expression required"
+)
+
+(assert_invalid
+  (module
+    (table 1 anyfunc)
+    (elem (offset (i32.const 0) (nop)))
+  )
+  "constant expression required"
+)
+
+;; Use of internal globals in constant expressions is not allowed in MVP.
+;; (assert_invalid
+;;   (module (memory 1) (data (get_global $g)) (global $g (mut i32) (i32.const 0)))
+;;   "constant expression required"
+;; )
+
+;; Two elements target the same slot
+
+(module
+  (type $out-i32 (func (result i32)))
+  (table 10 anyfunc)
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-overwritten") (i32.const 66))
+
+(module
+  (type $out-i32 (func (result i32)))
+  (import "spectest" "table" (table 10 anyfunc))
+  (elem (i32.const 9) $const-i32-a)
+  (elem (i32.const 9) $const-i32-b)
+  (func $const-i32-a (type $out-i32) (i32.const 65))
+  (func $const-i32-b (type $out-i32) (i32.const 66))
+  (func (export "call-overwritten-element") (type $out-i32)
+    (call_indirect (type $out-i32) (i32.const 9))
+  )
+)
+(assert_return (invoke "call-overwritten-element") (i32.const 66))
+
+;; Element sections across multiple modules change the same table
 
 (module $module1
   (type $out-i32 (func (result i32)))
diff --git a/test/core/memory.wast b/test/core/memory.wast
index ee39b3a04..c6f8cd5d4 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -1,20 +1,9 @@
 ;; Test memory section structure
+
 (module (memory 0 0))
 (module (memory 0 1))
 (module (memory 1 256))
 (module (memory 0 65536))
-(module (memory 0 0) (data (i32.const 0)))
-(module (memory 0 0) (data (i32.const 0) ""))
-(module (memory 1 1) (data (i32.const 0) "a"))
-(module (memory 1 2) (data (i32.const 0) "a") (data (i32.const 65535) "b"))
-(module (memory 1 2)
-  (data (i32.const 0) "a") (data (i32.const 1) "b") (data (i32.const 2) "c")
-)
-(module (global (import "spectest" "global_i32") i32) (memory 1) (data (get_global 0) "a"))
-(module (global $g (import "spectest" "global_i32") i32) (memory 1) (data (get_global $g) "a"))
-;; Use of internal globals in constant expressions is not allowed in MVP.
-;; (module (memory 1) (data (get_global 0) "a") (global i32 (i32.const 0)))
-;; (module (memory 1) (data (get_global $g) "a") (global $g i32 (i32.const 0)))
 
 (assert_invalid (module (memory 0) (memory 0)) "multiple memories")
 (assert_invalid (module (memory (import "spectest" "memory") 0) (memory 0)) "multiple memories")
@@ -55,77 +44,6 @@
   "unknown memory"
 )
 
-(assert_invalid
-  (module (memory 1) (data (i64.const 0)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (data (i32.ctz (i32.const 0))))
-  "constant expression required"
-)
-(assert_invalid
-  (module (memory 1) (data (nop)))
-  "constant expression required"
-)
-;; Use of internal globals in constant expressions is not allowed in MVP.
-;; (assert_invalid
-;;   (module (memory 1) (data (get_global $g)) (global $g (mut i32) (i32.const 0)))
-;;   "constant expression required"
-;; )
-
-(assert_unlinkable
-  (module (memory 0 0) (data (i32.const 0) "a"))
-  "data segment does not fit"
-)
-(assert_unlinkable
-  (module (memory 0 1) (data (i32.const 0) "a"))
-  "data segment does not fit"
-)
-(assert_unlinkable
-  (module (memory 1 2) (data (i32.const -1) "a"))
-  "data segment does not fit"
-)
-(assert_unlinkable
-  (module (memory 1 2) (data (i32.const -1000) "a"))
-  "data segment does not fit"
-)
-(assert_unlinkable
-  (module (memory 1 2) (data (i32.const 0) "a") (data (i32.const 98304) "b"))
-  "data segment does not fit"
-)
-(assert_unlinkable
-  (module (memory 0 0) (data (i32.const 1) ""))
-  "data segment does not fit"
-)
-(assert_unlinkable
-  (module (memory 1) (data (i32.const 0x12000) ""))
-  "data segment does not fit"
-)
-(assert_unlinkable
-  (module (memory 1 2) (data (i32.const -1) ""))
-  "data segment does not fit"
-)
-;; This seems to cause a time-out on Travis.
-(;assert_unlinkable
-  (module (memory 0x10000) (data (i32.const 0xffffffff) "ab"))
-  ""  ;; either out of memory or segment does not fit
-;)
-(assert_unlinkable
-  (module
-    (global (import "spectest" "global_i32") i32)
-    (memory 0) (data (get_global 0) "a")
-  )
-  "data segment does not fit"
-)
-
-(module (memory 0 0) (data (i32.const 0) ""))
-(module (memory 1 1) (data (i32.const 0x10000) ""))
-(module (memory 1 2) (data (i32.const 0) "abc") (data (i32.const 0) "def"))
-(module (memory 1 2) (data (i32.const 3) "ab") (data (i32.const 0) "de"))
-(module
-  (memory 1 2)
-  (data (i32.const 0) "a") (data (i32.const 2) "b") (data (i32.const 1) "c")
-)
 
 (assert_invalid
   (module (memory 1 0))

From ed0eec5e4d0c2809714b75fd38c9afcfc9d39e8a Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Wed, 14 Feb 2018 17:29:25 -0800
Subject: [PATCH 158/329] Moving boilerplate to bikeshed, pub fixes. (#690)

---
 document/core/copyright.include    |  1 -
 document/core/footer.include       | 34 -------------------
 document/core/header.include       | 30 -----------------
 document/core/index.bs             | 48 ++++-----------------------
 document/core/util/katex_fix.patch | 50 ++++++++++++----------------
 document/js-api/copyright.include  |  1 -
 document/js-api/footer.include     | 34 -------------------
 document/js-api/header.include     | 30 -----------------
 document/js-api/index.bs           | 48 ++++-----------------------
 document/web-api/copyright.include |  1 -
 document/web-api/footer.include    | 34 -------------------
 document/web-api/header.include    | 30 -----------------
 document/web-api/index.bs          | 52 ++++++------------------------
 13 files changed, 43 insertions(+), 350 deletions(-)
 delete mode 100644 document/core/copyright.include
 delete mode 100644 document/core/footer.include
 delete mode 100644 document/core/header.include
 delete mode 100644 document/js-api/copyright.include
 delete mode 100644 document/js-api/footer.include
 delete mode 100644 document/js-api/header.include
 delete mode 100644 document/web-api/copyright.include
 delete mode 100644 document/web-api/footer.include
 delete mode 100644 document/web-api/header.include

diff --git a/document/core/copyright.include b/document/core/copyright.include
deleted file mode 100644
index 90c193831..000000000
--- a/document/core/copyright.include
+++ /dev/null
@@ -1 +0,0 @@
-<a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright">Copyright</a> © [YEAR] <a href="http://www.w3.org/"><abbr title="World Wide Web Consortium">W3C</abbr></a><sup>®</sup> (<a href="http://www.csail.mit.edu/"><abbr title="Massachusetts Institute of Technology">MIT</abbr></a>, <a href="http://www.ercim.eu/"><abbr title="European Research Consortium for Informatics and Mathematics">ERCIM</abbr></a>, <a href="http://www.keio.ac.jp/">Keio</a>, <a href="http://ev.buaa.edu.cn/">Beihang</a>). W3C <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>, <a href="http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a> and <a href="http://www.w3.org/Consortium/Legal/2015/copyright-software-and-document">permissive document license</a> rules apply.
diff --git a/document/core/footer.include b/document/core/footer.include
deleted file mode 100644
index 21c351334..000000000
--- a/document/core/footer.include
+++ /dev/null
@@ -1,34 +0,0 @@
-</main>
-<h2 id="conformance" class="no-ref no-num">
-Conformance</h2>
-
-<h3 id="document-conventions">
-Document conventions</h3>
-
-	<p>Conformance requirements are expressed with a combination of
-	descriptive assertions and RFC 2119 terminology. The key words “MUST”,
-	“MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”,
-	“RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this
-	document are to be interpreted as described in RFC 2119.
-	However, for readability, these words do not appear in all uppercase
-	letters in this specification.
-
-	<p>All of the text of this specification is normative except sections
-	explicitly marked as non-normative, examples, and notes. [[!RFC2119]]
-
-	<p>Examples in this specification are introduced with the words “for example”
-	or are set apart from the normative text with <code>class="example"</code>,
-	like this:
-
-	<div class="example">
-		<p>This is an example of an informative example.
-	</div>
-
-	<p>Informative notes begin with the word “Note” and are set apart from the
-	normative text with <code>class="note"</code>, like this:
-
-	<p class="note">Note, this is an informative note.
-
-</body>
-<script src="https://www.w3.org/scripts/TR/2016/fixup.js"></script>
-</html>
diff --git a/document/core/header.include b/document/core/header.include
deleted file mode 100644
index d99feba0a..000000000
--- a/document/core/header.include
+++ /dev/null
@@ -1,30 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-  <title>[TITLE]</title>
-  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
-  <meta name="w3c-status" content="[STATUS]">
-  <meta name="abstract" content="[ABSTRACTATTR]">
-  <link href="[W3C-STYLESHEET-URL]" rel=stylesheet type="text/css">
-</head>
-<body class="h-entry">
-<div class="head">
-  <p data-fill-with="logo"></p>
-  <h1 id="title" class="p-name no-ref">[TITLE]</h1>
-  <h2 id="subtitle" class="no-num no-toc no-ref">[LONGSTATUS],
-    <time class="dt-updated" datetime="[ISODATE]">[DATE]</time></h2>
-  <div data-fill-with="spec-metadata"></div>
-  <div data-fill-with="warning"></div>
-  <p class='copyright' data-fill-with='copyright'></p>
-  <hr title="Separator for header">
-</div>
-
-<div class="p-summary" data-fill-with="abstract"></div>
-
-<h2 class='no-num no-toc no-ref' id='status'>Status of this document</h2>
-<div data-fill-with="status"></div>
-<div data-fill-with="at-risk"></div>
-
-<nav data-fill-with="table-of-contents" id="toc"></nav>
-<main>
diff --git a/document/core/index.bs b/document/core/index.bs
index 750ec2fc6..bc95ed9bf 100644
--- a/document/core/index.bs
+++ b/document/core/index.bs
@@ -1,15 +1,16 @@
 <pre class='metadata'>
 Title: WebAssembly Core Specification
 Shortname: wasm-core
-Group: WebAssembly Working Group
-Status: w3c/FPWD
+Group: wasm
+Status: FPWD
 Level: 1
-TR: https://www.w3.org/TR/2018/WD-wasm-core-1/
-ED: https://webassembly.github.io/spec/core/
+TR: https://www.w3.org/TR/wasm-core-1/
+ED: https://webassembly.github.io/spec/core/bikeshed/
 Editor: Andreas Rossberg (Dfinity Stiftung)
 Repository: WebAssembly/spec
 Markup Shorthands: css no, markdown yes, algorithm no
-Abstract: This document describes version 1.0 of the core WebAssembly standard, a safe, portable, low-level code format designed for efficient execution and compact representation. To be used in coordination with the <a href="https://www.w3.org/TR/2018/WD-wasm-js-api-1/">WebAssembly JavaScript Interface</a> and the <a href="https://www.w3.org/TR/2018/WD-wasm-web-api-1/">WebAssembly Web API</a>.
+Abstract: This document describes version 1.0 of the core WebAssembly standard, a safe, portable, low-level code format designed for efficient execution and compact representation.
+Prepare For TR: true
 </pre>
 
 <pre class='biblio'>
@@ -23,43 +24,6 @@ Abstract: This document describes version 1.0 of the core WebAssembly standard,
 }
 </pre>
 
-<div boilerplate='status'>
-<p>
-  This section describes the status of this document at the time of
-  its publication. Other documents may supersede this document. A list of
-  current W3C publications and the latest revision of this technical report
-  can be found in the <a href="https://www.w3.org/TR/">W3C technical reports
-  index at https://www.w3.org/TR/</a>.
-</p>
-
-<p>This document is a <b>First Public Working Draft</b>.</p>
-<p>
-  Publication as a First Public Working Draft does not imply endorsement
-  by the W3C Membership. This is a draft document and may be updated,
-  replaced or obsoleted by other documents at any time. It is inappropriate
-  to cite this document as other than work in progress.
-</p>
-<p>
-  <a href="https://github.com/WebAssembly/spec/issues">GitHub Issues</a>
-  are preferred for discussion of this specification.
-  All issues and comments are
-  <a href="https://github.com/WebAssembly/spec/issues?utf8=%E2%9C%93&q=is%3Aissue++">archived</a>.
-</p>
-<p>This document was produced by the <a href="https://www.w3.org/wasm/">WebAssembly Working Group</a>.</p>
-<p>This document was produced by a group operating under the
-  <a href="https://www.w3.org/Consortium/Patent-Policy/">W3C Patent Policy</a>.
-  W3C maintains a <a href="https://www.w3.org/2004/01/pp-impl/101196/status" rel="disclosure">public list of any patent disclosures</a> made in
-  connection with the deliverables of the group; that page also includes
-  instructions for disclosing a patent. An individual who has actual
-  knowledge of a patent which the individual believes contains
-  <a href="https://www.w3.org/Consortium/Patent-Policy/#def-essential">Essential Claim(s)</a> must disclose the information in accordance with <a href="https://www.w3.org/Consortium/Patent-Policy/#sec-Disclosure">section
-  6 of the W3C Patent Policy</a>.
-</p>
-<p>This document is governed by the <a href="https://www.w3.org/2018/Process-20180201/" id="w3c_process_revision">1 February 2018 W3C Process Document</a>. </p>
-<p></p>
-
-</div>
-
 <pre class=include>
 path: _build/bikeshed_singlehtml/index.html
 </pre>
diff --git a/document/core/util/katex_fix.patch b/document/core/util/katex_fix.patch
index 7cfe9580e..b39407283 100644
--- a/document/core/util/katex_fix.patch
+++ b/document/core/util/katex_fix.patch
@@ -1,29 +1,21 @@
-diff --git a/dist/katex.css b/dist/katex.css
-index f0c5040..0edb55a 100644
---- a/dist/katex.css
-+++ b/dist/katex.css
-@@ -111,12 +111,14 @@
-   font-style: normal;
- }
- .katex-display {
-+  /*
-   display: block;
-   margin: 1em 0;
-   text-align: center;
-+  */
- }
- .katex-display > .katex {
--  display: inline-block;
-+/*  display: inline-block; */
-   text-align: initial;
- }
- .katex {
-@@ -130,7 +132,7 @@
-   -ms-high-contrast-adjust: none !important;
- }
- .katex .katex-html {
--  display: inline-block;
-+/*  display: inline-block; */
- }
- .katex .katex-mathml {
-   position: absolute;
+113a114
+>   /*
+116a118
+>   */
+119c121
+<   display: inline-block;
+---
+> /*  display: inline-block; */
+127d128
+<   text-rendering: auto;
+133c134
+<   display: inline-block;
+---
+> /*  display: inline-block; */
+1059,1064d1059
+< }
+< .katex svg path {
+<   fill: currentColor;
+< }
+< .katex svg line {
+<   stroke: currentColor;
diff --git a/document/js-api/copyright.include b/document/js-api/copyright.include
deleted file mode 100644
index 90c193831..000000000
--- a/document/js-api/copyright.include
+++ /dev/null
@@ -1 +0,0 @@
-<a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright">Copyright</a> © [YEAR] <a href="http://www.w3.org/"><abbr title="World Wide Web Consortium">W3C</abbr></a><sup>®</sup> (<a href="http://www.csail.mit.edu/"><abbr title="Massachusetts Institute of Technology">MIT</abbr></a>, <a href="http://www.ercim.eu/"><abbr title="European Research Consortium for Informatics and Mathematics">ERCIM</abbr></a>, <a href="http://www.keio.ac.jp/">Keio</a>, <a href="http://ev.buaa.edu.cn/">Beihang</a>). W3C <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>, <a href="http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a> and <a href="http://www.w3.org/Consortium/Legal/2015/copyright-software-and-document">permissive document license</a> rules apply.
diff --git a/document/js-api/footer.include b/document/js-api/footer.include
deleted file mode 100644
index 21c351334..000000000
--- a/document/js-api/footer.include
+++ /dev/null
@@ -1,34 +0,0 @@
-</main>
-<h2 id="conformance" class="no-ref no-num">
-Conformance</h2>
-
-<h3 id="document-conventions">
-Document conventions</h3>
-
-	<p>Conformance requirements are expressed with a combination of
-	descriptive assertions and RFC 2119 terminology. The key words “MUST”,
-	“MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”,
-	“RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this
-	document are to be interpreted as described in RFC 2119.
-	However, for readability, these words do not appear in all uppercase
-	letters in this specification.
-
-	<p>All of the text of this specification is normative except sections
-	explicitly marked as non-normative, examples, and notes. [[!RFC2119]]
-
-	<p>Examples in this specification are introduced with the words “for example”
-	or are set apart from the normative text with <code>class="example"</code>,
-	like this:
-
-	<div class="example">
-		<p>This is an example of an informative example.
-	</div>
-
-	<p>Informative notes begin with the word “Note” and are set apart from the
-	normative text with <code>class="note"</code>, like this:
-
-	<p class="note">Note, this is an informative note.
-
-</body>
-<script src="https://www.w3.org/scripts/TR/2016/fixup.js"></script>
-</html>
diff --git a/document/js-api/header.include b/document/js-api/header.include
deleted file mode 100644
index d99feba0a..000000000
--- a/document/js-api/header.include
+++ /dev/null
@@ -1,30 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-  <title>[TITLE]</title>
-  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
-  <meta name="w3c-status" content="[STATUS]">
-  <meta name="abstract" content="[ABSTRACTATTR]">
-  <link href="[W3C-STYLESHEET-URL]" rel=stylesheet type="text/css">
-</head>
-<body class="h-entry">
-<div class="head">
-  <p data-fill-with="logo"></p>
-  <h1 id="title" class="p-name no-ref">[TITLE]</h1>
-  <h2 id="subtitle" class="no-num no-toc no-ref">[LONGSTATUS],
-    <time class="dt-updated" datetime="[ISODATE]">[DATE]</time></h2>
-  <div data-fill-with="spec-metadata"></div>
-  <div data-fill-with="warning"></div>
-  <p class='copyright' data-fill-with='copyright'></p>
-  <hr title="Separator for header">
-</div>
-
-<div class="p-summary" data-fill-with="abstract"></div>
-
-<h2 class='no-num no-toc no-ref' id='status'>Status of this document</h2>
-<div data-fill-with="status"></div>
-<div data-fill-with="at-risk"></div>
-
-<nav data-fill-with="table-of-contents" id="toc"></nav>
-<main>
diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index d0a17df30..e67679599 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -1,15 +1,16 @@
 <pre class='metadata'>
 Title: WebAssembly JavaScript Interface
 Shortname: wasm-js-api
-Group: WebAssembly Working Group
-Status: w3c/FPWD
+Group: wasm
+Status: FPWD
 Level: 1
-TR: https://www.w3.org/TR/2018/WD-wasm-js-api-1/
+TR: https://www.w3.org/TR/wasm-js-api-1/
 ED: https://webassembly.github.io/spec/js-api/
 Editor: Daniel Ehrenberg (Igalia)
 Repository: WebAssembly/spec
 Markup Shorthands: css no, markdown yes
-Abstract: This document provides an explicit JavaScript API for interacting with WebAssembly. To be used in coordination with the <a href="https://www.w3.org/TR/2018/WD-wasm-core-1/">Core WebAssembly Specification</a> and the <a href="https://www.w3.org/TR/2018/WD-wasm-web-api-1/">WebAssembly Web API</a>.
+Abstract: This document provides an explicit JavaScript API for interacting with WebAssembly.
+Prepare For TR: true
 </pre>
 
 <pre class='biblio'>
@@ -83,7 +84,7 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMASCRIPT
         text: the Number value; url: sec-ecmascript-language-types-number-type
         text: NumberToRawBytes; url: sec-numbertorawbytes
         text: Built-in Function Objects; url: sec-built-in-function-objects
-urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: dfn
+urlPrefix: https://webassembly.github.io/spec/core/multipage/; spec: WebAssembly; type: dfn
     url: valid/modules.html#valid-module
         text: valid
         text: WebAssembly module validation
@@ -162,43 +163,9 @@ spec:infra; type:dfn; for:set; text:append
 spec:ecmascript; type:exception; for:ECMAScript; text:TypeError
 spec:ecmascript; type:exception; for:ECMAScript; text:RangeError
 spec:ecmascript; type:interface; for:ECMAScript; text:ArrayBuffer
+spec:promises-guide-1; type:dfn; text:resolve
 </pre>
 
-<div boilerplate='status'>
-<p>
-  This section describes the status of this document at the time of
-  its publication. Other documents may supersede this document. A list of
-  current W3C publications and the latest revision of this technical report
-  can be found in the <a href="https://www.w3.org/TR/">W3C technical reports
-  index at https://www.w3.org/TR/</a>.
-</p>
-
-<p>This document is a <b>First Public Working Draft</b>.</p>
-<p>
-  Publication as a First Public Working Draft does not imply endorsement
-  by the W3C Membership. This is a draft document and may be updated,
-  replaced or obsoleted by other documents at any time. It is inappropriate
-  to cite this document as other than work in progress.
-</p>
-<p>
-  <a href="https://github.com/WebAssembly/spec/issues">GitHub Issues</a>
-  are preferred for discussion of this specification.
-  All issues and comments are
-  <a href="https://github.com/WebAssembly/spec/issues?utf8=%E2%9C%93&q=is%3Aissue++">archived</a>.
-</p>
-<p>This document was produced by the <a href="https://www.w3.org/wasm/">WebAssembly Working Group</a>.</p>
-<p>This document was produced by a group operating under the
-  <a href="https://www.w3.org/Consortium/Patent-Policy/">W3C Patent Policy</a>.
-  W3C maintains a <a href="https://www.w3.org/2004/01/pp-impl/101196/status" rel="disclosure">public list of any patent disclosures</a> made in
-  connection with the deliverables of the group; that page also includes
-  instructions for disclosing a patent. An individual who has actual
-  knowledge of a patent which the individual believes contains
-  <a href="https://www.w3.org/Consortium/Patent-Policy/#def-essential">Essential Claim(s)</a> must disclose the information in accordance with <a href="https://www.w3.org/Consortium/Patent-Policy/#sec-Disclosure">section
-  6 of the W3C Patent Policy</a>.
-</p>
-<p>This document is governed by the <a href="https://www.w3.org/2018/Process-20180201/" id="w3c_process_revision">1 February 2018 W3C Process Document</a>. </p>
-<p></p>
-
 Issue: This document is an early draft, porting <a href="https://github.com/WebAssembly/design/blob/master/JS.md">the official JS/WebAssembly interface specification</a> to WebIDL and Bikeshed. It should currently not be used as the WebAssembly specification.
 
 This API is, initially, the only API for accessing WebAssembly [[WEBASSEMBLY]] from the web platform, through a bridge to explicitly construct modules from ECMAScript [[ECMASCRIPT]].
@@ -211,7 +178,6 @@ any other Web API that loads ES6 modules via URL—as part of
 Note: WebAssembly JS API declaration file for TypeScript can be found [here](https://github.com/01alchemist/webassembly-types/blob/master/webassembly.d.ts) which enable autocompletion and make TypeScript compiler happy.
 
 <p>See the [[#issues-index]] for complete list of issues.</p>
-</div>
 
 <h2 id="sample">Sample API Usage</h2>
 
diff --git a/document/web-api/copyright.include b/document/web-api/copyright.include
deleted file mode 100644
index 90c193831..000000000
--- a/document/web-api/copyright.include
+++ /dev/null
@@ -1 +0,0 @@
-<a href="http://www.w3.org/Consortium/Legal/ipr-notice#Copyright">Copyright</a> © [YEAR] <a href="http://www.w3.org/"><abbr title="World Wide Web Consortium">W3C</abbr></a><sup>®</sup> (<a href="http://www.csail.mit.edu/"><abbr title="Massachusetts Institute of Technology">MIT</abbr></a>, <a href="http://www.ercim.eu/"><abbr title="European Research Consortium for Informatics and Mathematics">ERCIM</abbr></a>, <a href="http://www.keio.ac.jp/">Keio</a>, <a href="http://ev.buaa.edu.cn/">Beihang</a>). W3C <a href="http://www.w3.org/Consortium/Legal/ipr-notice#Legal_Disclaimer">liability</a>, <a href="http://www.w3.org/Consortium/Legal/ipr-notice#W3C_Trademarks">trademark</a> and <a href="http://www.w3.org/Consortium/Legal/2015/copyright-software-and-document">permissive document license</a> rules apply.
diff --git a/document/web-api/footer.include b/document/web-api/footer.include
deleted file mode 100644
index 21c351334..000000000
--- a/document/web-api/footer.include
+++ /dev/null
@@ -1,34 +0,0 @@
-</main>
-<h2 id="conformance" class="no-ref no-num">
-Conformance</h2>
-
-<h3 id="document-conventions">
-Document conventions</h3>
-
-	<p>Conformance requirements are expressed with a combination of
-	descriptive assertions and RFC 2119 terminology. The key words “MUST”,
-	“MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”,
-	“RECOMMENDED”, “MAY”, and “OPTIONAL” in the normative parts of this
-	document are to be interpreted as described in RFC 2119.
-	However, for readability, these words do not appear in all uppercase
-	letters in this specification.
-
-	<p>All of the text of this specification is normative except sections
-	explicitly marked as non-normative, examples, and notes. [[!RFC2119]]
-
-	<p>Examples in this specification are introduced with the words “for example”
-	or are set apart from the normative text with <code>class="example"</code>,
-	like this:
-
-	<div class="example">
-		<p>This is an example of an informative example.
-	</div>
-
-	<p>Informative notes begin with the word “Note” and are set apart from the
-	normative text with <code>class="note"</code>, like this:
-
-	<p class="note">Note, this is an informative note.
-
-</body>
-<script src="https://www.w3.org/scripts/TR/2016/fixup.js"></script>
-</html>
diff --git a/document/web-api/header.include b/document/web-api/header.include
deleted file mode 100644
index d99feba0a..000000000
--- a/document/web-api/header.include
+++ /dev/null
@@ -1,30 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-  <title>[TITLE]</title>
-  <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
-  <meta name="w3c-status" content="[STATUS]">
-  <meta name="abstract" content="[ABSTRACTATTR]">
-  <link href="[W3C-STYLESHEET-URL]" rel=stylesheet type="text/css">
-</head>
-<body class="h-entry">
-<div class="head">
-  <p data-fill-with="logo"></p>
-  <h1 id="title" class="p-name no-ref">[TITLE]</h1>
-  <h2 id="subtitle" class="no-num no-toc no-ref">[LONGSTATUS],
-    <time class="dt-updated" datetime="[ISODATE]">[DATE]</time></h2>
-  <div data-fill-with="spec-metadata"></div>
-  <div data-fill-with="warning"></div>
-  <p class='copyright' data-fill-with='copyright'></p>
-  <hr title="Separator for header">
-</div>
-
-<div class="p-summary" data-fill-with="abstract"></div>
-
-<h2 class='no-num no-toc no-ref' id='status'>Status of this document</h2>
-<div data-fill-with="status"></div>
-<div data-fill-with="at-risk"></div>
-
-<nav data-fill-with="table-of-contents" id="toc"></nav>
-<main>
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 5ed74a971..7ef0450e9 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -1,15 +1,16 @@
 <pre class='metadata'>
 Title: WebAssembly Web API
 Shortname: wasm-web-api
-Group: WebAssembly Working Group
-Status: w3c/FPWD
+Group: wasm
+Status: FPWD
 Level: 1
-TR: https://www.w3.org/TR/2018/WD-wasm-web-api-1/
+TR: https://www.w3.org/TR/wasm-web-api-1/
 ED: https://webassembly.github.io/spec/web-api/
 Editor: Daniel Ehrenberg (Igalia)
 Repository: WebAssembly/spec
-Abstract: This document describes the integration of WebAssembly with the broader web platform. To be used in coordination with the <a href="https://www.w3.org/TR/2018/WD-wasm-core-1/">WebAssembly Core Specification</a> and the <a href="https://www.w3.org/TR/2018/WD-wasm-js-api-1/">WebAssembly JavaScript Interface</a>.
+Abstract: This document describes the integration of WebAssembly with the broader web platform.
 Markup Shorthands: css no, markdown yes
+Prepare For TR: true
 </pre>
 
 <pre class='biblio'>
@@ -41,9 +42,10 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMA-262
         text: TypeError; url: sec-native-error-types-used-in-this-standard-typeerror
     type: interface
         text: ArrayBuffer; url: sec-arraybuffer-objects
-urlPrefix: https://webassembly.github.io/spec/; spec: WebAssembly; type: dfn
+urlPrefix: https://webassembly.github.io/spec/core/multipage/; spec: WebAssembly; type: dfn
     text: function index; url: syntax/modules.html#syntax-funcidx
-urlPrefix: https://webassembly.github.io/spec/document/js-api/; spec: WASMJS
+    text: "name" section; url: appendix/custom.html?highlight=name%20section#binary-namesec
+urlPrefix: https://webassembly.github.io/spec/js-api/; spec: WASMJS
     type: namespace
         text: WebAssembly; url: #namespacedef-webassembly
     type: interface
@@ -65,42 +67,6 @@ url:https://fetch.spec.whatwg.org/#concept-body-consume-body;text:consume body;t
 spec:ecma-262; type:exception; for:ECMAScript; text:TypeError
 </pre>
 
-<div boilerplate='status'>
-<p>
-  This section describes the status of this document at the time of
-  its publication. Other documents may supersede this document. A list of
-  current W3C publications and the latest revision of this technical report
-  can be found in the <a href="https://www.w3.org/TR/">W3C technical reports
-  index at https://www.w3.org/TR/</a>.
-</p>
-
-<p>This document is a <b>First Public Working Draft</b>.</p>
-<p>
-  Publication as a First Public Working Draft does not imply endorsement
-  by the W3C Membership. This is a draft document and may be updated,
-  replaced or obsoleted by other documents at any time. It is inappropriate
-  to cite this document as other than work in progress.
-</p>
-<p>
-  <a href="https://github.com/WebAssembly/spec/issues">GitHub Issues</a>
-  are preferred for discussion of this specification.
-  All issues and comments are
-  <a href="https://github.com/WebAssembly/spec/issues?utf8=%E2%9C%93&q=is%3Aissue++">archived</a>.
-</p>
-<p>This document was produced by the <a href="https://www.w3.org/wasm/">WebAssembly Working Group</a>.</p>
-<p>This document was produced by a group operating under the
-  <a href="https://www.w3.org/Consortium/Patent-Policy/">W3C Patent Policy</a>.
-  W3C maintains a <a href="https://www.w3.org/2004/01/pp-impl/101196/status" rel="disclosure">public list of any patent disclosures</a> made in
-  connection with the deliverables of the group; that page also includes
-  instructions for disclosing a patent. An individual who has actual
-  knowledge of a patent which the individual believes contains
-  <a href="https://www.w3.org/Consortium/Patent-Policy/#def-essential">Essential Claim(s)</a> must disclose the information in accordance with <a href="https://www.w3.org/Consortium/Patent-Policy/#sec-Disclosure">section
-  6 of the W3C Patent Policy</a>.
-</p>
-<p>This document is governed by the <a href="https://www.w3.org/2018/Process-20180201/" id="w3c_process_revision">1 February 2018 W3C Process Document</a>. </p>
-<p></p>
-</div>
-
 This document builds off of the WebAssembly specification [[WEBASSEMBLY]] and the WebAssembly JavaScript embedding [[WASMJS]].
 
 <h2 id="streaming-modules">Streaming Module Compilation and Instantiation</h2>
@@ -207,7 +173,7 @@ While the "name" property of an [=Exported Function=] instance
 is specified by the [[WASMJS|JS API]], synthesized function names are also
 displayed in other contexts like call stacks in debuggers and string representations
 of stack traces.
-If a WebAssembly module contains a ["name" section](BinaryEncoding.md#name-section),
+If a WebAssembly module contains a [="name" section=],
 these names should be used to synthesize a function name as follows:
 * If a function name subsection is present, the displayed name should
       be `${module_name}.${function_name}` or `${function_name}`, depending

From e1474b92e8bd768d6244a11437375753805cd558 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Wed, 14 Feb 2018 20:38:11 -0800
Subject: [PATCH 159/329] Make katex conversion more flexible, fix progress
 counter. (#691)

---
 document/core/util/mathjax2katex.py | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/document/core/util/mathjax2katex.py b/document/core/util/mathjax2katex.py
index 063667f00..a4ccf2b8d 100755
--- a/document/core/util/mathjax2katex.py
+++ b/document/core/util/mathjax2katex.py
@@ -97,7 +97,7 @@ def Main():
 
   def ExtractMath(match):
     fixups.append(
-        (match.group(1), match.group(2), match.group(3),
+        (match.group(1), match.group(2), match.group(3), match.group(4),
          match.start(), match.end()))
     return 'x' * len(match.group())
 
@@ -161,20 +161,22 @@ def ExtractMath(match):
 
   # Pull out math fragments.
   data = re.sub(
-      'class="([^"]*)math"[^>]*>((?:[ ]*<span[^>]*>[^<]*</span>)*)([^<]*)<',
+      'class="([^"]*)math([^"]*)"[^>]*>'
+      '((?:[ ]*<span[^>]*>[^<]*</span>)*)([^<]*)<',
       ExtractMath, data)
 
+  sys.stderr.write('Processing %d fragments.\n' % len(fixups))
+
   done_fixups = []
 
   def Worker():
     while True:
-      cls, spans, mth, start, end = q.get()
-      fixed = 'class="' + cls + '">' + spans + ReplaceMath(cache, mth) + '<'
+      cls_before, cls_after, spans, mth, start, end = q.get()
+      fixed = ('class="' + cls_before + ' ' + cls_after + '">' +
+               spans + ReplaceMath(cache, mth) + '<')
       done_fixups.append((start, end, fixed))
       q.task_done()
-      left = q.qsize()
-      if left > 0:
-        sys.stderr.write('Remaining: ' + str(left) + '            \r')
+      sys.stderr.write('.')
 
   q = Queue.Queue()
   for i in range(40):
@@ -194,7 +196,7 @@ def Worker():
     last = end
   result.append(data[last:])
 
-  sys.stderr.write('Done.             \n')
+  sys.stderr.write('\nProcessing Done.\n')
   sys.stdout.write(''.join(result))
   cache.close()
 

From 4ba9c41e4fada5cd1b118e2813770373b8549c4e Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Wed, 14 Feb 2018 20:50:48 -0800
Subject: [PATCH 160/329] Fix a typo on landing page. (#692)

---
 document/index.html | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/document/index.html b/document/index.html
index 2fad9247e..56b6f373e 100644
--- a/document/index.html
+++ b/document/index.html
@@ -49,8 +49,10 @@ <h3>API specifications</h3>
   <li><p><a href="web-api/index.html">Web API</a>: defines extensions to the JavaScript API made available specifically in web browsers, in particular, an interface for streaming compilation and instantiation from origin-bound <code>Response</code> types.</p></li>
   </ul>
 
-<p>Source for these documents is available
-<a href="https://github.com/WebAssembly/spec/">here</a></p>.
+<p>
+  Source for these documents is available
+  <a href="https://github.com/WebAssembly/spec/">here</a>.
+</p>
 
 </article>
 </div>

From aa3139de2ae2815fc0a091352eaaf901092c405c Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 15 Feb 2018 20:24:59 +0100
Subject: [PATCH 161/329] [spec] Clarify overloaded imports (#687)

---
 document/core/syntax/modules.rst | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index ae0f5d73b..fe2b3cd7a 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -307,7 +307,7 @@ The |MEXPORTS| component of a module defines a set of *exports* that become acce
      \EDGLOBAL~\globalidx \\
    \end{array}
 
-Each export is identified by a unique :ref:`name <syntax-name>`.
+Each export is labeled by a unique :ref:`name <syntax-name>`.
 Exportable definitions are :ref:`functions <syntax-func>`, :ref:`tables <syntax-table>`, :ref:`memories <syntax-mem>`, and :ref:`globals <syntax-global>`,
 which are referenced through a respective descriptor.
 
@@ -354,7 +354,7 @@ The |MIMPORTS| component of a module defines a set of *imports* that are require
      \IDGLOBAL~\globaltype \\
    \end{array}
 
-Each import is identified by a two-level :ref:`name <syntax-name>` space, consisting of a |IMODULE| name and a unique |INAME| for an entity within that module.
+Each import is labeled by a two-level :ref:`name <syntax-name>` space, consisting of a |IMODULE| name and a |INAME| for an entity within that module.
 Importable definitions are :ref:`functions <syntax-func>`, :ref:`tables <syntax-table>`, :ref:`memories <syntax-mem>`, and :ref:`globals <syntax-global>`.
 Each import is specified by a descriptor with a respective type that a definition provided during instantiation is required to match.
 
@@ -363,3 +363,10 @@ In each index space, the indices of imports go before the first index of any def
 
 .. note::
    In the current version of WebAssembly, only *immutable* globals may be imported.
+
+   Unlike export names, import names are not necessarily unique.
+   It is possible to import the same |IMODULE|/|INAME| pair multiple times;
+   such imports may even have different type descriptions, including different kinds of entities.
+   A module with such imports can still be instantiated depending on the specifics of how an :ref:`embedder <embedder>` allows resolving and supplying imports.
+   However, embedders are not required to support such overloading,
+   and a WebAssembly module itself cannot implement an overloaded name.

From 695f1bbde096edb7a0e76a3a8869b87f17f7c505 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 15 Feb 2018 21:30:31 +0100
Subject: [PATCH 162/329] [spec] Adjust sed hack for setting MAthJax buffer
 size (#697)

---
 document/core/Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/Makefile b/document/core/Makefile
index 67ce89944..d55d7e04a 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -100,7 +100,7 @@ html:
 	for file in `ls $(BUILDDIR)/html/multipage/*/*.html`; \
 	do \
 	  sed s:BASEDIR:..:g <$$file >$$file.out; \
-	  sed 's; <body; <script type="text/javascript">MathJax.Hub.Config({TeX: {MAXBUFFER: 30*1024}})</script><body;' \
+	  sed 's;<body; <script type="text/javascript">MathJax.Hub.Config({TeX: {MAXBUFFER: 30*1024}})</script><body;' \
 	    <$$file.out >$$file; \
 	  rm -f $$file.out; \
 	  sed s~$(OLDMATHJAX)~$(NEWMATHJAX)~g <$$file >$$file.out; \

From f43085f474ddaade1ca9519a192b247fca1bb5da Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 16 Feb 2018 11:37:49 +0100
Subject: [PATCH 163/329] [interpreter] Renamings in README to match spec
 (#701)

---
 interpreter/README.md       | 87 ++++++++++++++++++-------------------
 interpreter/text/parser.mly | 48 ++++++++++----------
 2 files changed, 67 insertions(+), 68 deletions(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 36ccf2754..af0ba2042 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -175,9 +175,6 @@ string: "(<char> | \n | \t | \\ | \' | \" | \<hex><hex> | \u{<hex>+})*"
 value:  <int> | <float>
 var:    <nat> | <name>
 
-type: i32 | i64 | f32 | f64
-elem_type: anyfunc
-
 unop:  ctz | clz | popcnt | ...
 binop: add | sub | mul | ...
 relop: eq | ne | lt | ...
@@ -186,27 +183,29 @@ offset: offset=<nat>
 align: align=(1|2|4|8|...)
 cvtop: trunc_s | trunc_u | extend_s | extend_u | ...
 
-block_sig : ( result <type>* )*
-func_sig:   ( type <var> )? <param>* <result>*
-global_sig: <type> | ( mut <type> )
-table_sig:  <nat> <nat>? <elem_type>
-memory_sig: <nat> <nat>?
+val_type: i32 | i64 | f32 | f64
+elem_type: anyfunc
+block_type : ( result <val_type>* )*
+func_type:   ( type <var> )? <param>* <result>*
+global_type: <val_type> | ( mut <val_type> )
+table_type:  <nat> <nat>? <elem_type>
+memory_type: <nat> <nat>?
 
 expr:
   ( <op> )
-  ( <op> <expr>+ )                                                  ;; = <expr>+ (<op>)
-  ( block <name>? <block_sig> <instr>* )
-  ( loop <name>? <block_sig> <instr>* )
-  ( if <name>? <block_sig> ( then <instr>* ) ( else <instr>* )? )
-  ( if <name>? <block_sig> <expr>+ ( then <instr>* ) ( else <instr>* )? ) ;; = <expr>+ (if <name>? <block_sig> (then <instr>*) (else <instr>*)?)
+  ( <op> <expr>+ )                                                   ;; = <expr>+ (<op>)
+  ( block <name>? <block_type> <instr>* )
+  ( loop <name>? <block_type> <instr>* )
+  ( if <name>? <block_type> ( then <instr>* ) ( else <instr>* )? )
+  ( if <name>? <block_tyoe> <expr>+ ( then <instr>* ) ( else <instr>* )? ) ;; = <expr>+ (if <name>? <block_type> (then <instr>*) (else <instr>*)?)
 
 instr:
   <expr>
-  <op>                                                              ;; = (<op>)
-  block <name>? <block_sig> <instr>* end <name>?                    ;; = (block <name>? <block_sig> <instr>*)
-  loop <name>? <block_sig> <instr>* end <name>?                     ;; = (loop <name>? <block_sig> <instr>*)
-  if <name>? <block_sig> <instr>* end <name>?                       ;; = (if <name>? <block_sig> (then <instr>*))
-  if <name>? <block_sig> <instr>* else <name>? <instr>* end <name>? ;; = (if <name>? <block_sig> (then <instr>*) (else <instr>*))
+  <op>                                                               ;; = (<op>)
+  block <name>? <block_type> <instr>* end <name>?                    ;; = (block <name>? <block_type> <instr>*)
+  loop <name>? <block_type> <instr>* end <name>?                     ;; = (loop <name>? <block_type> <instr>*)
+  if <name>? <block_type> <instr>* end <name>?                       ;; = (if <name>? <block_type> (then <instr>*))
+  if <name>? <block_type> <instr>* else <name>? <instr>* end <name>? ;; = (if <name>? <block_type> (then <instr>*) (else <instr>*))
 
 op:
   unreachable
@@ -216,7 +215,7 @@ op:
   br_table <var>+
   return
   call <var>
-  call_indirect <func_sig>
+  call_indirect <func_type>
   drop
   select
   get_local <var>
@@ -224,49 +223,49 @@ op:
   tee_local <var>
   get_global <var>
   set_global <var>
-  <type>.load((8|16|32)_<sign>)? <offset>? <align>?
-  <type>.store(8|16|32)? <offset>? <align>?
+  <val_type>.load((8|16|32)_<sign>)? <offset>? <align>?
+  <val_type>.store(8|16|32)? <offset>? <align>?
   current_memory
   grow_memory
-  <type>.const <value>
-  <type>.<unop>
-  <type>.<binop>
-  <type>.<testop>
-  <type>.<relop>
-  <type>.<cvtop>/<type>
-
-func:    ( func <name>? <func_sig> <local>* <instr>* )
+  <val_type>.const <value>
+  <val_type>.<unop>
+  <val_type>.<binop>
+  <val_type>.<testop>
+  <val_type>.<relop>
+  <val_type>.<cvtop>/<val_type>
+
+func:    ( func <name>? <func_type> <local>* <instr>* )
          ( func <name>? ( export <string> ) <...> )                         ;; = (export <string> (func <N>)) (func <name>? <...>)
-         ( func <name>? ( import <string> <string> ) <func_sig>)            ;; = (import <name>? <string> <string> (func <func_sig>))
-param:   ( param <type>* ) | ( param <name> <type> )
-result:  ( result <type>* )
-local:   ( local <type>* ) | ( local <name> <type> )
+         ( func <name>? ( import <string> <string> ) <func_type>)           ;; = (import <name>? <string> <string> (func <func_type>))
+param:   ( param <val_type>* ) | ( param <name> <val_type> )
+result:  ( result <val_type>* )
+local:   ( local <val_type>* ) | ( local <name> <val_type> )
 
-global:  ( global <name>? <global_sig> <instr>* )
+global:  ( global <name>? <global_type> <instr>* )
          ( global <name>? ( export <string> ) <...> )                       ;; = (export <string> (global <N>)) (global <name>? <...>)
-         ( global <name>? ( import <string> <string> ) <global_sig> )       ;; = (import <name>? <string> <string> (global <global_sig>))
-table:   ( table <name>? <table_sig> )
+         ( global <name>? ( import <string> <string> ) <global_type> )      ;; = (import <name>? <string> <string> (global <global_type>))
+table:   ( table <name>? <table_type> )
          ( table <name>? ( export <string> ) <...> )                        ;; = (export <string> (table <N>)) (table <name>? <...>)
-         ( table <name>? ( import <string> <string> ) <table_sig> )         ;; = (import <name>? <string> <string> (table <table_sig>))
+         ( table <name>? ( import <string> <string> ) <table_type> )        ;; = (import <name>? <string> <string> (table <table_type>))
          ( table <name>? ( export <string> )* <elem_type> ( elem <var>* ) ) ;; = (table <name>? ( export <string> )* <size> <size> <elem_type>) (elem (i32.const 0) <var>*)
 elem:    ( elem <var>? (offset <instr>* ) <var>* )
          ( elem <var>? <expr> <var>* )                                      ;; = (elem <var>? (offset <expr>) <var>*)
-memory:  ( memory <name>? <memory_sig> )
+memory:  ( memory <name>? <memory_type> )
          ( memory <name>? ( export <string> ) <...> )                       ;; = (export <string> (memory <N>))+ (memory <name>? <...>)
-         ( memory <name>? ( import <string> <string> ) <memory_sig> )       ;; = (import <name>? <string> <string> (memory <memory_sig>))
+         ( memory <name>? ( import <string> <string> ) <memory_type> )      ;; = (import <name>? <string> <string> (memory <memory_type>))
          ( memory <name>? ( export <string> )* ( data <string>* )           ;; = (memory <name>? ( export <string> )* <size> <size>) (data (i32.const 0) <string>*)
 data:    ( data <var>? ( offset <instr>* ) <string>* )
          ( data <var>? <expr> <string>* )                                   ;; = (data <var>? (offset <expr>) <string>*)
 
 start:   ( start <var> )
 
-typedef: ( type <name>? ( func <func_sig> ) )
+typedef: ( type <name>? ( func <param>* <result>* ) )
 
 import:  ( import <string> <string> <imkind> )
-imkind:  ( func <name>? <func_sig> )
-         ( global <name>? <global_sig> )
-         ( table <name>? <table_sig> )
-         ( memory <name>? <memory_sig> )
+imkind:  ( func <name>? <func_type> )
+         ( global <name>? <global_type> )
+         ( table <name>? <table_type> )
+         ( memory <name>? <memory_type> )
 export:  ( export <string> <exkind> )
 exkind:  ( func <var> )
          ( global <var> )
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index b7c65a3d1..685a05b0c 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -211,25 +211,25 @@ global_type :
   | VALUE_TYPE { GlobalType ($1, Immutable) }
   | LPAR MUT VALUE_TYPE RPAR { GlobalType ($3, Mutable) }
 
-func_type :
-  | LPAR FUNC func_sig RPAR { $3 }
+def_type :
+  | LPAR FUNC func_type RPAR { $3 }
 
-func_sig :
+func_type :
   | /* empty */
     { FuncType ([], []) }
-  | LPAR RESULT value_type_list RPAR func_sig
+  | LPAR RESULT value_type_list RPAR func_type
     { let FuncType (ins, out) = $5 in
       if ins <> [] then error (at ()) "result before parameter";
       FuncType (ins, $3 @ out) }
-  | LPAR PARAM value_type_list RPAR func_sig
+  | LPAR PARAM value_type_list RPAR func_type
     { let FuncType (ins, out) = $5 in FuncType ($3 @ ins, out) }
-  | LPAR PARAM bind_var VALUE_TYPE RPAR func_sig  /* Sugar */
+  | LPAR PARAM bind_var VALUE_TYPE RPAR func_type  /* Sugar */
     { let FuncType (ins, out) = $6 in FuncType ($4 :: ins, out) }
 
-table_sig :
+table_type :
   | limits elem_type { TableType ($1, $2) }
 
-memory_sig :
+memory_type :
   | limits { MemoryType $1 }
 
 limits :
@@ -327,11 +327,11 @@ plain_instr :
   | CONVERT { fun c -> $1 }
 
 call_instr :
-  | CALL_INDIRECT call_instr_sig
+  | CALL_INDIRECT call_instr_type
     { let at1 = ati 1 in
       fun c -> let x, es = $2 c in call_indirect x @@ at1, es }
 
-call_instr_sig :
+call_instr_type :
   | type_use call_instr_params
     { let at1 = ati 1 in
       fun c ->
@@ -366,11 +366,11 @@ block_instr :
     { fun c -> let c' = $2 c ($5 @ $8) in
       let ts, es1 = $3 c' in if_ ts es1 ($6 c') }
 
-block_sig :
+block_type :
   | LPAR RESULT VALUE_TYPE RPAR { [$3] }
 
 block :
-  | block_sig instr_list
+  | block_type instr_list
     { fun c -> $1, $2 c }
   | instr_list { fun c -> [], $1 c }
 
@@ -380,7 +380,7 @@ expr :  /* Sugar */
 
 expr1 :  /* Sugar */
   | plain_instr expr_list { fun c -> $2 c, $1 c }
-  | CALL_INDIRECT call_expr_sig
+  | CALL_INDIRECT call_expr_type
     { fun c -> let x, es = $2 c in es, call_indirect x }
   | BLOCK labeling_opt block
     { fun c -> let c' = $2 c [] in let ts, es = $3 c' in [], block ts es }
@@ -390,7 +390,7 @@ expr1 :  /* Sugar */
     { fun c -> let c' = $2 c [] in
       let ts, (es, es1, es2) = $3 c c' in es, if_ ts es1 es2 }
 
-call_expr_sig :
+call_expr_type :
   | type_use call_expr_params
     { let at1 = ati 1 in
       fun c ->
@@ -416,7 +416,7 @@ call_expr_results :
 
 
 if_block :
-  | block_sig if_block { fun c c' -> let ts, ess = $2 c c' in $1 @ ts, ess }
+  | block_type if_block { fun c c' -> let ts, ess = $2 c c' in $1 @ ts, ess }
   | if_ { fun c c' -> [], $1 c c' }
 
 if_ :
@@ -534,9 +534,9 @@ table :
       fun () -> $4 c x at }
 
 table_fields :
-  | table_sig
+  | table_type
     { fun c x at -> [{ttype = $1} @@ at], [], [], [] }
-  | inline_import table_sig
+  | inline_import table_type  /* Sugar */
     { fun c x at ->
       [], [],
       [{ module_name = fst $1; item_name = snd $1;
@@ -566,9 +566,9 @@ memory :
       fun () -> $4 c x at }
 
 memory_fields :
-  | memory_sig
+  | memory_type
     { fun c x at -> [{mtype = $1} @@ at], [], [], [] }
-  | inline_import memory_sig
+  | inline_import memory_type  /* Sugar */
     { fun c x at ->
       [], [],
       [{ module_name = fst $1; item_name = snd $1;
@@ -593,7 +593,7 @@ global :
 global_fields :
   | global_type const_expr
     { fun c x at -> [{gtype = $1; value = $2 c} @@ at], [], [] }
-  | inline_import global_type
+  | inline_import global_type  /* Sugar */
     { fun c x at ->
       [],
       [{ module_name = fst $1; item_name = snd $1;
@@ -609,14 +609,14 @@ import_desc :
   | LPAR FUNC bind_var_opt type_use RPAR
     { fun c -> ignore ($3 c anon_func bind_func);
       fun () -> FuncImport ($4 c type_) }
-  | LPAR FUNC bind_var_opt func_sig RPAR  /* Sugar */
+  | LPAR FUNC bind_var_opt func_type RPAR  /* Sugar */
     { let at4 = ati 4 in
       fun c -> ignore ($3 c anon_func bind_func);
       fun () -> FuncImport (inline_type c $4 at4) }
-  | LPAR TABLE bind_var_opt table_sig RPAR
+  | LPAR TABLE bind_var_opt table_type RPAR
     { fun c -> ignore ($3 c anon_table bind_table);
       fun () -> TableImport $4 }
-  | LPAR MEMORY bind_var_opt memory_sig RPAR
+  | LPAR MEMORY bind_var_opt memory_type RPAR
     { fun c -> ignore ($3 c anon_memory bind_memory);
       fun () -> MemoryImport $4 }
   | LPAR GLOBAL bind_var_opt global_type RPAR
@@ -651,7 +651,7 @@ inline_export :
 /* Modules */
 
 type_ :
-  | func_type { $1 @@ at () }
+  | def_type { $1 @@ at () }
 
 type_def :
   | LPAR TYPE type_ RPAR

From 1025a40f4f5fbaf5c5080ef37b13017bb21b6e1d Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 16 Feb 2018 17:29:30 +0100
Subject: [PATCH 164/329] [spec] Some more fail safety for Makefiles (#703)

---
 document/Makefile      | 19 +++++++++++++------
 document/core/Makefile | 16 +++++++++++++---
 document/deploy.sh     | 17 +++++++++++++++--
 3 files changed, 41 insertions(+), 11 deletions(-)

diff --git a/document/Makefile b/document/Makefile
index 8a1544477..1bc93c901 100644
--- a/document/Makefile
+++ b/document/Makefile
@@ -30,20 +30,27 @@ root: $(BUILDDIR)
 	cp -f $(FILES) $(BUILDDIR)/
 
 .PHONY: $(DIRS)
-$(DIRS): %: $(BUILDDIR)
-	(cd $@; make BUILDDIR=$(BUILDDIR) all)
-	mkdir -p $(BUILDDIR)/$@
-	cp -R $@/$(BUILDDIR)/html/* $(BUILDDIR)/$@/
+$(DIRS): %: $(BUILDDIR) $(DIRS:%=build-%) $(DIRS:%=dir-%)
+
+.PHONY: $(DIRS:%=build-%)
+$(DIRS:%=build-%): build-%:
+	(cd $(@:build-%=%); make BUILDDIR=$(BUILDDIR) all)
+
+.PHONY: $(DIRS:%=dir-%)
+$(DIRS:%=dir-%): dir-%:
+	mkdir -p $(BUILDDIR)/$(@:dir-%=%)
+	rm -rf $(BUILDDIR)/$(@:dir-%=%)/*
+	cp -R $(@:dir-%=%)/$(BUILDDIR)/html/* $(BUILDDIR)/$(@:dir-%=%)/
 
 .PHONY: $(DIRS:%=deploy-%)
-$(DIRS:%=deploy-%):
+$(DIRS:%=deploy-%): deploy-%:
 	GIT_DEPLOY_DIR=$(BUILDDIR) GIT_DEPLOY_SUBDIR=$(@:deploy-%=%) bash deploy.sh
 
 .PHONY: $(DIRS:%=publish-%)
 $(DIRS:%=publish-%): publish-%: % deploy-%
 
 .PHONY: $(DIRS:%=clean-%)
-$(DIRS:%=clean-%):
+$(DIRS:%=clean-%): clean-%:
 	(cd $(@:clean-%=%); make BUILDDIR=$(BUILDDIR) clean)
 	rm -rf $(BUILDDIR)/$(@:clean-%=%)
 
diff --git a/document/core/Makefile b/document/core/Makefile
index d55d7e04a..6b9acb998 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -67,15 +67,25 @@ help:
 
 .PHONY: deploy
 deploy:
-	(cd ..; make deploy-core)
+	(cd ..; make dir-core deploy-core)
 
 .PHONY: publish
-publish:
-	(cd ..; make publish-core)
+publish: clean all deploy
 
 .PHONY: all
 all:	pdf html bikeshed
 
+.PHONY: deploy-main
+deploy-main:
+	(cd ..; make dir-core)
+	(cd ..; GIT_DEPLOY_DIR=$(BUILDDIR) GIT_DEPLOY_SUBDIR=core/multipage bash deploy.sh)
+
+.PHONY: publish-main
+publish-main: clean main deploy-main
+
+.PHONY: main
+main:	pdf html
+
 .PHONY: pdf
 pdf:	latexpdf
 	mkdir -p $(BUILDDIR)/html/multipage/$(DOWNLOADDIR)
diff --git a/document/deploy.sh b/document/deploy.sh
index f91205bcd..66bba483e 100755
--- a/document/deploy.sh
+++ b/document/deploy.sh
@@ -114,6 +114,11 @@ main() {
 		
 	previous_branch=`git rev-parse --abbrev-ref HEAD`
 
+	if [ $previous_branch == $deploy_branch  ]; then
+		echo "Deploy branch is current branch. Aborting." >&2
+		return 1
+	fi
+
 	if [ ! -d "$deploy_directory" ]; then
 		echo "Deploy directory '$deploy_directory' does not exist. Aborting." >&2
 		return 1
@@ -127,7 +132,8 @@ main() {
 
 	if git ls-remote --exit-code $repo "refs/heads/$deploy_branch" ; then
 		# deploy_branch exists in $repo; make sure we have the latest version
-		
+
+		echo ==== Fetch branch $deploy_branch from $repo
 		disable_expanded_output
 		git fetch --force $repo $deploy_branch:$deploy_branch
 		enable_expanded_output
@@ -143,6 +149,8 @@ main() {
 }
 
 initial_deploy() {
+	echo ==== Initial deploy
+
 	if [[ -z $deploy_subdirectory ]]; then
 		git --work-tree "$deploy_directory" checkout --orphan $deploy_branch
 		git --work-tree "$deploy_directory" add --all
@@ -154,6 +162,8 @@ initial_deploy() {
 }
 
 incremental_deploy() {
+	echo ==== Incremental deploy
+
 	#make deploy_branch the current branch
 	git symbolic-ref HEAD refs/heads/$deploy_branch
 	#put the previously committed contents of deploy_branch into the index
@@ -174,9 +184,12 @@ incremental_deploy() {
 }
 
 commit_and_push() {
+	echo ==== Commit
+
 	set_user_id
-	git --work-tree "$deploy_directory" commit -m "$commit_message"
+	git --work-tree "$deploy_directory" commit -m "$commit_message" || echo ==== Skip
 
+	echo ==== Push
 	disable_expanded_output
 	#--quiet is important here to avoid outputting the repo URL, which may contain a secret token
 	git push --quiet $repo $deploy_branch

From 0226eb323ae69a927f2d471cc0e8038fca0f2bd5 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 16 Feb 2018 20:00:23 +0100
Subject: [PATCH 165/329] [spec] Restore dir location (#704)

---
 document/core/Makefile | 34 +++++++++++++++++++---------------
 document/index.html    |  4 ++--
 2 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/document/core/Makefile b/document/core/Makefile
index 6b9acb998..b47a57909 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -72,24 +72,28 @@ deploy:
 .PHONY: publish
 publish: clean all deploy
 
+.PHONY: publish-main
+publish-main: clean main bikeshed-keep deploy
+
 .PHONY: all
 all:	pdf html bikeshed
 
-.PHONY: deploy-main
-deploy-main:
-	(cd ..; make dir-core)
-	(cd ..; GIT_DEPLOY_DIR=$(BUILDDIR) GIT_DEPLOY_SUBDIR=core/multipage bash deploy.sh)
-
-.PHONY: publish-main
-publish-main: clean main deploy-main
-
 .PHONY: main
 main:	pdf html
 
+# Dirty hack to avoid rebuilding the Bikeshed version for every push.
+.PHONY: bikeshed-keep
+bikeshed-keep:
+	test -e $(BUILDDIR)/html/bikeshed || \
+	  wget -r -nH --cut-dirs=2 -P $(BUILDDIR)/html --no-check-certificate \
+	    https://webassembly.github.io/spec/core/bikeshed || \
+	  echo Downloaded Bikeshed.
+
+
 .PHONY: pdf
 pdf:	latexpdf
-	mkdir -p $(BUILDDIR)/html/multipage/$(DOWNLOADDIR)
-	ln -f $(BUILDDIR)/latex/$(NAME).pdf $(BUILDDIR)/html/multipage/$(DOWNLOADDIR)/$(NAME).pdf
+	mkdir -p $(BUILDDIR)/html/$(DOWNLOADDIR)
+	ln -f $(BUILDDIR)/latex/$(NAME).pdf $(BUILDDIR)/html/$(DOWNLOADDIR)/$(NAME).pdf
 
 
 .PHONY: clean
@@ -99,15 +103,15 @@ clean:
 
 .PHONY: html
 html:
-	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html/multipage
-	for file in `ls $(BUILDDIR)/html/multipage/*.html`; \
+	$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
+	for file in `ls $(BUILDDIR)/html/*.html`; \
 	do \
 	  sed s:BASEDIR:.:g <$$file >$$file.out; \
 	  mv -f $$file.out $$file; \
 	  sed s~$(OLDMATHJAX)~$(NEWMATHJAX)~g <$$file >$$file.out; \
 	  mv -f $$file.out $$file; \
 	done
-	for file in `ls $(BUILDDIR)/html/multipage/*/*.html`; \
+	for file in `ls $(BUILDDIR)/html/*/*.html`; \
 	do \
 	  sed s:BASEDIR:..:g <$$file >$$file.out; \
 	  sed 's;<body; <script type="text/javascript">MathJax.Hub.Config({TeX: {MAXBUFFER: 30*1024}})</script><body;' \
@@ -117,7 +121,7 @@ html:
 	  mv -f $$file.out $$file; \
 	done
 	@echo
-	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html/multipage."
+	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html/."
 
 .PHONY: dirhtml
 dirhtml:
@@ -145,7 +149,7 @@ bikeshed:
 	patch -p0 $(BUILDDIR)/html/bikeshed/katex/dist/katex.css \
 		< util/katex_fix.patch
 	@echo
-	@echo "Build finished. The HTML page is in $(BUILDDIR)/html/bikeshed."
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/html/bikeshed/."
 
 .PHONY: pickle
 pickle:
diff --git a/document/index.html b/document/index.html
index 56b6f373e..70f38ec47 100644
--- a/document/index.html
+++ b/document/index.html
@@ -27,13 +27,13 @@ <h3>Core specification</h3>
 
   <ul>
     <li>
-      <p><a href="core/multipage/index.html">Core</a>:
+      <p><a href="core/index.html">Core</a>:
       defines the structure of WebAssembly modules and its representation
       in binary and text format, as well as the semantics of validation,
       instantiation, and execution.
       Alternate versions:
       <a href="core/bikeshed/index.html">W3C Editor's Draft</a>,
-      <a href="core/multipage/_download/WebAssembly.pdf">PDF</a>.
+      <a href="core/_download/WebAssembly.pdf">PDF</a>.
       </p>
     </li>
   </ul>

From 8a0c449d5973361b6980d25e92463a4f735ee317 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Fri, 16 Feb 2018 23:43:00 +0100
Subject: [PATCH 166/329] [interpreter] Catch negative skip in decoder (#698)

---
 interpreter/binary/decode.ml                   | 4 ++--
 test/core/{custom_section.wast => custom.wast} | 8 ++++++++
 2 files changed, 10 insertions(+), 2 deletions(-)
 rename test/core/{custom_section.wast => custom.wast} (96%)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index a26663426..68a8d9c4c 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -16,7 +16,7 @@ let pos s = !(s.pos)
 let eos s = (pos s = len s)
 
 let check n s = if pos s + n > len s then raise EOS
-let skip n s = check n s; s.pos := !(s.pos) + n
+let skip n s = if n < 0 then raise EOS else check n s; s.pos := !(s.pos) + n
 
 let read s = Char.code (s.bytes.[!(s.pos)])
 let peek s = if eos s then None else Some (read s)
@@ -39,7 +39,7 @@ let error s pos msg = raise (Code (region s pos pos, msg))
 let require b s pos msg = if not b then error s pos msg
 
 let guard f s =
-  try f s with EOS -> error s (len s) "unexpected end of binary or function"
+  try f s with EOS -> error s (len s) "unexpected end of section or function"
 
 let get = guard get
 let get_string n = guard (get_string n)
diff --git a/test/core/custom_section.wast b/test/core/custom.wast
similarity index 96%
rename from test/core/custom_section.wast
rename to test/core/custom.wast
index c6c338905..fb04f2f6b 100644
--- a/test/core/custom_section.wast
+++ b/test/core/custom.wast
@@ -73,6 +73,14 @@
   "unexpected end"
 )
 
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\00\00\00\05\01\00\07\00\00"
+  )
+  "unexpected end"
+)
+
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"

From d67fb92f6ddf792f5ae0444695f074eaaf83b1d4 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Sat, 17 Feb 2018 14:18:29 +0100
Subject: [PATCH 167/329] [spec] Normative: Clarify that JSAPI i32 conversions
 are signed

Includes a test to verify
---
 document/js-api/index.bs |  3 ++-
 test/js-api/jsapi.js     | 20 ++++++++++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index e67679599..979f4446d 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -154,6 +154,7 @@ urlPrefix: https://webassembly.github.io/spec/core/multipage/; spec: WebAssembly
         text: 𝗀𝗅𝗈𝖻𝖺𝗅
     text: global type; url: syntax/types.html#syntax-globaltype
     text: address; url: exec/runtime.html#addresses
+    text: signed_32; url: exec/numerics.html#aux-signed
 </pre>
 
 <pre class='link-defaults'>
@@ -786,7 +787,7 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
 The algorithm <dfn>ToJSValue</dfn>(|w|) coerces a [=WebAssembly value=] to a JavaScript value performs the following steps:
 
 Assert: |w| is not of the form [=𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] |i64|.
-1. If |w| is of the form [=𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |i32|, return [=the Number value=] for |i32|.
+1. If |w| is of the form [=𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |i32|, return [=the Number value=] for [=signed_32=](|i32|).
 1. If |w| is of the form [=𝖿𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |f32|, return [=the Number value=] for |f32|.
 1. If |w| is of the form [=𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] |f64|, return [=the Number value=] for |f64|.
 
diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 90a8618ce..9b3290757 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -90,6 +90,17 @@ const moduleBinaryWithMemSectionAndMemImport = (() => {
     return builder.toBuffer();
 })();
 
+const exportingModuleIdentityFn = (() => {
+    let builder = new WasmModuleBuilder();
+
+    builder
+        .addFunction('id', kSig_i_i)
+        .addBody([])
+        .exportFunc();
+
+    return builder.toBuffer();
+})();
+
 let Module;
 let Instance;
 let CompileError;
@@ -881,4 +892,13 @@ test(() => {
   assert_equals(table.get(2)(), 46);
 }, "Tables export cached");
 
+test(() => {
+  let module = new WebAssembly.Module(exportingModuleIdentityFn );
+  let instance new WebAssembly.Instance(module);
+
+  let value = 2 ** 31;
+  let output = instance.exports.id(value);
+  assert_equals(output, - (2 ** 31));
+}, "WebAssembly integers are converted to JavaScript as if by ToInt32");
+
 })();

From 1f4ca1a29f1d9af16792286c913cbebb1e815d11 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Sat, 17 Feb 2018 13:38:01 +0100
Subject: [PATCH 168/329] [spec] Editorial: Simplify introduction

- Remove irrelevant issues and notes
- Clean up wording to indicate more clearly what it is for
---
 document/js-api/index.bs | 11 +----------
 1 file changed, 1 insertion(+), 10 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 979f4446d..ba2af4a4f 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -167,16 +167,7 @@ spec:ecmascript; type:interface; for:ECMAScript; text:ArrayBuffer
 spec:promises-guide-1; type:dfn; text:resolve
 </pre>
 
-Issue: This document is an early draft, porting <a href="https://github.com/WebAssembly/design/blob/master/JS.md">the official JS/WebAssembly interface specification</a> to WebIDL and Bikeshed. It should currently not be used as the WebAssembly specification.
-
-This API is, initially, the only API for accessing WebAssembly [[WEBASSEMBLY]] from the web platform, through a bridge to explicitly construct modules from ECMAScript [[ECMASCRIPT]].
-
-Issue: In future versions, WebAssembly may
-be loaded and run directly from an HTML `<script type='module'>` tag—and
-any other Web API that loads ES6 modules via URL—as part of
-[ES6 Module integration](https://github.com/WebAssembly/design/issues/1087).)
-
-Note: WebAssembly JS API declaration file for TypeScript can be found [here](https://github.com/01alchemist/webassembly-types/blob/master/webassembly.d.ts) which enable autocompletion and make TypeScript compiler happy.
+This API privides a way to access WebAssembly [[WEBASSEMBLY]] from the web platform or other JavaScript environments such as Node.js, through a bridge to explicitly construct modules from ECMAScript [[ECMASCRIPT]].
 
 <p>See the [[#issues-index]] for complete list of issues.</p>
 

From ef299ad9c6bf7c37dd8e5cad58ad297adc696bcd Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Sat, 17 Feb 2018 18:59:10 +0100
Subject: [PATCH 169/329] [spec] Editorial: Rename parameters from delta to
 index

---
 document/js-api/index.bs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index ba2af4a4f..7afbc5a9f 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -604,8 +604,8 @@ dictionary TableDescriptor {
 [LegacyNamespace=WebAssembly, Constructor(TableDescriptor descriptor), Exposed=(Window,Worker,Worklet)]
 interface Table {
   unsigned long grow([EnforceRange] unsigned long delta);
-  Function? get([EnforceRange] unsigned long delta);
-  void set([EnforceRange] unsigned long delta, Function? value);
+  Function? get([EnforceRange] unsigned long index);
+  void set([EnforceRange] unsigned long index, Function? value);
   readonly attribute unsigned long length;
 };
 </pre>

From 87135777bce91aed05810caada3b102f4ac64e8d Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Mon, 19 Feb 2018 12:26:45 +0100
Subject: [PATCH 170/329] [spec] Remove context about what JavaScript
 environments are

---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 7afbc5a9f..42c2e9409 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -167,7 +167,7 @@ spec:ecmascript; type:interface; for:ECMAScript; text:ArrayBuffer
 spec:promises-guide-1; type:dfn; text:resolve
 </pre>
 
-This API privides a way to access WebAssembly [[WEBASSEMBLY]] from the web platform or other JavaScript environments such as Node.js, through a bridge to explicitly construct modules from ECMAScript [[ECMASCRIPT]].
+This API privides a way to access WebAssembly [[WEBASSEMBLY]] through a bridge to explicitly construct modules from JavaScript [[ECMASCRIPT]].
 
 <p>See the [[#issues-index]] for complete list of issues.</p>
 

From 3bd8e6ae4743ab3d11cb5be3d125f510559bfc0c Mon Sep 17 00:00:00 2001
From: James Ray <16969914+jamesray1@users.noreply.github.com>
Date: Wed, 21 Feb 2018 16:30:27 +1100
Subject: [PATCH 171/329] Fix their their (#708)

---
 document/core/valid/modules.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 022792c85..6dc45a687 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -253,7 +253,7 @@ Start function declarations :math:`\start` are not classified by any type.
 Exports
 ~~~~~~~
 
-Exports :math:`\export` and export descriptions :math:`\exportdesc` are classified by their their :ref:`external type <syntax-externtype>`.
+Exports :math:`\export` and export descriptions :math:`\exportdesc` are classified by their :ref:`external type <syntax-externtype>`.
 
 
 :math:`\{ \ENAME~\name, \EDESC~\exportdesc \}`

From 71944160b5b61f5e5610c564a4061a981759a0f1 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 21 Feb 2018 12:26:47 +0100
Subject: [PATCH 172/329] [spec] Editorial: Fix cross-references to core spec

In particular, the spec moved and redirects don't seem to be in place;
this patch fixes the links.
---
 document/js-api/index.bs  | 6 +++---
 document/web-api/index.bs | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 42c2e9409..a764fff99 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -16,8 +16,8 @@ Prepare For TR: true
 <pre class='biblio'>
 {
   "WEBASSEMBLY": {
-    "href": "https://webassembly.github.io/spec/",
-    "title": "WebAssembly Specification",
+    "href": "https://webassembly.github.io/spec/core/",
+    "title": "WebAssembly Core Specification",
     "publisher": "W3C WebAssembly Community Group",
     "status": "Draft"
   }
@@ -84,7 +84,7 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMASCRIPT
         text: the Number value; url: sec-ecmascript-language-types-number-type
         text: NumberToRawBytes; url: sec-numbertorawbytes
         text: Built-in Function Objects; url: sec-built-in-function-objects
-urlPrefix: https://webassembly.github.io/spec/core/multipage/; spec: WebAssembly; type: dfn
+urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: dfn
     url: valid/modules.html#valid-module
         text: valid
         text: WebAssembly module validation
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 7ef0450e9..e14781402 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -22,8 +22,8 @@ Prepare For TR: true
     "status": "Current Editor's Draft"
   },
   "WEBASSEMBLY": {
-    "href": "https://webassembly.github.io/spec/",
-    "title": "WebAssembly Specification",
+    "href": "https://webassembly.github.io/spec/core/",
+    "title": "WebAssembly Core Specification",
     "publisher": "W3C WebAssembly Community Group",
     "status": "Draft"
   },
@@ -42,7 +42,7 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMA-262
         text: TypeError; url: sec-native-error-types-used-in-this-standard-typeerror
     type: interface
         text: ArrayBuffer; url: sec-arraybuffer-objects
-urlPrefix: https://webassembly.github.io/spec/core/multipage/; spec: WebAssembly; type: dfn
+urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: dfn
     text: function index; url: syntax/modules.html#syntax-funcidx
     text: "name" section; url: appendix/custom.html?highlight=name%20section#binary-namesec
 urlPrefix: https://webassembly.github.io/spec/js-api/; spec: WASMJS

From 4883a86517f0905a957eb0849dd9ecbb218cd28d Mon Sep 17 00:00:00 2001
From: Clemens Hammacher <clemens@hammacher.name>
Date: Wed, 21 Feb 2018 16:33:11 +0100
Subject: [PATCH 173/329] [spec] Fix spec for fne (returns 1 for NaN) (#710)

---
 document/core/exec/numerics.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/document/core/exec/numerics.rst b/document/core/exec/numerics.rst
index 16914d5f6..f1ff17542 100644
--- a/document/core/exec/numerics.rst
+++ b/document/core/exec/numerics.rst
@@ -1197,7 +1197,7 @@ This non-deterministic result is expressed by the following auxiliary function p
 :math:`\fne_N(z_1, z_2)`
 ........................
 
-* If either :math:`z_1` or :math:`z_2` is a NaN, then return :math:`0`.
+* If either :math:`z_1` or :math:`z_2` is a NaN, then return :math:`1`.
 
 * Else if both :math:`z_1` and :math:`z_2` are zeroes, then return :math:`0`.
 
@@ -1207,8 +1207,8 @@ This non-deterministic result is expressed by the following auxiliary function p
 
 .. math::
    \begin{array}{@{}lcll}
-   \fne_N(\pm \NAN(n), z_2) &=& 0 \\
-   \fne_N(z_1, \pm \NAN(n)) &=& 0 \\
+   \fne_N(\pm \NAN(n), z_2) &=& 1 \\
+   \fne_N(z_1, \pm \NAN(n)) &=& 1 \\
    \fne_N(\pm 0, \mp 0) &=& 0 \\
    \fne_N(z_1, z_2) &=& \bool(z_1 \neq z_2) \\
    \end{array}

From 105c5ea207ed3bc7194a931e6abcf9e6b3ae5d58 Mon Sep 17 00:00:00 2001
From: Sergey Pepyakin <s.pepyakin@gmail.com>
Date: Wed, 21 Feb 2018 20:48:05 +0300
Subject: [PATCH 174/329] [test] Add test for instructions' reserved bytes
 (#702)

---
 test/core/binary.wast | 58 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/test/core/binary.wast b/test/core/binary.wast
index 3e971a203..8cfeed46f 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -42,3 +42,61 @@
 (assert_malformed (module binary "\00asm\00\01\00\00") "unknown binary version")
 (assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version")
 (assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version")
+
+;; call_indirect reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\09\01"               ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\01"                      ;; call_indirect reserved byte is not equal to zero!
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; grow_memory reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; grow_memory
+    "\01"                      ;; grow_memory reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; current_memory reserved byte equal to zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\07\01"                ;; Code section
+
+    ;; function 0
+    "\05\00"
+    "\3f"                      ;; current_memory
+    "\01"                      ;; current_memory reserved byte is not equal to zero!
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)

From 7b1c0f932d16eabdcb46b8f00186b6a1adf993f9 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 22 Feb 2018 10:10:24 +0100
Subject: [PATCH 175/329] [spec] Fix missing operand (#713)

---
 document/core/appendix/algorithm.rst | 1 +
 document/core/exec/runtime.rst       | 1 -
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index 9191c864d..d11095afb 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -169,6 +169,7 @@ Other instructions are checked in a similar manner.
          push_ctrl([], [t*])
 
        case (if t*)
+         pop_opd(I32)
          push_ctrl([t*], [t*])
 
        case (end)
diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index c4ad03390..ea25079d3 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -359,7 +359,6 @@ Stack entries are described by abstract syntax as follows.
    However, because the stacks are interdependent, additional book keeping about associated stack heights would be required.
    For the purpose of this specification, an interleaved representation is simpler.
 
-
 Values
 ......
 

From 11e8cb88080d0ec2aa67e0ccc7597a71b4f26e41 Mon Sep 17 00:00:00 2001
From: James Ray <16969914+jamesray1@users.noreply.github.com>
Date: Fri, 23 Feb 2018 16:32:23 +1100
Subject: [PATCH 176/329] Fix WebAssebmly (#715)

---
 document/core/exec/runtime.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index ea25079d3..e798f06f4 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -355,7 +355,7 @@ These entries can occur on the stack in any order during the execution of a prog
 Stack entries are described by abstract syntax as follows.
 
 .. note::
-   It is possible to model the WebAssebmly semantics using separate stacks for operands, control constructs, and calls.
+   It is possible to model the WebAssembly semantics using separate stacks for operands, control constructs, and calls.
    However, because the stacks are interdependent, additional book keeping about associated stack heights would be required.
    For the purpose of this specification, an interleaved representation is simpler.
 

From c316bbfce8775d9c37a27adb27bfa6a3c6b7faf2 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Fri, 23 Feb 2018 15:29:38 +0100
Subject: [PATCH 177/329] [interpreter] Tweak to instantiation

---
 interpreter/exec/eval.ml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 6409cf0a3..a6bc8f397 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -433,7 +433,7 @@ let init (m : module_) (exts : extern list) : module_inst =
       types = List.map (fun type_ -> type_.it) types }
   in
   let fs = List.map (create_func inst0) funcs in
-  let inst =
+  let inst1 =
     { inst0 with
       funcs = inst0.funcs @ fs;
       tables = inst0.tables @ List.map (create_table inst0) tables;
@@ -441,10 +441,11 @@ let init (m : module_) (exts : extern list) : module_inst =
       globals = inst0.globals @ List.map (create_global inst0) globals;
     }
   in
+  let inst = {inst1 with exports = List.map (create_export inst1) exports} in
   List.iter (init_func inst) fs;
   let init_elems = List.map (init_table inst) elems in
   let init_datas = List.map (init_memory inst) data in
   List.iter (fun f -> f ()) init_elems;
   List.iter (fun f -> f ()) init_datas;
   Lib.Option.app (fun x -> ignore (invoke (func inst x) [])) start;
-  {inst with exports = List.map (create_export inst) exports}
+  inst

From f6d962a42767882a8ecd01112de24fe2899f41d8 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Fri, 23 Feb 2018 16:33:53 +0100
Subject: [PATCH 178/329] [interpreter] Tweak .gitignore

---
 interpreter/.gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/interpreter/.gitignore b/interpreter/.gitignore
index 6c3de62c5..0a02ff708 100644
--- a/interpreter/.gitignore
+++ b/interpreter/.gitignore
@@ -9,4 +9,5 @@
 *.mlpack
 _build
 wasm
+wasm.debug
 

From 0cc2a1014b9bf9bbc5fe8f193dc2c23edfd49dd2 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Fri, 23 Feb 2018 16:55:22 -0800
Subject: [PATCH 179/329] Mark trunk as Editor's Draft. (#714)

---
 document/core/index.bs    | 2 +-
 document/js-api/index.bs  | 2 +-
 document/web-api/index.bs | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/document/core/index.bs b/document/core/index.bs
index bc95ed9bf..bdf8d6b70 100644
--- a/document/core/index.bs
+++ b/document/core/index.bs
@@ -2,7 +2,7 @@
 Title: WebAssembly Core Specification
 Shortname: wasm-core
 Group: wasm
-Status: FPWD
+Status: ED
 Level: 1
 TR: https://www.w3.org/TR/wasm-core-1/
 ED: https://webassembly.github.io/spec/core/bikeshed/
diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index a764fff99..19d19808f 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -2,7 +2,7 @@
 Title: WebAssembly JavaScript Interface
 Shortname: wasm-js-api
 Group: wasm
-Status: FPWD
+Status: ED
 Level: 1
 TR: https://www.w3.org/TR/wasm-js-api-1/
 ED: https://webassembly.github.io/spec/js-api/
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index e14781402..ba62bc487 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -2,7 +2,7 @@
 Title: WebAssembly Web API
 Shortname: wasm-web-api
 Group: wasm
-Status: FPWD
+Status: ED
 Level: 1
 TR: https://www.w3.org/TR/wasm-web-api-1/
 ED: https://webassembly.github.io/spec/web-api/

From 992059eb099f6ab3e0e4af29c879ea09ab964912 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 27 Feb 2018 10:32:35 +0100
Subject: [PATCH 180/329] [spec] Fix typo in fdiv (#722)

---
 document/core/exec/numerics.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/exec/numerics.rst b/document/core/exec/numerics.rst
index f1ff17542..cd81a16db 100644
--- a/document/core/exec/numerics.rst
+++ b/document/core/exec/numerics.rst
@@ -895,7 +895,7 @@ This non-deterministic result is expressed by the following auxiliary function p
 
 * Else if :math:`z_2` is a zero and :math:`z_1` a value with opposite sign, then return negative infinity.
 
-* Else return the result of dividing :math:`z_2` by :math:`z_1`, :ref:`rounded <aux-ieee>` to the nearest representable value.
+* Else return the result of dividing :math:`z_1` by :math:`z_2`, :ref:`rounded <aux-ieee>` to the nearest representable value.
 
 .. math::
    \begin{array}{@{}lcll}

From 2a5d467e1600068593cdd5a255d4ede34ccdf9ad Mon Sep 17 00:00:00 2001
From: Andreas Haas <ahaas@google.com>
Date: Wed, 28 Feb 2018 10:32:47 +0100
Subject: [PATCH 181/329] [js-api] Fix broken test

---
 test/js-api/jsapi.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 9b3290757..f8fa71a38 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -95,7 +95,7 @@ const exportingModuleIdentityFn = (() => {
 
     builder
         .addFunction('id', kSig_i_i)
-        .addBody([])
+        .addBody([kExprGetLocal, 0])
         .exportFunc();
 
     return builder.toBuffer();
@@ -894,7 +894,7 @@ test(() => {
 
 test(() => {
   let module = new WebAssembly.Module(exportingModuleIdentityFn );
-  let instance new WebAssembly.Instance(module);
+  let instance = new WebAssembly.Instance(module);
 
   let value = 2 ** 31;
   let output = instance.exports.id(value);

From 893ea392049ca49da4b6a2eb195e240e7844aa9d Mon Sep 17 00:00:00 2001
From: Clemens Hammacher <clemens@hammacher.name>
Date: Wed, 28 Feb 2018 09:37:19 +0100
Subject: [PATCH 182/329] Test that exported functions have no prototype

According to the spec, exported functions should not have a [[Construct]] method, hence they should not have a prototype.
---
 test/js-api/jsapi.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index f8fa71a38..4e1a9e932 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -408,6 +408,7 @@ test(() => {
     assert_equals(f.length, 0);
     assert_equals('name' in f, true);
     assert_equals(Function.prototype.call.call(f), 42);
+    assert_equals('prototype' in f, false);
     assertThrows(() => new f(), TypeError);
 }, "Exported WebAssembly functions");
 

From 98b90e2ab22053559ded143768d6559d2ba8d2fd Mon Sep 17 00:00:00 2001
From: Juan Mellado <jcmellado@users.noreply.github.com>
Date: Thu, 1 Mar 2018 10:13:03 +0100
Subject: [PATCH 183/329] Fix typo (#735)

See #663
---
 document/core/text/modules.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index 24e66ff81..d649bd291 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -491,7 +491,7 @@ Abbreviations
 
 As an abbreviation, a single instruction may occur in place of the offset:
 
-.. math:
+.. math::
    \begin{array}{llcll}
    \production{element offset} &
      \Tinstr &\equiv&
@@ -535,7 +535,7 @@ Abbreviations
 
 As an abbreviation, a single instruction may occur in place of the offset:
 
-.. math:
+.. math::
    \begin{array}{llcll}
    \production{data offset} &
      \Tinstr &\equiv&

From 1526f4fa7d1248f511ad2fd45b7292528565a595 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Sat, 3 Mar 2018 08:23:42 +0100
Subject: [PATCH 184/329] [interpreter] Fix flat call_indirect parsing (#738)

---
 interpreter/text/parser.mly | 50 ++++++++++++++++-----
 test/core/stack.wast        | 88 +++++++++++++++++++++++++++++++++++++
 2 files changed, 128 insertions(+), 10 deletions(-)

diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 685a05b0c..5ee439128 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -294,7 +294,7 @@ align_opt :
 
 instr :
   | plain_instr { let at = at () in fun c -> [$1 c @@ at] }
-  | call_instr { fun c -> let e, es = $1 c in e :: es }
+  | call_instr_instr { fun c -> let e, es = $1 c in e :: es }
   | block_instr { let at = at () in fun c -> [$1 c @@ at] }
   | expr { $1 } /* Sugar */
 
@@ -326,35 +326,64 @@ plain_instr :
   | BINARY { fun c -> $1 }
   | CONVERT { fun c -> $1 }
 
+
 call_instr :
   | CALL_INDIRECT call_instr_type
-    { let at1 = ati 1 in
-      fun c -> let x, es = $2 c in call_indirect x @@ at1, es }
+    { let at = at () in fun c -> call_indirect ($2 c) @@ at }
 
 call_instr_type :
   | type_use call_instr_params
     { let at1 = ati 1 in
       fun c ->
       match $2 c with
-      | FuncType ([], []), es -> $1 c type_, es
-      | ft, es -> inline_type_explicit c ($1 c type_) ft at1, es }
+      | FuncType ([], []) -> $1 c type_
+      | ft -> inline_type_explicit c ($1 c type_) ft at1 }
   | call_instr_params
-    { let at1 = ati 1 in
-      fun c -> let ft, es = $1 c in inline_type c ft at1, es }
+    { let at = at () in fun c -> inline_type c ($1 c) at }
 
 call_instr_params :
   | LPAR PARAM value_type_list RPAR call_instr_params
-    { fun c ->
-      let FuncType (ts1, ts2), es = $5 c in FuncType ($3 @ ts1, ts2), es }
+    { fun c -> let FuncType (ts1, ts2) = $5 c in FuncType ($3 @ ts1, ts2) }
   | call_instr_results
-    { fun c -> let ts, es = $1 c in FuncType ([], ts), es }
+    { fun c -> FuncType ([], $1 c) }
 
 call_instr_results :
   | LPAR RESULT value_type_list RPAR call_instr_results
+    { fun c -> $3 @ $5 c }
+  | /* empty */
+    { fun c -> [] }
+
+
+call_instr_instr :
+  | CALL_INDIRECT call_instr_type_instr
+    { let at1 = ati 1 in
+      fun c -> let x, es = $2 c in call_indirect x @@ at1, es }
+
+call_instr_type_instr :
+  | type_use call_instr_params_instr
+    { let at1 = ati 1 in
+      fun c ->
+      match $2 c with
+      | FuncType ([], []), es -> $1 c type_, es
+      | ft, es -> inline_type_explicit c ($1 c type_) ft at1, es }
+  | call_instr_params_instr
+    { let at = at () in
+      fun c -> let ft, es = $1 c in inline_type c ft at, es }
+
+call_instr_params_instr :
+  | LPAR PARAM value_type_list RPAR call_instr_params_instr
+    { fun c ->
+      let FuncType (ts1, ts2), es = $5 c in FuncType ($3 @ ts1, ts2), es }
+  | call_instr_results_instr
+    { fun c -> let ts, es = $1 c in FuncType ([], ts), es }
+
+call_instr_results_instr :
+  | LPAR RESULT value_type_list RPAR call_instr_results_instr
     { fun c -> let ts, es = $5 c in $3 @ ts, es }
   | instr
     { fun c -> [], $1 c }
 
+
 block_instr :
   | BLOCK labeling_opt block END labeling_end_opt
     { fun c -> let c' = $2 c $5 in let ts, es = $3 c' in block ts es }
@@ -430,6 +459,7 @@ if_ :
 
 instr_list :
   | /* empty */ { fun c -> [] }
+  | call_instr { fun c -> [$1 c] }
   | instr instr_list { fun c -> $1 c @ $2 c }
 
 expr_list :
diff --git a/test/core/stack.wast b/test/core/stack.wast
index b3f321eca..88147fa3d 100644
--- a/test/core/stack.wast
+++ b/test/core/stack.wast
@@ -130,3 +130,91 @@
 (assert_return (invoke "fac-expr" (i64.const 25)) (i64.const 7034535277573963776))
 (assert_return (invoke "fac-stack" (i64.const 25)) (i64.const 7034535277573963776))
 (assert_return (invoke "fac-mixed" (i64.const 25)) (i64.const 7034535277573963776))
+
+
+;; Syntax of flat call_indirect
+
+(module
+  (type $proc (func))
+  (table 1 anyfunc)
+
+  (func
+    (block i32.const 0 call_indirect)
+    (loop i32.const 0 call_indirect)
+    (if (i32.const 0) (then i32.const 0 call_indirect))
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect)
+      (else i32.const 0 call_indirect)
+    )
+    (block i32.const 0 call_indirect (type $proc))
+    (loop i32.const 0 call_indirect (type $proc))
+    (if (i32.const 0) (then i32.const 0 call_indirect (type $proc)))
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect (type $proc))
+      (else i32.const 0 call_indirect (type $proc))
+    )
+    (block i32.const 0 i32.const 0 call_indirect (param i32))
+    (loop i32.const 0 i32.const 0 call_indirect (param i32))
+    (if (i32.const 0) (then i32.const 0 i32.const 0 call_indirect (param i32)))
+    (if (i32.const 0)
+      (then i32.const 0 i32.const 0 call_indirect (param i32))
+      (else i32.const 0 i32.const 0 call_indirect (param i32))
+    )
+    (block (result i32) i32.const 0 call_indirect (result i32)) (drop)
+    (loop (result i32) i32.const 0 call_indirect (result i32)) (drop)
+    (if (result i32) (i32.const 0)
+      (then i32.const 0 call_indirect (result i32))
+      (else i32.const 0 call_indirect (result i32))
+    ) (drop)
+    (block i32.const 0 call_indirect (type $proc) (param) (result))
+    (loop i32.const 0 call_indirect (type $proc) (param) (result))
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect (type $proc) (param) (result))
+    )
+    (if (i32.const 0)
+      (then i32.const 0 call_indirect (type $proc) (param) (param) (result))
+      (else i32.const 0 call_indirect (type $proc) (param) (result) (result))
+    )
+
+    block i32.const 0 call_indirect end
+    loop i32.const 0 call_indirect end
+    i32.const 0 if i32.const 0 call_indirect end
+    i32.const 0 if i32.const 0 call_indirect else i32.const 0 call_indirect end
+    block i32.const 0 call_indirect (type $proc) end
+    loop i32.const 0 call_indirect (type $proc) end
+    i32.const 0 if i32.const 0 call_indirect (type $proc) end
+    i32.const 0
+    if
+      i32.const 0 call_indirect (type $proc)
+    else
+      i32.const 0 call_indirect (type $proc)
+    end
+    block i32.const 0 i32.const 0 call_indirect (param i32) end
+    loop i32.const 0 i32.const 0 call_indirect (param i32) end
+    i32.const 0 if i32.const 0 i32.const 0 call_indirect (param i32) end
+    i32.const 0
+    if
+      i32.const 0 i32.const 0 call_indirect (param i32)
+    else
+      i32.const 0 i32.const 0 call_indirect (param i32)
+    end
+    block (result i32) i32.const 0 call_indirect (result i32) end drop
+    loop (result i32) i32.const 0 call_indirect (result i32) end drop
+    i32.const 0
+    if (result i32)
+      i32.const 0 call_indirect (result i32)
+    else
+      i32.const 0 call_indirect (result i32)
+    end drop
+    block i32.const 0 call_indirect (type $proc) (param) (result) end
+    loop i32.const 0 call_indirect (type $proc) (param) (result) end
+    i32.const 0 if i32.const 0 call_indirect (type $proc) (param) (result) end
+    i32.const 0
+    if
+      i32.const 0 call_indirect (type $proc) (param) (result)
+    else
+      i32.const 0 call_indirect (type $proc) (param) (param) (result) (result)
+    end
+    i32.const 0 call_indirect
+  )
+)

From ffae2596a1583a0d0b19dcd48f9f3e49a3692a8d Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Sat, 3 Mar 2018 01:12:42 +0100
Subject: [PATCH 185/329] [spec] Normative: Detach previous JS ArrayBuffer from
 grow_memory

Closes #646
---
 document/js-api/index.bs | 32 +++++++++++++++++++++++++++-----
 1 file changed, 27 insertions(+), 5 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 19d19808f..567ff9c74 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -155,6 +155,10 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
     text: global type; url: syntax/types.html#syntax-globaltype
     text: address; url: exec/runtime.html#addresses
     text: signed_32; url: exec/numerics.html#aux-signed
+    text: grow_memory; url: exec/instructions.html#exec-grow-memory
+    text: current frame; url: exec/conventions.html#exec-notation-textual
+    text: 𝗆𝗈𝖽𝗎𝗅𝖾; url: exec/runtime.html#syntax-frame
+    text: 𝗆𝖾𝗆𝖺𝖽𝖽𝗋𝗌; url: exec/runtime.html#syntax-moduleinst
 </pre>
 
 <pre class='link-defaults'>
@@ -569,6 +573,18 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. [=Create a memory object=] from the memory address |memaddr| and return the result.
 </div>
 
+<div algorithm>
+    To <dfn>reset the Memory buffer</dfn> of |memaddr|, perform the following steps:
+
+    1. Let |map| be the [=surrounding agent=]'s associated [=Memory object cache=].
+    1. Assert: |map|[|memaddr|] [=map/exists=]
+    1. Let |memory| be |map|[|memaddr|].
+    1. Perform ! [=DetachArrayBuffer=](|memory|.\[[BufferObject]]).
+    1. Let |block| be a [=Data Block=] which is [=identified with=] the underlying memory of |memaddr|.
+    1. Let |buffer| be a new {{ArrayBuffer}} whose \[[ArrayBufferData]] is |block| and \[[ArrayBufferByteLength]] is set to the length of |block|.
+    1. Set |memory|.\[[BufferObject]] to |buffer|.
+</div>
+
 <div algorithm>
     The <dfn method for="Memory">grow(delta)</dfn> method, when invoked, performs the following steps:
     1. Let |memory| be the Memory instance.
@@ -578,14 +594,20 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Let |store| be [=grow_mem=](|store|, |memaddr|, |delta|).
     1. If |store| is [=error=], throw a {{RangeError}} exception.
     1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
-    1. Perform ! [=DetachArrayBuffer=](|memory|.\[[BufferObject]]).
-    1. Let |block| be a [=Data Block=] which is [=identified with=] the underlying memory of |memaddr|.
-    1. Assert: The size of |block| is the same as [=size_mem=](|store|, |memaddr|) * 64 Ki
-    1. Let |buffer| be a new {{ArrayBuffer}} whose \[[ArrayBufferData]] is |block| and \[[ArrayBufferByteLength]] is set to the length of |block|.
-    1. Set |memory|.\[[BufferObject]] to |buffer|.
+    1. [=Reset the memory buffer=] of |memaddr|.
     1. Return |ret|.
 </div>
 
+Immediately after a WebAssembly [=grow_memory=] instruction executes, perform the following steps:
+
+<div algorithm="grow_memory">
+    1. If the top of the stack is not [=𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] (−1), then:
+        1. Let |frame| be the [=current frame=].
+        1. Assert: due to validation, |frame|.[=𝗆𝗈𝖽𝗎𝗅𝖾=].[=𝗆𝖾𝗆𝖺𝖽𝖽𝗋𝗌=][0] exists.
+        1. Let |memaddr| be the memory address |frame|.[=𝗆𝗈𝖽𝗎𝗅𝖾=].[=𝗆𝖾𝗆𝖺𝖽𝖽𝗋𝗌=][0].
+        1. [=Reset the memory buffer=] of |memaddr|.
+</div>
+
 <h3 id="tables">Tables</h3>
 
 <pre class="idl">

From e72b2e6ba66f93761cbd9fc40ddd5a8ee8dfb07a Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 6 Mar 2018 08:41:56 +0100
Subject: [PATCH 186/329] [spec] Fix irem_s (#743)

---
 document/core/exec/numerics.rst | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/document/core/exec/numerics.rst b/document/core/exec/numerics.rst
index cd81a16db..efa583f44 100644
--- a/document/core/exec/numerics.rst
+++ b/document/core/exec/numerics.rst
@@ -291,7 +291,8 @@ The integer result of predicates -- i.e., :ref:`tests <syntax-testop>` and :ref:
 .. math::
    \begin{array}{@{}lcll}
    \irems_N(i_1, 0) &=& \{\} \\
-   \irems_N(i_1, i_2) &=& \signed_N^{-1}(i_1 - i_2 \cdot \trunc(\signed_N(i_1) / \signed_N(i_2))) \\
+   \irems_N(i_1, i_2) &=& \signed_N^{-1}(j_1 - j_2 \cdot \trunc(j_1 / j_2)) \\
+     && (\where j_1 = \signed_N(i_1) \wedge j_2 = \signed_N(i_2)) \\
    \end{array}
 
 .. note::

From 9ff693f553d5ba10364e284eb26f1983d6972a17 Mon Sep 17 00:00:00 2001
From: Andreas Haas <ahaas@google.com>
Date: Tue, 13 Mar 2018 13:47:23 +0100
Subject: [PATCH 187/329] [test] Remove redundant kExprReturn

---
 test/html/indexeddb.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/html/indexeddb.js b/test/html/indexeddb.js
index f6e18fb66..e9e827a94 100644
--- a/test/html/indexeddb.js
+++ b/test/html/indexeddb.js
@@ -65,8 +65,7 @@
                 .addBody([
                     kExprI32Const,
                     42,
-                    kExprReturn,
-                    kExprEnd
+                    kExprReturn
                 ])
                 .exportFunc();
             let source = builder.toBuffer();

From 8221194b9a712bb97b640997edf2003d71d1a17a Mon Sep 17 00:00:00 2001
From: Andreas Haas <ahaas@google.com>
Date: Tue, 13 Mar 2018 14:26:38 +0100
Subject: [PATCH 188/329] [test] Fix default imports in the multi-stage tests

---
 test/harness/index.js | 32 ++++++++++++++++++--------------
 1 file changed, 18 insertions(+), 14 deletions(-)

diff --git a/test/harness/index.js b/test/harness/index.js
index 8ac8909ed..bd57cc481 100644
--- a/test/harness/index.js
+++ b/test/harness/index.js
@@ -76,21 +76,25 @@ function reinitializeRegistry() {
     if (typeof WebAssembly === 'undefined')
         return;
 
-    registry = {
-        spectest: {
-            print: console.log.bind(console),
-            print_i32: console.log.bind(console),
-            print_i32_f32: console.log.bind(console),
-            print_f64_f64: console.log.bind(console),
-            print_f32: console.log.bind(console),
-            print_f64: console.log.bind(console),
-            global_i32: 666,
-            global_f32: 666,
-            global_f64: 666,
-            table: new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'}),
-            memory: new WebAssembly.Memory({initial: 1, maximum: 2})
-        }
+    let spectest = {
+        print: console.log.bind(console),
+        print_i32: console.log.bind(console),
+        print_i32_f32: console.log.bind(console),
+        print_f64_f64: console.log.bind(console),
+        print_f32: console.log.bind(console),
+        print_f64: console.log.bind(console),
+        global_i32: 666,
+        global_f32: 666,
+        global_f64: 666,
+        table: new WebAssembly.Table({initial: 10, maximum: 20, element: 'anyfunc'}),
+        memory: new WebAssembly.Memory({initial: 1, maximum: 2})
+    };
+    let handler = {
+        get(target, prop) {
+        return (prop in target) ?  target[prop] : {};
+      }
     };
+    registry = new Proxy({spectest}, handler);
 }
 
 reinitializeRegistry();

From 7b7911eba79c06fe0511f4af65771c8e4325ebf4 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 14 Mar 2018 09:57:03 +0100
Subject: [PATCH 189/329] [test/interpreter] Fix LEB128 check; add tests (#750)

---
 interpreter/binary/decode.ml |   2 +-
 test/core/binary.wast        | 225 +++++++++++++++++++++++++++++++++++
 2 files changed, 226 insertions(+), 1 deletion(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 68a8d9c4c..370386633 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -86,7 +86,7 @@ let rec vuN n s =
 let rec vsN n s =
   require (n > 0) s (pos s) "integer representation too long";
   let b = u8 s in
-  let mask = (-1 lsl n) land 0x7f in
+  let mask = (-1 lsl (n - 1)) land 0x7f in
   require (n >= 7 || b land mask = 0 || b land mask = mask) s (pos s - 1)
     "integer too large";
   let x = Int64.of_int (b land 0x7f) in
diff --git a/test/core/binary.wast b/test/core/binary.wast
index 8cfeed46f..2c43d0ced 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -43,6 +43,231 @@
 (assert_malformed (module binary "\00asm\00\00\01\00") "unknown binary version")
 (assert_malformed (module binary "\00asm\00\00\00\01") "unknown binary version")
 
+;; Unsigned LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\04\01"                          ;; Memory section with 1 entry
+  "\00\82\00"                          ;; no max, minimum 2
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\07\01"                          ;; Memory section with 1 entry
+  "\00\82\80\80\80\00"                 ;; no max, minimum 2
+)
+
+;; Signed LEB128 can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\00"                          ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\7f"                          ;; i32.const -1
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\80\80\80\80\00"                 ;; i32.const 0
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0a\01"                          ;; Global section with 1 entry
+  "\7f\00"                             ;; i32, immutable
+  "\41\ff\ff\ff\ff\7f"                 ;; i32.const -1
+  "\0b"                                ;; end
+)
+
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\00"                          ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\07\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\7f"                          ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with unused bits set
+  "\0b"                                ;; end
+)
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\06\0f\01"                          ;; Global section with 1 entry
+  "\7e\00"                             ;; i64, immutable
+  "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with unused bits unset
+  "\0b"                                ;; end
+)
+
+;; Unsigned LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\08\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\80\00"              ;; no max, minimum 2 with one byte too many
+  )
+  "integer representation too long"
+)
+
+;; Signed LEB128 must not be overlong
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\80\00"              ;; i32.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0b\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\ff\7f"              ;; i32.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\80\00"  ;; i64.const 0 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\10\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\ff\7f"  ;; i64.const -1 with one byte too many
+    "\0b"                                ;; end
+  )
+  "integer representation too long"
+)
+
+;; Unsigned LEB128s zero-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\04\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\05\04\01"                          ;; Memory section with 1 entry
+    "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
+  )
+  "integer too large"
+)
+
+;; Signed LEB128s sign-extend
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\70"                 ;; i32.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\0f"                 ;; i32.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\80\80\80\80\1f"                 ;; i32.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0a\01"                          ;; Global section with 1 entry
+    "\7f\00"                             ;; i32, immutable
+    "\41\ff\ff\ff\ff\4f"                 ;; i32.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\7e"  ;; i64.const 0 with unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\01"  ;; i64.const -1 with unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\80\80\80\80\80\80\80\80\80\02"  ;; i64.const 0 with some unused bits set
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\06\0f\01"                          ;; Global section with 1 entry
+    "\7e\00"                             ;; i64, immutable
+    "\42\ff\ff\ff\ff\ff\ff\ff\ff\ff\41"  ;; i64.const -1 with some unused bits unset
+    "\0b"                                ;; end
+  )
+  "integer too large"
+)
+
 ;; call_indirect reserved byte equal to zero.
 (assert_malformed
   (module binary

From bd027d6eb3449d1cd26ffcca6c4b074b9b0221af Mon Sep 17 00:00:00 2001
From: Sergey Pepyakin <s.pepyakin@gmail.com>
Date: Sun, 18 Mar 2018 16:05:14 +0300
Subject: [PATCH 190/329] [interpreter] Fix link in README (#754)

---
 interpreter/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index af0ba2042..2547f6a7e 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -162,7 +162,7 @@ WebAssemblyText.decode(binary)
 
 The implementation consumes a WebAssembly AST given in S-expression syntax. Here is an overview of the grammar of types, expressions, functions, and modules, mirroring what's described in the [design doc](https://github.com/WebAssembly/design/blob/master/Semantics.md).
 
-Note: The grammar is shown here for convenience, the definite source is the [specification of the text format](https://webassembly.github.io/spec/text/).
+Note: The grammar is shown here for convenience, the definite source is the [specification of the text format](https://webassembly.github.io/spec/core/text/).
 ```
 num:    <digit> (_? <digit>)*
 hexnum: <hexdigit> (_? <hexdigit>)*

From 34e5b0087dc88828e0fe18d953341d3fb820b6e2 Mon Sep 17 00:00:00 2001
From: Sergey Pepyakin <s.pepyakin@gmail.com>
Date: Tue, 20 Mar 2018 17:39:28 +0300
Subject: [PATCH 191/329] [test] Add type-br_if-after-unreachable test (#756)

---
 test/core/unreached-invalid.wast | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/test/core/unreached-invalid.wast b/test/core/unreached-invalid.wast
index e22b8b4c9..907049fa3 100644
--- a/test/core/unreached-invalid.wast
+++ b/test/core/unreached-invalid.wast
@@ -697,3 +697,13 @@
   ))
   "type mismatch"
 )
+(assert_invalid 
+  (module
+    (func $type-br_if-after-unreachable (result i64)
+      unreachable
+      br_if 0
+      i64.extend_u/i32
+    )
+  )
+ "type mismatch"
+)

From 25c72fb88fb7548246bfd54d701d4bc277c129ba Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Wed, 21 Mar 2018 10:26:27 +0100
Subject: [PATCH 192/329] Use async compilation in the Web Platform Tests
 (#755)

---
 test/build.py                            |  78 ++---
 test/harness/async_index.js              | 375 +++++++++++++++++++++++
 test/harness/{index.js => sync_index.js} |   0
 3 files changed, 415 insertions(+), 38 deletions(-)
 create mode 100644 test/harness/async_index.js
 rename test/harness/{index.js => sync_index.js} (100%)

diff --git a/test/build.py b/test/build.py
index a3cf7f334..a6304d0a1 100755
--- a/test/build.py
+++ b/test/build.py
@@ -108,7 +108,7 @@ def build_js(out_js_dir, include_harness=False):
 
         <script src={WPT_PREFIX}/testharness.js></script>
         <script src={WPT_PREFIX}/testharnessreport.js></script>
-        <script src={PREFIX}/index.js></script>
+        <script src={PREFIX}/{JS_HARNESS}></script>
         <script src={PREFIX}/wasm-constants.js></script>
         <script src={PREFIX}/wasm-module-builder.js></script>
 
@@ -120,74 +120,69 @@ def build_js(out_js_dir, include_harness=False):
 </html>
 """
 
-def build_html_js(out_dir, js_dir, include_harness=False):
-    if js_dir is None:
-        ensure_empty_dir(out_dir)
-        build_js(out_dir, include_harness)
-    else:
-        print('Copying JS files into the HTML dir...')
-        ensure_remove_dir(out_dir)
-        def ignore(_src, names):
-            if include_harness:
-                return []
-            return [name for name in names if os.path.basename(name) in HARNESS_FILES]
-        shutil.copytree(js_dir, out_dir, ignore=ignore)
-        print('Done copying JS files into the HTML dir.')
+def wrap_single_test(js_file):
+    test_func_name = os.path.basename(js_file).replace('.', '_').replace('-', '_')
+
+    content = ["(function {}() {{".format(test_func_name)]
+    with open(js_file, 'r') as f:
+        content += f.readlines()
+    content.append('reinitializeRegistry();')
+    content.append('})();')
+
+    with open(js_file, 'w') as f:
+        f.write('\n'.join(content))
+
+def build_html_js(out_dir):
+    ensure_empty_dir(out_dir)
+    build_js(out_dir, True)
 
     for js_file in glob.glob(os.path.join(HTML_TESTS_DIR, '*.js')):
         shutil.copy(js_file, out_dir)
 
-def build_html_from_js(js_html_dir, html_dir):
+    for js_file in glob.glob(os.path.join(out_dir, '*.js')):
+        wrap_single_test(js_file)
+
+def build_html_from_js(js_html_dir, html_dir, use_sync):
     for js_file in glob.glob(os.path.join(js_html_dir, '*.js')):
         js_filename = os.path.basename(js_file)
         html_filename = js_filename + '.html'
         html_file = os.path.join(html_dir, html_filename)
+        js_harness = "sync_index.js" if use_sync else "async_index.js"
         with open(html_file, 'w+') as f:
             content = HTML_HEADER.replace('{PREFIX}', './js/harness') \
-                                 .replace('{WPT_PREFIX}', WPT_URL_PREFIX)
+                                 .replace('{WPT_PREFIX}', './js/harness') \
+                                 .replace('{JS_HARNESS}', js_harness)
             content += "        <script src=./js/{SCRIPT}></script>".replace('{SCRIPT}', js_filename)
             content += HTML_BOTTOM
             f.write(content)
 
-def build_html(html_dir, js_dir):
+def build_html(html_dir, js_dir, use_sync):
     print("Building HTML tests...")
 
     js_html_dir = os.path.join(html_dir, 'js')
 
-    build_html_js(js_html_dir, js_dir)
+    build_html_js(js_html_dir)
 
     print('Building WPT tests from JS tests...')
-    build_html_from_js(js_html_dir, html_dir)
+    build_html_from_js(js_html_dir, html_dir, use_sync)
 
     print("Done building HTML tests.")
 
 
 # Front page harness.
-def wrap_single_test(js_file):
-    test_func_name = os.path.basename(js_file).replace('.', '_').replace('-', '_')
-
-    content = ["(function {}() {{".format(test_func_name)]
-    with open(js_file, 'r') as f:
-        content += f.readlines()
-    content.append('reinitializeRegistry();')
-    content.append('})();')
-
-    with open(js_file, 'w') as f:
-        f.write('\n'.join(content))
-
-def build_front_page(out_dir, js_dir):
+def build_front_page(out_dir, js_dir, use_sync):
     print('Building front page containing all the HTML tests...')
 
     js_out_dir = os.path.join(out_dir, 'js')
 
-    build_html_js(js_out_dir, js_dir, include_harness=True)
-    for js_file in glob.glob(os.path.join(js_out_dir, '*.js')):
-        wrap_single_test(js_file)
+    build_html_js(js_out_dir)
 
     front_page = os.path.join(out_dir, 'index.html')
+    js_harness = "sync_index.js" if use_sync else "async_index.js"
     with open(front_page, 'w+') as f:
         content = HTML_HEADER.replace('{PREFIX}', './js/harness') \
-                             .replace('{WPT_PREFIX}', './js/harness')
+                             .replace('{WPT_PREFIX}', './js/harness')\
+                             .replace('{JS_HARNESS}', js_harness)
         for js_file in glob.glob(os.path.join(js_out_dir, '*.js')):
             filename = os.path.basename(js_file)
             content += "        <script src=./js/{SCRIPT}></script>\n".replace('{SCRIPT}', filename)
@@ -223,6 +218,13 @@ def process_args():
                         const=False,
                         default=True)
 
+    parser.add_argument('--use-sync',
+                        action="store_const",
+                        dest="use_sync",
+                        help="Let the tests use the synchronous JS API (by default, it does not)",
+                        const=True,
+                        default=False)
+
     return parser.parse_args(), parser
 
 if __name__ == '__main__':
@@ -248,10 +250,10 @@ def process_args():
 
     if html_dir is not None:
         ensure_empty_dir(html_dir)
-        build_html(html_dir, js_dir)
+        build_html(html_dir, js_dir, args.use_sync)
 
     if front_dir is not None:
         ensure_empty_dir(front_dir)
-        build_front_page(front_dir, js_dir)
+        build_front_page(front_dir, js_dir, args.use_sync)
 
     print('Done!')
diff --git a/test/harness/async_index.js b/test/harness/async_index.js
new file mode 100644
index 000000000..cc252f50e
--- /dev/null
+++ b/test/harness/async_index.js
@@ -0,0 +1,375 @@
+/*
+ * Copyright 2018 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+"use strict";
+
+let testNum = (function() {
+  let count = 1;
+  return function() {
+    return `#${count++} `;
+  };
+})();
+
+function uniqueTest(func, desc) {
+  test(func, testNum() + desc);
+}
+
+// WPT's assert_throw uses a list of predefined, hardcoded known errors. Since
+// it is not aware of the WebAssembly error types (yet), implement our own
+// version.
+function assertThrows(func, err) {
+  let caught = false;
+  try {
+    func();
+  } catch (e) {
+    assert_true(
+      e instanceof err,
+      `expected ${err.name}, observed ${e.constructor.name}`
+    );
+    caught = true;
+  }
+  assert_true(caught, testNum() + "assertThrows must catch any error.");
+}
+
+/******************************************************************************
+ ***************************** WAST HARNESS ************************************
+ ******************************************************************************/
+
+const EXPECT_INVALID = false;
+
+/* DATA **********************************************************************/
+
+// Default imports.
+var registry = {};
+
+// All tests run asynchronously and return their results as promises. To ensure
+// that all tests execute in the correct order, we chain the promises together
+// so that a test is only executed when all previous tests have finished their
+// execution.
+let chain = Promise.resolve();
+
+// Resets the registry between two different WPT tests.
+function reinitializeRegistry() {
+  if (typeof WebAssembly === "undefined") return;
+
+  chain = chain.then(_ => {
+    let spectest = {
+      print: console.log.bind(console),
+      print_i32: console.log.bind(console),
+      print_i32_f32: console.log.bind(console),
+      print_f64_f64: console.log.bind(console),
+      print_f32: console.log.bind(console),
+      print_f64: console.log.bind(console),
+      global_i32: 666,
+      global_f32: 666,
+      global_f64: 666,
+      table: new WebAssembly.Table({
+        initial: 10,
+        maximum: 20,
+        element: "anyfunc"
+      }),
+      memory: new WebAssembly.Memory({ initial: 1, maximum: 2 })
+    };
+    let handler = {
+      get(target, prop) {
+        return prop in target ? target[prop] : {};
+      }
+    };
+    registry = new Proxy({ spectest }, handler);
+  });
+
+  // This function is called at the end of every generated js test file. By
+  // adding the chain as a promise_test here we make sure that the WPT harness
+  // waits for all tests in the chain to finish.
+  promise_test(_ => chain, testNum() + "Reinitialize the default imports");
+}
+
+reinitializeRegistry();
+
+/* WAST POLYFILL *************************************************************/
+
+function binary(bytes) {
+  let buffer = new ArrayBuffer(bytes.length);
+  let view = new Uint8Array(buffer);
+  for (let i = 0; i < bytes.length; ++i) {
+    view[i] = bytes.charCodeAt(i);
+  }
+  return buffer;
+}
+
+/**
+ * Returns a compiled module, or throws if there was an error at compilation.
+ */
+function module(bytes, valid = true) {
+  const test = valid
+    ? "Test that WebAssembly compilation succeeds"
+    : "Test that WebAssembly compilation fails";
+  const loc = new Error().stack.toString().replace("Error", "");
+  let buffer = binary(bytes);
+  let validated = WebAssembly.validate(buffer);
+
+  uniqueTest(_ => {
+    assert_equals(valid, validated);
+  }, test);
+
+  chain = chain.then(_ => WebAssembly.compile(buffer)).then(
+    module => {
+      uniqueTest(_ => {
+        assert_true(valid, loc);
+      }, test);
+      return module;
+    },
+    error => {
+      uniqueTest(_ => {
+        assert_true(
+          !valid,
+          `WebAssembly.compile failed unexpectedly with ${error} at {loc}`
+        );
+      }, test);
+    }
+  );
+  return chain;
+}
+
+function assert_invalid(bytes) {
+  module(bytes, EXPECT_INVALID);
+}
+
+const assert_malformed = assert_invalid;
+
+function instance(bytes, imports, valid = true) {
+  const test = valid
+    ? "Test that WebAssembly instantiation succeeds"
+    : "Test that WebAssembly instantiation fails";
+  const loc = new Error().stack.toString().replace("Error", "");
+  chain = Promise.all([imports, chain])
+    .then(values => {
+      let imports = values[0] ? values[0] : registry;
+      return WebAssembly.instantiate(binary(bytes), imports);
+    })
+    .then(
+      pair => {
+        uniqueTest(_ => {
+          assert_true(valid, loc);
+        }, test);
+        return pair.instance;
+      },
+      error => {
+        uniqueTest(_ => {
+          assert_true(
+            !valid,
+            `unexpected instantiation error, observed ${error} ${loc}`
+          );
+        }, test);
+        return error;
+      }
+    );
+  return chain;
+}
+
+function exports(name, instance) {
+  return instance.then(inst => {
+    return { [name]: inst.exports };
+  });
+}
+
+function call(instance, name, args) {
+  return Promise.all([instance, chain]).then(values => {
+    return values[0].exports[name](...args);
+  });
+}
+
+function run(action) {
+  const test = "Run a WebAssembly test without special assertions";
+  const loc = new Error().stack.toString().replace("Error", "");
+  chain = Promise.all([chain, action()])
+    .then(
+      _ => {
+        uniqueTest(_ => {}, test);
+      },
+      error => {
+        uniqueTest(_ => {
+          assert_true(
+            false,
+            `unexpected runtime error, observed ${error} ${loc}`
+          );
+        }, "run");
+      }
+    )
+    // Clear all exceptions, so that subsequent tests get executed.
+    .catch(_ => {});
+}
+
+function assert_trap(action) {
+  const test = "Test that a WebAssembly code traps";
+  const loc = new Error().stack.toString().replace("Error", "");
+  chain = Promise.all([chain, action()])
+    .then(
+      result => {
+        uniqueTest(_ => {
+          assert_true(false, loc);
+        }, test);
+      },
+      error => {
+        uniqueTest(_ => {
+          assert_true(
+            error instanceof WebAssembly.RuntimeError,
+            `expected runtime error, observed ${error} ${loc}`
+          );
+        }, test);
+      }
+    )
+    // Clear all exceptions, so that subsequent tests get executed.
+    .catch(_ => {});
+}
+
+function assert_return(action, expected) {
+  const test = "Test that a WebAssembly code returns a specific result";
+  const loc = new Error().stack.toString().replace("Error", "");
+  chain = Promise.all([action(), chain])
+    .then(
+      values => {
+        uniqueTest(_ => {
+          assert_equals(values[0], expected, loc);
+        }, test);
+      },
+      error => {
+        uniqueTest(_ => {
+          assert_true(
+            false,
+            `unexpected runtime error, observed ${error} ${loc}`
+          );
+        }, test);
+      }
+    )
+    // Clear all exceptions, so that subsequent tests get executed.
+    .catch(_ => {});
+}
+
+let StackOverflow;
+try {
+  (function f() {
+    1 + f();
+  })();
+} catch (e) {
+  StackOverflow = e.constructor;
+}
+
+function assert_exhaustion(action) {
+  const test = "Test that a WebAssembly code exhauts the stack space";
+  const loc = new Error().stack.toString().replace("Error", "");
+  chain = Promise.all([action(), chain])
+    .then(
+      _ => {
+        uniqueTest(_ => {
+          assert_true(false, loc);
+        }, test);
+      },
+      error => {
+        uniqueTest(_ => {
+          assert_true(
+            error instanceof StackOverflow,
+            `expected runtime error, observed ${error} ${loc}`
+          );
+        }, test);
+      }
+    )
+    // Clear all exceptions, so that subsequent tests get executed.
+    .catch(_ => {});
+}
+
+function assert_unlinkable(bytes) {
+  const test = "Test that a WebAssembly module is unlinkable";
+  const loc = new Error().stack.toString().replace("Error", "");
+  instance(bytes, registry, EXPECT_INVALID)
+    .then(
+      result => {
+        uniqueTest(_ => {
+          assert_true(
+            result instanceof WebAssembly.LinkError,
+            `expected link error, observed ${result} ${loc}`
+          );
+        }, test);
+      },
+      _ => {
+        uniqueTest(_ => {
+          assert_true(false, loc);
+        }, test);
+      }
+    )
+    // Clear all exceptions, so that subsequent tests get executed.
+    .catch(_ => {});
+}
+
+function assert_uninstantiable(bytes) {
+  const test = "Test that a WebAssembly module is uninstantiable";
+  const loc = new Error().stack.toString().replace("Error", "");
+  instance(bytes, registry, EXPECT_INVALID)
+    .then(
+      result => {
+        uniqueTest(_ => {
+          assert_true(
+            result instanceof WebAssembly.RuntimeError,
+            `expected link error, observed ${result} ${loc}`
+          );
+        }, test);
+      },
+      _ => {
+        uniqueTest(_ => {
+          assert_true(false, loc);
+        }, test);
+      }
+    )
+    // Clear all exceptions, so that subsequent tests get executed.
+    .catch(_ => {});
+}
+
+function register(name, instance) {
+  const test =
+    "Test that the exports of a WebAssembly module can be registered";
+  const loc = new Error().stack.toString().replace("Error", "");
+  let stack = new Error();
+  chain = Promise.all([instance, chain])
+    .then(
+      values => {
+        registry[name] = values[0].exports;
+      },
+      _ => {
+        uniqueTest(_ => {
+          assert_true(false, loc);
+        }, test);
+      }
+    )
+    // Clear all exceptions, so that subsequent tests get executed.
+    .catch(_ => {});
+}
+
+function get(instance, name) {
+  const test = "Test that an export of a WebAssembly instance can be acquired";
+  const loc = new Error().stack.toString().replace("Error", "");
+  chain = Promise.all([instance, chain]).then(
+    values => {
+      return values[0].exports[name];
+    },
+    _ => {
+      uniqueTest(_ => {
+        assert_true(false, loc);
+      }, test);
+    }
+  );
+  return chain;
+}
+
diff --git a/test/harness/index.js b/test/harness/sync_index.js
similarity index 100%
rename from test/harness/index.js
rename to test/harness/sync_index.js

From ea77d90eeebe6ae9b3b38c5d8f9c11a7d199ff8e Mon Sep 17 00:00:00 2001
From: Sergey Pepyakin <s.pepyakin@gmail.com>
Date: Fri, 23 Mar 2018 00:13:56 +0300
Subject: [PATCH 193/329] [test] Import referring undefined type is invalid
 (#758)

---
 test/core/imports.wast | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/test/core/imports.wast b/test/core/imports.wast
index 7c17f805b..9b7b0ece0 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -87,6 +87,14 @@
 (assert_return (invoke "print32" (i32.const 13)))
 (assert_return (invoke "print64" (i64.const 24)))
 
+(assert_invalid
+  (module 
+    (type (func (result i32)))
+    (import "test" "func" (func (type 1)))
+  )
+  "unknown type"
+)
+
 (module (import "test" "func" (func)))
 (module (import "test" "func-i32" (func (param i32))))
 (module (import "test" "func-f32" (func (param f32))))

From 2b2f147c54de05a2d4c4ecd8f33a5bd728ba08f4 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 28 Mar 2018 08:14:05 +0200
Subject: [PATCH 194/329] [interpreter] Tweak ocamlbuild tags

---
 interpreter/Makefile | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/interpreter/Makefile b/interpreter/Makefile
index 2973a5f23..69a6b402b 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -29,6 +29,7 @@ JS =		# set to JS shell command to run JS tests
 .PHONY:		default opt unopt libopt libunopt jslib all land zip
 
 default:	opt
+debug:		unopt
 opt:		$(OPT)
 unopt:		$(UNOPT)
 libopt:		_build/$(LIB).cmx
@@ -48,16 +49,17 @@ comma =		,
 .INTERMEDIATE:	_tags
 _tags:
 		echo >$@ "true: bin_annot"
+		echo >>$@ "true: debug"
 		echo >>$@ "<{$(subst $(space),$(comma),$(DIRS))}/*.cmx>: for-pack($(PACK))"
 
-$(UNOPT):	main.d.byte
+$(UNOPT):	main.byte
 		mv $< $@
 
 $(OPT):		main.native
 		mv $< $@
 
-.PHONY:		main.d.byte main.native
-main.d.byte:	_tags
+.PHONY:		main.byte main.native
+main.byte:	_tags
 		$(OCB) -quiet $@
 
 main.native:	_tags

From 586d34770c6445bfb93c9bae8ac50baade7ee168 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 28 Mar 2018 09:43:07 +0200
Subject: [PATCH 195/329] [interpreter] Fix len32 check to unsigned (#760)

---
 interpreter/binary/decode.ml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 370386633..51df069fb 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -105,7 +105,7 @@ let f64 s = F64.of_bits (u64 s)
 let len32 s =
   let pos = pos s in
   let n = vu32 s in
-  if n <= Int32.of_int (len s) then Int32.to_int n else
+  if I32.le_u n (Int32.of_int (len s)) then Int32.to_int n else
     error s pos "length out of bounds"
 
 let bool s = (vu1 s = 1)

From 8313bd8262cd101c7e8cfda02ae243c1453fe3e8 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 28 Mar 2018 18:26:21 +0200
Subject: [PATCH 196/329] [interpreter] Fix local decoding (#761)

---
 interpreter/binary/decode.ml |  4 ++--
 interpreter/util/lib.ml      | 15 ++++++++++-----
 interpreter/util/lib.mli     |  1 +
 3 files changed, 13 insertions(+), 7 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 51df069fb..9f8530ec8 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -572,9 +572,9 @@ let start_section s =
 (* Code section *)
 
 let local s =
-  let n = len32 s in
+  let n = vu32 s in
   let t = value_type s in
-  Lib.List.make n t
+  Lib.List32.make n t
 
 let code _ s =
   let locals = List.flatten (vec local s) in
diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index 1be774ba1..01fc24efe 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -45,12 +45,13 @@ end
 
 module List =
 struct
-  let rec make n x =
-    if n = 0 then [] else x :: make (n - 1) x
+  let rec make n x = make' n x []
+  and make' n x xs =
+    if n = 0 then xs else make' (n - 1) x (x::xs)
 
-  let rec table n f = table' 0 n f
-  and table' i n f =
-    if i = n then [] else f i :: table' (i + 1) n f
+  let rec table n f = table' n f []
+  and table' n f xs =
+    if n = 0 then xs else table' (n - 1) f (f (n - 1) :: xs)
 
   let rec take n xs =
     match n, xs with
@@ -93,6 +94,10 @@ end
 
 module List32 =
 struct
+  let rec make n x = make' n x []
+  and make' n x xs =
+    if n = 0l then xs else make' (Int32.sub n 1l) x (x::xs)
+
   let rec length xs = length' xs 0l
   and length' xs n =
     match xs with
diff --git a/interpreter/util/lib.mli b/interpreter/util/lib.mli
index 5c3b80157..da4a58562 100644
--- a/interpreter/util/lib.mli
+++ b/interpreter/util/lib.mli
@@ -22,6 +22,7 @@ end
 
 module List32 :
 sig
+  val make : int32 -> 'a -> 'a list
   val length : 'a list -> int32
   val nth : 'a list -> int32 -> 'a (* raises Failure *)
   val take : int32 -> 'a list -> 'a list (* raises Failure *)

From 04a9b6efadc1189ab26cc517090e69409dd26ddc Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 4 Apr 2018 14:57:36 +0200
Subject: [PATCH 197/329] Fix typos

---
 document/core/exec/instructions.rst |  4 ++--
 interpreter/exec/eval.ml            |  2 +-
 interpreter/syntax/ast.ml           |  4 ++--
 interpreter/syntax/operators.ml     |  4 ++--
 interpreter/text/arrange.ml         |  4 ++--
 interpreter/text/parser.mly         |  4 ++--
 interpreter/valid/valid.ml          | 12 +++++++-----
 7 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index f0990ad26..5472b73e5 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -823,7 +823,7 @@ Control Instructions
 
 2. Let :math:`n` be the arity of :math:`F`.
 
-3. Assert: due to :ref:`validation <valid-br>`, there are at least :math:`n` values on the top of the stack.
+3. Assert: due to :ref:`validation <valid-return>`, there are at least :math:`n` values on the top of the stack.
 
 4. Pop the results :math:`\val^n` from the stack.
 
@@ -1049,7 +1049,7 @@ Invocation of :ref:`function address <syntax-funcaddr>` :math:`a`
 Returning from a function
 .........................
 
-When the end of a funtion is reached without a jump (i.e., |RETURN|) or trap aborting it, then the following steps are performed.
+When the end of a function is reached without a jump (i.e., |RETURN|) or trap aborting it, then the following steps are performed.
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index a6bc8f397..a8b69ea7b 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -50,12 +50,12 @@ type code = value stack * admin_instr list
 and admin_instr = admin_instr' phrase
 and admin_instr' =
   | Plain of instr'
+  | Invoke of func_inst
   | Trapping of string
   | Returning of value stack
   | Breaking of int32 * value stack
   | Label of int * instr list * code
   | Frame of int * frame * code
-  | Invoke of func_inst
 
 type config =
 {
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index e2efa7ee8..4ae9c5875 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -71,6 +71,8 @@ type instr = instr' Source.phrase
 and instr' =
   | Unreachable                       (* trap unconditionally *)
   | Nop                               (* do nothing *)
+  | Drop                              (* forget a value *)
+  | Select                            (* branchless conditional *)
   | Block of stack_type * instr list  (* execute in sequence *)
   | Loop of stack_type * instr list   (* loop header *)
   | If of stack_type * instr list * instr list  (* conditional *)
@@ -80,8 +82,6 @@ and instr' =
   | Return                            (* break from function body *)
   | Call of var                       (* call function *)
   | CallIndirect of var               (* call function through table *)
-  | Drop                              (* forget a value *)
-  | Select                            (* branchless conditional *)
   | GetLocal of var                   (* read local variable *)
   | SetLocal of var                   (* write local variable *)
   | TeeLocal of var                   (* write local variable and keep value *)
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index b207b193d..8f177bd2b 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -13,15 +13,15 @@ let f64_const n = Const (F64 n.it @@ n.at)
 let unreachable = Unreachable
 let nop = Nop
 let drop = Drop
+let select = Select
 let block ts es = Block (ts, es)
 let loop ts es = Loop (ts, es)
 let br x = Br x
 let br_if x = BrIf x
 let br_table xs x = BrTable (xs, x)
-let return = Return
 let if_ ts es1 es2 = If (ts, es1, es2)
-let select = Select
 
+let return = Return
 let call x = Call x
 let call_indirect x = CallIndirect x
 
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index c12d268b8..6c9feebe2 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -223,6 +223,8 @@ let rec instr e =
     match e.it with
     | Unreachable -> "unreachable", []
     | Nop -> "nop", []
+    | Drop -> "drop", []
+    | Select -> "select", []
     | Block (ts, es) -> "block", stack_type ts @ list instr es
     | Loop (ts, es) -> "loop", stack_type ts @ list instr es
     | If (ts, es1, es2) ->
@@ -235,8 +237,6 @@ let rec instr e =
     | Return -> "return", []
     | Call x -> "call " ^ var x, []
     | CallIndirect x -> "call_indirect", [Node ("type " ^ var x, [])]
-    | Drop -> "drop", []
-    | Select -> "select", []
     | GetLocal x -> "get_local " ^ var x, []
     | SetLocal x -> "set_local " ^ var x, []
     | TeeLocal x -> "tee_local " ^ var x, []
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 5ee439128..fc437bc5d 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -301,6 +301,8 @@ instr :
 plain_instr :
   | UNREACHABLE { fun c -> unreachable }
   | NOP { fun c -> nop }
+  | DROP { fun c -> drop }
+  | SELECT { fun c -> select }
   | BR var { fun c -> br ($2 c label) }
   | BR_IF var { fun c -> br_if ($2 c label) }
   | BR_TABLE var var_list
@@ -308,8 +310,6 @@ plain_instr :
       br_table xs x }
   | RETURN { fun c -> return }
   | CALL var { fun c -> call ($2 c func) }
-  | DROP { fun c -> drop }
-  | SELECT { fun c -> select }
   | GET_LOCAL var { fun c -> get_local ($2 c local) }
   | SET_LOCAL var { fun c -> set_local ($2 c local) }
   | TEE_LOCAL var { fun c -> tee_local ($2 c local) }
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 3bdb5e282..0170e084d 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -182,6 +182,13 @@ let rec check_instr (c : context) (e : instr) (s : infer_stack_type) : op_type =
   | Nop ->
     [] --> []
 
+  | Drop ->
+    [peek 0 s] -~> []
+
+  | Select ->
+    let t = peek 1 s in
+    [t; t; Some I32Type] -~> [t]
+
   | Block (ts, es) ->
     check_arity (List.length ts) e.at;
     check_block {c with labels = ts :: c.labels} es ts e.at;
@@ -221,12 +228,7 @@ let rec check_instr (c : context) (e : instr) (s : infer_stack_type) : op_type =
     let FuncType (ins, out) = type_ c x in
     (ins @ [I32Type]) --> out
 
-  | Drop ->
-    [peek 0 s] -~> []
 
-  | Select ->
-    let t = peek 1 s in
-    [t; t; Some I32Type] -~> [t]
 
   | GetLocal x ->
     [] --> [local c x]

From b3de271e8da3f8aa29a9ea3455665f88b1a4c3d2 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 4 Apr 2018 15:44:08 +0200
Subject: [PATCH 198/329] [spec] Rename memory instructions (#720)

---
 document/core/appendix/index-instructions.rst |  4 +-
 document/core/binary/instructions.rst         | 10 ++---
 document/core/exec/instructions.rst           | 28 +++++++-------
 document/core/syntax/instructions.rst         |  8 ++--
 document/core/text/instructions.rst           |  8 ++--
 document/core/util/macros.def                 |  4 +-
 document/core/valid/instructions.rst          | 14 +++----
 interpreter/README.md                         |  4 +-
 interpreter/binary/decode.ml                  |  4 +-
 interpreter/binary/encode.ml                  | 38 +++++++++----------
 interpreter/exec/eval.ml                      |  4 +-
 interpreter/runtime/memory.ml                 | 18 ++++-----
 interpreter/runtime/memory.mli                |  8 ++--
 interpreter/syntax/ast.ml                     |  8 ++--
 interpreter/syntax/operators.ml               | 34 ++++++++---------
 interpreter/text/arrange.ml                   | 16 ++++----
 interpreter/text/lexer.mll                    |  4 +-
 interpreter/text/parser.mly                   |  6 +--
 interpreter/valid/valid.ml                    |  8 ++--
 test/Todo.md                                  |  6 +--
 test/core/binary.wast                         | 12 +++---
 test/core/br.wast                             |  6 +--
 test/core/br_table.wast                       |  6 +--
 test/core/imports.wast                        |  2 +-
 test/core/linking.wast                        |  2 +-
 test/core/memory.wast                         | 10 ++---
 test/core/memory_trap.wast                    |  8 ++--
 test/core/nop.wast                            | 12 +++---
 test/core/resizing.wast                       |  8 ++--
 test/core/return.wast                         |  6 +--
 test/core/typecheck.wast                      |  4 +-
 test/core/unreachable.wast                    |  6 +--
 test/harness/wasm-constants.js                |  2 +-
 33 files changed, 159 insertions(+), 159 deletions(-)

diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index f5811e024..a8f51ad38 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -70,8 +70,8 @@ Instruction                          Binary Opcode     Type
 :math:`\I64.\STORE\K{8}~\memarg`     :math:`\hex{3C}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
 :math:`\I64.\STORE\K{16}~\memarg`    :math:`\hex{3D}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
 :math:`\I64.\STORE\K{32}~\memarg`    :math:`\hex{3E}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
-:math:`\CURRENTMEMORY`               :math:`\hex{3F}`  :math:`[] \to [\I32]`                       :ref:`validation <valid-current_memory>`  :ref:`execution <exec-current_memory>`
-:math:`\GROWMEMORY`                  :math:`\hex{40}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-grow_memory>`     :ref:`execution <exec-grow_memory>`
+:math:`\MEMORYSIZE`                  :math:`\hex{3F}`  :math:`[] \to [\I32]`                       :ref:`validation <valid-memory.size>`     :ref:`execution <exec-memory.size>`
+:math:`\MEMORYGROW`                  :math:`\hex{40}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-memory.grow>`     :ref:`execution <exec-memory.grow>`
 :math:`\I32.\CONST~\i32`             :math:`\hex{41}`  :math:`[] \to [\I32]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
 :math:`\I64.\CONST~\i64`             :math:`\hex{42}`  :math:`[] \to [\I64]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
 :math:`\F32.\CONST~\f32`             :math:`\hex{43}`  :math:`[] \to [\F32]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index faf5411de..7e4fbbb32 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -124,8 +124,8 @@ Each variant of :ref:`memory instruction <syntax-instr-memory>` is encoded with
 .. _binary-loadn:
 .. _binary-store:
 .. _binary-storen:
-.. _binary-current_memory:
-.. _binary-grow_memory:
+.. _binary-memory.size:
+.. _binary-memory.grow:
 
 .. math::
    \begin{array}{llclll}
@@ -155,12 +155,12 @@ Each variant of :ref:`memory instruction <syntax-instr-memory>` is encoded with
      \hex{3C}~~m{:}\Bmemarg &\Rightarrow& \I64.\STORE\K{8}~m \\ &&|&
      \hex{3D}~~m{:}\Bmemarg &\Rightarrow& \I64.\STORE\K{16}~m \\ &&|&
      \hex{3E}~~m{:}\Bmemarg &\Rightarrow& \I64.\STORE\K{32}~m \\ &&|&
-     \hex{3F}~~\hex{00} &\Rightarrow& \CURRENTMEMORY \\ &&|&
-     \hex{40}~~\hex{00} &\Rightarrow& \GROWMEMORY \\
+     \hex{3F}~~\hex{00} &\Rightarrow& \MEMORYSIZE \\ &&|&
+     \hex{40}~~\hex{00} &\Rightarrow& \MEMORYGROW \\
    \end{array}
 
 .. note::
-   In future versions of WebAssembly, the additional zero bytes occurring in the encoding of the |CURRENTMEMORY| and |GROWMEMORY| instructions may be used to index additional memories.
+   In future versions of WebAssembly, the additional zero bytes occurring in the encoding of the |MEMORYSIZE| and |MEMORYGROW| instructions may be used to index additional memories.
 
 
 .. index:: numeric instruction
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 5472b73e5..64f4e96a5 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -533,18 +533,18 @@ Memory Instructions
    \end{array}
 
 
-.. _exec-current_memory:
+.. _exec-memory.size:
 
-:math:`\CURRENTMEMORY`
-......................
+:math:`\MEMORYSIZE`
+...................
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-current_memory>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+2. Assert: due to :ref:`validation <valid-memory.size>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
 
 3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
 
-4. Assert: due to :ref:`validation <valid-current_memory>`, :math:`S.\SMEMS[a]` exists.
+4. Assert: due to :ref:`validation <valid-memory.size>`, :math:`S.\SMEMS[a]` exists.
 
 5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
 
@@ -555,31 +555,31 @@ Memory Instructions
 .. math::
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   S; F; \CURRENTMEMORY &\stepto& S; F; (\I32.\CONST~\X{sz})
+   S; F; \MEMORYSIZE &\stepto& S; F; (\I32.\CONST~\X{sz})
    \end{array}
    \\ \qquad
      (\iff |S.\SMEMS[F.\AMODULE.\MIMEMS[0]].\MIDATA| = \X{sz}\cdot64\,\F{Ki}) \\
    \end{array}
 
 
-.. _exec-grow_memory:
+.. _exec-memory.grow:
 
-:math:`\GROWMEMORY`
+:math:`\MEMORYGROW`
 ...................
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-grow_memory>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
+2. Assert: due to :ref:`validation <valid-memory.grow>`, :math:`F.\AMODULE.\MIMEMS[0]` exists.
 
 3. Let :math:`a` be the :ref:`memory address <syntax-memaddr>` :math:`F.\AMODULE.\MIMEMS[0]`.
 
-4. Assert: due to :ref:`validation <valid-grow_memory>`, :math:`S.\SMEMS[a]` exists.
+4. Assert: due to :ref:`validation <valid-memory.grow>`, :math:`S.\SMEMS[a]` exists.
 
 5. Let :math:`\X{mem}` be the :ref:`memory instance <syntax-meminst>` :math:`S.\SMEMS[a]`.
 
 6. Let :math:`\X{sz}` be the length of :math:`S.\SMEMS[a]` divided by the :ref:`page size <page-size>`.
 
-7. Assert: due to :ref:`validation <valid-grow_memory>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
+7. Assert: due to :ref:`validation <valid-memory.grow>`, a value of :ref:`value type <syntax-valtype>` |I32| is on the top of the stack.
 
 8. Pop the value :math:`\I32.\CONST~n` from the stack.
 
@@ -595,7 +595,7 @@ Memory Instructions
    ~\\[-1ex]
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~n)~\GROWMEMORY &\stepto& S'; F; (\I32.\CONST~\X{sz})
+   S; F; (\I32.\CONST~n)~\MEMORYGROW &\stepto& S'; F; (\I32.\CONST~\X{sz})
    \end{array}
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
@@ -605,12 +605,12 @@ Memory Instructions
      \end{array}
    \\[1ex]
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\I32.\CONST~n)~\GROWMEMORY &\stepto& S; F; (\I32.\CONST~{-1})
+   S; F; (\I32.\CONST~n)~\MEMORYGROW &\stepto& S; F; (\I32.\CONST~{-1})
    \end{array}
    \end{array}
 
 .. note::
-   The |GROWMEMORY| instruction is non-deterministic.
+   The |MEMORYGROW| instruction is non-deterministic.
    It may either succeed, returning the old memory size :math:`\X{sz}`,
    or fail, returning :math:`{-1}`.
    Failure *must* occur if the referenced memory instance has a maximum size defined that would be exceeded.
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 060933bf7..1b8e195db 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -240,8 +240,8 @@ Instructions in this group are concerned with linear :ref:`memory <syntax-mem>`.
      \K{i}\X{nn}\K{.}\STORE\K{8}~\memarg ~|~
      \K{i}\X{nn}\K{.}\STORE\K{16}~\memarg ~|~
      \K{i64.}\STORE\K{32}~\memarg \\&&|&
-     \CURRENTMEMORY \\&&|&
-     \GROWMEMORY \\
+     \MEMORYSIZE \\&&|&
+     \MEMORYGROW \\
    \end{array}
 
 Memory is accessed with |LOAD| and |STORE| instructions for the different :ref:`value types <syntax-valtype>`.
@@ -256,8 +256,8 @@ A :ref:`trap <trap>` results if any of the accessed memory bytes lies outside th
 .. note::
    Future version of WebAssembly might provide memory instructions with 64 bit address ranges.
 
-The |CURRENTMEMORY| instruction returns the current size of a memory.
-The |GROWMEMORY| instruction grows memory by a given delta and returns the previous size, or :math:`-1` if enough memory cannot be allocated.
+The |MEMORYSIZE| instruction returns the current size of a memory.
+The |MEMORYGROW| instruction grows memory by a given delta and returns the previous size, or :math:`-1` if enough memory cannot be allocated.
 Both instructions operate in units of :ref:`page size <page-size>`.
 
 .. note::
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index dadd435b0..7a0eadda2 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -173,8 +173,8 @@ Memory Instructions
 .. _text-loadn:
 .. _text-store:
 .. _text-storen:
-.. _text-current_memory:
-.. _text-grow_memory:
+.. _text-memory.size:
+.. _text-memory.grow:
 
 The offset and alignment immediates to memory instructions are optional.
 The offset defaults to :math:`\T{0}`, the alignment to the storage size of the respective memory access, which is its *natural alignment*.
@@ -214,8 +214,8 @@ Lexically, an |Toffset| or |Talign| phrase is considered a single :ref:`keyword
      \text{i64.store8}~~m{:}\Tmemarg_1 &\Rightarrow& \I64.\STORE\K{8}~m \\ &&|&
      \text{i64.store16}~~m{:}\Tmemarg_2 &\Rightarrow& \I64.\STORE\K{16}~m \\ &&|&
      \text{i64.store32}~~m{:}\Tmemarg_4 &\Rightarrow& \I64.\STORE\K{32}~m \\ &&|&
-     \text{current\_memory} &\Rightarrow& \CURRENTMEMORY \\ &&|&
-     \text{grow\_memory} &\Rightarrow& \GROWMEMORY \\
+     \text{memory.size} &\Rightarrow& \MEMORYSIZE \\ &&|&
+     \text{memory.grow} &\Rightarrow& \MEMORYGROW \\
    \end{array}
 
 
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index 2216694b1..ea5be82d8 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -325,8 +325,8 @@
 
 .. |LOAD| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{load}}
 .. |STORE| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{store}}
-.. |CURRENTMEMORY| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{current\_memory}}
-.. |GROWMEMORY| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{grow\_memory}}
+.. |MEMORYSIZE| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{memory.size}}
+.. |MEMORYGROW| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{memory.grow}}
 
 .. |CONST| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{const}}
 .. |EQZ| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{eqz}}
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index ffc308ff2..9ef152bad 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -389,10 +389,10 @@ Memory Instructions
    }
 
 
-.. _valid-current_memory:
+.. _valid-memory.size:
 
-:math:`\CURRENTMEMORY`
-......................
+:math:`\MEMORYSIZE`
+...................
 
 * The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
@@ -402,13 +402,13 @@ Memory Instructions
    \frac{
      C.\CMEMS[0] = \memtype
    }{
-     C \vdashinstr \CURRENTMEMORY : [] \to [\I32]
+     C \vdashinstr \MEMORYSIZE : [] \to [\I32]
    }
 
 
-.. _valid-grow_memory:
+.. _valid-memory.grow:
 
-:math:`\GROWMEMORY`
+:math:`\MEMORYGROW`
 ...................
 
 * The memory :math:`C.\CMEMS[0]` must be defined in the context.
@@ -419,7 +419,7 @@ Memory Instructions
    \frac{
      C.\CMEMS[0] = \memtype
    }{
-     C \vdashinstr \GROWMEMORY : [\I32] \to [\I32]
+     C \vdashinstr \MEMORYGROW : [\I32] \to [\I32]
    }
 
 
diff --git a/interpreter/README.md b/interpreter/README.md
index 2547f6a7e..65155ff8a 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -225,8 +225,8 @@ op:
   set_global <var>
   <val_type>.load((8|16|32)_<sign>)? <offset>? <align>?
   <val_type>.store(8|16|32)? <offset>? <align>?
-  current_memory
-  grow_memory
+  memory.size
+  memory.grow
   <val_type>.const <value>
   <val_type>.<unop>
   <val_type>.<binop>
diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 9f8530ec8..1c6da1d4b 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -289,10 +289,10 @@ let rec instr s =
 
   | 0x3f ->
     expect 0x00 s "zero flag expected";
-    current_memory
+    memory_size
   | 0x40 ->
     expect 0x00 s "zero flag expected";
-    grow_memory
+    memory_grow
 
   | 0x41 -> i32_const (at vs32 s)
   | 0x42 -> i64_const (at vs64 s)
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index adbf418a4..696dac418 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -171,27 +171,27 @@ let encode m =
       | Load ({ty = I64Type; sz = None; _} as mo) -> op 0x29; memop mo
       | Load ({ty = F32Type; sz = None; _} as mo) -> op 0x2a; memop mo
       | Load ({ty = F64Type; sz = None; _} as mo) -> op 0x2b; memop mo
-      | Load ({ty = I32Type; sz = Some (Mem8, SX); _} as mo) ->
+      | Load ({ty = I32Type; sz = Some (Pack8, SX); _} as mo) ->
         op 0x2c; memop mo
-      | Load ({ty = I32Type; sz = Some (Mem8, ZX); _} as mo) ->
+      | Load ({ty = I32Type; sz = Some (Pack8, ZX); _} as mo) ->
         op 0x2d; memop mo
-      | Load ({ty = I32Type; sz = Some (Mem16, SX); _} as mo) ->
+      | Load ({ty = I32Type; sz = Some (Pack16, SX); _} as mo) ->
         op 0x2e; memop mo
-      | Load ({ty = I32Type; sz = Some (Mem16, ZX); _} as mo) ->
+      | Load ({ty = I32Type; sz = Some (Pack16, ZX); _} as mo) ->
         op 0x2f; memop mo
-      | Load {ty = I32Type; sz = Some (Mem32, _); _} ->
+      | Load {ty = I32Type; sz = Some (Pack32, _); _} ->
         assert false
-      | Load ({ty = I64Type; sz = Some (Mem8, SX); _} as mo) ->
+      | Load ({ty = I64Type; sz = Some (Pack8, SX); _} as mo) ->
         op 0x30; memop mo
-      | Load ({ty = I64Type; sz = Some (Mem8, ZX); _} as mo) ->
+      | Load ({ty = I64Type; sz = Some (Pack8, ZX); _} as mo) ->
         op 0x31; memop mo
-      | Load ({ty = I64Type; sz = Some (Mem16, SX); _} as mo) ->
+      | Load ({ty = I64Type; sz = Some (Pack16, SX); _} as mo) ->
         op 0x32; memop mo
-      | Load ({ty = I64Type; sz = Some (Mem16, ZX); _} as mo) ->
+      | Load ({ty = I64Type; sz = Some (Pack16, ZX); _} as mo) ->
         op 0x33; memop mo
-      | Load ({ty = I64Type; sz = Some (Mem32, SX); _} as mo) ->
+      | Load ({ty = I64Type; sz = Some (Pack32, SX); _} as mo) ->
         op 0x34; memop mo
-      | Load ({ty = I64Type; sz = Some (Mem32, ZX); _} as mo) ->
+      | Load ({ty = I64Type; sz = Some (Pack32, ZX); _} as mo) ->
         op 0x35; memop mo
       | Load {ty = F32Type | F64Type; sz = Some _; _} ->
         assert false
@@ -200,16 +200,16 @@ let encode m =
       | Store ({ty = I64Type; sz = None; _} as mo) -> op 0x37; memop mo
       | Store ({ty = F32Type; sz = None; _} as mo) -> op 0x38; memop mo
       | Store ({ty = F64Type; sz = None; _} as mo) -> op 0x39; memop mo
-      | Store ({ty = I32Type; sz = Some Mem8; _} as mo) -> op 0x3a; memop mo
-      | Store ({ty = I32Type; sz = Some Mem16; _} as mo) -> op 0x3b; memop mo
-      | Store {ty = I32Type; sz = Some Mem32; _} -> assert false
-      | Store ({ty = I64Type; sz = Some Mem8; _} as mo) -> op 0x3c; memop mo
-      | Store ({ty = I64Type; sz = Some Mem16; _} as mo) -> op 0x3d; memop mo
-      | Store ({ty = I64Type; sz = Some Mem32; _} as mo) -> op 0x3e; memop mo
+      | Store ({ty = I32Type; sz = Some Pack8; _} as mo) -> op 0x3a; memop mo
+      | Store ({ty = I32Type; sz = Some Pack16; _} as mo) -> op 0x3b; memop mo
+      | Store {ty = I32Type; sz = Some Pack32; _} -> assert false
+      | Store ({ty = I64Type; sz = Some Pack8; _} as mo) -> op 0x3c; memop mo
+      | Store ({ty = I64Type; sz = Some Pack16; _} as mo) -> op 0x3d; memop mo
+      | Store ({ty = I64Type; sz = Some Pack32; _} as mo) -> op 0x3e; memop mo
       | Store {ty = F32Type | F64Type; sz = Some _; _} -> assert false
 
-      | CurrentMemory -> op 0x3f; u8 0x00
-      | GrowMemory -> op 0x40; u8 0x00
+      | MemorySize -> op 0x3f; u8 0x00
+      | MemoryGrow -> op 0x40; u8 0x00
 
       | Const {it = I32 c; _} -> op 0x41; vs32 c
       | Const {it = I64 c; _} -> op 0x42; vs64 c
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index a8b69ea7b..ca82b7345 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -214,11 +214,11 @@ let rec step (c : config) : config =
           vs', []
         with exn -> vs', [Trapping (memory_error e.at exn) @@ e.at]);
 
-      | CurrentMemory, vs ->
+      | MemorySize, vs ->
         let mem = memory frame.inst (0l @@ e.at) in
         I32 (Memory.size mem) :: vs, []
 
-      | GrowMemory, I32 delta :: vs' ->
+      | MemoryGrow, I32 delta :: vs' ->
         let mem = memory frame.inst (0l @@ e.at) in
         let old_size = Memory.size mem in
         let result =
diff --git a/interpreter/runtime/memory.ml b/interpreter/runtime/memory.ml
index fd9783d93..d1f2bce98 100644
--- a/interpreter/runtime/memory.ml
+++ b/interpreter/runtime/memory.ml
@@ -7,7 +7,7 @@ type size = int32  (* number of pages *)
 type address = int64
 type offset = int32
 
-type mem_size = Mem8 | Mem16 | Mem32
+type pack_size = Pack8 | Pack16 | Pack32
 type extension = SX | ZX
 
 type memory' = (int, int8_unsigned_elt, c_layout) Array1.t
@@ -22,10 +22,10 @@ exception OutOfMemory
 
 let page_size = 0x10000L (* 64 KiB *)
 
-let mem_size = function
-  | Mem8 -> 1
-  | Mem16 -> 2
-  | Mem32 -> 4
+let packed_size = function
+  | Pack8 -> 1
+  | Pack16 -> 2
+  | Pack32 -> 4
 
 let within_limits n = function
   | None -> true
@@ -126,8 +126,8 @@ let extend x n = function
   | SX -> let sh = 64 - 8 * n in Int64.(shift_right (shift_left x sh) sh)
 
 let load_packed sz ext mem a o t =
-  assert (mem_size sz <= Types.size t);
-  let n = mem_size sz in
+  assert (packed_size sz <= Types.size t);
+  let n = packed_size sz in
   let x = extend (loadn mem a o n) n ext in
   match t with
   | I32Type -> I32 (Int64.to_int32 x)
@@ -135,8 +135,8 @@ let load_packed sz ext mem a o t =
   | _ -> raise Type
 
 let store_packed sz mem a o v =
-  assert (mem_size sz <= Types.size (Values.type_of v));
-  let n = mem_size sz in
+  assert (packed_size sz <= Types.size (Values.type_of v));
+  let n = packed_size sz in
   let x =
     match v with
     | I32 x -> Int64.of_int32 x
diff --git a/interpreter/runtime/memory.mli b/interpreter/runtime/memory.mli
index c5586e7b9..2a2b8ae47 100644
--- a/interpreter/runtime/memory.mli
+++ b/interpreter/runtime/memory.mli
@@ -8,7 +8,7 @@ type size = int32  (* number of pages *)
 type address = int64
 type offset = int32
 
-type mem_size = Mem8 | Mem16 | Mem32
+type pack_size = Pack8 | Pack16 | Pack32
 type extension = SX | ZX
 
 exception Type
@@ -18,7 +18,7 @@ exception SizeLimit
 exception OutOfMemory
 
 val page_size : int64
-val mem_size : mem_size -> int
+val packed_size : pack_size -> int
 
 val alloc : memory_type -> memory (* raises SizeOverflow, OutOfMemory *)
 val type_of : memory -> memory_type
@@ -37,8 +37,8 @@ val load_value :
 val store_value :
   memory -> address -> offset -> value -> unit (* raises Bounds *)
 val load_packed :
-  mem_size -> extension -> memory -> address -> offset -> value_type -> value
+  pack_size -> extension -> memory -> address -> offset -> value_type -> value
     (* raises Type, Bounds *)
 val store_packed :
-  mem_size -> memory -> address -> offset -> value -> unit
+  pack_size -> memory -> address -> offset -> value -> unit
     (* raises Type, Bounds *)
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index 4ae9c5875..51b2f9213 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -57,8 +57,8 @@ type cvtop = (I32Op.cvtop, I64Op.cvtop, F32Op.cvtop, F64Op.cvtop) Values.op
 
 type 'a memop =
   {ty : value_type; align : int; offset : Memory.offset; sz : 'a option}
-type loadop = (Memory.mem_size * Memory.extension) memop
-type storeop = Memory.mem_size memop
+type loadop = (Memory.pack_size * Memory.extension) memop
+type storeop = Memory.pack_size memop
 
 
 (* Expressions *)
@@ -89,8 +89,8 @@ and instr' =
   | SetGlobal of var                  (* write global variable *)
   | Load of loadop                    (* read memory at address *)
   | Store of storeop                  (* write memory at address *)
-  | CurrentMemory                     (* size of linear memory *)
-  | GrowMemory                        (* grow linear memory *)
+  | MemorySize                        (* size of linear memory *)
+  | MemoryGrow                        (* grow linear memory *)
   | Const of literal                  (* constant *)
   | Test of testop                    (* numeric test *)
   | Compare of relop                  (* numeric comparison *)
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index 8f177bd2b..2b84fcea0 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -36,40 +36,40 @@ let i64_load align offset = Load {ty = I64Type; align; offset; sz = None}
 let f32_load align offset = Load {ty = F32Type; align; offset; sz = None}
 let f64_load align offset = Load {ty = F64Type; align; offset; sz = None}
 let i32_load8_s align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Mem8, SX)}
+  Load {ty = I32Type; align; offset; sz = Some (Pack8, SX)}
 let i32_load8_u align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Mem8, ZX)}
+  Load {ty = I32Type; align; offset; sz = Some (Pack8, ZX)}
 let i32_load16_s align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Mem16, SX)}
+  Load {ty = I32Type; align; offset; sz = Some (Pack16, SX)}
 let i32_load16_u align offset =
-  Load {ty = I32Type; align; offset; sz = Some (Mem16, ZX)}
+  Load {ty = I32Type; align; offset; sz = Some (Pack16, ZX)}
 let i64_load8_s align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Mem8, SX)}
+  Load {ty = I64Type; align; offset; sz = Some (Pack8, SX)}
 let i64_load8_u align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Mem8, ZX)}
+  Load {ty = I64Type; align; offset; sz = Some (Pack8, ZX)}
 let i64_load16_s align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Mem16, SX)}
+  Load {ty = I64Type; align; offset; sz = Some (Pack16, SX)}
 let i64_load16_u align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Mem16, ZX)}
+  Load {ty = I64Type; align; offset; sz = Some (Pack16, ZX)}
 let i64_load32_s align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Mem32, SX)}
+  Load {ty = I64Type; align; offset; sz = Some (Pack32, SX)}
 let i64_load32_u align offset =
-  Load {ty = I64Type; align; offset; sz = Some (Mem32, ZX)}
+  Load {ty = I64Type; align; offset; sz = Some (Pack32, ZX)}
 
 let i32_store align offset = Store {ty = I32Type; align; offset; sz = None}
 let i64_store align offset = Store {ty = I64Type; align; offset; sz = None}
 let f32_store align offset = Store {ty = F32Type; align; offset; sz = None}
 let f64_store align offset = Store {ty = F64Type; align; offset; sz = None}
 let i32_store8 align offset =
-  Store {ty = I32Type; align; offset; sz = Some Mem8}
+  Store {ty = I32Type; align; offset; sz = Some Pack8}
 let i32_store16 align offset =
-  Store {ty = I32Type; align; offset; sz = Some Mem16}
+  Store {ty = I32Type; align; offset; sz = Some Pack16}
 let i64_store8 align offset =
-  Store {ty = I64Type; align; offset; sz = Some Mem8}
+  Store {ty = I64Type; align; offset; sz = Some Pack8}
 let i64_store16 align offset =
-  Store {ty = I64Type; align; offset; sz = Some Mem16}
+  Store {ty = I64Type; align; offset; sz = Some Pack16}
 let i64_store32 align offset =
-  Store {ty = I64Type; align; offset; sz = Some Mem32}
+  Store {ty = I64Type; align; offset; sz = Some Pack32}
 
 let i32_clz = Unary (I32 I32Op.Clz)
 let i32_ctz = Unary (I32 I32Op.Ctz)
@@ -199,6 +199,6 @@ let i64_reinterpret_f64 = Convert (I64 I64Op.ReinterpretFloat)
 let f32_reinterpret_i32 = Convert (F32 F32Op.ReinterpretInt)
 let f64_reinterpret_i64 = Convert (F64 F64Op.ReinterpretInt)
 
-let current_memory = CurrentMemory
-let grow_memory = GrowMemory
+let memory_size = MemorySize
+let memory_grow = MemoryGrow
 
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 6c9feebe2..76f279aba 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -187,10 +187,10 @@ let testop = oper (IntOp.testop, FloatOp.testop)
 let relop = oper (IntOp.relop, FloatOp.relop)
 let cvtop = oper (IntOp.cvtop, FloatOp.cvtop)
 
-let mem_size = function
-  | Memory.Mem8 -> "8"
-  | Memory.Mem16 -> "16"
-  | Memory.Mem32 -> "32"
+let pack_size = function
+  | Memory.Pack8 -> "8"
+  | Memory.Pack16 -> "16"
+  | Memory.Pack32 -> "32"
 
 let extension = function
   | Memory.SX -> "_s"
@@ -204,12 +204,12 @@ let memop name {ty; align; offset; _} =
 let loadop op =
   match op.sz with
   | None -> memop "load" op
-  | Some (sz, ext) -> memop ("load" ^ mem_size sz ^ extension ext) op
+  | Some (sz, ext) -> memop ("load" ^ pack_size sz ^ extension ext) op
 
 let storeop op =
   match op.sz with
   | None -> memop "store" op
-  | Some sz -> memop ("store" ^ mem_size sz) op
+  | Some sz -> memop ("store" ^ pack_size sz) op
 
 
 (* Expressions *)
@@ -244,8 +244,8 @@ let rec instr e =
     | SetGlobal x -> "set_global " ^ var x, []
     | Load op -> loadop op, []
     | Store op -> storeop op, []
-    | CurrentMemory -> "current_memory", []
-    | GrowMemory -> "grow_memory", []
+    | MemorySize -> "memory.size", []
+    | MemoryGrow -> "memory.grow", []
     | Const lit -> constop lit ^ " " ^ value lit, []
     | Test op -> testop op, []
     | Compare op -> relop op, []
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index 2a41d8cfe..3b67da7ce 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -314,8 +314,8 @@ rule token = parse
   | "i32.reinterpret/f32" { CONVERT i32_reinterpret_f32 }
   | "i64.reinterpret/f64" { CONVERT i64_reinterpret_f64 }
 
-  | "current_memory" { CURRENT_MEMORY }
-  | "grow_memory" { GROW_MEMORY }
+  | "memory.size" { MEMORY_SIZE }
+  | "memory.grow" { MEMORY_GROW }
 
   | "type" { TYPE }
   | "func" { FUNC }
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index fc437bc5d..c72b3cf3f 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -151,7 +151,7 @@ let inline_type_explicit (c : context) x ft at =
 %token GET_LOCAL SET_LOCAL TEE_LOCAL GET_GLOBAL SET_GLOBAL
 %token LOAD STORE OFFSET_EQ_NAT ALIGN_EQ_NAT
 %token CONST UNARY BINARY TEST COMPARE CONVERT
-%token UNREACHABLE CURRENT_MEMORY GROW_MEMORY
+%token UNREACHABLE MEMORY_SIZE MEMORY_GROW
 %token FUNC START TYPE PARAM RESULT LOCAL GLOBAL
 %token TABLE ELEM MEMORY DATA OFFSET IMPORT EXPORT TABLE
 %token MODULE BIN QUOTE
@@ -317,8 +317,8 @@ plain_instr :
   | SET_GLOBAL var { fun c -> set_global ($2 c global) }
   | LOAD offset_opt align_opt { fun c -> $1 $3 $2 }
   | STORE offset_opt align_opt { fun c -> $1 $3 $2 }
-  | CURRENT_MEMORY { fun c -> current_memory }
-  | GROW_MEMORY { fun c -> grow_memory }
+  | MEMORY_SIZE { fun c -> memory_size }
+  | MEMORY_GROW { fun c -> memory_grow }
   | CONST literal { fun c -> fst (literal $1 $2) }
   | TEST { fun c -> $1 }
   | COMPARE { fun c -> $1 }
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 0170e084d..d3d8a4155 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -143,9 +143,9 @@ let check_memop (c : context) (memop : 'a memop) get_sz at =
     match get_sz memop.sz with
     | None -> size memop.ty
     | Some sz ->
-      require (memop.ty = I64Type || sz <> Memory.Mem32) at
+      require (memop.ty = I64Type || sz <> Memory.Pack32) at
         "memory size too big";
-      Memory.mem_size sz
+      Memory.packed_size sz
   in
   require (1 lsl memop.align <= size) at
     "alignment must not be larger than natural"
@@ -256,11 +256,11 @@ let rec check_instr (c : context) (e : instr) (s : infer_stack_type) : op_type =
     check_memop c memop (fun sz -> sz) e.at;
     [I32Type; memop.ty] --> []
 
-  | CurrentMemory ->
+  | MemorySize ->
     ignore (memory c (0l @@ e.at));
     [] --> [I32Type]
 
-  | GrowMemory ->
+  | MemoryGrow ->
     ignore (memory c (0l @@ e.at));
     [I32Type] --> [I32Type]
 
diff --git a/test/Todo.md b/test/Todo.md
index b98f989ec..4a2831d70 100644
--- a/test/Todo.md
+++ b/test/Todo.md
@@ -4,11 +4,11 @@ have a link to an open issue/PR, or be obvious. Comments/corrections/additions
 welcome.
 
 Linear memory semantics:
- - test that newly allocated memory (program start and `grow_memory`) is zeroed
- - test that `grow_memory` does a full 32-bit unsigned check for page-size divisibility
+ - test that newly allocated memory (program start and `memory.grow`) is zeroed
+ - test that `memory.grow` does a full 32-bit unsigned check for page-size divisibility
  - test that load/store addreses are full int32 (or int64), and not OCaml int
  - test that when allocating 4GiB, accessing index -1 fails
- - test that too-big `grow_memory` fails appropriately
+ - test that too-big `memory.grow` fails appropriately
  - test that too-big linear memory initial allocation fails
  - test that one can clobber the entire contents of the linear memory without corrupting: call stack, local variables, program execution.
  - test that an i64 store with 4-byte alignment that's 4 bytes out of bounds traps without storing anything.
diff --git a/test/core/binary.wast b/test/core/binary.wast
index 2c43d0ced..74692eb24 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -287,7 +287,7 @@
   "zero flag expected"
 )
 
-;; grow_memory reserved byte equal to zero.
+;; memory.grow reserved byte equal to zero.
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
@@ -299,15 +299,15 @@
     ;; function 0
     "\07\00"
     "\41\00"                   ;; i32.const 0
-    "\40"                      ;; grow_memory
-    "\01"                      ;; grow_memory reserved byte is not equal to zero!
+    "\40"                      ;; memory.grow
+    "\01"                      ;; memory.grow reserved byte is not equal to zero!
     "\1a"                      ;; drop
     "\0b"                      ;; end
   )
   "zero flag expected"
 )
 
-;; current_memory reserved byte equal to zero.
+;; memory.size reserved byte equal to zero.
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
@@ -318,8 +318,8 @@
 
     ;; function 0
     "\05\00"
-    "\3f"                      ;; current_memory
-    "\01"                      ;; current_memory reserved byte is not equal to zero!
+    "\3f"                      ;; memory.size
+    "\01"                      ;; memory.size reserved byte is not equal to zero!
     "\1a"                      ;; drop
     "\0b"                      ;; end
   )
diff --git a/test/core/br.wast b/test/core/br.wast
index 5e99209c7..e801a1b47 100644
--- a/test/core/br.wast
+++ b/test/core/br.wast
@@ -238,8 +238,8 @@
     (block (result i32) (i32.wrap/i64 (br 0 (i32.const 41))))
   )
 
-  (func (export "as-grow_memory-size") (result i32)
-    (block (result i32) (grow_memory (br 0 (i32.const 40))))
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br 0 (i32.const 40))))
   )
 
   (func (export "nested-block-value") (result i32)
@@ -398,7 +398,7 @@
 
 (assert_return (invoke "as-convert-operand") (i32.const 41))
 
-(assert_return (invoke "as-grow_memory-size") (i32.const 40))
+(assert_return (invoke "as-memory.grow-size") (i32.const 40))
 
 (assert_return (invoke "nested-block-value") (i32.const 9))
 (assert_return (invoke "nested-br-value") (i32.const 9))
diff --git a/test/core/br_table.wast b/test/core/br_table.wast
index 986089239..81259cacc 100644
--- a/test/core/br_table.wast
+++ b/test/core/br_table.wast
@@ -1098,8 +1098,8 @@
     )
   )
 
-  (func (export "as-grow_memory-size") (result i32)
-    (block (result i32) (grow_memory (br_table 0 (i32.const 40) (i32.const 0))))
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br_table 0 (i32.const 40) (i32.const 0))))
   )
 
   (func (export "nested-block-value") (param i32) (result i32)
@@ -1363,7 +1363,7 @@
 
 (assert_return (invoke "as-convert-operand") (i32.const 41))
 
-(assert_return (invoke "as-grow_memory-size") (i32.const 40))
+(assert_return (invoke "as-memory.grow-size") (i32.const 40))
 
 (assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 19))
 (assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 17))
diff --git a/test/core/imports.wast b/test/core/imports.wast
index 9b7b0ece0..691550bd3 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -486,7 +486,7 @@
 
 (module
   (import "spectest" "memory" (memory 0 3))  ;; actual has max size 2
-  (func (export "grow") (param i32) (result i32) (grow_memory (get_local 0)))
+  (func (export "grow") (param i32) (result i32) (memory.grow (get_local 0)))
 )
 (assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
diff --git a/test/core/linking.wast b/test/core/linking.wast
index 898d5a215..e75c9ec89 100644
--- a/test/core/linking.wast
+++ b/test/core/linking.wast
@@ -274,7 +274,7 @@
   (memory (import "Mm" "mem") 1 8)
 
   (func (export "grow") (param $a i32) (result i32)
-    (grow_memory (get_local 0))
+    (memory.grow (get_local 0))
   )
 )
 
diff --git a/test/core/memory.wast b/test/core/memory.wast
index c6f8cd5d4..ee35e1ee3 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -8,11 +8,11 @@
 (assert_invalid (module (memory 0) (memory 0)) "multiple memories")
 (assert_invalid (module (memory (import "spectest" "memory") 0) (memory 0)) "multiple memories")
 
-(module (memory (data)) (func (export "memsize") (result i32) (current_memory)))
+(module (memory (data)) (func (export "memsize") (result i32) (memory.size)))
 (assert_return (invoke "memsize") (i32.const 0))
-(module (memory (data "")) (func (export "memsize") (result i32) (current_memory)))
+(module (memory (data "")) (func (export "memsize") (result i32) (memory.size)))
 (assert_return (invoke "memsize") (i32.const 0))
-(module (memory (data "x")) (func (export "memsize") (result i32) (current_memory)))
+(module (memory (data "x")) (func (export "memsize") (result i32) (memory.size)))
 (assert_return (invoke "memsize") (i32.const 1))
 
 (assert_invalid (module (data (i32.const 0))) "unknown memory")
@@ -36,11 +36,11 @@
   "unknown memory"
 )
 (assert_invalid
-  (module (func (drop (current_memory))))
+  (module (func (drop (memory.size))))
   "unknown memory"
 )
 (assert_invalid
-  (module (func (drop (grow_memory (i32.const 0)))))
+  (module (func (drop (memory.grow (i32.const 0)))))
   "unknown memory"
 )
 
diff --git a/test/core/memory_trap.wast b/test/core/memory_trap.wast
index 5fd193de2..b79627d7c 100644
--- a/test/core/memory_trap.wast
+++ b/test/core/memory_trap.wast
@@ -2,7 +2,7 @@
     (memory 1)
 
     (func $addr_limit (result i32)
-      (i32.mul (current_memory) (i32.const 0x10000))
+      (i32.mul (memory.size) (i32.const 0x10000))
     )
 
     (func (export "store") (param $i i32) (param $v i32)
@@ -13,8 +13,8 @@
       (i32.load (i32.add (call $addr_limit) (get_local $i)))
     )
 
-    (func (export "grow_memory") (param i32) (result i32)
-      (grow_memory (get_local 0))
+    (func (export "memory.grow") (param i32) (result i32)
+      (memory.grow (get_local 0))
     )
 )
 
@@ -30,7 +30,7 @@
 (assert_trap (invoke "load" (i32.const 0)) "out of bounds memory access")
 (assert_trap (invoke "store" (i32.const 0x80000000) (i32.const 13)) "out of bounds memory access")
 (assert_trap (invoke "load" (i32.const 0x80000000)) "out of bounds memory access")
-(assert_return (invoke "grow_memory" (i32.const 0x10001)) (i32.const -1))
+(assert_return (invoke "memory.grow" (i32.const 0x10001)) (i32.const -1))
 
 (module
   (memory 1)
diff --git a/test/core/nop.wast b/test/core/nop.wast
index 286231558..02b402816 100644
--- a/test/core/nop.wast
+++ b/test/core/nop.wast
@@ -172,11 +172,11 @@
     (nop) (get_local 0) (nop) (nop) (get_local 0) (nop) (nop) (i32.le_s)
   )
 
-  (func (export "as-grow_memory-last") (param i32) (result i32)
-    (get_local 0) (nop) (grow_memory)
+  (func (export "as-memory.grow-last") (param i32) (result i32)
+    (get_local 0) (nop) (memory.grow)
   )
-  (func (export "as-grow_memory-everywhere") (param i32) (result i32)
-    (nop) (nop) (get_local 0) (nop) (nop) (grow_memory)
+  (func (export "as-memory.grow-everywhere") (param i32) (result i32)
+    (nop) (nop) (get_local 0) (nop) (nop) (memory.grow)
   )
 )
 
@@ -243,8 +243,8 @@
 (assert_return (invoke "as-compare-last" (i32.const 3)) (i32.const 0))
 (assert_return (invoke "as-compare-everywhere" (i32.const 3)) (i32.const 1))
 
-(assert_return (invoke "as-grow_memory-last" (i32.const 2)) (i32.const 1))
-(assert_return (invoke "as-grow_memory-everywhere" (i32.const 12)) (i32.const 3))
+(assert_return (invoke "as-memory.grow-last" (i32.const 2)) (i32.const 1))
+(assert_return (invoke "as-memory.grow-everywhere" (i32.const 12)) (i32.const 3))
 
 (assert_invalid
   (module (func $type-i32 (result i32) (nop)))
diff --git a/test/core/resizing.wast b/test/core/resizing.wast
index 80d20b56a..183332efd 100644
--- a/test/core/resizing.wast
+++ b/test/core/resizing.wast
@@ -7,8 +7,8 @@
     (func (export "load_at_page_size") (result i32) (i32.load (i32.const 0x10000)))
     (func (export "store_at_page_size") (i32.store (i32.const 0x10000) (i32.const 3)))
 
-    (func (export "grow") (param $sz i32) (result i32) (grow_memory (get_local $sz)))
-    (func (export "size") (result i32) (current_memory))
+    (func (export "grow") (param $sz i32) (result i32) (memory.grow (get_local $sz)))
+    (func (export "size") (result i32) (memory.size))
 )
 
 (assert_return (invoke "size") (i32.const 0))
@@ -35,7 +35,7 @@
 
 (module
   (memory 0)
-  (func (export "grow") (param i32) (result i32) (grow_memory (get_local 0)))
+  (func (export "grow") (param i32) (result i32) (memory.grow (get_local 0)))
 )
 
 (assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
@@ -47,7 +47,7 @@
 
 (module
   (memory 0 10)
-  (func (export "grow") (param i32) (result i32) (grow_memory (get_local 0)))
+  (func (export "grow") (param i32) (result i32) (memory.grow (get_local 0)))
 )
 
 (assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
diff --git a/test/core/return.wast b/test/core/return.wast
index d483b5e51..727680a17 100644
--- a/test/core/return.wast
+++ b/test/core/return.wast
@@ -196,8 +196,8 @@
     (i32.wrap/i64 (return (i32.const 41)))
   )
 
-  (func (export "as-grow_memory-size") (result i32)
-    (grow_memory (return (i32.const 40)))
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (return (i32.const 40)))
   )
 )
 
@@ -278,7 +278,7 @@
 
 (assert_return (invoke "as-convert-operand") (i32.const 41))
 
-(assert_return (invoke "as-grow_memory-size") (i32.const 40))
+(assert_return (invoke "as-memory.grow-size") (i32.const 40))
 
 (assert_invalid
   (module (func $type-value-empty-vs-num (result f64) (return)))
diff --git a/test/core/typecheck.wast b/test/core/typecheck.wast
index b322b526f..0ac0c75e2 100644
--- a/test/core/typecheck.wast
+++ b/test/core/typecheck.wast
@@ -421,5 +421,5 @@
 (assert_invalid (module (func (f64.promote/f32 (i32.const 0)))) "type mismatch")
 (assert_invalid (module (func (f64.reinterpret/i64 (i32.const 0)))) "type mismatch")
 
-;; grow_memory
-(assert_invalid (module (memory 1) (func (grow_memory (f32.const 0)))) "type mismatch")
+;; memory.grow
+(assert_invalid (module (memory 1) (func (memory.grow (f32.const 0)))) "type mismatch")
diff --git a/test/core/unreachable.wast b/test/core/unreachable.wast
index f7fe4030f..f9b888e02 100644
--- a/test/core/unreachable.wast
+++ b/test/core/unreachable.wast
@@ -203,8 +203,8 @@
     (i32.wrap/i64 (unreachable))
   )
 
-  (func (export "as-grow_memory-size") (result i32)
-    (grow_memory (unreachable))
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (unreachable))
   )
 )
 
@@ -286,5 +286,5 @@
 
 (assert_trap (invoke "as-convert-operand") "unreachable")
 
-(assert_trap (invoke "as-grow_memory-size") "unreachable")
+(assert_trap (invoke "as-memory.grow-size") "unreachable")
 
diff --git a/test/harness/wasm-constants.js b/test/harness/wasm-constants.js
index 9e0698599..17bbedfff 100644
--- a/test/harness/wasm-constants.js
+++ b/test/harness/wasm-constants.js
@@ -194,7 +194,7 @@ let kExprI64StoreMem8 = 0x3c;
 let kExprI64StoreMem16 = 0x3d;
 let kExprI64StoreMem32 = 0x3e;
 let kExprMemorySize = 0x3f;
-let kExprGrowMemory = 0x40;
+let kExprMemoryGrow = 0x40;
 let kExprI32Eqz = 0x45;
 let kExprI32Eq = 0x46;
 let kExprI32Ne = 0x47;

From 9762124c9c8bd45d93aa83894e48c533fa821893 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 4 Apr 2018 18:03:03 +0200
Subject: [PATCH 199/329] [spec] Address comments by Luke (#752)

---
 document/core/intro/introduction.rst |  2 +-
 document/core/syntax/conventions.rst |  4 +++
 document/core/syntax/types.rst       |  4 +--
 document/core/text/modules.rst       | 30 ++++++++++++----
 document/core/valid/conventions.rst  | 18 ++++------
 document/core/valid/instructions.rst | 28 +++++++++++----
 document/core/valid/modules.rst      | 54 +++++++++++++++++-----------
 document/core/valid/types.rst        |  2 +-
 8 files changed, 95 insertions(+), 47 deletions(-)

diff --git a/document/core/intro/introduction.rst b/document/core/intro/introduction.rst
index 6c9b05897..4819dbdd7 100644
--- a/document/core/intro/introduction.rst
+++ b/document/core/intro/introduction.rst
@@ -5,7 +5,7 @@ WebAssembly (abbreviated Wasm [#wasm]_) is a *safe, portable, low-level code for
 designed for efficient execution and compact representation.
 Its main goal is to enable high performance applications on the Web, but it does not make any Web-specific assumptions or provide Web-specific features, so it can be employed in other environments as well.
 
-WebAssembly is an open standard developed by a `W3C Community Group <https://www.w3.org/community/webassembly/>`_ that includes representatives of all major browser vendors.
+WebAssembly is an open standard developed by a `W3C Community Group <https://www.w3.org/community/webassembly/>`_.
 
 This document describes version |release| of the :ref:`core <scope>` WebAssembly standard.
 It is intended that it will be superseded by new incremental releases with additional features in the future.
diff --git a/document/core/syntax/conventions.rst b/document/core/syntax/conventions.rst
index bb1fba797..a1aec4214 100644
--- a/document/core/syntax/conventions.rst
+++ b/document/core/syntax/conventions.rst
@@ -41,9 +41,13 @@ The following conventions are adopted in defining grammar rules for abstract syn
 
 
 
+.. _notation-epsilon:
+.. _notation-length:
+.. _notation-index:
 .. _notation-slice:
 .. _notation-replace:
 .. _notation-record:
+.. _notation-project:
 .. _notation-concat:
 .. _notation-compose:
 
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index 6898fb59e..012eff4c3 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -49,7 +49,7 @@ Result Types
 ~~~~~~~~~~~~
 
 *Result types* classify the result of :ref:`executing <exec-instr>` :ref:`instructions <syntax-instr>` or :ref:`blocks <syntax-instr-control>`,
-which is a sequence of values.
+which is a sequence of values written with brackets.
 
 .. math::
    \begin{array}{llll}
@@ -71,7 +71,7 @@ Function Types
 ~~~~~~~~~~~~~~
 
 *Function types* classify the signature of :ref:`functions <syntax-func>`,
-mapping a vector of parameters to a vector of results.
+mapping a vector of parameters to a vector of results, written as follows.
 
 .. math::
    \begin{array}{llll}
diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index d649bd291..c52a3872c 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -476,9 +476,8 @@ When omitted, :math:`\T{0}` is assumed.
 .. math::
    \begin{array}{llclll}
    \production{element segment} & \Telem_I &::=&
-     \text{(}~\text{elem}~~(x{:}\Ttableidx_I)^?~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~y^\ast{:}\Tvec(\Tfuncidx_I)~\text{)} \\ &&& \qquad
-       \Rightarrow\quad \{ \ETABLE~x', \EOFFSET~e, \EINIT~y^\ast \} \\
-       &&& \qquad\qquad\qquad (\iff x' = x^? \neq \epsilon \vee x' = 0) \\
+     \text{(}~\text{elem}~~x{:}\Ttableidx_I~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~y^\ast{:}\Tvec(\Tfuncidx_I)~\text{)} \\ &&& \qquad
+       \Rightarrow\quad \{ \ETABLE~x, \EOFFSET~e, \EINIT~y^\ast \} \\
    \end{array}
 
 .. note::
@@ -498,6 +497,16 @@ As an abbreviation, a single instruction may occur in place of the offset:
      \text{(}~\text{offset}~~\Tinstr~\text{)}
    \end{array}
 
+Also, the table index can be omitted, defaulting to :math:`0`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{element segment} &
+    \text{(}~\text{elem}~~\text{(}~\text{offset}~~\Texpr_I~\text{)}~~\dots~\text{)}
+       &\equiv&
+     \text{(}~\text{elem}~~0~~\text{(}~\text{offset}~~\Texpr_I~\text{)}~~\dots~\text{)}
+   \end{array}
+
 As another abbreviation, element segments may also be specified inline with :ref:`table <text-table>` definitions; see the respective section.
 
 
@@ -518,9 +527,8 @@ The data is written as a :ref:`string <text-string>`, which may be split up into
 .. math::
    \begin{array}{llclll}
    \production{data segment} & \Tdata_I &::=&
-     \text{(}~\text{data}~~(x{:}\Tmemidx_I)^?~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~b^\ast{:}\Tdatastring~\text{)} \\ &&& \qquad
-       \Rightarrow\quad \{ \DMEM~x', \DOFFSET~e, \DINIT~b^\ast \} \\
-       &&& \qquad\qquad\qquad (\iff x' = x^? \neq \epsilon \vee x' = 0) \\[1ex]
+     \text{(}~\text{data}~~x{:}\Tmemidx_I~~\text{(}~\text{offset}~~e{:}\Texpr_I~\text{)}~~b^\ast{:}\Tdatastring~\text{)} \\ &&& \qquad
+       \Rightarrow\quad \{ \DMEM~x', \DOFFSET~e, \DINIT~b^\ast \} \\[1ex]
    \production{data string} & \Tdatastring &::=&
      (b^\ast{:}\Tstring)^\ast \quad\Rightarrow\quad \concat((b^\ast)^\ast) \\
    \end{array}
@@ -542,6 +550,16 @@ As an abbreviation, a single instruction may occur in place of the offset:
      \text{(}~\text{offset}~~\Tinstr~\text{)}
    \end{array}
 
+Also, the memory index can be omitted, defaulting to :math:`0`.
+
+.. math::
+   \begin{array}{llclll}
+   \production{data segment} &
+    \text{(}~\text{data}~~\text{(}~\text{offset}~~\Texpr_I~\text{)}~~\dots~\text{)}
+       &\equiv&
+     \text{(}~\text{data}~~0~~\text{(}~\text{offset}~~\Texpr_I~\text{)}~~\dots~\text{)}
+   \end{array}
+
 As another abbreviation, data segments may also be specified inline with :ref:`memory <text-mem>` definitions; see the respective section.
 
 
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index 5ed7789a7..9e5f6f182 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -40,14 +40,14 @@ which collects relevant information about the surrounding :ref:`module <syntax-m
 * *Globals*: the list of globals declared in the current module, represented by their global type.
 * *Locals*: the list of locals declared in the current function (including parameters), represented by their value type.
 * *Labels*: the stack of labels accessible from the current position, represented by their result type.
-* *Return*: the return type of the current function, represented as a result type.
+* *Return*: the return type of the current function, represented as an optional result type that is absent when no return is allowed, as in free-standing expressions.
 
 In other words, a context contains a sequence of suitable :ref:`types <syntax-type>` for each :ref:`index space <syntax-index>`,
 describing each defined entry in that space.
 Locals, labels and return type are only used for validating :ref:`instructions <syntax-instr>` in :ref:`function bodies <syntax-func>`, and are left empty elsewhere.
 The label stack is the only part of the context that changes as validation of an instruction sequence proceeds.
 
-It is convenient to define contexts as :ref:`records <notation-record>` :math:`C` with abstract syntax:
+More concretely, contexts are defined as :ref:`records <notation-record>` :math:`C` with abstract syntax:
 
 .. math::
    \begin{array}{llll}
@@ -64,22 +64,18 @@ It is convenient to define contexts as :ref:`records <notation-record>` :math:`C
      \end{array}
    \end{array}
 
-.. note::
-   The fields of a context are not defined as :ref:`vectors <syntax-vec>`,
-   since their lengths are not bounded by the maximum vector size.
+.. _notation-extend:
 
-In addition to field access :math:`C.\K{field}` the following notation is adopted for manipulating contexts:
+In addition to field access written :math:`C.\K{field}` the following notation is adopted for manipulating contexts:
 
 * When spelling out a context, empty fields are omitted.
 
 * :math:`C,\K{field}\,A^\ast` denotes the same context as :math:`C` but with the elements :math:`A^\ast` prepended to its :math:`\K{field}` component sequence.
 
 .. note::
-   This notation is defined to *prepend* not *append*.
-   It is only used in situations where the original :math:`C.\K{field}` is either empty
-   or :math:`\K{field}` is :math:`\K{labels}`.
-   In the latter case adding to the front is desired
-   because the :ref:`label index <syntax-labelidx>` space is indexed relatively, that is, in reverse order of addition.
+   We use :ref:`indexing notation <notation-index>` like :math:`C.\CLABELS[i]` to look up indices in their respective :ref:`index space <syntax-index>` in the context.
+   Context extension notation :math:`C,\K{field}\,A` is primarily used to locally extend *relative* index spaces, such as :ref:`label indices <syntax-labelidx>`.
+   Accordingly, the notation is defined to append at the *front* of the respective sequence, introducing a new relative index :math:`0` and shifting the existing ones.
 
 
 .. _valid-notation-textual:
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 9ef152bad..dfb14ea89 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -314,7 +314,7 @@ Memory Instructions
 
 * The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
-* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`width <syntax-valtype>` of :math:`t` divided by :math:`8`.
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`bit width <syntax-valtype>` of :math:`t` divided by :math:`8`.
 
 * Then the instruction is valid with type :math:`[\I32] \to [t]`.
 
@@ -354,7 +354,7 @@ Memory Instructions
 
 * The memory :math:`C.\CMEMS[0]` must be defined in the context.
 
-* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`width <syntax-valtype>` of :math:`t` divided by :math:`8`.
+* The alignment :math:`2^{\memarg.\ALIGN}` must not be larger than the :ref:`bit width <syntax-valtype>` of :math:`t` divided by :math:`8`.
 
 * Then the instruction is valid with type :math:`[\I32~t] \to []`.
 
@@ -483,6 +483,8 @@ Control Instructions
    }
 
 .. note::
+   The :ref:`notation <notation-extend>` :math:`C,\CLABELS\,[t^?]` inserts the new label type at index :math:`0`, shifting all others.
+
    The fact that the nested instruction sequence :math:`\instr^\ast` must have type :math:`[] \to [t^?]` implies that it cannot access operands that have been pushed on the stack before the block was entered.
    This may be generalized in future versions of WebAssembly.
 
@@ -507,6 +509,8 @@ Control Instructions
    }
 
 .. note::
+   The :ref:`notation <notation-extend>` :math:`C,\CLABELS\,[t^?]` inserts the new label type at index :math:`0`, shifting all others.
+
    The fact that the nested instruction sequence :math:`\instr^\ast` must have type :math:`[] \to [t^?]` implies that it cannot access operands that have been pushed on the stack before the loop was entered.
    This may be generalized in future versions of WebAssembly.
 
@@ -536,6 +540,8 @@ Control Instructions
    }
 
 .. note::
+   The :ref:`notation <notation-extend>` :math:`C,\CLABELS\,[t^?]` inserts the new label type at index :math:`0`, shifting all others.
+
    The fact that the nested instruction sequence :math:`\instr^\ast` must have type :math:`[] \to [t^?]` implies that it cannot access operands that have been pushed on the stack before the conditional was entered.
    This may be generalized in future versions of WebAssembly.
 
@@ -559,6 +565,8 @@ Control Instructions
    }
 
 .. note::
+   The :ref:`label index <syntax-labelidx>` space in the :ref:`context <context>` :math:`C` contains the most recent label first, so that :math:`C.\CLABELS[l]` performs a relative lookup as expected.
+
    The |BR| instruction is :ref:`stack-polymorphic <polymorphism>`.
 
 
@@ -580,6 +588,9 @@ Control Instructions
      C \vdashinstr \BRIF~l : [t^?~\I32] \to [t^?]
    }
 
+.. note::
+   The :ref:`label index <syntax-labelidx>` space in the :ref:`context <context>` :math:`C` contains the most recent label first, so that :math:`C.\CLABELS[l]` performs a relative lookup as expected.
+
 
 .. _valid-br_table:
 
@@ -608,6 +619,8 @@ Control Instructions
    }
 
 .. note::
+   The :ref:`label index <syntax-labelidx>` space in the :ref:`context <context>` :math:`C` contains the most recent label first, so that :math:`C.\CLABELS[l_i]` performs a relative lookup as expected.
+
    The |BRTABLE| instruction is :ref:`stack-polymorphic <polymorphism>`.
 
 
@@ -616,7 +629,7 @@ Control Instructions
 :math:`\RETURN`
 ...............
 
-* The return type :math:`C.\CRETURN` must not be empty in the context.
+* The return type :math:`C.\CRETURN` must not be absent in the context.
 
 * Let :math:`[t^?]` be the :ref:`result type <syntax-resulttype>` of :math:`C.\CRETURN`.
 
@@ -632,8 +645,8 @@ Control Instructions
 .. note::
    The |RETURN| instruction is :ref:`stack-polymorphic <polymorphism>`.
 
-   :math:`C.\CRETURN` is empty (:math:`\epsilon`) when validating an :ref:`expression <valid-expr>` that is not a function body.
-   This differs from it being set to the empty result type (:math:`[]`),
+   :math:`C.\CRETURN` is absent (set to :math:`\epsilon`) when validating an :ref:`expression <valid-expr>` that is not a function body.
+   This differs from it being set to the empty result type (:math:`[\epsilon]`),
    which is the case for functions not returning anything.
 
 
@@ -773,7 +786,7 @@ Constant Expressions
    \frac{
      (C \vdashinstrconst \instr \const)^\ast
    }{
-     C \vdashexprconst \instr~\END \const
+     C \vdashexprconst \instr^\ast~\END \const
    }
 
 .. math::
@@ -789,4 +802,7 @@ Constant Expressions
    }
 
 .. note::
+   Currently, constant expressions occurring as initializers of :ref:`globals <syntax-global>` are further constrained in that contained |GETGLOBAL| instructions are only allowed to refer to *imported* globals.
+   This is enforced in the :ref:`validation rule for modules <valid-module>` by constraining the context :math:`C` accordingly.
+
    The definition of constant expression may be extended in future versions of WebAssembly.
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 6dc45a687..78e99e77e 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -129,7 +129,7 @@ Globals :math:`\global` are classified by :ref:`global types <syntax-globaltype>
      \qquad
      C \vdashexpr \expr : [t]
      \qquad
-     C \vdashexprconst \expr ~\F{const}
+     C \vdashexprconst \expr \const
    }{
      C \vdashglobal \{ \GTYPE~\mut~t, \GINIT~\expr \} : \mut~t
    }
@@ -172,7 +172,7 @@ Element segments :math:`\elem` are not classified by a type.
      \qquad
      C \vdashexpr \expr : [\I32]
      \qquad
-     C \vdashexprconst \expr ~\F{const}
+     C \vdashexprconst \expr \const
      \qquad
      (C.\CFUNCS[y] = \functype)^\ast
    }{
@@ -210,7 +210,7 @@ Data segments :math:`\data` are not classified by any type.
      \qquad
      C \vdashexpr \expr : [\I32]
      \qquad
-     C \vdashexprconst \expr ~\F{const}
+     C \vdashexprconst \expr \const
    }{
      C \vdashdata \{ \DMEM~x, \DOFFSET~\expr, \DINIT~b^\ast \} \ok
    }
@@ -334,6 +334,9 @@ Exports :math:`\export` and export descriptions :math:`\exportdesc` are classifi
      C \vdashexportdesc \EDGLOBAL~x : \ETGLOBAL~(\MCONST~t)
    }
 
+.. note::
+   In future versions of WebAssembly, the restriction to exporting only immutable globals may be removed.
+
 
 .. index:: import, name, function type, table type, memory type, global type
    pair: validation; import
@@ -425,6 +428,9 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
      C \vdashimportdesc \IDGLOBAL~\MCONST~t : \ETGLOBAL~\MCONST~t
    }
 
+.. note::
+   In future versions of WebAssembly, the restriction to importing only immutable globals may be removed.
+
 
 .. index:: module, type definition, function type, function, table, memory, global, element, data, start function, import, export, context
    pair: validation; module
@@ -447,21 +453,21 @@ Instead, the context :math:`C` for validation of the module's content is constru
 
   * :math:`C.\CTYPES` is :math:`\module.\MTYPES`,
 
-  * :math:`C.\CFUNCS` is :math:`\etfuncs(\externtype_i^\ast)` concatenated with :math:`\functype_i^\ast`,
-    with the type sequences :math:`\externtype_i^\ast` and :math:`\functype_i^\ast` as determined below,
+  * :math:`C.\CFUNCS` is :math:`\etfuncs(\X{it}^\ast)` concatenated with :math:`\X{ft}^\ast`,
+    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :math:`function types <syntax-functype>` :math:`\X{ft}^\ast` as determined below,
 
-  * :math:`C.\CTABLES` is :math:`\ettables(\externtype_i^\ast)` concatenated with :math:`\tabletype_i^\ast`,
-    with the type sequences :math:`\externtype_i^\ast` and :math:`\tabletype_i^\ast` as determined below,
+  * :math:`C.\CTABLES` is :math:`\ettables(\X{it}^\ast)` concatenated with :math:`\X{tt}^\ast`,
+    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :math:`table types <syntax-tabletype>` :math:`\X{tt}^\ast` as determined below,
 
-  * :math:`C.\CMEMS` is :math:`\etmems(\externtype_i^\ast)` concatenated with :math:`\memtype_i^\ast`,
-    with the type sequences :math:`\externtype_i^\ast` and :math:`\memtype_i^\ast` as determined below,
+  * :math:`C.\CMEMS` is :math:`\etmems(\X{it}^\ast)` concatenated with :math:`\X{mt}^\ast`,
+    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :math:`memory types <syntax-memtype>` :math:`\X{mt}^\ast` as determined below,
 
-  * :math:`C.\CGLOBALS` is :math:`\etglobals(\externtype_i^\ast)` concatenated with :math:`\globaltype_i^\ast`,
-    with the type sequences :math:`\externtype_i^\ast` and :math:`\globaltype_i^\ast` as determined below.
+  * :math:`C.\CGLOBALS` is :math:`\etglobals(\X{it}^\ast)` concatenated with :math:`\X{gt}^\ast`,
+    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :math:`global types <syntax-globaltype>` :math:`\X{gt}^\ast` as determined below,
 
   * :math:`C.\CLOCALS` is empty,
 
-  * :math:`C.\CLABELS` is empty.
+  * :math:`C.\CLABELS` is empty,
 
   * :math:`C.\CRETURN` is empty.
 
@@ -476,15 +482,15 @@ Instead, the context :math:`C` for validation of the module's content is constru
     the definition :math:`\func_i` must be :ref:`valid <valid-func>` with a :ref:`function type <syntax-functype>` :math:`\X{ft}_i`.
 
   * For each :math:`\table_i` in :math:`\module.\MTABLES`,
-    the definition :math:`\table_i` must be :ref:`valid <valid-table>` with a :ref:`table type <syntax-tabletype>` :math:`\tabletype_i`.
+    the definition :math:`\table_i` must be :ref:`valid <valid-table>` with a :ref:`table type <syntax-tabletype>` :math:`\X{tt}_i`.
 
   * For each :math:`\mem_i` in :math:`\module.\MMEMS`,
-    the definition :math:`\mem_i` must be :ref:`valid <valid-mem>` with a :ref:`memory type <syntax-memtype>` :math:`\memtype_i`.
+    the definition :math:`\mem_i` must be :ref:`valid <valid-mem>` with a :ref:`memory type <syntax-memtype>` :math:`\X{mt}_i`.
 
   * For each :math:`\global_i` in :math:`\module.\MGLOBALS`:
 
     * Under the context :math:`C'`,
-      the definition :math:`\global_i` must be :ref:`valid <valid-global>` with a :ref:`global type <syntax-globaltype>` :math:`\globaltype_i`.
+      the definition :math:`\global_i` must be :ref:`valid <valid-global>` with a :ref:`global type <syntax-globaltype>` :math:`\X{gt}_i`.
 
   * For each :math:`\elem_i` in :math:`\module.\MELEM`,
     the segment :math:`\elem_i` must be :ref:`valid <valid-elem>`.
@@ -496,10 +502,10 @@ Instead, the context :math:`C` for validation of the module's content is constru
     then :math:`\module.\MSTART` must be :ref:`valid <valid-start>`.
 
   * For each :math:`\import_i` in :math:`\module.\MIMPORTS`,
-    the segment :math:`\import_i` must be :ref:`valid <valid-import>` with an :ref:`external type <syntax-externtype>` :math:`\externtype_i`.
+    the segment :math:`\import_i` must be :ref:`valid <valid-import>` with an :ref:`external type <syntax-externtype>` :math:`\X{it}_i`.
 
   * For each :math:`\export_i` in :math:`\module.\MEXPORTS`,
-    the segment :math:`\import_i` must be :ref:`valid <valid-export>` with :ref:`external type <syntax-externtype>` :math:`\externtype'_i`.
+    the segment :math:`\import_i` must be :ref:`valid <valid-export>` with :ref:`external type <syntax-externtype>` :math:`\X{et}_i`.
 
 * The length of :math:`C.\CTABLES` must not be larger than :math:`1`.
 
@@ -507,11 +513,19 @@ Instead, the context :math:`C` for validation of the module's content is constru
 
 * All export names :math:`\export_i.\ENAME` must be different.
 
-* Let :math:`\externtype^\ast` be the concatenation of :ref:`external types <syntax-externtype>` :math:`\externtype_i` of the imports, in index order.
+* Let :math:`\X{ft}^\ast` be the concatenation of the internal :ref:`function types <syntax-functype>` :math:`\X{ft}_i`, in index order.
+
+* Let :math:`\X{tt}^\ast` be the concatenation of the internal :ref:`table types <syntax-tabletype>` :math:`\X{tt}_i`, in index order.
+
+* Let :math:`\X{mt}^\ast` be the concatenation of the internal :ref:`memory types <syntax-memtype>` :math:`\X{mt}_i`, in index order.
+
+* Let :math:`\X{gt}^\ast` be the concatenation of the internal :ref:`global types <syntax-globaltype>` :math:`\X{gt}_i`, in index order.
+
+* Let :math:`\X{it}^\ast` be the concatenation of :ref:`external types <syntax-externtype>` :math:`\X{it}_i` of the imports, in index order.
 
-* Let :math:`{\externtype'}^\ast` be the concatenation of :ref:`external types <syntax-externtype>` :math:`\externtype'_i` of the exports, in index order.
+* Let :math:`\X{et}^\ast` be the concatenation of :ref:`external types <syntax-externtype>` :math:`\X{et}_i` of the exports, in index order.
 
-* Then the module is valid with :ref:`external types <syntax-externtype>` :math:`\externtype^\ast \to {\externtype'}^\ast`.
+* Then the module is valid with :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast \to \X{et}^\ast`.
 
 .. math::
    \frac{
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 76c6c7021..89b79a418 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -54,7 +54,7 @@ Function Types
    }
 
 .. note::
-   This restriction may be removed in future versions of WebAssembly.
+   The restriction to at most one result may be removed in future versions of WebAssembly.
 
 
 .. index:: table type, element type, limits

From af204ae80a1b95b0ff01509d553c4b79e5b801d0 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Thu, 5 Apr 2018 11:24:46 +0200
Subject: [PATCH 200/329] Remove extraneous parenthesis

---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 567ff9c74..6cf8fa216 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -367,7 +367,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
             1. Let |func| be the result of creating [=a new Exported Function=] from |funcaddr|.
             1. Let |value| be |func|.
         1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] |globaltype|,
-            1. If |globaltype|.<em>[=global type|valtype=]</em>) is [=𝗂𝟨𝟦=], throw a {{LinkError}} exception.
+            1. If |globaltype|.<em>[=global type|valtype=]</em> is [=𝗂𝟨𝟦=], throw a {{LinkError}} exception.
             1. Assert: |globaltype|.<em>[=global type|mut=]</em> is [=global type|𝖼𝗈𝗇𝗌𝗍=], as verified by WebAssembly validation.
             1. Assert: |externval| is of the form [=external value|𝗀𝗅𝗈𝖻𝖺𝗅=] |globaladdr|.
             1. Let [=external value|𝗀𝗅𝗈𝖻𝖺𝗅=] |globaladdr| be |externval|.

From 5a150c7d4009254abb74684b9b47429abc55f753 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Mon, 9 Apr 2018 09:28:15 -0700
Subject: [PATCH 201/329] Fixing up formatting for bikeshed. (#765)

Limiting TOC depth.
  https://github.com/WebAssembly/spec/issues/675
Bringing back hyperlinks.
  https://github.com/WebAssembly/spec/issues/667
Fix missing spaces.
  https://github.com/WebAssembly/spec/issues/669
Working around katex bug with multi-line + hrefs.
---
 document/core/Makefile               |   2 +
 document/core/index.bs               |   2 +-
 document/core/util/bikeshed/conf.py  |   2 +-
 document/core/util/bikeshed_fixup.py |  17 ++++
 document/core/util/mathdefbs.py      | 126 +++++++++++++++++++++++++++
 document/core/util/mathjax2katex.py  |   9 +-
 6 files changed, 154 insertions(+), 4 deletions(-)
 create mode 100755 document/core/util/bikeshed_fixup.py
 create mode 100644 document/core/util/mathdefbs.py

diff --git a/document/core/Makefile b/document/core/Makefile
index b47a57909..2bcd266d2 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -139,6 +139,8 @@ singlehtml:
 bikeshed:
 	$(SPHINXBUILD) -b singlehtml -c util/bikeshed \
 		$(ALLSPHINXOPTS) $(BUILDDIR)/bikeshed_singlehtml
+	python util/bikeshed_fixup.py $(BUILDDIR)/bikeshed_singlehtml/index.html \
+		>$(BUILDDIR)/bikeshed_singlehtml/index_fixed.html
 	mkdir -p $(BUILDDIR)/bikeshed_mathjax/
 	bikeshed spec index.bs $(BUILDDIR)/bikeshed_mathjax/index.html
 	mkdir -p $(BUILDDIR)/html/bikeshed/
diff --git a/document/core/index.bs b/document/core/index.bs
index bdf8d6b70..2cbd5058b 100644
--- a/document/core/index.bs
+++ b/document/core/index.bs
@@ -25,5 +25,5 @@ Prepare For TR: true
 </pre>
 
 <pre class=include>
-path: _build/bikeshed_singlehtml/index.html
+path: _build/bikeshed_singlehtml/index_fixed.html
 </pre>
diff --git a/document/core/util/bikeshed/conf.py b/document/core/util/bikeshed/conf.py
index db264f5fa..ebe284150 100644
--- a/document/core/util/bikeshed/conf.py
+++ b/document/core/util/bikeshed/conf.py
@@ -35,7 +35,7 @@
   'sphinx.ext.mathjax',
   'sphinx.ext.ifconfig',
   'sphinx.ext.githubpages',
-  'mathdef',
+  'mathdefbs',
   'pseudo-lexer'
 ]
 
diff --git a/document/core/util/bikeshed_fixup.py b/document/core/util/bikeshed_fixup.py
new file mode 100755
index 000000000..6a111e96f
--- /dev/null
+++ b/document/core/util/bikeshed_fixup.py
@@ -0,0 +1,17 @@
+#! /usr/bin/env python
+# -*- coding: latin-1 -*-
+
+import os
+import sys
+
+
+SCRIPT_DIR = os.path.dirname(os.path.realpath(__file__))
+
+
+def Main():
+  data = open(sys.argv[1]).read()
+  data = data.replace('<h5>', '<h5 class="no-toc">')
+  sys.stdout.write(data)
+
+
+Main()
diff --git a/document/core/util/mathdefbs.py b/document/core/util/mathdefbs.py
new file mode 100644
index 000000000..d7b4844a9
--- /dev/null
+++ b/document/core/util/mathdefbs.py
@@ -0,0 +1,126 @@
+# Version of mathdef.py for bikeshed build.
+# Tweaked to generate single page links.
+# TODO(bradnelson): Figure out a way to merge this back into
+# mathdef.py controlled by buildername.
+
+from sphinx.ext.mathbase import math
+from sphinx.ext.mathbase import displaymath
+from sphinx.ext.mathbase import math_role
+from sphinx.ext.mathbase import MathDirective
+from sphinx.ext.mathbase import latex_visit_math
+from sphinx.ext.mathbase import latex_visit_displaymath
+from sphinx.ext.mathjax import html_visit_math
+from sphinx.ext.mathjax import html_visit_displaymath
+from sphinx.util.texescape import tex_escape_map, tex_replace_map
+from docutils.parsers.rst.directives.misc import Replace
+from six import text_type
+import re
+
+
+# Transform \xref in math nodes
+
+xref_re = re.compile('\\\\xref\{([^}]*)\}\{([^}]*)\}', re.M)
+
+def html_hyperlink(file, id):
+  return '\\href{#%s}' % (id.replace('_', '-'))
+
+def html_transform_math_xref(node):
+  node['latex'] = \
+    xref_re.sub(lambda m: html_hyperlink(m.group(1), m.group(2)), node['latex'])
+
+def ext_html_visit_math(self, node):
+  html_transform_math_xref(node)
+  html_visit_math(self, node)
+
+def ext_html_visit_displaymath(self, node):
+  html_transform_math_xref(node)
+  html_visit_displaymath(self, node)
+
+# Mirrors sphinx/writers/latex
+def latex_hyperlink(file, id):
+  id = text_type(id).translate(tex_replace_map).\
+    encode('ascii', 'backslashreplace').decode('ascii').\
+    replace('_', '-').replace('\\', '_')
+  return '\\hyperref[%s:%s]' % (file, id)
+
+def latex_transform_math_xref(node):
+  node['latex'] = \
+    xref_re.sub(lambda m: latex_hyperlink(m.group(1), m.group(2)), node['latex'])
+
+def ext_latex_visit_math(self, node):
+  latex_transform_math_xref(node)
+  latex_visit_math(self, node)
+
+def ext_latex_visit_displaymath(self, node):
+  latex_transform_math_xref(node)
+  latex_visit_displaymath(self, node)
+
+
+# Expand mathdef names in math roles and directives
+
+def_re = re.compile('\\\\[A-Za-z][0-9A-Za-z]*', re.M)
+
+auxcounter = 0
+
+def lookup_mathdef(defs, name):
+  if name in defs:
+    [arity, s] = defs[name]
+    if arity > 0:
+      global auxcounter
+      auxcounter = auxcounter + 1
+      name = "\\mathdef%d" % auxcounter
+      s = "\\def%s#%d{%s}%s" % (name, arity, s, name)
+    return s
+  return name
+
+def replace_mathdefs(doc, s):
+  if not hasattr(doc, 'mathdefs'):
+    return s
+  return def_re.sub(lambda m: lookup_mathdef(doc.mathdefs, m.group(0)), s)
+
+def ext_math_role(role, raw, text, line, inliner, options = {}, content = []):
+  text = replace_mathdefs(inliner.document, raw.split('`')[1])
+  return math_role(role, raw, text, line, inliner, options = options,
+                   content = content)
+
+class ExtMathDirective(MathDirective):
+  def run(self):
+    doc = self.state.document
+    for i, s in enumerate(self.content):
+      self.content[i] = replace_mathdefs(doc, s)
+    for i, s in enumerate(self.arguments):
+      self.arguments[i] = replace_mathdefs(doc, s)
+    return super(ExtMathDirective, self).run()
+
+class MathdefDirective(Replace):
+  def run(self):
+    name = '\\' + self.state.parent.rawsource.split('|')[1]
+    name = name.split('#')
+    if len(name) > 1:
+      arity = int(name[1])
+    else:
+      arity = 0
+    name = name[0]
+    doc = self.state.document
+    if not hasattr(doc, 'mathdefs'):
+      doc.mathdefs = {}
+    for i, s in enumerate(self.content):
+      self.content[i] = replace_mathdefs(doc, s)
+    doc.mathdefs[name] = [arity, ''.join(self.content)]
+    self.content[0] = ':math:`' + self.content[0]
+    self.content[-1] = self.content[-1] + '`'
+    return super(MathdefDirective, self).run()
+
+
+# Setup
+
+def setup(app):
+  app.add_node(math,
+               html = (ext_html_visit_math, None),
+               latex = (ext_latex_visit_math, None))
+  app.add_node(displaymath,
+               html = (ext_html_visit_displaymath, None),
+               latex = (ext_latex_visit_displaymath, None))
+  app.add_role('math', ext_math_role)
+  app.add_directive('math', ExtMathDirective)
+  app.add_directive('mathdef', MathdefDirective)
diff --git a/document/core/util/mathjax2katex.py b/document/core/util/mathjax2katex.py
index a4ccf2b8d..7298305d0 100755
--- a/document/core/util/mathjax2katex.py
+++ b/document/core/util/mathjax2katex.py
@@ -57,7 +57,6 @@ def ReplaceMath(cache, data):
   data = data.replace('@{\\qquad}', '')
   data = data.replace('@{\\qquad\\qquad}', '')
   data = re.sub('([^\\\\])[$]', '\\1', data)
-  data = re.sub('[\\\\]href{[^}]*}', '', data)
   macros = {}
   while True:
     start, end = FindMatching(data, '\\def\\')
@@ -88,7 +87,13 @@ def ReplaceMath(cache, data):
   ret = '<span class="katex-display"><span class="katex">' + ret + '</span>'
   # w3c validator does not like negative em.
   ret = re.sub('height:[-][0-9][.][0-9]+em', 'height:0em', ret)
-  cache[old] = ret
+  # Fix ahref -> a href bug (fixed in next release).
+  # Also work around W3C forcing links to have underline.
+  ret = ret.replace('<ahref="<a', '<a style="border-bottom: 0px" href="')
+  # Fix stray spans that come out of katex.
+  ret = re.sub('[<]span class="vlist" style="height:[0-9.]+em;"[>]',
+               '<span class="vlist">', ret)
+  cache[old] = ' ' + ret + ' '
   return ret
 
 

From 5489d70d6c4f9115c1eadaeb70866f3236496a0f Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Mon, 9 Apr 2018 13:11:53 -0700
Subject: [PATCH 202/329] Fixing display math formatting. (#770)

Also centering:
https://github.com/WebAssembly/spec/issues/668
---
 document/core/util/katex_fix.patch | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/document/core/util/katex_fix.patch b/document/core/util/katex_fix.patch
index b39407283..7b48fd52f 100644
--- a/document/core/util/katex_fix.patch
+++ b/document/core/util/katex_fix.patch
@@ -1,18 +1,19 @@
-113a114
->   /*
-116a118
->   */
-119c121
-<   display: inline-block;
+113c113
+< .katex-display {
 ---
-> /*  display: inline-block; */
-127d128
+> div > .katex-display {
+123c123,124
+<   font: normal 1.21em KaTeX_Main, Times New Roman, serif;
+---
+>   /* font: normal 1.21em KaTeX_Main, Times New Roman, serif; */
+>   font: normal KaTeX_Main, Times New Roman, serif;
+127d127
 <   text-rendering: auto;
-133c134
+133c133
 <   display: inline-block;
 ---
 > /*  display: inline-block; */
-1059,1064d1059
+1059,1064d1058
 < }
 < .katex svg path {
 <   fill: currentColor;

From bfe3be3652193f821f994643b46d8909b8f665ac Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Mon, 9 Apr 2018 13:38:11 -0700
Subject: [PATCH 203/329] Don't number the Appendix. (#769)

https://github.com/WebAssembly/spec/issues/679

Also fix spurious sections:
https://github.com/WebAssembly/spec/issues/678
---
 document/core/util/bikeshed_fixup.py | 31 ++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/document/core/util/bikeshed_fixup.py b/document/core/util/bikeshed_fixup.py
index 6a111e96f..b3edb6ca3 100755
--- a/document/core/util/bikeshed_fixup.py
+++ b/document/core/util/bikeshed_fixup.py
@@ -10,7 +10,38 @@
 
 def Main():
   data = open(sys.argv[1]).read()
+
+  # Don't add more than 3 levels to TOC.
   data = data.replace('<h5>', '<h5 class="no-toc">')
+
+  # TODO(bradnelson/tabadkins): Fix when bikeshed can do letters.
+  # Don't number the Appendix.
+  data = data.replace(
+      '<h2>Appendix</h2>',
+      '<h2 class="no-num">A Appendix</h2>')
+  number = 1
+  for section in [
+      'Embedding',
+      'Implementation Limitations',
+      'Validation Algorithm',
+      'Custom Sections',
+      'Soundness']:
+    data = data.replace(
+        '<h3>' + section + '</h3>',
+        '<h3>A.' + str(number) + ' ' + section + '</h3>')
+    number += 1
+
+
+  # Drop spurious navigation.
+  data = data.replace(
+"""
+    <div class="related" role="navigation" aria-label="related navigation">
+      <h3>Navigation</h3>
+      <ul>
+        <li class="nav-item nav-item-0"><a href="index.html#document-index">WebAssembly 1.0</a> &#187;</li> 
+      </ul>
+    </div>""", '')
+
   sys.stdout.write(data)
 
 

From e7f530b9e7996700b2bd5db066ef9ef0df50b6ba Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Mon, 9 Apr 2018 14:56:48 -0700
Subject: [PATCH 204/329] Adding index of instructions for bikeshed. (#771)

Fixes:
https://github.com/WebAssembly/spec/issues/677
---
 document/core/appendix/index.rst     | 10 ++++++++++
 document/core/util/bikeshed_fixup.py |  5 ++++-
 2 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/document/core/appendix/index.rst b/document/core/appendix/index.rst
index 4be621299..ef5d64607 100644
--- a/document/core/appendix/index.rst
+++ b/document/core/appendix/index.rst
@@ -11,3 +11,13 @@ Appendix
    algorithm
    custom
    properties
+
+.. only:: singlehtml
+
+   .. toctree::
+
+      :maxdepth: 2
+      index-types
+      index-instructions
+      index-rules
+
diff --git a/document/core/util/bikeshed_fixup.py b/document/core/util/bikeshed_fixup.py
index b3edb6ca3..a51ec2525 100755
--- a/document/core/util/bikeshed_fixup.py
+++ b/document/core/util/bikeshed_fixup.py
@@ -25,7 +25,10 @@ def Main():
       'Implementation Limitations',
       'Validation Algorithm',
       'Custom Sections',
-      'Soundness']:
+      'Soundness',
+      'Index of Types',
+      'Index of Instructions',
+      'Index of Semantic Rules']:
     data = data.replace(
         '<h3>' + section + '</h3>',
         '<h3>A.' + str(number) + ' ' + section + '</h3>')

From dd5b76d21c25a2a427515ebc61ee146a8f5379ed Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Mon, 9 Apr 2018 15:23:45 -0700
Subject: [PATCH 205/329] Add borders to tables. (#772)

Fixes:
https://github.com/WebAssembly/spec/issues/674
---
 document/core/util/katex_fix.patch | 13 +++++++++++--
 1 file changed, 11 insertions(+), 2 deletions(-)

diff --git a/document/core/util/katex_fix.patch b/document/core/util/katex_fix.patch
index 7b48fd52f..86bf81b4a 100644
--- a/document/core/util/katex_fix.patch
+++ b/document/core/util/katex_fix.patch
@@ -13,10 +13,19 @@
 <   display: inline-block;
 ---
 > /*  display: inline-block; */
-1059,1064d1058
-< }
+1060,1065d1059
 < .katex svg path {
 <   fill: currentColor;
 < }
 < .katex svg line {
 <   stroke: currentColor;
+< }
+1143a1138,1145
+> /* Force borders on tables */
+> table {
+>   border-collapse: collapse;
+> }
+> th, td {
+>   border: 1px solid;
+>   padding: .4em;
+> };

From 833db0f2d7cbae4b9ac371ce14641096f6ee94c3 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Mon, 9 Apr 2018 16:37:10 -0700
Subject: [PATCH 206/329] Working around bad kerning. (#773)

Sadly hacky.
Fixes:
https://github.com/WebAssembly/spec/issues/669
---
 document/core/util/mathjax2katex.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/document/core/util/mathjax2katex.py b/document/core/util/mathjax2katex.py
index 7298305d0..e81d85913 100755
--- a/document/core/util/mathjax2katex.py
+++ b/document/core/util/mathjax2katex.py
@@ -93,6 +93,14 @@ def ReplaceMath(cache, data):
   # Fix stray spans that come out of katex.
   ret = re.sub('[<]span class="vlist" style="height:[0-9.]+em;"[>]',
                '<span class="vlist">', ret)
+  # Drop bad italic font adjustment.
+  # https://github.com/WebAssembly/spec/issues/669
+  # https://github.com/Khan/KaTeX/issues/1259
+  ret = re.sub(
+      'mathit" style="margin-right:0.[0-9]+em', 'mathit" style="', ret)
+  ret = re.sub(
+      'mainit" style="margin-right:0.[0-9]+em', 'mathit" style="', ret)
+
   cache[old] = ' ' + ret + ' '
   return ret
 

From 05710782d0dc0f0637cba6b75b17fba5b90aea14 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Mon, 9 Apr 2018 17:06:02 -0700
Subject: [PATCH 207/329] Fixing borders + gray bar. (#775)

Removes extra border on footnotes.
Fixes:
https://github.com/WebAssembly/spec/issues/673
---
 document/core/util/katex_fix.patch | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/document/core/util/katex_fix.patch b/document/core/util/katex_fix.patch
index 86bf81b4a..23819eb5c 100644
--- a/document/core/util/katex_fix.patch
+++ b/document/core/util/katex_fix.patch
@@ -20,12 +20,18 @@
 < .katex svg line {
 <   stroke: currentColor;
 < }
-1143a1138,1145
+1142a1137,1150
+> }
 > /* Force borders on tables */
 > table {
 >   border-collapse: collapse;
 > }
-> th, td {
+> .docutils th, td {
 >   border: 1px solid;
 >   padding: .4em;
-> };
+> }
+> .footnote td {
+>   border: 0; !important
+> }
+> blockquote {
+>   border-color: transparent;

From 1fcfb083c65fbc4cc0d9470ac2f824a334c92ba6 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Mon, 9 Apr 2018 17:56:52 -0700
Subject: [PATCH 208/329] [editorial] Remove !important from css selector.
 (#776)

This makes us pass the W3C CSS validator again.
---
 document/core/util/katex_fix.patch | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/util/katex_fix.patch b/document/core/util/katex_fix.patch
index 23819eb5c..9205024cc 100644
--- a/document/core/util/katex_fix.patch
+++ b/document/core/util/katex_fix.patch
@@ -31,7 +31,7 @@
 >   padding: .4em;
 > }
 > .footnote td {
->   border: 0; !important
+>   border: 0;
 > }
 > blockquote {
 >   border-color: transparent;

From a6b9729a8a131902cf188914ba17c2e6d62e6060 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Tue, 10 Apr 2018 09:21:43 -0700
Subject: [PATCH 209/329] [editorial] Moved reference to encoding to prevent
 double href. (#777)

Fixing a place where we get nested <a hrefs>
(fails W3C HTML checker).
---
 document/core/binary/types.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index e5342259c..317bf9f6c 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -25,7 +25,7 @@ Value Types
 
 .. note::
    In future versions of WebAssembly, value types may include types denoted by :ref:`type indices <syntax-typeidx>`.
-   Thus, the binary format for types corresponds to the encodings of small negative :math:`\xref{binary/values}{binary-sint}{\sN}` values, so that they can coexist with (positive) type indices in the future.
+   Thus, the binary format for types corresponds to the :ref:`encoding <binary-sint>` of small negative :math:`\sN` values, so that they can coexist with (positive) type indices in the future.
 
 
 .. index:: result type, value type

From 789a93b7dcade0c4f2e674171cef5897e04d6211 Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Tue, 10 Apr 2018 16:51:03 -0700
Subject: [PATCH 210/329] [editorial] Switch to using display mode. (#778)

Fixes parts of:
https://github.com/WebAssembly/spec/issues/669
---
 document/core/util/mathjax2katex.py | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/document/core/util/mathjax2katex.py b/document/core/util/mathjax2katex.py
index e81d85913..c1a3d83e5 100755
--- a/document/core/util/mathjax2katex.py
+++ b/document/core/util/mathjax2katex.py
@@ -32,8 +32,6 @@ def FindMatching(data, prefix):
 
 
 def ReplaceMath(cache, data):
-  if cache.has_key(data):
-    return cache[data]
   old = data
   data = data.replace('\\\\', '\\DOUBLESLASH')
   data = data.replace('\\(', '')
@@ -44,7 +42,7 @@ def ReplaceMath(cache, data):
   data = data.replace('’', '\\text{’}')
   data = data.replace('‘', '\\text{‘}')
   data = data.replace('\\hfill', '')
-  data = data.replace('\\mbox', '')
+  data = data.replace('\\mbox', '\\mathrel')
   data = data.replace('\\begin{split}', '\\begin{aligned}')
   data = data.replace('\\end{split}', '\\end{aligned}')
   data = data.replace('&amp;', '&')
@@ -57,6 +55,11 @@ def ReplaceMath(cache, data):
   data = data.replace('@{\\qquad}', '')
   data = data.replace('@{\\qquad\\qquad}', '')
   data = re.sub('([^\\\\])[$]', '\\1', data)
+  data = '\\mathrm{' + data + '}'
+
+  if cache.has_key(data):
+    return cache[data]
+
   macros = {}
   while True:
     start, end = FindMatching(data, '\\def\\')
@@ -76,7 +79,7 @@ def ReplaceMath(cache, data):
         break
       data = data[:start] + v.replace('#1', data[start+len(k):end]) + data[end:]
   p = subprocess.Popen(
-      ['node', os.path.join(SCRIPT_DIR, 'katex/cli.js')],
+      ['node', os.path.join(SCRIPT_DIR, 'katex/cli.js'), '--display-mode'],
       stdin=subprocess.PIPE, stdout=subprocess.PIPE)
   ret = p.communicate(input=data)[0]
   if p.returncode != 0:
@@ -101,7 +104,7 @@ def ReplaceMath(cache, data):
   ret = re.sub(
       'mainit" style="margin-right:0.[0-9]+em', 'mathit" style="', ret)
 
-  cache[old] = ' ' + ret + ' '
+  cache[data] = ' ' + ret + ' '
   return ret
 
 

From 1726d9694b3aab918f99e6e454b3914c0624aecb Mon Sep 17 00:00:00 2001
From: Brad Nelson <flagxor@gmail.com>
Date: Tue, 10 Apr 2018 20:52:38 -0700
Subject: [PATCH 211/329] [editorial] Fix multiple formatting issues. (#779)

Re-fix gray bars.
Fix formatting + coloring of code.
Fix math fragments inside span (period / comma not tight).
---
 document/core/Makefile               |  2 ++
 document/core/util/bikeshed_fixup.py |  2 +-
 document/core/util/katex_fix.patch   |  4 ++--
 document/core/util/mathjax2katex.py  | 22 +++++++++++++++++-----
 4 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/document/core/Makefile b/document/core/Makefile
index 2bcd266d2..5a34a52cc 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -150,6 +150,8 @@ bikeshed:
 	cp -r util/katex/dist/* $(BUILDDIR)/html/bikeshed/katex/dist/
 	patch -p0 $(BUILDDIR)/html/bikeshed/katex/dist/katex.css \
 		< util/katex_fix.patch
+	cp $(BUILDDIR)/bikeshed_singlehtml/_static/pygments.css \
+		$(BUILDDIR)/html/bikeshed/
 	@echo
 	@echo "Build finished. The HTML page is in $(BUILDDIR)/html/bikeshed/."
 
diff --git a/document/core/util/bikeshed_fixup.py b/document/core/util/bikeshed_fixup.py
index a51ec2525..f7876543c 100755
--- a/document/core/util/bikeshed_fixup.py
+++ b/document/core/util/bikeshed_fixup.py
@@ -14,7 +14,7 @@ def Main():
   # Don't add more than 3 levels to TOC.
   data = data.replace('<h5>', '<h5 class="no-toc">')
 
-  # TODO(bradnelson/tabadkins): Fix when bikeshed can do letters.
+  # TODO(bradnelson/tabatkins): Fix when bikeshed can do letters.
   # Don't number the Appendix.
   data = data.replace(
       '<h2>Appendix</h2>',
diff --git a/document/core/util/katex_fix.patch b/document/core/util/katex_fix.patch
index 9205024cc..e1f1bf59c 100644
--- a/document/core/util/katex_fix.patch
+++ b/document/core/util/katex_fix.patch
@@ -33,5 +33,5 @@
 > .footnote td {
 >   border: 0;
 > }
-> blockquote {
->   border-color: transparent;
+> .codepre {
+>   whitespace: pre;
diff --git a/document/core/util/mathjax2katex.py b/document/core/util/mathjax2katex.py
index c1a3d83e5..eac05643c 100755
--- a/document/core/util/mathjax2katex.py
+++ b/document/core/util/mathjax2katex.py
@@ -86,6 +86,7 @@ def ReplaceMath(cache, data):
     sys.stderr.write('BEFORE:\n' + old + '\n')
     sys.stderr.write('AFTER:\n' + data + '\n')
     return ''
+  ret = ret.strip()
   ret = ret[ret.find('<span class="katex-html"'):]
   ret = '<span class="katex-display"><span class="katex">' + ret + '</span>'
   # w3c validator does not like negative em.
@@ -104,13 +105,21 @@ def ReplaceMath(cache, data):
   ret = re.sub(
       'mainit" style="margin-right:0.[0-9]+em', 'mathit" style="', ret)
 
-  cache[data] = ' ' + ret + ' '
+  cache[data] = ret
   return ret
 
 
 def Main():
   fixups = []
 
+  # TODO(bradnelson, tabatkins): Fix bikeshed to not muck up <pre>.
+  def StripParas(match):
+    ret = match.group(1)
+    ret = ret.replace('\n<p><span class="k">case', '\n   <span class="k">case')
+    ret = ret.replace('<p>', '')
+    ret = ret.replace('</p>', '')
+    return ret
+
   def ExtractMath(match):
     fixups.append(
         (match.group(1), match.group(2), match.group(3), match.group(4),
@@ -147,9 +156,10 @@ def ExtractMath(match):
   # Drop sphinx css.
   data = data.replace(
       '<link href="_static/classic.css" rel="stylesheet" type="text/css">', '')
+  # Fix sphinx css
   data = data.replace(
       '<link href="_static/pygments.css" rel="stylesheet" type="text/css">',
-      '')
+      '<link href="pygments.css" rel="stylesheet" type="text/css">')
   # Bad duplicate meta.
   data = ''.join(data.rsplit(
       '<meta content="text/html; charset=utf-8" http-equiv="Content-Type">', 1))
@@ -167,13 +177,15 @@ def ExtractMath(match):
   data = data.replace(' frame="void"', '')
   # rules="none" fails w3c validator.
   data = data.replace(' rules="none"', '')
-  # <pre> makes w3c valdiator angry (w/ <p> nested)
-  data = data.replace('<pre>', '<div>')
-  data = data.replace('</pre>', '</div>')
   # width="*" angers w3c validator.
   data = re.sub(' width="[0-9]+%"', '', data)
   # border="1" angers w3c validator.
   data = data.replace(' border="1"', '')
+  # Get rid of gray bars.
+  data = data.replace(
+      '<blockquote>', '<blockquote style="border-color: transparent">')
+  # Strip <p> in <pre>
+  data = re.sub('(<pre>.*?</pre>)', StripParas, data, 0, re.DOTALL)
 
   # Pull out math fragments.
   data = re.sub(

From ae43bbef3af7eaf7d914db18a10e555f3e3bfbd1 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 21 Feb 2018 16:57:24 +0100
Subject: [PATCH 212/329] [spec] Layering: Improve way of throwing on detach

Detaching an ArrayBuffer which comes from a WebAssembly.Memory
throws an error. Previously, this was simply asserted in a comment;
this patch hooks into a new ECMAScript layering device to make
things more clear.
---
 document/js-api/index.bs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 6cf8fa216..f4ab3d92b 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -555,11 +555,10 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
         1. Return |map|[|memaddr|].
     1. Let |block| be a Data Block which is [=identified with=] the underlying memory of |memaddr|
     1. Let |buffer| be a new {{ArrayBuffer}} whose \[[ArrayBufferData]] is |block| and \[[ArrayBufferByteLength]] is set to the length of |block|.
+    1. Set |buffer|.\[[ArrayBufferDetachKey]] to "WebAssembly.Memory".
     1. Let |memory| be a new {{Memory}} instance with \[[Memory]] set to |memaddr| and \[[BufferObject]] set to |buffer|.
     1. [=map/Set=] |map|[|memaddr|] to |memory|.
     1. Return |memory|.
-
-    Issue: Any attempts to [=DetachArrayBuffer|detach=] |buffer|, other than the detachment performed by {{Memory/grow(delta)}}, will throw a {{TypeError}} exception. Specifying this behavior <a href="https://github.com/tc39/ecma262/issues/1024">requires changes to the ECMAScript specification</a>.
 </div>
 
 <div algorithm>
@@ -579,7 +578,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Let |map| be the [=surrounding agent=]'s associated [=Memory object cache=].
     1. Assert: |map|[|memaddr|] [=map/exists=]
     1. Let |memory| be |map|[|memaddr|].
-    1. Perform ! [=DetachArrayBuffer=](|memory|.\[[BufferObject]]).
+    1. Perform ! [=ForceDetachArrayBuffer=](|memory|.\[[BufferObject]], "WebAssembly.Memory").
     1. Let |block| be a [=Data Block=] which is [=identified with=] the underlying memory of |memaddr|.
     1. Let |buffer| be a new {{ArrayBuffer}} whose \[[ArrayBufferData]] is |block| and \[[ArrayBufferByteLength]] is set to the length of |block|.
     1. Set |memory|.\[[BufferObject]] to |buffer|.

From db551f3a13cd1c4220ca60e0e59a7181ddd17292 Mon Sep 17 00:00:00 2001
From: Jason Davies <jason@jasondavies.com>
Date: Thu, 26 Apr 2018 13:13:15 +0100
Subject: [PATCH 213/329] [spec] Fix typo (#786)

---
 document/core/appendix/custom.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/appendix/custom.rst b/document/core/appendix/custom.rst
index 02895e3cb..afd2b1a0e 100644
--- a/document/core/appendix/custom.rst
+++ b/document/core/appendix/custom.rst
@@ -16,7 +16,7 @@ Currently, only one dedicated custom section is defined, the :ref:`name section<
 Name Section
 ~~~~~~~~~~~~
 
-The *name section* is a :ref:`custom sections <binary-customsec>` whose name string is itself :math:`\text{name}`.
+The *name section* is a :ref:`custom section <binary-customsec>` whose name string is itself :math:`\text{name}`.
 The name section should appear only once in a module, and only after the :ref:`data section <binary-datasec>`.
 
 The purpose of this section is to attach printable names to definitions in a module, which e.g. can be used by a debugger or when parts of the module are to be rendered in :ref:`text form <text>`.

From 9f9e031078f53143668eb1741bc35dd811a16a2a Mon Sep 17 00:00:00 2001
From: Linda_pp <rhysd@users.noreply.github.com>
Date: Sat, 28 Apr 2018 22:42:40 +0900
Subject: [PATCH 214/329] [spec] Fix typos (#789)

---
 document/core/intro/introduction.rst | 2 +-
 document/web-api/index.bs            | 2 +-
 test/harness/testharness.js          | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/document/core/intro/introduction.rst b/document/core/intro/introduction.rst
index 4819dbdd7..f9523024c 100644
--- a/document/core/intro/introduction.rst
+++ b/document/core/intro/introduction.rst
@@ -91,6 +91,6 @@ However, to make this specification self-contained, relevant aspects of the afor
 such as the :ref:`binary representation <aux-fbits>` and :ref:`rounding <aux-ieee>` of floating-point values, and the :ref:`value range <syntax-codepoint>` and :ref:`UTF-8 encoding <binary-utf8>` of Unicode characters.
 
 .. note::
-   The aforementioned standards are the authorative source of all respective definitions.
+   The aforementioned standards are the authoritative source of all respective definitions.
    Formalizations given in this specification are intended to match these definitions.
    Any discrepancy in the syntax or semantics described is to be considered an error.
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index ba62bc487..1ceb13b84 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -136,7 +136,7 @@ example) even though the exact format of implementation-dependent stack trace
 strings does not always match, the locations are easily understandable and the
 same across browsers.
 
-To achive the same goal of a common representations for WebAssembly constructs, the
+To achieve the same goal of a common representations for WebAssembly constructs, the
 following conventions are adopted.
 
 A WebAssembly location is a reference to a particular instruction in the binary, and may be
diff --git a/test/harness/testharness.js b/test/harness/testharness.js
index 49e386754..fdd87e8fc 100644
--- a/test/harness/testharness.js
+++ b/test/harness/testharness.js
@@ -591,7 +591,7 @@ policies and contribution forms [3].
 
         /**
          * Returns a Promise that will resolve after the specified event or
-         * series of events has occured.
+         * series of events has occurred.
          */
         this.wait_for = function(types) {
             if (waitingFor) {
@@ -971,7 +971,7 @@ policies and contribution forms [3].
     function assert_approx_equals(actual, expected, epsilon, description)
     {
         /*
-         * Test if two primitive numbers are equal withing +/- epsilon
+         * Test if two primitive numbers are equal within +/- epsilon
          */
         assert(typeof actual === "number",
                "assert_approx_equals", description,

From de785f1fc8f70ed917e3d70ac2696af7a3895a10 Mon Sep 17 00:00:00 2001
From: Benjamin Bouvier <public@benj.me>
Date: Wed, 2 May 2018 12:20:09 +0200
Subject: [PATCH 215/329] Fix a typo in web api;

---
 document/web-api/index.bs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 1ceb13b84..8d7518125 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -157,7 +157,7 @@ Notes:
     browser, the associated URL should be used; or when the
     {{ArrayBuffer}}-based instantiation
     [=instantiate|API=] is used, the browser should represent
-    the location of the API call. This kind of instantiation is analagous to
+    the location of the API call. This kind of instantiation is analogous to
     executing JavaScript using `eval`; therefore if the browser has an existing
     method to represent the location of the `eval` call it can use a similar
     one for `WebAssembly.instantiate`. For example if the browser uses
@@ -166,7 +166,7 @@ Notes:
     `WebAssembly.instantiate at bar (foo.js:10:3)`, respectively.
     Offline tools may use a filename instead.
 * Using hexadecimal for module offsets matches common conventions in native tools
-    such as objdump (where addresses are printed in hex) and makes them visually
+    such as `objdump` (where addresses are printed in hex) and makes them visually
     distinct from JavaScript line numbers. Other numbers are represented in decimal.
 
 While the "name" property of an [=Exported Function=] instance

From f680ab80020f5d34f8f5673040a99bd9de25c3f4 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Wed, 2 May 2018 16:37:11 +0200
Subject: [PATCH 216/329] [spec] Layout tweak

---
 document/core/exec/runtime.rst | 22 +++++++---------------
 1 file changed, 7 insertions(+), 15 deletions(-)

diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst
index e798f06f4..c1375fe1e 100644
--- a/document/core/exec/runtime.rst
+++ b/document/core/exec/runtime.rst
@@ -565,22 +565,14 @@ Finally, the following definition of *evaluation context* and associated structu
    \end{array}
 
 .. math::
-   \begin{array}{l}
-   \begin{array}{lcl@{\qquad}l}
-   S; F; E[\instr^\ast] &\stepto& S'; F'; E[{\instr'}^\ast]
-   \end{array}
-   \\ \qquad
-     (\iff S; F; \instr^\ast \stepto S'; F'; {\instr'}^\ast) \\
-   \begin{array}{lcl@{\qquad}l}
-   S; F; \FRAME_n\{F'\}~\instr^\ast~\END &\stepto& S'; F; \FRAME_n\{F''\}~\instr'^\ast~\END
-   \end{array}
-   \\ \qquad
-     (\iff S; F'; \instr^\ast \stepto S'; F''; {\instr'}^\ast) \\[1ex]
-   \begin{array}{lcl@{\qquad}l}
+   \begin{array}{rcl}
+   S; F; E[\instr^\ast] &\stepto& S'; F'; E[{\instr'}^\ast] \\
+     && (\iff S; F; \instr^\ast \stepto S'; F'; {\instr'}^\ast) \\
+   S; F; \FRAME_n\{F'\}~\instr^\ast~\END &\stepto& S'; F; \FRAME_n\{F''\}~\instr'^\ast~\END \\
+     && (\iff S; F'; \instr^\ast \stepto S'; F''; {\instr'}^\ast) \\[1ex]
    S; F; E[\TRAP] &\stepto& S; F; \TRAP
-     &(\iff E \neq [\_]) \\
-   S; F; \FRAME_n\{F'\}~\TRAP~\END &\stepto& S; F; \TRAP
-   \end{array} \\
+     \qquad (\iff E \neq [\_]) \\
+   S; F; \FRAME_n\{F'\}~\TRAP~\END &\stepto& S; F; \TRAP \\
    \end{array}
 
 Reduction terminates when a thread's instruction sequence has been reduced to a :ref:`result <syntax-result>`,

From ea64a0e698dc42276b6e18c97e7656b326296441 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 3 May 2018 08:49:11 +0200
Subject: [PATCH 217/329] [spec] Address Derek's review comments for Section 2
 (#766)

---
 document/core/syntax/conventions.rst  |  3 ++-
 document/core/syntax/instructions.rst | 11 ++++++-----
 document/core/syntax/modules.rst      | 14 +++++++-------
 document/core/syntax/values.rst       |  2 +-
 4 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/document/core/syntax/conventions.rst b/document/core/syntax/conventions.rst
index a1aec4214..995f131f4 100644
--- a/document/core/syntax/conventions.rst
+++ b/document/core/syntax/conventions.rst
@@ -37,8 +37,9 @@ The following conventions are adopted in defining grammar rules for abstract syn
 
 * Productions are written :math:`\X{sym} ::= A_1 ~|~ \dots ~|~ A_n`.
 
-* Some productions are augmented with side conditions in parentheses, ":math:`(\iff \X{condition})`", that provide a shorthand for a combinatorial expansion of the production into many separate cases.
+* Large productions may be split into multiple definitions, indicated by ending the first one with explicit ellipses, :math:`\X{sym} ::= A_1 ~|~ \dots`, and starting continuations with ellipses, :math:`\X{sym} ::= \dots ~|~ A_2`.
 
+* Some productions are augmented with side conditions in parentheses, ":math:`(\iff \X{condition})`", that provide a shorthand for a combinatorial expansion of the production into many separate cases.
 
 
 .. _notation-epsilon:
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index 1b8e195db..a952041f6 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -7,7 +7,7 @@ Instructions
 
 WebAssembly code consists of sequences of *instructions*.
 Its computational model is based on a *stack machine* in that instructions manipulate values on an implicit *operand stack*,
-consuming (popping) argument values and producing (pushing) result values.
+consuming (popping) argument values and producing or returning (pushing) result values.
 
 .. note::
    In the current version of WebAssembly,
@@ -71,7 +71,8 @@ These operations closely match respective operations available in hardware.
      \K{f64.}\PROMOTE\K{/f32} ~|~
      \K{f}\X{nn}\K{.}\CONVERT\K{\_}\sx/\K{i}\X{mm} \\&&|&
      \K{i}\X{nn}\K{.}\REINTERPRET\K{/f}\X{nn} ~|~
-     \K{f}\X{nn}\K{.}\REINTERPRET\K{/i}\X{nn} \\
+     \K{f}\X{nn}\K{.}\REINTERPRET\K{/i}\X{nn} \\&&|&
+     \dots \\
    \production{integer unary operator} & \iunop &::=&
      \K{clz} ~|~
      \K{ctz} ~|~
@@ -139,7 +140,7 @@ For each type, several subcategories can be distinguished:
 * *Conversions*: consume a value of one type and produce a result of another
   (the source type of the conversion is the one after the ":math:`\K{/}`").
 
-Some integer instructions come in two flavours,
+Some integer instructions come in two flavors,
 where a signedness annotation |sx| distinguishes whether the operands are to be :ref:`interpreted <aux-signed>` as :ref:`unsigned <syntax-uint>` or :ref:`signed <syntax-sint>` integers.
 For the other integer instructions, the use of two's complement for the signed interpretation means that they behave the same regardless of signedness.
 
@@ -195,7 +196,7 @@ The |SELECT| operator selects one of its first two operands based on whether its
 Variable Instructions
 ~~~~~~~~~~~~~~~~~~~~~
 
-Variable instructions are concerned with the access to :ref:`local <syntax-local>` or :ref:`global <syntax-global>` variables.
+Variable instructions are concerned with access to :ref:`local <syntax-local>` or :ref:`global <syntax-global>` variables.
 
 .. math::
    \begin{array}{llcl}
@@ -315,7 +316,7 @@ A structured instruction can produce a value as described by the annotated :ref:
 
 Each structured control instruction introduces an implicit *label*.
 Labels are targets for branch instructions that reference them with :ref:`label indices <syntax-labelidx>`.
-Unlike with other index spaces, indexing of labels is relative by nesting depth,
+Unlike with other :ref:`index spaces <syntax-index>`, indexing of labels is relative by nesting depth,
 that is, label :math:`0` refers to the innermost structured control instruction enclosing the referring branch instruction,
 while increasing indices refer to those farther out.
 Consequently, labels can only be referenced from *within* the associated structured control instruction.
diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index fe2b3cd7a..9f4acbc82 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -73,7 +73,7 @@ Each class of definition has its own *index space*, as distinguished by the foll
 The index space for :ref:`functions <syntax-func>`, :ref:`tables <syntax-table>`, :ref:`memories <syntax-mem>` and :ref:`globals <syntax-global>` includes respective :ref:`imports <syntax-import>` declared in the same module.
 The indices of these imports precede the indices of other definitions in the same index space.
 
-The index space for :ref:`locals <syntax-local>` is only accessible inside a :ref:`function <syntax-func>` and includes the parameters and local variables of that function, which precede the other locals.
+The index space for :ref:`locals <syntax-local>` is only accessible inside a :ref:`function <syntax-func>` and includes the parameters of that function, which precede the local variables.
 
 Label indices reference :ref:`structured control instructions <syntax-instr-control>` inside an instruction sequence.
 
@@ -83,7 +83,7 @@ Conventions
 
 * The meta variable :math:`l` ranges over label indices.
 
-* The meta variables :math:`x, y` ranges over indices in any of the other index spaces.
+* The meta variables :math:`x, y` range over indices in any of the other index spaces.
 
 
 .. index:: ! type definition, type index, function type
@@ -120,7 +120,7 @@ The |MFUNCS| component of a module defines a vector of *functions* with the foll
    \end{array}
 
 The |FTYPE| of a function declares its signature by reference to a :ref:`type <syntax-type>` defined in the module.
-The parameters of the function are referenced through 0-based :ref:`local indices <syntax-localidx>` in the function's body.
+The parameters of the function are referenced through 0-based :ref:`local indices <syntax-localidx>` in the function's body; they are mutable.
 
 The |FLOCALS| declare a vector of mutable local variables and their types.
 These variables are referenced through :ref:`local indices <syntax-localidx>` in the function's body.
@@ -226,7 +226,7 @@ Element Segments
 ~~~~~~~~~~~~~~~~
 
 The initial contents of a table is uninitialized.
-The |MELEM| component of a module defines a vector of *element segments* that initialize a subrange of a table at a given offset from a static :ref:`vector <syntax-vec>` of elements.
+The |MELEM| component of a module defines a vector of *element segments* that initialize a subrange of a table, at a given offset, from a static :ref:`vector <syntax-vec>` of elements.
 
 .. math::
    \begin{array}{llll}
@@ -250,8 +250,8 @@ The |EOFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <s
 Data Segments
 ~~~~~~~~~~~~~
 
-The initial contents of a :ref:`memory <syntax-mem>` are zero bytes.
-The |MDATA| component of a module defines a vector of *data segments* that initialize a range of memory at a given offset with a static :ref:`vector <syntax-vec>` of :ref:`bytes <syntax-byte>`.
+The initial contents of a :ref:`memory <syntax-mem>` are zero-valued bytes.
+The |MDATA| component of a module defines a vector of *data segments* that initialize a range of memory, at a given offset, with a static :ref:`vector <syntax-vec>` of :ref:`bytes <syntax-byte>`.
 
 .. math::
    \begin{array}{llll}
@@ -273,7 +273,7 @@ The |DOFFSET| is given by a :ref:`constant <valid-constant>` :ref:`expression <s
 Start Function
 ~~~~~~~~~~~~~~
 
-The |MSTART| component of a module optionally declares the :ref:`function index <syntax-funcidx>` of a *start function* that is automatically invoked when the module is :ref:`instantiated <exec-instantiation>`, after :ref:`tables <syntax-table>` and :ref:`memories <syntax-mem>` have been initialized.
+The |MSTART| component of a module declares the :ref:`function index <syntax-funcidx>` of a *start function* that is automatically invoked when the module is :ref:`instantiated <exec-instantiation>`, after :ref:`tables <syntax-table>` and :ref:`memories <syntax-mem>` have been initialized.
 
 .. math::
    \begin{array}{llll}
diff --git a/document/core/syntax/values.rst b/document/core/syntax/values.rst
index e2dcc91ca..69385e6b3 100644
--- a/document/core/syntax/values.rst
+++ b/document/core/syntax/values.rst
@@ -166,7 +166,7 @@ Names
    \end{array}
 
 Due to the limitations of the :ref:`binary format <binary-name>`,
-the lengths of a name is bounded by the length of its :ref:`UTF-8 <binary-utf8>` encoding.
+the length of a name is bounded by the length of its :ref:`UTF-8 <binary-utf8>` encoding.
 
 
 Convention

From 5c75e108def4436197ac0f82a0a5311ce9567850 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 3 May 2018 22:12:54 +0200
Subject: [PATCH 218/329] [spec] Address review by eholk; allow host function
 divergence & non-determinism (#792)

---
 document/core/appendix/properties.rst | 27 +++++++++++++++++----------
 document/core/exec/instructions.rst   | 16 +++++++++++++---
 2 files changed, 30 insertions(+), 13 deletions(-)

diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index a584516e8..31f2ec854 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -7,11 +7,11 @@ Soundness
 The :ref:`type system <type-system>` of WebAssembly is *sound*, implying both *type safety* and *memory safety* with respect to the WebAssembly semantics. For example:
 
 * All types declared and derived during validation are respected at run time;
-  e.g., every :ref:`local <syntax-local>` or :ref:`global <syntax-global>` variable will only contain type-correct values, every :ref:`instruction <syntax-instr>` will only be applied to operands of the expected type, and every :ref:`function <syntax-func>` :ref:`invocation <exec-invocation>` always evaluates to a result of the right type (if it does not :ref:`trap <trap>`).
+  e.g., every :ref:`local <syntax-local>` or :ref:`global <syntax-global>` variable will only contain type-correct values, every :ref:`instruction <syntax-instr>` will only be applied to operands of the expected type, and every :ref:`function <syntax-func>` :ref:`invocation <exec-invocation>` always evaluates to a result of the right type (if it does not :ref:`trap <trap>` or diverge).
 
 * No memory location will be read or written except those explicitly defined by the program, i.e., as a :ref:`local <syntax-local>`, a :ref:`global <syntax-global>`, an element in a :ref:`table <syntax-table>`, or a location within a linear :ref:`memory <syntax-mem>`.
 
-* There is no undefined behaviour,
+* There is no undefined behavior,
   i.e., the :ref:`execution rules <exec>` cover all possible cases that can occur in a :ref:`valid <valid>` program, and the rules are mutually consistent.
 
 Soundness also is instrumental in ensuring additional properties, most notably, *encapsulation* of function and module scopes: no :ref:`locals <syntax-local>` can be accessed outside their own function and no :ref:`module <syntax-module>` components can be accessed outside their own module unless they are explicitly :ref:`exported <syntax-export>` or :ref:`imported <syntax-import>`.
@@ -161,11 +161,15 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type <syntax-functype>` :math:`\functype`.
 
-* For every possible :ref:`valid <valid-store>` :ref:`store <syntax-store>` :math:`S_1` :ref:`extending <extend-store>` :math:`S` and every sequence :math:`\val^\ast` of :ref:`values <syntax-val>` whose :ref:`types <valid-val>` coincide with :math:`t_1^\ast`:
+* For every :ref:`valid <valid-store>` :ref:`store <syntax-store>` :math:`S_1` :ref:`extending <extend-store>` :math:`S` and every sequence :math:`\val^\ast` of :ref:`values <syntax-val>` whose :ref:`types <valid-val>` coincide with :math:`t_1^\ast`:
 
-  * There must exist a :ref:`valid <valid-store>` :ref:`store <syntax-store>` :math:`S_2` :ref:`extending <extend-store>` :math:`S_1` and a :ref:`result <syntax-result>` :math:`\result` whose :ref:`type <valid-result>` coincides with :math:`[t_2^\ast]` such that:
+  * :ref:`Executing <exec-invoke-host>` :math:`\X{hf}` in store :math:`S_1` with arguments :math:`\val^\ast` has a non-empty set of possible outcomes.
 
-    * :ref:`Executing <exec-invoke-host>` :math:`\X{hf}` in store :math:`S_1` with arguments :math:`\val^\ast` produces :math:`\result` and store :math:`S_2`.
+  * For every element :math:`R` of this set:
+
+    * Either :math:`R` must be :math:`\bot` (i.e., divergence).
+
+    * Or :math:`R` consists of a :ref:`valid <valid-store>` :ref:`store <syntax-store>` :math:`S_2` :ref:`extending <extend-store>` :math:`S_1` and a :ref:`result <syntax-result>` :math:`\result` whose :ref:`type <valid-result>` coincides with :math:`[t_2^\ast]`.
 
 * Then the function instance is valid with :ref:`function type <syntax-functype>` :math:`\functype`.
 
@@ -181,11 +185,14 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
        {\vdashstoreextends S \extendsto S_1} \wedge
        {\vdashresult \val^\ast : [t_1^\ast]}
        \Longrightarrow {} \\ \qquad
-     \exists S_2, \result,~
+       \X{hf}(S_1; \val^\ast) \supset \emptyset \wedge {} \\ \qquad
+     \forall R \in \X{hf}(S_1; \val^\ast),~
+       R = \bot \vee {} \\ \qquad\qquad
+       \exists S_2, \result,~
        {\vdashstore S_2 \ok} \wedge
        {\vdashstoreextends S_1 \extendsto S_2} \wedge
        {\vdashresult \result : [t_2^\ast]} \wedge
-       \X{hf}(S_1; \val^\ast) = S_2; \result
+       R = (S_2; \result)
      \end{array}
    }{
      S \vdashfuncinst \{\FITYPE~[t_1^\ast] \to [t_2^\ast], \FIHOSTCODE~\X{hf}\} : [t_1^\ast] \to [t_2^\ast]
@@ -584,7 +591,7 @@ The necessary constraints are codified by the notion of store *extension*:
 a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S'`, when the following rules hold.
 
 .. note::
-   Extension does not imply that the new store is valid, which is defined :ref:separately `above <valid-store>`.
+   Extension does not imply that the new store is valid, which is defined separately :ref:`above <valid-store>`.
 
 
 .. index:: store, function instance, table instance, memory instance, global instance
@@ -714,7 +721,7 @@ the standard soundness theorems hold. [#cite-cpp2018]_
 **Theorem (Preservation).**
 If a :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` with :ref:`result type <syntax-resulttype>` :math:`[t^\ast]` (i.e., :math:`\vdashconfig S;T : [t^\ast]`),
 and steps to :math:`S';T'` (i.e., :math:`S;T \stepto S';T'`),
-then :math:`S';T'` is a valid configuration with the same resulttype (i.e., :math:`\vdashconfig S';T' : [t^\ast]`).
+then :math:`S';T'` is a valid configuration with the same result type (i.e., :math:`\vdashconfig S';T' : [t^\ast]`).
 Furthermore, :math:`S'` is an :ref:`extension <extend-store>` of :math:`S` (i.e., :math:`\vdashstoreextends S \extendsto S'`).
 
 A *terminal* :ref:`thread <syntax-thread>` is one whose sequence of :ref:`instructions <syntax-instr>` is a :ref:`result <syntax-result>`.
@@ -729,7 +736,7 @@ From Preservation and Progress the soundness of the WebAssembly type system foll
 
 **Corollary (Soundness).**
 If a :ref:`configuration <syntax-config>` :math:`S;T` is :ref:`valid <valid-config>` (i.e., :math:`\vdashconfig S;T : [t^\ast]` for some :ref:`result type <syntax-resulttype>` :math:`[t^\ast]`),
-then it either diverges or takes a finite number of steps to reach a terminal configuration :math:`S';T'` (i.e., :math:`S;T \stepto^\ast S';T'`) that is valid with the same resulttype (i.e., :math:`\vdashconfig S';T' : [t^\ast]`)
+then it either diverges or takes a finite number of steps to reach a terminal configuration :math:`S';T'` (i.e., :math:`S;T \stepto^\ast S';T'`) that is valid with the same result type (i.e., :math:`\vdashconfig S';T' : [t^\ast]`)
 and where :math:`S'` is an :ref:`extension <extend-store>` of :math:`S` (i.e., :math:`\vdashstoreextends S \extendsto S'`).
 
 In other words, every thread in a valid configuration either runs forever, traps, or terminates with a result that has the expected type.
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 64f4e96a5..3672e42d8 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -1098,18 +1098,28 @@ Furthermore, the resulting store must be :ref:`valid <valid-store>`, i.e., all d
    \\ \qquad
      \begin{array}[t]{@{}r@{~}l@{}}
      (\iff & S.\SFUNCS[a] = \{ \FITYPE~[t_1^n] \to [t_2^m], \FIHOSTCODE~\X{hf} \} \\
-     \wedge & \X{hf}(S; \val^n) = S'; \result) \\
+     \wedge & (S'; \result) \in \X{hf}(S; \val^n)) \\
+     \end{array} \\
+   \begin{array}{lcl@{\qquad}l}
+   S; \val^n~(\INVOKE~a) &\stepto& S; \val^n~(\INVOKE~a)
+   \end{array}
+   \\ \qquad
+     \begin{array}[t]{@{}r@{~}l@{}}
+     (\iff & S.\SFUNCS[a] = \{ \FITYPE~[t_1^n] \to [t_2^m], \FIHOSTCODE~\X{hf} \} \\
+     \wedge & \bot \in \X{hf}(S; \val^n)) \\
      \end{array} \\
    \end{array}
 
 Here, :math:`\X{hf}(S; \val^n)` denotes the implementation-defined execution of host function :math:`\X{hf}` in current store :math:`S` with arguments :math:`\val^n`.
-The outcome is a pair of a modified store :math:`S'` and a :ref:`result <syntax-result>`.
+It yields a set of possible outcomes, where each element is either a pair of a modified store :math:`S'` and a :ref:`result <syntax-result>`
+or the special value :math:`\bot` indicating divergence.
+A host function is non-deterministic if there is at least one argument for which the set of outcomes is not singular.
 
 For a WebAssembly implementation to be :ref:`sound <soundness>` in the presence of host functions,
 every :ref:`host function instance <syntax-funcinst>` must be :ref:`valid <valid-hostfuncinst>`,
 which means that it adheres to suitable pre- and post-conditions:
 under a :ref:`valid store <valid-store>` :math:`S`, and given arguments :math:`\val^n` matching the ascribed parameter types :math:`t_1^n`,
-executing the host function must produce a valid store :math:`S'` that is an :ref:`extension <extend-store>` of :math:`S` and a result matching the ascribed return types :math:`t_2^m`.
+executing the host function must yield a non-empty set of possible outcomes each of which is either divergence or consists of a valid store :math:`S'` that is an :ref:`extension <extend-store>` of :math:`S` and a result matching the ascribed return types :math:`t_2^m`.
 All these notions are made precise in the :ref:`Appendix <soundness>`.
 
 .. note::

From 4730de7cd26b26132e6e16c704a56c49faa8a322 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Thu, 3 May 2018 22:22:22 +0200
Subject: [PATCH 219/329] [js-api] Fix cross-reference to JS spec (#783)

* [js-api] Fix cross-reference to JS spec

Following up on #712

[rossberg] Removing additional build blocker and landing.
---
 document/js-api/index.bs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index f4ab3d92b..e4abb65aa 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -173,8 +173,6 @@ spec:promises-guide-1; type:dfn; text:resolve
 
 This API privides a way to access WebAssembly [[WEBASSEMBLY]] through a bridge to explicitly construct modules from JavaScript [[ECMASCRIPT]].
 
-<p>See the [[#issues-index]] for complete list of issues.</p>
-
 <h2 id="sample">Sample API Usage</h2>
 
 <p><em>This section is non-normative.</em></p>
@@ -578,7 +576,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Let |map| be the [=surrounding agent=]'s associated [=Memory object cache=].
     1. Assert: |map|[|memaddr|] [=map/exists=]
     1. Let |memory| be |map|[|memaddr|].
-    1. Perform ! [=ForceDetachArrayBuffer=](|memory|.\[[BufferObject]], "WebAssembly.Memory").
+    1. Perform ! [=DetachArrayBuffer=](|memory|.\[[BufferObject]], "WebAssembly.Memory").
     1. Let |block| be a [=Data Block=] which is [=identified with=] the underlying memory of |memaddr|.
     1. Let |buffer| be a new {{ArrayBuffer}} whose \[[ArrayBufferData]] is |block| and \[[ArrayBufferByteLength]] is set to the length of |block|.
     1. Set |memory|.\[[BufferObject]] to |buffer|.

From 4603d6c36992945e90ba96b82a17c084ebb25644 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 3 May 2018 22:56:51 +0200
Subject: [PATCH 220/329] [spec] Address sbc100's comments of Section 6 (#791)

---
 document/core/text/conventions.rst | 10 +++++-----
 document/core/text/lexical.rst     |  4 ++--
 document/core/text/modules.rst     | 18 ++++++++----------
 document/core/text/values.rst      |  4 ++--
 4 files changed, 17 insertions(+), 19 deletions(-)

diff --git a/document/core/text/conventions.rst b/document/core/text/conventions.rst
index ef7ad7f39..1d87c8ce7 100644
--- a/document/core/text/conventions.rst
+++ b/document/core/text/conventions.rst
@@ -15,7 +15,7 @@ that records bound :ref:`identifers <text-id>`.
 Except for a few exceptions, the core of the text grammar closely mirrors the grammar of the abstract syntax.
 However, it also defines a number of *abbreviations* that are "syntactic sugar" over the core syntax.
 
-The recommended extension for source files containing WebAssembly modules in text format is ":math:`\T{.wat}`".
+The recommended extension for files containing WebAssembly modules in text format is ":math:`\T{.wat}`".
 Files with this extension are assumed to be encoded in UTF-8, as per |Unicode|_ (Section 2.5).
 
 
@@ -27,12 +27,12 @@ Files with this extension are assumed to be encoded in UTF-8, as per |Unicode|_
 Grammar
 ~~~~~~~
 
-The following conventions are adopted in defining grammar rules for the text format.
+The following conventions are adopted in defining grammar rules of the text format.
 They mirror the conventions used for :ref:`abstract syntax <grammar>` and for the :ref:`binary format <binary>`.
 In order to distinguish symbols of the textual syntax from symbols of the abstract syntax, :math:`\mathtt{typewriter}` font is adopted for the former.
 
-* Terminal symbols are either literal strings of characters enclosed in quotes: :math:`\text{module}`;
-  or expressed as |Unicode|_ code points: :math:`\unicode{0A}`.
+* Terminal symbols are either literal strings of characters enclosed in quotes
+  or expressed as |Unicode|_ code points: :math:`\text{module}`, :math:`\unicode{0A}`.
   (All characters written literally are unambiguously drawn from the 7-bit |ASCII|_ subset of Unicode.)
 
 * Nonterminal symbols are written in typewriter font: :math:`\T{valtype}, \T{instr}`.
@@ -106,7 +106,7 @@ These expansions are assumed to be applied, recursively and in order of appearan
 Contexts
 ~~~~~~~~
 
-The text format allows to use symbolic :ref:`identifiers <text-id>` in place of :ref:`indices <syntax-index>`.
+The text format allows the use of symbolic :ref:`identifiers <text-id>` in place of :ref:`indices <syntax-index>`.
 To resolve these identifiers into concrete indices,
 some grammar production are indexed by an *identifier context* :math:`I` as a synthesized attribute that records the declared identifiers in each :ref:`index space <syntax-index>`.
 In addition, the context records the types defined in the module, so that :ref:`parameter <text-param>` indices can be computed for :ref:`functions <text-func>`.
diff --git a/document/core/text/lexical.rst b/document/core/text/lexical.rst
index 02b8db6ad..b4df16788 100644
--- a/document/core/text/lexical.rst
+++ b/document/core/text/lexical.rst
@@ -58,7 +58,7 @@ That is, the next token always consists of the longest possible sequence of char
 Tokens can be separated by :ref:`white space <text-space>`,
 but except for strings, they cannot themselves contain whitespace.
 
-The set of *keyword* tokens is defined implicitly, by all occurrences of a :ref:`terminal symbol <text-grammar>` in literal form :math:`\text{keyword}` in a :ref:`syntactic <text-syntactic>` production of this chapter.
+The set of *keyword* tokens is defined implicitly, by all occurrences of a :ref:`terminal symbol <text-grammar>` in literal form, such as :math:`\text{keyword}`, in a :ref:`syntactic <text-syntactic>` production of this chapter.
 
 Any token that does not fall into any of the other categories is considered *reserved*, and cannot occur in source text.
 
@@ -88,7 +88,7 @@ The allowed formatting characters correspond to a subset of the |ASCII|_ *format
      \unicode{09} ~|~ \unicode{0A} ~|~ \unicode{0D} \\
    \end{array}
 
-The only relevance of white space is to separate :ref:`tokens <text-token>`, it is ignored otherwise.
+The only relevance of white space is to separate :ref:`tokens <text-token>`. It is otherwise ignored.
 
 
 .. index:: ! comment, character
diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index c52a3872c..d6bfbb399 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -94,7 +94,7 @@ If inline declarations are given, then their types must match the referenced :re
        \quad\Rightarrow\quad x, I' \\ &&& \qquad
        (\iff \begin{array}[t]{@{}l@{}}
         I.\ITYPEDEFS[x] = [t_1^\ast] \to [t_2^\ast] \wedge
-        I' = \{\ILOCALS~\F{id}(\Tparam)\}^\ast \idcwellformed) \\
+        I' = \{\ILOCALS~\F{id}(\Tparam)^\ast\} \idcwellformed) \\
         \end{array} \\
    \end{array}
 
@@ -226,7 +226,7 @@ Multiple anonymous locals may be combined into a single declaration:
      (\text{(}~~\text{local}~~\Tvaltype~~\text{)})^\ast \\
    \end{array}
 
-Moreover, functions can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
+Functions can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
 
 .. math::
    \begin{array}{llclll}
@@ -273,7 +273,7 @@ Table definitions can bind a symbolic :ref:`table identifier <text-id>`.
 Abbreviations
 .............
 
-An :ref:`element segment <text-elem>` can be given inline with a table definition, in which case the :ref:`limits <text-limits>` of the :ref:`table type <text-tabletype>` are inferred from the length of the given segment:
+An :ref:`element segment <text-elem>` can be given inline with a table definition, in which case its offset is :math:`0` and the :ref:`limits <text-limits>` of the :ref:`table type <text-tabletype>` are inferred from the length of the given segment:
 
 .. math::
    \begin{array}{llclll}
@@ -285,7 +285,7 @@ An :ref:`element segment <text-elem>` can be given inline with a table definitio
        (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh) \\
    \end{array}
 
-Moreover, tables can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
+Tables can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
 
 .. math::
    \begin{array}{llclll}
@@ -332,7 +332,7 @@ Memory definitions can bind a symbolic :ref:`memory identifier <text-id>`.
 Abbreviations
 .............
 
-A :ref:`data segment <text-data>` can be given inline with a memory definition, in which case the :ref:`limits <text-limits>` of the :ref:`memory type <text-memtype>` are inferred from the length of the data, rounded up to :ref:`page size <page-size>`:
+A :ref:`data segment <text-data>` can be given inline with a memory definition, in which case its offset is :math:`0` the :ref:`limits <text-limits>` of the :ref:`memory type <text-memtype>` are inferred from the length of the data, rounded up to :ref:`page size <page-size>`:
 
 .. math::
    \begin{array}{llclll}
@@ -344,7 +344,7 @@ A :ref:`data segment <text-data>` can be given inline with a memory definition,
        (\iff \Tid' = \Tid^? \neq \epsilon \vee \Tid' \idfresh, m = \F{ceil}(n / 64\F{Ki})) \\
    \end{array}
 
-Moreover, memories can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
+Memories can be defined as :ref:`imports <text-import>` or :ref:`exports <text-export>` inline:
 
 .. math::
    \begin{array}{llclll}
@@ -471,7 +471,6 @@ Element Segments
 ~~~~~~~~~~~~~~~~
 
 Element segments allow for an optional :ref:`table index <text-tableidx>` to identify the table to initialize.
-When omitted, :math:`\T{0}` is assumed.
 
 .. math::
    \begin{array}{llclll}
@@ -497,7 +496,7 @@ As an abbreviation, a single instruction may occur in place of the offset:
      \text{(}~\text{offset}~~\Tinstr~\text{)}
    \end{array}
 
-Also, the table index can be omitted, defaulting to :math:`0`.
+Also, the table index can be omitted, defaulting to :math:`\T{0}`.
 
 .. math::
    \begin{array}{llclll}
@@ -521,7 +520,6 @@ Data Segments
 ~~~~~~~~~~~~~
 
 Data segments allow for an optional :ref:`memory index <text-memidx>` to identify the memory to initialize.
-When omitted, :math:`\T{0}` is assumed.
 The data is written as a :ref:`string <text-string>`, which may be split up into a possibly empty sequence of individual string literals.
 
 .. math::
@@ -550,7 +548,7 @@ As an abbreviation, a single instruction may occur in place of the offset:
      \text{(}~\text{offset}~~\Tinstr~\text{)}
    \end{array}
 
-Also, the memory index can be omitted, defaulting to :math:`0`.
+Also, the memory index can be omitted, defaulting to :math:`\T{0}`.
 
 .. math::
    \begin{array}{llclll}
diff --git a/document/core/text/values.rst b/document/core/text/values.rst
index 42084a2c1..51be72eb7 100644
--- a/document/core/text/values.rst
+++ b/document/core/text/values.rst
@@ -167,7 +167,7 @@ except for hexadecimal escape sequences :math:`\textl\backslash hh\textr`, which
    \begin{array}{llclll@{\qquad\qquad}l}
    \production{string character} & \Tstringchar &::=&
      c{:}\Tchar &\Rightarrow& c \qquad
-       & (\iff c \geq \unicode{20} \wedge c \neq \unicode{7F} \wedge c \neq \text{"} c \neq \text{\backslash}) \\ &&|&
+       & (\iff c \geq \unicode{20} \wedge c \neq \unicode{7F} \wedge c \neq \text{"} \wedge c \neq \text{\backslash}) \\ &&|&
      \text{\backslash t} &\Rightarrow& \unicode{09} \\ &&|&
      \text{\backslash n} &\Rightarrow& \unicode{0A} \\ &&|&
      \text{\backslash r} &\Rightarrow& \unicode{0D} \\ &&|&
@@ -187,7 +187,7 @@ Names
 ~~~~~
 
 :ref:`Names <syntax-name>` are strings denoting a literal character sequence. 
-A name string must form a valid UTF-8 encoding as defined by |Unicode|_ (Section 2.5) that is interpreted as a string of Unicode code points.
+A name string must form a valid UTF-8 encoding as defined by |Unicode|_ (Section 2.5) and is interpreted as a string of Unicode code points.
 
 .. math::
    \begin{array}{llclll@{\qquad}l}

From 1f00d57d009ec4098b60fb6ca138e8e2787accef Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 3 May 2018 23:20:37 +0200
Subject: [PATCH 221/329] [spec] Address aardappel's review of Section 5 (#795)

---
 document/core/binary/conventions.rst |  3 ++-
 document/core/binary/modules.rst     |  2 +-
 document/core/binary/types.rst       |  2 +-
 document/core/binary/values.rst      |  3 +++
 document/core/text/instructions.rst  | 10 ++++++++++
 5 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/document/core/binary/conventions.rst b/document/core/binary/conventions.rst
index 5f6b2e226..8d3839977 100644
--- a/document/core/binary/conventions.rst
+++ b/document/core/binary/conventions.rst
@@ -10,7 +10,8 @@ The format is defined by an *attribute grammar* whose only terminal symbols are
 A byte sequence is a well-formed encoding of a module if and only if it is generated by the grammar.
 
 Each production of this grammar has exactly one synthesized attribute: the abstract syntax that the respective byte sequence encodes.
-Thus, the attribute grammar implicitly defines a *decoding* function.
+Thus, the attribute grammar implicitly defines a *decoding* function
+(i.e., a parsing function for the binary format).
 
 Except for a few exceptions, the binary grammar closely mirrors the grammar of the abstract syntax.
 
diff --git a/document/core/binary/modules.rst b/document/core/binary/modules.rst
index 5e40a1e84..b66731498 100644
--- a/document/core/binary/modules.rst
+++ b/document/core/binary/modules.rst
@@ -414,7 +414,7 @@ It decodes into a vector of :ref:`data segments <syntax-data>` that represent th
 Modules
 ~~~~~~~
 
-The encoding of a :ref:`module <syntax-module>` starts with a preamble containing a 4-byte magic number and a version field.
+The encoding of a :ref:`module <syntax-module>` starts with a preamble containing a 4-byte magic number (the string :math:`\text{\backslash0asm}`) and a version field.
 The current version of the WebAssembly binary format is 1.
 
 The preamble is followed by a sequence of :ref:`sections <binary-section>`.
diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index 317bf9f6c..961a285cb 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -25,7 +25,7 @@ Value Types
 
 .. note::
    In future versions of WebAssembly, value types may include types denoted by :ref:`type indices <syntax-typeidx>`.
-   Thus, the binary format for types corresponds to the :ref:`encoding <binary-sint>` of small negative :math:`\sN` values, so that they can coexist with (positive) type indices in the future.
+   Thus, the binary format for types corresponds to the |SignedLEB128|_ :ref:`encoding <binary-sint>` of small negative :math:`\sN` values, so that they can coexist with (positive) type indices in the future.
 
 
 .. index:: result type, value type
diff --git a/document/core/binary/values.rst b/document/core/binary/values.rst
index 83dffe710..b8eddd9d6 100644
--- a/document/core/binary/values.rst
+++ b/document/core/binary/values.rst
@@ -140,3 +140,6 @@ The auxiliary |utf8| function expressing this encoding is defined as follows:
       \wedge & c = 2^{18}(b_1-\hex{C0})+2^{12}(b_2-\hex{80})+2^6(b_3-\hex{80})+(b_4-\hex{80})) \\
       \end{array} \\
    \end{array}
+
+.. note::
+   Unlike in some other formats, name strings are not 0-terminated.
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 7a0eadda2..025d80a1b 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -446,6 +446,16 @@ Such a folded instruction can appear anywhere a regular instruction can.
    \end{array}
 
 .. note::
+   For example, the instruction sequence
+
+   .. math::
+      \mathtt{(get\_local~\$x)~(i32.const~2)~i32.add~(i32.const~3)~i32.mul}
+
+   can be folded into
+
+   .. math::
+      \mathtt{(i32.mul~(i32.add~(get\_local~\$x)~(i32.const~2))~(i32.const~3))}
+
    Folded instructions are solely syntactic sugar,
    no additional syntactic or type-based checking is implied.
 

From 67e109e4fbaae11a91f56bfd22f644c96b6ec0ba Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 8 May 2018 09:12:59 +0200
Subject: [PATCH 222/329] [spec] Fix section link

---
 document/core/util/macros.def | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index ea5be82d8..b8dc96b3a 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -474,7 +474,7 @@
 .. |Bversion| mathdef:: \xref{binary/modules}{binary-version}{\B{version}}
 .. |Bmodule| mathdef:: \xref{binary/modules}{binary-module}{\B{module}}
 
-.. |Bsection| mathdef:: \xref{binary/modules}{binary-module}{\B{section}}
+.. |Bsection| mathdef:: \xref{binary/modules}{binary-section}{\B{section}}
 .. |Bcustomsec| mathdef:: \xref{binary/modules}{binary-customsec}{\B{customsec}}
 .. |Btypesec| mathdef:: \xref{binary/modules}{binary-typesec}{\B{typesec}}
 .. |Bfuncsec| mathdef:: \xref{binary/modules}{binary-funcsec}{\B{funcsec}}

From f820395384c308a78e72e19a6a7f4bee01317c33 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Wed, 9 May 2018 09:11:45 -0700
Subject: [PATCH 223/329] [spec] Fix typo: :math: used instead of :ref: (#798)

---
 document/core/valid/modules.rst | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 78e99e77e..7e7ed8795 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -454,16 +454,16 @@ Instead, the context :math:`C` for validation of the module's content is constru
   * :math:`C.\CTYPES` is :math:`\module.\MTYPES`,
 
   * :math:`C.\CFUNCS` is :math:`\etfuncs(\X{it}^\ast)` concatenated with :math:`\X{ft}^\ast`,
-    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :math:`function types <syntax-functype>` :math:`\X{ft}^\ast` as determined below,
+    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :ref:`function types <syntax-functype>` :math:`\X{ft}^\ast` as determined below,
 
   * :math:`C.\CTABLES` is :math:`\ettables(\X{it}^\ast)` concatenated with :math:`\X{tt}^\ast`,
-    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :math:`table types <syntax-tabletype>` :math:`\X{tt}^\ast` as determined below,
+    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :ref:`table types <syntax-tabletype>` :math:`\X{tt}^\ast` as determined below,
 
   * :math:`C.\CMEMS` is :math:`\etmems(\X{it}^\ast)` concatenated with :math:`\X{mt}^\ast`,
-    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :math:`memory types <syntax-memtype>` :math:`\X{mt}^\ast` as determined below,
+    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :ref:`memory types <syntax-memtype>` :math:`\X{mt}^\ast` as determined below,
 
   * :math:`C.\CGLOBALS` is :math:`\etglobals(\X{it}^\ast)` concatenated with :math:`\X{gt}^\ast`,
-    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :math:`global types <syntax-globaltype>` :math:`\X{gt}^\ast` as determined below,
+    with the import's :ref:`external types <syntax-externtype>` :math:`\X{it}^\ast` and the internal :ref:`global types <syntax-globaltype>` :math:`\X{gt}^\ast` as determined below,
 
   * :math:`C.\CLOCALS` is empty,
 

From 214f743d94f1c49901e55daba5af1af9a309caab Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Fri, 6 Apr 2018 01:51:23 +0200
Subject: [PATCH 224/329] [web-api] Changes from review

Addresses some issues in #731
---
 document/web-api/index.bs | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 8d7518125..bc407ecc5 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -44,7 +44,7 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMA-262
         text: ArrayBuffer; url: sec-arraybuffer-objects
 urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: dfn
     text: function index; url: syntax/modules.html#syntax-funcidx
-    text: "name" section; url: appendix/custom.html?highlight=name%20section#binary-namesec
+    text: name section; url: appendix/custom.html?highlight=name%20section#binary-namesec
 urlPrefix: https://webassembly.github.io/spec/js-api/; spec: WASMJS
     type: namespace
         text: WebAssembly; url: #namespacedef-webassembly
@@ -127,6 +127,8 @@ Note: This algorithm accepts a {{Response}} object, or a
 
 <h2 id="conventions">Developer-Facing Display Conventions</h2>
 
+<em>This section is non-normative.</em>
+
 Browsers, JavaScript engines, and offline tools have common ways of referring to
 JavaScript artifacts and language constructs. For example, locations in
 JavaScript source code are printed in stack traces or error messages, and are
@@ -173,17 +175,12 @@ While the "name" property of an [=Exported Function=] instance
 is specified by the [[WASMJS|JS API]], synthesized function names are also
 displayed in other contexts like call stacks in debuggers and string representations
 of stack traces.
-If a WebAssembly module contains a [="name" section=],
+If a WebAssembly module contains a [=name section=],
 these names should be used to synthesize a function name as follows:
-* If a function name subsection is present, the displayed name should
-      be `${module_name}.${function_name}` or `${function_name}`, depending
-      on whether the module name is present.
+* If a function name subsection is present, the displayed name should be `${module_name}.${function_name}` or `${function_name}`, depending on whether the module name is present.
 * Otherwise, the output can be context-dependent:
-  * If the function name is shown alongside its location in a
-    stack trace, then just the module name (if present) or an empty string
-    can be used (because the function index is already in the location).
-  * Otherwise, `${module_name}.wasm-function[${funcIndex}]` or
-    `wasm-function[${funcIndex}]` should be used to convey the function index.
+    * If the function name is shown alongside its location in a stack trace, then just the module name (if present) or an empty string can be used (because the function index is already in the location).
+    * Otherwise, `${module_name}.wasm-function[${funcIndex}]` or `wasm-function[${funcIndex}]` should be used to convey the function index.
 
 Note that this document does not specify the full format of strings such as
 stack frame representations; this allows engines to continue using their

From 45be3f0f1612eb74d2cd803627e96c407c8535f5 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Thu, 10 May 2018 14:50:16 -0700
Subject: [PATCH 225/329] Fix a few typos in module validation (#800)

---
 document/core/valid/modules.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 7e7ed8795..752500e52 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -496,7 +496,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
     the segment :math:`\elem_i` must be :ref:`valid <valid-elem>`.
 
   * For each :math:`\data_i` in :math:`\module.\MDATA`,
-    the segment :math:`\elem_i` must be :ref:`valid <valid-data>`.
+    the segment :math:`\data_i` must be :ref:`valid <valid-data>`.
 
   * If :math:`\module.\MSTART` is non-empty,
     then :math:`\module.\MSTART` must be :ref:`valid <valid-start>`.
@@ -505,7 +505,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
     the segment :math:`\import_i` must be :ref:`valid <valid-import>` with an :ref:`external type <syntax-externtype>` :math:`\X{it}_i`.
 
   * For each :math:`\export_i` in :math:`\module.\MEXPORTS`,
-    the segment :math:`\import_i` must be :ref:`valid <valid-export>` with :ref:`external type <syntax-externtype>` :math:`\X{et}_i`.
+    the segment :math:`\export_i` must be :ref:`valid <valid-export>` with :ref:`external type <syntax-externtype>` :math:`\X{et}_i`.
 
 * The length of :math:`C.\CTABLES` must not be larger than :math:`1`.
 

From 4a36cd4fc02fe479ca1afd05f9f13ea2b7348153 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Sat, 12 May 2018 09:20:12 +0200
Subject: [PATCH 226/329] Fis lonk in README

---
 interpreter/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 65155ff8a..c493c46fb 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -129,7 +129,7 @@ See `wasm -h` for (the few) additional options.
 
 #### JavaScript Library ####
 
-The file `wast.js` generated by the respective (Makefile target)[cross-compiling-the-interpreter-to-javascript] is a self-contained JavaScript library for making the [S-expression syntax](s-expression-syntax) available directly within JavaScript.
+The file `wast.js` generated by the respective [Makefile target](cross-compiling-the-interpreter-to-javascript) is a self-contained JavaScript library for making the [S-expression syntax](s-expression-syntax) available directly within JavaScript.
 It provides a global object named `WebAssemblyText` that currently provides two methods,
 ```
 WebAssemblyText.encode(source)

From 5b3a5bb0a92a7935e621eb7b4452670d4f5f6b1e Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Sat, 12 May 2018 13:02:09 -0700
Subject: [PATCH 227/329] [spec] Fix bug in validation algorithm (#802)

In `pop_ctrl()`, the control stack cannot be popped first since `pop_opds()` calls `pop_opd()` which accesses the top of the stack.
---
 document/core/appendix/algorithm.rst | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst
index d11095afb..4f9c7dabb 100644
--- a/document/core/appendix/algorithm.rst
+++ b/document/core/appendix/algorithm.rst
@@ -104,9 +104,10 @@ The control stack is likewise manipulated through auxiliary functions:
 
    func pop_ctrl() : list(val_type) =
      error_if(ctrls.is_empty())
-     let frame = ctrls.pop()
+     let frame = ctrls[0]
      pop_opds(frame.end_types)
      error_if(opds.size() =/= frame.height)
+     ctrls.pop()
      return frame.end_types
 
    func unreachable() =

From 27d63f22e72395248d314520b3ad5b1e0943fc10 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Wed, 16 May 2018 09:54:54 -0700
Subject: [PATCH 228/329] Remove invalid math section (#805)

Seemed to be duplicated from the math section above it, but never rendered because it is invalid.
---
 document/core/text/modules.rst | 24 ------------------------
 1 file changed, 24 deletions(-)

diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst
index d6bfbb399..feb3dba32 100644
--- a/document/core/text/modules.rst
+++ b/document/core/text/modules.rst
@@ -644,30 +644,6 @@ The definition of the initial :ref:`identifier context <text-context>` :math:`I`
    \end{array}
 
 
-.. math
-   \F{idc}(\epsilon) &=&
-     \{\} \\
-   \F{idc}(\Tmodulebody~\Tmodulefield) &=&
-     \F{idc}(\Tmodulebody) \compose \F{idc}(\Tmodulefield) \\[1ex]
-
-   The definition of the :ref:`identifier context <text-context>` :math:`I` uses the following auxiliary function to extract optional identifiers from definitions and imports in an order-preserving fashion:
-
-   \begin{array}{@{}l@{}}
-   \begin{array}{@{}lcl@{\qquad\qquad}l}
-   \F{id}(\text{(}~\text{type}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\
-   \F{id}(\text{(}~\text{func}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\
-   \F{id}(\text{(}~\text{table}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\
-   \F{id}(\text{(}~\text{memory}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\
-   \F{id}(\text{(}~\text{global}~\Tid^?~\dots~\text{)}) &=& \Tid^? \\[1ex]
-   \F{funcids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{func}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\
-   \F{tableids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{table}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\
-   \F{memids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{memory}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\
-   \F{globalids}(\Timport^\ast) &=& [\Tid^? ~|~ \text{(}~\text{global}~\Tid^?~\dots~\text{)} \in \F{desc}(\Timport)^\ast] \\
-   \end{array} \\
-   \F{desc}(\text{(}~\text{import}~\dots~\Timportdesc~\text{)}) \quad=\quad \Timportdesc
-   \end{array}
-
-
 Abbreviations
 .............
 

From 5a918f777e72c686cbad5e04074d565584670870 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Tue, 22 May 2018 12:49:10 +0200
Subject: [PATCH 229/329] [spec] Fix result type brackets in index (#803)

---
 document/core/appendix/index-types.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/appendix/index-types.rst b/document/core/appendix/index-types.rst
index 972ae6b49..5b8197831 100644
--- a/document/core/appendix/index-types.rst
+++ b/document/core/appendix/index-types.rst
@@ -17,7 +17,7 @@ Category                                  Constructor
 (reserved)                                                                             :math:`\hex{6F}` .. :math:`\hex{61}`
 :ref:`Function type <syntax-functype>`    :math:`[\valtype^\ast] \to [\valtype^\ast]`  :math:`\hex{60}` (-32 as |Bs7|)
 (reserved)                                                                             :math:`\hex{5F}` .. :math:`\hex{41}`
-:ref:`Result type <syntax-resulttype>`    :math:`\epsilon`                             :math:`\hex{40}` (-64 as |Bs7|)
+:ref:`Result type <syntax-resulttype>`    :math:`[\epsilon]`                           :math:`\hex{40}` (-64 as |Bs7|)
 :ref:`Table type <syntax-tabletype>`      :math:`\limits~\elemtype`                    (none)
 :ref:`Memory type <syntax-memtype>`       :math:`\limits`                              (none)
 :ref:`Global type <syntax-globaltype>`    :math:`\mut~\valtype`                        (none)

From f273957e1c70965f3097fe806934e163c3bafb93 Mon Sep 17 00:00:00 2001
From: Paul D <36397285+poemm@users.noreply.github.com>
Date: Wed, 30 May 2018 02:40:49 -0500
Subject: [PATCH 230/329] [spec] Fix some typos (#811)

---
 document/core/appendix/embedding.rst | 10 +++++-----
 document/core/binary/values.rst      |  4 ++--
 document/core/exec/conventions.rst   |  2 +-
 document/core/exec/instructions.rst  |  8 ++++----
 document/core/exec/modules.rst       |  6 +++---
 document/core/syntax/conventions.rst |  2 +-
 document/core/valid/instructions.rst |  4 ++--
 7 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst
index 15832df3c..48b601b2a 100644
--- a/document/core/appendix/embedding.rst
+++ b/document/core/appendix/embedding.rst
@@ -173,7 +173,7 @@ Modules
 
 2. Let :math:`\export^\ast` be the :ref:`exports <syntax-export>` :math:`\module.\MEXPORTS`.
 
-3. Assert: the length of :math:`\export^\ast` equals the length of :math:`\externtype^\ast`.
+3. Assert: the length of :math:`\export^\ast` equals the length of :math:`{\externtype'}^\ast`.
 
 4. For each :math:`\export_i` in :math:`\export^\ast` and corresponding :math:`\externtype'_i` in :math:`{\externtype'}^\ast`, do:
 
@@ -335,7 +335,7 @@ Tables
 
 3. Let :math:`\X{ti}` be the :ref:`table instance <syntax-tableinst>` :math:`\store.\STABLES[\tableaddr]`.
 
-4. If :math:`i` is larger than or equal to the length if :math:`\X{ti}.\TIELEM`, then return :math:`\ERROR`.
+4. If :math:`i` is larger than or equal to the length of :math:`\X{ti}.\TIELEM`, then return :math:`\ERROR`.
 
 5. Else, return :math:`\X{ti}.\TIELEM[i]`.
 
@@ -357,7 +357,7 @@ Tables
 
 3. Let :math:`\X{ti}` be the :ref:`table instance <syntax-tableinst>` :math:`\store.\STABLES[\tableaddr]`.
 
-4. If :math:`i` is larger than or equal to the length if :math:`\X{ti}.\TIELEM`, then return :math:`\ERROR`.
+4. If :math:`i` is larger than or equal to the length of :math:`\X{ti}.\TIELEM`, then return :math:`\ERROR`.
 
 5. Replace :math:`\X{ti}.\TIELEM[i]` with the optional :ref:`function address <syntax-funcaddr>` :math:`\X{fa}^?`.
 
@@ -461,7 +461,7 @@ Memories
 
 3. Let :math:`\X{mi}` be the :ref:`memory instance <syntax-meminst>` :math:`\store.\SMEMS[\memaddr]`.
 
-4. If :math:`i` is larger than or equal to the length if :math:`\X{mi}.\MIDATA`, then return :math:`\ERROR`.
+4. If :math:`i` is larger than or equal to the length of :math:`\X{mi}.\MIDATA`, then return :math:`\ERROR`.
 
 5. Else, return the  :ref:`byte <syntax-byte>` :math:`\X{mi}.\MIDATA[i]`.
 
@@ -483,7 +483,7 @@ Memories
 
 3. Let :math:`\X{mi}` be the :ref:`memory instance <syntax-meminst>` :math:`\store.\SMEMS[\memaddr]`.
 
-4. If :math:`i` is larger than or equal to the length if :math:`\X{mi}.\MIDATA`, then return :math:`\ERROR`.
+4. If :math:`i` is larger than or equal to the length of :math:`\X{mi}.\MIDATA`, then return :math:`\ERROR`.
 
 5. Replace :math:`\X{mi}.\MIDATA[i]` with :math:`\byte`.
 
diff --git a/document/core/binary/values.rst b/document/core/binary/values.rst
index b8eddd9d6..88065b8bb 100644
--- a/document/core/binary/values.rst
+++ b/document/core/binary/values.rst
@@ -132,12 +132,12 @@ The auxiliary |utf8| function expressing this encoding is defined as follows:
    \utf8(c) &=& b_1~b_2~b_3 &
      (\begin{array}[t]{@{}c@{~}l@{}}
       \iff & \unicode{800} \leq c < \unicode{10000} \\
-      \wedge & c = 2^{12}(b_1-\hex{C0})+2^6(b_2-\hex{80})+(b_3-\hex{80})) \\
+      \wedge & c = 2^{12}(b_1-\hex{E0})+2^6(b_2-\hex{80})+(b_3-\hex{80})) \\
       \end{array} \\
    \utf8(c) &=& b_1~b_2~b_3~b_4 &
      (\begin{array}[t]{@{}c@{~}l@{}}
       \iff & \unicode{10000} \leq c < \unicode{110000} \\
-      \wedge & c = 2^{18}(b_1-\hex{C0})+2^{12}(b_2-\hex{80})+2^6(b_3-\hex{80})+(b_4-\hex{80})) \\
+      \wedge & c = 2^{18}(b_1-\hex{F0})+2^{12}(b_2-\hex{80})+2^6(b_3-\hex{80})+(b_4-\hex{80})) \\
       \end{array} \\
    \end{array}
 
diff --git a/document/core/exec/conventions.rst b/document/core/exec/conventions.rst
index edddbea9f..807239b04 100644
--- a/document/core/exec/conventions.rst
+++ b/document/core/exec/conventions.rst
@@ -38,7 +38,7 @@ The following conventions are adopted in stating these rules.
 * Certain rules require the stack to contain at least one frame.
   The most recent frame is referred to as the *current* frame.
 
-* Both the store and the current frame are mutated by *replacing* some of its components.
+* Both the store and the current frame are mutated by *replacing* some of their components.
   Such replacement is assumed to apply globally.
 
 * The execution of an instruction may *trap*,
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 3672e42d8..326c8f18b 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -70,7 +70,7 @@ Where the underlying operators are non-deterministic, because they may return on
    (t\K{.}\CONST~c_1)~t\K{.}\unop &\stepto& (t\K{.}\CONST~c)
      & (\iff c \in \unop_t(c_1)) \\
    (t\K{.}\CONST~c_1)~t\K{.}\unop &\stepto& \TRAP
-     & (\iff \unop_{t_1,t_2}(c_1) = \{\})
+     & (\iff \unop_{t}(c_1) = \{\})
    \end{array}
 
 
@@ -100,7 +100,7 @@ Where the underlying operators are non-deterministic, because they may return on
    (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\binop &\stepto& (t\K{.}\CONST~c)
      & (\iff c \in \binop_t(c_1,c_2)) \\
    (t\K{.}\CONST~c_1)~(t\K{.}\CONST~c_2)~t\K{.}\binop &\stepto& \TRAP
-     & (\iff \binop_{t_1,t_2}(c_1) = \{\})
+     & (\iff \binop_{t}(c_1,c2) = \{\})
    \end{array}
 
 
@@ -167,9 +167,9 @@ Where the underlying operators are non-deterministic, because they may return on
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   (t\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& (t_2\K{.}\CONST~c_2)
+   (t_1\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& (t_2\K{.}\CONST~c_2)
      & (\iff c_2 \in \cvtop_{t_1,t_2}(c_1)) \\
-   (t\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& \TRAP
+   (t_1\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& \TRAP
      & (\iff \cvtop_{t_1,t_2}(c_1) = \{\})
    \end{array}
 
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index bc772ddcc..20d1d48a3 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -276,7 +276,7 @@ New instances of :ref:`functions <syntax-funcinst>`, :ref:`tables <syntax-tablei
    \mbox{where:} \hfill \\
    \funcaddr &=& |S.\SFUNCS| \\
    \funcinst &=& \{ \FITYPE~\functype, \FIHOSTCODE~\hostfunc \} \\
-   S' &=& S \compose \{\SFUNCS~\tableinst\} \\
+   S' &=& S \compose \{\SFUNCS~\funcinst\} \\
    \end{array}
 
 .. note::
@@ -772,6 +772,6 @@ The values :math:`\val_{\F{res}}^m` are returned as the results of the invocatio
    \begin{array}{@{}lcl}
    \invoke(S, \funcaddr, \val^n) &=& S; F; \val^n~(\INVOKE~\funcaddr) \\
      &(\iff & S.\SFUNCS[\funcaddr].\FITYPE = [t_1^n] \to [t_2^m] \\
-     &\wedge& \val^n = (t_1.\CONST~c)^n) \\
-     &\wedge& F = \{ \AMODULE~\{\}, \ALOCALS~\epsilon \} \\
+     &\wedge& \val^n = (t_1.\CONST~c)^n \\
+     &\wedge& F = \{ \AMODULE~\{\}, \ALOCALS~\epsilon \}) \\
    \end{array}
diff --git a/document/core/syntax/conventions.rst b/document/core/syntax/conventions.rst
index 995f131f4..c0890ba98 100644
--- a/document/core/syntax/conventions.rst
+++ b/document/core/syntax/conventions.rst
@@ -66,7 +66,7 @@ When dealing with syntactic constructs the following notation is also used:
 * :math:`s[i \slice n]` denotes the sub-sequence :math:`s[i]~\dots~s[i+n-1]` of a sequence :math:`s`.
 
 * :math:`s \with [i] = A` denotes the same sequence as :math:`s`,
-  except that the :math:`i`-the element is replaced with :math:`A`.
+  except that the :math:`i`-th element is replaced with :math:`A`.
 
 * :math:`s \with [i \slice n] = A^n` denotes the same sequence as :math:`s`,
   except that the sub-sequence :math:`s[i \slice n]` is replaced with :math:`A^n`.
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index dfb14ea89..1062f9386 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -14,7 +14,7 @@ and the provided output stack with result values of types :math:`t_2^\ast` that
    consuming two |I32| values and producing one.
 
 Typing extends to :ref:`instruction sequences <valid-instr-seq>` :math:`\instr^\ast`.
-Such a sequence has a :ref:`function types <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]` if the accumulative effect of executing the instructions is consuming values of types :math:`t_1^\ast` off the operand stack and pushing new values of types :math:`t_2^\ast`.
+Such a sequence has a :ref:`function type <syntax-functype>` :math:`[t_1^\ast] \to [t_2^\ast]` if the accumulative effect of executing the instructions is consuming values of types :math:`t_1^\ast` off the operand stack and pushing new values of types :math:`t_2^\ast`.
 
 .. _polymorphism:
 
@@ -605,7 +605,7 @@ Control Instructions
   the label :math:`C.\CLABELS[l_i]` must be defined in the context.
 
 * For all :math:`l_i` in :math:`l^\ast`,
-  :math:`C.\CLABELS[l_i]` must be :math:`t^?`.
+  :math:`C.\CLABELS[l_i]` must be :math:`[t^?]`.
 
 * Then the instruction is valid with type :math:`[t_1^\ast~t^?~\I32] \to [t_2^\ast]`, for any sequences of :ref:`value types <syntax-valtype>` :math:`t_1^\ast` and :math:`t_2^\ast`.
 

From ca5ec413e0b8305c73ce5b8eed848e95d389a309 Mon Sep 17 00:00:00 2001
From: Conrad Watt <caw77@cam.ac.uk>
Date: Mon, 4 Jun 2018 18:47:08 +0800
Subject: [PATCH 231/329] [spec] Fix typo in module instantiation (#813)

---
 document/core/valid/modules.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 752500e52..816259026 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -471,7 +471,7 @@ Instead, the context :math:`C` for validation of the module's content is constru
 
   * :math:`C.\CRETURN` is empty.
 
-* Let :math:`C'` be the :ref:`context <context>` where :math:`C'.\CGLOBALS` is the sequence :math:`\etglobals(\externtype_i^\ast)` and all other fields are empty.
+* Let :math:`C'` be the :ref:`context <context>` where :math:`C'.\CGLOBALS` is the sequence :math:`\etglobals(\X{it}^\ast)` and all other fields are empty.
 
 * Under the context :math:`C`:
 

From d8f775eed3645e689580610d101106cd1404b637 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Wed, 6 Jun 2018 14:31:33 -0700
Subject: [PATCH 232/329] Merge mutable global proposal into spec (#814)

See the mutable-globals proposal repo here:

https://github.com/WebAssembly/mutable-global
---
 document/core/syntax/modules.rst    |   5 -
 document/core/valid/modules.rst     |  14 +-
 document/js-api/index.bs            | 115 +++++++++++-
 interpreter/script/js.ml            |   3 +-
 interpreter/valid/valid.ml          |   8 +-
 test/core/globals.wast              |  22 +--
 test/core/linking.wast              |  33 ++++
 test/harness/wasm-module-builder.js |   4 +-
 test/js-api/jsapi.js                | 279 ++++++++++++++++++++++++++++
 9 files changed, 429 insertions(+), 54 deletions(-)

diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst
index 9f4acbc82..779eb21cf 100644
--- a/document/core/syntax/modules.rst
+++ b/document/core/syntax/modules.rst
@@ -311,9 +311,6 @@ Each export is labeled by a unique :ref:`name <syntax-name>`.
 Exportable definitions are :ref:`functions <syntax-func>`, :ref:`tables <syntax-table>`, :ref:`memories <syntax-mem>`, and :ref:`globals <syntax-global>`,
 which are referenced through a respective descriptor.
 
-.. note::
-   In the current version of WebAssembly, only *immutable* globals may be exported.
-
 
 Conventions
 ...........
@@ -362,8 +359,6 @@ Every import defines an index in the respective :ref:`index space <syntax-index>
 In each index space, the indices of imports go before the first index of any definition contained in the module itself.
 
 .. note::
-   In the current version of WebAssembly, only *immutable* globals may be imported.
-
    Unlike export names, import names are not necessarily unique.
    It is possible to import the same |IMODULE|/|INAME| pair multiple times;
    such imports may even have different type descriptions, including different kinds of entities.
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 816259026..1a6aa84d8 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -321,17 +321,13 @@ Exports :math:`\export` and export descriptions :math:`\exportdesc` are classifi
 
 * The global :math:`C.\CGLOBALS[x]` must be defined in the context.
 
-* Let :math:`\mut~t` be the :ref:`global type <syntax-globaltype>` :math:`C.\CGLOBALS[x]`.
-
-* The mutability :math:`\mut` must be |MCONST|.
-
 * Then the export description is valid with :ref:`external type <syntax-externtype>` :math:`\ETGLOBAL~C.\CGLOBALS[x]`.
 
 .. math::
    \frac{
-     C.\CGLOBALS[x] = \MCONST~t
+     C.\CGLOBALS[x] = \globaltype
    }{
-     C \vdashexportdesc \EDGLOBAL~x : \ETGLOBAL~(\MCONST~t)
+     C \vdashexportdesc \EDGLOBAL~x : \ETGLOBAL~\globaltype
    }
 
 .. note::
@@ -417,15 +413,13 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
 
 * The global type :math:`\globaltype` must be :ref:`valid <valid-globaltype>`.
 
-* The mutability of :math:`\globaltype` must be |MCONST|.
-
 * Then the import description is valid with type :math:`\ETGLOBAL~\globaltype`.
 
 .. math::
    \frac{
-     \vdashglobaltype \MCONST~t \ok
+     \vdashglobaltype \globaltype \ok
    }{
-     C \vdashimportdesc \IDGLOBAL~\MCONST~t : \ETGLOBAL~\MCONST~t
+     C \vdashimportdesc \IDGLOBAL~\globaltype : \ETGLOBAL~\globaltype
    }
 
 .. note::
diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index e4abb65aa..0c82236a1 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -132,6 +132,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
     text: table address; url: exec/runtime.html#syntax-tableaddr
     text: function address; url: exec/runtime.html#syntax-funcaddr
     text: memory address; url: exec/runtime.html#syntax-memaddr
+    text: global address; url: exec/runtime.html#syntax-globaladdr
     url: syntax/types.html#syntax-valtype
         text: 𝗂𝟥𝟤
         text: 𝗂𝟨𝟦
@@ -153,6 +154,9 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
         text: 𝗆𝖾𝗆
         text: 𝗀𝗅𝗈𝖻𝖺𝗅
     text: global type; url: syntax/types.html#syntax-globaltype
+    url: syntax/types.html#syntax-mut
+        text: var
+        text: const
     text: address; url: exec/runtime.html#addresses
     text: signed_32; url: exec/numerics.html#aux-signed
     text: grow_memory; url: exec/instructions.html#exec-grow-memory
@@ -225,6 +229,7 @@ Each [=agent=] is associated with the following [=ordered map=]s:
     * The <dfn>Memory object cache</dfn>, mapping [=memory address=]es to {{Memory}} objects.
     * The <dfn>Table object cache</dfn>, mapping [=table address=]es to {{Table}} objects.
     * The <dfn>Exported Function cache</dfn>, mapping [=function address=]es to [=Exported Function=] objects.
+    * The <dfn>Global object cache</dfn>, mapping [=global address=]es to {{Global}} objects.
 
 <h2 id="webassembly-namespace">The WebAssembly Namespace</h2>
 
@@ -326,13 +331,17 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
                 1. Let |index| be the number of external functions in |imports|. This value |index| is known as the <dfn>index of the host function</dfn> |funcaddr|.
             1. Let |externfunc| be the [=external value=] [=external value|𝖿𝗎𝗇𝖼=] |funcaddr|.
             1. [=Append=] |externfunc| to |imports|.
-        1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] |globaltype|,
-            1. If |globaltype| is [=𝗂𝟨𝟦=] or [=Type=](|v|) is not [=Number=], throw a {{LinkError}} exception.
-            1. Let |value| be [=ToWebAssemblyValue=](|v|, |globaltype|.<em>[=global type|valtype=]</em>)
-            1. Assert: |globaltype|.<em>[=global type|mut=]</em> is [=global type|𝖼𝗈𝗇𝗌𝗍=], as verified by WebAssembly validation.
-            1. Let |store| be the [=surrounding agent=]'s [=associated store=].
-            1. Let (|store|, |globaladdr|) be [=alloc_global=](|store|, |globaltype|, |value|).
-            1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
+        1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] |mut| |valtype|,
+            1. If [=Type=](|v|) is [=Number=],
+                1. If |valtype| is [=𝗂𝟨𝟦=], throw a {{LinkError}} exception.
+                1. Let |value| be [=ToWebAssemblyValue=](|v|, |valtype|)
+                1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+                1. Let (|store|, |globaladdr|) be [=alloc_global=](|store|, [=const=] |valtype|, |value|).
+                1. Set the [[surrounding agent=]'s [=associated store=] to |store|.
+            1. If |v| is a {{Global}} instance,
+                1. Let |globaladdr| be |v|.\[[Global]]
+            1. Otherwise,
+                1. Throw a {{LinkError}} exception.
             1. Let |externglobal| be [=external value|𝗀𝗅𝗈𝖻𝖺𝗅=] |globaladdr|.
             1. [=Append=] |externglobal| to |imports|.
         1. If |externtype| is of the form [=𝗆𝖾𝗆=] |memtype|,
@@ -365,11 +374,10 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
             1. Let |func| be the result of creating [=a new Exported Function=] from |funcaddr|.
             1. Let |value| be |func|.
         1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] |globaltype|,
-            1. If |globaltype|.<em>[=global type|valtype=]</em> is [=𝗂𝟨𝟦=], throw a {{LinkError}} exception.
-            1. Assert: |globaltype|.<em>[=global type|mut=]</em> is [=global type|𝖼𝗈𝗇𝗌𝗍=], as verified by WebAssembly validation.
             1. Assert: |externval| is of the form [=external value|𝗀𝗅𝗈𝖻𝖺𝗅=] |globaladdr|.
             1. Let [=external value|𝗀𝗅𝗈𝖻𝖺𝗅=] |globaladdr| be |externval|.
-            1. Let |value| be [=ToJSValue=]([=read_global=](|store|, |globaladdr|)).
+            1. Let |global| be [=create a global object|a new Global object=] created from |globaladdr|.
+            1. Let |value| be |global|.
         1. If |externtype| is of the form [=𝗆𝖾𝗆=] |memtype|,
             1. Assert: |externval| is of the form [=external value|𝗆𝖾𝗆=] |memaddr|.
             1. Let [=external value|𝗆𝖾𝗆=] |memaddr| be |externval|.
@@ -704,6 +712,93 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Return undefined.
 </div>
 
+<h3 id="globals">Globals</h3>
+
+<pre class="idl">
+dictionary GlobalDescriptor {
+  required USVString value;
+  boolean mutable = false;
+};
+
+[LegacyNamespace=WebAssembly, Constructor(GlobalDescriptor descriptor, unrestricted double value = 0), Exposed=(Window,Worker,Worklet)]
+interface Global {
+  unrestricted double valueOf();
+  attribute unrestricted double value;
+};
+</pre>
+
+<div>
+A {{Global}} object represents a single [=global instance=]
+which can be simultaneously referenced by multiple {{Instance}} objects. Each
+{{Global}} object has one internal slot:
+
+    * \[[Global]] : a [=global address=]
+</div>
+
+<div algorithm>
+    To <dfn>create a global object</dfn> from a [=global address=] |globaladdr|, perform the following steps:
+    1. Let |map| be the current [=agent=]'s associated [=Global object cache=].
+    1. If |map|[|globaladdr|] [=map/exists=],
+        1. Return |map|[|globaladdr|].
+    1. Let |global| be a new {{Global}} instance with \[[Global]] set to |globaladdr|.
+    1. [=map/Set=] |map|[|globaladdr|] to |global|.
+    1. Return |global|.
+</div>
+
+<div algorithm>
+    The algorithm <dfn>ToValueType</dfn>(|s|) performs the following steps:
+    1. If |s| equals "i32", return [=𝗂𝟥𝟤=].
+    1. If |s| equals "f32", return [=𝖿𝟥𝟤=].
+    1. If |s| equals "f64", return [=𝖿𝟨𝟦=].
+    1. Otherwise, throw a {{TypeError}} exception.
+</div>
+
+<div algorithm>
+    The <dfn constructor for="Global">Global(descriptor, v)</dfn> constructor, when invoked, performs the following steps:
+    1. Let |mutable| be |descriptor|["mutable"].
+    1. Let |valuetype| be [=ToValueType=](|descriptor|["value"]).
+    1. Let |value| be [=ToWebAssemblyValue=](|v|, |valuetype|).
+    1. If |mutable| is true, let |globaltype| be [=var=] |valuetype|; otherwise, let |globaltype| be [=const=] |valuetype|.
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let (|store|, |globaladdr|) be [=alloc_global=](|store|, |globaltype|, |value|). <!-- TODO(littledan): Report allocation failure https://github.com/WebAssembly/spec/issues/584 -->
+    1. Set the current agent's [=associated store=] to |store|.
+    1. [=Create a global object=] from the global address |globaladdr| and return the result.
+</div>
+
+<div algorithm>
+    The algorithm <dfn>GetGlobalValue</dfn>({{Global}} |global|) performs the following steps:
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let |globaladdr| be |global|.\[[Global]].
+    1. Let |globaltype| be [=type_global=](|store|, |globaladdr|).
+    1. If |globaltype| is of the form |mut| [=𝗂𝟨𝟦=], throw a {{TypeError}}.
+    1. Let |value| be [=read_global=](|store|, |globaladdr|).
+    1. Return [=ToJSValue=](|value|).
+</div>
+
+<div algorithm>
+    The getter of the <dfn attribute for="Global">value</dfn> attribute of {{Global}}, when invoked, performs the following steps:
+    1. Let |global| be the {{Global}} instance.
+    1. Return [=GetGlobalValue=](|global|).
+
+    The setter of the value attribute of {{Global}}, when invoked with a value |v|, performs the following steps:
+    1. Let |global| be the {{Global}} instance.
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let |globaladdr| be |global|.\[[Global]].
+    1. Let |globaltype| be [=type_global=](|store|, |globaladdr|), where |globaltype| is of the form |mut| |valuetype|.
+    1. If |mut| is [=const=], throw a {{TypeError}.
+    1. If |valuetype| is [=𝗂𝟨𝟦=], throw a {{TypeError}}.
+    1. Let |value| be [=ToWebAssemblyValue=](|v|, |valuetype|).
+    1. Let |store| be [=write_global=](|store|, |globaladdr|, |value|).
+    1. If |store| is [=error=], throw a {{RangeError}} exception.
+    1. Set the current agent's [=associated store=] to |store|.
+</div>
+
+<div algorithm>
+    The <dfn method for="Global">valueOf()</dfn> method, when invoked, performs the following steps:
+    1. Let |global| be the {{Global}} instance.
+    1. Return [=GetGlobalValue=](|global|).
+</div>
+
 <h3 id="exported-function-exotic-objects">Exported Functions</h3>
 
 A WebAssembly function is made available in JavaScript as an <dfn>Exported Function</dfn>.
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 3165756b4..088751e47 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -61,7 +61,8 @@ let harness =
   "}\n" ^
   "\n" ^
   "function get(instance, name) {\n" ^
-  "  return instance.exports[name];\n" ^
+  "  let v = instance.exports[name];\n" ^
+  "  return (v instanceof WebAssembly.Global) ? v.value : v;\n" ^
   "}\n" ^
   "\n" ^
   "function exports(name, instance) {\n" ^
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index d3d8a4155..0d1c4d8e2 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -428,9 +428,6 @@ let check_import (im : import) (c : context) : context =
     {c with memories = mt :: c.memories}
   | GlobalImport gt ->
     check_global_type gt idesc.at;
-    let GlobalType (_, mut) = gt in
-    require (mut = Immutable) idesc.at
-      "mutable globals cannot be imported (yet)";
     {c with globals = gt :: c.globals}
 
 module NameSet = Set.Make(struct type t = Ast.name let compare = compare end)
@@ -441,10 +438,7 @@ let check_export (c : context) (set : NameSet.t) (ex : export) : NameSet.t =
   | FuncExport x -> ignore (func c x)
   | TableExport x -> ignore (table c x)
   | MemoryExport x -> ignore (memory c x)
-  | GlobalExport x ->
-    let GlobalType (_, mut) = global c x in
-    require (mut = Immutable) edesc.at
-      "mutable globals cannot be exported (yet)"
+  | GlobalExport x -> ignore (global c x)
   );
   require (not (NameSet.mem name set)) ex.at "duplicate export name";
   NameSet.add name set
diff --git a/test/core/globals.wast b/test/core/globals.wast
index c4edfed3e..175af3679 100644
--- a/test/core/globals.wast
+++ b/test/core/globals.wast
@@ -51,25 +51,9 @@
   "global is immutable"
 )
 
-(assert_invalid
-  (module (import "m" "a" (global (mut i32))))
-  "mutable globals cannot be imported"
-)
-
-(assert_invalid
-  (module (global (import "m" "a") (mut i32)))
-  "mutable globals cannot be imported"
-)
-
-(assert_invalid
-  (module (global (mut f32) (f32.const 0)) (export "a" (global 0)))
-  "mutable globals cannot be exported"
-)
-
-(assert_invalid
-  (module (global (export "a") (mut f32) (f32.const 0)))
-  "mutable globals cannot be exported"
-)
+;; mutable globals can be exported
+(module (global (mut f32) (f32.const 0)) (export "a" (global 0)))
+(module (global (export "a") (mut f32) (f32.const 0)))
 
 (assert_invalid
   (module (global f32 (f32.neg (f32.const 0))))
diff --git a/test/core/linking.wast b/test/core/linking.wast
index e75c9ec89..e2fc8b8f2 100644
--- a/test/core/linking.wast
+++ b/test/core/linking.wast
@@ -39,16 +39,29 @@
 (module $Mg
   (global $glob (export "glob") i32 (i32.const 42))
   (func (export "get") (result i32) (get_global $glob))
+
+  ;; export mutable globals
+  (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142))
+  (func (export "get_mut") (result i32) (get_global $mut_glob))
+  (func (export "set_mut") (param i32) (set_global $mut_glob (get_local 0)))
 )
 (register "Mg" $Mg)
 
 (module $Ng
   (global $x (import "Mg" "glob") i32)
+  (global $mut_glob (import "Mg" "mut_glob") (mut i32))
   (func $f (import "Mg" "get") (result i32))
+  (func $get_mut (import "Mg" "get_mut") (result i32))
+  (func $set_mut (import "Mg" "set_mut") (param i32))
+
   (export "Mg.glob" (global $x))
   (export "Mg.get" (func $f))
   (global $glob (export "glob") i32 (i32.const 43))
   (func (export "get") (result i32) (get_global $glob))
+
+  (export "Mg.mut_glob" (global $mut_glob))
+  (export "Mg.get_mut" (func $get_mut))
+  (export "Mg.set_mut" (func $set_mut))
 )
 
 (assert_return (get $Mg "glob") (i32.const 42))
@@ -58,6 +71,26 @@
 (assert_return (invoke $Ng "Mg.get") (i32.const 42))
 (assert_return (invoke $Ng "get") (i32.const 43))
 
+(assert_return (get $Mg "mut_glob") (i32.const 142))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 142))
+(assert_return (invoke $Mg "get_mut") (i32.const 142))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 142))
+
+(assert_return (invoke $Mg "set_mut" (i32.const 241)))
+(assert_return (get $Mg "mut_glob") (i32.const 241))
+(assert_return (get $Ng "Mg.mut_glob") (i32.const 241))
+(assert_return (invoke $Mg "get_mut") (i32.const 241))
+(assert_return (invoke $Ng "Mg.get_mut") (i32.const 241))
+
+
+(assert_unlinkable
+  (module (import "Mg" "mut_glob" (global i32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (import "Mg" "glob" (global (mut i32))))
+  "incompatible import type"
+)
 
 ;; Tables
 
diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index a47611d8f..1076ec9e7 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -225,9 +225,9 @@ class WasmModuleBuilder {
     return this.num_imported_funcs++;
   }
 
-  addImportedGlobal(module = "", name, type) {
+  addImportedGlobal(module = "", name, type, mutable = false) {
     let o = {module: module, name: name, kind: kExternalGlobal, type: type,
-             mutable: false}
+             mutable: mutable}
     this.imports.push(o);
     return this.num_imported_globals++;
   }
diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 4e1a9e932..4469ed135 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -113,6 +113,16 @@ let mem1;
 let Table;
 let tbl1;
 let tableProto;
+let Global;
+let globalProto;
+let globalI32;
+let globalI64;
+let globalF32;
+let globalF64;
+let globalI32Mut;
+let globalI64Mut;
+let globalF32Mut;
+let globalF64Mut;
 
 let emptyModule;
 let exportingModule;
@@ -661,6 +671,275 @@ test(() => {
     assertThrows(() => tbl.grow(1), Error);
 }, "'WebAssembly.Table.prototype.grow' method");
 
+test(() => {
+    const globalDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Global');
+    assert_equals(typeof globalDesc.value, "function");
+    assert_equals(globalDesc.writable, true);
+    assert_equals(globalDesc.enumerable, false);
+    assert_equals(globalDesc.configurable, true);
+    Global = WebAssembly.Global;
+}, "'WebAssembly.Global' data property");
+
+test(() => {
+    const globalDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Global');
+    assert_equals(Global, globalDesc.value);
+    assert_equals(Global.length, 1);
+    assert_equals(Global.name, "Global");
+    assertThrows(() => Global(), TypeError);
+    assertThrows(() => new Global(1), TypeError);
+    assertThrows(() => new Global({}), TypeError);
+    assertThrows(() => new Global({value: 'foo'}), TypeError);
+    assertThrows(() => new Global({value: 'i64'}), TypeError);
+    assert_equals(new Global({value:'i32'}) instanceof Global, true);
+    assert_equals(new Global({value:'f32'}) instanceof Global, true);
+    assert_equals(new Global({value:'f64'}) instanceof Global, true);
+    assert_equals(new Global({value:'i32', mutable: false}) instanceof Global, true);
+    assert_equals(new Global({value:'f64', mutable: false}) instanceof Global, true);
+    assert_equals(new Global({value:'f64', mutable: false}) instanceof Global, true);
+    assert_equals(new Global({value:'i32', mutable: true}) instanceof Global, true);
+    assert_equals(new Global({value:'f64', mutable: true}) instanceof Global, true);
+    assert_equals(new Global({value:'f64', mutable: true}) instanceof Global, true);
+    assert_equals(new Global({value:'i32'}, 0x132) instanceof Global, true);
+    assert_equals(new Global({value:'f32'}, 0xf32) instanceof Global, true);
+    assert_equals(new Global({value:'f64'}, 0xf64) instanceof Global, true);
+    assert_equals(new Global({value:'i32', mutable: false}, 0x132) instanceof Global, true);
+    assert_equals(new Global({value:'f32', mutable: false}, 0xf32) instanceof Global, true);
+    assert_equals(new Global({value:'f64', mutable: false}, 0xf64) instanceof Global, true);
+    assert_equals(new Global({value:'i32', mutable: true}, 0x132) instanceof Global, true);
+    assert_equals(new Global({value:'f32', mutable: true}, 0xf32) instanceof Global, true);
+    assert_equals(new Global({value:'f64', mutable: true}, 0xf64) instanceof Global, true);
+}, "'WebAssembly.Global' constructor function");
+
+test(() => {
+    const globalProtoDesc = Object.getOwnPropertyDescriptor(Global, 'prototype');
+    assert_equals(typeof globalProtoDesc.value, "object");
+    assert_equals(globalProtoDesc.writable, false);
+    assert_equals(globalProtoDesc.enumerable, false);
+    assert_equals(globalProtoDesc.configurable, false);
+}, "'WebAssembly.Global.prototype' data property");
+
+test(() => {
+    const globalProtoDesc = Object.getOwnPropertyDescriptor(Global, 'prototype');
+    globalProto = Global.prototype;
+    assert_equals(globalProto, globalProtoDesc.value);
+    assert_equals(String(globalProto), "[object WebAssembly.Global]");
+    assert_equals(Object.getPrototypeOf(globalProto), Object.prototype);
+}, "'WebAssembly.Global.prototype' object");
+
+test(() => {
+    globalI32 = new Global({value: 'i32'}, 0x132);
+    globalF32 = new Global({value: 'f32'}, 0xf32);
+    globalF64 = new Global({value: 'f64'}, 0xf64);
+    globalI32Mut = new Global({value: 'i32', mutable: true}, 0x132);
+    globalF32Mut = new Global({value: 'f32', mutable: true}, 0xf32);
+    globalF64Mut = new Global({value: 'f64', mutable: true}, 0xf64);
+    assert_equals(typeof globalI32, "object");
+    assert_equals(String(globalI32), "[object WebAssembly.Global]");
+    assert_equals(Object.getPrototypeOf(globalI32), globalProto);
+}, "'WebAssembly.Global' instance objects");
+
+test(() => {
+    let builder = new WasmModuleBuilder();
+    builder.addGlobal(kWasmI32).exportAs('i32');
+    builder.addGlobal(kWasmI64).exportAs('i64');
+    builder.addGlobal(kWasmF32).exportAs('f32');
+    builder.addGlobal(kWasmF64).exportAs('f64');
+    builder.addGlobal(kWasmI32, true).exportAs('i32mut');
+    builder.addGlobal(kWasmI64, true).exportAs('i64mut');
+    builder.addGlobal(kWasmF32, true).exportAs('f32mut');
+    builder.addGlobal(kWasmF64, true).exportAs('f64mut');
+    let module = new WebAssembly.Module(builder.toBuffer());
+    let instance = new WebAssembly.Instance(module);
+
+    assert_true(instance.exports.i32 instanceof WebAssembly.Global);
+    assert_true(instance.exports.i64 instanceof WebAssembly.Global);
+    assert_true(instance.exports.f32 instanceof WebAssembly.Global);
+    assert_true(instance.exports.f64 instanceof WebAssembly.Global);
+    assert_true(instance.exports.i32mut instanceof WebAssembly.Global);
+    assert_true(instance.exports.i64mut instanceof WebAssembly.Global);
+    assert_true(instance.exports.f32mut instanceof WebAssembly.Global);
+    assert_true(instance.exports.f64mut instanceof WebAssembly.Global);
+
+    // Can't set value of immutable globals.
+    assertThrows(() => instance.exports.i32.value = 0, TypeError);
+    assertThrows(() => instance.exports.i64.value = 0, TypeError);
+    assertThrows(() => instance.exports.f32.value = 0, TypeError);
+    assertThrows(() => instance.exports.f64.value = 0, TypeError);
+
+    instance.exports.i32mut.value = 13579;
+    instance.exports.f32mut.value = 24680;
+    instance.exports.f64mut.value = 124816;
+
+    globalI64 = instance.exports.i64;
+    globalI64Mut = instance.exports.i64mut;
+}, "Export 'WebAssembly.Global'");
+
+test(() => {
+    const lengthDesc = Object.getOwnPropertyDescriptor(globalProto, 'value');
+    assert_equals(typeof lengthDesc.get, "function");
+    assert_equals(typeof lengthDesc.set, "function");
+    assert_equals(lengthDesc.enumerable, false);
+    assert_equals(lengthDesc.configurable, true);
+}, "'WebAssembly.Global.prototype.value' accessor data property");
+
+test(() => {
+    const valueDesc = Object.getOwnPropertyDescriptor(globalProto, 'value');
+    const valueGetter = valueDesc.get;
+    assert_equals(valueGetter.length, 0);
+    assertThrows(() => valueGetter.call(), TypeError);
+    assertThrows(() => valueGetter.call({}), TypeError);
+
+    assert_equals(typeof valueGetter.call(globalI32), "number");
+    assertThrows(() => valueGetter.call(globalI64), TypeError);
+    assert_equals(typeof valueGetter.call(globalF32), "number");
+    assert_equals(typeof valueGetter.call(globalF64), "number");
+    assert_equals(typeof valueGetter.call(globalI32Mut), "number");
+    assertThrows(() => valueGetter.call(globalI64Mut), TypeError);
+    assert_equals(typeof valueGetter.call(globalF32Mut), "number");
+    assert_equals(typeof valueGetter.call(globalF64Mut), "number");
+
+    assert_equals(valueGetter.call(globalI32), 0x132);
+    assert_equals(valueGetter.call(globalF32), 0xf32);
+    assert_equals(valueGetter.call(globalF64), 0xf64);
+    assert_equals(valueGetter.call(globalI32Mut), 0x132);
+    assert_equals(valueGetter.call(globalF32Mut), 0xf32);
+    assert_equals(valueGetter.call(globalF64Mut), 0xf64);
+}, "'WebAssembly.Global.prototype.value' getter");
+
+test(() => {
+    const valueDesc = Object.getOwnPropertyDescriptor(globalProto, 'value');
+    const valueSetter = valueDesc.set;
+    assert_equals(valueSetter.length, 1);
+    assertThrows(() => valueSetter.call(), TypeError);
+    assertThrows(() => valueSetter.call({}), TypeError);
+
+    assertThrows(() => valueSetter.call(globalI32, 1234), TypeError);
+    assertThrows(() => valueSetter.call(globalI64, 1234), TypeError);
+    assertThrows(() => valueSetter.call(globalF32, 1234), TypeError);
+    assertThrows(() => valueSetter.call(globalF64, 1234), TypeError);
+
+    valueSetter.call(globalI32Mut, 1234);
+    assertThrows(() => valueSetter.call(globalI64Mut, 1234), TypeError);
+    valueSetter.call(globalF32Mut, 5678);
+    valueSetter.call(globalF64Mut, 9012);
+
+    assert_equals(globalI32Mut.value, 1234);
+    assert_equals(globalF32Mut.value, 5678);
+    assert_equals(globalF64Mut.value, 9012);
+}, "'WebAssembly.Global.prototype.value' setter");
+
+test(() => {
+    const valueOfDesc = Object.getOwnPropertyDescriptor(globalProto, 'valueOf');
+    assert_equals(typeof valueOfDesc.value, "function");
+    assert_equals(valueOfDesc.enumerable, false);
+    assert_equals(valueOfDesc.configurable, true);
+}, "'WebAssembly.Global.prototype.valueOf' data property");
+
+test(() => {
+    const valueOfDesc = Object.getOwnPropertyDescriptor(globalProto, 'valueOf');
+    const valueOf = valueOfDesc.value;
+    assert_equals(valueOf.length, 0);
+    assertThrows(() => valueOf.call(), TypeError);
+    assertThrows(() => valueOf.call({}), TypeError);
+
+    assert_equals(valueOf.call(globalI32), 0x132);
+    assertThrows(() => valueOf.call(globalI64), TypeError);
+    assert_equals(valueOf.call(globalF32), 0xf32);
+    assert_equals(valueOf.call(globalF64), 0xf64);
+    assert_equals(valueOf.call(globalI32Mut), 1234);
+    assertThrows(() => valueOf.call(globalI64Mut), TypeError);
+    assert_equals(valueOf.call(globalF32Mut), 5678);
+    assert_equals(valueOf.call(globalF64Mut), 9012);
+}, "'WebAssembly.Global.prototype.valueOf' method");
+
+test(() => {
+    assert_equals(new Global({value: 'i32'}).value, 0);
+    assert_equals(new Global({value: 'f32'}).value, 0);
+    assert_equals(new Global({value: 'f64'}).value, 0);
+}, "'WebAssembly.Global' default value is 0");
+
+test(() => {
+    let builder = new WasmModuleBuilder();
+    builder.addImportedGlobal('', 'i32', kWasmI32);
+    builder.addImportedGlobal('', 'i64', kWasmI64);
+    builder.addImportedGlobal('', 'f32', kWasmF32);
+    builder.addImportedGlobal('', 'f64', kWasmF64);
+    builder.addImportedGlobal('', 'i32mut', kWasmI32, true);
+    builder.addImportedGlobal('', 'i64mut', kWasmI64, true);
+    builder.addImportedGlobal('', 'f32mut', kWasmF32, true);
+    builder.addImportedGlobal('', 'f64mut', kWasmF64, true);
+    let module = new WebAssembly.Module(builder.toBuffer());
+    let instance = new WebAssembly.Instance(module, {
+        '': {
+          i32: globalI32,
+          i64: globalI64,
+          f32: globalF32,
+          f64: globalF64,
+          i32mut: globalI32Mut,
+          i64mut: globalI64Mut,
+          f32mut: globalF32Mut,
+          f64mut: globalF64Mut
+        }
+    });
+}, "Import 'WebAssembly.Global'");
+
+test(() => {
+    let assertInstanceError = (type, mutable, imports) => {
+      assertThrows(() => {
+        let builder = new WasmModuleBuilder();
+        builder.addImportedGlobal('', 'g', type, mutable);
+        let module = new WebAssembly.Module(builder.toBuffer());
+        let instance = new WebAssembly.Instance(module, imports);
+      }, LinkError);
+    };
+
+    const immutable = false, mutable = true;
+
+    // Type mismatch.
+    assertInstanceError(kWasmI32, immutable, {'': {g: globalI64}});
+    assertInstanceError(kWasmI32, immutable, {'': {g: globalF32}});
+    assertInstanceError(kWasmI32, immutable, {'': {g: globalF64}});
+    assertInstanceError(kWasmI64, immutable, {'': {g: globalI32}});
+    assertInstanceError(kWasmI64, immutable, {'': {g: globalF32}});
+    assertInstanceError(kWasmI64, immutable, {'': {g: globalF64}});
+    assertInstanceError(kWasmF32, immutable, {'': {g: globalI32}});
+    assertInstanceError(kWasmF32, immutable, {'': {g: globalI64}});
+    assertInstanceError(kWasmF32, immutable, {'': {g: globalF64}});
+    assertInstanceError(kWasmF64, immutable, {'': {g: globalI32}});
+    assertInstanceError(kWasmF64, immutable, {'': {g: globalI64}});
+    assertInstanceError(kWasmF64, immutable, {'': {g: globalF32}});
+
+    assertInstanceError(kWasmI32, mutable, {'': {g: globalI64Mut}});
+    assertInstanceError(kWasmI32, mutable, {'': {g: globalF32Mut}});
+    assertInstanceError(kWasmI32, mutable, {'': {g: globalF64Mut}});
+    assertInstanceError(kWasmI64, mutable, {'': {g: globalI32Mut}});
+    assertInstanceError(kWasmI64, mutable, {'': {g: globalF32Mut}});
+    assertInstanceError(kWasmI64, mutable, {'': {g: globalF64Mut}});
+    assertInstanceError(kWasmF32, mutable, {'': {g: globalI32Mut}});
+    assertInstanceError(kWasmF32, mutable, {'': {g: globalI64Mut}});
+    assertInstanceError(kWasmF32, mutable, {'': {g: globalF64Mut}});
+    assertInstanceError(kWasmF64, mutable, {'': {g: globalI32Mut}});
+    assertInstanceError(kWasmF64, mutable, {'': {g: globalI64Mut}});
+    assertInstanceError(kWasmF64, mutable, {'': {g: globalF32Mut}});
+
+    // Mutable mismatch.
+    assertInstanceError(kWasmI32, immutable, {'': {g: globalI32Mut}});
+    assertInstanceError(kWasmI64, immutable, {'': {g: globalI64Mut}});
+    assertInstanceError(kWasmF32, immutable, {'': {g: globalF32Mut}});
+    assertInstanceError(kWasmF64, immutable, {'': {g: globalF64Mut}});
+
+    assertInstanceError(kWasmI32, mutable, {'': {g: globalI32}});
+    assertInstanceError(kWasmI64, mutable, {'': {g: globalI64}});
+    assertInstanceError(kWasmF32, mutable, {'': {g: globalF32}});
+    assertInstanceError(kWasmF64, mutable, {'': {g: globalF64}});
+
+    // Can't import Number as mutable.
+    assertInstanceError(kWasmI32, mutable, {'': {g: 1}});
+    assertInstanceError(kWasmI64, mutable, {'': {g: 1}});
+    assertInstanceError(kWasmF32, mutable, {'': {g: 1}});
+    assertInstanceError(kWasmF64, mutable, {'': {g: 1}});
+}, "Import 'WebAssembly.Global' type mismatch");
+
 test(() => {
     assertThrows(() => WebAssembly.validate(), TypeError);
     assertThrows(() => WebAssembly.validate("hi"), TypeError);

From 626e231e2f01e2fe4c14eba851f13819b318777a Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Thu, 7 Jun 2018 21:29:44 +0200
Subject: [PATCH 233/329] Fix typo in variable name. (#817)

---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 0c82236a1..0d5c27d27 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -498,7 +498,7 @@ interface Module {
     1. For each [=custom section=] |customSection| in the binary format of |bytes|,
         1. Let |name| be the <code>name</code> of the custom section, [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
         1. Assert: |name| is not failure (|moduleObject|.\[[Module]] is [=valid=]).
-        1. If |name| equals |secondName| as string values,
+        1. If |name| equals |sectionName| as string values,
             1. [=Append=] a new {{ArrayBuffer}} containing a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes| for the range matched by this [=customsec=] production.
     1. Return |customSections|.
 </div>

From 61a547be4030d476067cd5a6e74d0a45f481ffc2 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Mon, 11 Jun 2018 10:13:59 -0700
Subject: [PATCH 234/329] [spec] Use `any` in `Global` constructor (#818)

See discussion in issue #816. In the future, we'll want to store
non-numeric values in a `WebAssembly.Global` object, so using
`unrestricted double` is over-constrained.
---
 document/js-api/index.bs | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 0d5c27d27..0993c0252 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -720,10 +720,10 @@ dictionary GlobalDescriptor {
   boolean mutable = false;
 };
 
-[LegacyNamespace=WebAssembly, Constructor(GlobalDescriptor descriptor, unrestricted double value = 0), Exposed=(Window,Worker,Worklet)]
+[LegacyNamespace=WebAssembly, Constructor(GlobalDescriptor descriptor, optional any value), Exposed=(Window,Worker,Worklet)]
 interface Global {
-  unrestricted double valueOf();
-  attribute unrestricted double value;
+  any valueOf();
+  attribute any value;
 };
 </pre>
 
@@ -753,11 +753,19 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Otherwise, throw a {{TypeError}} exception.
 </div>
 
+<div algorithm>
+    The algorithm <dfn>DefaultValue</dfn>(|valuetype|) performs the following steps:
+    1. If |valuetype| equals [=𝗂𝟥𝟤=], return [=𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] 0.
+    1. If |valuetype| equals [=𝖿𝟥𝟤=], return [=𝖿𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] 0.
+    1. If |valuetype| equals [=𝖿𝟨𝟦=], return [=𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] 0.
+    1. Otherwise, throw a {{TypeError}} exception.
+</div>
+
 <div algorithm>
     The <dfn constructor for="Global">Global(descriptor, v)</dfn> constructor, when invoked, performs the following steps:
     1. Let |mutable| be |descriptor|["mutable"].
     1. Let |valuetype| be [=ToValueType=](|descriptor|["value"]).
-    1. Let |value| be [=ToWebAssemblyValue=](|v|, |valuetype|).
+    1. If |v| is undefined, let |value| be [=DefaultValue=](|valuetype|); otherwise, let |value| be [=ToWebAssemblyValue=](|v|, |valuetype|).
     1. If |mutable| is true, let |globaltype| be [=var=] |valuetype|; otherwise, let |globaltype| be [=const=] |valuetype|.
     1. Let |store| be the current agent's [=associated store=].
     1. Let (|store|, |globaladdr|) be [=alloc_global=](|store|, |globaltype|, |value|). <!-- TODO(littledan): Report allocation failure https://github.com/WebAssembly/spec/issues/584 -->

From 04b810a7d9f48024ef51581942f4533e041d88ba Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 18 Jun 2018 20:56:15 +0200
Subject: [PATCH 235/329] [test/interpreter] Check for max number of locals
 (#825)

---
 interpreter/binary/decode.ml |  9 +++++++--
 interpreter/util/lib.ml      |  3 +++
 interpreter/util/lib.mli     |  3 +++
 test/core/binary.wast        | 17 +++++++++++++++++
 4 files changed, 30 insertions(+), 2 deletions(-)

diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 1c6da1d4b..8358cb341 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -574,10 +574,15 @@ let start_section s =
 let local s =
   let n = vu32 s in
   let t = value_type s in
-  Lib.List32.make n t
+  n, t
 
 let code _ s =
-  let locals = List.flatten (vec local s) in
+  let pos = pos s in
+  let nts = vec local s in
+  let ns = List.map (fun (n, _) -> I64_convert.extend_u_i32 n) nts in
+  require (I64.lt_u (List.fold_left I64.add 0L ns) 0x1_0000_0000L)
+    s pos "too many locals";
+  let locals = List.flatten (List.map (Lib.Fun.uncurry Lib.List32.make) nts) in
   let body = instr_block s in
   end_ s;
   {locals; body; ftype = Source.((-1l) @@ Source.no_region)}
diff --git a/interpreter/util/lib.ml b/interpreter/util/lib.ml
index 01fc24efe..d8c33a1a0 100644
--- a/interpreter/util/lib.ml
+++ b/interpreter/util/lib.ml
@@ -1,5 +1,8 @@
 module Fun =
 struct
+  let curry f x y = f (x, y)
+  let uncurry f (x, y) = f x y
+
   let rec repeat n f x =
     if n = 0 then () else (f x; repeat (n - 1) f x)
 end
diff --git a/interpreter/util/lib.mli b/interpreter/util/lib.mli
index da4a58562..de24c295d 100644
--- a/interpreter/util/lib.mli
+++ b/interpreter/util/lib.mli
@@ -2,6 +2,9 @@
 
 module Fun :
 sig
+  val curry : ('a * 'b -> 'c) -> ('a -> 'b -> 'c)
+  val uncurry : ('a -> 'b -> 'c) -> ('a * 'b -> 'c)
+
   val repeat : int -> ('a -> unit) -> 'a -> unit
 end
 
diff --git a/test/core/binary.wast b/test/core/binary.wast
index 74692eb24..3dceb2ecd 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -325,3 +325,20 @@
   )
   "zero flag expected"
 )
+
+;; No more than 2^32 locals.
+(assert_malformed 
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\02"
+    "\ff\ff\ff\ff\0f\7f"       ;; 0xFFFFFFFF i32
+    "\02\7e"                   ;; 0x00000002 i64
+    "\0b"                      ;; end
+  )
+  "too many locals"
+)

From dd81ac6db134b2f314c58ac5fca9c683c2401841 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 4 Apr 2018 17:03:57 +0200
Subject: [PATCH 236/329] [js-api] Fix various style issues and typos found by
 Mark Miller

- Fix accidentally setting the wrong state from Table.grow
- secondName -> sectionName
- Fix note about NaN payloads
- Improve name of some types
- Make proper use of byte stability
- Create a promise from within "asynchronously compile..."

Fixes issues reported in #730
---
 document/js-api/index.bs  | 21 ++++++++++-----------
 document/web-api/index.bs |  2 +-
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 0993c0252..16ceb695e 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -293,22 +293,22 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
 </div>
 
 <div algorithm>
-  To <dfn>asynchronously compile a WebAssembly module</dfn> from a {{BufferSource}} |bytes|, with the promise |promise|, using optional [=task source=] |taskSource|, perform the following steps:
+  To <dfn>asynchronously compile a WebAssembly module</dfn> from a {{BufferSource}} |bytes|, using optional [=task source=] |taskSource|, perform the following steps:
 
+    1. Let |promise| be [=a new promise=].
     1. In parallel, [=compile a WebAssembly module|compile the WebAssembly module=] |bytes| and store the result as |module|.
     1. When the above operation completes, [=queue a task=] to perform the following steps. If |taskSource| was provided, queue the task on that task source.
         1. If |module| is [=error=], reject |promise| with a {{CompileError}} exception.
         1. Otherwise,
             1. [=Construct a WebAssembly module object=] from |module| and |bytes|, and let |moduleObject| be the result.
             1. [=Resolve=] |promise| with |moduleObject|.
+    1. Return |promise|.
 </div>
 
 <div algorithm>
     The <dfn method for="WebAssembly">compile(bytes)</dfn> method, when invoked, performs the following steps:
     1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes|.
-    1. Let |promise| be [=a new promise=].
-    1. [=Asynchronously compile a WebAssembly module=] from |stableBytes| with |promise|.
-    1. Return |promise|.
+    1. [=Asynchronously compile a WebAssembly module=] from |stableBytes| and return the result.
 </div>
 
 <div algorithm="instantiate">
@@ -415,8 +415,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
 <div algorithm>
   The <dfn method for="WebAssembly">instantiate(bytes, importObject)</dfn> method, when invoked, performs the following steps:
     1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes|.
-    1. Let |promiseOfModule| be [=a new promise=].
-    1. [=Asynchronously compile a WebAssembly module=] from |stableBytes| with |promiseOfModule|.
+    1. [=Asynchronously compile a WebAssembly module=] from |stableBytes| and let |promiseOfModule| be the result.
     1. [=Instantiate a promise of a module|Instantiate=] |promiseOfModule| with imports |importObject| and return the result.
 </div>
 
@@ -509,7 +508,7 @@ interface Module {
     1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes|.
     1. [=Compile a WebAssembly module|Compile the WebAssembly module=] |stableBytes| and store the result as |module|.
     1. If |module| is [=error=], throw a {{CompileError}} exception.
-    1. [=Construct a WebAssembly module object=] from |module| and |bytes|, and return the result.
+    1. [=Construct a WebAssembly module object=] from |module| and |stableBytes|, and return the result.
 </div>
 
 <h3 id="instances">Instances</h3>
@@ -679,7 +678,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 
         Note: The above exception may happen due to either insufficient memory or an invalid size parameter.
 
-    6. Set the [=surrounding agent=]'s [=associated store=] to |store|.
+    6. Set the [=surrounding agent=]'s [=associated store=] to |result|.
     1. [=Append=] null to the Table instance's \[[Values]] internal slot |d| times.
     1. Return |initialSize|.
 </div>
@@ -840,8 +839,8 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
     1. Set |function|.\[[FunctionAddress]] to |funcaddr|.
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |functype| be [=type_func=](|store|, |funcaddr|).
-    1. Let [|arguments|] → [|results|] be |functype|.
-    1. Let |arity| be the length of |arguments|.
+    1. Let [|paramTypes|] → [|resultTypes|] be |functype|.
+    1. Let |arity| be the length of |paramTypes|.
     1. Perform ! [=DefinePropertyOrThrow=](|function|, `"length"`, PropertyDescriptor {\[[Value]]: |arity|, \[[Writable]]: false, \[[Enumerable]]: false, \[[Configurable]]: true}).
     1. Let |name| be the [=name of the WebAssembly function=] |funcaddr|.
     1. Perform ! [=SetFunctionName=](|function|, |name|).
@@ -906,7 +905,7 @@ Assert: |w| is not of the form [=𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] |i64|.
 
 <!-- If the WebAssembly value is optional, then given `None`, return JavaScript value `undefined`. -->
 
-Note: Implementations may optionally replace the NaN payload with any other NaN payload at this point in the f32 or f64 cases; such a change would not be observable through [=NumberToRawBytes=].
+Note: Number values which are equal to NaN may have various observable NaN payloads; see [=NumberToRawBytes=].for details.
 </div>
 
 <div algorithm>
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index bc407ecc5..8b2f0325a 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -117,7 +117,7 @@ Note: This algorithm accepts a {{Response}} object, or a
         Note: Although it is specified here that the response is consumed entirely before compilation proceeds, that is purely for ease of specification; implementations are likely to instead perform processing in a streaming fashion. The different is unobservable, and thus the simpler model is specified. <!-- Using consume is a bit silly as it creates an ArrayBuffer but then we just want the underlying bytes. This is because of how streams is specced in terms of promises and JS objects whereas we want to operate more directly on the underlying concept. We can revisit this if things change in the Streams/Fetch specs. -->
 
         7. [=Upon fulfillment=] of |bodyPromise| with value |bodyArrayBuffer|:
-            1. [=Asynchronously compile a WebAssembly module|Asynchronously compile the WebAssembly module=] |bodyArrayBuffer| with |returnValue| using the [=networking task source=].
+            1. [=Asynchronously compile a WebAssembly module|Asynchronously compile the WebAssembly module=] |bodyArrayBuffer| using the [=networking task source=] and [=resolve=] |returnValue| with the result.
         1. [=Upon rejection=] of |bodyPromise| with reason |reason|:
             1. [=Reject=] |returnValue| with |reason|.
      1. [=Upon rejection=] of |source| with reason |reason|:

From 05e326b81e7c9357ff22a849308bdfe264a8d225 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 21 Feb 2018 12:23:05 +0100
Subject: [PATCH 237/329] [spec] Normative: Add serialization support for
 Modules

---
 document/web-api/index.bs | 46 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 8b2f0325a..1d48eaede 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -32,6 +32,12 @@ Prepare For TR: true
     "title": "WebAssembly JS Integration Specification",
     "publisher": "W3C WebAssembly Community Group",
     "status": "Draft"
+  },
+  "SECURECONTEXTS": {
+    "href": "https://w3c.github.io/webappsec-secure-contexts/",
+    "title": "Secure Contexts",
+    "publisher": "WebAppSec WG",
+    "status": "Candidate Recommendation"
   }
 }
 </pre>
@@ -42,6 +48,9 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMA-262
         text: TypeError; url: sec-native-error-types-used-in-this-standard-typeerror
     type: interface
         text: ArrayBuffer; url: sec-arraybuffer-objects
+    type: dfn
+        text: agent cluster; url: sec-agent-clusters
+        text: current Realm; url: current-realm
 urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: dfn
     text: function index; url: syntax/modules.html#syntax-funcidx
     text: name section; url: appendix/custom.html?highlight=name%20section#binary-namesec
@@ -61,6 +70,7 @@ urlPrefix: https://webassembly.github.io/spec/js-api/; spec: WASMJS
         text: Exported Function; url: #exported-function
 url:https://html.spec.whatwg.org/#cors-same-origin;text:CORS-same-origin;type:dfn;spec:HTML
 url:https://fetch.spec.whatwg.org/#concept-body-consume-body;text:consume body;type:dfn;spec:FETCH
+url:https://w3c.github.io/webappsec-secure-contexts/#environment-settings-object-contextually-secure; text:contextually secure; type: dfn; spec: SECURECONTEXTS
 </pre>
 
 <pre class='link-defaults'>
@@ -125,6 +135,42 @@ Note: This algorithm accepts a {{Response}} object, or a
      1. Return |returnValue|.
 </div>
 
+<h2 id="serialization">Serialization</h2>
+
+On the Web, {{Module}} has the <code>[<a extended-attribute>Serializable</a>]</code> extended attribute.
+
+The [=serialization steps=], given |value|, |serialized| and |forStorage|, are:
+
+    1. If |forStorage| is true and the [=relevant settings object=]
+        of |value| is not [=contextually secure=], throw a
+        "<a exception>DataCloneError</a>" {{DOMException}}
+
+    1. Set |serialized|.\[[Bytes]] to |value|.\[[Bytes]].
+
+    1. Set |serialized|.\[[AgentCluster]] to the [=current Realm=]'s corresponding [=agent cluster=].
+
+The [=deserialization steps=], given |serialized| and |value|, are:
+
+    1. If |targetRealm|'s corresponding [=agent cluster=] is not
+        |serialized|.\[[AgentCluster]], then throw a
+        "<a exception>DataCloneError</a>" {{DOMException}}.
+
+    1. Let |bytes| be |serialized|.\[[Bytes]].
+
+    1. Set |value|.\[[Bytes]] to |bytes|.
+
+    1. [=Compile a WebAssembly module=] from |bytes| and set |value|.\[[Module]] to the result.
+
+The semantics of a structured serialization is as-if the binary source, from which the
+{{Module}} was compiled, is serialized, then deserialized, and recompiled into the target realm.
+Engines should attempt to share/reuse internal compiled code when performing
+a structured serialization, although in corner cases like CPU upgrade or browser
+update, this might not be possible and full recompilation may be necessary.
+
+Given the above engine optimizations, structured serialization provides developers
+explicit control over both compiled-code caching and cross-window/worker code
+sharing.
+
 <h2 id="conventions">Developer-Facing Display Conventions</h2>
 
 <em>This section is non-normative.</em>

From 3a1698008088717f9e59711695b79a2043ab4457 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 21 Feb 2018 15:20:40 +0100
Subject: [PATCH 238/329] [spec] Normative: Remove same-agent-cluster
 restriction for Module deserialization

This restriction was non-sensical because there is practical no way to serialize
an agent cluster forStorage.
---
 document/web-api/index.bs | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 1d48eaede..21e9cc03a 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -147,14 +147,8 @@ The [=serialization steps=], given |value|, |serialized| and |forStorage|, are:
 
     1. Set |serialized|.\[[Bytes]] to |value|.\[[Bytes]].
 
-    1. Set |serialized|.\[[AgentCluster]] to the [=current Realm=]'s corresponding [=agent cluster=].
-
 The [=deserialization steps=], given |serialized| and |value|, are:
 
-    1. If |targetRealm|'s corresponding [=agent cluster=] is not
-        |serialized|.\[[AgentCluster]], then throw a
-        "<a exception>DataCloneError</a>" {{DOMException}}.
-
     1. Let |bytes| be |serialized|.\[[Bytes]].
 
     1. Set |value|.\[[Bytes]] to |bytes|.

From 82ec878fff264624154e7d9a825e790a9fb74a0a Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 21 Feb 2018 15:49:21 +0100
Subject: [PATCH 239/329] [spec] Editorial: Explicitly do subserialization

---
 document/web-api/index.bs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 21e9cc03a..c2f248dc5 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -145,11 +145,11 @@ The [=serialization steps=], given |value|, |serialized| and |forStorage|, are:
         of |value| is not [=contextually secure=], throw a
         "<a exception>DataCloneError</a>" {{DOMException}}
 
-    1. Set |serialized|.\[[Bytes]] to |value|.\[[Bytes]].
+    1. Set |serialized|.\[[Bytes]] to the [=sub-serialization=] of |value|.\[[Bytes]].
 
 The [=deserialization steps=], given |serialized| and |value|, are:
 
-    1. Let |bytes| be |serialized|.\[[Bytes]].
+    1. Let |bytes| be the [=sub-deserialization=] of |serialized|.\[[Bytes]].
 
     1. Set |value|.\[[Bytes]] to |bytes|.
 

From 518853c3b480ed3d63d054a3dffb1283b83b0a7f Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 21 Feb 2018 16:29:30 +0100
Subject: [PATCH 240/329] [spec] Editorial: Changes suggested by @annevk

---
 document/web-api/index.bs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index c2f248dc5..bbe48d8dc 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -139,7 +139,7 @@ Note: This algorithm accepts a {{Response}} object, or a
 
 On the Web, {{Module}} has the <code>[<a extended-attribute>Serializable</a>]</code> extended attribute.
 
-The [=serialization steps=], given |value|, |serialized| and |forStorage|, are:
+The [=serialization steps=], given |value|, |serialized|, and |forStorage|, are:
 
     1. If |forStorage| is true and the [=relevant settings object=]
         of |value| is not [=contextually secure=], throw a
@@ -155,12 +155,12 @@ The [=deserialization steps=], given |serialized| and |value|, are:
 
     1. [=Compile a WebAssembly module=] from |bytes| and set |value|.\[[Module]] to the result.
 
-The semantics of a structured serialization is as-if the binary source, from which the
-{{Module}} was compiled, is serialized, then deserialized, and recompiled into the target realm.
 Engines should attempt to share/reuse internal compiled code when performing
 a structured serialization, although in corner cases like CPU upgrade or browser
 update, this might not be possible and full recompilation may be necessary.
 
+Note: The semantics of a structured serialization is as-if the binary source, from which the
+{{Module}} was compiled, is serialized, then deserialized, and recompiled into the target realm.
 Given the above engine optimizations, structured serialization provides developers
 explicit control over both compiled-code caching and cross-window/worker code
 sharing.

From d72615b5a1afa03bfcb0c0b3ac52133d14ebd9bb Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 21 Feb 2018 23:09:01 +0100
Subject: [PATCH 241/329] [spec] Editorial: Adopt @annevk's suggested wording

---
 document/web-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index bbe48d8dc..e626652c9 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -137,7 +137,7 @@ Note: This algorithm accepts a {{Response}} object, or a
 
 <h2 id="serialization">Serialization</h2>
 
-On the Web, {{Module}} has the <code>[<a extended-attribute>Serializable</a>]</code> extended attribute.
+Web user agents must augment the {{Module}} interface with the <code>[<a extended-attribute>Serializable</a>]</code> extended attribute.
 
 The [=serialization steps=], given |value|, |serialized|, and |forStorage|, are:
 

From aba9769100f14b24ae221626ef99a6d49cc99a52 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 11 Apr 2018 19:07:08 +0200
Subject: [PATCH 242/329] Revert "[spec] Normative: Remove same-agent-cluster
 restriction for Module deserialization"

The same agent cluster restriction is present in the case of serializing
within memory. Also add a note about how this restricts serialization to be
within an origin.
---
 document/web-api/index.bs | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index e626652c9..1856a59e7 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -147,12 +147,20 @@ The [=serialization steps=], given |value|, |serialized|, and |forStorage|, are:
 
     1. Set |serialized|.\[[Bytes]] to the [=sub-serialization=] of |value|.\[[Bytes]].
 
+    1. If |forStorage| is *false*, set |serialized|.\[[AgentCluster]] to the
+       [=current Realm=]'s corresponding [=agent cluster=].
+
 The [=deserialization steps=], given |serialized| and |value|, are:
 
     1. Let |bytes| be the [=sub-deserialization=] of |serialized|.\[[Bytes]].
 
     1. Set |value|.\[[Bytes]] to |bytes|.
 
+    1. If |serialized| has an \[[AgentCluster]] field, and if |targetRealm|'s
+        corresponding [=agent cluster=] is not
+        |serialized|.\[[AgentCluster]], then throw a
+        "<a exception>DataCloneError</a>" {{DOMException}}.
+
     1. [=Compile a WebAssembly module=] from |bytes| and set |value|.\[[Module]] to the result.
 
 Engines should attempt to share/reuse internal compiled code when performing
@@ -165,6 +173,10 @@ Given the above engine optimizations, structured serialization provides develope
 explicit control over both compiled-code caching and cross-window/worker code
 sharing.
 
+Note: The web platform does not permit cross-origin sharing of serialized Modules: in the
+case of |forStorage| being true, IndexedDB separates storage per origin; in the case of
+|forStorage| being false, agent clusters in HTML do not span multiple origins.
+
 <h2 id="conventions">Developer-Facing Display Conventions</h2>
 
 <em>This section is non-normative.</em>

From f85f6e6b70fff9ee0f6ba21ebcdad2183bd67874 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 13 Jun 2018 10:02:34 -0700
Subject: [PATCH 243/329] [spec] Normative: Prohibit IndexedDB serialization of
 Modules

Based on discussions in the WebAssembly CG, it sounds like IndexedDB
serialization of WebAssembly Modules has the following problems:
- On some engines, it's impractical to serialize more than just the
  binary module data
- On some engines, upgrading from one version to another would cause
  the serialized module to be invalidated, with complicated implementation
  logic and a loss of reliability
- Some engines plan to just return an error for IndexedDB module
  serialization as a design decision

The purpose of IndexedDB Module serialization is for reliable performance,
and these items provide risks to that. This patch proposes that, initially,
IndexedDB serialization would not be provided for WebAssembly modules.
---
 document/web-api/index.bs | 12 +++---------
 1 file changed, 3 insertions(+), 9 deletions(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 1856a59e7..e0f0135f6 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -141,13 +141,12 @@ Web user agents must augment the {{Module}} interface with the <code>[<a extende
 
 The [=serialization steps=], given |value|, |serialized|, and |forStorage|, are:
 
-    1. If |forStorage| is true and the [=relevant settings object=]
-        of |value| is not [=contextually secure=], throw a
+    1. If |forStorage| is true, throw a
         "<a exception>DataCloneError</a>" {{DOMException}}
 
     1. Set |serialized|.\[[Bytes]] to the [=sub-serialization=] of |value|.\[[Bytes]].
 
-    1. If |forStorage| is *false*, set |serialized|.\[[AgentCluster]] to the
+    1. Set |serialized|.\[[AgentCluster]] to the
        [=current Realm=]'s corresponding [=agent cluster=].
 
 The [=deserialization steps=], given |serialized| and |value|, are:
@@ -156,8 +155,7 @@ The [=deserialization steps=], given |serialized| and |value|, are:
 
     1. Set |value|.\[[Bytes]] to |bytes|.
 
-    1. If |serialized| has an \[[AgentCluster]] field, and if |targetRealm|'s
-        corresponding [=agent cluster=] is not
+    1. If |targetRealm|'s corresponding [=agent cluster=] is not
         |serialized|.\[[AgentCluster]], then throw a
         "<a exception>DataCloneError</a>" {{DOMException}}.
 
@@ -173,10 +171,6 @@ Given the above engine optimizations, structured serialization provides develope
 explicit control over both compiled-code caching and cross-window/worker code
 sharing.
 
-Note: The web platform does not permit cross-origin sharing of serialized Modules: in the
-case of |forStorage| being true, IndexedDB separates storage per origin; in the case of
-|forStorage| being false, agent clusters in HTML do not span multiple origins.
-
 <h2 id="conventions">Developer-Facing Display Conventions</h2>
 
 <em>This section is non-normative.</em>

From c220352cd03ef7a8eec71d995dcb666bedafd82b Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Wed, 27 Jun 2018 11:00:27 -0700
Subject: [PATCH 244/329] Allow creation of default i64 global values (#829)

See issue #827.
---
 document/js-api/index.bs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 16ceb695e..9659b05b2 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -747,6 +747,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 <div algorithm>
     The algorithm <dfn>ToValueType</dfn>(|s|) performs the following steps:
     1. If |s| equals "i32", return [=𝗂𝟥𝟤=].
+    1. If |s| equals "i64", return [=𝗂𝟨𝟦=].
     1. If |s| equals "f32", return [=𝖿𝟥𝟤=].
     1. If |s| equals "f64", return [=𝖿𝟨𝟦=].
     1. Otherwise, throw a {{TypeError}} exception.
@@ -755,6 +756,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 <div algorithm>
     The algorithm <dfn>DefaultValue</dfn>(|valuetype|) performs the following steps:
     1. If |valuetype| equals [=𝗂𝟥𝟤=], return [=𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] 0.
+    1. If |valuetype| equals [=𝗂𝟨𝟦=], return [=𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] 0.
     1. If |valuetype| equals [=𝖿𝟥𝟤=], return [=𝖿𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] 0.
     1. If |valuetype| equals [=𝖿𝟨𝟦=], return [=𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] 0.
     1. Otherwise, throw a {{TypeError}} exception.
@@ -764,7 +766,11 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     The <dfn constructor for="Global">Global(descriptor, v)</dfn> constructor, when invoked, performs the following steps:
     1. Let |mutable| be |descriptor|["mutable"].
     1. Let |valuetype| be [=ToValueType=](|descriptor|["value"]).
-    1. If |v| is undefined, let |value| be [=DefaultValue=](|valuetype|); otherwise, let |value| be [=ToWebAssemblyValue=](|v|, |valuetype|).
+    1. If |v| is undefined,
+       1. let |value| be [=DefaultValue=](|valuetype|).
+    1. Otherwise,
+       1. If |valuetype| is [=𝗂𝟨𝟦=], throw a {{TypeError}} exception.
+       1. Let |value| be [=ToWebAssemblyValue=](|v|, |valuetype|).
     1. If |mutable| is true, let |globaltype| be [=var=] |valuetype|; otherwise, let |globaltype| be [=const=] |valuetype|.
     1. Let |store| be the current agent's [=associated store=].
     1. Let (|store|, |globaladdr|) be [=alloc_global=](|store|, |globaltype|, |value|). <!-- TODO(littledan): Report allocation failure https://github.com/WebAssembly/spec/issues/584 -->

From fbcc4428d8af221198a04614cdf0751f0a94542c Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Fri, 22 Jun 2018 17:21:43 +0200
Subject: [PATCH 245/329] Use SetFunctionLength.

---
 document/js-api/index.bs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 9659b05b2..30102a356 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -81,6 +81,7 @@ urlPrefix: https://tc39.github.io/ecma262/; spec: ECMASCRIPT
         text: ObjectCreate; url: sec-objectcreate
         text: CreateBuiltinFunction; url: sec-createbuiltinfunction
         text: SetFunctionName; url: sec-setfunctionname
+        text: SetFunctionLength; url: sec-setfunctionlength
         text: the Number value; url: sec-ecmascript-language-types-number-type
         text: NumberToRawBytes; url: sec-numbertorawbytes
         text: Built-in Function Objects; url: sec-built-in-function-objects
@@ -847,7 +848,7 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
     1. Let |functype| be [=type_func=](|store|, |funcaddr|).
     1. Let [|paramTypes|] → [|resultTypes|] be |functype|.
     1. Let |arity| be the length of |paramTypes|.
-    1. Perform ! [=DefinePropertyOrThrow=](|function|, `"length"`, PropertyDescriptor {\[[Value]]: |arity|, \[[Writable]]: false, \[[Enumerable]]: false, \[[Configurable]]: true}).
+    1. Perform ! [=SetFunctionLength=](|function|, |arity|).
     1. Let |name| be the [=name of the WebAssembly function=] |funcaddr|.
     1. Perform ! [=SetFunctionName=](|function|, |name|).
     1. [=map/Set=] |map|[|funcaddr|] to |function|.

From 161cf433283108546225d3bc223bee56fa56f1a8 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Fri, 22 Jun 2018 17:25:36 +0200
Subject: [PATCH 246/329] Fix typo in instantiate(moduleObject, importObject).

---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 30102a356..dc26bc168 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -424,7 +424,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
   The <dfn method for="WebAssembly">instantiate(moduleObject, importObject)</dfn> method, when invoked, performs the following steps:
     1. Let |promise| be [=a new promise=].
     1. [=Queue a task=] to perform the following steps:
-        1. [=instantiate a WebAssembly module|Instantiate the WebAssembly module=] |module| importing |importObject|, and let |instance| be the result.  If this throws an exception, catch it, and [=reject=] |promise| with the exception.
+        1. [=instantiate a WebAssembly module|Instantiate the WebAssembly module=] |moduleObject| importing |importObject|, and let |instance| be the result.  If this throws an exception, catch it, and [=reject=] |promise| with the exception.
         1. [=Resolve=] |promise| with |instance|.
     1. Return |promise|
 </div>

From 0627ab14b1caf885e0f8eed6cacc97637b8bcf35 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Fri, 22 Jun 2018 17:41:08 +0200
Subject: [PATCH 247/329] Add missing anchor for "global instance".

---
 document/js-api/index.bs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index dc26bc168..0d4ef3336 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -94,6 +94,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
     text: customsec; url: binary/modules.html#binary-customsec
     text: memory instance; url: exec/runtime.html#memory-instances
     text: table instance; url: exec/runtime.html#table-instances
+    text: global instance; url: exec/runtime.html#global-instances
     text: trap; url: exec/runtime.html#syntax-trap
     url: exec/runtime.html#values
         text: WebAssembly value

From bc7aaf73762fac35575ba8d53769ba4b33b6a473 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Fri, 22 Jun 2018 17:42:12 +0200
Subject: [PATCH 248/329] Mark method arguments as variables.

---
 document/js-api/index.bs | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 0d4ef3336..ff31a198d 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -272,7 +272,7 @@ Note:
 </div>
 
 <div algorithm>
-  The <dfn method for="WebAssembly">validate(bytes)</dfn> method, when invoked, performs the following steps:
+  The <dfn method for="WebAssembly">validate(|bytes|)</dfn> method, when invoked, performs the following steps:
     1. [=Compile a WebAssembly module|Compile=] |bytes| as a WebAssembly module and store the results as |module|.
     1. If |module| is [=error=], return false.
     1. Return true.
@@ -308,7 +308,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
 </div>
 
 <div algorithm>
-    The <dfn method for="WebAssembly">compile(bytes)</dfn> method, when invoked, performs the following steps:
+    The <dfn method for="WebAssembly">compile(|bytes|)</dfn> method, when invoked, performs the following steps:
     1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes|.
     1. [=Asynchronously compile a WebAssembly module=] from |stableBytes| and return the result.
 </div>
@@ -415,14 +415,14 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
 </div>
 
 <div algorithm>
-  The <dfn method for="WebAssembly">instantiate(bytes, importObject)</dfn> method, when invoked, performs the following steps:
+  The <dfn method for="WebAssembly">instantiate(|bytes|, |importObject|)</dfn> method, when invoked, performs the following steps:
     1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes|.
     1. [=Asynchronously compile a WebAssembly module=] from |stableBytes| and let |promiseOfModule| be the result.
     1. [=Instantiate a promise of a module|Instantiate=] |promiseOfModule| with imports |importObject| and return the result.
 </div>
 
 <div algorithm>
-  The <dfn method for="WebAssembly">instantiate(moduleObject, importObject)</dfn> method, when invoked, performs the following steps:
+  The <dfn method for="WebAssembly">instantiate(|moduleObject|, |importObject|)</dfn> method, when invoked, performs the following steps:
     1. Let |promise| be [=a new promise=].
     1. [=Queue a task=] to perform the following steps:
         1. [=instantiate a WebAssembly module|Instantiate the WebAssembly module=] |moduleObject| importing |importObject|, and let |instance| be the result.  If this throws an exception, catch it, and [=reject=] |promise| with the exception.
@@ -471,7 +471,7 @@ interface Module {
 </div>
 
 <div algorithm>
-    The <dfn method for="Module">exports(moduleObject)</dfn> method, when invoked, performs the following steps:
+    The <dfn method for="Module">exports(|moduleObject|)</dfn> method, when invoked, performs the following steps:
     1. Let |module| be |moduleObject|.\[[Module]].
     1. Let |exports| be an empty [=list=].
     1. For each (|name|, |type|) in [=module_exports=](|module|)
@@ -482,7 +482,7 @@ interface Module {
 </div>
 
 <div algorithm>
-    The <dfn method for="Module">imports(moduleObject)</dfn> method, when invoked, performs the following steps:
+    The <dfn method for="Module">imports(|moduleObject|)</dfn> method, when invoked, performs the following steps:
     1. Let |module| be |moduleObject|.\[[Module]].
     1. Let |imports| be an empty [=list=].
     1. For each (|moduleName|, |name|, |type|) in [=module_imports=](|module|),
@@ -493,7 +493,7 @@ interface Module {
 </div>
 
 <div algorithm>
-    The <dfn method for="Module">customSections(moduleObject, sectionName)</dfn> method, when invoked, performs the following steps:
+    The <dfn method for="Module">customSections(|moduleObject|, |sectionName|)</dfn> method, when invoked, performs the following steps:
     1. Let |bytes| be |moduleObject|.\[[Bytes]].
     1. Let |customSections| be an empty [=list=] of {{ArrayBuffer}}s.
     1. For each [=custom section=] |customSection| in the binary format of |bytes|,
@@ -505,7 +505,7 @@ interface Module {
 </div>
 
 <div algorithm>
-    The <dfn constructor for="Module">Module(bytes)</dfn> constructor, when invoked, performs the follwing steps:
+    The <dfn constructor for="Module">Module(|bytes|)</dfn> constructor, when invoked, performs the follwing steps:
 
     1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes|.
     1. [=Compile a WebAssembly module|Compile the WebAssembly module=] |stableBytes| and store the result as |module|.
@@ -523,7 +523,7 @@ interface Instance {
 </pre>
 
 <div algorithm>
-    The <dfn constructor for="Instance">Instance(module, importObject)</dfn> constructor, when invoked, [=instantiate a WebAssembly module|instantiates the WebAssembly module=] |module| importing |importObject| and returns the result.
+    The <dfn constructor for="Instance">Instance(|module|, |importObject|)</dfn> constructor, when invoked, [=instantiate a WebAssembly module|instantiates the WebAssembly module=] |module| importing |importObject| and returns the result.
 </div>
 
 <div algorithm>
@@ -569,7 +569,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 </div>
 
 <div algorithm>
-    The <dfn constructor for="Memory">Memory(descriptor)</dfn> constructor, when invoked, performs the following steps:
+    The <dfn constructor for="Memory">Memory(|descriptor|)</dfn> constructor, when invoked, performs the following steps:
     1. If |descriptor|["initial"] is [=present=], let |initial| be |descriptor|["initial"]; otherwise, let |initial| be 0.
     1. If |descriptor|["maximum"] is [=present=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
     1. Let |memtype| be { min |initial|, max |maximum| }
@@ -592,7 +592,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 </div>
 
 <div algorithm>
-    The <dfn method for="Memory">grow(delta)</dfn> method, when invoked, performs the following steps:
+    The <dfn method for="Memory">grow(|delta|)</dfn> method, when invoked, performs the following steps:
     1. Let |memory| be the Memory instance.
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |memaddr| be |memory|.\[[Memory]].
@@ -659,7 +659,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 </div>
 
 <div algorithm>
-    The <dfn constructor for="Table">Table(descriptor)</dfn> constructor, when invoked, performs the following steps:
+    The <dfn constructor for="Table">Table(|descriptor|)</dfn> constructor, when invoked, performs the following steps:
     1. If |descriptor|["initial"] is [=present=], let |n| be |descriptor|["initial"]; otherwise, let |n| be 0.
     1. If |descriptor|["maximum"] is [=present=], let |m| be |descriptor|["maximum"]; otherwise, let |m| be empty.
     1. If |m| is not empty and |m| &lt; |n|, throw a {{RangeError}} exception.
@@ -671,7 +671,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 </div>
 
 <div algorithm>
-    The <dfn method for="Table">grow(d)</dfn> method, when invoked, performs the following steps:
+    The <dfn method for="Table">grow(|d|)</dfn> method, when invoked, performs the following steps:
     1. Let |tableaddr| be the Table instance's \[[Table]] internal slot.
     1. Let |initialSize| be the length of the Table instance's \[[Values]] internal slot.
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
@@ -690,7 +690,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 </div>
 
 <div algorithm>
-    The <dfn method for="Table">get(index)</dfn> method, when invoked, performs the following steps:
+    The <dfn method for="Table">get(|index|)</dfn> method, when invoked, performs the following steps:
     1. Let |values| be the Table instance's \[[Values]] internal slot.
     1. Let |size| be the length of |values|.
     1. If |index| &ge; |size|, throw a {{RangeError}} exception.
@@ -698,7 +698,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 </div>
 
 <div algorithm>
-    The <dfn method for="Table">set(index, value)</dfn> method, when invoked, performs the following steps:
+    The <dfn method for="Table">set(|index|, |value|)</dfn> method, when invoked, performs the following steps:
     1. Let |tableaddr| be the Table instance's \[[Table]] internal slot.
     1. Let |values| be the Table instance's \[[Values]] internal slot.
     1. If |value| is null, let |funcaddr| be an empty [=function element=].
@@ -765,7 +765,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 </div>
 
 <div algorithm>
-    The <dfn constructor for="Global">Global(descriptor, v)</dfn> constructor, when invoked, performs the following steps:
+    The <dfn constructor for="Global">Global(|descriptor|, |v|)</dfn> constructor, when invoked, performs the following steps:
     1. Let |mutable| be |descriptor|["mutable"].
     1. Let |valuetype| be [=ToValueType=](|descriptor|["value"]).
     1. If |v| is undefined,

From ad1d1fb58428b03b1672ae7323c3b3c66f958035 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Fri, 22 Jun 2018 17:42:38 +0200
Subject: [PATCH 249/329] Tag unused variables.

---
 document/js-api/index.bs | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index ff31a198d..60d0f4408 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -333,7 +333,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
                 1. Let |index| be the number of external functions in |imports|. This value |index| is known as the <dfn>index of the host function</dfn> |funcaddr|.
             1. Let |externfunc| be the [=external value=] [=external value|𝖿𝗎𝗇𝖼=] |funcaddr|.
             1. [=Append=] |externfunc| to |imports|.
-        1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] |mut| |valtype|,
+        1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] <var ignore>mut</var> |valtype|,
             1. If [=Type=](|v|) is [=Number=],
                 1. If |valtype| is [=𝗂𝟨𝟦=], throw a {{LinkError}} exception.
                 1. Let |value| be [=ToWebAssemblyValue=](|v|, |valtype|)
@@ -375,7 +375,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
             1. Let [=external value|𝖿𝗎𝗇𝖼=] |funcaddr| be |externval|.
             1. Let |func| be the result of creating [=a new Exported Function=] from |funcaddr|.
             1. Let |value| be |func|.
-        1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] |globaltype|,
+        1. If |externtype| is of the form [=𝗀𝗅𝗈𝖻𝖺𝗅=] <var ignore>globaltype</var>,
             1. Assert: |externval| is of the form [=external value|𝗀𝗅𝗈𝖻𝖺𝗅=] |globaladdr|.
             1. Let [=external value|𝗀𝗅𝗈𝖻𝖺𝗅=] |globaladdr| be |externval|.
             1. Let |global| be [=create a global object|a new Global object=] created from |globaladdr|.
@@ -496,7 +496,7 @@ interface Module {
     The <dfn method for="Module">customSections(|moduleObject|, |sectionName|)</dfn> method, when invoked, performs the following steps:
     1. Let |bytes| be |moduleObject|.\[[Bytes]].
     1. Let |customSections| be an empty [=list=] of {{ArrayBuffer}}s.
-    1. For each [=custom section=] |customSection| in the binary format of |bytes|,
+    1. For each [=custom section=] <var ignore>customSection</var> in the binary format of |bytes|,
         1. Let |name| be the <code>name</code> of the custom section, [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
         1. Assert: |name| is not failure (|moduleObject|.\[[Module]] is [=valid=]).
         1. If |name| equals |sectionName| as string values,
@@ -785,7 +785,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Let |store| be the current agent's [=associated store=].
     1. Let |globaladdr| be |global|.\[[Global]].
     1. Let |globaltype| be [=type_global=](|store|, |globaladdr|).
-    1. If |globaltype| is of the form |mut| [=𝗂𝟨𝟦=], throw a {{TypeError}}.
+    1. If |globaltype| is of the form <var ignore>mut</var> [=𝗂𝟨𝟦=], throw a {{TypeError}}.
     1. Let |value| be [=read_global=](|store|, |globaladdr|).
     1. Return [=ToJSValue=](|value|).
 </div>
@@ -825,7 +825,7 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
 
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |funcinst| be |store|.𝖿𝗎𝗇𝖼𝗌[|funcaddr|].
-    1. If |funcinst| is of the form {𝗍𝗒𝗉𝖾 |functype|, 𝗁𝗈𝗌𝗍𝖼𝗈𝖽𝖾 |hostfunc|},
+    1. If |funcinst| is of the form {𝗍𝗒𝗉𝖾 <var ignore>functype</var>, 𝗁𝗈𝗌𝗍𝖼𝗈𝖽𝖾 |hostfunc|},
         1. Assert: |hostfunc| is a JavaScript object and [=IsCallable=](|hostfunc|) is true.
         1. Let |index| be the [=index of the host function=] |funcaddr|.
     1. Otherwise,
@@ -847,7 +847,7 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
     1. Set |function|.\[[FunctionAddress]] to |funcaddr|.
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |functype| be [=type_func=](|store|, |funcaddr|).
-    1. Let [|paramTypes|] → [|resultTypes|] be |functype|.
+    1. Let [|paramTypes|] → [<var ignore>resultTypes</var>] be |functype|.
     1. Let |arity| be the length of |paramTypes|.
     1. Perform ! [=SetFunctionLength=](|function|, |arity|).
     1. Let |name| be the [=name of the WebAssembly function=] |funcaddr|.
@@ -894,7 +894,7 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
         1. For each |arg| in |arguments|,
             1. [=Append=] [=ToJSValue=](|arg|) to |jsArguments|.
         1. Let |ret| be ? [=Call=](|func|, undefined, |jsArguments|). If an exception is thrown, trigger a WebAssembly trap, and propagate the exception to the enclosing JavaScript.
-        1. Let [|parameters|] → [|results|] be |functype|.
+        1. Let [<var ignore>parameters</var>] → [|results|] be |functype|.
         1. If |results| is empty, return undefined.
         1. Otherwise, return [=ToWebAssemblyValue=](|ret|, |results|[0]).
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
@@ -906,7 +906,7 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
 <div algorithm>
 The algorithm <dfn>ToJSValue</dfn>(|w|) coerces a [=WebAssembly value=] to a JavaScript value performs the following steps:
 
-Assert: |w| is not of the form [=𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] |i64|.
+Assert: |w| is not of the form [=𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] <var ignore>i64</var>.
 1. If |w| is of the form [=𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |i32|, return [=the Number value=] for [=signed_32=](|i32|).
 1. If |w| is of the form [=𝖿𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |f32|, return [=the Number value=] for |f32|.
 1. If |w| is of the form [=𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] |f64|, return [=the Number value=] for |f64|.

From 43a294af6cf6573f90784fbb7fda2527a9aca266 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Fri, 22 Jun 2018 17:42:48 +0200
Subject: [PATCH 250/329] Add a missing definition of "store".

---
 document/js-api/index.bs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 60d0f4408..1c5b6d23c 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -652,6 +652,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Let |map| be the [=surrounding agent=]'s associated [=Table object cache=].
     1. If |map|[|tableaddr|] [=map/exists=],
         1. Return |map|[|tableaddr|].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |values| be a list whose length is [=size_table=](|store|, |tableaddr|) where each element is null.
     1. Let |table| be a new {{Table}} instance with \[[Table]] set to |tableaddr| and \[[Values]] set to |values|.
     1. [=map/Set=] |map|[|tableaddr|] to |table|.

From c83624a0d6e21605e2bb1268056912a8ceaf035b Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Fri, 22 Jun 2018 17:42:57 +0200
Subject: [PATCH 251/329] Avoid undefined variable "retArity".

---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 1c5b6d23c..c41a7e6fa 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -877,7 +877,7 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
     1. Let (|store|, |ret|) be the result of [=invoke_func=](|store|, |funcaddr|, |args|).
     1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
     1. If |ret| is [=error=], throw an exception. This exception should be a WebAssembly {{RuntimeError}} exception, unless otherwise indicated by <a href="#errors">the WebAssembly error mapping</a>.
-    1. If |outArity| is 0, return undefined.
+    1. If |ret| is empty, return undefined.
     1. Otherwise, return [=ToJSValue=](|v|), where |v| is the singular element of |ret|.
 </div>
 

From e7b6cdcb2637caa1f45da55e3864f342d0d10f0a Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Thu, 28 Jun 2018 11:38:32 +0200
Subject: [PATCH 252/329] Add missing right guillemet.

---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index c41a7e6fa..e0ad98ec2 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -844,7 +844,7 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
         1. Return |map|[|funcaddr|].
     1. Let |steps| be "[=call an Exported Function|call the Exported Function=] |funcaddr| with arguments."
     1. Let |realm| be the [=current Realm=].
-    1. Let |function| be [=CreateBuiltinFunction=](|realm|, |steps|, [=%FunctionPrototype%=], &laquo; \[[FunctionAddress]]).
+    1. Let |function| be [=CreateBuiltinFunction=](|realm|, |steps|, [=%FunctionPrototype%=], &laquo; \[[FunctionAddress]] &raquo;).
     1. Set |function|.\[[FunctionAddress]] to |funcaddr|.
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let |functype| be [=type_func=](|store|, |funcaddr|).

From 0fa590454e93aae356a58c68ad58e6c289551e39 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Thu, 28 Jun 2018 11:38:49 +0200
Subject: [PATCH 253/329] Mark a variable 'i' as such.

---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index e0ad98ec2..497cc2764 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -870,7 +870,7 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
     5. Let |args| be an empty list of WebAssembly values.
     1. Let |i| be 0.
     1. For each type |t| of |parameters|,
-        1. If the length of |argValues| &gt; |i|, let |arg| be |argValues|[i].
+        1. If the length of |argValues| &gt; |i|, let |arg| be |argValues|[|i|].
         1. Otherwise, let |arg| be undefined.
         1. [=Append=] [=ToWebAssemblyValue=](|arg|, |t|) to |args|.
         1. Set |i| to |i| + 1.

From bca1718f6a974453c0e35df94b220bd83cc85be8 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Fri, 29 Jun 2018 11:00:14 +0200
Subject: [PATCH 254/329] Fix a link markup error.

---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 497cc2764..10a84bcfd 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -339,7 +339,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
                 1. Let |value| be [=ToWebAssemblyValue=](|v|, |valtype|)
                 1. Let |store| be the [=surrounding agent=]'s [=associated store=].
                 1. Let (|store|, |globaladdr|) be [=alloc_global=](|store|, [=const=] |valtype|, |value|).
-                1. Set the [[surrounding agent=]'s [=associated store=] to |store|.
+                1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
             1. If |v| is a {{Global}} instance,
                 1. Let |globaladdr| be |v|.\[[Global]]
             1. Otherwise,

From 4916530c6aa90641bbe287844b31b49647b2ac8c Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Mon, 9 Jul 2018 15:42:34 +0200
Subject: [PATCH 255/329] Fix Bikeshed pedantry

---
 document/web-api/index.bs | 10 +++-------
 1 file changed, 3 insertions(+), 7 deletions(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index e0f0135f6..fe3c3ed39 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -141,13 +141,11 @@ Web user agents must augment the {{Module}} interface with the <code>[<a extende
 
 The [=serialization steps=], given |value|, |serialized|, and |forStorage|, are:
 
-    1. If |forStorage| is true, throw a
-        "<a exception>DataCloneError</a>" {{DOMException}}
+    1. If |forStorage| is true, throw a "<a exception>DataCloneError</a>" {{DOMException}}
 
     1. Set |serialized|.\[[Bytes]] to the [=sub-serialization=] of |value|.\[[Bytes]].
 
-    1. Set |serialized|.\[[AgentCluster]] to the
-       [=current Realm=]'s corresponding [=agent cluster=].
+    1. Set |serialized|.\[[AgentCluster]] to the [=current Realm=]'s corresponding [=agent cluster=].
 
 The [=deserialization steps=], given |serialized| and |value|, are:
 
@@ -155,9 +153,7 @@ The [=deserialization steps=], given |serialized| and |value|, are:
 
     1. Set |value|.\[[Bytes]] to |bytes|.
 
-    1. If |targetRealm|'s corresponding [=agent cluster=] is not
-        |serialized|.\[[AgentCluster]], then throw a
-        "<a exception>DataCloneError</a>" {{DOMException}}.
+    1. If |targetRealm|'s corresponding [=agent cluster=] is not |serialized|.\[[AgentCluster]], then throw a "<a exception>DataCloneError</a>" {{DOMException}}.
 
     1. [=Compile a WebAssembly module=] from |bytes| and set |value|.\[[Module]] to the result.
 

From 80dec6f17a8ed4ec204df4234eddc4dd39ecb605 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Mon, 9 Jul 2018 21:44:55 +0800
Subject: [PATCH 256/329] [test] Enhance test coverage of address.wast (#832)

---
 test/core/address.wast | 628 ++++++++++++++++++++++++++++++++++++-----
 1 file changed, 557 insertions(+), 71 deletions(-)

diff --git a/test/core/address.wast b/test/core/address.wast
index ee2a6bb39..134d2dab3 100644
--- a/test/core/address.wast
+++ b/test/core/address.wast
@@ -1,98 +1,207 @@
+;; Load i32 data with different offset/align arguments
+
 (module
   (memory 1)
   (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz")
 
-  (func (export "good1") (param $i i32) (result i32)
-    (i32.load8_u offset=0 (get_local $i))  ;; 97 'a'
+  (func (export "8u_good1") (param $i i32) (result i32)
+    (i32.load8_u offset=0 (get_local $i))                   ;; 97 'a'
+  )
+  (func (export "8u_good2") (param $i i32) (result i32)
+    (i32.load8_u align=1 (get_local $i))                    ;; 97 'a'
+  )
+  (func (export "8u_good3") (param $i i32) (result i32)
+    (i32.load8_u offset=1 align=1 (get_local $i))           ;; 98 'b'
+  )
+  (func (export "8u_good4") (param $i i32) (result i32)
+    (i32.load8_u offset=2 align=1 (get_local $i))           ;; 99 'c'
+  )
+  (func (export "8u_good5") (param $i i32) (result i32)
+    (i32.load8_u offset=25 align=1 (get_local $i))          ;; 122 'z'
+  )
+
+  (func (export "8s_good1") (param $i i32) (result i32)
+    (i32.load8_s offset=0 (get_local $i))                   ;; 97 'a'
+  )
+  (func (export "8s_good2") (param $i i32) (result i32)
+    (i32.load8_s align=1 (get_local $i))                    ;; 97 'a'
   )
-  (func (export "good2") (param $i i32) (result i32)
-    (i32.load8_u offset=1 (get_local $i))  ;; 98 'b'
+  (func (export "8s_good3") (param $i i32) (result i32)
+    (i32.load8_s offset=1 align=1 (get_local $i))           ;; 98 'b'
   )
-  (func (export "good3") (param $i i32) (result i32)
-    (i32.load8_u offset=2 (get_local $i))  ;; 99 'c'
+  (func (export "8s_good4") (param $i i32) (result i32)
+    (i32.load8_s offset=2 align=1 (get_local $i))           ;; 99 'c'
   )
-  (func (export "good4") (param $i i32) (result i32)
-    (i32.load8_u offset=25 (get_local $i)) ;; 122 'z'
+  (func (export "8s_good5") (param $i i32) (result i32)
+    (i32.load8_s offset=25 align=1 (get_local $i))          ;; 122 'z'
   )
 
-  (func (export "good5") (param $i i32) (result i32)
-    (i32.load16_u offset=0 (get_local $i))          ;; 25185 'ab'
+  (func (export "16u_good1") (param $i i32) (result i32)
+    (i32.load16_u offset=0 (get_local $i))                  ;; 25185 'ab'
   )
-  (func (export "good6") (param $i i32) (result i32)
-    (i32.load16_u align=1 (get_local $i))           ;; 25185 'ab'
+  (func (export "16u_good2") (param $i i32) (result i32)
+    (i32.load16_u align=1 (get_local $i))                   ;; 25185 'ab'
   )
-  (func (export "good7") (param $i i32) (result i32)
-    (i32.load16_u offset=1 align=1 (get_local $i))  ;; 25442 'bc'
+  (func (export "16u_good3") (param $i i32) (result i32)
+    (i32.load16_u offset=1 align=1 (get_local $i))          ;; 25442 'bc'
   )
-  (func (export "good8") (param $i i32) (result i32)
-    (i32.load16_u offset=2 (get_local $i))          ;; 25699 'cd'
+  (func (export "16u_good4") (param $i i32) (result i32)
+    (i32.load16_u offset=2 align=2 (get_local $i))          ;; 25699 'cd'
   )
-  (func (export "good9") (param $i i32) (result i32)
-    (i32.load16_u offset=25 align=1 (get_local $i)) ;; 122 'z\0'
+  (func (export "16u_good5") (param $i i32) (result i32)
+    (i32.load16_u offset=25 align=2 (get_local $i))         ;; 122 'z\0'
   )
 
-  (func (export "good10") (param $i i32) (result i32)
-    (i32.load offset=0 (get_local $i))          ;; 1684234849 'abcd'
+  (func (export "16s_good1") (param $i i32) (result i32)
+    (i32.load16_s offset=0 (get_local $i))                  ;; 25185 'ab'
   )
-  (func (export "good11") (param $i i32) (result i32)
-    (i32.load offset=1 align=1 (get_local $i))  ;; 1701077858 'bcde'
+  (func (export "16s_good2") (param $i i32) (result i32)
+    (i32.load16_s align=1 (get_local $i))                   ;; 25185 'ab'
   )
-  (func (export "good12") (param $i i32) (result i32)
-    (i32.load offset=2 align=2 (get_local $i))  ;; 1717920867 'cdef'
+  (func (export "16s_good3") (param $i i32) (result i32)
+    (i32.load16_s offset=1 align=1 (get_local $i))          ;; 25442 'bc'
   )
-  (func (export "good13") (param $i i32) (result i32)
-    (i32.load offset=25 align=1 (get_local $i)) ;; 122 'z\0\0\0'
+  (func (export "16s_good4") (param $i i32) (result i32)
+    (i32.load16_s offset=2 align=2 (get_local $i))          ;; 25699 'cd'
+  )
+  (func (export "16s_good5") (param $i i32) (result i32)
+    (i32.load16_s offset=25 align=2 (get_local $i))         ;; 122 'z\0'
   )
 
-  (func (export "bad") (param $i i32)
+  (func (export "32_good1") (param $i i32) (result i32)
+    (i32.load offset=0 (get_local $i))                      ;; 1684234849 'abcd'
+  )
+  (func (export "32_good2") (param $i i32) (result i32)
+    (i32.load align=1 (get_local $i))                       ;; 1684234849 'abcd'
+  )
+  (func (export "32_good3") (param $i i32) (result i32)
+    (i32.load offset=1 align=1 (get_local $i))              ;; 1701077858 'bcde'
+  )
+  (func (export "32_good4") (param $i i32) (result i32)
+    (i32.load offset=2 align=2 (get_local $i))              ;; 1717920867 'cdef'
+  )
+  (func (export "32_good5") (param $i i32) (result i32)
+    (i32.load offset=25 align=4 (get_local $i))             ;; 122 'z\0\0\0'
+  )
+
+  (func (export "8u_bad") (param $i i32)
+    (drop (i32.load8_u offset=4294967295 (get_local $i)))
+  )
+  (func (export "8s_bad") (param $i i32)
+    (drop (i32.load8_s offset=4294967295 (get_local $i)))
+  )
+  (func (export "16u_bad") (param $i i32)
+    (drop (i32.load16_u offset=4294967295 (get_local $i)))
+  )
+  (func (export "16s_bad") (param $i i32)
+    (drop (i32.load16_s offset=4294967295 (get_local $i)))
+  )
+  (func (export "32_bad") (param $i i32)
     (drop (i32.load offset=4294967295 (get_local $i)))
   )
 )
 
-(assert_return (invoke "good1" (i32.const 0)) (i32.const 97))
-(assert_return (invoke "good2" (i32.const 0)) (i32.const 98))
-(assert_return (invoke "good3" (i32.const 0)) (i32.const 99))
-(assert_return (invoke "good4" (i32.const 0)) (i32.const 122))
-(assert_return (invoke "good5" (i32.const 0)) (i32.const 25185))
-(assert_return (invoke "good6" (i32.const 0)) (i32.const 25185))
-(assert_return (invoke "good7" (i32.const 0)) (i32.const 25442))
-(assert_return (invoke "good8" (i32.const 0)) (i32.const 25699))
-(assert_return (invoke "good9" (i32.const 0)) (i32.const 122))
-(assert_return (invoke "good10" (i32.const 0)) (i32.const 1684234849))
-(assert_return (invoke "good11" (i32.const 0)) (i32.const 1701077858))
-(assert_return (invoke "good12" (i32.const 0)) (i32.const 1717920867))
-(assert_return (invoke "good13" (i32.const 0)) (i32.const 122))
-
-(assert_return (invoke "good1" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good2" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good3" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good4" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good5" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good6" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good7" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good8" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good9" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good10" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good11" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good12" (i32.const 65507)) (i32.const 0))
-(assert_return (invoke "good13" (i32.const 65507)) (i32.const 0))
-
-(assert_return (invoke "good1" (i32.const 65508)) (i32.const 0))
-(assert_return (invoke "good2" (i32.const 65508)) (i32.const 0))
-(assert_return (invoke "good3" (i32.const 65508)) (i32.const 0))
-(assert_return (invoke "good4" (i32.const 65508)) (i32.const 0))
-(assert_return (invoke "good5" (i32.const 65508)) (i32.const 0))
-(assert_return (invoke "good6" (i32.const 65508)) (i32.const 0))
-(assert_return (invoke "good7" (i32.const 65508)) (i32.const 0))
-(assert_return (invoke "good8" (i32.const 65508)) (i32.const 0))
-(assert_return (invoke "good9" (i32.const 65508)) (i32.const 0))
-(assert_return (invoke "good10" (i32.const 65508)) (i32.const 0))
-(assert_return (invoke "good11" (i32.const 65508)) (i32.const 0))
-(assert_return (invoke "good12" (i32.const 65508)) (i32.const 0))
-(assert_trap (invoke "good13" (i32.const 65508)) "out of bounds memory access")
-
-(assert_trap (invoke "bad" (i32.const 0)) "out of bounds memory access")
-(assert_trap (invoke "bad" (i32.const 1)) "out of bounds memory access")
+(assert_return (invoke "8u_good1" (i32.const 0)) (i32.const 97))
+(assert_return (invoke "8u_good2" (i32.const 0)) (i32.const 97))
+(assert_return (invoke "8u_good3" (i32.const 0)) (i32.const 98))
+(assert_return (invoke "8u_good4" (i32.const 0)) (i32.const 99))
+(assert_return (invoke "8u_good5" (i32.const 0)) (i32.const 122))
+
+(assert_return (invoke "8s_good1" (i32.const 0)) (i32.const 97))
+(assert_return (invoke "8s_good2" (i32.const 0)) (i32.const 97))
+(assert_return (invoke "8s_good3" (i32.const 0)) (i32.const 98))
+(assert_return (invoke "8s_good4" (i32.const 0)) (i32.const 99))
+(assert_return (invoke "8s_good5" (i32.const 0)) (i32.const 122))
+
+(assert_return (invoke "16u_good1" (i32.const 0)) (i32.const 25185))
+(assert_return (invoke "16u_good2" (i32.const 0)) (i32.const 25185))
+(assert_return (invoke "16u_good3" (i32.const 0)) (i32.const 25442))
+(assert_return (invoke "16u_good4" (i32.const 0)) (i32.const 25699))
+(assert_return (invoke "16u_good5" (i32.const 0)) (i32.const 122))
+
+(assert_return (invoke "16s_good1" (i32.const 0)) (i32.const 25185))
+(assert_return (invoke "16s_good2" (i32.const 0)) (i32.const 25185))
+(assert_return (invoke "16s_good3" (i32.const 0)) (i32.const 25442))
+(assert_return (invoke "16s_good4" (i32.const 0)) (i32.const 25699))
+(assert_return (invoke "16s_good5" (i32.const 0)) (i32.const 122))
+
+(assert_return (invoke "32_good1" (i32.const 0)) (i32.const 1684234849))
+(assert_return (invoke "32_good2" (i32.const 0)) (i32.const 1684234849))
+(assert_return (invoke "32_good3" (i32.const 0)) (i32.const 1701077858))
+(assert_return (invoke "32_good4" (i32.const 0)) (i32.const 1717920867))
+(assert_return (invoke "32_good5" (i32.const 0)) (i32.const 122))
+
+(assert_return (invoke "8u_good1" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8u_good2" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8u_good3" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8u_good4" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8u_good5" (i32.const 65507)) (i32.const 0))
+
+(assert_return (invoke "8s_good1" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8s_good2" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8s_good3" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8s_good4" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "8s_good5" (i32.const 65507)) (i32.const 0))
+
+(assert_return (invoke "16u_good1" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16u_good2" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16u_good3" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16u_good4" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16u_good5" (i32.const 65507)) (i32.const 0))
+
+(assert_return (invoke "16s_good1" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16s_good2" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16s_good3" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16s_good4" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "16s_good5" (i32.const 65507)) (i32.const 0))
+
+(assert_return (invoke "32_good1" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "32_good2" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "32_good3" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "32_good4" (i32.const 65507)) (i32.const 0))
+(assert_return (invoke "32_good5" (i32.const 65507)) (i32.const 0))
+
+(assert_return (invoke "8u_good1" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8u_good2" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8u_good3" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8u_good4" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8u_good5" (i32.const 65508)) (i32.const 0))
+
+(assert_return (invoke "8s_good1" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8s_good2" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8s_good3" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8s_good4" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "8s_good5" (i32.const 65508)) (i32.const 0))
+
+(assert_return (invoke "16u_good1" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16u_good2" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16u_good3" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16u_good4" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16u_good5" (i32.const 65508)) (i32.const 0))
+
+(assert_return (invoke "16s_good1" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16s_good2" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16s_good3" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16s_good4" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "16s_good5" (i32.const 65508)) (i32.const 0))
+
+(assert_return (invoke "32_good1" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "32_good2" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "32_good3" (i32.const 65508)) (i32.const 0))
+(assert_return (invoke "32_good4" (i32.const 65508)) (i32.const 0))
+(assert_trap (invoke "32_good5" (i32.const 65508)) "out of bounds memory access")
+
+(assert_trap (invoke "8u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "8s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "16u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "16s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "32_bad" (i32.const 0)) "out of bounds memory access")
+
+(assert_trap (invoke "8u_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "8s_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "16u_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "16s_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "32_bad" (i32.const 1)) "out of bounds memory access")
 
 (assert_malformed
   (module quote
@@ -101,3 +210,380 @@
   )
   "i32 constant"
 )
+
+;; Load i64 data with different offset/align arguments
+
+(module
+  (memory 1)
+  (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz")
+
+  (func (export "8u_good1") (param $i i32) (result i64)
+    (i64.load8_u offset=0 (get_local $i))                   ;; 97 'a'
+  )
+  (func (export "8u_good2") (param $i i32) (result i64)
+    (i64.load8_u align=1 (get_local $i))                    ;; 97 'a'
+  )
+  (func (export "8u_good3") (param $i i32) (result i64)
+    (i64.load8_u offset=1 align=1 (get_local $i))           ;; 98 'b'
+  )
+  (func (export "8u_good4") (param $i i32) (result i64)
+    (i64.load8_u offset=2 align=1 (get_local $i))           ;; 99 'c'
+  )
+  (func (export "8u_good5") (param $i i32) (result i64)
+    (i64.load8_u offset=25 align=1 (get_local $i))          ;; 122 'z'
+  )
+
+  (func (export "8s_good1") (param $i i32) (result i64)
+    (i64.load8_s offset=0 (get_local $i))                   ;; 97 'a'
+  )
+  (func (export "8s_good2") (param $i i32) (result i64)
+    (i64.load8_s align=1 (get_local $i))                    ;; 97 'a'
+  )
+  (func (export "8s_good3") (param $i i32) (result i64)
+    (i64.load8_s offset=1 align=1 (get_local $i))           ;; 98 'b'
+  )
+  (func (export "8s_good4") (param $i i32) (result i64)
+    (i64.load8_s offset=2 align=1 (get_local $i))           ;; 99 'c'
+  )
+  (func (export "8s_good5") (param $i i32) (result i64)
+    (i64.load8_s offset=25 align=1 (get_local $i))          ;; 122 'z'
+  )
+
+  (func (export "16u_good1") (param $i i32) (result i64)
+    (i64.load16_u offset=0 (get_local $i))                 ;; 25185 'ab'
+  )
+  (func (export "16u_good2") (param $i i32) (result i64)
+    (i64.load16_u align=1 (get_local $i))                  ;; 25185 'ab'
+  )
+  (func (export "16u_good3") (param $i i32) (result i64)
+    (i64.load16_u offset=1 align=1 (get_local $i))         ;; 25442 'bc'
+  )
+  (func (export "16u_good4") (param $i i32) (result i64)
+    (i64.load16_u offset=2 align=2 (get_local $i))         ;; 25699 'cd'
+  )
+  (func (export "16u_good5") (param $i i32) (result i64)
+    (i64.load16_u offset=25 align=2 (get_local $i))        ;; 122 'z\0'
+  )
+
+  (func (export "16s_good1") (param $i i32) (result i64)
+    (i64.load16_s offset=0 (get_local $i))                 ;; 25185 'ab'
+  )
+  (func (export "16s_good2") (param $i i32) (result i64)
+    (i64.load16_s align=1 (get_local $i))                  ;; 25185 'ab'
+  )
+  (func (export "16s_good3") (param $i i32) (result i64)
+    (i64.load16_s offset=1 align=1 (get_local $i))         ;; 25442 'bc'
+  )
+  (func (export "16s_good4") (param $i i32) (result i64)
+    (i64.load16_s offset=2 align=2 (get_local $i))         ;; 25699 'cd'
+  )
+  (func (export "16s_good5") (param $i i32) (result i64)
+    (i64.load16_s offset=25 align=2 (get_local $i))        ;; 122 'z\0'
+  )
+
+  (func (export "32u_good1") (param $i i32) (result i64)
+    (i64.load32_u offset=0 (get_local $i))                 ;; 1684234849 'abcd'
+  )
+  (func (export "32u_good2") (param $i i32) (result i64)
+    (i64.load32_u align=1 (get_local $i))                  ;; 1684234849 'abcd'
+  )
+  (func (export "32u_good3") (param $i i32) (result i64)
+    (i64.load32_u offset=1 align=1 (get_local $i))         ;; 1701077858 'bcde'
+  )
+  (func (export "32u_good4") (param $i i32) (result i64)
+    (i64.load32_u offset=2 align=2 (get_local $i))         ;; 1717920867 'cdef'
+  )
+  (func (export "32u_good5") (param $i i32) (result i64)
+    (i64.load32_u offset=25 align=4 (get_local $i))        ;; 122 'z\0\0\0'
+  )
+
+  (func (export "32s_good1") (param $i i32) (result i64)
+    (i64.load32_s offset=0 (get_local $i))                 ;; 1684234849 'abcd'
+  )
+  (func (export "32s_good2") (param $i i32) (result i64)
+    (i64.load32_s align=1 (get_local $i))                  ;; 1684234849 'abcd'
+  )
+  (func (export "32s_good3") (param $i i32) (result i64)
+    (i64.load32_s offset=1 align=1 (get_local $i))         ;; 1701077858 'bcde'
+  )
+  (func (export "32s_good4") (param $i i32) (result i64)
+    (i64.load32_s offset=2 align=2 (get_local $i))         ;; 1717920867 'cdef'
+  )
+  (func (export "32s_good5") (param $i i32) (result i64)
+    (i64.load32_s offset=25 align=4 (get_local $i))        ;; 122 'z\0\0\0'
+  )
+
+  (func (export "64_good1") (param $i i32) (result i64)
+    (i64.load offset=0 (get_local $i))                     ;; 0x6867666564636261 'abcdefgh'
+  )
+  (func (export "64_good2") (param $i i32) (result i64)
+    (i64.load align=1 (get_local $i))                      ;; 0x6867666564636261 'abcdefgh'
+  )
+  (func (export "64_good3") (param $i i32) (result i64)
+    (i64.load offset=1 align=1 (get_local $i))             ;; 0x6968676665646362 'bcdefghi'
+  )
+  (func (export "64_good4") (param $i i32) (result i64)
+    (i64.load offset=2 align=2 (get_local $i))             ;; 0x6a69686766656463 'cdefghij'
+  )
+  (func (export "64_good5") (param $i i32) (result i64)
+    (i64.load offset=25 align=8 (get_local $i))            ;; 122 'z\0\0\0\0\0\0\0'
+  )
+
+  (func (export "8u_bad") (param $i i32)
+    (drop (i64.load8_u offset=4294967295 (get_local $i)))
+  )
+  (func (export "8s_bad") (param $i i32)
+    (drop (i64.load8_s offset=4294967295 (get_local $i)))
+  )
+  (func (export "16u_bad") (param $i i32)
+    (drop (i64.load16_u offset=4294967295 (get_local $i)))
+  )
+  (func (export "16s_bad") (param $i i32)
+    (drop (i64.load16_s offset=4294967295 (get_local $i)))
+  )
+  (func (export "32u_bad") (param $i i32)
+    (drop (i64.load32_u offset=4294967295 (get_local $i)))
+  )
+  (func (export "32s_bad") (param $i i32)
+    (drop (i64.load32_s offset=4294967295 (get_local $i)))
+  )
+  (func (export "64_bad") (param $i i32)
+    (drop (i64.load offset=4294967295 (get_local $i)))
+  )
+)
+
+(assert_return (invoke "8u_good1" (i32.const 0)) (i64.const 97))
+(assert_return (invoke "8u_good2" (i32.const 0)) (i64.const 97))
+(assert_return (invoke "8u_good3" (i32.const 0)) (i64.const 98))
+(assert_return (invoke "8u_good4" (i32.const 0)) (i64.const 99))
+(assert_return (invoke "8u_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "8s_good1" (i32.const 0)) (i64.const 97))
+(assert_return (invoke "8s_good2" (i32.const 0)) (i64.const 97))
+(assert_return (invoke "8s_good3" (i32.const 0)) (i64.const 98))
+(assert_return (invoke "8s_good4" (i32.const 0)) (i64.const 99))
+(assert_return (invoke "8s_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "16u_good1" (i32.const 0)) (i64.const 25185))
+(assert_return (invoke "16u_good2" (i32.const 0)) (i64.const 25185))
+(assert_return (invoke "16u_good3" (i32.const 0)) (i64.const 25442))
+(assert_return (invoke "16u_good4" (i32.const 0)) (i64.const 25699))
+(assert_return (invoke "16u_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "16s_good1" (i32.const 0)) (i64.const 25185))
+(assert_return (invoke "16s_good2" (i32.const 0)) (i64.const 25185))
+(assert_return (invoke "16s_good3" (i32.const 0)) (i64.const 25442))
+(assert_return (invoke "16s_good4" (i32.const 0)) (i64.const 25699))
+(assert_return (invoke "16s_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "32u_good1" (i32.const 0)) (i64.const 1684234849))
+(assert_return (invoke "32u_good2" (i32.const 0)) (i64.const 1684234849))
+(assert_return (invoke "32u_good3" (i32.const 0)) (i64.const 1701077858))
+(assert_return (invoke "32u_good4" (i32.const 0)) (i64.const 1717920867))
+(assert_return (invoke "32u_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "32s_good1" (i32.const 0)) (i64.const 1684234849))
+(assert_return (invoke "32s_good2" (i32.const 0)) (i64.const 1684234849))
+(assert_return (invoke "32s_good3" (i32.const 0)) (i64.const 1701077858))
+(assert_return (invoke "32s_good4" (i32.const 0)) (i64.const 1717920867))
+(assert_return (invoke "32s_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "64_good1" (i32.const 0)) (i64.const 0x6867666564636261))
+(assert_return (invoke "64_good2" (i32.const 0)) (i64.const 0x6867666564636261))
+(assert_return (invoke "64_good3" (i32.const 0)) (i64.const 0x6968676665646362))
+(assert_return (invoke "64_good4" (i32.const 0)) (i64.const 0x6a69686766656463))
+(assert_return (invoke "64_good5" (i32.const 0)) (i64.const 122))
+
+(assert_return (invoke "8u_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8u_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8u_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8u_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8u_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "8s_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8s_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8s_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8s_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "8s_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "16u_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16u_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16u_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16u_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16u_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "16s_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16s_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16s_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16s_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "16s_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "32u_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32u_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32u_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32u_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32u_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "32s_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32s_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32s_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32s_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "32s_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "64_good1" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "64_good2" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "64_good3" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "64_good4" (i32.const 65503)) (i64.const 0))
+(assert_return (invoke "64_good5" (i32.const 65503)) (i64.const 0))
+
+(assert_return (invoke "8u_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8u_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8u_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8u_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8u_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "8s_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8s_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8s_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8s_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "8s_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "16u_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16u_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16u_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16u_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16u_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "16s_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16s_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16s_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16s_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "16s_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "32u_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32u_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32u_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32u_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32u_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "32s_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32s_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32s_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32s_good4" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "32s_good5" (i32.const 65504)) (i64.const 0))
+
+(assert_return (invoke "64_good1" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "64_good2" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "64_good3" (i32.const 65504)) (i64.const 0))
+(assert_return (invoke "64_good4" (i32.const 65504)) (i64.const 0))
+(assert_trap (invoke "64_good5" (i32.const 65504)) "out of bounds memory access")
+
+(assert_trap (invoke "8u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "8s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "16u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "16s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "32u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "32s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "64_bad" (i32.const 0)) "out of bounds memory access")
+
+(assert_trap (invoke "8u_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "8s_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "16u_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "16s_bad" (i32.const 1)) "out of bounds memory access")
+(assert_trap (invoke "32u_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "32s_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "64_bad" (i32.const 1)) "out of bounds memory access")
+
+;; Load f32 data with different offset/align arguments
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\00\00\00\00\00\a0\7f\01\00\d0\7f")
+
+  (func (export "32_good1") (param $i i32) (result f32)
+    (f32.load offset=0 (get_local $i))                   ;; 0.0 '\00\00\00\00'
+  )
+  (func (export "32_good2") (param $i i32) (result f32)
+    (f32.load align=1 (get_local $i))                    ;; 0.0 '\00\00\00\00'
+  )
+  (func (export "32_good3") (param $i i32) (result f32)
+    (f32.load offset=1 align=1 (get_local $i))           ;; 0.0 '\00\00\00\00'
+  )
+  (func (export "32_good4") (param $i i32) (result f32)
+    (f32.load offset=2 align=2 (get_local $i))           ;; 0.0 '\00\00\00\00'
+  )
+  (func (export "32_good5") (param $i i32) (result f32)
+    (f32.load offset=8 align=4 (get_local $i))           ;; nan:0x500001 '\01\00\d0\7f'
+  )
+  (func (export "32_bad") (param $i i32)
+    (drop (f32.load offset=4294967295 (get_local $i)))
+  )
+)
+
+(assert_return (invoke "32_good1" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "32_good2" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "32_good3" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "32_good4" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "32_good5" (i32.const 0)) (f32.const nan:0x500001))
+
+(assert_return (invoke "32_good1" (i32.const 65524)) (f32.const 0.0))
+(assert_return (invoke "32_good2" (i32.const 65524)) (f32.const 0.0))
+(assert_return (invoke "32_good3" (i32.const 65524)) (f32.const 0.0))
+(assert_return (invoke "32_good4" (i32.const 65524)) (f32.const 0.0))
+(assert_return (invoke "32_good5" (i32.const 65524)) (f32.const 0.0))
+
+(assert_return (invoke "32_good1" (i32.const 65525)) (f32.const 0.0))
+(assert_return (invoke "32_good2" (i32.const 65525)) (f32.const 0.0))
+(assert_return (invoke "32_good3" (i32.const 65525)) (f32.const 0.0))
+(assert_return (invoke "32_good4" (i32.const 65525)) (f32.const 0.0))
+(assert_trap (invoke "32_good5" (i32.const 65525)) "out of bounds memory access")
+
+(assert_trap (invoke "32_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "32_bad" (i32.const 1)) "out of bounds memory access")
+
+;; Load f64 data with different offset/align arguments
+
+(module
+  (memory 1)
+  (data (i32.const 0) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\f4\7f\01\00\00\00\00\00\fc\7f")
+
+  (func (export "64_good1") (param $i i32) (result f64)
+    (f64.load offset=0 (get_local $i))                     ;; 0.0 '\00\00\00\00\00\00\00\00'
+  )
+  (func (export "64_good2") (param $i i32) (result f64)
+    (f64.load align=1 (get_local $i))                      ;; 0.0 '\00\00\00\00\00\00\00\00'
+  )
+  (func (export "64_good3") (param $i i32) (result f64)
+    (f64.load offset=1 align=1 (get_local $i))             ;; 0.0 '\00\00\00\00\00\00\00\00'
+  )
+  (func (export "64_good4") (param $i i32) (result f64)
+    (f64.load offset=2 align=2 (get_local $i))             ;; 0.0 '\00\00\00\00\00\00\00\00'
+  )
+  (func (export "64_good5") (param $i i32) (result f64)
+    (f64.load offset=18 align=8 (get_local $i))            ;; nan:0xc000000000001 '\01\00\00\00\00\00\fc\7f'
+  )
+  (func (export "64_bad") (param $i i32)
+    (drop (f64.load offset=4294967295 (get_local $i)))
+  )
+)
+
+(assert_return (invoke "64_good1" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "64_good2" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "64_good3" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "64_good4" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "64_good5" (i32.const 0)) (f64.const nan:0xc000000000001))
+
+(assert_return (invoke "64_good1" (i32.const 65510)) (f64.const 0.0))
+(assert_return (invoke "64_good2" (i32.const 65510)) (f64.const 0.0))
+(assert_return (invoke "64_good3" (i32.const 65510)) (f64.const 0.0))
+(assert_return (invoke "64_good4" (i32.const 65510)) (f64.const 0.0))
+(assert_return (invoke "64_good5" (i32.const 65510)) (f64.const 0.0))
+
+(assert_return (invoke "64_good1" (i32.const 65511)) (f64.const 0.0))
+(assert_return (invoke "64_good2" (i32.const 65511)) (f64.const 0.0))
+(assert_return (invoke "64_good3" (i32.const 65511)) (f64.const 0.0))
+(assert_return (invoke "64_good4" (i32.const 65511)) (f64.const 0.0))
+(assert_trap (invoke "64_good5" (i32.const 65511)) "out of bounds memory access")
+
+(assert_trap (invoke "64_bad" (i32.const 0)) "out of bounds memory access")
+(assert_trap (invoke "64_bad" (i32.const 1)) "out of bounds memory access")

From 9a18eb6787b26b803e59f9caffa716330f717925 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Mon, 9 Jul 2018 21:56:43 +0800
Subject: [PATCH 257/329] [test] Grow memory and verify that new allocated byte
 is zero (#808)

---
 test/Todo.md                                  |  2 --
 test/core/{resizing.wast => memory_grow.wast} | 35 +++++++++++++++++++
 2 files changed, 35 insertions(+), 2 deletions(-)
 rename test/core/{resizing.wast => memory_grow.wast} (63%)

diff --git a/test/Todo.md b/test/Todo.md
index 4a2831d70..18e954ded 100644
--- a/test/Todo.md
+++ b/test/Todo.md
@@ -4,8 +4,6 @@ have a link to an open issue/PR, or be obvious. Comments/corrections/additions
 welcome.
 
 Linear memory semantics:
- - test that newly allocated memory (program start and `memory.grow`) is zeroed
- - test that `memory.grow` does a full 32-bit unsigned check for page-size divisibility
  - test that load/store addreses are full int32 (or int64), and not OCaml int
  - test that when allocating 4GiB, accessing index -1 fails
  - test that too-big `memory.grow` fails appropriately
diff --git a/test/core/resizing.wast b/test/core/memory_grow.wast
similarity index 63%
rename from test/core/resizing.wast
rename to test/core/memory_grow.wast
index 183332efd..c7cd6dc69 100644
--- a/test/core/resizing.wast
+++ b/test/core/memory_grow.wast
@@ -58,3 +58,38 @@
 (assert_return (invoke "grow" (i32.const 0)) (i32.const 10))
 (assert_return (invoke "grow" (i32.const 1)) (i32.const -1))
 (assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1))
+
+;; Test that newly allocated memory (program start and memory.grow) is zeroed
+
+(module
+  (memory 1)
+  (func (export "grow") (param i32) (result i32)
+    (memory.grow (get_local 0))
+  )
+  (func (export "check-memory-zero") (param i32 i32) (result i32)
+    (local i32)
+    (set_local 2 (i32.const 1))
+    (block
+      (loop
+        (set_local 2 (i32.load8_u (get_local 0)))
+        (br_if 1 (i32.ne (get_local 2) (i32.const 0)))
+        (br_if 1 (i32.ge_u (get_local 0) (get_local 1)))
+        (set_local 0 (i32.add (get_local 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (get_local 0) (get_local 1)))
+      )
+    )
+    (get_local 2)
+  )
+)
+
+(assert_return (invoke "check-memory-zero" (i32.const 0) (i32.const 0xffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "check-memory-zero" (i32.const 0x10000) (i32.const 0x1_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "check-memory-zero" (i32.const 0x20000) (i32.const 0x2_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "check-memory-zero" (i32.const 0x30000) (i32.const 0x3_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 4))
+(assert_return (invoke "check-memory-zero" (i32.const 0x40000) (i32.const 0x4_ffff)) (i32.const 0))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 5))
+(assert_return (invoke "check-memory-zero" (i32.const 0x50000) (i32.const 0x5_ffff)) (i32.const 0))

From 03905dc8c245b0c661f6b76ceb0f361f8ce48313 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Mon, 9 Jul 2018 22:00:31 +0800
Subject: [PATCH 258/329] [test] Add tests for Alignment (#822)

- Fulfill the test coverage of Alignment section
 - Centralize alignment relative tests in one file
---
 test/core/align.wast  | 823 +++++++++++++++++++++++++++++++++++++++++-
 test/core/memory.wast |  93 -----
 2 files changed, 820 insertions(+), 96 deletions(-)

diff --git a/test/core/align.wast b/test/core/align.wast
index 133b501d7..90dbd53c8 100644
--- a/test/core/align.wast
+++ b/test/core/align.wast
@@ -1,3 +1,161 @@
+;; Test alignment annotation rules
+
+(module (memory 0) (func (drop (i32.load8_s align=1 (i32.const 0)))))
+(module (memory 0) (func (drop (i32.load8_u align=1 (i32.const 0)))))
+(module (memory 0) (func (drop (i32.load16_s align=2 (i32.const 0)))))
+(module (memory 0) (func (drop (i32.load16_u align=2 (i32.const 0)))))
+(module (memory 0) (func (drop (i32.load align=4 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load8_s align=1 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load8_u align=1 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load16_s align=2 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load16_u align=2 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load32_s align=4 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load32_u align=4 (i32.const 0)))))
+(module (memory 0) (func (drop (i64.load align=8 (i32.const 0)))))
+(module (memory 0) (func (drop (f32.load align=4 (i32.const 0)))))
+(module (memory 0) (func (drop (f64.load align=8 (i32.const 0)))))
+(module (memory 0) (func (i32.store8 align=1 (i32.const 0) (i32.const 1))))
+(module (memory 0) (func (i32.store16 align=2 (i32.const 0) (i32.const 1))))
+(module (memory 0) (func (i32.store align=4 (i32.const 0) (i32.const 1))))
+(module (memory 0) (func (i64.store8 align=1 (i32.const 0) (i64.const 1))))
+(module (memory 0) (func (i64.store16 align=2 (i32.const 0) (i64.const 1))))
+(module (memory 0) (func (i64.store32 align=4 (i32.const 0) (i64.const 1))))
+(module (memory 0) (func (i64.store align=8 (i32.const 0) (i64.const 1))))
+(module (memory 0) (func (f32.store align=4 (i32.const 0) (f32.const 1.0))))
+(module (memory 0) (func (f64.store align=8 (i32.const 0) (f64.const 1.0))))
+
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load8_s align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load8_s align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load8_u align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load8_u align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load16_s align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load16_s align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load16_u align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load16_u align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i32.load align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load8_s align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load8_s align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load8_u align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load8_u align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load16_s align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load16_s align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load16_u align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load16_u align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load32_s align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load32_s align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load32_u align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (i64.load32_u align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
 (assert_malformed
   (module quote
     "(module (memory 0) (func (drop (i64.load align=0 (i32.const 0)))))"
@@ -10,11 +168,103 @@
   )
   "alignment"
 )
-(assert_invalid
-  (module (memory 0) (func (drop (i64.load align=16 (i32.const 0)))))
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (f32.load align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (f32.load align=7 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (f64.load align=0 (i32.const 0)))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (drop (f64.load align=7 (i32.const 0)))))"
+  )
   "alignment"
 )
 
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store8 align=0 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store8 align=7 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store16 align=0 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store16 align=7 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store align=0 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i32.store align=7 (i32.const 0) (i32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store8 align=0 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store8 align=7 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store16 align=0 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store16 align=7 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store32 align=0 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (i64.store32 align=7 (i32.const 0) (i64.const 0))))"
+  )
+  "alignment"
+)
 (assert_malformed
   (module quote
     "(module (memory 0) (func (i64.store align=0 (i32.const 0) (i64.const 0))))"
@@ -23,11 +273,578 @@
 )
 (assert_malformed
   (module quote
-    "(module (memory 0) (func (i64.store align=5 (i32.const 0) (i64.const 0))))"
+    "(module (memory 0) (func (i64.store align=7 (i32.const 0) (i64.const 0))))"
   )
   "alignment"
 )
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (f32.store align=0 (i32.const 0) (f32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (f32.store align=7 (i32.const 0) (f32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (f64.store align=0 (i32.const 0) (f32.const 0))))"
+  )
+  "alignment"
+)
+(assert_malformed
+  (module quote
+    "(module (memory 0) (func (f64.store align=7 (i32.const 0) (f32.const 0))))"
+  )
+  "alignment"
+)
+
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load8_s align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load8_u align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load16_s align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load16_u align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i32.load align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load8_s align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load8_u align=2 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load16_s align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load16_u align=4 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load32_s align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load32_u align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (i64.load align=16 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (f32.load align=8 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (drop (f64.load align=16 (i32.const 0)))))
+  "alignment must not be larger than natural"
+)
+
+(assert_invalid
+  (module (memory 0) (func (i32.load8_s align=2 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i32.load8_u align=2 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i32.load16_s align=4 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i32.load16_u align=4 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i32.load align=8 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.load8_s align=2 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.load8_u align=2 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.load16_s align=4 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.load16_u align=4 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.load32_s align=8 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.load32_u align=8 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.load align=16 (i32.const 0))))
+  "alignment"
+)
+(assert_invalid
+  (module (memory 0) (func (f32.load align=8 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (f64.load align=16 (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+
+(assert_invalid
+  (module (memory 0) (func (i32.store8 align=2 (i32.const 0) (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i32.store16 align=4 (i32.const 0) (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i32.store align=8 (i32.const 0) (i32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.store8 align=2 (i32.const 0) (i64.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.store16 align=4 (i32.const 0) (i64.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (i64.store32 align=8 (i32.const 0) (i64.const 0))))
+  "alignment must not be larger than natural"
+)
 (assert_invalid
   (module (memory 0) (func (i64.store align=16 (i32.const 0) (i64.const 0))))
   "alignment"
 )
+(assert_invalid
+  (module (memory 0) (func (f32.store align=8 (i32.const 0) (f32.const 0))))
+  "alignment must not be larger than natural"
+)
+(assert_invalid
+  (module (memory 0) (func (f64.store align=16 (i32.const 0) (f32.const 0))))
+  "alignment must not be larger than natural"
+)
+
+;; Test aligned and unaligned read/write
+
+(module
+  (memory 1)
+
+  ;; $default: natural alignment, $1: align=1, $2: align=2, $4: align=4, $8: align=8
+
+  (func (export "f32_align_switch") (param i32) (result f32)
+    (local f32 f32)
+    (set_local 1 (f32.const 10.0))
+    (block $4
+      (block $2
+        (block $1
+          (block $default
+            (block $0
+              (br_table $0 $default $1 $2 $4 (get_local 0))
+            ) ;; 0
+            (f32.store (i32.const 0) (get_local 1))
+            (set_local 2 (f32.load (i32.const 0)))
+            (br $4)
+          ) ;; default
+          (f32.store align=1 (i32.const 0) (get_local 1))
+          (set_local 2 (f32.load align=1 (i32.const 0)))
+          (br $4)
+        ) ;; 1
+        (f32.store align=2 (i32.const 0) (get_local 1))
+        (set_local 2 (f32.load align=2 (i32.const 0)))
+        (br $4)
+      ) ;; 2
+      (f32.store align=4 (i32.const 0) (get_local 1))
+      (set_local 2 (f32.load align=4 (i32.const 0)))
+    ) ;; 4
+    (get_local 2)
+  )
+
+  (func (export "f64_align_switch") (param i32) (result f64)
+    (local f64 f64)
+    (set_local 1 (f64.const 10.0))
+    (block $8
+      (block $4
+        (block $2
+          (block $1
+            (block $default
+              (block $0
+                (br_table $0 $default $1 $2 $4 $8 (get_local 0))
+              ) ;; 0
+              (f64.store (i32.const 0) (get_local 1))
+              (set_local 2 (f64.load (i32.const 0)))
+              (br $8)
+            ) ;; default
+            (f64.store align=1 (i32.const 0) (get_local 1))
+            (set_local 2 (f64.load align=1 (i32.const 0)))
+            (br $8)
+          ) ;; 1
+          (f64.store align=2 (i32.const 0) (get_local 1))
+          (set_local 2 (f64.load align=2 (i32.const 0)))
+          (br $8)
+        ) ;; 2
+        (f64.store align=4 (i32.const 0) (get_local 1))
+        (set_local 2 (f64.load align=4 (i32.const 0)))
+        (br $8)
+      ) ;; 4
+      (f64.store align=8 (i32.const 0) (get_local 1))
+      (set_local 2 (f64.load align=8 (i32.const 0)))
+    ) ;; 8
+    (get_local 2)
+  )
+
+  ;; $8s: i32/i64.load8_s, $8u: i32/i64.load8_u, $16s: i32/i64.load16_s, $16u: i32/i64.load16_u, $32: i32.load
+  ;; $32s: i64.load32_s, $32u: i64.load32_u, $64: i64.load
+
+  (func (export "i32_align_switch") (param i32 i32) (result i32)
+    (local i32 i32)
+    (set_local 2 (i32.const 10))
+    (block $32
+      (block $16u
+        (block $16s
+          (block $8u
+            (block $8s
+              (block $0
+                (br_table $0 $8s $8u $16s $16u $32 (get_local 0))
+              ) ;; 0
+              (if (i32.eq (get_local 1) (i32.const 0))
+                (then
+                  (i32.store8 (i32.const 0) (get_local 2))
+                  (set_local 3 (i32.load8_s (i32.const 0)))
+                )
+              )
+              (if (i32.eq (get_local 1) (i32.const 1))
+                (then
+                  (i32.store8 align=1 (i32.const 0) (get_local 2))
+                  (set_local 3 (i32.load8_s align=1 (i32.const 0)))
+                )
+              )
+              (br $32)
+            ) ;; 8s
+            (if (i32.eq (get_local 1) (i32.const 0))
+              (then
+                (i32.store8 (i32.const 0) (get_local 2))
+                (set_local 3 (i32.load8_u (i32.const 0)))
+              )
+            )
+            (if (i32.eq (get_local 1) (i32.const 1))
+              (then
+                (i32.store8 align=1 (i32.const 0) (get_local 2))
+                (set_local 3 (i32.load8_u align=1 (i32.const 0)))
+              )
+            )
+            (br $32)
+          ) ;; 8u
+          (if (i32.eq (get_local 1) (i32.const 0))
+            (then
+              (i32.store16 (i32.const 0) (get_local 2))
+              (set_local 3 (i32.load16_s (i32.const 0)))
+            )
+          )
+          (if (i32.eq (get_local 1) (i32.const 1))
+            (then
+              (i32.store16 align=1 (i32.const 0) (get_local 2))
+              (set_local 3 (i32.load16_s align=1 (i32.const 0)))
+            )
+          )
+          (if (i32.eq (get_local 1) (i32.const 2))
+            (then
+              (i32.store16 align=2 (i32.const 0) (get_local 2))
+              (set_local 3 (i32.load16_s align=2 (i32.const 0)))
+            )
+          )
+          (br $32)
+        ) ;; 16s
+        (if (i32.eq (get_local 1) (i32.const 0))
+          (then
+            (i32.store16 (i32.const 0) (get_local 2))
+            (set_local 3 (i32.load16_u (i32.const 0)))
+          )
+        )
+        (if (i32.eq (get_local 1) (i32.const 1))
+          (then
+            (i32.store16 align=1 (i32.const 0) (get_local 2))
+            (set_local 3 (i32.load16_u align=1 (i32.const 0)))
+          )
+        )
+        (if (i32.eq (get_local 1) (i32.const 2))
+          (then
+            (i32.store16 align=2 (i32.const 0) (get_local 2))
+            (set_local 3 (i32.load16_u align=2 (i32.const 0)))
+          )
+        )
+        (br $32)
+      ) ;; 16u
+      (if (i32.eq (get_local 1) (i32.const 0))
+        (then
+          (i32.store (i32.const 0) (get_local 2))
+          (set_local 3 (i32.load (i32.const 0)))
+        )
+      )
+      (if (i32.eq (get_local 1) (i32.const 1))
+        (then
+          (i32.store align=1 (i32.const 0) (get_local 2))
+          (set_local 3 (i32.load align=1 (i32.const 0)))
+        )
+      )
+      (if (i32.eq (get_local 1) (i32.const 2))
+        (then
+          (i32.store align=2 (i32.const 0) (get_local 2))
+          (set_local 3 (i32.load align=2 (i32.const 0)))
+        )
+      )
+      (if (i32.eq (get_local 1) (i32.const 4))
+        (then
+          (i32.store align=4 (i32.const 0) (get_local 2))
+          (set_local 3 (i32.load align=4 (i32.const 0)))
+        )
+      )
+    ) ;; 32
+    (get_local 3)
+  )
+
+  (func (export "i64_align_switch") (param i32 i32) (result i64)
+    (local i64 i64)
+    (set_local 2 (i64.const 10))
+    (block $64
+      (block $32u
+        (block $32s
+          (block $16u
+            (block $16s
+              (block $8u
+                (block $8s
+                  (block $0
+                    (br_table $0 $8s $8u $16s $16u $32s $32u $64 (get_local 0))
+                  ) ;; 0
+                  (if (i32.eq (get_local 1) (i32.const 0))
+                    (then
+                      (i64.store8 (i32.const 0) (get_local 2))
+                      (set_local 3 (i64.load8_s (i32.const 0)))
+                    )
+                  )
+                  (if (i32.eq (get_local 1) (i32.const 1))
+                    (then
+                      (i64.store8 align=1 (i32.const 0) (get_local 2))
+                      (set_local 3 (i64.load8_s align=1 (i32.const 0)))
+                    )
+                  )
+                  (br $64)
+                ) ;; 8s
+                (if (i32.eq (get_local 1) (i32.const 0))
+                  (then
+                    (i64.store8 (i32.const 0) (get_local 2))
+                    (set_local 3 (i64.load8_u (i32.const 0)))
+                  )
+                )
+                (if (i32.eq (get_local 1) (i32.const 1))
+                  (then
+                    (i64.store8 align=1 (i32.const 0) (get_local 2))
+                    (set_local 3 (i64.load8_u align=1 (i32.const 0)))
+                  )
+                )
+                (br $64)
+              ) ;; 8u
+              (if (i32.eq (get_local 1) (i32.const 0))
+                (then
+                  (i64.store16 (i32.const 0) (get_local 2))
+                  (set_local 3 (i64.load16_s (i32.const 0)))
+                )
+              )
+              (if (i32.eq (get_local 1) (i32.const 1))
+                (then
+                  (i64.store16 align=1 (i32.const 0) (get_local 2))
+                  (set_local 3 (i64.load16_s align=1 (i32.const 0)))
+                )
+              )
+              (if (i32.eq (get_local 1) (i32.const 2))
+                (then
+                  (i64.store16 align=2 (i32.const 0) (get_local 2))
+                  (set_local 3 (i64.load16_s align=2 (i32.const 0)))
+                )
+              )
+              (br $64)
+            ) ;; 16s
+            (if (i32.eq (get_local 1) (i32.const 0))
+              (then
+                (i64.store16 (i32.const 0) (get_local 2))
+                (set_local 3 (i64.load16_u (i32.const 0)))
+              )
+            )
+            (if (i32.eq (get_local 1) (i32.const 1))
+              (then
+                (i64.store16 align=1 (i32.const 0) (get_local 2))
+                (set_local 3 (i64.load16_u align=1 (i32.const 0)))
+              )
+            )
+            (if (i32.eq (get_local 1) (i32.const 2))
+              (then
+                (i64.store16 align=2 (i32.const 0) (get_local 2))
+                (set_local 3 (i64.load16_u align=2 (i32.const 0)))
+              )
+            )
+            (br $64)
+          ) ;; 16u
+          (if (i32.eq (get_local 1) (i32.const 0))
+            (then
+              (i64.store32 (i32.const 0) (get_local 2))
+              (set_local 3 (i64.load32_s (i32.const 0)))
+            )
+          )
+          (if (i32.eq (get_local 1) (i32.const 1))
+            (then
+              (i64.store32 align=1 (i32.const 0) (get_local 2))
+              (set_local 3 (i64.load32_s align=1 (i32.const 0)))
+            )
+          )
+          (if (i32.eq (get_local 1) (i32.const 2))
+            (then
+              (i64.store32 align=2 (i32.const 0) (get_local 2))
+              (set_local 3 (i64.load32_s align=2 (i32.const 0)))
+            )
+          )
+          (if (i32.eq (get_local 1) (i32.const 4))
+            (then
+              (i64.store32 align=4 (i32.const 0) (get_local 2))
+              (set_local 3 (i64.load32_s align=4 (i32.const 0)))
+            )
+          )
+          (br $64)
+        ) ;; 32s
+        (if (i32.eq (get_local 1) (i32.const 0))
+          (then
+            (i64.store32 (i32.const 0) (get_local 2))
+            (set_local 3 (i64.load32_u (i32.const 0)))
+          )
+        )
+        (if (i32.eq (get_local 1) (i32.const 1))
+          (then
+            (i64.store32 align=1 (i32.const 0) (get_local 2))
+            (set_local 3 (i64.load32_u align=1 (i32.const 0)))
+          )
+        )
+        (if (i32.eq (get_local 1) (i32.const 2))
+          (then
+            (i64.store32 align=2 (i32.const 0) (get_local 2))
+            (set_local 3 (i64.load32_u align=2 (i32.const 0)))
+          )
+        )
+        (if (i32.eq (get_local 1) (i32.const 4))
+          (then
+            (i64.store32 align=4 (i32.const 0) (get_local 2))
+            (set_local 3 (i64.load32_u align=4 (i32.const 0)))
+          )
+        )
+        (br $64)
+      ) ;; 32u
+      (if (i32.eq (get_local 1) (i32.const 0))
+        (then
+          (i64.store (i32.const 0) (get_local 2))
+          (set_local 3 (i64.load (i32.const 0)))
+        )
+      )
+      (if (i32.eq (get_local 1) (i32.const 1))
+        (then
+          (i64.store align=1 (i32.const 0) (get_local 2))
+          (set_local 3 (i64.load align=1 (i32.const 0)))
+        )
+      )
+      (if (i32.eq (get_local 1) (i32.const 2))
+        (then
+          (i64.store align=2 (i32.const 0) (get_local 2))
+          (set_local 3 (i64.load align=2 (i32.const 0)))
+        )
+      )
+      (if (i32.eq (get_local 1) (i32.const 4))
+        (then
+          (i64.store align=4 (i32.const 0) (get_local 2))
+          (set_local 3 (i64.load align=4 (i32.const 0)))
+        )
+      )
+      (if (i32.eq (get_local 1) (i32.const 8))
+        (then
+          (i64.store align=8 (i32.const 0) (get_local 2))
+          (set_local 3 (i64.load align=8 (i32.const 0)))
+        )
+      )
+    ) ;; 64
+    (get_local 3)
+  )
+)
+
+(assert_return (invoke "f32_align_switch" (i32.const 0)) (f32.const 10.0))
+(assert_return (invoke "f32_align_switch" (i32.const 1)) (f32.const 10.0))
+(assert_return (invoke "f32_align_switch" (i32.const 2)) (f32.const 10.0))
+(assert_return (invoke "f32_align_switch" (i32.const 3)) (f32.const 10.0))
+
+(assert_return (invoke "f64_align_switch" (i32.const 0)) (f64.const 10.0))
+(assert_return (invoke "f64_align_switch" (i32.const 1)) (f64.const 10.0))
+(assert_return (invoke "f64_align_switch" (i32.const 2)) (f64.const 10.0))
+(assert_return (invoke "f64_align_switch" (i32.const 3)) (f64.const 10.0))
+(assert_return (invoke "f64_align_switch" (i32.const 4)) (f64.const 10.0))
+
+(assert_return (invoke "i32_align_switch" (i32.const 0) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 0) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 1) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 1) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 2) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 2) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 2) (i32.const 2)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 3) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 3) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 3) (i32.const 2)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 0)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 1)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 2)) (i32.const 10))
+(assert_return (invoke "i32_align_switch" (i32.const 4) (i32.const 4)) (i32.const 10))
+
+(assert_return (invoke "i64_align_switch" (i32.const 0) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 0) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 1) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 1) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 2) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 2) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 2) (i32.const 2)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 3) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 3) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 3) (i32.const 2)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 2)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 4) (i32.const 4)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 2)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 5) (i32.const 4)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 0)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 1)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 2)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 4)) (i64.const 10))
+(assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 8)) (i64.const 10))
diff --git a/test/core/memory.wast b/test/core/memory.wast
index ee35e1ee3..498fda60f 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -74,49 +74,6 @@
   "memory size must be at most 65536 pages (4GiB)"
 )
 
-;; Test alignment annotation rules
-(module (memory 0) (func (drop (i32.load8_u align=1 (i32.const 0)))))
-(module (memory 0) (func (drop (i32.load16_u align=2 (i32.const 0)))))
-(module (memory 0) (func (drop (i32.load align=4 (i32.const 0)))))
-(module (memory 0) (func (drop (f32.load align=4 (i32.const 0)))))
-
-(assert_invalid
-  (module (memory 0) (func (drop (i64.load align=16 (i32.const 0)))))
-  "alignment must not be larger than natural"
-)
-(assert_invalid
-  (module (memory 0) (func (drop (i64.load align=32 (i32.const 0)))))
-  "alignment must not be larger than natural"
-)
-(assert_invalid
-  (module (memory 0) (func (drop (i32.load align=8 (i32.const 0)))))
-  "alignment must not be larger than natural"
-)
-(assert_invalid
-  (module (memory 0) (func (drop (i32.load16_u align=4 (i32.const 0)))))
-  "alignment must not be larger than natural"
-)
-(assert_invalid
-  (module (memory 0) (func (drop (i32.load8_u align=2 (i32.const 0)))))
-  "alignment must not be larger than natural"
-)
-(assert_invalid
-  (module (memory 0) (func (i32.store8 align=2 (i32.const 0) (i32.const 0))))
-  "alignment must not be larger than natural"
-)
-(assert_invalid
-  (module (memory 0) (func (i32.load16_u align=4 (i32.const 0))))
-  "alignment must not be larger than natural"
-)
-(assert_invalid
-  (module (memory 0) (func (i32.load8_u align=2 (i32.const 0))))
-  "alignment must not be larger than natural"
-)
-(assert_invalid
-  (module (memory 0) (func (i32.store8 align=2 (i32.const 0) (i32.const 0))))
-  "alignment must not be larger than natural"
-)
-
 (module
   (memory 1)
   (data (i32.const 0) "ABC\a7D") (data (i32.const 20) "WASM")
@@ -147,54 +104,6 @@
     )
   )
 
-  ;; Aligned read/write
-  (func (export "aligned") (result i32)
-    (local i32 i32 i32)
-    (set_local 0 (i32.const 10))
-    (block
-      (loop
-        (if
-          (i32.eq (get_local 0) (i32.const 0))
-          (then (br 2))
-        )
-        (set_local 2 (i32.mul (get_local 0) (i32.const 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))
-          (then (return (i32.const 0)))
-        )
-        (set_local 0 (i32.sub (get_local 0) (i32.const 1)))
-        (br 0)
-      )
-    )
-    (i32.const 1)
-  )
-
-  ;; Unaligned read/write
-  (func (export "unaligned") (result i32)
-    (local i32 f64 f64)
-    (set_local 0 (i32.const 10))
-    (block
-      (loop
-        (if
-          (i32.eq (get_local 0) (i32.const 0))
-          (then (br 2))
-        )
-        (set_local 2 (f64.convert_s/i32 (get_local 0)))
-        (f64.store align=1 (get_local 0) (get_local 2))
-        (set_local 1 (f64.load align=1 (get_local 0)))
-        (if
-          (f64.ne (get_local 2) (get_local 1))
-          (then (return (i32.const 0)))
-        )
-        (set_local 0 (i32.sub (get_local 0) (i32.const 1)))
-        (br 0)
-      )
-    )
-    (i32.const 1)
-  )
-
   ;; Memory cast
   (func (export "cast") (result f64)
     (i64.store (i32.const 8) (i64.const -12345))
@@ -254,8 +163,6 @@
 )
 
 (assert_return (invoke "data") (i32.const 1))
-(assert_return (invoke "aligned") (i32.const 1))
-(assert_return (invoke "unaligned") (i32.const 1))
 (assert_return (invoke "cast") (f64.const 42.0))
 
 (assert_return (invoke "i32_load8_s" (i32.const -1)) (i32.const -1))

From 2113ea7e106f8a964e0445ba38f289d2aa845edd Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Tue, 10 Jul 2018 10:08:58 +0800
Subject: [PATCH 259/329] [test] Remove non-conformance checkponits (#812)

---
 test/Todo.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/test/Todo.md b/test/Todo.md
index 18e954ded..62539bc11 100644
--- a/test/Todo.md
+++ b/test/Todo.md
@@ -4,8 +4,6 @@ have a link to an open issue/PR, or be obvious. Comments/corrections/additions
 welcome.
 
 Linear memory semantics:
- - test that load/store addreses are full int32 (or int64), and not OCaml int
- - test that when allocating 4GiB, accessing index -1 fails
  - test that too-big `memory.grow` fails appropriately
  - test that too-big linear memory initial allocation fails
  - test that one can clobber the entire contents of the linear memory without corrupting: call stack, local variables, program execution.

From 0a8f46fa556e32f82c993d2e735b68701f353e37 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Sun, 15 Jul 2018 23:29:43 +0800
Subject: [PATCH 260/329] [test] Add more type mismatch tests for block
 construct (#835)

---
 test/core/block.wast | 685 +++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 665 insertions(+), 20 deletions(-)

diff --git a/test/core/block.wast b/test/core/block.wast
index f2b6384c3..3754a159b 100644
--- a/test/core/block.wast
+++ b/test/core/block.wast
@@ -173,121 +173,766 @@
 )
 
 (assert_invalid
-  (module (func $type-value-num-vs-void
+  (module (func $type-value-i32-vs-void
     (block (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-value-empty-vs-num (result i32)
+  (module (func $type-value-i64-vs-void
+    (block (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-void
+    (block (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-void
+    (block (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-empty-vs-i32 (result i32)
     (block (result i32))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-value-void-vs-num (result i32)
+  (module (func $type-value-empty-vs-i64 (result i64)
+    (block (result i64))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-f32 (result f32)
+    (block (result f32))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-empty-vs-f64 (result f64)
+    (block (result f64))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-void-vs-i32 (result i32)
     (block (result i32) (nop))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-value-num-vs-num (result i32)
-    (block (result i32) (f32.const 0))
+  (module (func $type-value-void-vs-i64 (result i64)
+    (block (result i64) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-f32 (result f32)
+    (block (result f32) (nop))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-void-vs-f64 (result f64)
+    (block (result f64) (nop))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-i32-vs-i64 (result i32)
+    (block (result i32) (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i32-vs-f32 (result i32)
+    (block (result i32) (f32.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i32-vs-f64 (result i32)
+    (block (result i32) (f64.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i64-vs-i32 (result i64)
+    (block (result i64) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-i64-vs-f32 (result i64)
+    (block (result i64) (f32.const 0.0))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-value-unreached-select (result i32)
+  (module (func $type-value-i64-vs-f64 (result i64)
+    (block (result i64) (f64.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-i32 (result f32)
+    (block (result f32) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-i64 (result f32)
+    (block (result f32) (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f32-vs-f64 (result f32)
+    (block (result f32) (f64.const 0.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-i32 (result f64)
+    (block (result f64) (i32.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-i64 (result f64)
+    (block (result f64) (i64.const 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-f64-vs-f32 (result f32)
+    (block (result f64) (f32.const 0.0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-value-unreached-select-i32-i64 (result i32)
     (block (result i64) (select (unreachable) (unreachable) (unreachable)))
   ))
   "type mismatch"
 )
+(assert_invalid
+  (module (func $type-value-unreached-select-i32-f32 (result i32)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i32-f64 (result i32)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i64-i32 (result i64)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i64-f32 (result i64)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-i64-f64 (result i64)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f32-i32 (result f32)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f32-i64 (result f32)
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f32-f64 (result f32)
+    (block (result f64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f64-i32 (result f64)
+    (block (result i32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f64-i64 (result f64)
+    (block (result i64) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-value-unreached-select-f64-f32 (result f64)
+    (block (result f32) (select (unreachable) (unreachable) (unreachable)))
+  ))
+  "type mismatch"
+)
 
 (assert_invalid
-  (module (func $type-break-last-void-vs-num (result i32)
+  (module (func $type-break-last-void-vs-i32 (result i32)
     (block (result i32) (br 0))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-break-empty-vs-num (result i32)
+  (module (func $type-break-last-void-vs-i64 (result i64)
+    (block (result i64) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-f32 (result f32)
+    (block (result f32) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-last-void-vs-f64 (result f64)
+    (block (result f64) (br 0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-empty-vs-i32 (result i32)
     (block (result i32) (br 0) (i32.const 1))
   ))
   "type mismatch"
 )
+(assert_invalid
+  (module (func $type-break-empty-vs-i64 (result i64)
+    (block (result i64) (br 0) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-empty-vs-f32 (result f32)
+    (block (result f32) (br 0) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-empty-vs-f64 (result f64)
+    (block (result f64) (br 0) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
 
 (assert_invalid
-  (module (func $type-break-void-vs-num (result i32)
+  (module (func $type-break-void-vs-i32 (result i32)
     (block (result i32) (br 0 (nop)) (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-break-num-vs-num (result i32)
+  (module (func $type-break-void-vs-i64 (result i64)
+    (block (result i64) (br 0 (nop)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-f32 (result f32)
+    (block (result f32) (br 0 (nop)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-void-vs-f64 (result f64)
+    (block (result f64) (br 0 (nop)) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-i32-vs-i64 (result i32)
     (block (result i32) (br 0 (i64.const 1)) (i32.const 1))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-break-first-void-vs-num (result i32)
+  (module (func $type-break-i32-vs-f32 (result i32)
+    (block (result i32) (br 0 (f32.const 1.0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i32-vs-f64 (result i32)
+    (block (result i32) (br 0 (f64.const 1.0)) (i32.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i64-vs-i32 (result i64)
+    (block (result i64) (br 0 (i32.const 1)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i64-vs-f32 (result i64)
+    (block (result i64) (br 0 (f32.const 1.0)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-i64-vs-f64 (result i64)
+    (block (result i64) (br 0 (f64.const 1.0)) (i64.const 1))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f32-vs-i32 (result f32)
+    (block (result f32) (br 0 (i32.const 1)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f32-vs-i64 (result f32)
+    (block (result f32) (br 0 (i64.const 1)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f32-vs-f64 (result f32)
+    (block (result f32) (br 0 (f64.const 1.0)) (f32.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f64-vs-i32 (result f64)
+    (block (result i64) (br 0 (i32.const 1)) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f64-vs-i64 (result f64)
+    (block (result f64) (br 0 (i64.const 1)) (f64.const 1.0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-f64-vs-f32 (result f64)
+    (block (result f64) (br 0 (f32.const 1.0)) (f64.const 1))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-first-void-vs-i32 (result i32)
     (block (result i32) (br 0 (nop)) (br 0 (i32.const 1)))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-break-first-num-vs-num (result i32)
+  (module (func $type-break-first-void-vs-i64 (result i64)
+    (block (result i64) (br 0 (nop)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-void-vs-f32 (result f32)
+    (block (result f32) (br 0 (nop)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-void-vs-f64 (result f64)
+    (block (result f64) (br 0 (nop)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-first-i32-vs-i64 (result i32)
     (block (result i32) (br 0 (i64.const 1)) (br 0 (i32.const 1)))
   ))
   "type mismatch"
 )
+(assert_invalid
+  (module (func $type-break-first-i32-vs-f32 (result i32)
+    (block (result i32) (br 0 (f32.const 1.0)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i32-vs-f64 (result i32)
+    (block (result i32) (br 0 (f64.const 1.0)) (br 0 (i32.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i64-vs-i32 (result i64)
+    (block (result i64) (br 0 (i32.const 1)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i64-vs-f32 (result i64)
+    (block (result i64) (br 0 (f32.const 1.0)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-i64-vs-f64 (result i64)
+    (block (result i64) (br 0 (f64.const 1.0)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f32-vs-i32 (result f32)
+    (block (result f32) (br 0 (i32.const 1)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f32-vs-i64 (result f32)
+    (block (result f32) (br 0 (i64.const 1)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f32-vs-f64 (result f32)
+    (block (result f32) (br 0 (f64.const 1.0)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f64-vs-i32 (result f64)
+    (block (result f64) (br 0 (i32.const 1)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f64-vs-i64 (result f64)
+    (block (result f64) (br 0 (i64.const 1)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-first-f64-vs-f32 (result f64)
+    (block (result f64) (br 0 (f32.const 1.0)) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
 
 (assert_invalid
-  (module (func $type-break-nested-num-vs-void
+  (module (func $type-break-nested-i32-vs-void
     (block (result i32) (block (result i32) (br 1 (i32.const 1))) (br 0))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-break-nested-empty-vs-num (result i32)
+  (module (func $type-break-nested-i64-vs-void
+    (block (result i64) (block (result i64) (br 1 (i64.const 1))) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-void
+    (block (result f32) (block (result f32) (br 1 (f32.const 1.0))) (br 0))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-void
+    (block (result f64) (block (result f64) (br 1 (f64.const 1.0))) (br 0))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-i32 (result i32)
     (block (result i32) (block (br 1)) (br 0 (i32.const 1)))
   ))
   "type mismatch"
 )
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-i64 (result i64)
+    (block (result i64) (block (br 1)) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-f32 (result f32)
+    (block (result f32) (block (br 1)) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-empty-vs-f64 (result f64)
+    (block (result f64) (block (br 1)) (br 0 (f64.const 1)))
+  ))
+  "type mismatch"
+)
 
 (assert_invalid
-  (module (func $type-break-nested-void-vs-num (result i32)
+  (module (func $type-break-nested-void-vs-i32 (result i32)
     (block (result i32) (block (result i32) (br 1 (nop))) (br 0 (i32.const 1)))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-break-nested-num-vs-num (result i32)
+  (module (func $type-break-nested-void-vs-i64 (result i64)
+    (block (result i64) (block (result i64) (br 1 (nop))) (br 0 (i64.const 1)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-f32 (result f32)
+    (block (result f32) (block (result f32) (br 1 (nop))) (br 0 (f32.const 1.0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-void-vs-f64 (result f64)
+    (block (result f64) (block (result f64) (br 1 (nop))) (br 0 (f64.const 1.0)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-nested-i32-vs-i64 (result i32)
     (block (result i32)
       (block (result i32) (br 1 (i64.const 1))) (br 0 (i32.const 1))
     )
   ))
   "type mismatch"
 )
+(assert_invalid
+  (module (func $type-break-nested-i32-vs-f32 (result i32)
+    (block (result i32)
+      (block (result i32) (br 1 (f32.const 1.0))) (br 0 (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i32-vs-f64 (result i32)
+    (block (result i32)
+      (block (result i32) (br 1 (f64.const 1.0))) (br 0 (i32.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i64-vs-i32 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (i32.const 1))) (br 0 (i64.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i64-vs-f32 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (f32.const 1.0))) (br 0 (i64.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-i64-vs-f64 (result i64)
+    (block (result i64)
+      (block (result i64) (br 1 (f64.const 1.0))) (br 0 (i64.const 1))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-i32 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (i32.const 1))) (br 0 (f32.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-i64 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (i64.const 1))) (br 0 (f32.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f32-vs-f64 (result f32)
+    (block (result f32)
+      (block (result f32) (br 1 (f64.const 1.0))) (br 0 (f32.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-i32 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (i32.const 1))) (br 0 (f64.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-i64 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (i64.const 1))) (br 0 (f64.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-nested-f64-vs-f32 (result f64)
+    (block (result f64)
+      (block (result f64) (br 1 (f32.const 1.0))) (br 0 (f64.const 1.0))
+    )
+  ))
+  "type mismatch"
+)
 
 (assert_invalid
-  (module (func $type-break-operand-empty-vs-num (result i32)
+  (module (func $type-break-operand-empty-vs-i32 (result i32)
     (i32.ctz (block (br 0)))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-break-operand-void-vs-num (result i32)
+  (module (func $type-break-operand-empty-vs-i64 (result i64)
+    (i64.ctz (block (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-f32 (result f32)
+    (f32.floor (block (br 0)))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-empty-vs-f64 (result f64)
+    (f64.floor (block (br 0)))
+  ))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $type-break-operand-void-vs-i32 (result i32)
+    (i32.ctz (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-void-vs-i64 (result i64)
     (i64.ctz (block (br 0 (nop))))
   ))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-break-operand-num-vs-num (result i32)
-    (i64.ctz (block (br 0 (i64.const 9))))
+  (module (func $type-break-operand-void-vs-f32 (result f32)
+    (f32.floor (block (br 0 (nop))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-void-vs-f64 (result f64)
+    (f64.floor (block (br 0 (nop))))
   ))
   "type mismatch"
 )
 
+(assert_invalid
+  (module (func $type-break-operand-i32-vs-i64 (result i32)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i32-vs-f32 (result i32)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i32-vs-f64 (result i32)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i64-vs-i32 (result i64)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i64-vs-f32 (result i64)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-i64-vs-f64 (result i64)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f32-vs-i32 (result f32)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f32-vs-i64 (result f32)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f32-vs-f64 (result f32)
+    (f64.floor (block (br 0 (f64.const 9.0))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f64-vs-i32 (result f64)
+    (i32.ctz (block (br 0 (i32.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f64-vs-i64 (result f64)
+    (i64.ctz (block (br 0 (i64.const 9))))
+  ))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-break-operand-f64-vs-f32 (result f64)
+    (f32.floor (block (br 0 (f32.const 9.0))))
+  ))
+  "type mismatch"
+)
 
 (assert_malformed
   (module quote "(func block end $l)")

From c8355fb100373429ee34b5998833c4947f50a224 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Sun, 15 Jul 2018 23:30:27 +0800
Subject: [PATCH 261/329] [test] Remove tested checkpoints in Todo.md (#833)

---
 test/Todo.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/test/Todo.md b/test/Todo.md
index 62539bc11..fa2aa1026 100644
--- a/test/Todo.md
+++ b/test/Todo.md
@@ -4,8 +4,6 @@ have a link to an open issue/PR, or be obvious. Comments/corrections/additions
 welcome.
 
 Linear memory semantics:
- - test that too-big `memory.grow` fails appropriately
- - test that too-big linear memory initial allocation fails
  - test that one can clobber the entire contents of the linear memory without corrupting: call stack, local variables, program execution.
  - test that an i64 store with 4-byte alignment that's 4 bytes out of bounds traps without storing anything.
 

From c8338e9b4a60edb431edba51a4e1a1617060c2e9 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Tue, 17 Jul 2018 14:43:01 +0800
Subject: [PATCH 262/329] [test] Add test to cover one checkpoint in Todo.md
 (#834)

---
 test/Todo.md         |  1 -
 test/core/align.wast | 16 ++++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/test/Todo.md b/test/Todo.md
index fa2aa1026..99e246435 100644
--- a/test/Todo.md
+++ b/test/Todo.md
@@ -5,7 +5,6 @@ welcome.
 
 Linear memory semantics:
  - test that one can clobber the entire contents of the linear memory without corrupting: call stack, local variables, program execution.
- - test that an i64 store with 4-byte alignment that's 4 bytes out of bounds traps without storing anything.
 
 Misc optimizer bait:
  - test that the scheduler doesn't move a trapping div past a call which may not return
diff --git a/test/core/align.wast b/test/core/align.wast
index 90dbd53c8..7f877c4ec 100644
--- a/test/core/align.wast
+++ b/test/core/align.wast
@@ -848,3 +848,19 @@
 (assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 2)) (i64.const 10))
 (assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 4)) (i64.const 10))
 (assert_return (invoke "i64_align_switch" (i32.const 6) (i32.const 8)) (i64.const 10))
+
+;; Test that an i64 store with 4-byte alignment that's 4 bytes out of bounds traps without storing anything
+
+(module
+  (memory 1)
+  (func (export "store") (param i32 i64)
+    (i64.store align=4 (get_local 0) (get_local 1))
+  )
+  (func (export "load") (param i32) (result i32)
+    (i32.load (get_local 0))
+  )
+)
+
+(assert_trap (invoke "store" (i32.const 65532) (i64.const -1)) "out of bounds memory access")
+;; No memory was changed
+(assert_return (invoke "load" (i32.const 65532)) (i32.const 0))

From b9cddea4dddd103324e45f96e642aebc2b43b7fd Mon Sep 17 00:00:00 2001
From: Dan Gohman <sunfish@mozilla.com>
Date: Wed, 18 Jul 2018 06:12:27 -0700
Subject: [PATCH 263/329] Miscellanous floating-point and unicode tests (#807)

---
 test/core/float_exprs.wast    |  2 +-
 test/core/float_literals.wast |  8 ++++++++
 test/core/float_misc.wast     |  2 +-
 test/core/names.wast          | 10 ++++++++++
 4 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/test/core/float_exprs.wast b/test/core/float_exprs.wast
index 5cee2d46c..0351de782 100644
--- a/test/core/float_exprs.wast
+++ b/test/core/float_exprs.wast
@@ -1022,7 +1022,7 @@
 (assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const 0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const -0.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
-(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -nan))(f32.const -nan))
+(assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -nan)) (f32.const -nan))
 (assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const 0.0)) (f32.const -0.0))
 (assert_return (invoke "f32.no_fold_le_select_to_abs" (f32.const -0.0)) (f32.const 0.0))
 (assert_return (invoke "f32.no_fold_gt_select_to_abs" (f32.const nan:0x200000)) (f32.const -nan:0x200000))
diff --git a/test/core/float_literals.wast b/test/core/float_literals.wast
index ed5969b88..28acabec2 100644
--- a/test/core/float_literals.wast
+++ b/test/core/float_literals.wast
@@ -37,6 +37,9 @@
   (func (export "f32_dec.max_finite") (result i32) (i32.reinterpret/f32 (f32.const 3.4028234e+38)))
   (func (export "f32_dec.trailing_dot") (result i32) (i32.reinterpret/f32 (f32.const 1.e10)))
 
+  ;; https://twitter.com/Archivd/status/994637336506912768
+  (func (export "f32_dec.root_beer_float") (result i32) (i32.reinterpret/f32 (f32.const 1.000000119)))
+
   ;; f64 special values
   (func (export "f64.nan") (result i64) (i64.reinterpret/f64 (f64.const nan)))
   (func (export "f64.positive_nan") (result i64) (i64.reinterpret/f64 (f64.const +nan)))
@@ -73,6 +76,9 @@
   (func (export "f64_dec.max_finite") (result i64) (i64.reinterpret/f64 (f64.const 1.7976931348623157e+308)))
   (func (export "f64_dec.trailing_dot") (result i64) (i64.reinterpret/f64 (f64.const 1.e100)))
 
+  ;; https://twitter.com/Archivd/status/994637336506912768
+  (func (export "f64_dec.root_beer_float") (result i64) (i64.reinterpret/f64 (f64.const 1.000000119)))
+
   (func (export "f32-dec-sep1") (result f32) (f32.const 1_000_000))
   (func (export "f32-dec-sep2") (result f32) (f32.const 1_0_0_0))
   (func (export "f32-dec-sep3") (result f32) (f32.const 100_3.141_592))
@@ -126,6 +132,7 @@
 (assert_return (invoke "f32_dec.max_subnormal") (i32.const 0x7fffff))
 (assert_return (invoke "f32_dec.max_finite") (i32.const 0x7f7fffff))
 (assert_return (invoke "f32_dec.trailing_dot") (i32.const 0x501502f9))
+(assert_return (invoke "f32_dec.root_beer_float") (i32.const 0x3f800001))
 
 (assert_return (invoke "f64.nan") (i64.const 0x7ff8000000000000))
 (assert_return (invoke "f64.positive_nan") (i64.const 0x7ff8000000000000))
@@ -157,6 +164,7 @@
 (assert_return (invoke "f64_dec.max_subnormal") (i64.const 0xfffffffffffff))
 (assert_return (invoke "f64_dec.max_finite") (i64.const 0x7fefffffffffffff))
 (assert_return (invoke "f64_dec.trailing_dot") (i64.const 0x54b249ad2594c37d))
+(assert_return (invoke "f64_dec.root_beer_float") (i64.const 0x3ff000001ff19e24))
 
 (assert_return (invoke "f32-dec-sep1") (f32.const 1000000))
 (assert_return (invoke "f32-dec-sep2") (f32.const 1000))
diff --git a/test/core/float_misc.wast b/test/core/float_misc.wast
index 095b8d827..313534326 100644
--- a/test/core/float_misc.wast
+++ b/test/core/float_misc.wast
@@ -235,7 +235,7 @@
 (assert_return (invoke "f64.sub" (f64.const 0x1.5e423fe8571f4p-57) (f64.const 0x1.9624ed7c162dfp-618)) (f64.const 0x1.5e423fe8571f4p-57))
 
 ;; pow(e, π) - π
-;; https://xkcd.com/217
+;; https://xkcd.com/217/
 (assert_return (invoke "f32.sub" (f32.const 0x1.724046p+4) (f32.const 0x1.921fb6p+1)) (f32.const 0x1.3ffc5p+4))
 (assert_return (invoke "f64.sub" (f64.const 0x1.724046eb0933ap+4) (f64.const 0x1.921fb54442d18p+1)) (f64.const 0x1.3ffc504280d97p+4))
 
diff --git a/test/core/names.wast b/test/core/names.wast
index 97f28f3b4..2ed6ca575 100644
--- a/test/core/names.wast
+++ b/test/core/names.wast
@@ -597,6 +597,12 @@
   (func (export "⸎") (result i32) (i32.const 469))
   (func (export "\14") (result i32) (i32.const 470)) ;; ¶ in CP437
   (func (export "☙") (result i32) (i32.const 471))
+  (func (export "⸿") (result i32) (i32.const 472))
+  (func (export "〇") (result i32) (i32.const 473))
+  (func (export "๛") (result i32) (i32.const 474))
+
+  ;; Test an unusual character.
+  (func (export "ꙮ") (result i32) (i32.const 475))
 )
 
 (assert_return (invoke "") (i32.const 0))
@@ -1071,6 +1077,10 @@
 (assert_return (invoke "⸎") (i32.const 469))
 (assert_return (invoke "\14") (i32.const 470))
 (assert_return (invoke "☙") (i32.const 471))
+(assert_return (invoke "⸿") (i32.const 472))
+(assert_return (invoke "〇") (i32.const 473))
+(assert_return (invoke "๛") (i32.const 474))
+(assert_return (invoke "ꙮ") (i32.const 475))
 
 (module
   ;; Test that we can use indices instead of names to reference imports,

From 4ce607c773de1fbc077289e857facaa9ac46dc73 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Thu, 26 Jul 2018 19:55:49 +0200
Subject: [PATCH 264/329] Indent substeps correctly in the Global constructor.
 (#839)

They need four spaces rather than three to escape from the parent list.
---
 document/js-api/index.bs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 10a84bcfd..f62750c4e 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -770,10 +770,10 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Let |mutable| be |descriptor|["mutable"].
     1. Let |valuetype| be [=ToValueType=](|descriptor|["value"]).
     1. If |v| is undefined,
-       1. let |value| be [=DefaultValue=](|valuetype|).
+        1. let |value| be [=DefaultValue=](|valuetype|).
     1. Otherwise,
-       1. If |valuetype| is [=𝗂𝟨𝟦=], throw a {{TypeError}} exception.
-       1. Let |value| be [=ToWebAssemblyValue=](|v|, |valuetype|).
+        1. If |valuetype| is [=𝗂𝟨𝟦=], throw a {{TypeError}} exception.
+        1. Let |value| be [=ToWebAssemblyValue=](|v|, |valuetype|).
     1. If |mutable| is true, let |globaltype| be [=var=] |valuetype|; otherwise, let |globaltype| be [=const=] |valuetype|.
     1. Let |store| be the current agent's [=associated store=].
     1. Let (|store|, |globaladdr|) be [=alloc_global=](|store|, |globaltype|, |value|). <!-- TODO(littledan): Report allocation failure https://github.com/WebAssembly/spec/issues/584 -->

From 7ee1a8936098427a7807cddcd646106fb55afe72 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Thu, 26 Jul 2018 19:56:31 +0200
Subject: [PATCH 265/329] Use the customSection variable where appropriate.
 (#819)

---
 document/js-api/index.bs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index f62750c4e..10a85adc0 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -496,8 +496,8 @@ interface Module {
     The <dfn method for="Module">customSections(|moduleObject|, |sectionName|)</dfn> method, when invoked, performs the following steps:
     1. Let |bytes| be |moduleObject|.\[[Bytes]].
     1. Let |customSections| be an empty [=list=] of {{ArrayBuffer}}s.
-    1. For each [=custom section=] <var ignore>customSection</var> in the binary format of |bytes|,
-        1. Let |name| be the <code>name</code> of the custom section, [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
+    1. For each [=custom section=] |customSection| in the binary format of |bytes|,
+        1. Let |name| be the <code>name</code> of |customSection|, [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
         1. Assert: |name| is not failure (|moduleObject|.\[[Module]] is [=valid=]).
         1. If |name| equals |sectionName| as string values,
             1. [=Append=] a new {{ArrayBuffer}} containing a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes| for the range matched by this [=customsec=] production.

From 90b808387e41adb5509d9ce9a5c6636fff64839a Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Mon, 30 Jul 2018 16:50:35 +0200
Subject: [PATCH 266/329] [spec] Reorganise main links (#782)

---
 document/index.html | 35 ++++++++++++++++++++++++-----------
 1 file changed, 24 insertions(+), 11 deletions(-)

diff --git a/document/index.html b/document/index.html
index 70f38ec47..f95c9a1d4 100644
--- a/document/index.html
+++ b/document/index.html
@@ -22,31 +22,44 @@ <h1>WebAssembly Specifications</h1>
 
 <h3>Core specification</h3>
 
-<p>Defines the semantics of WebAssembly modules and its instruction set, independent from a concrete embedding.
+<p>Defines the semantics of WebAssembly modules independent from a concrete embedding.
   The WebAssembly core is specified in a single document:</p>
 
   <ul>
     <li>
-      <p><a href="core/index.html">Core</a>:
-      defines the structure of WebAssembly modules and its representation
+      <p><b>WebAssembly</b>:
+      defines the structure of WebAssembly modules, their instruction set, and their representation
       in binary and text format, as well as the semantics of validation,
       instantiation, and execution.
-      Alternate versions:
-      <a href="core/bikeshed/index.html">W3C Editor's Draft</a>,
-      <a href="core/_download/WebAssembly.pdf">PDF</a>.
       </p>
+      <ul>
+        <li><a href="core/index.html">Browser version</a> (multi-page)</li>
+        <li><a href="core/bikeshed/index.html">W3C version</a> (single-page)</li>
+        <li><a href="core/_download/WebAssembly.pdf">PDF version</a></li>
+        <!-- <li><a href="https://github.com/WebAssembly/spec/document/core/">Sources</a></li> -->
+      </ul>
     </li>
   </ul>
 
-<h3>API specifications</h3>
+<h3>Embedder specifications</h3>
 
-<p>Define <em>application programming interfaces</em> enabling the use of WebAssembly modules in concrete embedding environments.
+<p>Define <em>application programming interfaces</em> (APIs) enabling the use of WebAssembly modules in concrete embedding environments.
   Currently, two APIs are specified:</p>
 
   <ul>
-  <li><p><a href="js-api/index.html">JavaScript API</a>: defines JavaScript classes and objects for accessing WebAssembly from within JavaScript, including methods for validation, compilation, instantiation, and classes for representing and manipulating imports and exports as JavaScript objects.</p></li>
-
-  <li><p><a href="web-api/index.html">Web API</a>: defines extensions to the JavaScript API made available specifically in web browsers, in particular, an interface for streaming compilation and instantiation from origin-bound <code>Response</code> types.</p></li>
+  <li><p><b>JavaScript Embedding</b>: defines JavaScript classes and objects for accessing WebAssembly from within JavaScript, including methods for validation, compilation, instantiation, and classes for representing and manipulating imports and exports as JavaScript objects.</p>
+    <ul>
+      <li><a href="js-api/index.html">W3C version</a></li>
+      <!-- <li><a href="https://github.com/WebAssembly/spec/document/js-api/">Sources</a></li> -->
+    </ul>
+  </li>
+
+  <li><p><b>Web Embedding</b>: defines extensions to the JavaScript API made available specifically in web browsers, in particular, an interface for streaming compilation and instantiation from origin-bound <code>Response</code> types.</p>
+    <ul>
+      <li><a href="web-api/index.html">W3C version</a></li>
+      <!-- <li><a href="https://github.com/WebAssembly/spec/document/web-api/">Sources</a></li> -->
+    </ul>
+  </li>
   </ul>
 
 <p>

From 14bce491c1587290c6ff76625891637022515718 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Tue, 31 Jul 2018 17:14:12 +0800
Subject: [PATCH 267/329] [test] Fix a minor issue in br_table.wast (#841)

---
 test/core/br_table.wast | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/core/br_table.wast b/test/core/br_table.wast
index 81259cacc..7dc787b6b 100644
--- a/test/core/br_table.wast
+++ b/test/core/br_table.wast
@@ -873,7 +873,7 @@
   )
 
   (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (br 0 (i32.const 9))))
+    (block (result i32) (br 0 (br_table 0 (i32.const 9) (i32.const 0))))
   )
 
   (func (export "as-br_if-cond")

From c255ab47c5fe2e9a750681ef507c0beeb9ef2bab Mon Sep 17 00:00:00 2001
From: Gabor Greif <ggreif@gmail.com>
Date: Wed, 1 Aug 2018 14:33:24 +0200
Subject: [PATCH 268/329] [spec] Fix typo (#842)

---
 document/core/syntax/types.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index 012eff4c3..b92d9c92c 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -5,7 +5,7 @@
 Types
 -----
 
-Various entitites in WebAssembly are classified by types.
+Various entities in WebAssembly are classified by types.
 Types are checked during :ref:`validation <valid>`, :ref:`instantiation <exec-instantiation>`, and possibly :ref:`execution <syntax-call_indirect>`.
 
 

From c2a628642fa7699104f9564252f7dcaa24922a30 Mon Sep 17 00:00:00 2001
From: Gabor Greif <ggreif@gmail.com>
Date: Thu, 2 Aug 2018 12:28:40 +0200
Subject: [PATCH 269/329] [spec] Fix type in note (#843)

---
 document/core/valid/instructions.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 1062f9386..288c2a67b 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -509,7 +509,7 @@ Control Instructions
    }
 
 .. note::
-   The :ref:`notation <notation-extend>` :math:`C,\CLABELS\,[t^?]` inserts the new label type at index :math:`0`, shifting all others.
+   The :ref:`notation <notation-extend>` :math:`C,\CLABELS\,[]` inserts the new label type at index :math:`0`, shifting all others.
 
    The fact that the nested instruction sequence :math:`\instr^\ast` must have type :math:`[] \to [t^?]` implies that it cannot access operands that have been pushed on the stack before the loop was entered.
    This may be generalized in future versions of WebAssembly.

From b1217bd5b40676406ac8359f40cb29021c19c9e8 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Sun, 5 Aug 2018 19:45:05 -0700
Subject: [PATCH 270/329] Some html validation fixes for bikeshed spec (#844)

* There was an extra `</span>` in the math fragments; this occurred when
  replacing the output before "katex-html". This removes the extra
  closing tag, and also adds a function to catch look for balanced tags
  in the math output. It's not very clever, but it works for the current
  math fragments.
* Some `<a>` tags were being generated with multiple "style" attributes,
  to prevent underlining links.
  The fix here is to add a new style section instead of annotating each
  element.
---
 document/core/util/mathjax2katex.py | 50 +++++++++++++++++++++++++----
 1 file changed, 44 insertions(+), 6 deletions(-)

diff --git a/document/core/util/mathjax2katex.py b/document/core/util/mathjax2katex.py
index eac05643c..b279d6bc5 100755
--- a/document/core/util/mathjax2katex.py
+++ b/document/core/util/mathjax2katex.py
@@ -31,6 +31,31 @@ def FindMatching(data, prefix):
   return (start, end)
 
 
+def HasBalancedTags(s):
+  tt = re.findall(r'(</?\w+|/>)', s)
+  tags = []
+  for tag in tt:
+    if tag == '/>':
+      # self-closing tag.
+      tags.pop
+    elif tag[0] == '</':
+      # closing tag
+      tag = tag[2:]
+      if len(tags) == 0 or tag != tags[-1]:
+        expected = '"%s"' % tags[-1] if len(tags) else 'empty tag stack'
+        sys.stderr.write('expected %s, got "%s"\n' % (expected, tag))
+        sys.stderr.write('tags: %s\n' % tt)
+        sys.stderr.write('tag stack: %s\n' % tags)
+        sys.stderr.write('string: %s\n' % s)
+        return False
+
+      tags.pop()
+    else:
+      # opening tag
+      tags.append(tag[1:])
+  return True
+
+
 def ReplaceMath(cache, data):
   old = data
   data = data.replace('\\\\', '\\DOUBLESLASH')
@@ -88,12 +113,11 @@ def ReplaceMath(cache, data):
     return ''
   ret = ret.strip()
   ret = ret[ret.find('<span class="katex-html"'):]
-  ret = '<span class="katex-display"><span class="katex">' + ret + '</span>'
+  ret = '<span class="katex-display"><span class="katex">' + ret
   # w3c validator does not like negative em.
   ret = re.sub('height:[-][0-9][.][0-9]+em', 'height:0em', ret)
   # Fix ahref -> a href bug (fixed in next release).
-  # Also work around W3C forcing links to have underline.
-  ret = ret.replace('<ahref="<a', '<a style="border-bottom: 0px" href="')
+  ret = ret.replace('<ahref="<a', '<a href="')
   # Fix stray spans that come out of katex.
   ret = re.sub('[<]span class="vlist" style="height:[0-9.]+em;"[>]',
                '<span class="vlist">', ret)
@@ -104,6 +128,7 @@ def ReplaceMath(cache, data):
       'mathit" style="margin-right:0.[0-9]+em', 'mathit" style="', ret)
   ret = re.sub(
       'mainit" style="margin-right:0.[0-9]+em', 'mathit" style="', ret)
+  assert HasBalancedTags(ret)
 
   cache[data] = ret
   return ret
@@ -187,6 +212,15 @@ def ExtractMath(match):
   # Strip <p> in <pre>
   data = re.sub('(<pre>.*?</pre>)', StripParas, data, 0, re.DOTALL)
 
+  # Work around W3C forcing links to have underline for math fragments.
+  data = data.replace('<style>',
+"""<style>/* mathjax2katex fixes */
+.katex-display a[href] {
+  border-bottom: 0;
+}
+</style>
+<style>""" , 1)
+
   # Pull out math fragments.
   data = re.sub(
       'class="([^"]*)math([^"]*)"[^>]*>'
@@ -200,9 +234,13 @@ def ExtractMath(match):
   def Worker():
     while True:
       cls_before, cls_after, spans, mth, start, end = q.get()
-      fixed = ('class="' + cls_before + ' ' + cls_after + '">' +
-               spans + ReplaceMath(cache, mth) + '<')
-      done_fixups.append((start, end, fixed))
+      try:
+        fixed = ('class="' + cls_before + ' ' + cls_after + '">' +
+                 spans + ReplaceMath(cache, mth) + '<')
+        done_fixups.append((start, end, fixed))
+      except KeyboardInterrupt, AssertionError:
+        sys.stderr.write('!!! Error processing fragment')
+
       q.task_done()
       sys.stderr.write('.')
 

From c3fa573b9e37e29e7e002f1379dce133cc2f9b64 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Mon, 6 Aug 2018 16:21:06 -0700
Subject: [PATCH 271/329] Fix a few issues with CSS validation (#846)

* The CSS validator doesn't seem to allow using an unknown font-family
  name in the font shorthand.
* s/whitespace/white-space/
---
 document/core/util/katex_fix.patch | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/document/core/util/katex_fix.patch b/document/core/util/katex_fix.patch
index e1f1bf59c..6467e9753 100644
--- a/document/core/util/katex_fix.patch
+++ b/document/core/util/katex_fix.patch
@@ -2,25 +2,27 @@
 < .katex-display {
 ---
 > div > .katex-display {
-123c123,124
+123c123,126
 <   font: normal 1.21em KaTeX_Main, Times New Roman, serif;
 ---
 >   /* font: normal 1.21em KaTeX_Main, Times New Roman, serif; */
->   font: normal KaTeX_Main, Times New Roman, serif;
-127d127
+>   font-weight: normal;
+>   font-size: 1.21em;
+>   font-family: KaTeX_Main, Times New Roman, serif;
+127d129
 <   text-rendering: auto;
-133c133
+133c135
 <   display: inline-block;
 ---
 > /*  display: inline-block; */
-1060,1065d1059
+1060,1065d1061
 < .katex svg path {
 <   fill: currentColor;
 < }
 < .katex svg line {
 <   stroke: currentColor;
 < }
-1142a1137,1150
+1142a1139,1152
 > }
 > /* Force borders on tables */
 > table {
@@ -34,4 +36,4 @@
 >   border: 0;
 > }
 > .codepre {
->   whitespace: pre;
+>   white-space: pre;

From 68cae913d57405a9d592e9986e8322caf3a10ad0 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Tue, 7 Aug 2018 16:12:09 +0800
Subject: [PATCH 272/329] [test] Add some tests for `br_if` (#837)

---
 test/core/br_if.wast  | 222 ++++++++++++++++++++++++++++++++++++++++++
 test/core/unwind.wast |  64 ++++++++++++
 2 files changed, 286 insertions(+)

diff --git a/test/core/br_if.wast b/test/core/br_if.wast
index 0aa46d471..378e45fba 100644
--- a/test/core/br_if.wast
+++ b/test/core/br_if.wast
@@ -3,6 +3,32 @@
 (module
   (func $dummy)
 
+  (func (export "type-i32")
+    (block (drop (i32.ctz (br_if 0 (i32.const 0) (i32.const 1)))))
+  )
+  (func (export "type-i64")
+    (block (drop (i64.ctz (br_if 0 (i64.const 0) (i32.const 1)))))
+  )
+  (func (export "type-f32")
+    (block (drop (f32.neg (br_if 0 (f32.const 0) (i32.const 1)))))
+  )
+  (func (export "type-f64")
+    (block (drop (f64.neg (br_if 0 (f64.const 0) (i32.const 1)))))
+  )
+
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (br_if 0 (i64.const 2) (i32.const 1))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (br_if 0 (f32.const 3) (i32.const 1))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (br_if 0 (f64.const 4) (i32.const 1))))
+  )
+
   (func (export "as-block-first") (param i32) (result i32)
     (block (br_if 0 (get_local 0)) (return (i32.const 2))) (i32.const 3)
   )
@@ -42,6 +68,52 @@
     (loop (call $dummy) (br_if 1 (get_local 0)))
   )
 
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)))
+      (i32.const 4)
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 2) (br_if 0 (i32.const 1) (get_local 0))))
+      (i32.const 4)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (br_if 0 (i32.const 1) (i32.const 2)) (i32.const 3)) (i32.const 4)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 2) (br_if 0 (i32.const 1) (i32.const 3))) (i32.const 4)
+    )
+  )
+  (func (export "as-return-value") (result i64)
+    (block (result i64) (return (br_if 0 (i64.const 1) (i32.const 2))))
+  )
+
+  (func (export "as-if-cond") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32)
+        (br_if 0 (i32.const 1) (get_local 0))
+        (then (i32.const 2))
+        (else (i32.const 3))
+      )
+    )
+  )
   (func (export "as-if-then") (param i32 i32)
     (block
       (if (get_local 0) (then (br_if 1 (get_local 1))) (else (call $dummy)))
@@ -53,6 +125,102 @@
     )
   )
 
+  (func (export "as-select-first") (param i32) (result i32)
+    (block (result i32)
+      (select (br_if 0 (i32.const 3) (i32.const 10)) (i32.const 2) (get_local 0))
+    )
+  )
+  (func (export "as-select-second") (param i32) (result i32)
+    (block (result i32)
+      (select (i32.const 1) (br_if 0 (i32.const 3) (i32.const 10)) (get_local 0))
+    )
+  )
+  (func (export "as-select-cond") (result i32)
+    (block (result i32)
+      (select (i32.const 1) (i32.const 2) (br_if 0 (i32.const 3) (i32.const 10)))
+    )
+  )
+
+ (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (block (result i32)
+      (call $f
+        (br_if 0 (i32.const 12) (i32.const 1)) (i32.const 2) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-mid") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (br_if 0 (i32.const 13) (i32.const 1)) (i32.const 3)
+      )
+    )
+  )
+  (func (export "as-call-last") (result i32)
+    (block (result i32)
+      (call $f
+        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 14) (i32.const 1))
+      )
+    )
+  )
+
+  (func $func (param i32 i32 i32) (result i32) (get_local 0))
+  (type $check (func (param i32 i32 i32) (result i32)))
+  (table anyfunc (elem $func))
+  (func (export "as-call_indirect-func") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (br_if 0 (i32.const 4) (i32.const 10))
+        (i32.const 1) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (br_if 0 (i32.const 4) (i32.const 10)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (i32.const 3) (br_if 0 (i32.const 4) (i32.const 10))
+      )
+    )
+  )
+
+  (func (export "as-set_local-value") (param i32) (result i32)
+    (local i32)
+    (block (result i32)
+      (set_local 0 (br_if 0 (i32.const 17) (get_local 0)))
+      (i32.const -1)
+    )
+  )
+
+  (func (export "as-unary-operand") (result f64)
+    (block (result f64) (f64.neg (br_if 0 (f64.const 1.0) (i32.const 1))))
+  )
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32) (i32.sub (i32.const 10) (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+
+  (memory 0)
+  (func (export "as-memory.grow-size") (result i32)
+    (block (result i32) (memory.grow (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+
   (func (export "nested-block-value") (param i32) (result i32)
     (i32.add
       (i32.const 1)
@@ -147,14 +315,30 @@
       )
     )
   )
+
 )
 
+(assert_return (invoke "type-i32"))
+(assert_return (invoke "type-i64"))
+(assert_return (invoke "type-f32"))
+(assert_return (invoke "type-f64"))
+
+(assert_return (invoke "type-i32-value") (i32.const 1))
+(assert_return (invoke "type-i64-value") (i64.const 2))
+(assert_return (invoke "type-f32-value") (f32.const 3))
+(assert_return (invoke "type-f64-value") (f64.const 4))
+
 (assert_return (invoke "as-block-first" (i32.const 0)) (i32.const 2))
 (assert_return (invoke "as-block-first" (i32.const 1)) (i32.const 3))
 (assert_return (invoke "as-block-mid" (i32.const 0)) (i32.const 2))
 (assert_return (invoke "as-block-mid" (i32.const 1)) (i32.const 3))
 (assert_return (invoke "as-block-last" (i32.const 0)))
 (assert_return (invoke "as-block-last" (i32.const 1)))
+
+(assert_return (invoke "as-block-first-value" (i32.const 0)) (i32.const 11))
+(assert_return (invoke "as-block-first-value" (i32.const 1)) (i32.const 10))
+(assert_return (invoke "as-block-mid-value" (i32.const 0)) (i32.const 21))
+(assert_return (invoke "as-block-mid-value" (i32.const 1)) (i32.const 20))
 (assert_return (invoke "as-block-last-value" (i32.const 0)) (i32.const 11))
 (assert_return (invoke "as-block-last-value" (i32.const 1)) (i32.const 11))
 
@@ -165,6 +349,21 @@
 (assert_return (invoke "as-loop-last" (i32.const 0)))
 (assert_return (invoke "as-loop-last" (i32.const 1)))
 
+(assert_return (invoke "as-br-value") (i32.const 1))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 1))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 1))
+(assert_return (invoke "as-br_table-value-index") (i32.const 1))
+
+(assert_return (invoke "as-return-value") (i64.const 1))
+
+(assert_return (invoke "as-if-cond" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-if-cond" (i32.const 1)) (i32.const 1))
 (assert_return (invoke "as-if-then" (i32.const 0) (i32.const 0)))
 (assert_return (invoke "as-if-then" (i32.const 4) (i32.const 0)))
 (assert_return (invoke "as-if-then" (i32.const 0) (i32.const 1)))
@@ -174,6 +373,29 @@
 (assert_return (invoke "as-if-else" (i32.const 0) (i32.const 1)))
 (assert_return (invoke "as-if-else" (i32.const 3) (i32.const 1)))
 
+(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-select-second" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-select-second" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-select-cond") (i32.const 3))
+
+(assert_return (invoke "as-call-first") (i32.const 12))
+(assert_return (invoke "as-call-mid") (i32.const 13))
+(assert_return (invoke "as-call-last") (i32.const 14))
+
+(assert_return (invoke "as-call_indirect-func") (i32.const 4))
+(assert_return (invoke "as-call_indirect-first") (i32.const 4))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 4))
+(assert_return (invoke "as-call_indirect-last") (i32.const 4))
+
+(assert_return (invoke "as-set_local-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-set_local-value" (i32.const 1)) (i32.const 17))
+
+(assert_return (invoke "as-unary-operand") (f64.const 1.0))
+(assert_return (invoke "as-binary-left") (i32.const 1))
+(assert_return (invoke "as-binary-right") (i32.const 1))
+(assert_return (invoke "as-memory.grow-size") (i32.const 1))
+
 (assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 21))
 (assert_return (invoke "nested-block-value" (i32.const 1)) (i32.const 9))
 (assert_return (invoke "nested-br-value" (i32.const 0)) (i32.const 5))
diff --git a/test/core/unwind.wast b/test/core/unwind.wast
index 40b0dcf6f..85db60b59 100644
--- a/test/core/unwind.wast
+++ b/test/core/unwind.wast
@@ -10,6 +10,12 @@
   (func (export "func-unwind-by-br-value") (result i32)
     (i32.const 3) (i64.const 1) (br 0 (i32.const 9))
   )
+  (func (export "func-unwind-by-br_if")
+    (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 1))))
+  )
+  (func (export "func-unwind-by-br_if-value") (result i32)
+    (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 9) (i32.const 1))))
+  )
   (func (export "func-unwind-by-br_table")
     (i32.const 3) (i64.const 1) (br_table 0 (i32.const 0))
   )
@@ -29,6 +35,14 @@
   (func (export "block-unwind-by-br-value") (result i32)
     (block (result i32) (i32.const 3) (i64.const 1) (br 0 (i32.const 9)))
   )
+  (func (export "block-unwind-by-br_if") (result i32)
+    (block (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 1))))) (i32.const 9)
+  )
+  (func (export "block-unwind-by-br_if-value") (result i32)
+    (block (result i32)
+      (i32.const 3) (i64.const 1) (drop (drop (br_if 0 (i32.const 9) (i32.const 1))))
+    )
+  )
   (func (export "block-unwind-by-br_table") (result i32)
     (block (i32.const 3) (i64.const 1) (br_table 0 (i32.const 0))) (i32.const 9)
   )
@@ -52,6 +66,14 @@
       (i32.const 3) (block (i64.const 1) (br 1 (i32.const 9)))
     )
   )
+  (func (export "block-nested-unwind-by-br_if") (result i32)
+    (block (i32.const 3) (block (i64.const 1) (drop (br_if 1 (i32.const 1)))) (drop)) (i32.const 9)
+  )
+  (func (export "block-nested-unwind-by-br_if-value") (result i32)
+    (block (result i32)
+      (i32.const 3) (block (i64.const 1) (drop (drop (br_if 1 (i32.const 9) (i32.const 1)))))
+    )
+  )
   (func (export "block-nested-unwind-by-br_table") (result i32)
     (block
       (i32.const 3) (block (i64.const 1) (br_table 1 (i32.const 1)))
@@ -77,6 +99,11 @@
   (func (export "unary-after-br") (result i32)
     (block (result i32) (f32.const 0) (br 0 (i32.const 9)) (i64.eqz))
   )
+  (func (export "unary-after-br_if") (result i32)
+    (block (result i32)
+      (i64.const 0) (drop (br_if 0 (i32.const 9) (i32.const 1))) (i64.eqz)
+    )
+  )
   (func (export "unary-after-br_table") (result i32)
     (block (result i32)
       (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0)) (i64.eqz)
@@ -94,6 +121,12 @@
       (f32.const 0) (f64.const 1) (br 0 (i32.const 9)) (i64.eq)
     )
   )
+  (func (export "binary-after-br_if") (result i32)
+    (block (result i32)
+      (i64.const 0) (i64.const 1) (drop (br_if 0 (i32.const 9) (i32.const 1)))
+      (i64.eq)
+    )
+  )
   (func (export "binary-after-br_table") (result i32)
     (block (result i32)
       (f32.const 0) (f64.const 1) (br_table 0 (i32.const 9) (i32.const 0))
@@ -112,6 +145,13 @@
       (f32.const 0) (f64.const 1) (i64.const 0) (br 0 (i32.const 9)) (select)
     )
   )
+  (func (export "select-after-br_if") (result i32)
+    (block (result i32)
+      (i32.const 0) (i32.const 1) (i32.const 0)
+      (drop (br_if 0 (i32.const 9) (i32.const 1)))
+      (select)
+    )
+  )
   (func (export "select-after-br_table") (result i32)
     (block (result i32)
       (f32.const 0) (f64.const 1) (i64.const 0)
@@ -129,6 +169,11 @@
   (func (export "block-value-after-br") (result i32)
     (block (result i32) (f32.const 0) (br 0 (i32.const 9)))
   )
+  (func (export "block-value-after-br_if") (result i32)
+    (block (result i32)
+      (i32.const 0) (drop (br_if 0 (i32.const 9) (i32.const 1)))
+    )
+  )
   (func (export "block-value-after-br_table") (result i32)
     (block (result i32)
       (f32.const 0) (br_table 0 0 (i32.const 9) (i32.const 0))
@@ -144,6 +189,14 @@
   (func (export "loop-value-after-br") (result i32)
     (block (result i32) (loop (result i32) (f32.const 0) (br 1 (i32.const 9))))
   )
+  (func (export "loop-value-after-br_if") (result i32)
+    (block (result i32)
+      (loop (result i32)
+        (i32.const 0) (drop (br_if 1 (i32.const 9) (i32.const 1)))
+      )
+    )
+  )
+
   (func (export "loop-value-after-br_table") (result i32)
     (block (result i32)
       (loop (result i32)
@@ -159,6 +212,8 @@
 (assert_trap (invoke "func-unwind-by-unreachable") "unreachable")
 (assert_return (invoke "func-unwind-by-br"))
 (assert_return (invoke "func-unwind-by-br-value") (i32.const 9))
+(assert_return (invoke "func-unwind-by-br_if"))
+(assert_return (invoke "func-unwind-by-br_if-value") (i32.const 9))
 (assert_return (invoke "func-unwind-by-br_table"))
 (assert_return (invoke "func-unwind-by-br_table-value") (i32.const 9))
 (assert_return (invoke "func-unwind-by-return") (i32.const 9))
@@ -166,6 +221,8 @@
 (assert_trap (invoke "block-unwind-by-unreachable") "unreachable")
 (assert_return (invoke "block-unwind-by-br") (i32.const 9))
 (assert_return (invoke "block-unwind-by-br-value") (i32.const 9))
+(assert_return (invoke "block-unwind-by-br_if") (i32.const 9))
+(assert_return (invoke "block-unwind-by-br_if-value") (i32.const 9))
 (assert_return (invoke "block-unwind-by-br_table") (i32.const 9))
 (assert_return (invoke "block-unwind-by-br_table-value") (i32.const 9))
 (assert_return (invoke "block-unwind-by-return") (i32.const 9))
@@ -173,31 +230,38 @@
 (assert_trap (invoke "block-nested-unwind-by-unreachable") "unreachable")
 (assert_return (invoke "block-nested-unwind-by-br") (i32.const 9))
 (assert_return (invoke "block-nested-unwind-by-br-value") (i32.const 9))
+(assert_return (invoke "block-nested-unwind-by-br_if") (i32.const 9))
+(assert_return (invoke "block-nested-unwind-by-br_if-value") (i32.const 9))
 (assert_return (invoke "block-nested-unwind-by-br_table") (i32.const 9))
 (assert_return (invoke "block-nested-unwind-by-br_table-value") (i32.const 9))
 (assert_return (invoke "block-nested-unwind-by-return") (i32.const 9))
 
 (assert_trap (invoke "unary-after-unreachable") "unreachable")
 (assert_return (invoke "unary-after-br") (i32.const 9))
+(assert_return (invoke "unary-after-br_if") (i32.const 9))
 (assert_return (invoke "unary-after-br_table") (i32.const 9))
 (assert_return (invoke "unary-after-return") (i32.const 9))
 
 (assert_trap (invoke "binary-after-unreachable") "unreachable")
 (assert_return (invoke "binary-after-br") (i32.const 9))
+(assert_return (invoke "binary-after-br_if") (i32.const 9))
 (assert_return (invoke "binary-after-br_table") (i32.const 9))
 (assert_return (invoke "binary-after-return") (i32.const 9))
 
 (assert_trap (invoke "select-after-unreachable") "unreachable")
 (assert_return (invoke "select-after-br") (i32.const 9))
+(assert_return (invoke "select-after-br_if") (i32.const 9))
 (assert_return (invoke "select-after-br_table") (i32.const 9))
 (assert_return (invoke "select-after-return") (i32.const 9))
 
 (assert_trap (invoke "block-value-after-unreachable") "unreachable")
 (assert_return (invoke "block-value-after-br") (i32.const 9))
+(assert_return (invoke "block-value-after-br_if") (i32.const 9))
 (assert_return (invoke "block-value-after-br_table") (i32.const 9))
 (assert_return (invoke "block-value-after-return") (i32.const 9))
 
 (assert_trap (invoke "loop-value-after-unreachable") "unreachable")
 (assert_return (invoke "loop-value-after-br") (i32.const 9))
+(assert_return (invoke "loop-value-after-br_if") (i32.const 9))
 (assert_return (invoke "loop-value-after-br_table") (i32.const 9))
 (assert_return (invoke "loop-value-after-return") (i32.const 9))

From 151248adad8e7441ea043cfe92b197cbac66be27 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Tue, 7 Aug 2018 01:46:35 -0700
Subject: [PATCH 273/329] Add script to diff HTML against previous version
 (#847)

This uses the same htmldiff script as found in the w3c HTML diff
service: https://services.w3.org/htmldiff

To diff locally, run: `make diff` in the core directory.
---
 document/core/Makefile                |  10 +
 document/core/util/README.htmldiff.pl |   2 +
 document/core/util/htmldiff.pl        | 588 ++++++++++++++++++++++++++
 3 files changed, 600 insertions(+)
 create mode 100644 document/core/util/README.htmldiff.pl
 create mode 100755 document/core/util/htmldiff.pl

diff --git a/document/core/Makefile b/document/core/Makefile
index 5a34a52cc..63983426d 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -27,6 +27,7 @@ usage:
 	@echo "  html       to make standalone HTML files"
 	@echo "  pdf        to make standalone PDF file"
 	@echo "  bikeshed   to make a bikeshed wrapped single large HTML file"
+	@echo "  diff       to make a diff of the bikeshed HTML file with the latest TR"
 	@echo "  all        to make all 3"
 	@echo "  publish    to make all and push to gh-pages"
 	@echo "  help       to see more options"
@@ -155,6 +156,15 @@ bikeshed:
 	@echo
 	@echo "Build finished. The HTML page is in $(BUILDDIR)/html/bikeshed/."
 
+.PHONY: diff
+diff: bikeshed
+	@echo "Downloading the old single-file html spec..."
+	curl `grep "^TR" index.bs | cut -d' ' -f2` -o $(BUILDDIR)/html/bikeshed/old.html
+	@echo "Done."
+	@echo "Diffing new against old (go get a coffee)..."
+	perl util/htmldiff.pl $(BUILDDIR)/html/bikeshed/old.html $(BUILDDIR)/html/bikeshed/index.html $(BUILDDIR)/html/bikeshed/diff.html
+	@echo "Done. The diff is at $(BUILDDIR)/html/bikeshed/diff.html"
+
 .PHONY: pickle
 pickle:
 	$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
diff --git a/document/core/util/README.htmldiff.pl b/document/core/util/README.htmldiff.pl
new file mode 100644
index 000000000..877fa69bd
--- /dev/null
+++ b/document/core/util/README.htmldiff.pl
@@ -0,0 +1,2 @@
+This file is a copy of the HTML diff script found here:
+https://dev.w3.org/cvsweb/2009/htmldiff/
diff --git a/document/core/util/htmldiff.pl b/document/core/util/htmldiff.pl
new file mode 100755
index 000000000..4c2780c83
--- /dev/null
+++ b/document/core/util/htmldiff.pl
@@ -0,0 +1,588 @@
+#!/usr/bin/perl
+#
+# htmldiff - present a diff marked version of two html documents
+#
+# Copyright (c) 1998-2006 MACS, Inc.
+#
+# Copyright (c) 2007 SiSco, Inc.
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# See http://www.themacs.com for more information.
+#
+# usage: htmldiff [[-c] [-l] [-o] oldversion newversion [output]]
+#
+# -c - disable metahtml comment processing
+# -o - disable outputting of old text
+# -l - use navindex to create sequence of diffs
+# oldversion - the previous version of the document
+# newversion - the newer version of the document
+# output - a filename to place the output in. If omitted, the output goes to
+#          standard output.
+#
+# if invoked with no options or arguments, operates as a CGI script. It then
+# takes the following parameters:
+#
+# oldfile - the URL of the original file
+# newfile - the URL of the new file
+# mhtml - a flag to indicate whether it should be aware of MetaHTML comments.
+#
+# requires GNU diff utility
+# also requires the perl modules Getopt::Std
+#
+# NOTE: The markup created by htmldiff may not validate against the HTML 4.0
+# DTD. This is because the algorithm is realtively simple, and there are
+# places in the markup content model where the span element is not allowed.
+# Htmldiff is NOT aware of these places.
+#
+# $Source: /u/sources/public/2009/htmldiff/htmldiff.pl,v $
+# $Revision: 1.7 $
+#
+# $Log: htmldiff.pl,v $
+# Revision 1.7  2018/05/17 14:17:56  dom
+# Summary: take into account no </head>
+#
+# Revision 1.6  2018/05/17 13:53:51  dom
+# Switch from tidy to html5lib for preparing to htmldiff
+#
+# also, adapt a more robust approach to including diff style/script
+#
+# Revision 1.5  2017/03/30 09:04:03  dom
+# Summary: Update link to navigation script
+#
+# Revision 1.4  2017/02/10 10:48:41  dom
+# Remove :focus rule per Simon Pieters request
+#
+# Revision 1.3  2016/10/24 15:06:51  dom
+# Summary: Use nav script always
+#
+# Revision 1.2  2016/10/24 15:04:28  dom
+# Add navigation script
+#
+# Revision 1.1  2014-01-06 08:04:51  dom
+# added copy of htmldiff perl script since aptest.com repo no longer available
+#
+# Revision 1.5  2008/03/05 13:23:16  ahby
+# Fixed a problem with leading whitespace before markup.
+#
+# Revision 1.4  2007/12/13 13:09:16  ahby
+# Updated copyright and license.
+#
+# Revision 1.3  2007/12/13 12:53:34  ahby
+# Changed use of span to ins and del
+#
+# Revision 1.2  2002/02/13 16:27:23  ahby
+# Changed processing model.
+# Improved handling of old text and changed styles.
+#
+# Revision 1.1  2000/07/12 12:20:04  ahby
+# Updated to remove empty spans - this fixes validation problems under
+# strict.
+#
+# Revision 1.11  1999/12/08 19:46:45  ahby
+# Fixed validation errors introduced by placing markup where it didn't
+# belong.
+#
+# Revision 1.10  1999/10/18 13:42:58  ahby
+# Added -o to the usage message.
+#
+# Revision 1.9  1999/05/04 12:29:11  ahby
+# Added an option to turn off the display of old text.
+#
+# Revision 1.8  1999/04/09 14:37:27  ahby
+# Fixed a perl syntax error.
+#
+# Revision 1.7  1999/04/09 14:35:49  ahby
+# Added reference to MACS homepage.
+#
+# Revision 1.6  1999/04/09 14:35:09  ahby
+# Added comment about validity of generated markup.
+#
+# Revision 1.5  1999/02/22 22:17:54  ahby
+# Changed to use stylesheets.
+# Changed to rely upon span.
+# Changed to work around content model problems.
+#
+# Revision 1.4  1999/02/08 02:32:22  ahby
+# Added a copyright statement.
+#
+# Revision 1.3  1999/02/08 02:30:40  ahby
+# Added header processing.
+#
+# Revision 1.2  1998/12/10 17:31:31  ahby
+# Fixed to escape less-thans in change blocks and to not permit change
+# markup within specific elements (like TITLE).
+#
+# Revision 1.1  1998/11/26 00:09:22  ahby
+# Initial revision
+#
+#
+
+use Getopt::Std;
+
+sub usage {
+	print STDERR "htmldiff [-c] [-o] oldversion newversion [output]\n";
+	exit;
+}
+
+sub url_encode {
+    my $str = shift;
+    $str =~ s/([\x00-\x1f\x7F-\xFF])/
+                 sprintf ('%%%02x', ord ($1))/eg;
+    return $str;
+}
+
+# markit - diff-mark the streams
+#
+# markit(file1, file2)
+#
+# markit relies upon GNUdiff to mark up the text.
+#
+# The markup is encoded using special control sequences:
+#
+#   a block wrapped in control-a is deleted text
+#   a block wrapped in control-b is old text
+#   a block wrapped in control-c is new text
+#
+# The main processing loop attempts to wrap the text blocks in appropriate
+# SPANs based upon the type of text that it is.
+#
+# When the loop encounters a < in the text, it stops the span. Then it outputs
+# the element that is defined, then it restarts the span.
+
+sub markit {
+	my $retval = "";
+	my($file1) = shift;
+	my($file2) = shift;
+#	my $old="<span class=\\\"diff-old-a\\\">deleted text: </span>%c'\012'%c'\001'%c'\012'%<%c'\012'%c'\001'%c'\012'";
+	my $old="%c'\012'%c'\001'%c'\012'%<%c'\012'%c'\001'%c'\012'";
+	my $new="%c'\012'%c'\003'%c'\012'%>%c'\012'%c'\003'%c'\012'";
+	my $unchanged="%=";
+	my $changed="%c'\012'%c'\001'%c'\012'%<%c'\012'%c'\001'%c'\012'%c'\004'%c'\012'%>%c'\012'%c'\004'%c'\012'";
+	if ($opt_o) {
+		$old = "";
+		$changed = "%c'\012'%c'\004'%c'\012'%>%c'\012'%c'\004'%c'\012'";
+	}
+#	my $old="%c'\002'<font color=\\\"purple\\\" size=\\\"-2\\\">deleted text:</font><s>%c'\012'%c'\001'%c'\012'%<%c'\012'%c'\001'%c'\012'</s>%c'\012'%c'\002'";
+#	my $new="%c'\002'<font color=\\\"purple\\\"><u>%c'\012'%c'\002'%>%c'\002'</u></font>%c'\002'%c'\012'";
+#	my $unchanged="%=";
+#	my $changed="%c'\002'<s>%c'\012'%c'\001'%c'\012'%<%c'\012'%c'\001'%c'\012'</s><font color=\\\"purple\\\"><u>%c'\002'%c'\012'%>%c'\012'%c'\002'</u></font>%c'\002'%c'\012'";
+
+	my @span;
+	$span[0]="</span>";
+	$span[1]="<del class=\"diff-old\">";
+	$span[2]="<del class=\"diff-old\">";
+	$span[3]="<ins class=\"diff-new\">";
+	$span[4]="<ins class=\"diff-chg\">";
+	
+	my @diffEnd ;
+	$diffEnd[1] = '</del>';
+	$diffEnd[2] = '</del>';
+	$diffEnd[3] = '</ins>';
+	$diffEnd[4] = '</ins>';
+
+	my $diffcounter = 0;
+
+	open(FILE, qq(diff -d --old-group-format="$old" --new-group-format="$new" --changed-group-format="$changed" --unchanged-group-format="$unchanged" $file1 $file2 |)) || die("Diff failed: $!");
+#	system (qq(diff --old-group-format="$old" --new-group-format="$new" --changed-group-format="$changed" --unchanged-group-format="$unchanged" $file1 $file2 > /tmp/output));
+
+	my $state = 0;
+	my $inblock = 0;
+	my $temp = "";
+	my $lineCount = 0;
+
+# strategy: 
+#
+# process the output of diff...
+#
+# a link with control A-D means the start/end of the corresponding ordinal
+# state (1-4). Resting state is state 0.
+#
+# While in a state, accumulate the contents for that state. When exiting the
+# state, determine if it is appropriate to emit the contents with markup or
+# not (basically, if the accumulated buffer contains only empty lines or lines
+# with markup, then we don't want to emit the wrappers.  We don't need them.
+#
+# Note that if there is markup in the "old" block, that markup is silently
+# removed.  It isn't really that interesting, and it messes up the output
+# something fierce.
+
+	while (<FILE>) {
+		my $anchor = $opt_l ? qq[<a tabindex="$diffcounter">] : "" ;
+		my $anchorEnd = $opt_l ? q[</a>] : "" ;
+		$lineCount ++;
+		if ($state == 0) {	# if we are resting and we find a marker, 
+							# then we must be entering a block
+			if (m/^([\001-\004])/) {
+				$state = ord($1);
+				$_ = "";
+			}
+#			if (m/^\001/) {
+#				$state = 1;
+#				s/^/$span[1]/;
+#			} elsif (m/^\002/) {
+#				$state = 2;
+#				s/^/$span[2]/;
+#			} elsif (m/^\003/) {
+#				$state = 3;
+#				s/^/$span[3]/;
+#			} elsif (m/^\004/) {
+#				$state = 4;
+#				s/^/$span[4]/;
+#			}
+		} else {
+			# if we are in "old" state, remove markup
+			if (($state == 1) || ($state == 2)) {
+				s/\<.*\>//;	# get rid of any old markup
+				s/\</&lt;/g; # escape any remaining STAG or ETAGs
+				s/\>/&gt;/g;
+			}
+			# if we found another marker, we must be exiting the state
+			if (m/^([\001-\004])/) {
+				if ($temp ne "") {
+					$_ = $span[$state] . $anchor . $temp . $anchorEnd . $diffEnd[$state] . "\n";
+					$temp = "";
+				} else {
+					$_ = "" ;
+				}
+				$state = 0;
+			} elsif (m/^\s*\</) { # otherwise, is this line markup?
+				# if it is markup AND we haven't seen anything else yet,
+				# then we will emit the markup
+				if ($temp eq "") {
+					$retval .= $_;
+					$_ = "";
+				} else {	# we wrap it with the state switches and hold it
+					s/^/$anchorEnd$diffEnd[$state]/;
+					s/$/$span[$state]$anchor/;
+					$temp .= $_;
+					$_ = "";
+				}
+			} else {
+				if (m/.+/) {
+					$temp .= $_;
+					$_ = "";
+				}
+			}
+		}
+
+		s/\001//g;
+		s/\002//g;
+		s/\003//g;
+		s/\004//g;
+		if ($_ !~ m/^$/) {
+			$retval .= $_;
+		}
+		$diffcounter++;
+	}
+	close FILE;
+	$retval =~ s/$span[1]\n+$diffEnd[1]//g;
+	$retval =~ s/$span[2]\n+$diffEnd[2]//g;
+	$retval =~ s/$span[3]\n+$diffEnd[3]//g;
+	$retval =~ s/$span[4]\n+$diffEnd[4]//g;
+	$retval =~ s/$span[1]\n*$//g;
+	$retval =~ s/$span[2]\n*$//g;
+	$retval =~ s/$span[3]\n*$//g;
+	$retval =~ s/$span[4]\n*$//g;
+	return $retval;
+}
+
+sub splitit {
+	my $filename = shift;
+	my $headertmp = shift;
+	my $inheader=0;
+	my $preformatted=0;
+	my $inelement=0;
+	my $retval = "";
+	my $styles = q(<style type='text/css'>
+.diff-old-a {
+  font-size: smaller;
+  color: red;
+}
+
+.diff-new { background-color: yellow; }
+.diff-chg { background-color: lime; }
+.diff-new:before,
+.diff-new:after
+    { content: "\2191" }
+.diff-chg:before, .diff-chg:after
+    { content: "\2195" }
+.diff-old { text-decoration: line-through; background-color: #FBB; }
+.diff-old:before,
+.diff-old:after
+    { content: "\2193" }
+</style>
+<script src="https://w3c.github.io/htmldiff-nav/index.js"></script>);
+	if ($opt_t) {
+		$styles .= q(
+<script type="text/javascript">
+<!--
+function setOldDisplay() {
+	for ( var s = 0; s < document.styleSheets.length; s++ ) {
+		var css = document.styleSheets[s];
+		var mydata ;
+		try { mydata = css.cssRules ;
+		if ( ! mydata ) mydata = css.rules;
+		for ( var r = 0; r < mydata.length; r++ ) {
+			if ( mydata[r].selectorText == '.diff-old' ) {
+				mydata[r].style.display = ( mydata[r].style.display == '' ) ? 'none'
+: '';
+				return;
+			}
+		} 
+		} catch(e) {} ;
+	}
+}
+-->
+</script>
+);
+
+	}
+	
+	if ($stripheader) {
+		open(HEADER, ">$headertmp");
+	}
+
+	my $incomment = 0;
+        my $styleprinted = 0;
+	my $inhead = 1;
+	open(FILE, $filename) || die("File $filename cannot be opened: $!");
+	while (<FILE>) {
+		if ($inhead == 1) {
+			if (m/\<\/head/i) {
+                                s/\<\/head/$styles\<\/head/i;
+                                $styleprinted = 1;
+			}
+			if (m/\<body/i) {
+                                if (!$styleprinted) {
+                                      s/\<body/$styles\<body/i;
+                                }
+				$inhead = 0;
+				print HEADER;
+				if ($opt_t) {
+					print HEADER q(
+<form action=""><input type="button" onclick="setOldDisplay()" value="Show/Hide Old Content" /></form>
+);
+				}
+				close HEADER;
+			} else {
+				print HEADER;
+			}
+		} else {
+			if ($incomment) {
+				if (m;-->;) {
+					$incomment = 0;
+					s/.*-->//;
+				} else {
+					next;
+				}
+			}
+			if (m;<!--;) {
+				while (m;<!--.*-->;) {
+					s/<!--.*?-->//;
+				}
+				if (m;<!--; ) {
+					$incomment = 1;
+					s/<!--.*//;
+				}
+			}
+			if (m/\<pre/i) {
+				$preformatted = 1;
+			}
+			if (m/\<\/pre\>/i) {
+				$preformatted = 0;
+			}
+			if ($preformatted) {
+				$retval .= $_;
+			} elsif ($mhtmlcomments && /^;;;/) {
+				$retval .= $_;
+			} else {
+				my @list = split(' ');
+				foreach $element (@list) {
+					if ($element =~ m/\<H[1-6]/i) {
+#						$inheader = 1;
+					}
+					if ($inheader == 0) {
+						$element =~ s/</\n</g;
+						$element =~ s/^\n//;
+						$element =~ s/>/>\n/g;
+						$element =~ s/\n$//;
+						$element =~ s/>\n([.,:!]+)/>$1/g;
+					}
+					if ($element =~ m/\<\/H[1-6]\>/i) {
+						$inheader = 0;
+					}
+					$retval .= "$element";
+					$inelement += ($element =~ s/</&lt;/g);
+					$inelement -= ($element =~ s/>/&gt;/g);
+					if ($inelement < 0) {
+						$inelement = 0;
+					}
+					if (($inelement == 0) && ($inheader == 0)) {
+						$retval .= "\n";
+					} else {
+						$retval .= " ";
+					}
+				}
+			undef @list;
+			}
+		}
+	}
+	$retval .= "\n";
+	close FILE;
+	return $retval;
+}
+
+$mhtmlcomments = 1;
+
+sub cli {
+	getopts("clto") || usage();
+
+	if ($opt_c) {$mhtmlcomments = 0;}
+
+	if (@ARGV < 2) { usage(); }
+
+	$file1 = $ARGV[0];
+	$file2 = $ARGV[1];
+	$file3 = $ARGV[2];
+
+	$tmp = splitit($file1, $headertmp1);
+	open (FILE, ">$tmp1");
+	print FILE $tmp;
+	close FILE;
+
+	$tmp = splitit($file2, $headertmp2);
+	open (FILE, ">$tmp2");
+	print FILE $tmp;
+	close FILE;
+
+	$output = "";
+
+	if ($stripheader) {
+		open(FILE, $headertmp2);
+		while (<FILE>) {
+			$output .= $_;
+		}
+		close(FILE);
+	}
+
+	$output .= markit($tmp1, $tmp2);
+
+	if ($file3) {
+		open(FILE, ">$file3");
+		print FILE $output;
+		close FILE;
+	} else {
+		print $output;
+	}
+}
+
+sub cgi {
+#	use LWP::UserAgent;
+#	use CGI;
+
+	my $query = new CGI;
+	my $url1 = $query->param("oldfile");
+	my $url2 = $query->param("newfile");
+	my $mhtml = $query->param("mhtml");
+
+	my $file1 = "/tmp/htdcgi1.$$";
+	my $file2 = "/tmp/htdcgi2.$$";
+
+	my $ua = new LWP::UserAgent;
+	$ua->agent("MACS, Inc. HTMLdiff/0.9 " . $ua->agent);
+
+	# Create a request
+
+	my $req1 = new HTTP::Request GET => $url1;
+
+	my $res1 = $ua->request($req1, $file1);
+	if ($res1->is_error) {
+		print $res1->error_as_HTML();
+		print "<p>The URL $url1 could not be found.  Please check it and try again.</p>";
+		return;
+	}
+
+	my $req2 = new HTTP::Request GET => $url2;
+
+	my $res2 = $ua->request($req2, $file2);
+	if ($res2->is_error) {
+		print $res2->error_as_HTML();
+		print "<p>The URL $url2 could not be found.  Please check it and try again.</p>";
+		return;
+	}
+
+	$split1 = splitit($file1, $headertmp1);
+	open (FILE, ">$tmp1");
+	print FILE $split1;
+	close FILE;
+
+	$split2 = splitit($file2, $headertmp2);
+	open (FILE, ">$tmp2");
+	print FILE $split2;
+	close FILE;
+
+	$output = "";
+
+	if ($stripheader) {
+		open(FILE, $headertmp2);
+		while (<FILE>) {
+			$output .= $_;
+		}
+		close(FILE);
+	}
+
+	$output .= markit($tmp1, $tmp2);
+
+	my $base=$res2->base;
+
+	if ($base !~ /\/$/) {
+		$base =~ s/[^\/]*$//;
+	}
+
+	if ( $output !~ /<base/i ) {
+		$output =~ s/<head>/<head>\n<base href="$base">/i ||
+	  	$output =~ s/<html>/<html>\n<base href="$base">/i ;
+	}
+
+	print $query->header(-type=>'text/html',-nph=>1);
+	print $output;
+
+	unlink $file1;
+	unlink $file2;
+
+}
+
+$tmp1="/tmp/htdtmp1.$$";
+$headertmp1="/tmp/htdhtmp1.$$";
+$tmp2="/tmp/htdtmp2.$$";
+$headertmp2="/tmp/htdhtmp2.$$";
+$stripheader = 1;
+
+if (@ARGV == 0) {
+	cgi();		# if no arguments, we must be operating as a cgi script
+} else {
+	cli();		# if there are arguments, then we are operating as a CLI
+}
+
+unlink $tmp1;
+unlink $headertmp1;
+unlink $tmp2;
+unlink $headertmp2;

From ef064eaafc360bc494abb73860f701afff8cfb5b Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Tue, 7 Aug 2018 17:49:23 +0200
Subject: [PATCH 274/329] Various cleanup in the Web API specification. (#848)

* Mark arguments as variables.

This is the standard bikeshed convention, and fixes some single-use variable
warnings.

* Fix links to 'resolve' for Promises.

Fixes #845.

* Fix interaction of notes and lists.

These notes should be part of a list item, rather than splitting the list.
---
 document/web-api/index.bs | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index fe3c3ed39..17e73b4a5 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -75,6 +75,7 @@ url:https://w3c.github.io/webappsec-secure-contexts/#environment-settings-object
 
 <pre class='link-defaults'>
 spec:ecma-262; type:exception; for:ECMAScript; text:TypeError
+spec:promises-guide-1; type:dfn; text:resolve
 </pre>
 
 This document builds off of the WebAssembly specification [[WEBASSEMBLY]] and the WebAssembly JavaScript embedding [[WASMJS]].
@@ -90,11 +91,11 @@ partial namespace WebAssembly {
 </pre>
 
 <div algorithm>
-The <dfn method for="WebAssembly">compileStreaming(source)</dfn> method, when invoked, returns the result of [=compile a potential WebAssembly response|compiling a potential WebAssembly response=] with |source|.
+The <dfn method for="WebAssembly">compileStreaming(|source|)</dfn> method, when invoked, returns the result of [=compile a potential WebAssembly response|compiling a potential WebAssembly response=] with |source|.
 </div>
 
 <div algorithm>
-The <dfn method for="WebAssembly">instantiateStreaming(source, importObject)</dfn> method, when invoked, performs the following steps:
+The <dfn method for="WebAssembly">instantiateStreaming(|source|, |importObject|)</dfn> method, when invoked, performs the following steps:
 
     1. Let |promiseOfModule| be the result of [=compile a potential WebAssembly response|compiling a potential WebAssembly response=] with |source|.
     1. Return the result of [=instantiate a promise of a module|instantiating the promise of a module=] |promiseOfModule| with imports |importObject|.
@@ -118,15 +119,15 @@ Note: This algorithm accepts a {{Response}} object, or a
         1. Let |mimeType| be the result of [=extracting a MIME type=] from |response|'s [=response/header list=].
         1. If |mimeType| is not `` `application/wasm` ``, reject |returnValue| with a {{TypeError}} and abort these substeps.
 
-        Note: extra parameters are not allowed, including the empty `` `application/wasm;` ``.
+            Note: extra parameters are not allowed, including the empty `` `application/wasm;` ``.
 
-        4. If |response| is not [=CORS-same-origin=], [=reject=] |returnValue| with a {{TypeError}} and abort these substeps.
+        1. If |response| is not [=CORS-same-origin=], [=reject=] |returnValue| with a {{TypeError}} and abort these substeps.
         1. If |response|'s [=response/status=] is not an [=ok status=], [=reject=] |returnValue| with a {{TypeError}} and abort these substeps.
         1. [=Consume body|consume=] |response|'s body as an {{ArrayBuffer}}, and let |bodyPromise| be the result.
 
-        Note: Although it is specified here that the response is consumed entirely before compilation proceeds, that is purely for ease of specification; implementations are likely to instead perform processing in a streaming fashion. The different is unobservable, and thus the simpler model is specified. <!-- Using consume is a bit silly as it creates an ArrayBuffer but then we just want the underlying bytes. This is because of how streams is specced in terms of promises and JS objects whereas we want to operate more directly on the underlying concept. We can revisit this if things change in the Streams/Fetch specs. -->
+            Note: Although it is specified here that the response is consumed entirely before compilation proceeds, that is purely for ease of specification; implementations are likely to instead perform processing in a streaming fashion. The different is unobservable, and thus the simpler model is specified. <!-- Using consume is a bit silly as it creates an ArrayBuffer but then we just want the underlying bytes. This is because of how streams is specced in terms of promises and JS objects whereas we want to operate more directly on the underlying concept. We can revisit this if things change in the Streams/Fetch specs. -->
 
-        7. [=Upon fulfillment=] of |bodyPromise| with value |bodyArrayBuffer|:
+        1. [=Upon fulfillment=] of |bodyPromise| with value |bodyArrayBuffer|:
             1. [=Asynchronously compile a WebAssembly module|Asynchronously compile the WebAssembly module=] |bodyArrayBuffer| using the [=networking task source=] and [=resolve=] |returnValue| with the result.
         1. [=Upon rejection=] of |bodyPromise| with reason |reason|:
             1. [=Reject=] |returnValue| with |reason|.

From 10083e9a3b0d7b579d431d71e150aa0bf4bccd8f Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Wed, 8 Aug 2018 02:02:45 -0700
Subject: [PATCH 275/329] Remove immutable global notes (#849)

These are no longer true, now that the mutable-globals proposal has been
merged into the spec.
---
 document/core/valid/modules.rst | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index 1a6aa84d8..d8dd82ee1 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -330,9 +330,6 @@ Exports :math:`\export` and export descriptions :math:`\exportdesc` are classifi
      C \vdashexportdesc \EDGLOBAL~x : \ETGLOBAL~\globaltype
    }
 
-.. note::
-   In future versions of WebAssembly, the restriction to exporting only immutable globals may be removed.
-
 
 .. index:: import, name, function type, table type, memory type, global type
    pair: validation; import
@@ -422,9 +419,6 @@ Imports :math:`\import` and import descriptions :math:`\importdesc` are classifi
      C \vdashimportdesc \IDGLOBAL~\globaltype : \ETGLOBAL~\globaltype
    }
 
-.. note::
-   In future versions of WebAssembly, the restriction to importing only immutable globals may be removed.
-
 
 .. index:: module, type definition, function type, function, table, memory, global, element, data, start function, import, export, context
    pair: validation; module

From 32da67a563c787c1221c9f8d785c44ef0693dfff Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Wed, 8 Aug 2018 17:09:54 +0200
Subject: [PATCH 276/329] [test] Fix typo in the f_v signature (#850)

---
 test/harness/wasm-constants.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/harness/wasm-constants.js b/test/harness/wasm-constants.js
index 17bbedfff..486ce31d1 100644
--- a/test/harness/wasm-constants.js
+++ b/test/harness/wasm-constants.js
@@ -108,7 +108,7 @@ let kSig_i_dd = makeSig([kWasmF64, kWasmF64], [kWasmI32]);
 let kSig_v_v = makeSig([], []);
 let kSig_i_v = makeSig([], [kWasmI32]);
 let kSig_l_v = makeSig([], [kWasmI64]);
-let kSig_f_v = makeSig([], [kWasmF64]);
+let kSig_f_v = makeSig([], [kWasmF32]);
 let kSig_d_v = makeSig([], [kWasmF64]);
 let kSig_v_i = makeSig([kWasmI32], []);
 let kSig_v_ii = makeSig([kWasmI32, kWasmI32], []);

From e9128ec3b58bdff9c0ec3a28e4a048751598e630 Mon Sep 17 00:00:00 2001
From: gahaas <ahaas@google.com>
Date: Wed, 8 Aug 2018 17:10:37 +0200
Subject: [PATCH 277/329] [test] Update wasm-module-builder.js (#851)

---
 test/harness/wasm-module-builder.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index 1076ec9e7..29b5518c2 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -627,6 +627,11 @@ class WasmModuleBuilder {
     return instance;
   }
 
+  asyncInstantiate(ffi) {
+    return WebAssembly.instantiate(this.Buffer(), ffi)
+        .then(({module, instance}) => instance);
+  }
+
   toModule(debug = false) {
     return new WebAssembly.Module(this.toBuffer(debug));
   }

From 6fcbdb3825b2bcb9c3180deb647386463b0282fa Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Mon, 13 Aug 2018 16:38:47 +0800
Subject: [PATCH 278/329] [test] Improve test coverage of nop (#854)

---
 test/core/nop.wast | 136 ++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 134 insertions(+), 2 deletions(-)

diff --git a/test/core/nop.wast b/test/core/nop.wast
index 02b402816..67931a741 100644
--- a/test/core/nop.wast
+++ b/test/core/nop.wast
@@ -21,6 +21,9 @@
     (nop) (nop) (call $dummy) (nop) (i32.const 4) (nop) (nop)
   )
 
+  (func (export "as-drop-first") (param i32)
+    (nop) (get_local 0) (drop)
+  )
   (func (export "as-drop-last") (param i32)
     (get_local 0) (nop) (drop)
   )
@@ -28,6 +31,9 @@
     (nop) (nop) (get_local 0) (nop) (nop) (drop)
   )
 
+  (func (export "as-select-first") (param i32) (result i32)
+    (nop) (get_local 0) (get_local 0) (get_local 0) (select)
+  )
   (func (export "as-select-mid1") (param i32) (result i32)
     (get_local 0) (nop) (get_local 0) (get_local 0) (select)
   )
@@ -82,6 +88,9 @@
     (if (get_local 0) (then (call $dummy)) (else (nop)))
   )
 
+  (func (export "as-br-first") (param i32) (result i32)
+    (block (result i32) (nop) (get_local 0) (br 0))
+  )
   (func (export "as-br-last") (param i32) (result i32)
     (block (result i32) (get_local 0) (nop) (br 0))
   )
@@ -89,6 +98,9 @@
     (block (result i32) (nop) (nop) (get_local 0) (nop) (nop) (br 0))
   )
 
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32) (nop) (get_local 0) (get_local 0) (br_if 0))
+  )
   (func (export "as-br_if-mid") (param i32) (result i32)
     (block (result i32) (get_local 0) (nop) (get_local 0) (br_if 0))
   )
@@ -102,6 +114,9 @@
     )
   )
 
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32) (nop) (get_local 0) (get_local 0) (br_table 0 0))
+  )
   (func (export "as-br_table-mid") (param i32) (result i32)
     (block (result i32) (get_local 0) (nop) (get_local 0) (br_table 0 0))
   )
@@ -115,6 +130,9 @@
     )
   )
 
+  (func (export "as-return-first") (param i32) (result i32)
+    (nop) (get_local 0) (return)
+  )
   (func (export "as-return-last") (param i32) (result i32)
     (get_local 0) (nop) (return)
   )
@@ -122,6 +140,9 @@
     (nop) (nop) (get_local 0) (nop) (nop) (return)
   )
 
+  (func (export "as-call-first") (param i32 i32 i32) (result i32)
+    (nop) (get_local 0) (get_local 1) (get_local 2) (call $3-ary)
+  )
   (func (export "as-call-mid1") (param i32 i32 i32) (result i32)
     (get_local 0) (nop) (get_local 1) (get_local 2) (call $3-ary)
   )
@@ -136,8 +157,9 @@
     (nop) (nop) (get_local 2) (nop) (nop) (call $3-ary)
   )
 
-  ;; TODO(stack): call_indirect, *_local, load*, store*
-
+  (func (export "as-unary-first") (param i32) (result i32)
+    (nop) (get_local 0) (i32.ctz)
+  )
   (func (export "as-unary-last") (param i32) (result i32)
     (get_local 0) (nop) (i32.ctz)
   )
@@ -145,6 +167,9 @@
     (nop) (nop) (get_local 0) (nop) (nop) (i32.ctz)
   )
 
+  (func (export "as-binary-first") (param i32) (result i32)
+    (nop) (get_local 0) (get_local 0) (i32.add)
+  )
   (func (export "as-binary-mid") (param i32) (result i32)
     (get_local 0) (nop) (get_local 0) (i32.add)
   )
@@ -155,6 +180,9 @@
     (nop) (get_local 0) (nop) (nop) (get_local 0) (nop) (nop) (i32.add)
   )
 
+  (func (export "as-test-first") (param i32) (result i32)
+    (nop) (get_local 0) (i32.eqz)
+  )
   (func (export "as-test-last") (param i32) (result i32)
     (get_local 0) (nop) (i32.eqz)
   )
@@ -162,6 +190,9 @@
     (nop) (nop) (get_local 0) (nop) (nop) i32.eqz
   )
 
+  (func (export "as-compare-first") (param i32) (result i32)
+    (nop) (get_local 0) (get_local 0) (i32.ne)
+  )
   (func (export "as-compare-mid") (param i32) (result i32)
     (get_local 0) (nop) (get_local 0) (i32.ne)
   )
@@ -172,12 +203,82 @@
     (nop) (get_local 0) (nop) (nop) (get_local 0) (nop) (nop) (i32.le_s)
   )
 
+  (func (export "as-memory.grow-first") (param i32) (result i32)
+    (nop) (get_local 0) (memory.grow)
+  )
   (func (export "as-memory.grow-last") (param i32) (result i32)
     (get_local 0) (nop) (memory.grow)
   )
   (func (export "as-memory.grow-everywhere") (param i32) (result i32)
     (nop) (nop) (get_local 0) (nop) (nop) (memory.grow)
   )
+
+  (func $func (param i32 i32) (result i32) (get_local 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table anyfunc (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (nop) (i32.const 1) (i32.const 2) (i32.const 0)
+      (call_indirect (type $check))
+    )
+  )
+  (func (export "as-call_indirect-mid1") (result i32)
+    (block (result i32)
+      (i32.const 1) (nop) (i32.const 2) (i32.const 0)
+      (call_indirect (type $check))
+    )
+  )
+  (func (export "as-call_indirect-mid2") (result i32)
+    (block (result i32)
+      (i32.const 1) (i32.const 2) (nop) (i32.const 0)
+      (call_indirect (type $check))
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (i32.const 1) (i32.const 2) (i32.const 0) (nop)
+      (call_indirect (type $check))
+    )
+  )
+  (func (export "as-call_indirect-everywhere") (result i32)
+    (block (result i32)
+      (nop) (nop) (i32.const 1) (nop) (nop) (i32.const 2) (nop) (nop) (i32.const 0) (nop) (nop)
+      (call_indirect (type $check))
+    )
+  )
+
+  (func (export "as-set_local-first") (param i32) (result i32)
+    (nop) (i32.const 2) (set_local 0) (get_local 0)
+  )
+  (func (export "as-set_local-last") (param i32) (result i32)
+    (i32.const 2) (nop) (set_local 0) (get_local 0)
+  )
+  (func (export "as-set_local-everywhere") (param i32) (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (set_local 0) (get_local 0)
+  )
+
+  (func (export "as-load-first") (param i32) (result i32)
+    (nop) (get_local 0) (i32.load)
+  )
+  (func (export "as-load-last") (param i32) (result i32)
+    (get_local 0) (nop) (i32.load)
+  )
+  (func (export "as-load-everywhere") (param i32) (result i32)
+    (nop) (nop) (get_local 0) (nop) (nop) (i32.load)
+  )
+
+  (func (export "as-store-first") (param i32 i32)
+    (nop) (get_local 0) (get_local 1) (i32.store)
+  )
+  (func (export "as-store-mid") (param i32 i32)
+    (get_local 0) (nop) (get_local 1) (i32.store)
+  )
+  (func (export "as-store-last") (param i32 i32)
+    (get_local 0) (get_local 1) (nop) (i32.store)
+  )
+  (func (export "as-store-everywhere") (param i32 i32)
+    (nop) (nop) (get_local 0) (nop) (nop) (get_local 1) (nop) (nop) (i32.store)
+  )
 )
 
 (assert_return (invoke "as-func-first") (i32.const 1))
@@ -185,9 +286,11 @@
 (assert_return (invoke "as-func-last") (i32.const 3))
 (assert_return (invoke "as-func-everywhere") (i32.const 4))
 
+(assert_return (invoke "as-drop-first" (i32.const 0)))
 (assert_return (invoke "as-drop-last" (i32.const 0)))
 (assert_return (invoke "as-drop-everywhere" (i32.const 0)))
 
+(assert_return (invoke "as-select-first" (i32.const 3)) (i32.const 3))
 (assert_return (invoke "as-select-mid1" (i32.const 3)) (i32.const 3))
 (assert_return (invoke "as-select-mid2" (i32.const 3)) (i32.const 3))
 (assert_return (invoke "as-select-last" (i32.const 3)) (i32.const 3))
@@ -210,42 +313,71 @@
 (assert_return (invoke "as-if-else" (i32.const 0)))
 (assert_return (invoke "as-if-else" (i32.const 3)))
 
+(assert_return (invoke "as-br-first" (i32.const 5)) (i32.const 5))
 (assert_return (invoke "as-br-last" (i32.const 6)) (i32.const 6))
 (assert_return (invoke "as-br-everywhere" (i32.const 7)) (i32.const 7))
 
+(assert_return (invoke "as-br_if-first" (i32.const 4)) (i32.const 4))
 (assert_return (invoke "as-br_if-mid" (i32.const 5)) (i32.const 5))
 (assert_return (invoke "as-br_if-last" (i32.const 6)) (i32.const 6))
 (assert_return (invoke "as-br_if-everywhere" (i32.const 7)) (i32.const 7))
 
+(assert_return (invoke "as-br_table-first" (i32.const 4)) (i32.const 4))
 (assert_return (invoke "as-br_table-mid" (i32.const 5)) (i32.const 5))
 (assert_return (invoke "as-br_table-last" (i32.const 6)) (i32.const 6))
 (assert_return (invoke "as-br_table-everywhere" (i32.const 7)) (i32.const 7))
 
+(assert_return (invoke "as-return-first" (i32.const 5)) (i32.const 5))
 (assert_return (invoke "as-return-last" (i32.const 6)) (i32.const 6))
 (assert_return (invoke "as-return-everywhere" (i32.const 7)) (i32.const 7))
 
+(assert_return (invoke "as-call-first" (i32.const 3) (i32.const 1) (i32.const 2)) (i32.const 2))
 (assert_return (invoke "as-call-mid1" (i32.const 3) (i32.const 1) (i32.const 2)) (i32.const 2))
 (assert_return (invoke "as-call-mid2" (i32.const 0) (i32.const 3) (i32.const 1)) (i32.const 2))
 (assert_return (invoke "as-call-last" (i32.const 10) (i32.const 9) (i32.const -1)) (i32.const 20))
 (assert_return (invoke "as-call-everywhere" (i32.const 2) (i32.const 1) (i32.const 5)) (i32.const -2))
 
+(assert_return (invoke "as-unary-first" (i32.const 30)) (i32.const 1))
 (assert_return (invoke "as-unary-last" (i32.const 30)) (i32.const 1))
 (assert_return (invoke "as-unary-everywhere" (i32.const 12)) (i32.const 2))
 
+(assert_return (invoke "as-binary-first" (i32.const 3)) (i32.const 6))
 (assert_return (invoke "as-binary-mid" (i32.const 3)) (i32.const 6))
 (assert_return (invoke "as-binary-last" (i32.const 3)) (i32.const 6))
 (assert_return (invoke "as-binary-everywhere" (i32.const 3)) (i32.const 6))
 
+(assert_return (invoke "as-test-first" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "as-test-last" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "as-test-everywhere" (i32.const 0)) (i32.const 1))
 
+(assert_return (invoke "as-compare-first" (i32.const 3)) (i32.const 0))
 (assert_return (invoke "as-compare-mid" (i32.const 3)) (i32.const 0))
 (assert_return (invoke "as-compare-last" (i32.const 3)) (i32.const 0))
 (assert_return (invoke "as-compare-everywhere" (i32.const 3)) (i32.const 1))
 
+(assert_return (invoke "as-memory.grow-first" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "as-memory.grow-last" (i32.const 2)) (i32.const 1))
 (assert_return (invoke "as-memory.grow-everywhere" (i32.const 12)) (i32.const 3))
 
+(assert_return (invoke "as-call_indirect-first") (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid1") (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid2") (i32.const 1))
+(assert_return (invoke "as-call_indirect-last") (i32.const 1))
+(assert_return (invoke "as-call_indirect-everywhere") (i32.const 1))
+
+(assert_return (invoke "as-set_local-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-set_local-last" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-set_local-everywhere" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-load-first" (i32.const 100)) (i32.const 0))
+(assert_return (invoke "as-load-last" (i32.const 100)) (i32.const 0))
+(assert_return (invoke "as-load-everywhere" (i32.const 100)) (i32.const 0))
+
+(assert_return (invoke "as-store-first" (i32.const 0) (i32.const 1)))
+(assert_return (invoke "as-store-mid" (i32.const 0) (i32.const 2)))
+(assert_return (invoke "as-store-last" (i32.const 0) (i32.const 3)))
+(assert_return (invoke "as-store-everywhere" (i32.const 0) (i32.const 4)))
+
 (assert_invalid
   (module (func $type-i32 (result i32) (nop)))
   "type mismatch"

From c525a4008b11c7b5dc45cfad13a9db553b582011 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Thu, 16 Aug 2018 14:32:15 +0800
Subject: [PATCH 279/329] [test] Improve test coverage of block.wast (#856)

---
 test/core/block.wast | 136 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 136 insertions(+)

diff --git a/test/core/block.wast b/test/core/block.wast
index 3754a159b..50aaab7b3 100644
--- a/test/core/block.wast
+++ b/test/core/block.wast
@@ -2,6 +2,8 @@
 
 (module
   ;; Auxiliary definition
+  (memory 1)
+
   (func $dummy)
 
   (func (export "empty")
@@ -68,6 +70,107 @@
     ))
   )
 
+  (func (export "as-select-first") (result i32)
+    (select (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (block (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32) (block (result i32) (i32.const 1)) (call $dummy) (call $dummy))
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32) (call $dummy) (block (result i32) (i32.const 1)) (call $dummy))
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32) (call $dummy) (call $dummy) (block (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-if-condition")
+    (block (result i32) (i32.const 1)) (if (then (call $dummy)))
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1) (then (block (result i32) (i32.const 1))) (else (i32.const 2)))
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (block (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (block (result i32) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (block (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (block (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (block (result i32) (i32.const 1)) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (get_local 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table anyfunc (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (block (result i32) (i32.const 1)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (block (result i32) (i32.const 1)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (block (result i32) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (block (result i32) (i32.const 1)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (block (result i32) (i32.const 1)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (block (result i32) (i32.const 1)))
+  )
+
+  (func $f (param i32) (result i32) (get_local 0))
+
+  (func (export "as-call-value") (result i32)
+    (call $f (block (result i32) (i32.const 1)))
+  )
+  (func (export "as-return-value") (result i32)
+    (block (result i32) (i32.const 1)) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (block (result i32) (i32.const 1)))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (block (result i32) (i32.const 1))))
+  )
+  (func (export "as-set_local-value") (result i32)
+    (local i32) (set_local 0 (block (result i32) (i32.const 1))) (get_local 0)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (block (result i32) (i32.const 1)))
+  )
+
   (func (export "as-unary-operand") (result i32)
     (i32.ctz (block (result i32) (call $dummy) (i32.const 13)))
   )
@@ -143,6 +246,39 @@
 (assert_return (invoke "nested") (i32.const 9))
 (assert_return (invoke "deep") (i32.const 150))
 
+(assert_return (invoke "as-select-first") (i32.const 1))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 1))
+(assert_return (invoke "as-loop-mid") (i32.const 1))
+(assert_return (invoke "as-loop-last") (i32.const 1))
+
+(assert_return (invoke "as-if-condition"))
+(assert_return (invoke "as-if-then") (i32.const 1))
+(assert_return (invoke "as-if-else") (i32.const 2))
+
+(assert_return (invoke "as-br_if-first") (i32.const 1))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 1))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_return (invoke "as-call_indirect-last") (i32.const 1))
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-call-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 1))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 1))
+(assert_return (invoke "as-set_local-value") (i32.const 1))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+
 (assert_return (invoke "as-unary-operand") (i32.const 0))
 (assert_return (invoke "as-binary-operand") (i32.const 12))
 (assert_return (invoke "as-test-operand") (i32.const 0))

From c8cf0f1f0bae63dc0f154c136d2a992a1560ca79 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Fri, 17 Aug 2018 17:40:42 +0800
Subject: [PATCH 280/329] [test] Improve test coverage of loop.wast (#857)

---
 test/core/loop.wast | 122 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 122 insertions(+)

diff --git a/test/core/loop.wast b/test/core/loop.wast
index d51b70361..a250d0133 100644
--- a/test/core/loop.wast
+++ b/test/core/loop.wast
@@ -1,6 +1,8 @@
 ;; Test `loop` opcode
 
 (module
+  (memory 1)
+
   (func $dummy)
 
   (func (export "empty")
@@ -69,6 +71,97 @@
     ))
   )
 
+  (func (export "as-select-first") (result i32)
+    (select (loop (result i32) (i32.const 1)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (loop (result i32) (i32.const 1)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (loop (result i32) (i32.const 1)))
+  )
+
+  (func (export "as-if-condition")
+    (loop (result i32) (i32.const 1)) (if (then (call $dummy)))
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1) (then (loop (result i32) (i32.const 1))) (else (i32.const 2)))
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 1) (then (i32.const 2)) (else (loop (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (loop (result i32) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (loop (result i32) (i32.const 1))))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (loop (result i32) (i32.const 1)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (loop (result i32) (i32.const 1)) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (get_local 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table anyfunc (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (loop (result i32) (i32.const 1)) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (loop (result i32) (i32.const 1)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (loop (result i32) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (loop (result i32) (i32.const 1)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (loop (result i32) (i32.const 1)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (loop (result i32) (i32.const 1)))
+  )
+
+  (func $f (param i32) (result i32) (get_local 0))
+
+  (func (export "as-call-value") (result i32)
+    (call $f (loop (result i32) (i32.const 1)))
+  )
+  (func (export "as-return-value") (result i32)
+    (loop (result i32) (i32.const 1)) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (loop (result i32) (i32.const 1)))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (loop (result i32) (i32.const 1))))
+  )
+  (func (export "as-set_local-value") (result i32)
+    (local i32) (set_local 0 (loop (result i32) (i32.const 1))) (get_local 0)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (loop (result i32) (i32.const 1)))
+  )
+
   (func (export "as-unary-operand") (result i32)
     (i32.ctz (loop (result i32) (call $dummy) (i32.const 13)))
   )
@@ -207,6 +300,35 @@
 (assert_return (invoke "nested") (i32.const 9))
 (assert_return (invoke "deep") (i32.const 150))
 
+(assert_return (invoke "as-select-first") (i32.const 1))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-if-condition"))
+(assert_return (invoke "as-if-then") (i32.const 1))
+(assert_return (invoke "as-if-else") (i32.const 2))
+
+(assert_return (invoke "as-br_if-first") (i32.const 1))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 1))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_return (invoke "as-call_indirect-last") (i32.const 1))
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-call-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 1))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 1))
+(assert_return (invoke "as-set_local-value") (i32.const 1))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+
 (assert_return (invoke "as-unary-operand") (i32.const 0))
 (assert_return (invoke "as-binary-operand") (i32.const 12))
 (assert_return (invoke "as-test-operand") (i32.const 0))

From 240ea673de6e75d78ae472f66127301ecab22a99 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Mon, 20 Aug 2018 12:40:15 -0700
Subject: [PATCH 281/329] Add build commands to diff JS+Web documents too
 (#859)

The diff script was first added in #847, but only had a command to diff
the core spec.
---
 document/Makefile                    | 7 +++++++
 document/core/Makefile               | 2 +-
 document/js-api/Makefile             | 9 +++++++++
 document/{core => }/util/htmldiff.pl | 0
 document/web-api/Makefile            | 9 +++++++++
 5 files changed, 26 insertions(+), 1 deletion(-)
 rename document/{core => }/util/htmldiff.pl (100%)

diff --git a/document/Makefile b/document/Makefile
index 1bc93c901..875efc720 100644
--- a/document/Makefile
+++ b/document/Makefile
@@ -21,6 +21,9 @@ publish: all deploy
 clean: $(DIRS:%=clean-%)
 	rm -rf $(BUILDDIR)
 
+.PHONY: diff
+diff: $(DIRS:%=diff-%)
+
 
 # Directory-specific targets.
 
@@ -54,6 +57,10 @@ $(DIRS:%=clean-%): clean-%:
 	(cd $(@:clean-%=%); make BUILDDIR=$(BUILDDIR) clean)
 	rm -rf $(BUILDDIR)/$(@:clean-%=%)
 
+.PHONY: $(DIRS:%=diff-%)
+$(DIRS:%=diff-%): diff-%:
+	(cd $(@:diff-%=%); make BUILDDIR=$(BUILDDIR) diff)
+
 
 # Help.
 
diff --git a/document/core/Makefile b/document/core/Makefile
index 63983426d..2125cb7a5 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -162,7 +162,7 @@ diff: bikeshed
 	curl `grep "^TR" index.bs | cut -d' ' -f2` -o $(BUILDDIR)/html/bikeshed/old.html
 	@echo "Done."
 	@echo "Diffing new against old (go get a coffee)..."
-	perl util/htmldiff.pl $(BUILDDIR)/html/bikeshed/old.html $(BUILDDIR)/html/bikeshed/index.html $(BUILDDIR)/html/bikeshed/diff.html
+	perl ../util/htmldiff.pl $(BUILDDIR)/html/bikeshed/old.html $(BUILDDIR)/html/bikeshed/index.html $(BUILDDIR)/html/bikeshed/diff.html
 	@echo "Done. The diff is at $(BUILDDIR)/html/bikeshed/diff.html"
 
 .PHONY: pickle
diff --git a/document/js-api/Makefile b/document/js-api/Makefile
index e7783ff93..8746d854e 100644
--- a/document/js-api/Makefile
+++ b/document/js-api/Makefile
@@ -17,3 +17,12 @@ publish:
 clean:
 	rm -rf $(BUILDDIR)
 	rm -rf $(STATICDIR)
+
+.PHONY: diff
+diff: all
+	@echo "Downloading the old single-file html spec..."
+	curl `grep "^TR" index.bs | cut -d' ' -f2` -o $(BUILDDIR)/html/old.html
+	@echo "Done."
+	@echo "Diffing new against old..."
+	perl ../util/htmldiff.pl $(BUILDDIR)/html/old.html $(BUILDDIR)/html/index.html $(BUILDDIR)/html/diff.html
+	@echo "Done. The diff is at $(BUILDDIR)/html/diff.html"
diff --git a/document/core/util/htmldiff.pl b/document/util/htmldiff.pl
similarity index 100%
rename from document/core/util/htmldiff.pl
rename to document/util/htmldiff.pl
diff --git a/document/web-api/Makefile b/document/web-api/Makefile
index 5166f7c12..e0b290e8b 100644
--- a/document/web-api/Makefile
+++ b/document/web-api/Makefile
@@ -17,3 +17,12 @@ publish:
 clean:
 	rm -rf $(BUILDDIR)
 	rm -rf $(STATICDIR)
+
+.PHONY: diff
+diff: all
+	@echo "Downloading the old single-file html spec..."
+	curl `grep "^TR" index.bs | cut -d' ' -f2` -o $(BUILDDIR)/html/old.html
+	@echo "Done."
+	@echo "Diffing new against old..."
+	perl ../util/htmldiff.pl $(BUILDDIR)/html/old.html $(BUILDDIR)/html/index.html $(BUILDDIR)/html/diff.html
+	@echo "Done. The diff is at $(BUILDDIR)/html/diff.html"

From 2308f1e36ffa9dd3af74b5ef1790ba33abf3c8a1 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 23 Aug 2018 08:49:28 +0200
Subject: [PATCH 282/329] [spec] Add missing range checks on memory limits
 (#862)

* Check range of limits during validation.
* Check range of limits when growing emory or table.
---
 document/core/appendix/index-rules.rst |  2 +-
 document/core/exec/modules.rst         | 32 ++++++++++++++++++++------
 document/core/valid/types.rst          | 26 ++++++++++++++-------
 interpreter/valid/valid.ml             | 15 +++++-------
 test/core/memory_grow.wast             |  2 ++
 5 files changed, 52 insertions(+), 25 deletions(-)

diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst
index 281548063..4d02f7af7 100644
--- a/document/core/appendix/index-rules.rst
+++ b/document/core/appendix/index-rules.rst
@@ -13,7 +13,7 @@ Typing of Static Constructs
 ===============================================  ===============================================================================
 Construct                                        Judgement
 ===============================================  ===============================================================================
-:ref:`Limits <valid-limits>`                     :math:`\vdashlimits \limits \ok`
+:ref:`Limits <valid-limits>`                     :math:`\vdashlimits \limits : k`
 :ref:`Function type <valid-functype>`            :math:`\vdashfunctype \functype \ok`
 :ref:`Table type <valid-tabletype>`              :math:`\vdashtabletype \tabletype \ok`
 :ref:`Memory type <valid-memtype>`               :math:`\vdashmemtype \memtype \ok`
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index 20d1d48a3..f6ae892d7 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -379,14 +379,23 @@ Growing :ref:`tables <syntax-tableinst>`
 
 1. Let :math:`\tableinst` be the :ref:`table instance <syntax-tableinst>` to grow and :math:`n` the number of elements by which to grow it.
 
-2. If :math:`\tableinst.\TIMAX` is not empty and smaller than :math:`n` added to the length of :math:`\tableinst.\TIELEM`, then fail.
+2. Let :math:`\X{len}` be :math:`n` added to the length of :math:`\tableinst.\TIELEM`.
 
-3. Append :math:`n` empty elements to :math:`\tableinst.\TIELEM`.
+3. If :math:`\X{len}` is larger than :math:`2^{32}`, then fail.
+
+4. If :math:`\tableinst.\TIMAX` is not empty and smaller than :math:`\X{len}`, then fail.
+
+5. Append :math:`n` empty elements to :math:`\tableinst.\TIELEM`.
 
 .. math::
    \begin{array}{rllll}
    \growtable(\tableinst, n) &=& \tableinst \with \TIELEM = \tableinst.\TIELEM~(\epsilon)^n \\
-     && (\iff \tableinst.\TIMAX = \epsilon \vee |\tableinst.\TIELEM| + n \leq \tableinst.\TIMAX) \\
+     && (
+       \begin{array}[t]{@{}r@{~}l@{}}
+       \iff & \X{len} = n + |\tableinst.\TIELEM| \\
+       \wedge & \X{len} \leq 2^{32} \\
+       \wedge & (\tableinst.\TIMAX = \epsilon \vee \X{len} \leq \tableinst.\TIMAX)) \\
+       \end{array} \\
    \end{array}
 
 
@@ -398,16 +407,25 @@ Growing :ref:`memories <syntax-meminst>`
 
 1. Let :math:`\meminst` be the :ref:`memory instance <syntax-meminst>` to grow and :math:`n` the number of :ref:`pages <page-size>` by which to grow it.
 
-2. Let :math:`\X{len}` be :math:`n` multiplied by the :ref:`page size <page-size>` :math:`64\,\F{Ki}`.
+2. Assert: The length of :math:`\meminst.\MIDATA` is divisible by the :ref:`page size <page-size>` :math:`64\,\F{Ki}`.
+
+3. Let :math:`\X{len}` be :math:`n` added to the length of :math:`\meminst.\MIDATA` divided by the :ref:`page size <page-size>` :math:`64\,\F{Ki}`.
+
+4. If :math:`\X{len}` is larger than :math:`2^{16}`, then fail.
 
-3. If :math:`\meminst.\MIMAX` is not empty and its value multiplied by the :ref:`page size <page-size>` :math:`64\,\F{Ki}` is smaller than :math:`\X{len}` added to the length of :math:`\meminst.\MIDATA`, then fail.
+5. If :math:`\meminst.\MIMAX` is not empty and its value is smaller than :math:`\X{len}`, then fail.
 
-4. Append :math:`\X{len}` :ref:`bytes <syntax-byte>` with value :math:`\hex{00}` to :math:`\meminst.\MIDATA`.
+6. Append :math:`n` times :math:`64\,\F{Ki}` :ref:`bytes <syntax-byte>` with value :math:`\hex{00}` to :math:`\meminst.\MIDATA`.
 
 .. math::
    \begin{array}{rllll}
    \growmem(\meminst, n) &=& \meminst \with \MIDATA = \meminst.\MIDATA~(\hex{00})^{n \cdot 64\,\F{Ki}} \\
-     && (\iff \meminst.\MIMAX = \epsilon \vee |\meminst.\MIDATA| + n \cdot 64\,\F{Ki} \leq \meminst.\MIMAX \cdot 64\,\F{Ki}) \\
+     && (
+       \begin{array}[t]{@{}r@{~}l@{}}
+       \iff & \X{len} = n + |\meminst.\MIDATA| / 64\,\F{Ki} \\
+       \wedge & \X{len} \leq 2^{16} \\
+       \wedge & (\meminst.\MIMAX = \epsilon \vee \X{len} \leq \meminst.\MIMAX)) \\
+       \end{array} \\
    \end{array}
 
 
diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst
index 89b79a418..39a64c6a4 100644
--- a/document/core/valid/types.rst
+++ b/document/core/valid/types.rst
@@ -13,20 +13,30 @@ However, restrictions apply to :ref:`function types <syntax-functype>` as well a
 Limits
 ~~~~~~
 
-:ref:`Limits <syntax-limits>` must have meaningful bounds.
+:ref:`Limits <syntax-limits>` must have meaningful bounds that are within a given range.
 
 :math:`\{ \LMIN~n, \LMAX~m^? \}`
 ................................
 
-* If the maximum :math:`m^?` is not empty, then its value must not be smaller than :math:`n`.
+* The value of :math:`n` must not be larger than :math:`k`.
 
-* Then the limit is valid.
+* If the maximum :math:`m^?` is not empty, then:
+
+  * Its value must not be larger than :math:`k`.
+
+  * Its value must not be smaller than :math:`n`.
+
+* Then the limit is valid within range :math:`k`.
 
 .. math::
    \frac{
+     n \leq k
+     \qquad
+     (m \leq k)^?
+     \qquad
      (n \leq m)^?
    }{
-     \vdashlimits \{ \LMIN~n, \LMAX~m^? \} \ok
+     \vdashlimits \{ \LMIN~n, \LMAX~m^? \} : k
    }
 
 
@@ -68,13 +78,13 @@ Table Types
 :math:`\limits~\elemtype`
 .........................
 
-* The limits :math:`\limits` must be :ref:`valid <valid-limits>`.
+* The limits :math:`\limits` must be :ref:`valid <valid-limits>` within range :math:`2^{32}`.
 
 * Then the table type is valid.
 
 .. math::
    \frac{
-     \vdashlimits \limits \ok
+     \vdashlimits \limits : 2^{32}
    }{
      \vdashtabletype \limits~\elemtype \ok
    }
@@ -91,13 +101,13 @@ Memory Types
 :math:`\limits`
 ...............
 
-* The limits :math:`\limits` must be :ref:`valid <valid-limits>`.
+* The limits :math:`\limits` must be :ref:`valid <valid-limits>` within range :math:`2^{16}`.
 
 * Then the memory type is valid.
 
 .. math::
    \frac{
-     \vdashlimits \limits \ok
+     \vdashlimits \limits : 2^{16}
    }{
      \vdashmemtype \limits \ok
    }
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index 0d1c4d8e2..e3612bccf 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -309,10 +309,12 @@ and check_block (c : context) (es : instr list) (ts : stack_type) at =
 
 (* Types *)
 
-let check_limits {min; max} at =
+let check_limits {min; max} range at msg =
+  require (I64.le_u (Int64.of_int32 min) range) at msg;
   match max with
   | None -> ()
   | Some max ->
+    require (I64.le_u (Int64.of_int32 max) range) at msg;
     require (I32.le_u min max) at
       "size minimum must not be greater than maximum"
 
@@ -327,17 +329,12 @@ let check_func_type (ft : func_type) at =
 
 let check_table_type (tt : table_type) at =
   let TableType (lim, _) = tt in
-  check_limits lim at
-
-let check_memory_size (sz : I32.t) at =
-  require (I32.le_u sz 65536l) at
-    "memory size must be at most 65536 pages (4GiB)"
+  check_limits lim 0x1_0000_0000L at "table size must be at most 2^32"
 
 let check_memory_type (mt : memory_type) at =
   let MemoryType lim = mt in
-  check_limits lim at;
-  check_memory_size lim.min at;
-  Lib.Option.app (fun max -> check_memory_size max at) lim.max
+  check_limits lim 0x1_0000L at
+    "memory size must be at most 65536 pages (4GiB)"
 
 let check_global_type (gt : global_type) at =
   let GlobalType (t, mut) = gt in
diff --git a/test/core/memory_grow.wast b/test/core/memory_grow.wast
index c7cd6dc69..cd1466016 100644
--- a/test/core/memory_grow.wast
+++ b/test/core/memory_grow.wast
@@ -44,6 +44,8 @@
 (assert_return (invoke "grow" (i32.const 2)) (i32.const 1))
 (assert_return (invoke "grow" (i32.const 800)) (i32.const 3))
 (assert_return (invoke "grow" (i32.const 0x10000)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 64736)) (i32.const -1))
+(assert_return (invoke "grow" (i32.const 1)) (i32.const 803))
 
 (module
   (memory 0 10)

From b9af968f325f27999a393bd2207edca60083208d Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Fri, 24 Aug 2018 14:22:40 +0800
Subject: [PATCH 283/329] [test] Improve test coverage of if.wast and
 return.wast (#865)

---
 test/core/if.wast     | 293 ++++++++++++++++++++++++++++++++++++++++++
 test/core/return.wast |  18 +++
 2 files changed, 311 insertions(+)

diff --git a/test/core/if.wast b/test/core/if.wast
index 07a9ee248..1c2f90225 100644
--- a/test/core/if.wast
+++ b/test/core/if.wast
@@ -2,6 +2,8 @@
 
 (module
   ;; Auxiliary definition
+  (memory 1)
+
   (func $dummy)
 
   (func (export "empty") (param i32)
@@ -47,6 +49,237 @@
     )
   )
 
+  (func (export "as-select-first") (param i32) (result i32)
+    (select
+      (if (result i32) (get_local 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 2) (i32.const 3)
+    )
+  )
+  (func (export "as-select-mid") (param i32) (result i32)
+    (select
+      (i32.const 2)
+      (if (result i32) (get_local 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 3)
+    )
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (select
+      (i32.const 2) (i32.const 3)
+      (if (result i32) (get_local 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32)
+      (if (result i32) (get_local 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (call $dummy) (call $dummy)
+    )
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32)
+      (call $dummy)
+      (if (result i32) (get_local 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (call $dummy)
+    )
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32)
+      (call $dummy) (call $dummy)
+      (if (result i32) (get_local 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "as-if-condition") (param i32) (result i32)
+    (if (result i32)
+      (if (result i32) (get_local 0)
+        (then (i32.const 1)) (else (i32.const 0))
+      )
+      (then (call $dummy) (i32.const 2))
+      (else (call $dummy) (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (if (result i32) (get_local 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 2)
+      )
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32)
+      (br_if 0
+        (i32.const 2)
+        (if (result i32) (get_local 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+      )
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32)
+      (if (result i32) (get_local 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (i32.const 2)
+      (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32)
+      (i32.const 2)
+      (if (result i32) (get_local 0)
+        (then (call $dummy) (i32.const 1))
+        (else (call $dummy) (i32.const 0))
+      )
+      (br_table 0 0)
+    )
+  )
+
+  (func $func (param i32 i32) (result i32) (get_local 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table anyfunc (elem $func))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (if (result i32) (get_local 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2)
+        (if (result i32) (get_local 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+        (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (i32.const 0)
+        (if (result i32) (get_local 0)
+          (then (call $dummy) (i32.const 1))
+          (else (call $dummy) (i32.const 0))
+        )
+      )
+    )
+  )
+
+  (func (export "as-store-first") (param i32)
+    (if (result i32) (get_local 0)
+      (then (call $dummy) (i32.const 1))
+      (else (call $dummy) (i32.const 0))
+    )
+    (i32.const 2)
+    (i32.store)
+  )
+  (func (export "as-store-last") (param i32)
+    (i32.const 2)
+    (if (result i32) (get_local 0)
+      (then (call $dummy) (i32.const 1))
+      (else (call $dummy) (i32.const 0))
+    )
+    (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (param i32) (result i32)
+    (memory.grow
+      (if (result i32) (get_local 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+
+  (func $f (param i32) (result i32) (get_local 0))
+
+  (func (export "as-call-value") (param i32) (result i32)
+    (call $f
+      (if (result i32) (get_local 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-return-value") (param i32) (result i32)
+    (if (result i32) (get_local 0)
+      (then (i32.const 1))
+      (else (i32.const 0)))
+    (return)
+  )
+  (func (export "as-drop-operand") (param i32)
+    (drop
+      (if (result i32) (get_local 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32)
+      (br 0
+        (if (result i32) (get_local 0)
+          (then (i32.const 1))
+          (else (i32.const 0))
+        )
+      )
+    )
+  )
+  (func (export "as-set_local-value") (param i32) (result i32)
+    (local i32)
+    (set_local 0
+      (if (result i32) (get_local 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+    (get_local 0)
+  )
+  (func (export "as-load-operand") (param i32) (result i32)
+    (i32.load
+      (if (result i32) (get_local 0)
+        (then (i32.const 11))
+        (else (i32.const 10))
+      )
+    )
+  )
+
   (func (export "as-unary-operand") (param i32) (result i32)
     (i32.ctz
       (if (result i32) (get_local 0)
@@ -155,6 +388,66 @@
 (assert_return (invoke "nested" (i32.const 0) (i32.const -1)) (i32.const 10))
 (assert_return (invoke "nested" (i32.const -111) (i32.const -2)) (i32.const 9))
 
+(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-select-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-if-condition" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-condition" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_if-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_table-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-br_table-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const 2))
+(assert_trap (invoke "as-call_indirect-last" (i32.const 1)) "undefined element")
+
+(assert_return (invoke "as-store-first" (i32.const 0)))
+(assert_return (invoke "as-store-first" (i32.const 1)))
+(assert_return (invoke "as-store-last" (i32.const 0)))
+(assert_return (invoke "as-store-last" (i32.const 1)))
+
+(assert_return (invoke "as-memory.grow-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-memory.grow-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-return-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-drop-operand" (i32.const 0)))
+(assert_return (invoke "as-drop-operand" (i32.const 1)))
+
+(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-set_local-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-set_local-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 0))
+
 (assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0))
 (assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 0))
 (assert_return (invoke "as-unary-operand" (i32.const -1)) (i32.const 0))
diff --git a/test/core/return.wast b/test/core/return.wast
index 727680a17..775baaa09 100644
--- a/test/core/return.wast
+++ b/test/core/return.wast
@@ -9,6 +9,19 @@
   (func (export "type-f32") (drop (f32.neg (return))))
   (func (export "type-f64") (drop (f64.neg (return))))
 
+  (func (export "type-i32-value") (result i32)
+    (block (result i32) (i32.ctz (return (i32.const 1))))
+  )
+  (func (export "type-i64-value") (result i64)
+    (block (result i64) (i64.ctz (return (i64.const 2))))
+  )
+  (func (export "type-f32-value") (result f32)
+    (block (result f32) (f32.neg (return (f32.const 3))))
+  )
+  (func (export "type-f64-value") (result f64)
+    (block (result f64) (f64.neg (return (f64.const 4))))
+  )
+
   (func (export "nullary") (return))
   (func (export "unary") (result f64) (return (f64.const 3)))
 
@@ -206,6 +219,11 @@
 (assert_return (invoke "type-f32"))
 (assert_return (invoke "type-f64"))
 
+(assert_return (invoke "type-i32-value") (i32.const 1))
+(assert_return (invoke "type-i64-value") (i64.const 2))
+(assert_return (invoke "type-f32-value") (f32.const 3))
+(assert_return (invoke "type-f64-value") (f64.const 4))
+
 (assert_return (invoke "nullary"))
 (assert_return (invoke "unary") (f64.const 3))
 

From 2311cf29acdea58b6041095ca82be90dcdbda749 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Wed, 5 Sep 2018 02:26:24 +0200
Subject: [PATCH 284/329] [js-api] Fix some inconsistencies around handling
 bytes and buffers. (#867)

This changes the specification to consistently grab the bytes immediately upon
receiving a BufferSource from user code, and store bytes directly in the
[[Bytes]] field.

This also clarifies the parsing of custom sections from the module bytes.
---
 document/js-api/index.bs  | 15 ++++++++-------
 document/web-api/index.bs |  3 ++-
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 10a85adc0..a411511a6 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -89,7 +89,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
     url: valid/modules.html#valid-module
         text: valid
         text: WebAssembly module validation
-    text: binary format of a module; url: binary/modules.html
+    text: module grammar; url: binary/modules.html#binary-module
     text: custom section; url: binary/modules.html#custom-section
     text: customsec; url: binary/modules.html#binary-customsec
     text: memory instance; url: exec/runtime.html#memory-instances
@@ -265,7 +265,7 @@ Note:
 -->
 
 <div algorithm>
-  To <dfn>compile a WebAssembly module</dfn> from a {{BufferSource}} |bytes|, perform the following steps:
+  To <dfn>compile a WebAssembly module</dfn> from source bytes |bytes|, perform the following steps:
     1. Let |module| be [=decode_module=](|bytes|). If |module| is [=error=], return [=error=].
     1. If [=validate_module=](|module|) is [=error=], return [=error=].
     1. Return |module|.
@@ -273,7 +273,8 @@ Note:
 
 <div algorithm>
   The <dfn method for="WebAssembly">validate(|bytes|)</dfn> method, when invoked, performs the following steps:
-    1. [=Compile a WebAssembly module|Compile=] |bytes| as a WebAssembly module and store the results as |module|.
+    1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes|.
+    1. [=Compile a WebAssembly module|Compile=] |stableBytes| as a WebAssembly module and store the results as |module|.
     1. If |module| is [=error=], return false.
     1. Return true.
 </div>
@@ -282,7 +283,7 @@ Note:
 A {{Module}} object represents a single WebAssembly module. Each {{Module}} object has the following internal slots:
 
     * \[[Module]] : a WebAssembly [=module=]
-    * \[[Bytes]] : an {{ArrayBuffer}} which is source bytes of \[[Module]].
+    * \[[Bytes]] : the source bytes of \[[Module]].
 </div>
 
 <div algorithm>
@@ -295,7 +296,7 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje
 </div>
 
 <div algorithm>
-  To <dfn>asynchronously compile a WebAssembly module</dfn> from a {{BufferSource}} |bytes|, using optional [=task source=] |taskSource|, perform the following steps:
+  To <dfn>asynchronously compile a WebAssembly module</dfn> from source bytes |bytes|, using optional [=task source=] |taskSource|, perform the following steps:
 
     1. Let |promise| be [=a new promise=].
     1. In parallel, [=compile a WebAssembly module|compile the WebAssembly module=] |bytes| and store the result as |module|.
@@ -496,11 +497,11 @@ interface Module {
     The <dfn method for="Module">customSections(|moduleObject|, |sectionName|)</dfn> method, when invoked, performs the following steps:
     1. Let |bytes| be |moduleObject|.\[[Bytes]].
     1. Let |customSections| be an empty [=list=] of {{ArrayBuffer}}s.
-    1. For each [=custom section=] |customSection| in the binary format of |bytes|,
+    1. For each [=custom section=] |customSection| in |bytes|, interpreted according to the [=module grammar=],
         1. Let |name| be the <code>name</code> of |customSection|, [=UTF-8 decode without BOM or fail|decoded as UTF-8=].
         1. Assert: |name| is not failure (|moduleObject|.\[[Module]] is [=valid=]).
         1. If |name| equals |sectionName| as string values,
-            1. [=Append=] a new {{ArrayBuffer}} containing a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bytes| for the range matched by this [=customsec=] production.
+            1. [=Append=] a new {{ArrayBuffer}} containing a copy of the bytes in |bytes| for the range matched by this [=customsec=] production.
     1. Return |customSections|.
 </div>
 
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 17e73b4a5..87bc5b3cf 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -128,7 +128,8 @@ Note: This algorithm accepts a {{Response}} object, or a
             Note: Although it is specified here that the response is consumed entirely before compilation proceeds, that is purely for ease of specification; implementations are likely to instead perform processing in a streaming fashion. The different is unobservable, and thus the simpler model is specified. <!-- Using consume is a bit silly as it creates an ArrayBuffer but then we just want the underlying bytes. This is because of how streams is specced in terms of promises and JS objects whereas we want to operate more directly on the underlying concept. We can revisit this if things change in the Streams/Fetch specs. -->
 
         1. [=Upon fulfillment=] of |bodyPromise| with value |bodyArrayBuffer|:
-            1. [=Asynchronously compile a WebAssembly module|Asynchronously compile the WebAssembly module=] |bodyArrayBuffer| using the [=networking task source=] and [=resolve=] |returnValue| with the result.
+            1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bodyArrayBuffer|.
+            1. [=Asynchronously compile a WebAssembly module|Asynchronously compile the WebAssembly module=] |stableBytes| using the [=networking task source=] and [=resolve=] |returnValue| with the result.
         1. [=Upon rejection=] of |bodyPromise| with reason |reason|:
             1. [=Reject=] |returnValue| with |reason|.
      1. [=Upon rejection=] of |source| with reason |reason|:

From 4ccad09cb1716a713a46192557717d498c4b483a Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Wed, 5 Sep 2018 03:05:10 +0200
Subject: [PATCH 285/329] [js-api] Fix some editorial issues. (#858)

* Add a missing closing curly brace.

* Fix link to the definition of the Global constructor.

* Replace an unreachable step by an assertion.

* Fix the link to Table::grow().

This also required distinguishing the two grow() methods.

* Link the Module static methods to their definition.

* Make the assertion in ToWebAssemblyValue part of the algorithm.

* Make the assertion in ToJSValue part of the algorithm.

* Remove stray period in the note about ToJSValue.

* Change `6.` to `1.`
---
 document/js-api/index.bs | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index a411511a6..74e63ef8f 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -457,9 +457,9 @@ dictionary ModuleImportDescriptor {
 
 [LegacyNamespace=WebAssembly, Constructor(BufferSource bytes), Exposed=(Window,Worker,Worklet)]
 interface Module {
-  static sequence&lt;ModuleExportDescriptor> exports(Module module);
-  static sequence&lt;ModuleImportDescriptor> imports(Module module);
-  static sequence&lt;ArrayBuffer> customSections(Module module, USVString sectionName);
+  static sequence&lt;ModuleExportDescriptor> exports(Module moduleObject);
+  static sequence&lt;ModuleImportDescriptor> imports(Module moduleObject);
+  static sequence&lt;ArrayBuffer> customSections(Module moduleObject, USVString sectionName);
 };
 </pre>
 
@@ -592,7 +592,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Set |memory|.\[[BufferObject]] to |buffer|.
 </div>
 
-<div algorithm>
+<div algorithm=dom-Memory-grow>
     The <dfn method for="Memory">grow(|delta|)</dfn> method, when invoked, performs the following steps:
     1. Let |memory| be the Memory instance.
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
@@ -672,18 +672,18 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. [=Create a table object=] from the table address |tableaddr| and return the result.
 </div>
 
-<div algorithm>
-    The <dfn method for="Table">grow(|d|)</dfn> method, when invoked, performs the following steps:
+<div algorithm=dom-Table-grow>
+    The <dfn method for="Table">grow(|delta|)</dfn> method, when invoked, performs the following steps:
     1. Let |tableaddr| be the Table instance's \[[Table]] internal slot.
     1. Let |initialSize| be the length of the Table instance's \[[Values]] internal slot.
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
-    1. Let |result| be [=grow_table=](|store|, |tableaddr|, |d|).
+    1. Let |result| be [=grow_table=](|store|, |tableaddr|, |delta|).
     1. If |result| is [=error=], throw a {{RangeError}} exception.
 
         Note: The above exception may happen due to either insufficient memory or an invalid size parameter.
 
-    6. Set the [=surrounding agent=]'s [=associated store=] to |result|.
-    1. [=Append=] null to the Table instance's \[[Values]] internal slot |d| times.
+    1. Set the [=surrounding agent=]'s [=associated store=] to |result|.
+    1. [=Append=] null to the Table instance's \[[Values]] internal slot |delta| times.
     1. Return |initialSize|.
 </div>
 
@@ -723,7 +723,7 @@ dictionary GlobalDescriptor {
   boolean mutable = false;
 };
 
-[LegacyNamespace=WebAssembly, Constructor(GlobalDescriptor descriptor, optional any value), Exposed=(Window,Worker,Worklet)]
+[LegacyNamespace=WebAssembly, Constructor(GlobalDescriptor descriptor, optional any v), Exposed=(Window,Worker,Worklet)]
 interface Global {
   any valueOf();
   attribute any value;
@@ -763,7 +763,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. If |valuetype| equals [=𝗂𝟨𝟦=], return [=𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] 0.
     1. If |valuetype| equals [=𝖿𝟥𝟤=], return [=𝖿𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] 0.
     1. If |valuetype| equals [=𝖿𝟨𝟦=], return [=𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] 0.
-    1. Otherwise, throw a {{TypeError}} exception.
+    1. Assert: This step is not reached.
 </div>
 
 <div algorithm>
@@ -802,7 +802,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Let |store| be the current agent's [=associated store=].
     1. Let |globaladdr| be |global|.\[[Global]].
     1. Let |globaltype| be [=type_global=](|store|, |globaladdr|), where |globaltype| is of the form |mut| |valuetype|.
-    1. If |mut| is [=const=], throw a {{TypeError}.
+    1. If |mut| is [=const=], throw a {{TypeError}}.
     1. If |valuetype| is [=𝗂𝟨𝟦=], throw a {{TypeError}}.
     1. Let |value| be [=ToWebAssemblyValue=](|v|, |valuetype|).
     1. Let |store| be [=write_global=](|store|, |globaladdr|, |value|).
@@ -908,21 +908,21 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
 <div algorithm>
 The algorithm <dfn>ToJSValue</dfn>(|w|) coerces a [=WebAssembly value=] to a JavaScript value performs the following steps:
 
-Assert: |w| is not of the form [=𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] <var ignore>i64</var>.
+1. Assert: |w| is not of the form [=𝗂𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] <var ignore>i64</var>.
 1. If |w| is of the form [=𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |i32|, return [=the Number value=] for [=signed_32=](|i32|).
 1. If |w| is of the form [=𝖿𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |f32|, return [=the Number value=] for |f32|.
 1. If |w| is of the form [=𝖿𝟨𝟦.𝖼𝗈𝗇𝗌𝗍=] |f64|, return [=the Number value=] for |f64|.
 
 <!-- If the WebAssembly value is optional, then given `None`, return JavaScript value `undefined`. -->
 
-Note: Number values which are equal to NaN may have various observable NaN payloads; see [=NumberToRawBytes=].for details.
+Note: Number values which are equal to NaN may have various observable NaN payloads; see [=NumberToRawBytes=] for details.
 </div>
 
 <div algorithm>
 The algorithm <dfn>ToWebAssemblyValue</dfn>(|v|, |type|) coerce a JavaScript value to a [=WebAssembly value=]  performs the following steps:
 
 
-Assert: |type| is not [=𝗂𝟨𝟦=].
+1. Assert: |type| is not [=𝗂𝟨𝟦=].
 1. If |type| is [=𝗂𝟥𝟤=],
     1. Let |i32| be ? [=ToInt32=](|v|).
     1. Return [=𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] |i32|.

From fda397a56f1e97e57eb8231eb0466d0cbfa3a6b8 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Wed, 12 Sep 2018 07:53:48 -0700
Subject: [PATCH 286/329] Add commands to generate Working Draft (#872)

* `make WD-tar`: Generate the Working Draft tar file to submit
* `make WD-echidna`: Publish the Working Draft via Echidna
---
 document/core/Makefile    | 30 ++++++++++++++++++++++++++++++
 document/js-api/Makefile  | 16 ++++++++++++++++
 document/web-api/Makefile | 16 ++++++++++++++++
 3 files changed, 62 insertions(+)

diff --git a/document/core/Makefile b/document/core/Makefile
index 2125cb7a5..9f12b7af0 100644
--- a/document/core/Makefile
+++ b/document/core/Makefile
@@ -28,6 +28,8 @@ usage:
 	@echo "  pdf        to make standalone PDF file"
 	@echo "  bikeshed   to make a bikeshed wrapped single large HTML file"
 	@echo "  diff       to make a diff of the bikeshed HTML file with the latest TR"
+	@echo "  WD-tar     generate tar file for updating the Working Draft"
+	@echo "  WD-echidna publish the Working Draft tar file via Echidna"
 	@echo "  all        to make all 3"
 	@echo "  publish    to make all and push to gh-pages"
 	@echo "  help       to see more options"
@@ -156,6 +158,34 @@ bikeshed:
 	@echo
 	@echo "Build finished. The HTML page is in $(BUILDDIR)/html/bikeshed/."
 
+.PHONY: WD-tar
+WD-tar: bikeshed
+	@echo "Building tar file..."
+	tar cvf \
+		$(BUILDDIR)/WD.tar \
+		--transform='s|$(BUILDDIR)/html/bikeshed/||' \
+		--transform='s|index.html|Overview.html|' \
+		$(BUILDDIR)/html/bikeshed/index.html \
+		$(BUILDDIR)/html/bikeshed/pygments.css \
+		$(BUILDDIR)/html/bikeshed/katex/dist/katex.css \
+		$(BUILDDIR)/html/bikeshed/katex/dist/fonts
+	@echo "Built $(BUILDDIR)/WD.tar."
+
+.PHONY: WD-echidna
+WD-echidna: WD-tar
+	@if [ -z $(W3C_USERNAME) ] || \
+	    [ -z $(W3C_PASSWORD) ] || \
+			[ -z $(DECISION_URL) ] ; then \
+		echo "Must provide W3C_USERNAME, W3C_PASSWORD, and DECISION_URL environment variables"; \
+		exit 1; \
+	fi
+	curl 'https://labs.w3.org/echidna/api/request' \
+		--user '$(W3C_USERNAME):$(W3C_PASSWORD)' \
+		-F "tar=@$(BUILDDIR)/WD.tar" \
+		-F "decision=$(DECISION_URL)" | tee $(BUILDDIR)/WD-echidna-id.txt
+	@echo
+	@echo "Published working draft. Check its status at https://labs.w3.org/echidna/api/status?id=`cat $(BUILDDIR)/WD-echidna-id.txt`"
+
 .PHONY: diff
 diff: bikeshed
 	@echo "Downloading the old single-file html spec..."
diff --git a/document/js-api/Makefile b/document/js-api/Makefile
index 8746d854e..84ba5d3ab 100644
--- a/document/js-api/Makefile
+++ b/document/js-api/Makefile
@@ -26,3 +26,19 @@ diff: all
 	@echo "Diffing new against old..."
 	perl ../util/htmldiff.pl $(BUILDDIR)/html/old.html $(BUILDDIR)/html/index.html $(BUILDDIR)/html/diff.html
 	@echo "Done. The diff is at $(BUILDDIR)/html/diff.html"
+
+.PHONY: WD-tar
+WD-tar:
+	bikeshed echidna --just-tar index.bs $(BUILDDIR)/html/index.html
+	mv test.tar $(BUILDDIR)/WD.tar
+	@echo "Built $(BUILDDIR)/WD.tar."
+
+.PHONY: WD-echidna
+WD-echidna:
+	@if [ -z $(W3C_USERNAME) ] || \
+	    [ -z $(W3C_PASSWORD) ] || \
+			[ -z $(DECISION_URL) ] ; then \
+		echo "Must provide W3C_USERNAME, W3C_PASSWORD, and DECISION_URL environment variables"; \
+		exit 1; \
+	fi
+	bikeshed echidna index.bs --u $(W3C_USERNAME) --p $(W3C_PASSWORD) --d $(DECISION_URL)
diff --git a/document/web-api/Makefile b/document/web-api/Makefile
index e0b290e8b..616f30ced 100644
--- a/document/web-api/Makefile
+++ b/document/web-api/Makefile
@@ -26,3 +26,19 @@ diff: all
 	@echo "Diffing new against old..."
 	perl ../util/htmldiff.pl $(BUILDDIR)/html/old.html $(BUILDDIR)/html/index.html $(BUILDDIR)/html/diff.html
 	@echo "Done. The diff is at $(BUILDDIR)/html/diff.html"
+
+.PHONY: WD-tar
+WD-tar:
+	bikeshed echidna --just-tar index.bs $(BUILDDIR)/html/index.html
+	mv test.tar $(BUILDDIR)/WD.tar
+	@echo "Built $(BUILDDIR)/WD.tar."
+
+.PHONY: WD-echidna
+WD-echidna:
+	@if [ -z $(W3C_USERNAME) ] || \
+	    [ -z $(W3C_PASSWORD) ] || \
+			[ -z $(DECISION_URL) ] ; then \
+		echo "Must provide W3C_USERNAME, W3C_PASSWORD, and DECISION_URL environment variables"; \
+		exit 1; \
+	fi
+	bikeshed echidna index.bs --u $(W3C_USERNAME) --p $(W3C_PASSWORD) --d $(DECISION_URL)

From 3dd64b7ae0781bf3905c7e1ecee7e78b928557f5 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Thu, 13 Sep 2018 16:18:45 -0700
Subject: [PATCH 287/329] Pin sphinx to v1.7.9 to workaround upstream bug
 (#875)

See https://github.com/sphinx-doc/sphinx/issues/5417
---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index a90c23084..275b88e18 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -7,7 +7,7 @@ sudo: on
 
 install:
   - ./interpreter/meta/travis/install-ocaml.sh
-  - sudo pip install sphinx
+  - sudo pip install sphinx==1.7.9
   - sudo apt-get install texlive-full
   - git clone https://github.com/tabatkins/bikeshed.git
   - pip install --editable $PWD/bikeshed

From 639bb02f851d9468bdae533457d40731156ef12a Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Tue, 18 Sep 2018 08:34:57 -0700
Subject: [PATCH 288/329] [js-api] Verify initial < maximum in Memory ctor
 (#877)

Fixes issue #876.
---
 document/js-api/index.bs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 74e63ef8f..98c1f213a 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -573,6 +573,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     The <dfn constructor for="Memory">Memory(|descriptor|)</dfn> constructor, when invoked, performs the following steps:
     1. If |descriptor|["initial"] is [=present=], let |initial| be |descriptor|["initial"]; otherwise, let |initial| be 0.
     1. If |descriptor|["maximum"] is [=present=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
+    1. If |maximum| is not empty and |maximum| &lt; |initial|, throw a {{RangeError}} exception.
     1. Let |memtype| be { min |initial|, max |maximum| }
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let (|store|, |memaddr|) be [=alloc_mem=](|store|, |memtype|). If allocation fails, throw a {{RangeError}} exception.
@@ -662,10 +663,10 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 
 <div algorithm>
     The <dfn constructor for="Table">Table(|descriptor|)</dfn> constructor, when invoked, performs the following steps:
-    1. If |descriptor|["initial"] is [=present=], let |n| be |descriptor|["initial"]; otherwise, let |n| be 0.
-    1. If |descriptor|["maximum"] is [=present=], let |m| be |descriptor|["maximum"]; otherwise, let |m| be empty.
-    1. If |m| is not empty and |m| &lt; |n|, throw a {{RangeError}} exception.
-    1. Let |type| be the [=table type=] {[=table type|𝗆𝗂𝗇=] n, [=table type|𝗆𝖺𝗑=] |m|} [=table type|𝖺𝗇𝗒𝖿𝗎𝗇𝖼=].
+    1. If |descriptor|["initial"] is [=present=], let |initial| be |descriptor|["initial"]; otherwise, let |initial| be 0.
+    1. If |descriptor|["maximum"] is [=present=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
+    1. If |maximum| is not empty and |maximum| &lt; |initial|, throw a {{RangeError}} exception.
+    1. Let |type| be the [=table type=] {[=table type|𝗆𝗂𝗇=] n, [=table type|𝗆𝖺𝗑=] |maximum|} [=table type|𝖺𝗇𝗒𝖿𝗎𝗇𝖼=].
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let (|store|, |tableaddr|) be [=alloc_table=](|store|, |type|). <!-- TODO(littledan): Report allocation failure https://github.com/WebAssembly/spec/issues/584 -->
     1. Set the [=surrounding agent=]'s [=associated store=] to |store|.

From db9cd40808a90ecc5f4a23e88fb375c8f60b8d52 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Sun, 23 Sep 2018 21:45:19 +0200
Subject: [PATCH 289/329] Typo

---
 document/core/appendix/index.rst | 1 -
 document/core/index.rst          | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/document/core/appendix/index.rst b/document/core/appendix/index.rst
index ef5d64607..789d2140e 100644
--- a/document/core/appendix/index.rst
+++ b/document/core/appendix/index.rst
@@ -16,7 +16,6 @@ Appendix
 
    .. toctree::
 
-      :maxdepth: 2
       index-types
       index-instructions
       index-rules
diff --git a/document/core/index.rst b/document/core/index.rst
index f6dca0a22..b4bf15c07 100644
--- a/document/core/index.rst
+++ b/document/core/index.rst
@@ -6,7 +6,7 @@ WebAssembly Specification
    Release |release| (Draft, last updated |today|)
 
 .. toctree::
-   :maxdepth: 3
+   :maxdepth: 2
 
    intro/index
    syntax/index

From 24912ee2805488e1f59b0e7872db8af25a10124d Mon Sep 17 00:00:00 2001
From: Nicholas Lordello <nlordell@gmail.com>
Date: Wed, 26 Sep 2018 18:43:09 +0200
Subject: [PATCH 290/329] Fix memory section length (#882)

---
 test/core/binary.wast | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/core/binary.wast b/test/core/binary.wast
index 3dceb2ecd..bb4008da8 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -171,7 +171,7 @@
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\05\04\01"                          ;; Memory section with 1 entry
+    "\05\07\01"                          ;; Memory section with 1 entry
     "\00\82\80\80\80\70"                 ;; no max, minimum 2 with unused bits set
   )
   "integer too large"
@@ -179,7 +179,7 @@
 (assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
-    "\05\04\01"                          ;; Memory section with 1 entry
+    "\05\07\01"                          ;; Memory section with 1 entry
     "\00\82\80\80\80\40"                 ;; no max, minimum 2 with some unused bits set
   )
   "integer too large"

From 00060912c52cacbbbbcf3f305575aac45466f37a Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Sat, 29 Sep 2018 23:27:20 +0800
Subject: [PATCH 291/329] [test] Improve coverage of call and call_indirect
 (#868)

---
 test/core/call.wast          | 108 +++++++++++++
 test/core/call_indirect.wast | 287 ++++++++++++++++++++++++++++++++---
 2 files changed, 373 insertions(+), 22 deletions(-)

diff --git a/test/core/call.wast b/test/core/call.wast
index 3a89f2323..7f81dbb97 100644
--- a/test/core/call.wast
+++ b/test/core/call.wast
@@ -106,6 +106,89 @@
 
   (func $mutual-runaway1 (export "mutual-runaway") (call $mutual-runaway2))
   (func $mutual-runaway2 (call $mutual-runaway1))
+
+  ;; As parameter of control constructs and instructions
+
+  (memory 1)
+
+  (func (export "as-select-first") (result i32)
+    (select (call $const-i32) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (call $const-i32) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (call $const-i32))
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (call $const-i32) (then (i32.const 1)) (else (i32.const 2)))
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32) (br_if 0 (call $const-i32) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (call $const-i32)))
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32) (call $const-i32) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (call $const-i32) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (get_local 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table anyfunc (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (call $const-i32) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (call $const-i32) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 2) (call $const-i32)
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (call $const-i32) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (call $const-i32) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (call $const-i32))
+  )
+  (func (export "as-return-value") (result i32)
+    (call $const-i32) (return)
+  )
+  (func (export "as-drop-operand")
+    (call $const-i32) (drop)
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (call $const-i32)))
+  )
+  (func (export "as-set_local-value") (result i32)
+    (local i32) (set_local 0 (call $const-i32)) (get_local 0)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (call $const-i32))
+  )
 )
 
 (assert_return (invoke "type-i32") (i32.const 0x132))
@@ -153,6 +236,31 @@
 (assert_exhaustion (invoke "runaway") "call stack exhausted")
 (assert_exhaustion (invoke "mutual-runaway") "call stack exhausted")
 
+(assert_return (invoke "as-select-first") (i32.const 0x132))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-if-condition") (i32.const 1))
+
+(assert_return (invoke "as-br_if-first") (i32.const 0x132))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 0x132))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 0x132))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_trap (invoke "as-call_indirect-last") "undefined element")
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 0x132))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 0x132))
+(assert_return (invoke "as-set_local-value") (i32.const 0x132))
+(assert_return (invoke "as-load-operand") (i32.const 1))
 
 ;; Invalid typing
 
diff --git a/test/core/call_indirect.wast b/test/core/call_indirect.wast
index e1fa41701..938cf7ab9 100644
--- a/test/core/call_indirect.wast
+++ b/test/core/call_indirect.wast
@@ -45,10 +45,12 @@
       $const-i32 $const-i64 $const-f32 $const-f64
       $id-i32 $id-i64 $id-f32 $id-f64
       $f32-i32 $i32-i64 $f64-f32 $i64-f64
-      $fac $fib $even $odd
+      $fac-i64 $fib-i64 $even $odd
       $runaway $mutual-runaway1 $mutual-runaway2
       $over-i32-duplicate $over-i64-duplicate
       $over-f32-duplicate $over-f64-duplicate
+      $fac-i32 $fac-f32 $fac-f64
+      $fib-i32 $fib-f32 $fib-f64
     )
   )
 
@@ -131,13 +133,22 @@
     (call_indirect (type $over-i64) (get_local 1) (get_local 0))
   )
 
-  (func (export "dispatch-structural") (param i32) (result i64)
+  (func (export "dispatch-structural-i64") (param i32) (result i64)
     (call_indirect (type $over-i64-duplicate) (i64.const 9) (get_local 0))
   )
+  (func (export "dispatch-structural-i32") (param i32) (result i32)
+    (call_indirect (type $over-i32-duplicate) (i32.const 9) (get_local 0))
+  )
+  (func (export "dispatch-structural-f32") (param i32) (result f32)
+    (call_indirect (type $over-f32-duplicate) (f32.const 9.0) (get_local 0))
+  )
+  (func (export "dispatch-structural-f64") (param i32) (result f64)
+    (call_indirect (type $over-f64-duplicate) (f64.const 9.0) (get_local 0))
+  )
 
   ;; Recursion
 
-  (func $fac (export "fac") (type $over-i64)
+  (func $fac-i64 (export "fac-i64") (type $over-i64)
     (if (result i64) (i64.eqz (get_local 0))
       (then (i64.const 1))
       (else
@@ -152,7 +163,7 @@
     )
   )
 
-  (func $fib (export "fib") (type $over-i64)
+  (func $fib-i64 (export "fib-i64") (type $over-i64)
     (if (result i64) (i64.le_u (get_local 0) (i64.const 1))
       (then (i64.const 1))
       (else
@@ -170,6 +181,105 @@
     )
   )
 
+  (func $fac-i32 (export "fac-i32") (type $over-i32)
+    (if (result i32) (i32.eqz (get_local 0))
+      (then (i32.const 1))
+      (else
+        (i32.mul
+          (get_local 0)
+          (call_indirect (type $over-i32)
+            (i32.sub (get_local 0) (i32.const 1))
+            (i32.const 23)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fac-f32 (export "fac-f32") (type $over-f32)
+    (if (result f32) (f32.eq (get_local 0) (f32.const 0.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.mul
+          (get_local 0)
+          (call_indirect (type $over-f32)
+            (f32.sub (get_local 0) (f32.const 1.0))
+            (i32.const 24)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fac-f64 (export "fac-f64") (type $over-f64)
+    (if (result f64) (f64.eq (get_local 0) (f64.const 0.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.mul
+          (get_local 0)
+          (call_indirect (type $over-f64)
+            (f64.sub (get_local 0) (f64.const 1.0))
+            (i32.const 25)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib-i32 (export "fib-i32") (type $over-i32)
+    (if (result i32) (i32.le_u (get_local 0) (i32.const 1))
+      (then (i32.const 1))
+      (else
+        (i32.add
+          (call_indirect (type $over-i32)
+            (i32.sub (get_local 0) (i32.const 2))
+            (i32.const 26)
+          )
+          (call_indirect (type $over-i32)
+            (i32.sub (get_local 0) (i32.const 1))
+            (i32.const 26)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib-f32 (export "fib-f32") (type $over-f32)
+    (if (result f32) (f32.le (get_local 0) (f32.const 1.0))
+      (then (f32.const 1.0))
+      (else
+        (f32.add
+          (call_indirect (type $over-f32)
+            (f32.sub (get_local 0) (f32.const 2.0))
+            (i32.const 27)
+          )
+          (call_indirect (type $over-f32)
+            (f32.sub (get_local 0) (f32.const 1.0))
+            (i32.const 27)
+          )
+        )
+      )
+    )
+  )
+
+  (func $fib-f64 (export "fib-f64") (type $over-f64)
+    (if (result f64) (f64.le (get_local 0) (f64.const 1.0))
+      (then (f64.const 1.0))
+      (else
+        (f64.add
+          (call_indirect (type $over-f64)
+            (f64.sub (get_local 0) (f64.const 2.0))
+            (i32.const 28)
+          )
+          (call_indirect (type $over-f64)
+            (f64.sub (get_local 0) (f64.const 1.0))
+            (i32.const 28)
+          )
+        )
+      )
+    )
+  )
+
   (func $even (export "even") (param i32) (result i32)
     (if (result i32) (i32.eqz (get_local 0))
       (then (i32.const 44))
@@ -206,6 +316,64 @@
 
   (func $mutual-runaway1 (export "mutual-runaway") (call_indirect (type $proc) (i32.const 18)))
   (func $mutual-runaway2 (call_indirect (type $proc) (i32.const 17)))
+
+  ;; As parameter of control constructs and instructions
+
+  (memory 1)
+
+  (func (export "as-select-first") (result i32)
+    (select (call_indirect (type $out-i32) (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (call_indirect (type $out-i32) (i32.const 0)))
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (call_indirect (type $out-i32) (i32.const 0)) (then (i32.const 1)) (else (i32.const 2)))
+  )
+
+  (func (export "as-br_if-first") (result i64)
+    (block (result i64) (br_if 0 (call_indirect (type $out-i64) (i32.const 1)) (i32.const 2)))
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (call_indirect (type $out-i32) (i32.const 0))))
+  )
+
+  (func (export "as-br_table-first") (result f32)
+    (block (result f32) (call_indirect (type $out-f32) (i32.const 2)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32) (i32.const 2) (call_indirect (type $out-i32) (i32.const 0)) (br_table 0 0))
+  )
+
+  (func (export "as-store-first")
+    (call_indirect (type $out-i32) (i32.const 0)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 10) (call_indirect (type $out-f64) (i32.const 3)) (f64.store)
+  )
+
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (call_indirect (type $out-i32) (i32.const 0)))
+  )
+  (func (export "as-return-value") (result i32)
+    (call_indirect (type $over-i32) (i32.const 1) (i32.const 4)) (return)
+  )
+  (func (export "as-drop-operand")
+    (call_indirect (type $over-i64) (i64.const 1) (i32.const 5)) (drop)
+  )
+  (func (export "as-br-value") (result f32)
+    (block (result f32) (br 0 (call_indirect (type $over-f32) (f32.const 1) (i32.const 6))))
+  )
+  (func (export "as-set_local-value") (result f64)
+    (local f64) (set_local 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) (get_local 0)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (call_indirect (type $out-i32) (i32.const 0)))
+  )
 )
 
 (assert_return (invoke "type-i32") (i32.const 0x132))
@@ -232,27 +400,81 @@
 (assert_return (invoke "dispatch" (i32.const 20) (i64.const 2)) (i64.const 2))
 (assert_trap (invoke "dispatch" (i32.const 0) (i64.const 2)) "indirect call type mismatch")
 (assert_trap (invoke "dispatch" (i32.const 15) (i64.const 2)) "indirect call type mismatch")
-(assert_trap (invoke "dispatch" (i32.const 23) (i64.const 2)) "undefined element")
+(assert_trap (invoke "dispatch" (i32.const 29) (i64.const 2)) "undefined element")
 (assert_trap (invoke "dispatch" (i32.const -1) (i64.const 2)) "undefined element")
 (assert_trap (invoke "dispatch" (i32.const 1213432423) (i64.const 2)) "undefined element")
 
-(assert_return (invoke "dispatch-structural" (i32.const 5)) (i64.const 9))
-(assert_return (invoke "dispatch-structural" (i32.const 5)) (i64.const 9))
-(assert_return (invoke "dispatch-structural" (i32.const 12)) (i64.const 362880))
-(assert_return (invoke "dispatch-structural" (i32.const 20)) (i64.const 9))
-(assert_trap (invoke "dispatch-structural" (i32.const 11)) "indirect call type mismatch")
-(assert_trap (invoke "dispatch-structural" (i32.const 22)) "indirect call type mismatch")
-
-(assert_return (invoke "fac" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "fac" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fac" (i64.const 5)) (i64.const 120))
-(assert_return (invoke "fac" (i64.const 25)) (i64.const 7034535277573963776))
-
-(assert_return (invoke "fib" (i64.const 0)) (i64.const 1))
-(assert_return (invoke "fib" (i64.const 1)) (i64.const 1))
-(assert_return (invoke "fib" (i64.const 2)) (i64.const 2))
-(assert_return (invoke "fib" (i64.const 5)) (i64.const 8))
-(assert_return (invoke "fib" (i64.const 20)) (i64.const 10946))
+(assert_return (invoke "dispatch-structural-i64" (i32.const 5)) (i64.const 9))
+(assert_return (invoke "dispatch-structural-i64" (i32.const 12)) (i64.const 362880))
+(assert_return (invoke "dispatch-structural-i64" (i32.const 13)) (i64.const 55))
+(assert_return (invoke "dispatch-structural-i64" (i32.const 20)) (i64.const 9))
+(assert_trap (invoke "dispatch-structural-i64" (i32.const 11)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-i64" (i32.const 22)) "indirect call type mismatch")
+
+(assert_return (invoke "dispatch-structural-i32" (i32.const 4)) (i32.const 9))
+(assert_return (invoke "dispatch-structural-i32" (i32.const 23)) (i32.const 362880))
+(assert_return (invoke "dispatch-structural-i32" (i32.const 26)) (i32.const 55))
+(assert_return (invoke "dispatch-structural-i32" (i32.const 19)) (i32.const 9))
+(assert_trap (invoke "dispatch-structural-i32" (i32.const 9)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-i32" (i32.const 21)) "indirect call type mismatch")
+
+(assert_return (invoke "dispatch-structural-f32" (i32.const 6)) (f32.const 9.0))
+(assert_return (invoke "dispatch-structural-f32" (i32.const 24)) (f32.const 362880.0))
+(assert_return (invoke "dispatch-structural-f32" (i32.const 27)) (f32.const 55.0))
+(assert_return (invoke "dispatch-structural-f32" (i32.const 21)) (f32.const 9.0))
+(assert_trap (invoke "dispatch-structural-f32" (i32.const 8)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-f32" (i32.const 19)) "indirect call type mismatch")
+
+(assert_return (invoke "dispatch-structural-f64" (i32.const 7)) (f64.const 9.0))
+(assert_return (invoke "dispatch-structural-f64" (i32.const 25)) (f64.const 362880.0))
+(assert_return (invoke "dispatch-structural-f64" (i32.const 28)) (f64.const 55.0))
+(assert_return (invoke "dispatch-structural-f64" (i32.const 22)) (f64.const 9.0))
+(assert_trap (invoke "dispatch-structural-f64" (i32.const 10)) "indirect call type mismatch")
+(assert_trap (invoke "dispatch-structural-f64" (i32.const 18)) "indirect call type mismatch")
+
+(assert_return (invoke "fac-i64" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fac-i64" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fac-i64" (i64.const 5)) (i64.const 120))
+(assert_return (invoke "fac-i64" (i64.const 25)) (i64.const 7034535277573963776))
+
+(assert_return (invoke "fac-i32" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "fac-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "fac-i32" (i32.const 5)) (i32.const 120))
+(assert_return (invoke "fac-i32" (i32.const 10)) (i32.const 3628800))
+
+(assert_return (invoke "fac-f32" (f32.const 0.0)) (f32.const 1.0))
+(assert_return (invoke "fac-f32" (f32.const 1.0)) (f32.const 1.0))
+(assert_return (invoke "fac-f32" (f32.const 5.0)) (f32.const 120.0))
+(assert_return (invoke "fac-f32" (f32.const 10.0)) (f32.const 3628800.0))
+
+(assert_return (invoke "fac-f64" (f64.const 0.0)) (f64.const 1.0))
+(assert_return (invoke "fac-f64" (f64.const 1.0)) (f64.const 1.0))
+(assert_return (invoke "fac-f64" (f64.const 5.0)) (f64.const 120.0))
+(assert_return (invoke "fac-f64" (f64.const 10.0)) (f64.const 3628800.0))
+
+(assert_return (invoke "fib-i64" (i64.const 0)) (i64.const 1))
+(assert_return (invoke "fib-i64" (i64.const 1)) (i64.const 1))
+(assert_return (invoke "fib-i64" (i64.const 2)) (i64.const 2))
+(assert_return (invoke "fib-i64" (i64.const 5)) (i64.const 8))
+(assert_return (invoke "fib-i64" (i64.const 20)) (i64.const 10946))
+
+(assert_return (invoke "fib-i32" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "fib-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "fib-i32" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "fib-i32" (i32.const 5)) (i32.const 8))
+(assert_return (invoke "fib-i32" (i32.const 20)) (i32.const 10946))
+
+(assert_return (invoke "fib-f32" (f32.const 0.0)) (f32.const 1.0))
+(assert_return (invoke "fib-f32" (f32.const 1.0)) (f32.const 1.0))
+(assert_return (invoke "fib-f32" (f32.const 2.0)) (f32.const 2.0))
+(assert_return (invoke "fib-f32" (f32.const 5.0)) (f32.const 8.0))
+(assert_return (invoke "fib-f32" (f32.const 20.0)) (f32.const 10946.0))
+
+(assert_return (invoke "fib-f64" (f64.const 0.0)) (f64.const 1.0))
+(assert_return (invoke "fib-f64" (f64.const 1.0)) (f64.const 1.0))
+(assert_return (invoke "fib-f64" (f64.const 2.0)) (f64.const 2.0))
+(assert_return (invoke "fib-f64" (f64.const 5.0)) (f64.const 8.0))
+(assert_return (invoke "fib-f64" (f64.const 20.0)) (f64.const 10946.0))
 
 (assert_return (invoke "even" (i32.const 0)) (i32.const 44))
 (assert_return (invoke "even" (i32.const 1)) (i32.const 99))
@@ -266,6 +488,27 @@
 (assert_exhaustion (invoke "runaway") "call stack exhausted")
 (assert_exhaustion (invoke "mutual-runaway") "call stack exhausted")
 
+(assert_return (invoke "as-select-first") (i32.const 0x132))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-if-condition") (i32.const 1))
+
+(assert_return (invoke "as-br_if-first") (i64.const 0x164))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (f32.const 0xf32))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+(assert_return (invoke "as-return-value") (i32.const 1))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (f32.const 1))
+(assert_return (invoke "as-set_local-value") (f64.const 1))
+(assert_return (invoke "as-load-operand") (i32.const 1))
 
 ;; Invalid syntax
 

From 81013b49f2f741091a065a0dbac9293533994e2a Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Sat, 29 Sep 2018 23:30:23 +0800
Subject: [PATCH 292/329] [test] Improve coverage of select (#871)

---
 test/core/select.wast | 209 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 209 insertions(+)

diff --git a/test/core/select.wast b/test/core/select.wast
index 4dfa45612..ba8074604 100644
--- a/test/core/select.wast
+++ b/test/core/select.wast
@@ -1,4 +1,9 @@
 (module
+
+  (memory 1)
+
+  (func $dummy)
+
   (func (export "select_i32") (param $lhs i32) (param $rhs i32) (param $cond i32) (result i32)
    (select (get_local $lhs) (get_local $rhs) (get_local $cond)))
 
@@ -26,6 +31,127 @@
     (unreachable) (f32.const 0) (i32.const 0) (select)
     (unreachable)
   )
+
+  ;; As the argument of control constructs and instructions
+
+  (func (export "as-select-first") (param i32) (result i32)
+    (select (select (i32.const 0) (i32.const 1) (get_local 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (param i32) (result i32)
+    (select (i32.const 2) (select (i32.const 0) (i32.const 1) (get_local 0)) (i32.const 3))
+  )
+  (func (export "as-select-last") (param i32) (result i32)
+    (select (i32.const 2) (i32.const 3) (select (i32.const 0) (i32.const 1) (get_local 0)))
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32) (select (i32.const 2) (i32.const 3) (get_local 0)) (call $dummy) (call $dummy))
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (select (i32.const 2) (i32.const 3) (get_local 0)) (call $dummy))
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (call $dummy) (select (i32.const 2) (i32.const 3) (get_local 0)))
+  )
+
+  (func (export "as-if-condition") (param i32)
+    (select (i32.const 2) (i32.const 3) (get_local 0)) (if (then (call $dummy)))
+  )
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (i32.const 1) (then (select (i32.const 2) (i32.const 3) (get_local 0))) (else (i32.const 4)))
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (i32.const 0) (then (i32.const 2)) (else (select (i32.const 2) (i32.const 3) (get_local 0))))
+  )
+
+  (func (export "as-br_if-first") (param i32) (result i32)
+    (block (result i32) (br_if 0 (select (i32.const 2) (i32.const 3) (get_local 0)) (i32.const 4)))
+  )
+  (func (export "as-br_if-last") (param i32) (result i32)
+    (block (result i32) (br_if 0 (i32.const 2) (select (i32.const 2) (i32.const 3) (get_local 0))))
+  )
+
+  (func (export "as-br_table-first") (param i32) (result i32)
+    (block (result i32) (select (i32.const 2) (i32.const 3) (get_local 0)) (i32.const 2) (br_table 0 0))
+  )
+  (func (export "as-br_table-last") (param i32) (result i32)
+    (block (result i32) (i32.const 2) (select (i32.const 2) (i32.const 3) (get_local 0)) (br_table 0 0))
+  )
+
+  (func $func (param i32 i32) (result i32) (get_local 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table anyfunc (elem $func))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (select (i32.const 2) (i32.const 3) (get_local 0)) (i32.const 1) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (select (i32.const 2) (i32.const 3) (get_local 0)) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 1) (i32.const 4) (select (i32.const 2) (i32.const 3) (get_local 0))
+      )
+    )
+  )
+
+  (func (export "as-store-first") (param i32)
+    (select (i32.const 0) (i32.const 4) (get_local 0)) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last") (param i32)
+    (i32.const 8) (select (i32.const 1) (i32.const 2) (get_local 0)) (i32.store)
+  )
+
+  (func (export "as-memory.grow-value") (param i32) (result i32)
+    (memory.grow (select (i32.const 1) (i32.const 2) (get_local 0)))
+  )
+
+  (func $f (param i32) (result i32) (get_local 0))
+
+  (func (export "as-call-value") (param i32) (result i32)
+    (call $f (select (i32.const 1) (i32.const 2) (get_local 0)))
+  )
+  (func (export "as-return-value") (param i32) (result i32)
+    (select (i32.const 1) (i32.const 2) (get_local 0)) (return)
+  )
+  (func (export "as-drop-operand") (param i32)
+    (drop (select (i32.const 1) (i32.const 2) (get_local 0)))
+  )
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (select (i32.const 1) (i32.const 2) (get_local 0))))
+  )
+  (func (export "as-set_local-value") (param i32) (result i32)
+    (local i32) (set_local 0 (select (i32.const 1) (i32.const 2) (get_local 0))) (get_local 0)
+  )
+  (func (export "as-tee_local-value") (param i32) (result i32)
+    (tee_local 0 (select (i32.const 1) (i32.const 2) (get_local 0)))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-set_global-value") (param i32) (result i32)
+    (set_global $a (select (i32.const 1) (i32.const 2) (get_local 0)))
+    (get_global $a)
+  )
+  (func (export "as-load-operand") (param i32) (result i32)
+    (i32.load (select (i32.const 0) (i32.const 4) (get_local 0)))
+  )
+
+  (func (export "as-unary-operand") (param i32) (result i32)
+    (i32.eqz (select (i32.const 0) (i32.const 1) (get_local 0)))
+  )
+  (func (export "as-binary-operand") (param i32) (result i32)
+    (i32.mul
+      (select (i32.const 1) (i32.const 2) (get_local 0))
+      (select (i32.const 1) (i32.const 2) (get_local 0))
+    )
+  )
 )
 
 (assert_return (invoke "select_i32" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
@@ -61,7 +187,90 @@
 (assert_trap (invoke "select_trap_r" (i32.const 1)) "unreachable executed")
 (assert_trap (invoke "select_trap_r" (i32.const 0)) "unreachable executed")
 
+(assert_return (invoke "as-select-first" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-select-first" (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-select-mid" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-select-last" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-mid" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-if-condition" (i32.const 0)))
+(assert_return (invoke "as-if-condition" (i32.const 1)))
+(assert_return (invoke "as-if-then" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-if-else" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_if-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_if-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-br_if-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_if-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-br_table-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-br_table-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br_table-last" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-call_indirect-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 1)) (i32.const 1))
+(assert_trap (invoke "as-call_indirect-last" (i32.const 0)) "undefined element")
+(assert_trap (invoke "as-call_indirect-last" (i32.const 1)) "undefined element")
+
+(assert_return (invoke "as-store-first" (i32.const 0)))
+(assert_return (invoke "as-store-first" (i32.const 1)))
+(assert_return (invoke "as-store-last" (i32.const 0)))
+(assert_return (invoke "as-store-last" (i32.const 1)))
+
+(assert_return (invoke "as-memory.grow-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-memory.grow-value" (i32.const 1)) (i32.const 3))
+
+(assert_return (invoke "as-call-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-call-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-return-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-drop-operand" (i32.const 0)))
+(assert_return (invoke "as-drop-operand" (i32.const 1)))
+(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-set_local-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-set_local-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-tee_local-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-tee_local-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-set_global-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-set_global-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-unary-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-binary-operand" (i32.const 0)) (i32.const 4))
+(assert_return (invoke "as-binary-operand" (i32.const 1)) (i32.const 1))
+
 (assert_invalid
   (module (func $arity-0 (select (nop) (nop) (i32.const 1))))
   "type mismatch"
 )
+
+;; The first two operands should have the same type as each other
+
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (i64.const 1) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (f32.const 1.0) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-num-vs-num (select (i32.const 1) (f64.const 1.0) (i32.const 1))))
+  "type mismatch"
+)

From 2ba6882a3dfc702d94c2f92f70f7e1815b5bcf6f Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Sun, 30 Sep 2018 04:05:49 +0800
Subject: [PATCH 293/329] [test] Improve coverage for globals (#881)

---
 test/core/globals.wast | 193 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 193 insertions(+)

diff --git a/test/core/globals.wast b/test/core/globals.wast
index 175af3679..5a7c6d39f 100644
--- a/test/core/globals.wast
+++ b/test/core/globals.wast
@@ -24,6 +24,158 @@
   (func (export "get-6") (result f64) (get_global 6))
   (func (export "set-5") (param f32) (set_global 5 (get_local 0)))
   (func (export "set-6") (param f64) (set_global 6 (get_local 0)))
+
+  ;; As the argument of control constructs and instructions
+
+  (memory 1)
+
+  (func $dummy)
+
+  (func (export "as-select-first") (result i32)
+    (select (get_global $x) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-select-mid") (result i32)
+    (select (i32.const 2) (get_global $x) (i32.const 3))
+  )
+  (func (export "as-select-last") (result i32)
+    (select (i32.const 2) (i32.const 3) (get_global $x))
+  )
+
+  (func (export "as-loop-first") (result i32)
+    (loop (result i32)
+      (get_global $x) (call $dummy) (call $dummy)
+    )
+  )
+  (func (export "as-loop-mid") (result i32)
+    (loop (result i32)
+      (call $dummy) (get_global $x) (call $dummy)
+    )
+  )
+  (func (export "as-loop-last") (result i32)
+    (loop (result i32)
+      (call $dummy) (call $dummy) (get_global $x)
+    )
+  )
+
+  (func (export "as-if-condition") (result i32)
+    (if (result i32) (get_global $x)
+      (then (call $dummy) (i32.const 2))
+      (else (call $dummy) (i32.const 3))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (get_global $x)) (else (i32.const 2))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 2)) (else (get_global $x))
+    )
+  )
+
+  (func (export "as-br_if-first") (result i32)
+    (block (result i32)
+      (br_if 0 (get_global $x) (i32.const 2))
+      (return (i32.const 3))
+    )
+  )
+  (func (export "as-br_if-last") (result i32)
+    (block (result i32)
+      (br_if 0 (i32.const 2) (get_global $x))
+      (return (i32.const 3))
+    )
+  )
+
+  (func (export "as-br_table-first") (result i32)
+    (block (result i32)
+      (get_global $x) (i32.const 2) (br_table 0 0)
+    )
+  )
+  (func (export "as-br_table-last") (result i32)
+    (block (result i32)
+      (i32.const 2) (get_global $x) (br_table 0 0)
+    )
+  )
+
+  (func $func (param i32 i32) (result i32) (get_local 0))
+  (type $check (func (param i32 i32) (result i32)))
+  (table anyfunc (elem $func))
+  (func (export "as-call_indirect-first") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (get_global $x) (i32.const 2) (i32.const 0)
+      )
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (get_global $x) (i32.const 0)
+      )
+    )
+  )
+ (func (export "as-call_indirect-last") (result i32)
+    (block (result i32)
+      (call_indirect (type $check)
+        (i32.const 2) (i32.const 0) (get_global $x)
+      )
+    )
+  )
+
+  (func (export "as-store-first")
+    (get_global $x) (i32.const 1) (i32.store)
+  )
+  (func (export "as-store-last")
+    (i32.const 0) (get_global $x) (i32.store)
+  )
+  (func (export "as-load-operand") (result i32)
+    (i32.load (get_global $x))
+  )
+  (func (export "as-memory.grow-value") (result i32)
+    (memory.grow (get_global $x))
+  )
+
+  (func $f (param i32) (result i32) (get_local 0))
+  (func (export "as-call-value") (result i32)
+    (call $f (get_global $x))
+  )
+
+  (func (export "as-return-value") (result i32)
+    (get_global $x) (return)
+  )
+  (func (export "as-drop-operand")
+    (drop (get_global $x))
+  )
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (get_global $x)))
+  )
+
+  (func (export "as-set_local-value") (param i32) (result i32)
+    (set_local 0 (get_global $x))
+    (get_local 0)
+  )
+  (func (export "as-tee_local-value") (param i32) (result i32)
+    (tee_local 0 (get_global $x))
+  )
+  (func (export "as-set_global-value") (result i32)
+    (set_global $x (get_global $x))
+    (get_global $x)
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.eqz (get_global $x))
+  )
+  (func (export "as-binary-operand") (result i32)
+    (i32.mul
+      (get_global $x) (get_global $x)
+    )
+  )
+  (func (export "as-compare-operand") (result i32)
+    (i32.gt_u
+      (get_global 0) (i32.const 1)
+    )
+  )
 )
 
 (assert_return (invoke "get-a") (i32.const -2))
@@ -46,6 +198,47 @@
 (assert_return (invoke "get-5") (f32.const 8))
 (assert_return (invoke "get-6") (f64.const 9))
 
+(assert_return (invoke "as-select-first") (i32.const 6))
+(assert_return (invoke "as-select-mid") (i32.const 2))
+(assert_return (invoke "as-select-last") (i32.const 2))
+
+(assert_return (invoke "as-loop-first") (i32.const 6))
+(assert_return (invoke "as-loop-mid") (i32.const 6))
+(assert_return (invoke "as-loop-last") (i32.const 6))
+
+(assert_return (invoke "as-if-condition") (i32.const 2))
+(assert_return (invoke "as-if-then") (i32.const 6))
+(assert_return (invoke "as-if-else") (i32.const 6))
+
+(assert_return (invoke "as-br_if-first") (i32.const 6))
+(assert_return (invoke "as-br_if-last") (i32.const 2))
+
+(assert_return (invoke "as-br_table-first") (i32.const 6))
+(assert_return (invoke "as-br_table-last") (i32.const 2))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const 6))
+(assert_return (invoke "as-call_indirect-mid") (i32.const 2))
+(assert_trap (invoke "as-call_indirect-last") "undefined element")
+
+(assert_return (invoke "as-store-first"))
+(assert_return (invoke "as-store-last"))
+(assert_return (invoke "as-load-operand") (i32.const 1))
+(assert_return (invoke "as-memory.grow-value") (i32.const 1))
+
+(assert_return (invoke "as-call-value") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 6))
+(assert_return (invoke "as-drop-operand"))
+(assert_return (invoke "as-br-value") (i32.const 6))
+
+(assert_return (invoke "as-set_local-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-tee_local-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-set_global-value") (i32.const 6))
+
+(assert_return (invoke "as-unary-operand") (i32.const 0))
+(assert_return (invoke "as-binary-operand") (i32.const 36))
+(assert_return (invoke "as-compare-operand") (i32.const 1))
+
 (assert_invalid
   (module (global f32 (f32.const 0)) (func (set_global 0 (i32.const 1))))
   "global is immutable"

From 26db2a25b12d2033a0598add3a38cbb36a6a0210 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Wed, 3 Oct 2018 21:19:50 +0200
Subject: [PATCH 294/329] Editorial: Fix typo. (#885)

---
 document/web-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 87bc5b3cf..897b42dd9 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -125,7 +125,7 @@ Note: This algorithm accepts a {{Response}} object, or a
         1. If |response|'s [=response/status=] is not an [=ok status=], [=reject=] |returnValue| with a {{TypeError}} and abort these substeps.
         1. [=Consume body|consume=] |response|'s body as an {{ArrayBuffer}}, and let |bodyPromise| be the result.
 
-            Note: Although it is specified here that the response is consumed entirely before compilation proceeds, that is purely for ease of specification; implementations are likely to instead perform processing in a streaming fashion. The different is unobservable, and thus the simpler model is specified. <!-- Using consume is a bit silly as it creates an ArrayBuffer but then we just want the underlying bytes. This is because of how streams is specced in terms of promises and JS objects whereas we want to operate more directly on the underlying concept. We can revisit this if things change in the Streams/Fetch specs. -->
+            Note: Although it is specified here that the response is consumed entirely before compilation proceeds, that is purely for ease of specification; implementations are likely to instead perform processing in a streaming fashion. The difference is unobservable, and thus the simpler model is specified. <!-- Using consume is a bit silly as it creates an ArrayBuffer but then we just want the underlying bytes. This is because of how streams is specced in terms of promises and JS objects whereas we want to operate more directly on the underlying concept. We can revisit this if things change in the Streams/Fetch specs. -->
 
         1. [=Upon fulfillment=] of |bodyPromise| with value |bodyArrayBuffer|:
             1. Let |stableBytes| be a [=get a copy of the buffer source|copy of the bytes held by the buffer=] |bodyArrayBuffer|.

From 2de3fb0ce193d98d8ceb23394620edd86c9fa041 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Fri, 5 Oct 2018 15:43:02 -0700
Subject: [PATCH 295/329] [core test] Reject "long" LEB128 reserved bytes
 (#888)

`call_indirect`, `memory.grow`, and `memory.size` all require the
memory/table index to be a single zero byte.

These tests ensure that the index is not being parsed as a LEB128, which
can encode zero as two or more bytes: `0x80 0x00`, `0x80 0x80 0x00`,
etc.
---
 test/core/binary.wast | 226 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 226 insertions(+)

diff --git a/test/core/binary.wast b/test/core/binary.wast
index bb4008da8..dd7cca106 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -287,6 +287,80 @@
   "zero flag expected"
 )
 
+;; call_indirect reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0a\01"               ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\00"                   ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0b\01"               ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\80\00"                ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0c\01"               ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\80\80\00"             ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"      ;; Type section
+    "\03\02\01\00"            ;; Function section
+    "\04\04\01\70\00\00"      ;; Table section
+    "\0a\0d\01"               ;; Code section
+
+    ;; function 0
+    "\0a\00"
+    "\41\00"                   ;; i32.const 0
+    "\11\00"                   ;; call_indirect (type 0)
+    "\80\80\80\80\00"          ;; call_indirect reserved byte
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
 ;; memory.grow reserved byte equal to zero.
 (assert_malformed
   (module binary
@@ -307,6 +381,84 @@
   "zero flag expected"
 )
 
+;; memory.grow reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\00"                   ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\00"                ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0c\01"                ;; Code section
+
+    ;; function 0
+    "\0a\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\00"             ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0d\01"                ;; Code section
+
+    ;; function 0
+    "\0b\00"
+    "\41\00"                   ;; i32.const 0
+    "\40"                      ;; memory.grow
+    "\80\80\80\80\00"          ;; memory.grow reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
 ;; memory.size reserved byte equal to zero.
 (assert_malformed
   (module binary
@@ -326,6 +478,80 @@
   "zero flag expected"
 )
 
+;; memory.size reserved byte should not be a "long" LEB128 zero.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\08\01"                ;; Code section
+
+    ;; function 0
+    "\06\00"
+    "\3f"                      ;; memory.size
+    "\80\00"                   ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+;; Same as above for 3, 4, and 5-byte zero encodings.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\09\01"                ;; Code section
+
+    ;; function 0
+    "\07\00"
+    "\3f"                      ;; memory.size
+    "\80\80\00"                ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0a\01"                ;; Code section
+
+    ;; function 0
+    "\08\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\00"             ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"       ;; Type section
+    "\03\02\01\00"             ;; Function section
+    "\05\03\01\00\00"          ;; Memory section
+    "\0a\0b\01"                ;; Code section
+
+    ;; function 0
+    "\09\00"
+    "\3f"                      ;; memory.size
+    "\80\80\80\80\00"          ;; memory.size reserved byte
+    "\1a"                      ;; drop
+    "\0b"                      ;; end
+  )
+  "zero flag expected"
+)
+
 ;; No more than 2^32 locals.
 (assert_malformed 
   (module binary

From f5e1fd138ccfe588abde7d8438bcc8f391576a28 Mon Sep 17 00:00:00 2001
From: Ben Smith <binji@chromium.org>
Date: Fri, 5 Oct 2018 11:07:20 -0700
Subject: [PATCH 296/329] [js-api] Add definition of Memory#buffer getter

See issue #840.
---
 document/js-api/index.bs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 98c1f213a..0146ad49a 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -616,6 +616,10 @@ Immediately after a WebAssembly [=grow_memory=] instruction executes, perform th
         1. [=Reset the memory buffer=] of |memaddr|.
 </div>
 
+<div algorithm>
+    The getter of the <dfn attribute for="Memory">buffer</dfn> attribute of {{Memory}} returns the receiver's \[[BufferObject]] internal slot.
+</div>
+
 <h3 id="tables">Tables</h3>
 
 <pre class="idl">

From 05aa1d90fc5881fed0480caa28841a7655b0dbcd Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <titzer@google.com>
Date: Fri, 27 Apr 2018 16:01:19 +0200
Subject: [PATCH 297/329] Initial commit of spec text and test for WASM limits.

---
 document/js-api/index.bs            |  28 +++++
 test/build.py                       |   2 +-
 test/harness/wasm-module-builder.js |  15 ++-
 test/js-api/limits.js               | 160 ++++++++++++++++++++++++++++
 4 files changed, 200 insertions(+), 5 deletions(-)
 create mode 100644 test/js-api/limits.js

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 0146ad49a..dd402dd26 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -989,3 +989,31 @@ same class of exception is thrown as for out of memory conditions in JavaScript.
 The particular exception here is implementation-defined in both cases.
 
 Note: ECMAScript doesn't specify any sort of behavior on out-of-memory conditions; implementations have been observed to throw OOMError and to crash. Either is valid here.
+
+<h2 id="limits">Implementation-defined Limits</h2>
+
+The WebAssembly core specification allows an implementation to define limits on the syntactic structure of the module.
+The standard WebAssembly JavaScript Interface described in this document hereby defines a set of standard limits on the syntactic module structure as below.
+Modules that exceed these limits are invalid and are rejected with a {{CompileError}}.
+
+<ul>
+<li>The maximum size of a module is 1073741824 bytes (1 GiB).</li>
+<li>The maximum number of types defined in the types section is 1000000.</li>
+<li>The maximum number of functions defined in a module is 1000000.</li>
+<li>The maximum number of imports declared in a module is 100000.</li>
+<li>The maximum number of exports declared in a module is 100000.</li>
+<li>The maximum number of globals defined in a module is 1000000.</li>
+<li>The maximum number of data segments defined in a module is 100000.</li>
+
+<li>The maximum number of tables, including declared or imported tables, is 1.</li>
+<li>The maximum size of a table is 10000000.</li>
+<li>The maximum number of table entries in any table initialization is 10000000.</li>
+<li>The maximum number of memories, including declared or imported memories, is 1.</li>
+<li>The initial or maximum number of pages for any memory, declared or imported, is at most 32767.</li>
+
+<li>The maximum number of parameters to any function is 1000.</li>
+<li>The maximum number of return types for any function is 1.</li>
+<li>The maximum size of a function body, including locals declarations, is 7654321 bytes.</li>
+<li>The maximum number of locals declared in a function is 50000.</li>
+
+</ul>
diff --git a/test/build.py b/test/build.py
index a6304d0a1..4d8557fc5 100755
--- a/test/build.py
+++ b/test/build.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 
 import argparse
 import sys
diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index 29b5518c2..60ae8745a 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -284,8 +284,15 @@ class WasmModuleBuilder {
     return this.addFunctionTableInit(this.function_table.length, false, array);
   }
 
+  setFunctionTableBounds(min, max) {
+    this.function_table_length_min = min;
+    this.function_table_length_max = max;
+    return this;
+  }
+
   setFunctionTableLength(length) {
-    this.function_table_length = length;
+    this.function_table_length_min = length;
+    this.function_table_length_max = length;
     return this;
   }
 
@@ -364,14 +371,14 @@ class WasmModuleBuilder {
     }
 
     // Add function_table.
-    if (wasm.function_table_length > 0) {
+    if (wasm.function_table_length_min > 0) {
       if (debug) print("emitting table @ " + binary.length);
       binary.emit_section(kTableSectionCode, section => {
         section.emit_u8(1);  // one table entry
         section.emit_u8(kWasmAnyFunctionTypeForm);
         section.emit_u8(1);
-        section.emit_u32v(wasm.function_table_length);
-        section.emit_u32v(wasm.function_table_length);
+        section.emit_u32v(wasm.function_table_length_min);
+        section.emit_u32v(wasm.function_table_length_max);
       });
     }
 
diff --git a/test/js-api/limits.js b/test/js-api/limits.js
new file mode 100644
index 000000000..dab7b5911
--- /dev/null
+++ b/test/js-api/limits.js
@@ -0,0 +1,160 @@
+/*
+ * Copyright 2018 WebAssembly Community Group participants
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+*/
+
+let kJSEmbeddingMaxTypes = 1000000;
+let kJSEmbeddingMaxFunctions = 1000000;
+let kJSEmbeddingMaxImports = 100000;
+let kJSEmbeddingMaxExports = 100000;
+let kJSEmbeddingMaxGlobals = 1000000;
+let kJSEmbeddingMaxDataSegments = 100000;
+
+let kJSEmbeddingMaxMemoryPages = 32767;  // ~ 2 GiB
+let kJSEmbeddingMaxModuleSize = 1024 * 1024 * 1024;  // = 1 GiB
+let kJSEmbeddingMaxFunctionSize = 7654321;
+let kJSEmbeddingMaxFunctionLocals = 50000;
+let kJSEmbeddingMaxFunctionParams = 1000;
+let kJSEmbeddingMaxFunctionReturns = 1;
+let kJSEmbeddingMaxTableSize = 10000000;
+let kJSEmbeddingMaxTableEntries = 10000000;
+let kJSEmbeddingMaxTables = 1;
+let kJSEmbeddingMaxMemories = 1;
+
+if (typeof(assert_equals) != "function" && typeof(assertEquals) == "function") {
+  // TODO(titzer): local standalone hack
+  assert_equals = assertEquals;
+}
+
+function testLimit(name, min, limit, gen) {
+    print("test max " + name + " = " + limit);
+    function run(count) {
+        var expected = (count <= limit) ? "(expect ok)  " : "(expect fail)";
+        print("  " + expected + " " + count + "...");
+        // TODO(titzer): the builder is pretty inefficient for large modules; do manually?
+        let builder = new WasmModuleBuilder();
+        gen(builder, count);
+        return WebAssembly.validate(builder.toBuffer());
+    }
+    assert_equals(true, run(min));
+    assert_equals(true, run(limit));
+    assert_equals(false, run(limit+1));
+}
+
+// A little doodad to disable a test easily
+let DISABLED = {testLimit: () => 0};
+let X = DISABLED;
+
+testLimit("types", 1, kJSEmbeddingMaxTypes, (builder, count) => {
+        for (let i = 0; i < count; i++) {
+            builder.addType(kSig_i_i);
+        }
+    });
+
+testLimit("functions", 1, kJSEmbeddingMaxFunctions, (builder, count) => {
+        let type = builder.addType(kSig_v_v);
+        let body = [];
+        for (let i = 0; i < count; i++) {
+            builder.addFunction(/*name=*/ undefined, type).addBody(body);
+        }
+    });
+
+testLimit("imports", 1, kJSEmbeddingMaxImports, (builder, count) => {
+        let type = builder.addType(kSig_v_v);
+        for (let i = 0; i < count; i++) {
+            builder.addImport("", "", type);
+        }
+    });
+
+testLimit("exports", 1, kJSEmbeddingMaxExports, (builder, count) => {
+        let type = builder.addType(kSig_v_v);
+        let f = builder.addFunction(/*name=*/ undefined, type);
+        f.addBody([]);
+        for (let i = 0; i < count; i++) {
+            builder.addExport("f" + i, f.index);
+        }
+    });
+
+testLimit("globals", 1, kJSEmbeddingMaxGlobals, (builder, count) => {
+        for (let i = 0; i < count; i++) {
+            builder.addGlobal(kWasmI32, true);
+        }
+    });
+
+testLimit("data segments", 1, kJSEmbeddingMaxDataSegments, (builder, count) => {
+        let data = [];
+        builder.addMemory(1, 1, false, false);
+        for (let i = 0; i < count; i++) {
+            builder.addDataSegment(0, data);
+        }
+    });
+
+testLimit("memory pages", 1, kJSEmbeddingMaxMemoryPages, (builder, count) => {
+        builder.addMemory(count, count, false, false);
+    });
+
+// TODO(titzer): ugh, that's hard to test.
+DISABLED.testLimit("module size", 1, kJSEmbeddingMaxModuleSize, (builder, count) => {
+    });
+
+testLimit("function size", 2, kJSEmbeddingMaxFunctionSize, (builder, count) => {
+        let type = builder.addType(kSig_v_v);
+        let nops = count-2;
+        let array = new Array(nops);
+        for (let i = 0; i < nops; i++) array[i] = kExprNop;
+        builder.addFunction(undefined, type).addBody(array);
+    });
+
+testLimit("function locals", 1, kJSEmbeddingMaxFunctionLocals, (builder, count) => {
+        let type = builder.addType(kSig_v_v);
+        builder.addFunction(undefined, type)
+          .addLocals({i32_count: count})
+          .addBody([]);
+    });
+
+testLimit("function params", 1, kJSEmbeddingMaxFunctionParams, (builder, count) => {
+        let array = new Array(count);
+        for (let i = 0; i < count; i++) array[i] = kWasmI32;
+        let type = builder.addType({params: array, results: []});
+    });
+
+testLimit("function returns", 0, kJSEmbeddingMaxFunctionReturns, (builder, count) => {
+        let array = new Array(count);
+        for (let i = 0; i < count; i++) array[i] = kWasmI32;
+        let type = builder.addType({params: [], results: array});
+    });
+
+testLimit("table size", 1, kJSEmbeddingMaxTableSize, (builder, count) => {
+        builder.setFunctionTableBounds(count, count);
+    });
+
+testLimit("table entries", 1, kJSEmbeddingMaxTableEntries, (builder, count) => {
+        builder.setFunctionTableBounds(1, 1);
+        let array = [];
+        for (let i = 0; i < count; i++) {
+            builder.addFunctionTableInit(0, false, array, false);
+        }
+    });
+
+testLimit("tables", 0, kJSEmbeddingMaxTables, (builder, count) => {
+        for (let i = 0; i < count; i++) {
+            builder.addImportedTable("", "", 1, 1);
+        }
+    });
+
+testLimit("memories", 0, kJSEmbeddingMaxMemories, (builder, count) => {
+        for (let i = 0; i < count; i++) {
+            builder.addImportedMemory("", "", 1, 1, false);
+        }
+    });

From bd103fcb1f67fa97a3f738c439fcf3fe86ca512a Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <titzer@google.com>
Date: Wed, 2 May 2018 17:05:10 +0200
Subject: [PATCH 298/329] Add test for function with params and locals

---
 test/js-api/limits.js | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/test/js-api/limits.js b/test/js-api/limits.js
index dab7b5911..92ad11522 100644
--- a/test/js-api/limits.js
+++ b/test/js-api/limits.js
@@ -35,6 +35,8 @@ let kJSEmbeddingMaxMemories = 1;
 if (typeof(assert_equals) != "function" && typeof(assertEquals) == "function") {
   // TODO(titzer): local standalone hack
   assert_equals = assertEquals;
+} else {
+    throw "No assertEquals() equivalent found.";
 }
 
 function testLimit(name, min, limit, gen) {
@@ -100,7 +102,8 @@ testLimit("data segments", 1, kJSEmbeddingMaxDataSegments, (builder, count) => {
         }
     });
 
-testLimit("memory pages", 1, kJSEmbeddingMaxMemoryPages, (builder, count) => {
+// TODO(titzer): some engines (e.g. V8) have a lower limit on max memory pages.
+DISABLED.testLimit("memory pages", 1, kJSEmbeddingMaxMemoryPages, (builder, count) => {
         builder.addMemory(count, count, false, false);
     });
 
@@ -129,6 +132,13 @@ testLimit("function params", 1, kJSEmbeddingMaxFunctionParams, (builder, count)
         let type = builder.addType({params: array, results: []});
     });
 
+testLimit("function params+locals", 1, kJSEmbeddingMaxFunctionLocals - 2, (builder, count) => {
+        let type = builder.addType(kSig_i_ii);
+        builder.addFunction(undefined, type)
+          .addLocals({i32_count: count})
+          .addBody([kExprUnreachable]);
+    });
+
 testLimit("function returns", 0, kJSEmbeddingMaxFunctionReturns, (builder, count) => {
         let array = new Array(count);
         for (let i = 0; i < count; i++) array[i] = kWasmI32;

From 510de767605f2a47d9af4780bf47d7f0e898a5f1 Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <titzer@google.com>
Date: Fri, 18 May 2018 15:28:28 +0200
Subject: [PATCH 299/329] Update limits test and harness

---
 test/harness/wasm-module-builder.js |  11 +-
 test/js-api/limits.js               | 156 +++++++++++++++++++++++-----
 2 files changed, 138 insertions(+), 29 deletions(-)

diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index 60ae8745a..5c7ea5693 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -376,9 +376,11 @@ class WasmModuleBuilder {
       binary.emit_section(kTableSectionCode, section => {
         section.emit_u8(1);  // one table entry
         section.emit_u8(kWasmAnyFunctionTypeForm);
-        section.emit_u8(1);
+        const max = wasm.function_table_length_max;
+        const has_max = max !== undefined;
+        section.emit_u8(has_max ? kResizableMaximumFlag : 0);
         section.emit_u32v(wasm.function_table_length_min);
-        section.emit_u32v(wasm.function_table_length_max);
+        if (has_max) section.emit_u32v(max);
       });
     }
 
@@ -387,10 +389,11 @@ class WasmModuleBuilder {
       if (debug) print("emitting memory @ " + binary.length);
       binary.emit_section(kMemorySectionCode, section => {
         section.emit_u8(1);  // one memory entry
-        const has_max = wasm.memory.max !== undefined;
+        const max = wasm.memory.max;
+        const has_max = max !== undefined;
         section.emit_u32v(has_max ? kResizableMaximumFlag : 0);
         section.emit_u32v(wasm.memory.min);
-        if (has_max) section.emit_u32v(wasm.memory.max);
+        if (has_max) section.emit_u32v(max);
       });
     }
 
diff --git a/test/js-api/limits.js b/test/js-api/limits.js
index 92ad11522..09a1681c3 100644
--- a/test/js-api/limits.js
+++ b/test/js-api/limits.js
@@ -21,7 +21,7 @@ let kJSEmbeddingMaxExports = 100000;
 let kJSEmbeddingMaxGlobals = 1000000;
 let kJSEmbeddingMaxDataSegments = 100000;
 
-let kJSEmbeddingMaxMemoryPages = 32767;  // ~ 2 GiB
+let kJSEmbeddingMaxMemoryPages = 65536;
 let kJSEmbeddingMaxModuleSize = 1024 * 1024 * 1024;  // = 1 GiB
 let kJSEmbeddingMaxFunctionSize = 7654321;
 let kJSEmbeddingMaxFunctionLocals = 50000;
@@ -32,26 +32,104 @@ let kJSEmbeddingMaxTableEntries = 10000000;
 let kJSEmbeddingMaxTables = 1;
 let kJSEmbeddingMaxMemories = 1;
 
-if (typeof(assert_equals) != "function" && typeof(assertEquals) == "function") {
-  // TODO(titzer): local standalone hack
-  assert_equals = assertEquals;
-} else {
-    throw "No assertEquals() equivalent found.";
+function verbose(...args) {
+  if (false) print(...args);
 }
 
+//=======================================================================
+// HARNESS SNIPPET, DO NOT COMMIT
+//=======================================================================
+const known_failures = {
+  // Enter failing tests like follows:
+  // "'WebAssembly.Instance.prototype.exports' accessor property":
+  //  'https://bugs.chromium.org/p/v8/issues/detail?id=5507',
+};
+
+let failures = [];
+let unexpected_successes = [];
+
+function test(func, description) {
+  let maybeErr;
+  try { func(); }
+  catch(e) { maybeErr = e; }
+  if (typeof maybeErr !== 'undefined') {
+    var known = "";
+    if (known_failures[description]) {
+      known = " (known)";
+    }
+    print(`${description}: FAIL${known}. ${maybeErr}`);
+    failures.push(description);
+  } else {
+    if (known_failures[description]) {
+      unexpected_successes.push(description);
+    }
+    print(`${description}: PASS.`);
+  }
+}
+//=======================================================================
+
 function testLimit(name, min, limit, gen) {
-    print("test max " + name + " = " + limit);
-    function run(count) {
-        var expected = (count <= limit) ? "(expect ok)  " : "(expect fail)";
-        print("  " + expected + " " + count + "...");
-        // TODO(titzer): the builder is pretty inefficient for large modules; do manually?
-        let builder = new WasmModuleBuilder();
-        gen(builder, count);
-        return WebAssembly.validate(builder.toBuffer());
+  print(`==== Test ${name} limit = ${limit} ====`);
+  function run_validate(count) {
+    let expected = count <= limit;
+    verbose(`  ${expected ? "(expect ok)  " : "(expect fail)"} = ${count}...`);
+
+    // TODO(titzer): builder is slow for large modules; make manual?
+    let builder = new WasmModuleBuilder();
+    gen(builder, count);
+    let result = WebAssembly.validate(builder.toBuffer());
+    
+    if (result != expected) {
+      let msg = `UNEXPECTED ${expected ? "FAIL" : "PASS"}: ${name} == ${count}`;
+      verbose(`=====> UNEXPECTED ${msg}`);
+      throw new Error(msg);
+    }
+  }
+
+  function run_compile(count) {
+    let expected = count <= limit;
+    verbose(`  ${expected ? "(expect ok)  " : "(expect fail)"} = ${count}...`);
+
+    // TODO(titzer): builder is slow for large modules; make manual?
+    let builder = new WasmModuleBuilder();
+    gen(builder, count);
+    try {
+      let result = new WebAssembly.Module(builder.toBuffer());
+    } catch (e) {
+      if (expected) {
+        let msg = `UNEXPECTED FAIL: ${name} == ${count} (${e})`;
+        verbose(`=====> UNEXPECTED ${msg}`);
+        throw new Error(msg);
+      }
+      return;
+    }
+    if (!expected) {
+      let msg = `UNEXPECTED PASS: ${name} == ${count}`;
+      verbose(`=====> UNEXPECTED ${msg}`);
+      throw new Error(msg);
     }
-    assert_equals(true, run(min));
-    assert_equals(true, run(limit));
-    assert_equals(false, run(limit+1));
+  }
+  
+  test(() => {
+    run_validate(min);
+  }, `Validate ${name} mininum`);
+  test(() => {
+    run_validate(limit);
+  }, `Validate ${name} limit`);
+  test(() => {
+    run_validate(limit+1);
+  }, `Validate ${name} over limit`);
+
+  test(() => {
+    run_compile(min);
+  }, `Compile ${name} mininum`);
+  test(() => {
+    run_compile(limit);
+  }, `Compile ${name} limit`);
+  test(() => {
+    run_compile(limit+1);
+  }, `Compile ${name} over limit`);
+  
 }
 
 // A little doodad to disable a test easily
@@ -102,14 +180,30 @@ testLimit("data segments", 1, kJSEmbeddingMaxDataSegments, (builder, count) => {
         }
     });
 
-// TODO(titzer): some engines (e.g. V8) have a lower limit on max memory pages.
-DISABLED.testLimit("memory pages", 1, kJSEmbeddingMaxMemoryPages, (builder, count) => {
-        builder.addMemory(count, count, false, false);
-    });
+testLimit("initial declared memory pages", 1, kJSEmbeddingMaxMemoryPages,
+          (builder, count) => {
+            builder.addMemory(count, undefined, false, false);
+          });
+
+testLimit("maximum declared memory pages", 1, kJSEmbeddingMaxMemoryPages,
+          (builder, count) => {
+            builder.addMemory(1, count, false, false);
+          });
+
+testLimit("initial imported memory pages", 1, kJSEmbeddingMaxMemoryPages,
+          (builder, count) => {
+            builder.addImportedMemory("mod", "mem", count, undefined);
+          });
+
+testLimit("maximum imported memory pages", 1, kJSEmbeddingMaxMemoryPages,
+          (builder, count) => {
+            builder.addImportedMemory("mod", "mem", 1, count);
+          });
 
 // TODO(titzer): ugh, that's hard to test.
-DISABLED.testLimit("module size", 1, kJSEmbeddingMaxModuleSize, (builder, count) => {
-    });
+DISABLED.testLimit("module size", 1, kJSEmbeddingMaxModuleSize,
+                   (builder, count) => {
+                   });
 
 testLimit("function size", 2, kJSEmbeddingMaxFunctionSize, (builder, count) => {
         let type = builder.addType(kSig_v_v);
@@ -145,8 +239,12 @@ testLimit("function returns", 0, kJSEmbeddingMaxFunctionReturns, (builder, count
         let type = builder.addType({params: [], results: array});
     });
 
-testLimit("table size", 1, kJSEmbeddingMaxTableSize, (builder, count) => {
-        builder.setFunctionTableBounds(count, count);
+testLimit("initial table size", 1, kJSEmbeddingMaxTableSize, (builder, count) => {
+        builder.setFunctionTableBounds(count, undefined);
+    });
+
+testLimit("maximum table size", 1, kJSEmbeddingMaxTableSize, (builder, count) => {
+        builder.setFunctionTableBounds(1, count);
     });
 
 testLimit("table entries", 1, kJSEmbeddingMaxTableEntries, (builder, count) => {
@@ -168,3 +266,11 @@ testLimit("memories", 0, kJSEmbeddingMaxMemories, (builder, count) => {
             builder.addImportedMemory("", "", 1, 1, false);
         }
     });
+
+//=======================================================================
+// HARNESS SNIPPET, DO NOT COMMIT
+//=======================================================================
+if (failures.length > 0) {
+  throw failures[0];
+}
+//=======================================================================

From 89d87618afb1b5f972eca606937b9a3287027b45 Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <titzer@google.com>
Date: Tue, 22 May 2018 16:58:34 +0200
Subject: [PATCH 300/329] Add sync compile tests

---
 test/js-api/limits.js | 106 +++++++++++++++++++++++++++++++++---------
 1 file changed, 85 insertions(+), 21 deletions(-)

diff --git a/test/js-api/limits.js b/test/js-api/limits.js
index 09a1681c3..6ee0c56fd 100644
--- a/test/js-api/limits.js
+++ b/test/js-api/limits.js
@@ -36,6 +36,10 @@ function verbose(...args) {
   if (false) print(...args);
 }
 
+let kTestValidate = true;
+let kTestSyncCompile = true;
+let kTestAsyncCompile = true;
+
 //=======================================================================
 // HARNESS SNIPPET, DO NOT COMMIT
 //=======================================================================
@@ -48,6 +52,8 @@ const known_failures = {
 let failures = [];
 let unexpected_successes = [];
 
+let last_promise = new Promise((resolve, reject) => { resolve(); });
+
 function test(func, description) {
   let maybeErr;
   try { func(); }
@@ -66,6 +72,24 @@ function test(func, description) {
     print(`${description}: PASS.`);
   }
 }
+
+function promise_test(func, description) {
+  last_promise = last_promise.then(func)
+  .then(_ => {
+    if (known_failures[description]) {
+      unexpected_successes.push(description);
+    }
+    print(`${description}: PASS.`);
+  })
+  .catch(err => {
+    var known = "";
+    if (known_failures[description]) {
+      known = " (known)";
+    }
+    print(`${description}: FAIL${known}. ${err}`);
+    failures.push(description);
+  });
+}
 //=======================================================================
 
 function testLimit(name, min, limit, gen) {
@@ -109,27 +133,67 @@ function testLimit(name, min, limit, gen) {
       throw new Error(msg);
     }
   }
-  
-  test(() => {
-    run_validate(min);
-  }, `Validate ${name} mininum`);
-  test(() => {
-    run_validate(limit);
-  }, `Validate ${name} limit`);
-  test(() => {
-    run_validate(limit+1);
-  }, `Validate ${name} over limit`);
-
-  test(() => {
-    run_compile(min);
-  }, `Compile ${name} mininum`);
-  test(() => {
-    run_compile(limit);
-  }, `Compile ${name} limit`);
-  test(() => {
-    run_compile(limit+1);
-  }, `Compile ${name} over limit`);
-  
+
+  function run_async_compile(count) {
+    let expected = count <= limit;
+    verbose(`  ${expected ? "(expect ok)  " : "(expect fail)"} = ${count}...`);
+
+    // TODO(titzer): builder is slow for large modules; make manual?
+    let builder = new WasmModuleBuilder();
+    gen(builder, count);
+    let buffer = builder.toBuffer();
+    WebAssembly.compile(buffer)
+      .then(result => {
+        if (!expected) {
+          let msg = `UNEXPECTED PASS: ${name} == ${count}`;
+          verbose(`=====> UNEXPECTED ${msg}`);
+          throw new Error(msg);
+        }
+      })
+      .catch(err => {
+        if (expected) {
+          let msg = `UNEXPECTED FAIL: ${name} == ${count} (${e})`;
+          verbose(`=====> UNEXPECTED ${msg}`);
+          throw new Error(msg);
+        }
+      })
+  }
+
+  if (kTestValidate) {
+    test(() => {
+      run_validate(min);
+    }, `Validate ${name} mininum`);
+    test(() => {
+      run_validate(limit);
+    }, `Validate ${name} limit`);
+    test(() => {
+      run_validate(limit+1);
+    }, `Validate ${name} over limit`);
+  }
+
+  if (kTestSyncCompile) {
+    test(() => {
+      run_compile(min);
+    }, `Compile ${name} mininum`);
+    test(() => {
+      run_compile(limit);
+    }, `Compile ${name} limit`);
+    test(() => {
+      run_compile(limit+1);
+    }, `Compile ${name} over limit`);
+  }
+
+  if (kTestAsyncCompile) {
+    promise_test(() => {
+      run_async_compile(min);
+    }, `Async compile ${name} mininum`);
+    promise_test(() => {
+      run_async_compile(limit);
+    }, `Async compile ${name} limit`);
+    promise_test(() => {
+      run_async_compile(limit+1);
+    }, `Async compile ${name} over limit`);
+  }
 }
 
 // A little doodad to disable a test easily

From 2622ca2ad79e6e83d3a900fbf116a8e11ed923ee Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <titzer@google.com>
Date: Tue, 22 May 2018 17:12:39 +0200
Subject: [PATCH 301/329] Mention that parameters are included in the local
 computation

---
 document/js-api/index.bs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index dd402dd26..0ffe0d0d6 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -1014,6 +1014,6 @@ Modules that exceed these limits are invalid and are rejected with a {{CompileEr
 <li>The maximum number of parameters to any function is 1000.</li>
 <li>The maximum number of return types for any function is 1.</li>
 <li>The maximum size of a function body, including locals declarations, is 7654321 bytes.</li>
-<li>The maximum number of locals declared in a function is 50000.</li>
+<li>The maximum number of locals declared in a function, including implicitly declared as parameters, is 50000.</li>
 
 </ul>

From ea7886320f7a82b302c965089eadbc8f97e78a07 Mon Sep 17 00:00:00 2001
From: "Ben L. Titzer" <titzer@google.com>
Date: Mon, 24 Sep 2018 14:26:52 +0200
Subject: [PATCH 302/329] Address first review comments

---
 document/js-api/index.bs |  7 ++++---
 test/build.py            |  2 +-
 test/js-api/limits.js    | 16 +++++-----------
 3 files changed, 10 insertions(+), 15 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 0ffe0d0d6..4c8294ceb 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -993,8 +993,9 @@ Note: ECMAScript doesn't specify any sort of behavior on out-of-memory condition
 <h2 id="limits">Implementation-defined Limits</h2>
 
 The WebAssembly core specification allows an implementation to define limits on the syntactic structure of the module.
-The standard WebAssembly JavaScript Interface described in this document hereby defines a set of standard limits on the syntactic module structure as below.
-Modules that exceed these limits are invalid and are rejected with a {{CompileError}}.
+While each embedding of WebAssembly may choose to define its own limits, for predictability the standard WebAssembly JavaScript Interface described in this document defines the following exact limits.
+An implementation must reject a module that exceeds these limits with a {{CompileError}}.
+In practice, an implementation may run out of resources for valid modules below these limits.
 
 <ul>
 <li>The maximum size of a module is 1073741824 bytes (1 GiB).</li>
@@ -1012,7 +1013,7 @@ Modules that exceed these limits are invalid and are rejected with a {{CompileEr
 <li>The initial or maximum number of pages for any memory, declared or imported, is at most 32767.</li>
 
 <li>The maximum number of parameters to any function is 1000.</li>
-<li>The maximum number of return types for any function is 1.</li>
+<li>The maximum number of return values for any function is 1.</li>
 <li>The maximum size of a function body, including locals declarations, is 7654321 bytes.</li>
 <li>The maximum number of locals declared in a function, including implicitly declared as parameters, is 50000.</li>
 
diff --git a/test/build.py b/test/build.py
index 4d8557fc5..a6304d0a1 100755
--- a/test/build.py
+++ b/test/build.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 import argparse
 import sys
diff --git a/test/js-api/limits.js b/test/js-api/limits.js
index 6ee0c56fd..0dc2b44c7 100644
--- a/test/js-api/limits.js
+++ b/test/js-api/limits.js
@@ -28,7 +28,7 @@ let kJSEmbeddingMaxFunctionLocals = 50000;
 let kJSEmbeddingMaxFunctionParams = 1000;
 let kJSEmbeddingMaxFunctionReturns = 1;
 let kJSEmbeddingMaxTableSize = 10000000;
-let kJSEmbeddingMaxTableEntries = 10000000;
+let kJSEmbeddingMaxElementSegments = 10000000;
 let kJSEmbeddingMaxTables = 1;
 let kJSEmbeddingMaxMemories = 1;
 
@@ -92,6 +92,9 @@ function promise_test(func, description) {
 }
 //=======================================================================
 
+// This function runs the {gen} function with the values {min}, {limit}, and
+// {limit+1}, assuming that values below and including the limit should
+// pass. {name} is used for debugging output.
 function testLimit(name, min, limit, gen) {
   print(`==== Test ${name} limit = ${limit} ====`);
   function run_validate(count) {
@@ -196,10 +199,6 @@ function testLimit(name, min, limit, gen) {
   }
 }
 
-// A little doodad to disable a test easily
-let DISABLED = {testLimit: () => 0};
-let X = DISABLED;
-
 testLimit("types", 1, kJSEmbeddingMaxTypes, (builder, count) => {
         for (let i = 0; i < count; i++) {
             builder.addType(kSig_i_i);
@@ -264,11 +263,6 @@ testLimit("maximum imported memory pages", 1, kJSEmbeddingMaxMemoryPages,
             builder.addImportedMemory("mod", "mem", 1, count);
           });
 
-// TODO(titzer): ugh, that's hard to test.
-DISABLED.testLimit("module size", 1, kJSEmbeddingMaxModuleSize,
-                   (builder, count) => {
-                   });
-
 testLimit("function size", 2, kJSEmbeddingMaxFunctionSize, (builder, count) => {
         let type = builder.addType(kSig_v_v);
         let nops = count-2;
@@ -311,7 +305,7 @@ testLimit("maximum table size", 1, kJSEmbeddingMaxTableSize, (builder, count) =>
         builder.setFunctionTableBounds(1, count);
     });
 
-testLimit("table entries", 1, kJSEmbeddingMaxTableEntries, (builder, count) => {
+testLimit("element segments", 1, kJSEmbeddingMaxElementSegments, (builder, count) => {
         builder.setFunctionTableBounds(1, 1);
         let array = [];
         for (let i = 0; i < count; i++) {

From 9af41ee4d04f644c62739122970c78faad3aa4b9 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Thu, 11 Oct 2018 09:44:25 -0700
Subject: [PATCH 303/329] Use "Element Segment" terminology in js-api tests
 (#874)

This matches the nomenclature of the spec.

Also:

* Remove the `function_table` array from `wasm-module-builder.js` which
  is not used.
* The `appendToTable` function should reference
  `function_table_length` instead of `function_table.length`.
* Synchronize wasm-module-builder.js with v8's version
---
 test/harness/wasm-constants.js      |   2 +-
 test/harness/wasm-module-builder.js | 102 +++++++++++++++++-----------
 test/js-api/jsapi.js                |   3 +-
 test/js-api/limits.js               |   8 +--
 4 files changed, 68 insertions(+), 47 deletions(-)

diff --git a/test/harness/wasm-constants.js b/test/harness/wasm-constants.js
index 486ce31d1..18748e6cf 100644
--- a/test/harness/wasm-constants.js
+++ b/test/harness/wasm-constants.js
@@ -73,7 +73,7 @@ let kLocalNamesCode = 2;
 let kWasmFunctionTypeForm = 0x60;
 let kWasmAnyFunctionTypeForm = 0x70;
 
-let kResizableMaximumFlag = 1;
+let kHasMaximumFlag = 1;
 
 // Function declaration flags
 let kDeclFunctionName   = 0x01;
diff --git a/test/harness/wasm-module-builder.js b/test/harness/wasm-module-builder.js
index 5c7ea5693..c01b71733 100644
--- a/test/harness/wasm-module-builder.js
+++ b/test/harness/wasm-module-builder.js
@@ -123,9 +123,25 @@ class WasmFunctionBuilder {
     return this;
   }
 
+  getNumLocals() {
+    let total_locals = 0;
+    for (let l of this.locals || []) {
+      for (let type of ["i32", "i64", "f32", "f64"]) {
+        total_locals += l[type + "_count"] || 0;
+      }
+    }
+    return total_locals;
+  }
+
   addLocals(locals, names) {
-    this.locals = locals;
-    this.local_names = names;
+    const old_num_locals = this.getNumLocals();
+    if (!this.locals) this.locals = []
+    this.locals.push(locals);
+    if (names) {
+      if (!this.local_names) this.local_names = [];
+      const missing_names = old_num_locals - this.local_names.length;
+      this.local_names.push(...new Array(missing_names), ...names);
+    }
     return this;
   }
 
@@ -156,10 +172,10 @@ class WasmModuleBuilder {
     this.exports = [];
     this.globals = [];
     this.functions = [];
-    this.function_table = [];
-    this.function_table_length = 0;
-    this.function_table_inits = [];
-    this.segments = [];
+    this.table_length_min = 0;
+    this.table_length_max = undefined;
+    this.element_segments = [];
+    this.data_segments = [];
     this.explicit = [];
     this.num_imported_funcs = 0;
     this.num_imported_globals = 0;
@@ -219,6 +235,9 @@ class WasmModuleBuilder {
   }
 
   addImport(module = "", name, type) {
+    if (this.functions.length != 0) {
+      throw new Error('Imported functions must be declared before local ones');
+    }
     let type_index = (typeof type) == "number" ? type : this.addType(type);
     this.imports.push({module: module, name: name, kind: kExternalFunction,
                        type: type_index});
@@ -226,8 +245,11 @@ class WasmModuleBuilder {
   }
 
   addImportedGlobal(module = "", name, type, mutable = false) {
+    if (this.globals.length != 0) {
+      throw new Error('Imported globals must be declared before local ones');
+    }
     let o = {module: module, name: name, kind: kExternalGlobal, type: type,
-             mutable: mutable}
+             mutable: mutable};
     this.imports.push(o);
     return this.num_imported_globals++;
   }
@@ -256,21 +278,24 @@ class WasmModuleBuilder {
   }
 
   addDataSegment(addr, data, is_global = false) {
-    this.segments.push({addr: addr, data: data, is_global: is_global});
-    return this.segments.length - 1;
+    this.data_segments.push({addr: addr, data: data, is_global: is_global});
+    return this.data_segments.length - 1;
   }
 
   exportMemoryAs(name) {
     this.exports.push({name: name, kind: kExternalMemory, index: 0});
   }
 
-  addFunctionTableInit(base, is_global, array, is_import = false) {
-    this.function_table_inits.push({base: base, is_global: is_global,
+  addElementSegment(base, is_global, array, is_import = false) {
+    this.element_segments.push({base: base, is_global: is_global,
                                     array: array});
     if (!is_global) {
       var length = base + array.length;
-      if (length > this.function_table_length && !is_import) {
-        this.function_table_length = length;
+      if (length > this.table_length_min && !is_import) {
+        this.table_length_min = length;
+      }
+      if (length > this.table_length_max && !is_import) {
+         this.table_length_max = length;
       }
     }
     return this;
@@ -281,18 +306,18 @@ class WasmModuleBuilder {
       if (typeof n != 'number')
         throw new Error('invalid table (entries have to be numbers): ' + array);
     }
-    return this.addFunctionTableInit(this.function_table.length, false, array);
+    return this.addElementSegment(this.table_length_min, false, array);
   }
 
-  setFunctionTableBounds(min, max) {
-    this.function_table_length_min = min;
-    this.function_table_length_max = max;
+  setTableBounds(min, max) {
+    this.table_length_min = min;
+    this.table_length_max = max;
     return this;
   }
 
-  setFunctionTableLength(length) {
-    this.function_table_length_min = length;
-    this.function_table_length_max = length;
+  setTableLength(length) {
+    this.table_length_min = length;
+    this.table_length_max = length;
     return this;
   }
 
@@ -370,16 +395,16 @@ class WasmModuleBuilder {
       });
     }
 
-    // Add function_table.
-    if (wasm.function_table_length_min > 0) {
+    // Add table section
+    if (wasm.table_length_min > 0) {
       if (debug) print("emitting table @ " + binary.length);
       binary.emit_section(kTableSectionCode, section => {
         section.emit_u8(1);  // one table entry
         section.emit_u8(kWasmAnyFunctionTypeForm);
-        const max = wasm.function_table_length_max;
+        const max = wasm.table_length_max;
         const has_max = max !== undefined;
-        section.emit_u8(has_max ? kResizableMaximumFlag : 0);
-        section.emit_u32v(wasm.function_table_length_min);
+        section.emit_u8(has_max ? kHasMaximumFlag : 0);
+        section.emit_u32v(wasm.table_length_min);
         if (has_max) section.emit_u32v(max);
       });
     }
@@ -389,11 +414,10 @@ class WasmModuleBuilder {
       if (debug) print("emitting memory @ " + binary.length);
       binary.emit_section(kMemorySectionCode, section => {
         section.emit_u8(1);  // one memory entry
-        const max = wasm.memory.max;
-        const has_max = max !== undefined;
-        section.emit_u32v(has_max ? kResizableMaximumFlag : 0);
+        const has_max = wasm.memory.max !== undefined;
+        section.emit_u8(has_max ? kHasMaximumFlag : 0);
         section.emit_u32v(wasm.memory.min);
-        if (has_max) section.emit_u32v(max);
+        if (has_max) section.emit_u32v(wasm.memory.max);
       });
     }
 
@@ -475,11 +499,11 @@ class WasmModuleBuilder {
       });
     }
 
-    // Add table elements.
-    if (wasm.function_table_inits.length > 0) {
-      if (debug) print("emitting table @ " + binary.length);
+    // Add element segments
+    if (wasm.element_segments.length > 0) {
+      if (debug) print("emitting element segments @ " + binary.length);
       binary.emit_section(kElementSectionCode, section => {
-        var inits = wasm.function_table_inits;
+        var inits = wasm.element_segments;
         section.emit_u32v(inits.length);
 
         for (let init of inits) {
@@ -508,9 +532,7 @@ class WasmModuleBuilder {
         for (let func of wasm.functions) {
           // Function body length will be patched later.
           let local_decls = [];
-          let l = func.locals;
-          if (l !== undefined) {
-            let local_decls_count = 0;
+          for (let l of func.locals || []) {
             if (l.i32_count > 0) {
               local_decls.push({count: l.i32_count, type: kWasmI32});
             }
@@ -540,11 +562,11 @@ class WasmModuleBuilder {
     }
 
     // Add data segments.
-    if (wasm.segments.length > 0) {
+    if (wasm.data_segments.length > 0) {
       if (debug) print("emitting data segments @ " + binary.length);
       binary.emit_section(kDataSectionCode, section => {
-        section.emit_u32v(wasm.segments.length);
-        for (let seg of wasm.segments) {
+        section.emit_u32v(wasm.data_segments.length);
+        for (let seg of wasm.data_segments) {
           section.emit_u8(0);  // linear memory index 0
           if (seg.is_global) {
             // initializer is a global variable
@@ -638,7 +660,7 @@ class WasmModuleBuilder {
   }
 
   asyncInstantiate(ffi) {
-    return WebAssembly.instantiate(this.Buffer(), ffi)
+    return WebAssembly.instantiate(this.toBuffer(), ffi)
         .then(({module, instance}) => instance);
   }
 
diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
index 4469ed135..30a7e606c 100644
--- a/test/js-api/jsapi.js
+++ b/test/js-api/jsapi.js
@@ -66,7 +66,7 @@ const complexExportingModuleBinary = (() => {
     builder.addMemory(1, 1, /* exported */ false);
     builder.exportMemoryAs('b');
 
-    builder.setFunctionTableLength(1);
+    builder.setTableLength(1);
     builder.addExportOfKind('c', kExternalTable, 0);
 
     // Default init for global values is 0. Keep that.
@@ -1111,7 +1111,6 @@ const complexTableReExportingModuleBinary = (() => {
             46
         ]).index;
 
-    builder.setFunctionTableLength(3);
     builder.appendToTable([fIndex, gIndex, hIndex]);
     builder.addExportOfKind('tab', kExternalTable, 0);
 
diff --git a/test/js-api/limits.js b/test/js-api/limits.js
index 0dc2b44c7..c1c578ee7 100644
--- a/test/js-api/limits.js
+++ b/test/js-api/limits.js
@@ -298,18 +298,18 @@ testLimit("function returns", 0, kJSEmbeddingMaxFunctionReturns, (builder, count
     });
 
 testLimit("initial table size", 1, kJSEmbeddingMaxTableSize, (builder, count) => {
-        builder.setFunctionTableBounds(count, undefined);
+        builder.setTableBounds(count, undefined);
     });
 
 testLimit("maximum table size", 1, kJSEmbeddingMaxTableSize, (builder, count) => {
-        builder.setFunctionTableBounds(1, count);
+        builder.setTableBounds(1, count);
     });
 
 testLimit("element segments", 1, kJSEmbeddingMaxElementSegments, (builder, count) => {
-        builder.setFunctionTableBounds(1, 1);
+        builder.setTableBounds(1, 1);
         let array = [];
         for (let i = 0; i < count; i++) {
-            builder.addFunctionTableInit(0, false, array, false);
+            builder.addElementSegment(0, false, array, false);
         }
     });
 

From 423c6f87267daf65d62f5ef709307aa4ab47f0f7 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Thu, 11 Oct 2018 14:23:41 +0200
Subject: [PATCH 304/329] [js-api] Introduce a 'create a memory buffer'
 algorithm.

In particular, this ensures that the [[ArrayBufferDetachKey]] slot is always set (fixes #855).
---
 document/js-api/index.bs | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 4c8294ceb..2cc5a89ac 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -555,15 +555,22 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     * \[[BufferObject]] : an {{ArrayBuffer}} whose [=Data Block=] is [=identified with=] the above memory address
 </div>
 
+<div algorithm>
+    To <dfn>create a memory buffer</dfn> from a [=memory address=] |memaddr|, perform the following steps:
+
+    1. Let |block| be a [=Data Block=] which is [=identified with=] the underlying memory of |memaddr|.
+    1. Let |buffer| be a new {{ArrayBuffer}} whose \[[ArrayBufferData]] is |block| and \[[ArrayBufferByteLength]] is set to the length of |block|.
+    1. Set |buffer|.\[[ArrayBufferDetachKey]] to "WebAssembly.Memory".
+    1. Return |buffer|.
+</div>
+
 <div algorithm>
     To <dfn>create a memory object</dfn> from a [=memory address=] |memaddr|, perform the following steps:
 
     1. Let |map| be the [=surrounding agent=]'s associated [=Memory object cache=].
     1. If |map|[|memaddr|] [=map/exists=],
         1. Return |map|[|memaddr|].
-    1. Let |block| be a Data Block which is [=identified with=] the underlying memory of |memaddr|
-    1. Let |buffer| be a new {{ArrayBuffer}} whose \[[ArrayBufferData]] is |block| and \[[ArrayBufferByteLength]] is set to the length of |block|.
-    1. Set |buffer|.\[[ArrayBufferDetachKey]] to "WebAssembly.Memory".
+    1. Let |buffer| be a the result of [=create a memory buffer|creating a memory buffer=] from |memaddr|.
     1. Let |memory| be a new {{Memory}} instance with \[[Memory]] set to |memaddr| and \[[BufferObject]] set to |buffer|.
     1. [=map/Set=] |map|[|memaddr|] to |memory|.
     1. Return |memory|.
@@ -588,8 +595,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Assert: |map|[|memaddr|] [=map/exists=]
     1. Let |memory| be |map|[|memaddr|].
     1. Perform ! [=DetachArrayBuffer=](|memory|.\[[BufferObject]], "WebAssembly.Memory").
-    1. Let |block| be a [=Data Block=] which is [=identified with=] the underlying memory of |memaddr|.
-    1. Let |buffer| be a new {{ArrayBuffer}} whose \[[ArrayBufferData]] is |block| and \[[ArrayBufferByteLength]] is set to the length of |block|.
+    1. Let |buffer| be a the result of [=create a memory buffer|creating a memory buffer=] from |memaddr|.
     1. Set |memory|.\[[BufferObject]] to |buffer|.
 </div>
 

From cf67a477d2d802329640ef4e6461e4c180d8f910 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@gmail.com>
Date: Tue, 16 Oct 2018 23:49:30 +0200
Subject: [PATCH 305/329] Import jsapi tests from WPT. (#883)

* Import jsapi tests from WPT.

* Add LICENSE file to ensure compatibility with WPT.

* Improve bad-imports.js.

Add documentation and use the correct argument in one set of tests.

* Support subdirectories of test/js-api in build.py.
---
 test/build.py                                 |    8 +-
 test/js-api/LICENSE.md                        |   33 +
 test/js-api/assertions.js                     |   73 +
 test/js-api/bad-imports.js                    |  152 +++
 test/js-api/constructor/compile.any.js        |   81 ++
 .../instantiate-bad-imports.any.js            |   23 +
 test/js-api/constructor/instantiate.any.js    |  111 ++
 test/js-api/constructor/validate.any.js       |  100 ++
 test/js-api/global/constructor.any.js         |  127 ++
 test/js-api/global/toString.any.js            |    7 +
 test/js-api/global/value-get-set.any.js       |  111 ++
 test/js-api/global/valueOf.any.js             |   28 +
 .../instance/constructor-bad-imports.any.js   |   14 +
 test/js-api/instance/constructor.any.js       |   55 +
 test/js-api/instance/exports.any.js           |   67 +
 test/js-api/instance/toString.any.js          |   10 +
 test/js-api/instanceTestFactory.js            |  229 ++++
 test/js-api/interface.any.js                  |  160 +++
 test/js-api/jsapi.js                          | 1183 -----------------
 test/js-api/memory/buffer.any.js              |   64 +
 test/js-api/memory/constructor.any.js         |  147 ++
 test/js-api/memory/grow.any.js                |  185 +++
 test/js-api/memory/toString.any.js            |    7 +
 test/js-api/module/constructor.any.js         |   65 +
 test/js-api/module/customSections.any.js      |  167 +++
 test/js-api/module/exports.any.js             |  136 ++
 test/js-api/module/imports.any.js             |  126 ++
 test/js-api/module/toString.any.js            |    9 +
 test/js-api/table/assertions.js               |   13 +
 test/js-api/table/constructor.any.js          |  179 +++
 test/js-api/table/get-set.any.js              |  230 ++++
 test/js-api/table/grow.any.js                 |   96 ++
 test/js-api/table/length.any.js               |   60 +
 test/js-api/table/toString.any.js             |    7 +
 test/js-api/wasm-constants.js                 |  374 ++++++
 test/js-api/wasm-module-builder.js            |  555 ++++++++
 36 files changed, 3807 insertions(+), 1185 deletions(-)
 create mode 100644 test/js-api/LICENSE.md
 create mode 100644 test/js-api/assertions.js
 create mode 100644 test/js-api/bad-imports.js
 create mode 100644 test/js-api/constructor/compile.any.js
 create mode 100644 test/js-api/constructor/instantiate-bad-imports.any.js
 create mode 100644 test/js-api/constructor/instantiate.any.js
 create mode 100644 test/js-api/constructor/validate.any.js
 create mode 100644 test/js-api/global/constructor.any.js
 create mode 100644 test/js-api/global/toString.any.js
 create mode 100644 test/js-api/global/value-get-set.any.js
 create mode 100644 test/js-api/global/valueOf.any.js
 create mode 100644 test/js-api/instance/constructor-bad-imports.any.js
 create mode 100644 test/js-api/instance/constructor.any.js
 create mode 100644 test/js-api/instance/exports.any.js
 create mode 100644 test/js-api/instance/toString.any.js
 create mode 100644 test/js-api/instanceTestFactory.js
 create mode 100644 test/js-api/interface.any.js
 delete mode 100644 test/js-api/jsapi.js
 create mode 100644 test/js-api/memory/buffer.any.js
 create mode 100644 test/js-api/memory/constructor.any.js
 create mode 100644 test/js-api/memory/grow.any.js
 create mode 100644 test/js-api/memory/toString.any.js
 create mode 100644 test/js-api/module/constructor.any.js
 create mode 100644 test/js-api/module/customSections.any.js
 create mode 100644 test/js-api/module/exports.any.js
 create mode 100644 test/js-api/module/imports.any.js
 create mode 100644 test/js-api/module/toString.any.js
 create mode 100644 test/js-api/table/assertions.js
 create mode 100644 test/js-api/table/constructor.any.js
 create mode 100644 test/js-api/table/get-set.any.js
 create mode 100644 test/js-api/table/grow.any.js
 create mode 100644 test/js-api/table/length.any.js
 create mode 100644 test/js-api/table/toString.any.js
 create mode 100644 test/js-api/wasm-constants.js
 create mode 100644 test/js-api/wasm-module-builder.js

diff --git a/test/build.py b/test/build.py
index a6304d0a1..e9fc3b3d7 100755
--- a/test/build.py
+++ b/test/build.py
@@ -83,8 +83,12 @@ def build_js(out_js_dir, include_harness=False):
     convert_wast_to_js(out_js_dir)
 
     print('Copying JS tests to the JS out dir...')
-    for js_file in glob.glob(os.path.join(JS_TESTS_DIR, '*.js')):
-        shutil.copy(js_file, out_js_dir)
+    for path in os.listdir(JS_TESTS_DIR):
+        abspath = os.path.join(JS_TESTS_DIR, js_file)
+        if os.path.isdir(abspath):
+            shutil.copytree(abspath, os.path.join(out_js_dir, path))
+        else:
+            shutil.copy(abspath, out_js_dir)
 
     harness_dir = os.path.join(out_js_dir, 'harness')
     ensure_empty_dir(harness_dir)
diff --git a/test/js-api/LICENSE.md b/test/js-api/LICENSE.md
new file mode 100644
index 000000000..6b346a528
--- /dev/null
+++ b/test/js-api/LICENSE.md
@@ -0,0 +1,33 @@
+# Dual-License for W3C Test Suites
+
+All documents in this Repository are licensed by contributors to be distributed under both the [W3C Test Suite License](#w3c-test-suite-license) and the [W3C 3-clause BSD License](#w3c-3-clause-bsd-license), reproduced below. The choice of license is up to the licensee. For more information, see [Licenses for W3C Test Suites](https://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html)
+
+# W3C Test Suite License
+
+This document, Test Suites and other documents that link to this statement are provided by the copyright holders under the following license: By using and/or copying this document, or the W3C document from which this statement is linked, you (the licensee) agree that you have read, understood, and will comply with the following terms and conditions:
+
+Permission to copy, and distribute the contents of this document, or the W3C document from which this statement is linked, in any medium for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the document, or portions thereof, that you use:
+
+*    A link or URL to the original W3C document.
+*    The pre-existing copyright notice of the original author, or if it doesn't exist, a notice (hypertext is preferred, but a textual representation is permitted) of the form: "Copyright © [$date-of-document] World Wide Web Consortium, (MIT, ERCIM, Keio, Beihang) and others. All Rights Reserved. http://www.w3.org/Consortium/Legal/2008/04-testsuite-copyright.html"
+*    If it exists, the STATUS of the W3C document.
+
+When space permits, inclusion of the full text of this NOTICE should be provided. We request that authorship attribution be provided in any software, documents, or other items or products that you create pursuant to the implementation of the contents of this document, or any portion thereof.
+
+No right to create modifications or derivatives of W3C documents is granted pursuant to this license. However, if additional requirements (documented in the Copyright FAQ) are satisfied, the right to create modifications or derivatives is sometimes granted by the W3C to individuals complying with those requirements.
+
+If a Test Suite distinguishes the test harness (or, framework for navigation) and the actual tests, permission is given to remove or alter the harness or navigation if the Test Suite in question allows to do so. The tests themselves shall NOT be changed in any way.
+
+The name and trademarks of W3C and other copyright holders may NOT be used in advertising or publicity pertaining to this document or other documents that link to this statement without specific, written prior permission. Title to copyright in this document will at all times remain with copyright holders. Permission is given to use the trademarked string "W3C" within claims of performance concerning W3C Specifications or features described therein, and there only, if the test suite so authorizes.
+
+THIS WORK IS PROVIDED BY W3C, MIT, ERCIM, KEIO, BEIHANG, THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL W3C, MIT, ERCIM, KEIO, BEIHANG, THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# W3C 3-clause BSD License
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+*    Redistributions of works must retain the original copyright notice, this list of conditions and the following disclaimer.
+*    Redistributions in binary form must reproduce the original copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+*    Neither the name of the W3C nor the names of its contributors may be used to endorse or promote products derived from this work without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/test/js-api/assertions.js b/test/js-api/assertions.js
new file mode 100644
index 000000000..bda3ae7bc
--- /dev/null
+++ b/test/js-api/assertions.js
@@ -0,0 +1,73 @@
+function assert_function_name(fn, name, description) {
+  const propdesc = Object.getOwnPropertyDescriptor(fn, "name");
+  assert_equals(typeof propdesc, "object", `${description} should have name property`);
+  assert_false(propdesc.writable, "writable", `${description} name should not be writable`);
+  assert_false(propdesc.enumerable, "enumerable", `${description} name should not be enumerable`);
+  assert_true(propdesc.configurable, "configurable", `${description} name should be configurable`);
+  assert_equals(propdesc.value, name, `${description} name should be ${name}`);
+}
+
+function assert_function_length(fn, length, description) {
+  const propdesc = Object.getOwnPropertyDescriptor(fn, "length");
+  assert_equals(typeof propdesc, "object", `${description} should have length property`);
+  assert_false(propdesc.writable, "writable", `${description} length should not be writable`);
+  assert_false(propdesc.enumerable, "enumerable", `${description} length should not be enumerable`);
+  assert_true(propdesc.configurable, "configurable", `${description} length should be configurable`);
+  assert_equals(propdesc.value, length, `${description} length should be ${length}`);
+}
+
+function assert_exported_function(fn, { name, length }, description) {
+  assert_equals(Object.getPrototypeOf(fn), Function.prototype,
+                `${description}: prototype`);
+
+  assert_function_name(fn, name, description);
+  assert_function_length(fn, length, description);
+}
+
+function assert_Instance(instance, expected_exports) {
+  assert_equals(Object.getPrototypeOf(instance), WebAssembly.Instance.prototype,
+                "prototype");
+  assert_true(Object.isExtensible(instance), "extensible");
+
+  assert_equals(instance.exports, instance.exports, "exports should be idempotent");
+  const exports = instance.exports;
+
+  assert_equals(Object.getPrototypeOf(exports), null, "exports prototype");
+  assert_false(Object.isExtensible(exports), "extensible exports");
+  for (const [key, expected] of Object.entries(expected_exports)) {
+    const property = Object.getOwnPropertyDescriptor(exports, key);
+    assert_equals(typeof property, "object", `${key} should be present`);
+    assert_false(property.writable, `${key}: writable`);
+    assert_true(property.enumerable, `${key}: enumerable`);
+    assert_false(property.configurable, `${key}: configurable`);
+    const actual = property.value;
+    assert_true(Object.isExtensible(actual), `${key}: extensible`);
+
+    switch (expected.kind) {
+    case "function":
+      assert_exported_function(actual, expected, `value of ${key}`);
+      break;
+    case "global":
+      assert_equals(Object.getPrototypeOf(actual), WebAssembly.Global.prototype,
+                    `value of ${key}: prototype`);
+      assert_equals(actual.value, expected.value, `value of ${key}: value`);
+      assert_equals(actual.valueOf(), expected.value, `value of ${key}: valueOf()`);
+      break;
+    case "memory":
+      assert_equals(Object.getPrototypeOf(actual), WebAssembly.Memory.prototype,
+                    `value of ${key}: prototype`);
+      assert_equals(Object.getPrototypeOf(actual.buffer), ArrayBuffer.prototype,
+                    `value of ${key}: prototype of buffer`);
+      assert_equals(actual.buffer.byteLength, 0x10000 * expected.size, `value of ${key}: size of buffer`);
+      const array = new Uint8Array(actual.buffer);
+      assert_equals(array[0], 0, `value of ${key}: first element of buffer`);
+      assert_equals(array[array.byteLength - 1], 0, `value of ${key}: last element of buffer`);
+      break;
+    case "table":
+      assert_equals(Object.getPrototypeOf(actual), WebAssembly.Table.prototype,
+                    `value of ${key}: prototype`);
+      assert_equals(actual.length, expected.length, `value of ${key}: length of table`);
+      break;
+    }
+  }
+}
diff --git a/test/js-api/bad-imports.js b/test/js-api/bad-imports.js
new file mode 100644
index 000000000..6c7d8056c
--- /dev/null
+++ b/test/js-api/bad-imports.js
@@ -0,0 +1,152 @@
+/**
+ * `t` should be a function that takes at least three arguments:
+ *
+ * - the name of the test;
+ * - the expected error (to be passed to `assert_throws` or similar);
+ * - a function that takes a `WasmModuleBuilder` and initializes it;
+ * - (optionally) an options object.
+ *
+ * The function is expected to create a test that checks if instantiating a
+ * module with the result of the `WasmModuleBuilder` and the options object
+ * (if any) yields the correct error.
+ */
+function test_bad_imports(t) {
+  for (const value of [null, true, "", Symbol(), 1, 0.1, NaN]) {
+    t(`Non-object imports argument: ${format_value(value)}`,
+      new TypeError(),
+      builder => {},
+      value);
+  }
+
+  for (const value of [undefined, null, true, "", Symbol(), 1, 0.1, NaN]) {
+    const imports = {
+      "module": value,
+    };
+    t(`Non-object module: ${format_value(value)}`,
+      new TypeError(),
+      builder => {
+        builder.addImport("module", "fn", kSig_v_v);
+      },
+      imports);
+  }
+
+  t(`Missing imports argument`,
+    new TypeError(),
+    builder => {
+      builder.addImport("module", "fn", kSig_v_v);
+    });
+
+  for (const [value, name] of [[undefined, "undefined"], [{}, "empty object"], [{ "module\0": null }, "wrong property"]]) {
+    t(`Imports argument with missing property: ${name}`,
+      new TypeError(),
+      builder => {
+        builder.addImport("module", "fn", kSig_v_v);
+      },
+      value);
+  }
+
+  t(`Importing an i64 global`,
+    new WebAssembly.LinkError(),
+    builder => {
+      builder.addImportedGlobal("module", "global", kWasmI64);
+    },
+    {
+      "module": {
+        "global": 0,
+      },
+    });
+
+  for (const value of [undefined, null, true, "", Symbol(), 1, 0.1, NaN, {}]) {
+    t(`Importing a function with an incorrectly-typed value: ${format_value(value)}`,
+      new WebAssembly.LinkError(),
+      builder => {
+        builder.addImport("module", "fn", kSig_v_v);
+      },
+      {
+        "module": {
+          "fn": value,
+        },
+      });
+  }
+
+  const nonGlobals = [
+    [undefined],
+    [null],
+    [true],
+    [""],
+    [Symbol()],
+    [{}, "plain object"],
+    [WebAssembly.Global, "WebAssembly.Global"],
+    [WebAssembly.Global.prototype, "WebAssembly.Global.prototype"],
+    [Object.create(WebAssembly.Global.prototype), "Object.create(WebAssembly.Global.prototype)"],
+  ];
+
+  for (const [value, name = format_value(value)] of nonGlobals) {
+    t(`Importing a global with an incorrectly-typed value: ${name}`,
+      new WebAssembly.LinkError(),
+      builder => {
+        builder.addImportedGlobal("module", "global", kWasmI32);
+      },
+      {
+        "module": {
+          "global": value,
+        },
+      });
+  }
+
+  const nonMemories = [
+    [undefined],
+    [null],
+    [true],
+    [""],
+    [Symbol()],
+    [1],
+    [0.1],
+    [NaN],
+    [{}, "plain object"],
+    [WebAssembly.Memory, "WebAssembly.Memory"],
+    [WebAssembly.Memory.prototype, "WebAssembly.Memory.prototype"],
+    [Object.create(WebAssembly.Memory.prototype), "Object.create(WebAssembly.Memory.prototype)"],
+  ];
+
+  for (const [value, name = format_value(value)] of nonMemories) {
+    t(`Importing memory with an incorrectly-typed value: ${name}`,
+      new WebAssembly.LinkError(),
+      builder => {
+        builder.addImportedMemory("module", "memory", 0, 128);
+      },
+      {
+        "module": {
+          "memory": value,
+        },
+      });
+  }
+
+  const nonTables = [
+    [undefined],
+    [null],
+    [true],
+    [""],
+    [Symbol()],
+    [1],
+    [0.1],
+    [NaN],
+    [{}, "plain object"],
+    [WebAssembly.Table, "WebAssembly.Table"],
+    [WebAssembly.Table.prototype, "WebAssembly.Table.prototype"],
+    [Object.create(WebAssembly.Table.prototype), "Object.create(WebAssembly.Table.prototype)"],
+  ];
+
+  for (const [value, name = format_value(value)] of nonTables) {
+    t(`Importing table with an incorrectly-typed value: ${name}`,
+      new WebAssembly.LinkError(),
+      builder => {
+        builder.addImportedTable("module", "table", 0, 128);
+      },
+      {
+        "module": {
+          "table": value,
+        },
+      });
+  }
+}
diff --git a/test/js-api/constructor/compile.any.js b/test/js-api/constructor/compile.any.js
new file mode 100644
index 000000000..bd23a8666
--- /dev/null
+++ b/test/js-api/constructor/compile.any.js
@@ -0,0 +1,81 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+function assert_Module(module) {
+  assert_equals(Object.getPrototypeOf(module), WebAssembly.Module.prototype,
+                "Prototype");
+  assert_true(Object.isExtensible(module), "Extensibility");
+}
+
+let emptyModuleBinary;
+setup(() => {
+  emptyModuleBinary = new WasmModuleBuilder().toBuffer();
+});
+
+promise_test(t => {
+  return promise_rejects(t, new TypeError(), WebAssembly.compile());
+}, "Missing argument");
+
+promise_test(t => {
+  const invalidArguments = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    ArrayBuffer,
+    ArrayBuffer.prototype,
+    Array.from(emptyModuleBinary),
+  ];
+  return Promise.all(invalidArguments.map(argument => {
+    return promise_rejects(t, new TypeError(), WebAssembly.compile(argument),
+                           `compile(${format_value(argument)})`);
+  }));
+}, "Invalid arguments");
+
+promise_test(() => {
+  const fn = WebAssembly.compile;
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly,
+  ];
+  return Promise.all(thisValues.map(thisValue => {
+    return fn.call(thisValue, emptyModuleBinary).then(assert_Module);
+  }));
+}, "Branding");
+
+test(() => {
+  const promise = WebAssembly.compile(emptyModuleBinary);
+  assert_equals(Object.getPrototypeOf(promise), Promise.prototype, "prototype");
+  assert_true(Object.isExtensible(promise), "extensibility");
+}, "Promise type");
+
+promise_test(t => {
+  const buffer = new Uint8Array();
+  return promise_rejects(t, new WebAssembly.CompileError(), WebAssembly.compile(buffer));
+}, "Invalid code");
+
+promise_test(() => {
+  return WebAssembly.compile(emptyModuleBinary).then(assert_Module);
+}, "Result type");
+
+promise_test(() => {
+  return WebAssembly.compile(emptyModuleBinary, {}).then(assert_Module);
+}, "Stray argument");
+
+promise_test(() => {
+  const buffer = new WasmModuleBuilder().toBuffer();
+  assert_equals(buffer[0], 0);
+  const promise = WebAssembly.compile(buffer);
+  buffer[0] = 1;
+  return promise.then(assert_Module);
+}, "Changing the buffer");
diff --git a/test/js-api/constructor/instantiate-bad-imports.any.js b/test/js-api/constructor/instantiate-bad-imports.any.js
new file mode 100644
index 000000000..86700298d
--- /dev/null
+++ b/test/js-api/constructor/instantiate-bad-imports.any.js
@@ -0,0 +1,23 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+// META: script=/wasm/jsapi/bad-imports.js
+
+test_bad_imports((name, error, build, ...arguments) => {
+  promise_test(t => {
+    const builder = new WasmModuleBuilder();
+    build(builder);
+    const buffer = builder.toBuffer();
+    const module = new WebAssembly.Module(buffer);
+    return promise_rejects(t, error, WebAssembly.instantiate(module, ...arguments));
+  }, `WebAssembly.instantiate(module): ${name}`);
+});
+
+test_bad_imports((name, error, build, ...arguments) => {
+  promise_test(t => {
+    const builder = new WasmModuleBuilder();
+    build(builder);
+    const buffer = builder.toBuffer();
+    return promise_rejects(t, error, WebAssembly.instantiate(buffer, ...arguments));
+  }, `WebAssembly.instantiate(buffer): ${name}`);
+});
diff --git a/test/js-api/constructor/instantiate.any.js b/test/js-api/constructor/instantiate.any.js
new file mode 100644
index 000000000..5da6bd58d
--- /dev/null
+++ b/test/js-api/constructor/instantiate.any.js
@@ -0,0 +1,111 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+// META: script=/wasm/jsapi/assertions.js
+// META: script=/wasm/jsapi/instanceTestFactory.js
+
+function assert_WebAssemblyInstantiatedSource(actual, expected_exports={}) {
+  assert_equals(Object.getPrototypeOf(actual), Object.prototype,
+                "Prototype");
+  assert_true(Object.isExtensible(actual), "Extensibility");
+
+  const module = Object.getOwnPropertyDescriptor(actual, "module");
+  assert_equals(typeof module, "object", "module: type of descriptor");
+  assert_true(module.writable, "module: writable");
+  assert_true(module.enumerable, "module: enumerable");
+  assert_true(module.configurable, "module: configurable");
+  assert_equals(Object.getPrototypeOf(module.value), WebAssembly.Module.prototype,
+                "module: prototype");
+
+  const instance = Object.getOwnPropertyDescriptor(actual, "instance");
+  assert_equals(typeof instance, "object", "instance: type of descriptor");
+  assert_true(instance.writable, "instance: writable");
+  assert_true(instance.enumerable, "instance: enumerable");
+  assert_true(instance.configurable, "instance: configurable");
+  assert_Instance(instance.value, expected_exports);
+}
+
+let emptyModuleBinary;
+setup(() => {
+  emptyModuleBinary = new WasmModuleBuilder().toBuffer();
+});
+
+promise_test(t => {
+  return promise_rejects(t, new TypeError(), WebAssembly.instantiate());
+}, "Missing arguments");
+
+promise_test(() => {
+  const fn = WebAssembly.instantiate;
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly,
+  ];
+  return Promise.all(thisValues.map(thisValue => {
+    return fn.call(thisValue, emptyModuleBinary).then(assert_WebAssemblyInstantiatedSource);
+  }));
+}, "Branding");
+
+promise_test(t => {
+  const invalidArguments = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Module,
+    WebAssembly.Module.prototype,
+    ArrayBuffer,
+    ArrayBuffer.prototype,
+    Array.from(emptyModuleBinary),
+  ];
+  return Promise.all(invalidArguments.map(argument => {
+    return promise_rejects(t, new TypeError(), WebAssembly.instantiate(argument),
+                           `instantiate(${format_value(argument)})`);
+  }));
+}, "Invalid arguments");
+
+test(() => {
+  const promise = WebAssembly.instantiate(emptyModuleBinary);
+  assert_equals(Object.getPrototypeOf(promise), Promise.prototype, "prototype");
+  assert_true(Object.isExtensible(promise), "extensibility");
+}, "Promise type");
+
+for (const [name, fn] of instanceTestFactory) {
+  promise_test(() => {
+    const { buffer, args, exports, verify } = fn();
+    return WebAssembly.instantiate(buffer, ...args).then(result => {
+      assert_WebAssemblyInstantiatedSource(result, exports);
+      verify(result.instance);
+    });
+  }, `${name}: BufferSource argument`);
+
+  promise_test(() => {
+    const { buffer, args, exports, verify } = fn();
+    const module = new WebAssembly.Module(buffer);
+    return WebAssembly.instantiate(module, ...args).then(instance => {
+      assert_Instance(instance, exports);
+      verify(instance);
+    });
+  }, `${name}: Module argument`);
+}
+
+promise_test(t => {
+  const buffer = new Uint8Array();
+  return promise_rejects(t, new WebAssembly.CompileError(), WebAssembly.instantiate(buffer));
+}, "Invalid code");
+
+promise_test(() => {
+  const buffer = new WasmModuleBuilder().toBuffer();
+  assert_equals(buffer[0], 0);
+  const promise = WebAssembly.instantiate(buffer);
+  buffer[0] = 1;
+  return promise.then(assert_WebAssemblyInstantiatedSource);
+}, "Changing the buffer");
diff --git a/test/js-api/constructor/validate.any.js b/test/js-api/constructor/validate.any.js
new file mode 100644
index 000000000..c8613cbd9
--- /dev/null
+++ b/test/js-api/constructor/validate.any.js
@@ -0,0 +1,100 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+let emptyModuleBinary;
+setup(() => {
+  emptyModuleBinary = new WasmModuleBuilder().toBuffer();
+});
+
+test(() => {
+  assert_throws(new TypeError(), () => WebAssembly.validate());
+}, "Missing argument");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    ArrayBuffer,
+    ArrayBuffer.prototype,
+    Array.from(emptyModuleBinary),
+  ];
+  for (const argument of invalidArguments) {
+    assert_throws(new TypeError(), () => WebAssembly.validate(argument),
+                  `validate(${format_value(argument)})`);
+  }
+}, "Invalid arguments");
+
+test(() => {
+  const fn = WebAssembly.validate;
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly,
+  ];
+  for (const thisValue of thisValues) {
+    assert_true(fn.call(thisValue, emptyModuleBinary), `this=${format_value(thisValue)}`);
+  }
+}, "Branding");
+
+const modules = [
+  // Incomplete header.
+  [[], false],
+  [[0x00], false],
+  [[0x00, 0x61], false],
+  [[0x00, 0x61, 0x73], false],
+  [[0x00, 0x61, 0x73, 0x6d], false],
+  [[0x00, 0x61, 0x73, 0x6d, 0x01], false],
+  [[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00], false],
+  [[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00], false],
+
+  // Complete header.
+  [[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00], true],
+
+  // Invalid version.
+  [[0x00, 0x61, 0x73, 0x6d, 0x00, 0x00, 0x00, 0x00], false],
+  [[0x00, 0x61, 0x73, 0x6d, 0x02, 0x00, 0x00, 0x00], false],
+
+  // Nameless custom section.
+  [[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00], false],
+
+  // Custom section with empty name.
+  [[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00], true],
+
+  // Custom section with name "a".
+  [[0x00, 0x61, 0x73, 0x6d, 0x01, 0x00, 0x00, 0x00, 0x00, 0x02, 0x01, 0x61], true],
+];
+const bufferTypes = [
+  Uint8Array,
+  Int8Array,
+  Uint16Array,
+  Int16Array,
+  Uint32Array,
+  Int32Array,
+];
+for (const [module, expected] of modules) {
+  const name = module.map(n => n.toString(16)).join(" ");
+  for (const bufferType of bufferTypes) {
+    if (module.length % bufferType.BYTES_PER_ELEMENT === 0) {
+      test(() => {
+        const bytes = new Uint8Array(module);
+        const moduleBuffer = new bufferType(bytes.buffer);
+        assert_equals(WebAssembly.validate(moduleBuffer), expected);
+      }, `Validating module [${name}] in ${bufferType.name}`);
+    }
+  }
+}
+
+test(() => {
+  assert_true(WebAssembly.validate(emptyModuleBinary, {}));
+}, "Stray argument");
diff --git a/test/js-api/global/constructor.any.js b/test/js-api/global/constructor.any.js
new file mode 100644
index 000000000..237f99c8b
--- /dev/null
+++ b/test/js-api/global/constructor.any.js
@@ -0,0 +1,127 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/assertions.js
+
+function assert_Global(actual, expected) {
+  assert_equals(Object.getPrototypeOf(actual), WebAssembly.Global.prototype,
+                "prototype");
+  assert_true(Object.isExtensible(actual), "extensible");
+
+  assert_equals(actual.value, expected, "value");
+  assert_equals(actual.valueOf(), expected, "valueOf");
+}
+
+test(() => {
+  assert_function_name(WebAssembly.Global, "Global", "WebAssembly.Global");
+}, "name");
+
+test(() => {
+  assert_function_length(WebAssembly.Global, 1, "WebAssembly.Global");
+}, "length");
+
+test(() => {
+  assert_throws(new TypeError(), () => new WebAssembly.Global());
+}, "No arguments");
+
+test(() => {
+  const argument = { "value": "i32" };
+  assert_throws(new TypeError(), () => WebAssembly.Global(argument));
+}, "Calling");
+
+test(() => {
+  const order = [];
+
+  new WebAssembly.Global({
+    get value() {
+      order.push("descriptor value");
+      return {
+        toString() {
+          order.push("descriptor value toString");
+          return "f64";
+        },
+      };
+    },
+
+    get mutable() {
+      order.push("descriptor mutable");
+      return false;
+    },
+  }, {
+    valueOf() {
+      order.push("value valueOf()");
+    }
+  });
+
+  assert_array_equals(order, [
+    "descriptor mutable",
+    "descriptor value",
+    "descriptor value toString",
+    "value valueOf()",
+  ]);
+}, "Order of evaluation");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    false,
+    true,
+    "",
+    "test",
+    Symbol(),
+    1,
+    NaN,
+    {},
+  ];
+  for (const invalidArgument of invalidArguments) {
+    assert_throws(new TypeError(),
+                  () => new WebAssembly.Global(invalidArgument),
+                  `new Global(${format_value(invalidArgument)})`);
+  }
+}, "Invalid descriptor argument");
+
+test(() => {
+  const invalidTypes = ["i16", "i128", "f16", "f128", "u32", "u64", "i32\0"];
+  for (const value of invalidTypes) {
+    const argument = { value };
+    assert_throws(new TypeError(), () => new WebAssembly.Global(argument));
+  }
+}, "Invalid type argument");
+
+test(() => {
+  const argument = { "value": "i64" };
+  const global = new WebAssembly.Global(argument);
+  assert_throws(new TypeError(), () => global.value);
+  assert_throws(new TypeError(), () => global.valueOf());
+}, "i64 with default");
+
+for (const type of ["i32", "f32", "f64"]) {
+  test(() => {
+    const argument = { "value": type };
+    const global = new WebAssembly.Global(argument);
+    assert_Global(global, 0);
+  }, `Default value for type ${type}`);
+
+  const valueArguments = [
+    [undefined, 0],
+    [null, 0],
+    [true, 1],
+    [false, 0],
+    [2, 2],
+    ["3", 3],
+    [{ toString() { return "5" } }, 5, "object with toString"],
+    [{ valueOf() { return "8" } }, 8, "object with valueOf"],
+  ];
+  for (const [value, expected, name = format_value(value)] of valueArguments) {
+    test(() => {
+      const argument = { "value": type };
+      const global = new WebAssembly.Global(argument, value);
+      assert_Global(global, expected);
+    }, `Explicit value ${name} for type ${type}`);
+  }
+}
+
+test(() => {
+  const argument = { "value": "i32" };
+  const global = new WebAssembly.Global(argument, 0, {});
+  assert_Global(global, 0);
+}, "Stray argument");
diff --git a/test/js-api/global/toString.any.js b/test/js-api/global/toString.any.js
new file mode 100644
index 000000000..ca025576c
--- /dev/null
+++ b/test/js-api/global/toString.any.js
@@ -0,0 +1,7 @@
+// META: global=jsshell
+
+test(() => {
+  const argument = { "value": "i32" };
+  const global = new WebAssembly.Global(argument);
+  assert_class_string(global, "WebAssembly.Global");
+}, "Object.prototype.toString on an Global");
diff --git a/test/js-api/global/value-get-set.any.js b/test/js-api/global/value-get-set.any.js
new file mode 100644
index 000000000..6de62d5f5
--- /dev/null
+++ b/test/js-api/global/value-get-set.any.js
@@ -0,0 +1,111 @@
+// META: global=jsshell
+
+test(() => {
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Global,
+    WebAssembly.Global.prototype,
+  ];
+
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Global.prototype, "value");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  const setter = desc.set;
+  assert_equals(typeof setter, "function");
+
+  for (const thisValue of thisValues) {
+    assert_throws(new TypeError(), () => getter.call(thisValue), `getter with this=${format_value(thisValue)}`);
+    assert_throws(new TypeError(), () => setter.call(thisValue, 1), `setter with this=${format_value(thisValue)}`);
+  }
+}, "Branding");
+
+for (const type of ["i32", "f32", "f64"]) {
+  const immutableOptions = [
+    [{}, "missing"],
+    [{ "mutable": undefined }, "undefined"],
+    [{ "mutable": null }, "null"],
+    [{ "mutable": false }, "false"],
+    [{ "mutable": "" }, "empty string"],
+    [{ "mutable": 0 }, "zero"],
+  ];
+  for (const [opts, name] of immutableOptions) {
+    test(() => {
+      opts.value = type;
+      const global = new WebAssembly.Global(opts);
+      assert_equals(global.value, 0, "initial value");
+      assert_equals(global.valueOf(), 0, "initial valueOf");
+
+      assert_throws(new TypeError(), () => global.value = 1);
+
+      assert_equals(global.value, 0, "post-set value");
+      assert_equals(global.valueOf(), 0, "post-set valueOf");
+    }, `Immutable ${type} (${name})`);
+  }
+
+  const mutableOptions = [
+    [{ "mutable": true }, "true"],
+    [{ "mutable": 1 }, "one"],
+    [{ "mutable": "x" }, "string"],
+    [Object.create({ "mutable": true }), "true on prototype"],
+  ];
+  for (const [opts, name] of mutableOptions) {
+    test(() => {
+      opts.value = type;
+      const global = new WebAssembly.Global(opts);
+      assert_equals(global.value, 0, "initial value");
+      assert_equals(global.valueOf(), 0, "initial valueOf");
+
+      global.value = 1;
+
+      assert_equals(global.value, 1, "post-set value");
+      assert_equals(global.valueOf(), 1, "post-set valueOf");
+    }, `Mutable ${type} (${name})`);
+  }
+}
+
+test(() => {
+  const argument = { "value": "i64", "mutable": true };
+  const global = new WebAssembly.Global(argument);
+  assert_throws(new TypeError(), () => global.value);
+  assert_throws(new TypeError(), () => global.value = 0);
+  assert_throws(new TypeError(), () => global.valueOf());
+}, "i64 with default");
+
+
+test(() => {
+  const argument = { "value": "i32", "mutable": true };
+  const global = new WebAssembly.Global(argument);
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Global.prototype, "value");
+  assert_equals(typeof desc, "object");
+
+  const setter = desc.set;
+  assert_equals(typeof setter, "function");
+
+  assert_throws(new TypeError(), () => setter.call(global));
+}, "Calling setter without argument");
+
+test(() => {
+  const argument = { "value": "i32", "mutable": true };
+  const global = new WebAssembly.Global(argument);
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Global.prototype, "value");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  const setter = desc.set;
+  assert_equals(typeof setter, "function");
+
+  assert_equals(getter.call(global, {}), 0);
+  assert_equals(setter.call(global, 1, {}), undefined);
+  assert_equals(global.value, 1);
+}, "Stray argument");
diff --git a/test/js-api/global/valueOf.any.js b/test/js-api/global/valueOf.any.js
new file mode 100644
index 000000000..d4a84b254
--- /dev/null
+++ b/test/js-api/global/valueOf.any.js
@@ -0,0 +1,28 @@
+// META: global=jsshell
+
+test(() => {
+  const argument = { "value": "i32" };
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Global,
+    WebAssembly.Global.prototype,
+  ];
+
+  const fn = WebAssembly.Global.prototype.valueOf;
+
+  for (const thisValue of thisValues) {
+    assert_throws(new TypeError(), () => fn.call(thisValue), `this=${format_value(thisValue)}`);
+  }
+}, "Branding");
+
+test(() => {
+  const argument = { "value": "i32" };
+  const global = new WebAssembly.Global(argument, 0);
+  assert_equals(global.valueOf({}), 0);
+}, "Stray argument");
diff --git a/test/js-api/instance/constructor-bad-imports.any.js b/test/js-api/instance/constructor-bad-imports.any.js
new file mode 100644
index 000000000..24c51c10d
--- /dev/null
+++ b/test/js-api/instance/constructor-bad-imports.any.js
@@ -0,0 +1,14 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+// META: script=/wasm/jsapi/bad-imports.js
+
+test_bad_imports((name, error, build, ...arguments) => {
+  test(() => {
+    const builder = new WasmModuleBuilder();
+    build(builder);
+    const buffer = builder.toBuffer();
+    const module = new WebAssembly.Module(buffer);
+    assert_throws(error, () => new WebAssembly.Instance(module, ...arguments));
+  }, `new WebAssembly.Instance(module): ${name}`);
+});
diff --git a/test/js-api/instance/constructor.any.js b/test/js-api/instance/constructor.any.js
new file mode 100644
index 000000000..e6a045020
--- /dev/null
+++ b/test/js-api/instance/constructor.any.js
@@ -0,0 +1,55 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+// META: script=/wasm/jsapi/assertions.js
+// META: script=/wasm/jsapi/instanceTestFactory.js
+
+let emptyModuleBinary;
+setup(() => {
+  emptyModuleBinary = new WasmModuleBuilder().toBuffer();
+});
+
+test(() => {
+  assert_function_name(WebAssembly.Instance, "Instance", "WebAssembly.Instance");
+}, "name");
+
+test(() => {
+  assert_function_length(WebAssembly.Instance, 1, "WebAssembly.Instance");
+}, "length");
+
+test(() => {
+  assert_throws(new TypeError(), () => new WebAssembly.Instance());
+}, "No arguments");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Module,
+    WebAssembly.Module.prototype,
+  ];
+  for (const argument of invalidArguments) {
+    assert_throws(new TypeError(), () => new WebAssembly.Instance(argument),
+                  `new Instance(${format_value(argument)})`);
+  }
+}, "Non-Module arguments");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  assert_throws(new TypeError(), () => WebAssembly.Instance(module));
+}, "Calling");
+
+for (const [name, fn] of instanceTestFactory) {
+  test(() => {
+    const { buffer, args, exports, verify } = fn();
+    const module = new WebAssembly.Module(buffer);
+    const instance = new WebAssembly.Instance(module, ...args);
+    assert_Instance(instance, exports);
+    verify(instance);
+  }, name);
+}
diff --git a/test/js-api/instance/exports.any.js b/test/js-api/instance/exports.any.js
new file mode 100644
index 000000000..cad468660
--- /dev/null
+++ b/test/js-api/instance/exports.any.js
@@ -0,0 +1,67 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+let emptyModuleBinary;
+setup(() => {
+  emptyModuleBinary = new WasmModuleBuilder().toBuffer();
+});
+
+test(() => {
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Instance,
+    WebAssembly.Instance.prototype,
+  ];
+
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Instance.prototype, "exports");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  assert_equals(typeof desc.set, "undefined");
+
+  for (const thisValue of thisValues) {
+    assert_throws(new TypeError(), () => getter.call(thisValue), `this=${format_value(thisValue)}`);
+  }
+}, "Branding");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const instance = new WebAssembly.Instance(module);
+  const exports = instance.exports;
+
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Instance.prototype, "exports");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  assert_equals(getter.call(instance, {}), exports);
+}, "Stray argument");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const instance = new WebAssembly.Instance(module);
+  const exports = instance.exports;
+  instance.exports = {};
+  assert_equals(instance.exports, exports, "Should not change the exports");
+}, "Setting (sloppy mode)");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const instance = new WebAssembly.Instance(module);
+  const exports = instance.exports;
+  assert_throws(new TypeError(), () => {
+    "use strict";
+    instance.exports = {};
+  });
+  assert_equals(instance.exports, exports, "Should not change the exports");
+}, "Setting (strict mode)");
diff --git a/test/js-api/instance/toString.any.js b/test/js-api/instance/toString.any.js
new file mode 100644
index 000000000..08dcb14a5
--- /dev/null
+++ b/test/js-api/instance/toString.any.js
@@ -0,0 +1,10 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+test(() => {
+  const emptyModuleBinary = new WasmModuleBuilder().toBuffer();
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const instance = new WebAssembly.Instance(module);
+  assert_class_string(instance, "WebAssembly.Instance");
+}, "Object.prototype.toString on an Instance");
diff --git a/test/js-api/instanceTestFactory.js b/test/js-api/instanceTestFactory.js
new file mode 100644
index 000000000..24f849e6f
--- /dev/null
+++ b/test/js-api/instanceTestFactory.js
@@ -0,0 +1,229 @@
+const instanceTestFactory = [
+  [
+    "Empty module without imports argument",
+    function() {
+      return {
+        buffer: emptyModuleBinary,
+        args: [],
+        exports: {},
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "Empty module with undefined imports argument",
+    function() {
+      return {
+        buffer: emptyModuleBinary,
+        args: [undefined],
+        exports: {},
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "Empty module with empty imports argument",
+    function() {
+      return {
+        buffer: emptyModuleBinary,
+        args: [{}],
+        exports: {},
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "getter order for imports object",
+    function() {
+      const builder = new WasmModuleBuilder();
+      builder.addImportedGlobal("module", "global1", kWasmI32);
+      builder.addImportedGlobal("module2", "global3", kWasmI32);
+      builder.addImportedMemory("module", "memory", 0, 128);
+      builder.addImportedGlobal("module", "global2", kWasmI32);
+      const buffer = builder.toBuffer();
+      const order = [];
+
+      const imports = {
+        get module() {
+          order.push("module getter");
+          return {
+            get global1() {
+              order.push("global1 getter");
+              return 0;
+            },
+            get global2() {
+              order.push("global2 getter");
+              return 0;
+            },
+            get memory() {
+              order.push("memory getter");
+              return new WebAssembly.Memory({ "initial": 64, maximum: 128 });
+            },
+          }
+        },
+        get module2() {
+          order.push("module2 getter");
+          return {
+            get global3() {
+              order.push("global3 getter");
+              return 0;
+            },
+          }
+        },
+      };
+
+      const expected = [
+        "module getter",
+        "global1 getter",
+        "module2 getter",
+        "global3 getter",
+        "module getter",
+        "memory getter",
+        "module getter",
+        "global2 getter",
+      ];
+      return {
+        buffer,
+        args: [imports],
+        exports: {},
+        verify: () => assert_array_equals(order, expected),
+      };
+    }
+  ],
+
+  [
+    "imports",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder.addImport("module", "fn", kSig_v_v);
+      builder.addImportedGlobal("module", "global", kWasmI32);
+      builder.addImportedMemory("module", "memory", 0, 128);
+      builder.addImportedTable("module", "table", 0, 128);
+
+      const buffer = builder.toBuffer();
+      const imports = {
+        "module": {
+          "fn": function() {},
+          "global": 0,
+          "memory": new WebAssembly.Memory({ "initial": 64, maximum: 128 }),
+          "table": new WebAssembly.Table({ "element": "anyfunc", "initial": 64, maximum: 128 }),
+        },
+        get "module2"() {
+          assert_unreached("Should not get modules that are not imported");
+        },
+      };
+
+      return {
+        buffer,
+        args: [imports],
+        exports: {},
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "No imports",
+    function() {
+      const builder = new WasmModuleBuilder();
+
+      builder
+        .addFunction("fn", kSig_v_d)
+        .addBody([
+            kExprEnd
+        ])
+        .exportFunc();
+      builder
+        .addFunction("fn2", kSig_v_v)
+        .addBody([
+            kExprEnd
+        ])
+        .exportFunc();
+
+      builder.setFunctionTableLength(1);
+      builder.addExportOfKind("table", kExternalTable, 0);
+
+      builder.addGlobal(kWasmI32, true)
+        .exportAs("global")
+        .init = 7;
+      builder.addGlobal(kWasmF64, true)
+        .exportAs("global2")
+        .init = 1.2;
+
+      builder.addMemory(4, 8, true);
+
+      const buffer = builder.toBuffer();
+
+      const exports = {
+        "fn": { "kind": "function", "name": "0", "length": 1 },
+        "fn2": { "kind": "function", "name": "1", "length": 0 },
+        "table": { "kind": "table", "length": 1 },
+        "global": { "kind": "global", "value": 7 },
+        "global2": { "kind": "global", "value": 1.2 },
+        "memory": { "kind": "memory", "size": 4 },
+      };
+
+      return {
+        buffer,
+        args: [],
+        exports,
+        verify: () => {},
+      };
+    }
+  ],
+
+  [
+    "exports and imports",
+    function() {
+      const value = 102;
+
+      const builder = new WasmModuleBuilder();
+
+      const index = builder.addImportedGlobal("module", "global", kWasmI32);
+      builder
+        .addFunction("fn", kSig_i_v)
+        .addBody([
+            kExprGetGlobal,
+            index,
+            kExprReturn,
+            kExprEnd,
+        ])
+        .exportFunc();
+
+      const buffer = builder.toBuffer();
+
+      const imports = {
+        "module": {
+          "global": value,
+        },
+      };
+
+      const exports = {
+        "fn": { "kind": "function", "name": "0", "length": 0 },
+      };
+
+      return {
+        buffer,
+        args: [imports],
+        exports,
+        verify: instance => assert_equals(instance.exports.fn(), value)
+      };
+    }
+  ],
+
+  [
+    "stray argument",
+    function() {
+      return {
+        buffer: emptyModuleBinary,
+        args: [{}, {}],
+        exports: {},
+        verify: () => {}
+      };
+    }
+  ],
+];
diff --git a/test/js-api/interface.any.js b/test/js-api/interface.any.js
new file mode 100644
index 000000000..98c4a1d78
--- /dev/null
+++ b/test/js-api/interface.any.js
@@ -0,0 +1,160 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/assertions.js
+
+function test_operations(object, object_name, operations) {
+  for (const [name, length] of operations) {
+    test(() => {
+      const propdesc = Object.getOwnPropertyDescriptor(object, name);
+      assert_equals(typeof propdesc, "object");
+      assert_true(propdesc.writable, "writable");
+      assert_true(propdesc.enumerable, "enumerable");
+      assert_true(propdesc.configurable, "configurable");
+      assert_equals(propdesc.value, object[name]);
+    }, `${object_name}.${name}`);
+
+    test(() => {
+      assert_function_name(object[name], name, `${object_name}.${name}`);
+    }, `${object_name}.${name}: name`);
+
+    test(() => {
+      assert_function_length(object[name], length, `${object_name}.${name}`);
+    }, `${object_name}.${name}: length`);
+  }
+}
+
+function test_attributes(object, object_name, attributes) {
+  for (const [name, mutable] of attributes) {
+    test(() => {
+      const propdesc = Object.getOwnPropertyDescriptor(object, name);
+      assert_equals(typeof propdesc, "object");
+      assert_true(propdesc.enumerable, "enumerable");
+      assert_true(propdesc.configurable, "configurable");
+    }, `${object_name}.${name}`);
+
+    test(() => {
+      const propdesc = Object.getOwnPropertyDescriptor(object, name);
+      assert_equals(typeof propdesc, "object");
+      assert_equals(typeof propdesc.get, "function");
+      assert_function_name(propdesc.get, "get " + name, `getter for "${name}"`);
+      assert_function_length(propdesc.get, 0, `getter for "${name}"`);
+    }, `${object_name}.${name}: getter`);
+
+    test(() => {
+      const propdesc = Object.getOwnPropertyDescriptor(object, name);
+      assert_equals(typeof propdesc, "object");
+      if (mutable) {
+        assert_equals(typeof propdesc.set, "function");
+        assert_function_name(propdesc.set, "set " + name, `setter for "${name}"`);
+        assert_function_length(propdesc.set, 1, `setter for "${name}"`);
+      } else {
+        assert_equals(typeof propdesc.set, "undefined");
+      }
+    }, `${object_name}.${name}: setter`);
+  }
+}
+
+test(() => {
+  const propdesc = Object.getOwnPropertyDescriptor(this, "WebAssembly");
+  assert_equals(typeof propdesc, "object");
+  assert_true(propdesc.writable, "writable");
+  assert_false(propdesc.enumerable, "enumerable");
+  assert_true(propdesc.configurable, "configurable");
+  assert_equals(propdesc.value, this.WebAssembly);
+}, "WebAssembly: property descriptor");
+
+test(() => {
+  assert_throws(new TypeError(), () => WebAssembly());
+}, "WebAssembly: calling");
+
+test(() => {
+  assert_throws(new TypeError(), () => new WebAssembly());
+}, "WebAssembly: constructing");
+
+const interfaces = [
+  "Module",
+  "Instance",
+  "Memory",
+  "Table",
+  "Global",
+  "CompileError",
+  "LinkError",
+  "RuntimeError",
+];
+
+for (const name of interfaces) {
+  test(() => {
+    const propdesc = Object.getOwnPropertyDescriptor(WebAssembly, name);
+    assert_equals(typeof propdesc, "object");
+    assert_true(propdesc.writable, "writable");
+    assert_false(propdesc.enumerable, "enumerable");
+    assert_true(propdesc.configurable, "configurable");
+    assert_equals(propdesc.value, WebAssembly[name]);
+  }, `WebAssembly.${name}: property descriptor`);
+
+  test(() => {
+    const interface_object = WebAssembly[name];
+    const propdesc = Object.getOwnPropertyDescriptor(interface_object, "prototype");
+    assert_equals(typeof propdesc, "object");
+    assert_false(propdesc.writable, "writable");
+    assert_false(propdesc.enumerable, "enumerable");
+    assert_false(propdesc.configurable, "configurable");
+  }, `WebAssembly.${name}: prototype`);
+
+  test(() => {
+    const interface_object = WebAssembly[name];
+    const interface_prototype_object = interface_object.prototype;
+    const propdesc = Object.getOwnPropertyDescriptor(interface_prototype_object, "constructor");
+    assert_equals(typeof propdesc, "object");
+    assert_true(propdesc.writable, "writable");
+    assert_false(propdesc.enumerable, "enumerable");
+    assert_true(propdesc.configurable, "configurable");
+    assert_equals(propdesc.value, interface_object);
+  }, `WebAssembly.${name}: prototype.constructor`);
+}
+
+test_operations(WebAssembly, "WebAssembly", [
+  ["validate", 1],
+  ["compile", 1],
+  ["instantiate", 1],
+]);
+
+
+test_operations(WebAssembly.Module, "WebAssembly.Module", [
+  ["exports", 1],
+  ["imports", 1],
+  ["customSections", 2],
+]);
+
+
+test_attributes(WebAssembly.Instance.prototype, "WebAssembly.Instance", [
+  ["exports", false],
+]);
+
+
+test_operations(WebAssembly.Memory.prototype, "WebAssembly.Memory", [
+  ["grow", 1],
+]);
+
+test_attributes(WebAssembly.Memory.prototype, "WebAssembly.Memory", [
+  ["buffer", false],
+]);
+
+
+test_operations(WebAssembly.Table.prototype, "WebAssembly.Table", [
+  ["grow", 1],
+  ["get", 1],
+  ["set", 2],
+]);
+
+test_attributes(WebAssembly.Table.prototype, "WebAssembly.Table", [
+  ["length", false],
+]);
+
+
+test_operations(WebAssembly.Global.prototype, "WebAssembly.Global", [
+  ["valueOf", 0],
+]);
+
+test_attributes(WebAssembly.Global.prototype, "WebAssembly.Global", [
+  ["value", true],
+]);
diff --git a/test/js-api/jsapi.js b/test/js-api/jsapi.js
deleted file mode 100644
index 30a7e606c..000000000
--- a/test/js-api/jsapi.js
+++ /dev/null
@@ -1,1183 +0,0 @@
-/*
- * Copyright 2017 WebAssembly Community Group participants
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-const kC0DEFEFE = new Uint8Array([0xC0, 0xDE, 0xFE, 0xFE]);
-
-(function testJSAPI() {
-
-const WasmPage = 64 * 1024;
-
-const emptyModuleBinary = new WasmModuleBuilder().toBuffer();
-
-const importingModuleBinary = (() => {
-    let builder = new WasmModuleBuilder();
-
-    builder.addImport('', 'f', kSig_v_v);
-
-    return builder.toBuffer();
-})();
-
-const complexImportingModuleBinary = (() => {
-    let builder = new WasmModuleBuilder();
-
-    builder.addImport('a', 'b', kSig_v_v);
-    builder.addImportedMemory('c', 'd', 1);
-    builder.addImportedTable('e', 'f', 1);
-    builder.addImportedGlobal('g', '⚡', kWasmI32);
-
-    return builder.toBuffer();
-})();
-
-const exportingModuleBinary = (() => {
-    let builder = new WasmModuleBuilder();
-
-    builder
-        .addFunction('f', kSig_i_v)
-        .addBody([
-            kExprI32Const,
-            42
-        ])
-        .exportFunc();
-
-    return builder.toBuffer();
-})();
-
-const complexExportingModuleBinary = (() => {
-    let builder = new WasmModuleBuilder();
-
-    builder
-        .addFunction('a', kSig_v_v)
-        .addBody([])
-        .exportFunc();
-
-    builder.addMemory(1, 1, /* exported */ false);
-    builder.exportMemoryAs('b');
-
-    builder.setTableLength(1);
-    builder.addExportOfKind('c', kExternalTable, 0);
-
-    // Default init for global values is 0. Keep that.
-    builder.addGlobal(kWasmI32, /* mutable */ false)
-        .exportAs("⚡");
-
-    return builder.toBuffer();
-})();
-
-const moduleBinaryImporting2Memories = (() => {
-    var builder = new WasmModuleBuilder();
-    builder.addImportedMemory("", "memory1");
-    builder.addImportedMemory("", "memory2");
-    return builder.toBuffer();
-})();
-
-const moduleBinaryWithMemSectionAndMemImport = (() => {
-    var builder = new WasmModuleBuilder();
-    builder.addMemory(1, 1, false);
-    builder.addImportedMemory("", "memory1");
-    return builder.toBuffer();
-})();
-
-const exportingModuleIdentityFn = (() => {
-    let builder = new WasmModuleBuilder();
-
-    builder
-        .addFunction('id', kSig_i_i)
-        .addBody([kExprGetLocal, 0])
-        .exportFunc();
-
-    return builder.toBuffer();
-})();
-
-let Module;
-let Instance;
-let CompileError;
-let LinkError;
-let RuntimeError;
-let Memory;
-let instanceProto;
-let memoryProto;
-let mem1;
-let Table;
-let tbl1;
-let tableProto;
-let Global;
-let globalProto;
-let globalI32;
-let globalI64;
-let globalF32;
-let globalF64;
-let globalI32Mut;
-let globalI64Mut;
-let globalF32Mut;
-let globalF64Mut;
-
-let emptyModule;
-let exportingModule;
-let exportingInstance;
-let exportsObj;
-let importingModule;
-
-// Start of tests.
-
-test(() => {
-    const wasmDesc = Object.getOwnPropertyDescriptor(this, 'WebAssembly');
-    assert_equals(typeof wasmDesc.value, "object");
-    assert_true(wasmDesc.writable);
-    assert_false(wasmDesc.enumerable);
-    assert_true(wasmDesc.configurable);
-}, "'WebAssembly' data property on global object");
-
-test(() => {
-    const wasmDesc = Object.getOwnPropertyDescriptor(this, 'WebAssembly');
-    assert_equals(WebAssembly, wasmDesc.value);
-    assert_equals(String(WebAssembly), "[object WebAssembly]");
-}, "'WebAssembly' object");
-
-test(() => {
-    const compileErrorDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'CompileError');
-    const linkErrorDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'LinkError');
-    const runtimeErrorDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'RuntimeError');
-    assert_equals(typeof compileErrorDesc.value, "function");
-    assert_equals(typeof linkErrorDesc.value, "function");
-    assert_equals(typeof runtimeErrorDesc.value, "function");
-    assert_equals(compileErrorDesc.writable, true);
-    assert_equals(linkErrorDesc.writable, true);
-    assert_equals(runtimeErrorDesc.writable, true);
-    assert_equals(compileErrorDesc.enumerable, false);
-    assert_equals(linkErrorDesc.enumerable, false);
-    assert_equals(runtimeErrorDesc.enumerable, false);
-    assert_equals(compileErrorDesc.configurable, true);
-    assert_equals(linkErrorDesc.configurable, true);
-    assert_equals(runtimeErrorDesc.configurable, true);
-
-    CompileError = WebAssembly.CompileError;
-    LinkError = WebAssembly.LinkError;
-    RuntimeError = WebAssembly.RuntimeError;
-}, "'WebAssembly.(Compile|Link|Runtime)Error' data property");
-
-test(() => {
-    const compileErrorDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'CompileError');
-    const linkErrorDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'LinkError');
-    const runtimeErrorDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'RuntimeError');
-    assert_equals(CompileError, compileErrorDesc.value);
-    assert_equals(LinkError, linkErrorDesc.value);
-    assert_equals(RuntimeError, runtimeErrorDesc.value);
-    assert_equals(CompileError.length, 1);
-    assert_equals(LinkError.length, 1);
-    assert_equals(RuntimeError.length, 1);
-    assert_equals(CompileError.name, "CompileError");
-    assert_equals(LinkError.name, "LinkError");
-    assert_equals(RuntimeError.name, "RuntimeError");
-}, "'WebAssembly.(Compile|Runtime)Error' constructor function");
-
-test(() => {
-    const compileError = new CompileError;
-    const runtimeError = new RuntimeError;
-    assert_equals(compileError instanceof CompileError, true);
-    assert_equals(runtimeError instanceof RuntimeError, true);
-    assert_equals(compileError instanceof Error, true);
-    assert_equals(runtimeError instanceof Error, true);
-    assert_equals(compileError instanceof TypeError, false);
-    assert_equals(runtimeError instanceof TypeError, false);
-    assert_equals(compileError.message, "");
-    assert_equals(runtimeError.message, "");
-    assert_equals(new CompileError("hi").message, "hi");
-    assert_equals(new RuntimeError("hi").message, "hi");
-}, "'WebAssembly.(Compile|Runtime)Error' instance objects");
-
-test(() => {
-    const moduleDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Module');
-    assert_equals(typeof moduleDesc.value, "function");
-    assert_equals(moduleDesc.writable, true);
-    assert_equals(moduleDesc.enumerable, false);
-    assert_equals(moduleDesc.configurable, true);
-    Module = WebAssembly.Module;
-}, "'WebAssembly.Module' data property");
-
-test(() => {
-    const moduleDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Module');
-    assert_equals(Module, moduleDesc.value);
-    assert_equals(Module.length, 1);
-    assert_equals(Module.name, "Module");
-    assertThrows(() => Module(), TypeError);
-    assertThrows(() => new Module(), TypeError);
-    assertThrows(() => new Module(undefined), TypeError);
-    assertThrows(() => new Module(1), TypeError);
-    assertThrows(() => new Module({}), TypeError);
-    assertThrows(() => new Module(new Uint8Array()), CompileError);
-    assertThrows(() => new Module(new ArrayBuffer()), CompileError);
-    assert_equals(new Module(emptyModuleBinary) instanceof Module, true);
-    assert_equals(new Module(new Uint8Array(emptyModuleBinary)) instanceof Module, true);
-}, "'WebAssembly.Module' constructor function");
-
-test(() => {
-    const moduleProtoDesc = Object.getOwnPropertyDescriptor(Module, 'prototype');
-    assert_equals(typeof moduleProtoDesc.value, "object");
-    assert_equals(moduleProtoDesc.writable, false);
-    assert_equals(moduleProtoDesc.enumerable, false);
-    assert_equals(moduleProtoDesc.configurable, false);
-}, "'WebAssembly.Module.prototype' data property");
-
-test(() => {
-    const moduleProtoDesc = Object.getOwnPropertyDescriptor(Module, 'prototype');
-    const moduleProto = Module.prototype;
-    assert_equals(moduleProto, moduleProtoDesc.value);
-    assert_equals(String(moduleProto), "[object WebAssembly.Module]");
-    assert_equals(Object.getPrototypeOf(moduleProto), Object.prototype);
-}, "'WebAssembly.Module.prototype' object");
-
-test(() => {
-    const moduleProto = Module.prototype;
-    emptyModule = new Module(emptyModuleBinary);
-    exportingModule = new Module(exportingModuleBinary);
-    importingModule = new Module(importingModuleBinary);
-    assert_equals(typeof emptyModule, "object");
-    assert_equals(String(emptyModule), "[object WebAssembly.Module]");
-    assert_equals(Object.getPrototypeOf(emptyModule), moduleProto);
-}, "'WebAssembly.Module' instance objects");
-
-test(() => {
-    const moduleImportsDesc = Object.getOwnPropertyDescriptor(Module, 'imports');
-    assert_equals(typeof moduleImportsDesc.value, "function");
-    assert_equals(moduleImportsDesc.writable, true);
-    assert_equals(moduleImportsDesc.enumerable, false);
-    assert_equals(moduleImportsDesc.configurable, true);
-}, "'WebAssembly.Module.imports' data property");
-
-test(() => {
-    const moduleImportsDesc = Object.getOwnPropertyDescriptor(Module, 'imports');
-    const moduleImports = moduleImportsDesc.value;
-    assert_equals(moduleImports.length, 1);
-    assertThrows(() => moduleImports(), TypeError);
-    assertThrows(() => moduleImports(undefined), TypeError);
-    assertThrows(() => moduleImports({}), TypeError);
-    var arr = moduleImports(emptyModule);
-    assert_equals(arr instanceof Array, true);
-    assert_equals(arr.length, 0);
-    var arr = moduleImports(new Module(complexImportingModuleBinary));
-    assert_equals(arr instanceof Array, true);
-    assert_equals(arr.length, 4);
-    assert_equals(arr[0].kind, "function");
-    assert_equals(arr[0].module, "a");
-    assert_equals(arr[0].name, "b");
-    assert_equals(arr[1].kind, "memory");
-    assert_equals(arr[1].module, "c");
-    assert_equals(arr[1].name, "d");
-    assert_equals(arr[2].kind, "table");
-    assert_equals(arr[2].module, "e");
-    assert_equals(arr[2].name, "f");
-    assert_equals(arr[3].kind, "global");
-    assert_equals(arr[3].module, "g");
-    assert_equals(arr[3].name, "⚡");
-}, "'WebAssembly.Module.imports' method");
-
-test(() => {
-    const moduleExportsDesc = Object.getOwnPropertyDescriptor(Module, 'exports');
-    assert_equals(typeof moduleExportsDesc.value, "function");
-    assert_equals(moduleExportsDesc.writable, true);
-    assert_equals(moduleExportsDesc.enumerable, false);
-    assert_equals(moduleExportsDesc.configurable, true);
-}, "'WebAssembly.Module.exports' data property");
-
-test(() => {
-    const moduleExportsDesc = Object.getOwnPropertyDescriptor(Module, 'exports');
-    const moduleExports = moduleExportsDesc.value;
-    assert_equals(moduleExports.length, 1);
-    assertThrows(() => moduleExports(), TypeError);
-    assertThrows(() => moduleExports(undefined), TypeError);
-    assertThrows(() => moduleExports({}), TypeError);
-    var arr = moduleExports(emptyModule);
-    assert_equals(arr instanceof Array, true);
-    assert_equals(arr.length, 0);
-    var arr = moduleExports(new Module(complexExportingModuleBinary));
-    assert_equals(arr instanceof Array, true);
-    assert_equals(arr.length, 4);
-    assert_equals(arr[0].kind, "function");
-    assert_equals(arr[0].name, "a");
-    assert_equals(arr[1].kind, "memory");
-    assert_equals(arr[1].name, "b");
-    assert_equals(arr[2].kind, "table");
-    assert_equals(arr[2].name, "c");
-    assert_equals(arr[3].kind, "global");
-    assert_equals(arr[3].name, "⚡");
-}, "'WebAssembly.Module.exports' method");
-
-test(() => {
-    const customSectionsDesc = Object.getOwnPropertyDescriptor(Module, 'customSections');
-    assert_equals(typeof customSectionsDesc.value, "function");
-    assert_equals(customSectionsDesc.writable, true);
-    assert_equals(customSectionsDesc.enumerable, false);
-    assert_equals(customSectionsDesc.configurable, true);
-}, "'WebAssembly.Module.customSections' data property");
-
-test(() => {
-    const customSectionsDesc = Object.getOwnPropertyDescriptor(Module, 'customSections');
-    const moduleCustomSections = customSectionsDesc.value;
-    assert_equals(moduleCustomSections.length, 2);
-    assertThrows(() => moduleCustomSections(), TypeError);
-    assertThrows(() => moduleCustomSections(undefined), TypeError);
-    assertThrows(() => moduleCustomSections({}), TypeError);
-    var arr = moduleCustomSections(emptyModule);
-    assert_equals(arr instanceof Array, true);
-    assert_equals(arr.length, 0);
-}, "'WebAssembly.Module.customSections' method");
-
-test(() => {
-    const instanceDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Instance');
-    assert_equals(typeof instanceDesc.value, "function");
-    assert_equals(instanceDesc.writable, true);
-    assert_equals(instanceDesc.enumerable, false);
-    assert_equals(instanceDesc.configurable, true);
-    Instance = WebAssembly.Instance;
-}, "'WebAssembly.Instance' data property");
-
-test(() => {
-    const instanceDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Instance');
-    assert_equals(Instance, instanceDesc.value);
-    assert_equals(Instance.length, 1);
-    assert_equals(Instance.name, "Instance");
-    assertThrows(() => Instance(), TypeError);
-    assertThrows(() => new Instance(1), TypeError);
-    assertThrows(() => new Instance({}), TypeError);
-    assertThrows(() => new Instance(emptyModule, null), TypeError);
-    assertThrows(() => new Instance(importingModule, null), TypeError);
-    assertThrows(() => new Instance(importingModule, undefined), TypeError);
-    assertThrows(() => new Instance(importingModule, {}), TypeError);
-    assertThrows(() => new Instance(importingModule, {"":{g:()=>{}}}), LinkError);
-    assertThrows(() => new Instance(importingModule, {t:{f:()=>{}}}), TypeError);
-    assert_equals(new Instance(emptyModule) instanceof Instance, true);
-    assert_equals(new Instance(emptyModule, {}) instanceof Instance, true);
-}, "'WebAssembly.Instance' constructor function");
-
-test(() => {
-    const instanceProtoDesc = Object.getOwnPropertyDescriptor(Instance, 'prototype');
-    assert_equals(typeof instanceProtoDesc.value, "object");
-    assert_equals(instanceProtoDesc.writable, false);
-    assert_equals(instanceProtoDesc.enumerable, false);
-    assert_equals(instanceProtoDesc.configurable, false);
-}, "'WebAssembly.Instance.prototype' data property");
-
-test(() => {
-    instanceProto = Instance.prototype;
-    const instanceProtoDesc = Object.getOwnPropertyDescriptor(Instance, 'prototype');
-    assert_equals(instanceProto, instanceProtoDesc.value);
-    assert_equals(String(instanceProto), "[object WebAssembly.Instance]");
-    assert_equals(Object.getPrototypeOf(instanceProto), Object.prototype);
-}, "'WebAssembly.Instance.prototype' object");
-
-test(() => {
-    const instanceProto = Instance.prototype;
-    exportingInstance = new Instance(exportingModule);
-    assert_equals(typeof exportingInstance, "object");
-    assert_equals(String(exportingInstance), "[object WebAssembly.Instance]");
-    assert_equals(Object.getPrototypeOf(exportingInstance), instanceProto);
-}, "'WebAssembly.Instance' instance objects");
-
-test(() => {
-    const exportsDesc = Object.getOwnPropertyDescriptor(instanceProto, 'exports');
-    assert_equals(typeof exportsDesc.get, "function");
-    assert_equals(exportsDesc.set, undefined);
-    assert_equals(exportsDesc.enumerable, false);
-    assert_equals(exportsDesc.configurable, true);
-    const exportsGetter = exportsDesc.get;
-    assertThrows(() => exportsGetter.call(), TypeError);
-    assertThrows(() => exportsGetter.call({}), TypeError);
-    assert_equals(typeof exportsGetter.call(exportingInstance), "object");
-}, "'WebAssembly.Instance.prototype.exports' accessor property");
-
-test(() => {
-    exportsObj = exportingInstance.exports;
-    assert_equals(typeof exportsObj, "object");
-    assert_equals(Object.isExtensible(exportsObj), false);
-    assert_equals(Object.getPrototypeOf(exportsObj), null);
-    assert_equals(Object.keys(exportsObj).join(), "f");
-    exportsObj.g = 1;
-    assert_equals(Object.keys(exportsObj).join(), "f");
-    assertThrows(() => Object.setPrototypeOf(exportsObj, {}), TypeError);
-    assert_equals(Object.getPrototypeOf(exportsObj), null);
-    assertThrows(() => Object.defineProperty(exportsObj, 'g', {}), TypeError);
-    assert_equals(Object.keys(exportsObj).join(), "f");
-}, "exports object");
-
-test(() => {
-    const f = exportsObj.f;
-    assert_equals(f instanceof Function, true);
-    assert_equals(f.length, 0);
-    assert_equals('name' in f, true);
-    assert_equals(Function.prototype.call.call(f), 42);
-    assert_equals('prototype' in f, false);
-    assertThrows(() => new f(), TypeError);
-}, "Exported WebAssembly functions");
-
-test(() => {
-    const memoryDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Memory');
-    assert_equals(typeof memoryDesc.value, "function");
-    assert_equals(memoryDesc.writable, true);
-    assert_equals(memoryDesc.enumerable, false);
-    assert_equals(memoryDesc.configurable, true);
-    Memory = WebAssembly.Memory;
-}, "'WebAssembly.Memory' data property");
-
-test(() => {
-    const memoryDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Memory');
-    assert_equals(Memory, memoryDesc.value);
-    assert_equals(Memory.length, 1);
-    assert_equals(Memory.name, "Memory");
-    assertThrows(() => Memory(), TypeError);
-    assertThrows(() => new Memory(1), TypeError);
-    assertThrows(() => new Memory({initial:{valueOf() { throw new Error("here")}}}), Error);
-    assertThrows(() => new Memory({initial:-1}), RangeError);
-    assertThrows(() => new Memory({initial:Math.pow(2,32)}), RangeError);
-    assertThrows(() => new Memory({initial:1, maximum: Math.pow(2,32)/Math.pow(2,14) }), RangeError);
-    assertThrows(() => new Memory({initial:2, maximum:1 }), RangeError);
-    assertThrows(() => new Memory({maximum: -1 }), RangeError);
-    assert_equals(new Memory({initial:1}) instanceof Memory, true);
-    assert_equals(new Memory({initial:1.5}).buffer.byteLength, WasmPage);
-}, "'WebAssembly.Memory' constructor function");
-
-test(() => {
-    const memoryProtoDesc = Object.getOwnPropertyDescriptor(Memory, 'prototype');
-    assert_equals(typeof memoryProtoDesc.value, "object");
-    assert_equals(memoryProtoDesc.writable, false);
-    assert_equals(memoryProtoDesc.enumerable, false);
-    assert_equals(memoryProtoDesc.configurable, false);
-}, "'WebAssembly.Memory.prototype' data property");
-
-test(() => {
-    memoryProto = Memory.prototype;
-    const memoryProtoDesc = Object.getOwnPropertyDescriptor(Memory, 'prototype');
-    assert_equals(memoryProto, memoryProtoDesc.value);
-    assert_equals(String(memoryProto), "[object WebAssembly.Memory]");
-    assert_equals(Object.getPrototypeOf(memoryProto), Object.prototype);
-}, "'WebAssembly.Memory.prototype' object");
-
-test(() => {
-    mem1 = new Memory({initial:1});
-    assert_equals(typeof mem1, "object");
-    assert_equals(String(mem1), "[object WebAssembly.Memory]");
-    assert_equals(Object.getPrototypeOf(mem1), memoryProto);
-}, "'WebAssembly.Memory' instance objects");
-
-test(() => {
-    const bufferDesc = Object.getOwnPropertyDescriptor(memoryProto, 'buffer');
-    assert_equals(typeof bufferDesc.get, "function");
-    assert_equals(bufferDesc.set, undefined);
-    assert_equals(bufferDesc.enumerable, false);
-    assert_equals(bufferDesc.configurable, true);
-}, "'WebAssembly.Memory.prototype.buffer' accessor property");
-
-test(() => {
-    const bufferDesc = Object.getOwnPropertyDescriptor(memoryProto, 'buffer');
-    const bufferGetter = bufferDesc.get;
-    assertThrows(() => bufferGetter.call(), TypeError);
-    assertThrows(() => bufferGetter.call({}), TypeError);
-    assert_equals(bufferGetter.call(mem1) instanceof ArrayBuffer, true);
-    assert_equals(bufferGetter.call(mem1).byteLength, WasmPage);
-}, "'WebAssembly.Memory.prototype.buffer' getter");
-
-test(() => {
-    const memGrowDesc = Object.getOwnPropertyDescriptor(memoryProto, 'grow');
-    assert_equals(typeof memGrowDesc.value, "function");
-    assert_equals(memGrowDesc.enumerable, false);
-    assert_equals(memGrowDesc.configurable, true);
-}, "'WebAssembly.Memory.prototype.grow' data property");
-
-test(() => {
-    const memGrowDesc = Object.getOwnPropertyDescriptor(memoryProto, 'grow');
-    const memGrow = memGrowDesc.value;
-    assert_equals(memGrow.length, 1);
-    assertThrows(() => memGrow.call(), TypeError);
-    assertThrows(() => memGrow.call({}), TypeError);
-    assertThrows(() => memGrow.call(mem1, -1), RangeError);
-    assertThrows(() => memGrow.call(mem1, Math.pow(2,32)), RangeError);
-    var mem = new Memory({initial:1, maximum:2});
-    var buf = mem.buffer;
-    assert_equals(buf.byteLength, WasmPage);
-    assert_equals(mem.grow(0), 1);
-    assert_not_equals(buf, mem.buffer)
-    assert_equals(buf.byteLength, 0);
-    buf = mem.buffer;
-    assert_equals(buf.byteLength, WasmPage);
-    assert_equals(mem.grow(1), 1);
-    assert_not_equals(buf, mem.buffer)
-    assert_equals(buf.byteLength, 0);
-    buf = mem.buffer;
-    assert_equals(buf.byteLength, 2 * WasmPage);
-    assertThrows(() => mem.grow(1), Error);
-    assert_equals(buf, mem.buffer);
-    mem = new Memory({initial:0, maximum:1});
-    buf = mem.buffer;
-    assert_equals(buf.byteLength, 0);
-    assert_equals(mem.grow(0), 0);
-    assert_not_equals(buf, mem.buffer)
-    assert_equals(buf.byteLength, 0);
-    assert_equals(mem.buffer.byteLength, 0);
-}, "'WebAssembly.Memory.prototype.grow' method");
-
-test(() => {
-    const tableDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Table');
-    assert_equals(typeof tableDesc.value, "function");
-    assert_equals(tableDesc.writable, true);
-    assert_equals(tableDesc.enumerable, false);
-    assert_equals(tableDesc.configurable, true);
-    Table = WebAssembly.Table;
-}, "'WebAssembly.Table' data property");
-
-test(() => {
-    const tableDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Table');
-    assert_equals(Table, tableDesc.value);
-    assert_equals(Table.length, 1);
-    assert_equals(Table.name, "Table");
-    assertThrows(() => Table(), TypeError);
-    assertThrows(() => new Table(1), TypeError);
-    assertThrows(() => new Table({initial:1, element:1}), TypeError);
-    assertThrows(() => new Table({initial:1, element:"any"}), TypeError);
-    assertThrows(() => new Table({initial:1, element:{valueOf() { return "anyfunc" }}}), TypeError);
-    assertThrows(() => new Table({initial:{valueOf() { throw new Error("here")}}, element:"anyfunc"}), Error);
-    assertThrows(() => new Table({initial:-1, element:"anyfunc"}), RangeError);
-    assertThrows(() => new Table({initial:Math.pow(2,32), element:"anyfunc"}), RangeError);
-    assertThrows(() => new Table({initial:2, maximum:1, element:"anyfunc"}), RangeError);
-    assertThrows(() => new Table({initial:2, maximum:Math.pow(2,32), element:"anyfunc"}), RangeError);
-    assert_equals(new Table({initial:1, element:"anyfunc"}) instanceof Table, true);
-    assert_equals(new Table({initial:1.5, element:"anyfunc"}) instanceof Table, true);
-    assert_equals(new Table({initial:1, maximum:1.5, element:"anyfunc"}) instanceof Table, true);
-    assert_equals(new Table({initial:1, maximum:Math.pow(2,32)-1, element:"anyfunc"}) instanceof Table, true);
-}, "'WebAssembly.Table' constructor function");
-
-test(() => {
-    const tableProtoDesc = Object.getOwnPropertyDescriptor(Table, 'prototype');
-    assert_equals(typeof tableProtoDesc.value, "object");
-    assert_equals(tableProtoDesc.writable, false);
-    assert_equals(tableProtoDesc.enumerable, false);
-    assert_equals(tableProtoDesc.configurable, false);
-}, "'WebAssembly.Table.prototype' data property");
-
-test(() => {
-    const tableProtoDesc = Object.getOwnPropertyDescriptor(Table, 'prototype');
-    tableProto = Table.prototype;
-    assert_equals(tableProto, tableProtoDesc.value);
-    assert_equals(String(tableProto), "[object WebAssembly.Table]");
-    assert_equals(Object.getPrototypeOf(tableProto), Object.prototype);
-}, "'WebAssembly.Table.prototype' object");
-
-test(() => {
-    tbl1 = new Table({initial:2, element:"anyfunc"});
-    assert_equals(typeof tbl1, "object");
-    assert_equals(String(tbl1), "[object WebAssembly.Table]");
-    assert_equals(Object.getPrototypeOf(tbl1), tableProto);
-}, "'WebAssembly.Table' instance objects");
-
-test(() => {
-    const lengthDesc = Object.getOwnPropertyDescriptor(tableProto, 'length');
-    assert_equals(typeof lengthDesc.get, "function");
-    assert_equals(lengthDesc.set, undefined);
-    assert_equals(lengthDesc.enumerable, false);
-    assert_equals(lengthDesc.configurable, true);
-}, "'WebAssembly.Table.prototype.length' accessor data property");
-
-test(() => {
-    const lengthDesc = Object.getOwnPropertyDescriptor(tableProto, 'length');
-    const lengthGetter = lengthDesc.get;
-    assert_equals(lengthGetter.length, 0);
-    assertThrows(() => lengthGetter.call(), TypeError);
-    assertThrows(() => lengthGetter.call({}), TypeError);
-    assert_equals(typeof lengthGetter.call(tbl1), "number");
-    assert_equals(lengthGetter.call(tbl1), 2);
-}, "'WebAssembly.Table.prototype.length' getter");
-
-test(() => {
-    const getDesc = Object.getOwnPropertyDescriptor(tableProto, 'get');
-    assert_equals(typeof getDesc.value, "function");
-    assert_equals(getDesc.enumerable, false);
-    assert_equals(getDesc.configurable, true);
-}, "'WebAssembly.Table.prototype.get' data property");
-
-test(() => {
-    const getDesc = Object.getOwnPropertyDescriptor(tableProto, 'get');
-    const get = getDesc.value;
-    assert_equals(get.length, 1);
-    assertThrows(() => get.call(), TypeError);
-    assertThrows(() => get.call({}), TypeError);
-    assert_equals(get.call(tbl1, 0), null);
-    assert_equals(get.call(tbl1, 1), null);
-    assert_equals(get.call(tbl1, 1.5), null);
-    assertThrows(() => get.call(tbl1, 2), RangeError);
-    assertThrows(() => get.call(tbl1, 2.5), RangeError);
-    assertThrows(() => get.call(tbl1, -1), RangeError);
-    assertThrows(() => get.call(tbl1, Math.pow(2,33)), RangeError);
-    assertThrows(() => get.call(tbl1, {valueOf() { throw new Error("hi") }}), Error);
-}, "'WebAssembly.Table.prototype.get' method");
-
-test(() => {
-    const setDesc = Object.getOwnPropertyDescriptor(tableProto, 'set');
-    assert_equals(typeof setDesc.value, "function");
-    assert_equals(setDesc.enumerable, false);
-    assert_equals(setDesc.configurable, true);
-}, "'WebAssembly.Table.prototype.set' data property");
-
-test(() => {
-    const setDesc = Object.getOwnPropertyDescriptor(tableProto, 'set');
-    const set = setDesc.value;
-    assert_equals(set.length, 2);
-    assertThrows(() => set.call(), TypeError);
-    assertThrows(() => set.call({}), TypeError);
-    assertThrows(() => set.call(tbl1, 0), TypeError);
-    assertThrows(() => set.call(tbl1, 2, null), RangeError);
-    assertThrows(() => set.call(tbl1, -1, null), RangeError);
-    assertThrows(() => set.call(tbl1, Math.pow(2,33), null), RangeError);
-    assertThrows(() => set.call(tbl1, 0, undefined), TypeError);
-    assertThrows(() => set.call(tbl1, 0, {}), TypeError);
-    assertThrows(() => set.call(tbl1, 0, function() {}), TypeError);
-    assertThrows(() => set.call(tbl1, 0, Math.sin), TypeError);
-    assertThrows(() => set.call(tbl1, {valueOf() { throw Error("hai") }}, null), Error);
-    assert_equals(set.call(tbl1, 0, null), undefined);
-    assert_equals(set.call(tbl1, 1, null), undefined);
-}, "'WebAssembly.Table.prototype.set' method");
-
-test(() => {
-    const tblGrowDesc = Object.getOwnPropertyDescriptor(tableProto, 'grow');
-    assert_equals(typeof tblGrowDesc.value, "function");
-    assert_equals(tblGrowDesc.enumerable, false);
-    assert_equals(tblGrowDesc.configurable, true);
-}, "'WebAssembly.Table.prototype.grow' data property");
-
-test(() => {
-    const tblGrowDesc = Object.getOwnPropertyDescriptor(tableProto, 'grow');
-    const tblGrow = tblGrowDesc.value;
-    assert_equals(tblGrow.length, 1);
-    assertThrows(() => tblGrow.call(), TypeError);
-    assertThrows(() => tblGrow.call({}), TypeError);
-    assertThrows(() => tblGrow.call(tbl1, -1), RangeError);
-    assertThrows(() => tblGrow.call(tbl1, Math.pow(2,32)), RangeError);
-    var tbl = new Table({element:"anyfunc", initial:1, maximum:2});
-    assert_equals(tbl.length, 1);
-    assert_equals(tbl.grow(0), 1);
-    assert_equals(tbl.length, 1);
-    assert_equals(tbl.grow(1), 1);
-    assert_equals(tbl.length, 2);
-    assertThrows(() => tbl.grow(1), Error);
-}, "'WebAssembly.Table.prototype.grow' method");
-
-test(() => {
-    const globalDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Global');
-    assert_equals(typeof globalDesc.value, "function");
-    assert_equals(globalDesc.writable, true);
-    assert_equals(globalDesc.enumerable, false);
-    assert_equals(globalDesc.configurable, true);
-    Global = WebAssembly.Global;
-}, "'WebAssembly.Global' data property");
-
-test(() => {
-    const globalDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'Global');
-    assert_equals(Global, globalDesc.value);
-    assert_equals(Global.length, 1);
-    assert_equals(Global.name, "Global");
-    assertThrows(() => Global(), TypeError);
-    assertThrows(() => new Global(1), TypeError);
-    assertThrows(() => new Global({}), TypeError);
-    assertThrows(() => new Global({value: 'foo'}), TypeError);
-    assertThrows(() => new Global({value: 'i64'}), TypeError);
-    assert_equals(new Global({value:'i32'}) instanceof Global, true);
-    assert_equals(new Global({value:'f32'}) instanceof Global, true);
-    assert_equals(new Global({value:'f64'}) instanceof Global, true);
-    assert_equals(new Global({value:'i32', mutable: false}) instanceof Global, true);
-    assert_equals(new Global({value:'f64', mutable: false}) instanceof Global, true);
-    assert_equals(new Global({value:'f64', mutable: false}) instanceof Global, true);
-    assert_equals(new Global({value:'i32', mutable: true}) instanceof Global, true);
-    assert_equals(new Global({value:'f64', mutable: true}) instanceof Global, true);
-    assert_equals(new Global({value:'f64', mutable: true}) instanceof Global, true);
-    assert_equals(new Global({value:'i32'}, 0x132) instanceof Global, true);
-    assert_equals(new Global({value:'f32'}, 0xf32) instanceof Global, true);
-    assert_equals(new Global({value:'f64'}, 0xf64) instanceof Global, true);
-    assert_equals(new Global({value:'i32', mutable: false}, 0x132) instanceof Global, true);
-    assert_equals(new Global({value:'f32', mutable: false}, 0xf32) instanceof Global, true);
-    assert_equals(new Global({value:'f64', mutable: false}, 0xf64) instanceof Global, true);
-    assert_equals(new Global({value:'i32', mutable: true}, 0x132) instanceof Global, true);
-    assert_equals(new Global({value:'f32', mutable: true}, 0xf32) instanceof Global, true);
-    assert_equals(new Global({value:'f64', mutable: true}, 0xf64) instanceof Global, true);
-}, "'WebAssembly.Global' constructor function");
-
-test(() => {
-    const globalProtoDesc = Object.getOwnPropertyDescriptor(Global, 'prototype');
-    assert_equals(typeof globalProtoDesc.value, "object");
-    assert_equals(globalProtoDesc.writable, false);
-    assert_equals(globalProtoDesc.enumerable, false);
-    assert_equals(globalProtoDesc.configurable, false);
-}, "'WebAssembly.Global.prototype' data property");
-
-test(() => {
-    const globalProtoDesc = Object.getOwnPropertyDescriptor(Global, 'prototype');
-    globalProto = Global.prototype;
-    assert_equals(globalProto, globalProtoDesc.value);
-    assert_equals(String(globalProto), "[object WebAssembly.Global]");
-    assert_equals(Object.getPrototypeOf(globalProto), Object.prototype);
-}, "'WebAssembly.Global.prototype' object");
-
-test(() => {
-    globalI32 = new Global({value: 'i32'}, 0x132);
-    globalF32 = new Global({value: 'f32'}, 0xf32);
-    globalF64 = new Global({value: 'f64'}, 0xf64);
-    globalI32Mut = new Global({value: 'i32', mutable: true}, 0x132);
-    globalF32Mut = new Global({value: 'f32', mutable: true}, 0xf32);
-    globalF64Mut = new Global({value: 'f64', mutable: true}, 0xf64);
-    assert_equals(typeof globalI32, "object");
-    assert_equals(String(globalI32), "[object WebAssembly.Global]");
-    assert_equals(Object.getPrototypeOf(globalI32), globalProto);
-}, "'WebAssembly.Global' instance objects");
-
-test(() => {
-    let builder = new WasmModuleBuilder();
-    builder.addGlobal(kWasmI32).exportAs('i32');
-    builder.addGlobal(kWasmI64).exportAs('i64');
-    builder.addGlobal(kWasmF32).exportAs('f32');
-    builder.addGlobal(kWasmF64).exportAs('f64');
-    builder.addGlobal(kWasmI32, true).exportAs('i32mut');
-    builder.addGlobal(kWasmI64, true).exportAs('i64mut');
-    builder.addGlobal(kWasmF32, true).exportAs('f32mut');
-    builder.addGlobal(kWasmF64, true).exportAs('f64mut');
-    let module = new WebAssembly.Module(builder.toBuffer());
-    let instance = new WebAssembly.Instance(module);
-
-    assert_true(instance.exports.i32 instanceof WebAssembly.Global);
-    assert_true(instance.exports.i64 instanceof WebAssembly.Global);
-    assert_true(instance.exports.f32 instanceof WebAssembly.Global);
-    assert_true(instance.exports.f64 instanceof WebAssembly.Global);
-    assert_true(instance.exports.i32mut instanceof WebAssembly.Global);
-    assert_true(instance.exports.i64mut instanceof WebAssembly.Global);
-    assert_true(instance.exports.f32mut instanceof WebAssembly.Global);
-    assert_true(instance.exports.f64mut instanceof WebAssembly.Global);
-
-    // Can't set value of immutable globals.
-    assertThrows(() => instance.exports.i32.value = 0, TypeError);
-    assertThrows(() => instance.exports.i64.value = 0, TypeError);
-    assertThrows(() => instance.exports.f32.value = 0, TypeError);
-    assertThrows(() => instance.exports.f64.value = 0, TypeError);
-
-    instance.exports.i32mut.value = 13579;
-    instance.exports.f32mut.value = 24680;
-    instance.exports.f64mut.value = 124816;
-
-    globalI64 = instance.exports.i64;
-    globalI64Mut = instance.exports.i64mut;
-}, "Export 'WebAssembly.Global'");
-
-test(() => {
-    const lengthDesc = Object.getOwnPropertyDescriptor(globalProto, 'value');
-    assert_equals(typeof lengthDesc.get, "function");
-    assert_equals(typeof lengthDesc.set, "function");
-    assert_equals(lengthDesc.enumerable, false);
-    assert_equals(lengthDesc.configurable, true);
-}, "'WebAssembly.Global.prototype.value' accessor data property");
-
-test(() => {
-    const valueDesc = Object.getOwnPropertyDescriptor(globalProto, 'value');
-    const valueGetter = valueDesc.get;
-    assert_equals(valueGetter.length, 0);
-    assertThrows(() => valueGetter.call(), TypeError);
-    assertThrows(() => valueGetter.call({}), TypeError);
-
-    assert_equals(typeof valueGetter.call(globalI32), "number");
-    assertThrows(() => valueGetter.call(globalI64), TypeError);
-    assert_equals(typeof valueGetter.call(globalF32), "number");
-    assert_equals(typeof valueGetter.call(globalF64), "number");
-    assert_equals(typeof valueGetter.call(globalI32Mut), "number");
-    assertThrows(() => valueGetter.call(globalI64Mut), TypeError);
-    assert_equals(typeof valueGetter.call(globalF32Mut), "number");
-    assert_equals(typeof valueGetter.call(globalF64Mut), "number");
-
-    assert_equals(valueGetter.call(globalI32), 0x132);
-    assert_equals(valueGetter.call(globalF32), 0xf32);
-    assert_equals(valueGetter.call(globalF64), 0xf64);
-    assert_equals(valueGetter.call(globalI32Mut), 0x132);
-    assert_equals(valueGetter.call(globalF32Mut), 0xf32);
-    assert_equals(valueGetter.call(globalF64Mut), 0xf64);
-}, "'WebAssembly.Global.prototype.value' getter");
-
-test(() => {
-    const valueDesc = Object.getOwnPropertyDescriptor(globalProto, 'value');
-    const valueSetter = valueDesc.set;
-    assert_equals(valueSetter.length, 1);
-    assertThrows(() => valueSetter.call(), TypeError);
-    assertThrows(() => valueSetter.call({}), TypeError);
-
-    assertThrows(() => valueSetter.call(globalI32, 1234), TypeError);
-    assertThrows(() => valueSetter.call(globalI64, 1234), TypeError);
-    assertThrows(() => valueSetter.call(globalF32, 1234), TypeError);
-    assertThrows(() => valueSetter.call(globalF64, 1234), TypeError);
-
-    valueSetter.call(globalI32Mut, 1234);
-    assertThrows(() => valueSetter.call(globalI64Mut, 1234), TypeError);
-    valueSetter.call(globalF32Mut, 5678);
-    valueSetter.call(globalF64Mut, 9012);
-
-    assert_equals(globalI32Mut.value, 1234);
-    assert_equals(globalF32Mut.value, 5678);
-    assert_equals(globalF64Mut.value, 9012);
-}, "'WebAssembly.Global.prototype.value' setter");
-
-test(() => {
-    const valueOfDesc = Object.getOwnPropertyDescriptor(globalProto, 'valueOf');
-    assert_equals(typeof valueOfDesc.value, "function");
-    assert_equals(valueOfDesc.enumerable, false);
-    assert_equals(valueOfDesc.configurable, true);
-}, "'WebAssembly.Global.prototype.valueOf' data property");
-
-test(() => {
-    const valueOfDesc = Object.getOwnPropertyDescriptor(globalProto, 'valueOf');
-    const valueOf = valueOfDesc.value;
-    assert_equals(valueOf.length, 0);
-    assertThrows(() => valueOf.call(), TypeError);
-    assertThrows(() => valueOf.call({}), TypeError);
-
-    assert_equals(valueOf.call(globalI32), 0x132);
-    assertThrows(() => valueOf.call(globalI64), TypeError);
-    assert_equals(valueOf.call(globalF32), 0xf32);
-    assert_equals(valueOf.call(globalF64), 0xf64);
-    assert_equals(valueOf.call(globalI32Mut), 1234);
-    assertThrows(() => valueOf.call(globalI64Mut), TypeError);
-    assert_equals(valueOf.call(globalF32Mut), 5678);
-    assert_equals(valueOf.call(globalF64Mut), 9012);
-}, "'WebAssembly.Global.prototype.valueOf' method");
-
-test(() => {
-    assert_equals(new Global({value: 'i32'}).value, 0);
-    assert_equals(new Global({value: 'f32'}).value, 0);
-    assert_equals(new Global({value: 'f64'}).value, 0);
-}, "'WebAssembly.Global' default value is 0");
-
-test(() => {
-    let builder = new WasmModuleBuilder();
-    builder.addImportedGlobal('', 'i32', kWasmI32);
-    builder.addImportedGlobal('', 'i64', kWasmI64);
-    builder.addImportedGlobal('', 'f32', kWasmF32);
-    builder.addImportedGlobal('', 'f64', kWasmF64);
-    builder.addImportedGlobal('', 'i32mut', kWasmI32, true);
-    builder.addImportedGlobal('', 'i64mut', kWasmI64, true);
-    builder.addImportedGlobal('', 'f32mut', kWasmF32, true);
-    builder.addImportedGlobal('', 'f64mut', kWasmF64, true);
-    let module = new WebAssembly.Module(builder.toBuffer());
-    let instance = new WebAssembly.Instance(module, {
-        '': {
-          i32: globalI32,
-          i64: globalI64,
-          f32: globalF32,
-          f64: globalF64,
-          i32mut: globalI32Mut,
-          i64mut: globalI64Mut,
-          f32mut: globalF32Mut,
-          f64mut: globalF64Mut
-        }
-    });
-}, "Import 'WebAssembly.Global'");
-
-test(() => {
-    let assertInstanceError = (type, mutable, imports) => {
-      assertThrows(() => {
-        let builder = new WasmModuleBuilder();
-        builder.addImportedGlobal('', 'g', type, mutable);
-        let module = new WebAssembly.Module(builder.toBuffer());
-        let instance = new WebAssembly.Instance(module, imports);
-      }, LinkError);
-    };
-
-    const immutable = false, mutable = true;
-
-    // Type mismatch.
-    assertInstanceError(kWasmI32, immutable, {'': {g: globalI64}});
-    assertInstanceError(kWasmI32, immutable, {'': {g: globalF32}});
-    assertInstanceError(kWasmI32, immutable, {'': {g: globalF64}});
-    assertInstanceError(kWasmI64, immutable, {'': {g: globalI32}});
-    assertInstanceError(kWasmI64, immutable, {'': {g: globalF32}});
-    assertInstanceError(kWasmI64, immutable, {'': {g: globalF64}});
-    assertInstanceError(kWasmF32, immutable, {'': {g: globalI32}});
-    assertInstanceError(kWasmF32, immutable, {'': {g: globalI64}});
-    assertInstanceError(kWasmF32, immutable, {'': {g: globalF64}});
-    assertInstanceError(kWasmF64, immutable, {'': {g: globalI32}});
-    assertInstanceError(kWasmF64, immutable, {'': {g: globalI64}});
-    assertInstanceError(kWasmF64, immutable, {'': {g: globalF32}});
-
-    assertInstanceError(kWasmI32, mutable, {'': {g: globalI64Mut}});
-    assertInstanceError(kWasmI32, mutable, {'': {g: globalF32Mut}});
-    assertInstanceError(kWasmI32, mutable, {'': {g: globalF64Mut}});
-    assertInstanceError(kWasmI64, mutable, {'': {g: globalI32Mut}});
-    assertInstanceError(kWasmI64, mutable, {'': {g: globalF32Mut}});
-    assertInstanceError(kWasmI64, mutable, {'': {g: globalF64Mut}});
-    assertInstanceError(kWasmF32, mutable, {'': {g: globalI32Mut}});
-    assertInstanceError(kWasmF32, mutable, {'': {g: globalI64Mut}});
-    assertInstanceError(kWasmF32, mutable, {'': {g: globalF64Mut}});
-    assertInstanceError(kWasmF64, mutable, {'': {g: globalI32Mut}});
-    assertInstanceError(kWasmF64, mutable, {'': {g: globalI64Mut}});
-    assertInstanceError(kWasmF64, mutable, {'': {g: globalF32Mut}});
-
-    // Mutable mismatch.
-    assertInstanceError(kWasmI32, immutable, {'': {g: globalI32Mut}});
-    assertInstanceError(kWasmI64, immutable, {'': {g: globalI64Mut}});
-    assertInstanceError(kWasmF32, immutable, {'': {g: globalF32Mut}});
-    assertInstanceError(kWasmF64, immutable, {'': {g: globalF64Mut}});
-
-    assertInstanceError(kWasmI32, mutable, {'': {g: globalI32}});
-    assertInstanceError(kWasmI64, mutable, {'': {g: globalI64}});
-    assertInstanceError(kWasmF32, mutable, {'': {g: globalF32}});
-    assertInstanceError(kWasmF64, mutable, {'': {g: globalF64}});
-
-    // Can't import Number as mutable.
-    assertInstanceError(kWasmI32, mutable, {'': {g: 1}});
-    assertInstanceError(kWasmI64, mutable, {'': {g: 1}});
-    assertInstanceError(kWasmF32, mutable, {'': {g: 1}});
-    assertInstanceError(kWasmF64, mutable, {'': {g: 1}});
-}, "Import 'WebAssembly.Global' type mismatch");
-
-test(() => {
-    assertThrows(() => WebAssembly.validate(), TypeError);
-    assertThrows(() => WebAssembly.validate("hi"), TypeError);
-    assert_true(WebAssembly.validate(emptyModuleBinary));
-    assert_true(WebAssembly.validate(complexImportingModuleBinary));
-    assert_false(WebAssembly.validate(moduleBinaryImporting2Memories));
-    assert_false(WebAssembly.validate(moduleBinaryWithMemSectionAndMemImport));
-}, "'WebAssembly.validate' method");
-
-test(() => {
-    const compileDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'compile');
-    assert_equals(typeof compileDesc.value, "function");
-    assert_equals(compileDesc.writable, true);
-    assert_equals(compileDesc.enumerable, false);
-    assert_equals(compileDesc.configurable, true);
-}, "'WebAssembly.compile' data property");
-
-test(() => {
-    const compile = WebAssembly.compile;
-    const compileDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'compile');
-
-    assert_equals(compile, compileDesc.value);
-    assert_equals(compile.length, 1);
-    assert_equals(compile.name, "compile");
-}, "'WebAssembly.compile' function");
-
-var num_tests = 1;
-function assertCompileError(args, err) {
-    promise_test(() => {
-        return WebAssembly.compile(...args)
-        .then(_ => {
-            throw null;
-        })
-        .catch(error => {
-            assert_equals(error instanceof err, true);
-            return Promise.resolve()
-        });
-    }, `assertCompileError ${num_tests++}`);
-}
-
-assertCompileError([], TypeError);
-assertCompileError([undefined], TypeError);
-assertCompileError([1], TypeError);
-assertCompileError([{}], TypeError);
-assertCompileError([new Uint8Array()], CompileError);
-assertCompileError([new ArrayBuffer()], CompileError);
-assertCompileError([kC0DEFEFE], CompileError);
-
-num_tests = 1;
-function assertCompileSuccess(bytes) {
-    promise_test(() => {
-        return WebAssembly.compile(bytes)
-        .then(module => {
-            assert_equals(module instanceof Module, true);
-        });
-    }, `assertCompileSuccess ${num_tests++}`);
-}
-
-assertCompileSuccess(emptyModuleBinary);
-assertCompileSuccess(new Uint8Array(emptyModuleBinary));
-
-test(() => {
-    const instantiateDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'instantiate');
-    assert_equals(typeof instantiateDesc.value, "function");
-    assert_equals(instantiateDesc.writable, true);
-    assert_equals(instantiateDesc.enumerable, false);
-    assert_equals(instantiateDesc.configurable, true);
-}, "'WebAssembly.instantiate' data property");
-
-test(() => {
-    const instantiateDesc = Object.getOwnPropertyDescriptor(WebAssembly, 'instantiate');
-    const instantiate = WebAssembly.instantiate;
-    assert_equals(instantiate, instantiateDesc.value);
-    assert_equals(instantiate.length, 1);
-    assert_equals(instantiate.name, "instantiate");
-    function assertInstantiateError(args, err) {
-        promise_test(() => {
-            return instantiate(...args)
-                .then(m => {
-                    throw null;
-                })
-                .catch(error => {
-                    assert_equals(error instanceof err, true);
-                })
-        }, 'unexpected success in assertInstantiateError');
-    }
-    var scratch_memory = new WebAssembly.Memory({initial:1});
-    var scratch_table = new WebAssembly.Table({element:"anyfunc", initial:1, maximum:1});
-    assertInstantiateError([], TypeError);
-    assertInstantiateError([undefined], TypeError);
-    assertInstantiateError([1], TypeError);
-    assertInstantiateError([{}], TypeError);
-    assertInstantiateError([new Uint8Array()], CompileError);
-    assertInstantiateError([new ArrayBuffer()], CompileError);
-    assertInstantiateError([kC0DEFEFE], CompileError);
-    assertInstantiateError([importingModule], TypeError);
-    assertInstantiateError([importingModule, null], TypeError);
-    assertInstantiateError([importingModuleBinary, null], TypeError);
-    assertInstantiateError([emptyModule, null], TypeError);
-    assertInstantiateError([importingModuleBinary, null], TypeError);
-    assertInstantiateError([importingModuleBinary, undefined], TypeError);
-    assertInstantiateError([importingModuleBinary, {}], TypeError);
-    assertInstantiateError([importingModuleBinary, {"":{g:()=>{}}}], LinkError);
-    assertInstantiateError([importingModuleBinary, {t:{f:()=>{}}}], TypeError);
-    assertInstantiateError([complexImportingModuleBinary, null], TypeError);
-    assertInstantiateError([complexImportingModuleBinary, undefined], TypeError);
-    assertInstantiateError([complexImportingModuleBinary, {}], TypeError);
-    assertInstantiateError([complexImportingModuleBinary, {"c": {"d": scratch_memory}}], TypeError);
-
-    function assertInstantiateSuccess(module, imports) {
-        promise_test(()=> {
-            return instantiate(module, imports)
-                .then(result => {
-                    if (module instanceof Module) {
-                        assert_equals(result instanceof Instance, true);
-                    } else {
-                        assert_equals(result.module instanceof Module, true);
-                        assert_equals(result.instance instanceof Instance, true);
-                        var desc = Object.getOwnPropertyDescriptor(result, 'module');
-                        assert_equals(desc.writable, true);
-                        assert_equals(desc.enumerable, true);
-                        assert_equals(desc.configurable, true);
-                        desc = Object.getOwnPropertyDescriptor(result, 'instance');
-                        assert_equals(desc.writable, true);
-                        assert_equals(desc.enumerable, true);
-                        assert_equals(desc.configurable, true);
-                    }
-                })}, 'unexpected failure in assertInstantiateSuccess');
-    }
-    assertInstantiateSuccess(emptyModule);
-    assertInstantiateSuccess(emptyModuleBinary);
-    assertInstantiateSuccess(new Uint8Array(emptyModuleBinary));
-    assertInstantiateSuccess(importingModule, {"":{f:()=>{}}});
-    assertInstantiateSuccess(importingModuleBinary, {"":{f:()=>{}}});
-    assertInstantiateSuccess(new Uint8Array(importingModuleBinary), {"":{f:()=>{}}});
-    assertInstantiateSuccess(complexImportingModuleBinary, {
-        a:{b:()=>{}},
-        c:{d:scratch_memory},
-        e:{f:scratch_table},
-        g:{'⚡':1}});
-}, "'WebAssembly.instantiate' function");
-
-const complexReExportingModuleBinary = (() => {
-    let builder = new WasmModuleBuilder();
-
-    let fIndex = builder.addImport('a', 'f', kSig_i_i);
-    let gIndex = builder.addImport('a', 'g', kSig_i_v);
-    builder.addImportedMemory('c', 'd');
-    builder.addImportedTable('e', 'f');
-
-    builder.addExport('x', fIndex)
-    builder.addExport('y', gIndex)
-    builder.addExportOfKind('z', kExternalMemory, 0)
-    builder.addExportOfKind('w', kExternalTable, 0)
-
-    return builder.toBuffer();
-})();
-
-const complexTableReExportingModuleBinary = (() => {
-    let builder = new WasmModuleBuilder();
-
-    builder.addImport('a', '_', kSig_v_v);
-    let gIndex = builder.addImport('a', 'g', kSig_i_v);
-    let fIndex = builder.addImport('a', 'f', kSig_i_i);
-    let hIndex = builder
-        .addFunction('h', kSig_i_v)
-        .addBody([
-            kExprI32Const,
-            46
-        ]).index;
-
-    builder.appendToTable([fIndex, gIndex, hIndex]);
-    builder.addExportOfKind('tab', kExternalTable, 0);
-
-    return builder.toBuffer();
-})();
-
-
-test(() => {
-  let module = new WebAssembly.Module(complexReExportingModuleBinary);
-  let memory = new WebAssembly.Memory({initial: 0});
-  let table = new WebAssembly.Table({initial: 0, element: 'anyfunc'});
-  let imports = {
-    a: { f(x) { return x+1; }, g: exportingInstance.exports.f },
-    c: { d: memory },
-    e: { f: table },
-  };
-  let instance = reExportingInstance =
-      new WebAssembly.Instance(module, imports);
-
-  assert_equals(instance.exports.x.name, "0");
-  assert_false(instance.exports.x === imports.a.f);
-
-  // Previously exported Wasm functions are re-exported with the same value
-  assert_equals(instance.exports.y, exportingInstance.exports.f);
-  assert_equals(instance.exports.y.name, "0");
-
-  // Re-exported Memory and Table objects have the same value
-  assert_equals(instance.exports.z, memory);
-  assert_equals(instance.exports.w, table);
-
-  // Importing the same JS function object results in a distinct exported
-  // function object, whereas previously exported Wasm functions are
-  // re-exported with the same identity.
-  let instance2 = new WebAssembly.Instance(module, imports);
-  assert_false(instance.exports.x === instance2.exports.x);
-  assert_equals(instance.exports.y, instance2.exports.y);
-}, "Exported values have cached JS objects");
-
-test(() => {
-  let module = new WebAssembly.Module(complexTableReExportingModuleBinary);
-  let instance = new WebAssembly.Instance(module,
-      { a: { _() { }, f: reExportingInstance.exports.x,
-             g: exportingInstance.exports.f } });
-  let table = instance.exports.tab;
-
-  // The functions that were put in come right back out
-  assert_equals(table.get(0), reExportingInstance.exports.x);
-  assert_equals(table.get(1), exportingInstance.exports.f);
-
-  // The original function indices are reflected in the name
-  assert_equals(table.get(0).name, "0");
-  assert_equals(table.get(1).name, "0");
-  assert_equals(table.get(2).name, "3");
-
-  // All of the functions work
-  assert_equals(table.get(0)(5), 6);
-  assert_equals(table.get(1)(), 42);
-  assert_equals(table.get(2)(), 46);
-}, "Tables export cached");
-
-test(() => {
-  let module = new WebAssembly.Module(exportingModuleIdentityFn );
-  let instance = new WebAssembly.Instance(module);
-
-  let value = 2 ** 31;
-  let output = instance.exports.id(value);
-  assert_equals(output, - (2 ** 31));
-}, "WebAssembly integers are converted to JavaScript as if by ToInt32");
-
-})();
diff --git a/test/js-api/memory/buffer.any.js b/test/js-api/memory/buffer.any.js
new file mode 100644
index 000000000..4788ffcf8
--- /dev/null
+++ b/test/js-api/memory/buffer.any.js
@@ -0,0 +1,64 @@
+// META: global=jsshell
+
+test(() => {
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Memory,
+    WebAssembly.Memory.prototype,
+  ];
+
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Memory.prototype, "buffer");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  assert_equals(typeof desc.set, "undefined");
+
+  for (const thisValue of thisValues) {
+    assert_throws(new TypeError(), () => getter.call(thisValue), `this=${format_value(thisValue)}`);
+  }
+}, "Branding");
+
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument);
+  const buffer = memory.buffer;
+
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Memory.prototype, "buffer");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  assert_equals(getter.call(memory, {}), buffer);
+}, "Stray argument");
+
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument);
+  const memory2 = new WebAssembly.Memory(argument);
+  const buffer = memory.buffer;
+  assert_not_equals(buffer, memory2.buffer, "Need two distinct buffers");
+  memory.buffer = memory2.buffer;
+  assert_equals(memory.buffer, buffer, "Should not change the buffer");
+}, "Setting (sloppy mode)");
+
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument);
+  const memory2 = new WebAssembly.Memory(argument);
+  const buffer = memory.buffer;
+  assert_not_equals(buffer, memory2.buffer, "Need two distinct buffers");
+  assert_throws(new TypeError(), () => {
+    "use strict";
+    memory.buffer = memory2.buffer;
+  });
+  assert_equals(memory.buffer, buffer, "Should not change the buffer");
+}, "Setting (strict mode)");
diff --git a/test/js-api/memory/constructor.any.js b/test/js-api/memory/constructor.any.js
new file mode 100644
index 000000000..a584a23ec
--- /dev/null
+++ b/test/js-api/memory/constructor.any.js
@@ -0,0 +1,147 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/assertions.js
+
+function assert_Memory(memory, expected) {
+  assert_equals(Object.getPrototypeOf(memory), WebAssembly.Memory.prototype,
+                "prototype");
+  assert_true(Object.isExtensible(memory), "extensible");
+
+  // https://github.com/WebAssembly/spec/issues/840
+  assert_equals(memory.buffer, memory.buffer, "buffer should be idempotent");
+  assert_equals(Object.getPrototypeOf(memory.buffer), ArrayBuffer.prototype,
+                "prototype of buffer");
+  assert_true(Object.isExtensible(memory.buffer), "buffer extensibility");
+  assert_equals(memory.buffer.byteLength, 0x10000 * expected.size, "size of buffer");
+  if (expected.size > 0) {
+    const array = new Uint8Array(memory.buffer);
+    assert_equals(array[0], 0, "first element of buffer");
+    assert_equals(array[array.byteLength - 1], 0, "last element of buffer");
+  }
+}
+
+test(() => {
+  assert_function_name(WebAssembly.Memory, "Memory", "WebAssembly.Memory");
+}, "name");
+
+test(() => {
+  assert_function_length(WebAssembly.Memory, 1, "WebAssembly.Memory");
+}, "length");
+
+test(() => {
+  assert_throws(new TypeError(), () => new WebAssembly.Memory());
+}, "No arguments");
+
+test(() => {
+  const argument = { "initial": 0 };
+  assert_throws(new TypeError(), () => WebAssembly.Memory(argument));
+}, "Calling");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    false,
+    true,
+    "",
+    "test",
+    Symbol(),
+    1,
+    NaN,
+    {},
+  ];
+  for (const invalidArgument of invalidArguments) {
+    assert_throws(new TypeError(),
+                  () => new WebAssembly.Memory(invalidArgument),
+                  `new Memory(${format_value(invalidArgument)})`);
+  }
+}, "Invalid descriptor argument");
+
+test(() => {
+  assert_throws(new TypeError(), () => new WebAssembly.Memory({ "initial": undefined }));
+}, "Undefined initial value in descriptor");
+
+const outOfRangeValues = [
+  NaN,
+  Infinity,
+  -Infinity,
+  -1,
+  0x100000000,
+  0x1000000000,
+];
+
+for (const value of outOfRangeValues) {
+  test(() => {
+    assert_throws(new TypeError(), () => new WebAssembly.Memory({ "initial": value }));
+  }, `Out-of-range initial value in descriptor: ${format_value(value)}`);
+
+  test(() => {
+    assert_throws(new TypeError(), () => new WebAssembly.Memory({ "initial": 0, "maximum": value }));
+  }, `Out-of-range maximum value in descriptor: ${format_value(value)}`);
+}
+
+test(() => {
+  assert_throws(new RangeError(), () => new WebAssembly.Memory({ "element": "anyfunc", "initial": 10, "maximum": 9 }));
+}, "Initial value exceeds maximum");
+
+test(() => {
+  const proxy = new Proxy({}, {
+    has(o, x) {
+      assert_unreached(`Should not call [[HasProperty]] with ${x}`);
+    },
+    get(o, x) {
+      return 0;
+    },
+  });
+  new WebAssembly.Memory(proxy);
+}, "Proxy descriptor");
+
+test(() => {
+  const order = [];
+
+  new WebAssembly.Memory({
+    get maximum() {
+      order.push("maximum");
+      return {
+        valueOf() {
+          order.push("maximum valueOf");
+          return 1;
+        },
+      };
+    },
+
+    get initial() {
+      order.push("initial");
+      return {
+        valueOf() {
+          order.push("initial valueOf");
+          return 1;
+        },
+      };
+    },
+  });
+
+  assert_array_equals(order, [
+    "initial",
+    "initial valueOf",
+    "maximum",
+    "maximum valueOf",
+  ]);
+}, "Order of evaluation for descriptor");
+
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument);
+  assert_Memory(memory, { "size": 0 });
+}, "Zero initial");
+
+test(() => {
+  const argument = { "initial": 4 };
+  const memory = new WebAssembly.Memory(argument);
+  assert_Memory(memory, { "size": 4 });
+}, "Non-zero initial");
+
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument, {});
+  assert_Memory(memory, { "size": 0 });
+}, "Stray argument");
diff --git a/test/js-api/memory/grow.any.js b/test/js-api/memory/grow.any.js
new file mode 100644
index 000000000..1ccfb9467
--- /dev/null
+++ b/test/js-api/memory/grow.any.js
@@ -0,0 +1,185 @@
+// META: global=jsshell
+
+function assert_ArrayBuffer(actual, expected, message) {
+  // https://github.com/WebAssembly/spec/issues/840
+  assert_equals(Object.getPrototypeOf(actual), ArrayBuffer.prototype,
+                `${message}: prototype`);
+  if (expected.detached) {
+    // https://github.com/tc39/ecma262/issues/678
+    let byteLength;
+    try {
+      byteLength = actual.byteLength;
+    } catch (e) {
+      byteLength = 0;
+    }
+    assert_equals(byteLength, 0, `${message}: detached size`);
+  } else {
+    assert_equals(actual.byteLength, 0x10000 * expected.size, `${message}: size`);
+    if (expected.size > 0) {
+      const array = new Uint8Array(actual);
+      assert_equals(array[0], 0, `${message}: first element`);
+      assert_equals(array[array.byteLength - 1], 0, `${message}: last element`);
+    }
+  }
+}
+
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument);
+  assert_throws(new TypeError(), () => memory.grow());
+}, "Missing arguments");
+
+test(t => {
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Memory,
+    WebAssembly.Memory.prototype,
+  ];
+
+  const argument = {
+    valueOf: t.unreached_func("Should not touch the argument (valueOf)"),
+    toString: t.unreached_func("Should not touch the argument (toString)"),
+  };
+
+  const fn = WebAssembly.Memory.prototype.grow;
+
+  for (const thisValue of thisValues) {
+    assert_throws(new TypeError(), () => fn.call(thisValue, argument), `this=${format_value(thisValue)}`);
+  }
+}, "Branding");
+
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
+
+  const result = memory.grow(2);
+  assert_equals(result, 0);
+
+  const newMemory = memory.buffer;
+  assert_not_equals(oldMemory, newMemory);
+  assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
+  assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
+}, "Zero initial");
+
+test(() => {
+  const argument = { "initial": { valueOf() { return 0 } } };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
+
+  const result = memory.grow({ valueOf() { return 2 } });
+  assert_equals(result, 0);
+
+  const newMemory = memory.buffer;
+  assert_not_equals(oldMemory, newMemory);
+  assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
+  assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
+}, "Zero initial with valueOf");
+
+test(() => {
+  const argument = { "initial": 3 };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 3 }, "Buffer before growing");
+
+  const result = memory.grow(2);
+  assert_equals(result, 3);
+
+  const newMemory = memory.buffer;
+  assert_not_equals(oldMemory, newMemory);
+  assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
+  assert_ArrayBuffer(newMemory, { "size": 5 }, "New buffer after growing");
+}, "Non-zero initial");
+
+test(() => {
+  const argument = { "initial": 0, "maximum": 2 };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
+
+  const result = memory.grow(2);
+  assert_equals(result, 0);
+
+  const newMemory = memory.buffer;
+  assert_not_equals(oldMemory, newMemory);
+  assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
+  assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
+}, "Zero initial with respected maximum");
+
+test(() => {
+  const argument = { "initial": 0, "maximum": 2 };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
+
+  const result = memory.grow(1);
+  assert_equals(result, 0);
+
+  const newMemory = memory.buffer;
+  assert_not_equals(oldMemory, newMemory);
+  assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing once");
+  assert_ArrayBuffer(newMemory, { "size": 1 }, "New buffer after growing once");
+
+  const result2 = memory.grow(1);
+  assert_equals(result2, 1);
+
+  const newestMemory = memory.buffer;
+  assert_not_equals(newMemory, newestMemory);
+  assert_ArrayBuffer(oldMemory, { "detached": true }, "New buffer after growing twice");
+  assert_ArrayBuffer(newMemory, { "detached": true }, "New buffer after growing twice");
+  assert_ArrayBuffer(newestMemory, { "size": 2 }, "Newest buffer after growing twice");
+}, "Zero initial with respected maximum grown twice");
+
+test(() => {
+  const argument = { "initial": 1, "maximum": 2 };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 1 }, "Buffer before growing");
+
+  assert_throws(new RangeError(), () => memory.grow(2));
+  assert_equals(memory.buffer, oldMemory);
+  assert_ArrayBuffer(memory.buffer, { "size": 1 }, "Buffer before trying to grow");
+}, "Zero initial growing too much");
+
+const outOfRangeValues = [
+  undefined,
+  NaN,
+  Infinity,
+  -Infinity,
+  -1,
+  0x100000000,
+  0x1000000000,
+  "0x100000000",
+  { valueOf() { return 0x100000000; } },
+];
+
+for (const value of outOfRangeValues) {
+  test(() => {
+    const argument = { "initial": 0 };
+    const memory = new WebAssembly.Memory(argument);
+    assert_throws(new TypeError(), () => memory.grow(value));
+  }, `Out-of-range argument: ${format_value(value)}`);
+}
+
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument);
+  const oldMemory = memory.buffer;
+  assert_ArrayBuffer(oldMemory, { "size": 0 }, "Buffer before growing");
+
+  const result = memory.grow(2, {});
+  assert_equals(result, 0);
+
+  const newMemory = memory.buffer;
+  assert_not_equals(oldMemory, newMemory);
+  assert_ArrayBuffer(oldMemory, { "detached": true }, "Old buffer after growing");
+  assert_ArrayBuffer(newMemory, { "size": 2 }, "New buffer after growing");
+}, "Stray argument");
diff --git a/test/js-api/memory/toString.any.js b/test/js-api/memory/toString.any.js
new file mode 100644
index 000000000..4e15d75ea
--- /dev/null
+++ b/test/js-api/memory/toString.any.js
@@ -0,0 +1,7 @@
+// META: global=jsshell
+
+test(() => {
+  const argument = { "initial": 0 };
+  const memory = new WebAssembly.Memory(argument);
+  assert_class_string(memory, "WebAssembly.Memory");
+}, "Object.prototype.toString on an Memory");
diff --git a/test/js-api/module/constructor.any.js b/test/js-api/module/constructor.any.js
new file mode 100644
index 000000000..a467c1a17
--- /dev/null
+++ b/test/js-api/module/constructor.any.js
@@ -0,0 +1,65 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+// META: script=/wasm/jsapi/assertions.js
+
+let emptyModuleBinary;
+setup(() => {
+  emptyModuleBinary = new WasmModuleBuilder().toBuffer();
+});
+
+test(() => {
+  assert_function_name(WebAssembly.Module, "Module", "WebAssembly.Module");
+}, "name");
+
+test(() => {
+  assert_function_length(WebAssembly.Module, 1, "WebAssembly.Module");
+}, "length");
+
+test(() => {
+  assert_throws(new TypeError(), () => new WebAssembly.Module());
+}, "No arguments");
+
+test(() => {
+  assert_throws(new TypeError(), () => WebAssembly.Module(emptyModuleBinary));
+}, "Calling");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    true,
+    "test",
+    Symbol(),
+    7,
+    NaN,
+    {},
+    ArrayBuffer,
+    ArrayBuffer.prototype,
+    Array.from(emptyModuleBinary),
+  ];
+  for (const argument of invalidArguments) {
+    assert_throws(new TypeError(), () => new WebAssembly.Module(argument),
+                  `new Module(${format_value(argument)})`);
+  }
+}, "Invalid arguments");
+
+test(() => {
+  const buffer = new Uint8Array();
+  assert_throws(new WebAssembly.CompileError(), () => new WebAssembly.Module(buffer));
+}, "Empty buffer");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  assert_equals(Object.getPrototypeOf(module), WebAssembly.Module.prototype);
+}, "Prototype");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  assert_true(Object.isExtensible(module));
+}, "Extensibility");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary, {});
+  assert_equals(Object.getPrototypeOf(module), WebAssembly.Module.prototype);
+}, "Stray argument");
diff --git a/test/js-api/module/customSections.any.js b/test/js-api/module/customSections.any.js
new file mode 100644
index 000000000..04c5abed5
--- /dev/null
+++ b/test/js-api/module/customSections.any.js
@@ -0,0 +1,167 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+function assert_ArrayBuffer(buffer, expected) {
+  assert_equals(Object.getPrototypeOf(buffer), ArrayBuffer.prototype, "Prototype");
+  assert_true(Object.isExtensible(buffer), "isExtensible");
+  assert_array_equals(new Uint8Array(buffer), expected);
+}
+
+function assert_sections(sections, expected) {
+  assert_true(Array.isArray(sections), "Should be array");
+  assert_equals(Object.getPrototypeOf(sections), Array.prototype, "Prototype");
+  assert_true(Object.isExtensible(sections), "isExtensible");
+
+  assert_equals(sections.length, expected.length);
+  for (let i = 0; i < expected.length; ++i) {
+    assert_ArrayBuffer(sections[i], expected[i]);
+  }
+}
+
+let emptyModuleBinary;
+setup(() => {
+  emptyModuleBinary = new WasmModuleBuilder().toBuffer();
+});
+
+test(() => {
+  assert_throws(new TypeError(), () => WebAssembly.Module.customSections());
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  assert_throws(new TypeError(), () => WebAssembly.Module.customSections(module));
+}, "Missing arguments");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Module,
+    WebAssembly.Module.prototype,
+  ];
+  for (const argument of invalidArguments) {
+    assert_throws(new TypeError(), () => WebAssembly.Module.customSections(argument, ""),
+                  `customSections(${format_value(argument)})`);
+  }
+}, "Non-Module arguments");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const fn = WebAssembly.Module.customSections;
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Module,
+    WebAssembly.Module.prototype,
+  ];
+  for (const thisValue of thisValues) {
+    assert_sections(fn.call(thisValue, module, ""), []);
+  }
+}, "Branding");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  assert_sections(WebAssembly.Module.customSections(module, ""), []);
+}, "Empty module");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  assert_not_equals(WebAssembly.Module.customSections(module, ""),
+                    WebAssembly.Module.customSections(module, ""));
+}, "Empty module: array caching");
+
+test(() => {
+  const bytes1 = [87, 101, 98, 65, 115, 115, 101, 109, 98, 108, 121];
+  const bytes2 = [74, 83, 65, 80, 73];
+
+  const binary = new Binary;
+  binary.emit_section(kUnknownSectionCode, section => {
+    section.emit_string("name");
+    section.emit_bytes(bytes1);
+  });
+  binary.emit_section(kUnknownSectionCode, section => {
+    section.emit_string("name");
+    section.emit_bytes(bytes2);
+  });
+  binary.emit_section(kUnknownSectionCode, section => {
+    section.emit_string("foo");
+    section.emit_bytes(bytes1);
+  });
+
+  const builder = new WasmModuleBuilder();
+  builder.addExplicitSection(binary);
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+
+  assert_sections(WebAssembly.Module.customSections(module, "name"), [
+    bytes1,
+    bytes2,
+  ])
+
+  assert_sections(WebAssembly.Module.customSections(module, "foo"), [
+    bytes1,
+  ])
+
+  assert_sections(WebAssembly.Module.customSections(module, ""), [])
+  assert_sections(WebAssembly.Module.customSections(module, "\0"), [])
+  assert_sections(WebAssembly.Module.customSections(module, "name\0"), [])
+  assert_sections(WebAssembly.Module.customSections(module, "foo\0"), [])
+}, "Custom sections");
+
+test(() => {
+  const bytes = [87, 101, 98, 65, 115, 115, 101, 109, 98, 108, 121];
+  const name = "yee\uD801\uDC37eey"
+
+  const binary = new Binary;
+  binary.emit_section(kUnknownSectionCode, section => {
+    section.emit_string(name);
+    section.emit_bytes(bytes);
+  });
+
+  const builder = new WasmModuleBuilder();
+  builder.addExplicitSection(binary);
+  const buffer = builder.toBuffer();
+  const module = new WebAssembly.Module(buffer);
+
+  assert_sections(WebAssembly.Module.customSections(module, name), [
+    bytes,
+  ]);
+  assert_sections(WebAssembly.Module.customSections(module, "yee\uFFFDeey"), []);
+  assert_sections(WebAssembly.Module.customSections(module, "yee\uFFFD\uFFFDeey"), []);
+}, "Custom sections with surrogate pairs");
+
+test(() => {
+  const bytes = [87, 101, 98, 65, 115, 115, 101, 109, 98, 108, 121];
+
+  const binary = new Binary;
+  binary.emit_section(kUnknownSectionCode, section => {
+    section.emit_string("na\uFFFDme");
+    section.emit_bytes(bytes);
+  });
+
+  const builder = new WasmModuleBuilder();
+  builder.addExplicitSection(binary);
+  const buffer = builder.toBuffer();
+  const module = new WebAssembly.Module(buffer);
+
+  assert_sections(WebAssembly.Module.customSections(module, "name"), []);
+  assert_sections(WebAssembly.Module.customSections(module, "na\uFFFDme"), [
+    bytes,
+  ]);
+  assert_sections(WebAssembly.Module.customSections(module, "na\uDC01me"), [
+    bytes,
+  ]);
+}, "Custom sections with U+FFFD");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  assert_sections(WebAssembly.Module.customSections(module, "", {}), []);
+}, "Stray argument");
diff --git a/test/js-api/module/exports.any.js b/test/js-api/module/exports.any.js
new file mode 100644
index 000000000..9d95b6522
--- /dev/null
+++ b/test/js-api/module/exports.any.js
@@ -0,0 +1,136 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+let emptyModuleBinary;
+setup(() => {
+  emptyModuleBinary = new WasmModuleBuilder().toBuffer();
+});
+
+function assert_ModuleExportDescriptor(export_, expected) {
+  assert_equals(Object.getPrototypeOf(export_), Object.prototype, "Prototype");
+  assert_true(Object.isExtensible(export_), "isExtensible");
+
+  const name = Object.getOwnPropertyDescriptor(export_, "name");
+  assert_true(name.writable, "name: writable");
+  assert_true(name.enumerable, "name: enumerable");
+  assert_true(name.configurable, "name: configurable");
+  assert_equals(name.value, expected.name);
+
+  const kind = Object.getOwnPropertyDescriptor(export_, "kind");
+  assert_true(kind.writable, "kind: writable");
+  assert_true(kind.enumerable, "kind: enumerable");
+  assert_true(kind.configurable, "kind: configurable");
+  assert_equals(kind.value, expected.kind);
+}
+
+function assert_exports(exports, expected) {
+  assert_true(Array.isArray(exports), "Should be array");
+  assert_equals(Object.getPrototypeOf(exports), Array.prototype, "Prototype");
+  assert_true(Object.isExtensible(exports), "isExtensible");
+
+  assert_equals(exports.length, expected.length);
+  for (let i = 0; i < expected.length; ++i) {
+    assert_ModuleExportDescriptor(exports[i], expected[i]);
+  }
+}
+
+test(() => {
+  assert_throws(new TypeError(), () => WebAssembly.Module.exports());
+}, "Missing arguments");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Module,
+    WebAssembly.Module.prototype,
+  ];
+  for (const argument of invalidArguments) {
+    assert_throws(new TypeError(), () => WebAssembly.Module.exports(argument),
+                  `exports(${format_value(argument)})`);
+  }
+}, "Non-Module arguments");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const fn = WebAssembly.Module.exports;
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Module,
+    WebAssembly.Module.prototype,
+  ];
+  for (const thisValue of thisValues) {
+    assert_array_equals(fn.call(thisValue, module), []);
+  }
+}, "Branding");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const exports = WebAssembly.Module.exports(module);
+  assert_exports(exports, []);
+}, "Empty module");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  assert_not_equals(WebAssembly.Module.exports(module), WebAssembly.Module.exports(module));
+}, "Empty module: array caching");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder
+    .addFunction("fn", kSig_v_v)
+    .addBody([
+        kExprEnd
+    ])
+    .exportFunc();
+  builder
+    .addFunction("fn2", kSig_v_v)
+    .addBody([
+        kExprEnd
+    ])
+    .exportFunc();
+
+  builder.setFunctionTableLength(1);
+  builder.addExportOfKind("table", kExternalTable, 0);
+
+  builder.addGlobal(kWasmI32, true)
+    .exportAs("global")
+    .init = 7;
+  builder.addGlobal(kWasmF64, true)
+    .exportAs("global2")
+    .init = 1.2;
+
+  builder.addMemory(0, 256, true);
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const exports = WebAssembly.Module.exports(module);
+  const expected = [
+    { "kind": "function", "name": "fn" },
+    { "kind": "function", "name": "fn2" },
+    { "kind": "table", "name": "table" },
+    { "kind": "global", "name": "global" },
+    { "kind": "global", "name": "global2" },
+    { "kind": "memory", "name": "memory" },
+  ];
+  assert_exports(exports, expected);
+}, "exports");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const exports = WebAssembly.Module.exports(module, {});
+  assert_exports(exports, []);
+}, "Stray argument");
diff --git a/test/js-api/module/imports.any.js b/test/js-api/module/imports.any.js
new file mode 100644
index 000000000..b3bb8598b
--- /dev/null
+++ b/test/js-api/module/imports.any.js
@@ -0,0 +1,126 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+function assert_ModuleImportDescriptor(import_, expected) {
+  assert_equals(Object.getPrototypeOf(import_), Object.prototype, "Prototype");
+  assert_true(Object.isExtensible(import_), "isExtensible");
+
+  const module = Object.getOwnPropertyDescriptor(import_, "module");
+  assert_true(module.writable, "module: writable");
+  assert_true(module.enumerable, "module: enumerable");
+  assert_true(module.configurable, "module: configurable");
+  assert_equals(module.value, expected.module);
+
+  const name = Object.getOwnPropertyDescriptor(import_, "name");
+  assert_true(name.writable, "name: writable");
+  assert_true(name.enumerable, "name: enumerable");
+  assert_true(name.configurable, "name: configurable");
+  assert_equals(name.value, expected.name);
+
+  const kind = Object.getOwnPropertyDescriptor(import_, "kind");
+  assert_true(kind.writable, "kind: writable");
+  assert_true(kind.enumerable, "kind: enumerable");
+  assert_true(kind.configurable, "kind: configurable");
+  assert_equals(kind.value, expected.kind);
+}
+
+function assert_imports(imports, expected) {
+  assert_true(Array.isArray(imports), "Should be array");
+  assert_equals(Object.getPrototypeOf(imports), Array.prototype, "Prototype");
+  assert_true(Object.isExtensible(imports), "isExtensible");
+
+  assert_equals(imports.length, expected.length);
+  for (let i = 0; i < expected.length; ++i) {
+    assert_ModuleImportDescriptor(imports[i], expected[i]);
+  }
+}
+
+let emptyModuleBinary;
+setup(() => {
+  emptyModuleBinary = new WasmModuleBuilder().toBuffer();
+});
+
+test(() => {
+  assert_throws(new TypeError(), () => WebAssembly.Module.imports());
+}, "Missing arguments");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Module,
+    WebAssembly.Module.prototype,
+  ];
+  for (const argument of invalidArguments) {
+    assert_throws(new TypeError(), () => WebAssembly.Module.imports(argument),
+                  `imports(${format_value(argument)})`);
+  }
+}, "Non-Module arguments");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const fn = WebAssembly.Module.imports;
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Module,
+    WebAssembly.Module.prototype,
+  ];
+  for (const thisValue of thisValues) {
+    assert_array_equals(fn.call(thisValue, module), []);
+  }
+}, "Branding");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const imports = WebAssembly.Module.imports(module);
+  assert_true(Array.isArray(imports));
+}, "Return type");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const imports = WebAssembly.Module.imports(module);
+  assert_imports(imports, []);
+}, "Empty module");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  assert_not_equals(WebAssembly.Module.imports(module), WebAssembly.Module.imports(module));
+}, "Empty module: array caching");
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder.addImport("module", "fn", kSig_v_v);
+  builder.addImportedGlobal("module", "global", kWasmI32);
+  builder.addImportedMemory("module", "memory", 0, 128);
+  builder.addImportedTable("module", "table", 0, 128);
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const imports = WebAssembly.Module.imports(module);
+  const expected = [
+    { "module": "module", "kind": "function", "name": "fn" },
+    { "module": "module", "kind": "global", "name": "global" },
+    { "module": "module", "kind": "memory", "name": "memory" },
+    { "module": "module", "kind": "table", "name": "table" },
+  ];
+  assert_imports(imports, expected);
+}, "imports");
+
+test(() => {
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  const imports = WebAssembly.Module.imports(module, {});
+  assert_imports(imports, []);
+}, "Stray argument");
diff --git a/test/js-api/module/toString.any.js b/test/js-api/module/toString.any.js
new file mode 100644
index 000000000..d9231a132
--- /dev/null
+++ b/test/js-api/module/toString.any.js
@@ -0,0 +1,9 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+test(() => {
+  const emptyModuleBinary = new WasmModuleBuilder().toBuffer();
+  const module = new WebAssembly.Module(emptyModuleBinary);
+  assert_class_string(module, "WebAssembly.Module");
+}, "Object.prototype.toString on an Module");
diff --git a/test/js-api/table/assertions.js b/test/js-api/table/assertions.js
new file mode 100644
index 000000000..c88972b4e
--- /dev/null
+++ b/test/js-api/table/assertions.js
@@ -0,0 +1,13 @@
+function assert_equal_to_array(table, expected, message) {
+  assert_equals(table.length, expected.length, `${message}: length`);
+  // The argument check in get() happens before the range check, and negative numbers
+  // are illegal, hence will throw TypeError per spec.
+  assert_throws(new TypeError(), () => table.get(-1), `${message}: table.get(-1)`);
+  for (let i = 0; i < expected.length; ++i) {
+    assert_equals(table.get(i), expected[i], `${message}: table.get(${i} of ${expected.length})`);
+  }
+  assert_throws(new RangeError(), () => table.get(expected.length),
+                `${message}: table.get(${expected.length} of ${expected.length})`);
+  assert_throws(new RangeError(), () => table.get(expected.length + 1),
+                `${message}: table.get(${expected.length + 1} of ${expected.length})`);
+}
diff --git a/test/js-api/table/constructor.any.js b/test/js-api/table/constructor.any.js
new file mode 100644
index 000000000..99eee19fe
--- /dev/null
+++ b/test/js-api/table/constructor.any.js
@@ -0,0 +1,179 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/assertions.js
+
+function assert_Table(actual, expected) {
+  assert_equals(Object.getPrototypeOf(actual), WebAssembly.Table.prototype,
+                "prototype");
+  assert_true(Object.isExtensible(actual), "extensible");
+
+  assert_equals(actual.length, expected.length, "length");
+  for (let i = 0; i < expected.length; ++i) {
+    assert_equals(actual.get(i), null, `actual.get(${i})`);
+  }
+}
+
+test(() => {
+  assert_function_name(WebAssembly.Table, "Table", "WebAssembly.Table");
+}, "name");
+
+test(() => {
+  assert_function_length(WebAssembly.Table, 1, "WebAssembly.Table");
+}, "length");
+
+test(() => {
+  assert_throws(new TypeError(), () => new WebAssembly.Table());
+}, "No arguments");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 0 };
+  assert_throws(new TypeError(), () => WebAssembly.Table(argument));
+}, "Calling");
+
+test(() => {
+  assert_throws(new TypeError(), () => new WebAssembly.Table({}));
+}, "Empty descriptor");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    false,
+    true,
+    "",
+    "test",
+    Symbol(),
+    1,
+    NaN,
+    {},
+  ];
+  for (const invalidArgument of invalidArguments) {
+    assert_throws(new TypeError(),
+                  () => new WebAssembly.Table(invalidArgument),
+                  `new Table(${format_value(invalidArgument)})`);
+  }
+}, "Invalid descriptor argument");
+
+test(() => {
+  assert_throws(new TypeError(), () => new WebAssembly.Table({ "element": "anyfunc", "initial": undefined }));
+}, "Undefined initial value in descriptor");
+
+test(() => {
+  assert_throws(new TypeError(), () => new WebAssembly.Table({ "element": undefined, "initial": 0 }));
+}, "Undefined element value in descriptor");
+
+const outOfRangeValues = [
+  NaN,
+  Infinity,
+  -Infinity,
+  -1,
+  0x100000000,
+  0x1000000000,
+];
+
+for (const value of outOfRangeValues) {
+  test(() => {
+    assert_throws(new TypeError(), () => new WebAssembly.Table({ "element": "anyfunc", "initial": value }));
+  }, `Out-of-range initial value in descriptor: ${format_value(value)}`);
+
+  test(() => {
+    assert_throws(new TypeError(), () => new WebAssembly.Table({ "element": "anyfunc", "initial": 0, "maximum": value }));
+  }, `Out-of-range maximum value in descriptor: ${format_value(value)}`);
+}
+
+test(() => {
+  assert_throws(new RangeError(), () => new WebAssembly.Table({ "element": "anyfunc", "initial": 10, "maximum": 9 }));
+}, "Initial value exceeds maximum");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 0 };
+  const table = new WebAssembly.Table(argument);
+  assert_Table(table, { "length": 0 });
+}, "Basic (zero)");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_Table(table, { "length": 5 });
+}, "Basic (non-zero)");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 0 };
+  const table = new WebAssembly.Table(argument, {});
+  assert_Table(table, { "length": 0 });
+}, "Stray argument");
+
+test(() => {
+  const proxy = new Proxy({}, {
+    has(o, x) {
+      assert_unreached(`Should not call [[HasProperty]] with ${x}`);
+    },
+    get(o, x) {
+      switch (x) {
+      case "element":
+        return "anyfunc";
+      case "initial":
+      case "maximum":
+        return 0;
+      default:
+        return undefined;
+      }
+    },
+  });
+  const table = new WebAssembly.Table(proxy);
+  assert_Table(table, { "length": 0 });
+}, "Proxy descriptor");
+
+test(() => {
+  const table = new WebAssembly.Table({
+    "element": {
+      toString() { return "anyfunc"; },
+    },
+    "initial": 1,
+  });
+  assert_Table(table, { "length": 1 });
+}, "Type conversion for descriptor.element");
+
+test(() => {
+  const order = [];
+
+  new WebAssembly.Table({
+    get maximum() {
+      order.push("maximum");
+      return {
+        valueOf() {
+          order.push("maximum valueOf");
+          return 1;
+        },
+      };
+    },
+
+    get initial() {
+      order.push("initial");
+      return {
+        valueOf() {
+          order.push("initial valueOf");
+          return 1;
+        },
+      };
+    },
+
+    get element() {
+      order.push("element");
+      return {
+        toString() {
+          order.push("element toString");
+          return "anyfunc";
+        },
+      };
+    },
+  });
+
+  assert_array_equals(order, [
+    "element",
+    "element toString",
+    "initial",
+    "initial valueOf",
+    "maximum",
+    "maximum valueOf",
+  ]);
+}, "Order of evaluation for descriptor");
diff --git a/test/js-api/table/get-set.any.js b/test/js-api/table/get-set.any.js
new file mode 100644
index 000000000..f8a019436
--- /dev/null
+++ b/test/js-api/table/get-set.any.js
@@ -0,0 +1,230 @@
+// META: global=jsshell
+// META: script=/wasm/jsapi/wasm-constants.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+// META: script=assertions.js
+
+let functions;
+setup(() => {
+  const builder = new WasmModuleBuilder();
+
+  builder
+    .addFunction("fn", kSig_v_d)
+    .addBody([
+        kExprEnd
+    ])
+    .exportFunc();
+  builder
+    .addFunction("fn2", kSig_v_v)
+    .addBody([
+        kExprEnd
+    ])
+    .exportFunc();
+
+  const buffer = builder.toBuffer()
+  const module = new WebAssembly.Module(buffer);
+  const instance = new WebAssembly.Instance(module, {});
+  functions = instance.exports;
+});
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_throws(new TypeError(), () => table.get());
+}, "Missing arguments: get");
+
+test(t => {
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Table,
+    WebAssembly.Table.prototype,
+  ];
+
+  const argument = {
+    valueOf: t.unreached_func("Should not touch the argument (valueOf)"),
+    toString: t.unreached_func("Should not touch the argument (toString)"),
+  };
+
+  const fn = WebAssembly.Table.prototype.get;
+
+  for (const thisValue of thisValues) {
+    assert_throws(new TypeError(), () => fn.call(thisValue, argument), `this=${format_value(thisValue)}`);
+  }
+}, "Branding: get");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_throws(new TypeError(), () => table.set());
+  assert_throws(new TypeError(), () => table.set(0));
+}, "Missing arguments: set");
+
+test(t => {
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Table,
+    WebAssembly.Table.prototype,
+  ];
+
+  const argument = {
+    valueOf: t.unreached_func("Should not touch the argument (valueOf)"),
+    toString: t.unreached_func("Should not touch the argument (toString)"),
+  };
+
+  const fn = WebAssembly.Table.prototype.set;
+
+  for (const thisValue of thisValues) {
+    assert_throws(new TypeError(), () => fn.call(thisValue, argument, null), `this=${format_value(thisValue)}`);
+  }
+}, "Branding: set");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_equal_to_array(table, [null, null, null, null, null]);
+
+  const {fn, fn2} = functions;
+
+  assert_equals(table.set(0, fn), undefined, "set() returns undefined.");
+  table.set(2, fn2);
+  table.set(4, fn);
+
+  assert_equal_to_array(table, [fn, null, fn2, null, fn]);
+
+  table.set(0, null);
+  assert_equal_to_array(table, [null, null, fn2, null, fn]);
+}, "Basic");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_equal_to_array(table, [null, null, null, null, null]);
+
+  const {fn, fn2} = functions;
+
+  table.set(0, fn);
+  table.set(2, fn2);
+  table.set(4, fn);
+
+  assert_equal_to_array(table, [fn, null, fn2, null, fn]);
+
+  table.grow(4);
+
+  assert_equal_to_array(table, [fn, null, fn2, null, fn, null, null, null, null]);
+}, "Growing");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_equal_to_array(table, [null, null, null, null, null]);
+
+  const {fn} = functions;
+
+  // -1 is the wrong type hence the type check on entry gets this
+  // before the range check does.
+  assert_throws(new TypeError(), () => table.set(-1, fn));
+  assert_throws(new RangeError(), () => table.set(5, fn));
+  assert_equal_to_array(table, [null, null, null, null, null]);
+}, "Setting out-of-bounds");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+  assert_equal_to_array(table, [null]);
+
+  const invalidArguments = [
+    undefined,
+    true,
+    false,
+    "test",
+    Symbol(),
+    7,
+    NaN,
+    {},
+  ];
+  for (const argument of invalidArguments) {
+    assert_throws(new TypeError(), () => table.set(0, argument),
+                  `set(${format_value(argument)})`);
+  }
+  assert_equal_to_array(table, [null]);
+}, "Setting non-function");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+  assert_equal_to_array(table, [null]);
+
+  const fn = function() {};
+  assert_throws(new TypeError(), () => table.set(0, fn));
+  assert_equal_to_array(table, [null]);
+}, "Setting non-wasm function");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+  assert_equal_to_array(table, [null]);
+
+  const fn = () => {};
+  assert_throws(new TypeError(), () => table.set(0, fn));
+  assert_equal_to_array(table, [null]);
+}, "Setting non-wasm arrow function");
+
+const outOfRangeValues = [
+  undefined,
+  NaN,
+  Infinity,
+  -Infinity,
+  -1,
+  0x100000000,
+  0x1000000000,
+  "0x100000000",
+  { valueOf() { return 0x100000000; } },
+];
+
+for (const value of outOfRangeValues) {
+  test(() => {
+    const argument = { "element": "anyfunc", "initial": 1 };
+    const table = new WebAssembly.Table(argument);
+    assert_throws(new TypeError(), () => table.get(value));
+  }, `Getting out-of-range argument: ${format_value(value)}`);
+
+  test(() => {
+    const argument = { "element": "anyfunc", "initial": 1 };
+    const table = new WebAssembly.Table(argument);
+    assert_throws(new TypeError(), () => table.set(value, null));
+  }, `Setting out-of-range argument: ${format_value(value)}`);
+}
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+  let called = 0;
+  const value = {
+    valueOf() {
+      called++;
+      return 0;
+    },
+  };
+  assert_throws(new TypeError(), () => table.set(value, {}));
+  assert_equals(called, 1);
+}, "Order of argument conversion");
+
+test(() => {
+  const {fn} = functions;
+  const argument = { "element": "anyfunc", "initial": 1 };
+  const table = new WebAssembly.Table(argument);
+
+  assert_equals(table.get(0, {}), null);
+  assert_equals(table.set(0, fn, {}), undefined);
+}, "Stray argument");
diff --git a/test/js-api/table/grow.any.js b/test/js-api/table/grow.any.js
new file mode 100644
index 000000000..4978e3ca2
--- /dev/null
+++ b/test/js-api/table/grow.any.js
@@ -0,0 +1,96 @@
+// META: global=jsshell
+// META: script=assertions.js
+
+function nulls(n) {
+  return Array(n).fill(null);
+}
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_throws(new TypeError(), () => table.grow());
+}, "Missing arguments");
+
+test(t => {
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Table,
+    WebAssembly.Table.prototype,
+  ];
+
+  const argument = {
+    valueOf: t.unreached_func("Should not touch the argument (valueOf)"),
+    toString: t.unreached_func("Should not touch the argument (toString)"),
+  };
+
+  const fn = WebAssembly.Table.prototype.grow;
+
+  for (const thisValue of thisValues) {
+    assert_throws(new TypeError(), () => fn.call(thisValue, argument), `this=${format_value(thisValue)}`);
+  }
+}, "Branding");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_equal_to_array(table, nulls(5), "before");
+
+  const result = table.grow(3);
+  assert_equals(result, 5);
+  assert_equal_to_array(table, nulls(8), "after");
+}, "Basic");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 3, "maximum": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_equal_to_array(table, nulls(3), "before");
+
+  const result = table.grow(2);
+  assert_equals(result, 3);
+  assert_equal_to_array(table, nulls(5), "after");
+}, "Reached maximum");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 2, "maximum": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_equal_to_array(table, nulls(2), "before");
+
+  assert_throws(new RangeError(), () => table.grow(4));
+  assert_equal_to_array(table, nulls(2), "after");
+}, "Exceeded maximum");
+
+const outOfRangeValues = [
+  undefined,
+  NaN,
+  Infinity,
+  -Infinity,
+  -1,
+  0x100000000,
+  0x1000000000,
+  "0x100000000",
+  { valueOf() { return 0x100000000; } },
+];
+
+for (const value of outOfRangeValues) {
+  test(() => {
+    const argument = { "element": "anyfunc", "initial": 1 };
+    const table = new WebAssembly.Table(argument);
+    assert_throws(new TypeError(), () => table.grow(value));
+  }, `Out-of-range argument: ${format_value(value)}`);
+}
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 5 };
+  const table = new WebAssembly.Table(argument);
+  assert_equal_to_array(table, nulls(5), "before");
+
+  const result = table.grow(3, {});
+  assert_equals(result, 5);
+  assert_equal_to_array(table, nulls(8), "after");
+}, "Stray argument");
diff --git a/test/js-api/table/length.any.js b/test/js-api/table/length.any.js
new file mode 100644
index 000000000..b1bfa6cfd
--- /dev/null
+++ b/test/js-api/table/length.any.js
@@ -0,0 +1,60 @@
+// META: global=jsshell
+
+test(() => {
+  const thisValues = [
+    undefined,
+    null,
+    true,
+    "",
+    Symbol(),
+    1,
+    {},
+    WebAssembly.Table,
+    WebAssembly.Table.prototype,
+  ];
+
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Table.prototype, "length");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  assert_equals(typeof desc.set, "undefined");
+
+  for (const thisValue of thisValues) {
+    assert_throws(new TypeError(), () => getter.call(thisValue), `this=${format_value(thisValue)}`);
+  }
+}, "Branding");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 2 };
+  const table = new WebAssembly.Table(argument);
+  assert_equals(table.length, 2, "Initial length");
+
+  const desc = Object.getOwnPropertyDescriptor(WebAssembly.Table.prototype, "length");
+  assert_equals(typeof desc, "object");
+
+  const getter = desc.get;
+  assert_equals(typeof getter, "function");
+
+  assert_equals(getter.call(table, {}), 2);
+}, "Stray argument");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 2 };
+  const table = new WebAssembly.Table(argument);
+  assert_equals(table.length, 2, "Initial length");
+  table.length = 4;
+  assert_equals(table.length, 2, "Should not change the length");
+}, "Setting (sloppy mode)");
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 2 };
+  const table = new WebAssembly.Table(argument);
+  assert_equals(table.length, 2, "Initial length");
+  assert_throws(new TypeError(), () => {
+    "use strict";
+    table.length = 4;
+  });
+  assert_equals(table.length, 2, "Should not change the length");
+}, "Setting (strict mode)");
diff --git a/test/js-api/table/toString.any.js b/test/js-api/table/toString.any.js
new file mode 100644
index 000000000..e57647791
--- /dev/null
+++ b/test/js-api/table/toString.any.js
@@ -0,0 +1,7 @@
+// META: global=jsshell
+
+test(() => {
+  const argument = { "element": "anyfunc", "initial": 0 };
+  const table = new WebAssembly.Table(argument);
+  assert_class_string(table, "WebAssembly.Table");
+}, "Object.prototype.toString on an Table");
diff --git a/test/js-api/wasm-constants.js b/test/js-api/wasm-constants.js
new file mode 100644
index 000000000..f056f9cbf
--- /dev/null
+++ b/test/js-api/wasm-constants.js
@@ -0,0 +1,374 @@
+// Copyright 2015 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --expose-wasm
+
+function bytes() {
+  var buffer = new ArrayBuffer(arguments.length);
+  var view = new Uint8Array(buffer);
+  for (var i = 0; i < arguments.length; i++) {
+    var val = arguments[i];
+    if ((typeof val) == "string") val = val.charCodeAt(0);
+    view[i] = val | 0;
+  }
+  return buffer;
+}
+
+// Header declaration constants
+var kWasmH0 = 0;
+var kWasmH1 = 0x61;
+var kWasmH2 = 0x73;
+var kWasmH3 = 0x6d;
+
+var kWasmV0 = 1;
+var kWasmV1 = 0;
+var kWasmV2 = 0;
+var kWasmV3 = 0;
+
+var kHeaderSize = 8;
+var kPageSize = 65536;
+
+function bytesWithHeader() {
+  var buffer = new ArrayBuffer(kHeaderSize + arguments.length);
+  var view = new Uint8Array(buffer);
+  view[0] = kWasmH0;
+  view[1] = kWasmH1;
+  view[2] = kWasmH2;
+  view[3] = kWasmH3;
+  view[4] = kWasmV0;
+  view[5] = kWasmV1;
+  view[6] = kWasmV2;
+  view[7] = kWasmV3;
+  for (var i = 0; i < arguments.length; i++) {
+    var val = arguments[i];
+    if ((typeof val) == "string") val = val.charCodeAt(0);
+    view[kHeaderSize + i] = val | 0;
+  }
+  return buffer;
+}
+
+let kDeclNoLocals = 0;
+
+// Section declaration constants
+let kUnknownSectionCode = 0;
+let kTypeSectionCode = 1;      // Function signature declarations
+let kImportSectionCode = 2;    // Import declarations
+let kFunctionSectionCode = 3;  // Function declarations
+let kTableSectionCode = 4;     // Indirect function table and other tables
+let kMemorySectionCode = 5;    // Memory attributes
+let kGlobalSectionCode = 6;    // Global declarations
+let kExportSectionCode = 7;    // Exports
+let kStartSectionCode = 8;     // Start function declaration
+let kElementSectionCode = 9;  // Elements section
+let kCodeSectionCode = 10;      // Function code
+let kDataSectionCode = 11;     // Data segments
+let kNameSectionCode = 12;     // Name section (encoded as string)
+
+let kWasmFunctionTypeForm = 0x60;
+let kWasmAnyFunctionTypeForm = 0x70;
+
+let kResizableMaximumFlag = 1;
+
+// Function declaration flags
+let kDeclFunctionName   = 0x01;
+let kDeclFunctionImport = 0x02;
+let kDeclFunctionLocals = 0x04;
+let kDeclFunctionExport = 0x08;
+
+// Local types
+let kWasmStmt = 0x40;
+let kWasmI32 = 0x7f;
+let kWasmI64 = 0x7e;
+let kWasmF32 = 0x7d;
+let kWasmF64 = 0x7c;
+let kWasmS128 = 0x7b;
+
+let kExternalFunction = 0;
+let kExternalTable = 1;
+let kExternalMemory = 2;
+let kExternalGlobal = 3;
+
+let kTableZero = 0;
+let kMemoryZero = 0;
+
+// Useful signatures
+let kSig_i_i = makeSig([kWasmI32], [kWasmI32]);
+let kSig_l_l = makeSig([kWasmI64], [kWasmI64]);
+let kSig_i_l = makeSig([kWasmI64], [kWasmI32]);
+let kSig_i_ii = makeSig([kWasmI32, kWasmI32], [kWasmI32]);
+let kSig_i_iii = makeSig([kWasmI32, kWasmI32, kWasmI32], [kWasmI32]);
+let kSig_d_dd = makeSig([kWasmF64, kWasmF64], [kWasmF64]);
+let kSig_l_ll = makeSig([kWasmI64, kWasmI64], [kWasmI64]);
+let kSig_i_dd = makeSig([kWasmF64, kWasmF64], [kWasmI32]);
+let kSig_v_v = makeSig([], []);
+let kSig_i_v = makeSig([], [kWasmI32]);
+let kSig_l_v = makeSig([], [kWasmI64]);
+let kSig_f_v = makeSig([], [kWasmF64]);
+let kSig_d_v = makeSig([], [kWasmF64]);
+let kSig_v_i = makeSig([kWasmI32], []);
+let kSig_v_ii = makeSig([kWasmI32, kWasmI32], []);
+let kSig_v_iii = makeSig([kWasmI32, kWasmI32, kWasmI32], []);
+let kSig_v_l = makeSig([kWasmI64], []);
+let kSig_v_d = makeSig([kWasmF64], []);
+let kSig_v_dd = makeSig([kWasmF64, kWasmF64], []);
+let kSig_v_ddi = makeSig([kWasmF64, kWasmF64, kWasmI32], []);
+let kSig_s_v = makeSig([], [kWasmS128]);
+
+function makeSig(params, results) {
+  return {params: params, results: results};
+}
+
+function makeSig_v_x(x) {
+  return makeSig([x], []);
+}
+
+function makeSig_v_xx(x) {
+  return makeSig([x, x], []);
+}
+
+function makeSig_r_v(r) {
+  return makeSig([], [r]);
+}
+
+function makeSig_r_x(r, x) {
+  return makeSig([x], [r]);
+}
+
+function makeSig_r_xx(r, x) {
+  return makeSig([x, x], [r]);
+}
+
+// Opcodes
+let kExprUnreachable = 0x00;
+let kExprNop = 0x01;
+let kExprBlock = 0x02;
+let kExprLoop = 0x03;
+let kExprIf = 0x04;
+let kExprElse = 0x05;
+let kExprTry = 0x06;
+let kExprCatch = 0x07;
+let kExprThrow = 0x08;
+let kExprEnd = 0x0b;
+let kExprBr = 0x0c;
+let kExprBrIf = 0x0d;
+let kExprBrTable = 0x0e;
+let kExprReturn = 0x0f;
+let kExprCallFunction = 0x10;
+let kExprCallIndirect = 0x11;
+let kExprDrop = 0x1a;
+let kExprSelect = 0x1b;
+let kExprGetLocal = 0x20;
+let kExprSetLocal = 0x21;
+let kExprTeeLocal = 0x22;
+let kExprGetGlobal = 0x23;
+let kExprSetGlobal = 0x24;
+let kExprI32Const = 0x41;
+let kExprI64Const = 0x42;
+let kExprF32Const = 0x43;
+let kExprF64Const = 0x44;
+let kExprI32LoadMem = 0x28;
+let kExprI64LoadMem = 0x29;
+let kExprF32LoadMem = 0x2a;
+let kExprF64LoadMem = 0x2b;
+let kExprI32LoadMem8S = 0x2c;
+let kExprI32LoadMem8U = 0x2d;
+let kExprI32LoadMem16S = 0x2e;
+let kExprI32LoadMem16U = 0x2f;
+let kExprI64LoadMem8S = 0x30;
+let kExprI64LoadMem8U = 0x31;
+let kExprI64LoadMem16S = 0x32;
+let kExprI64LoadMem16U = 0x33;
+let kExprI64LoadMem32S = 0x34;
+let kExprI64LoadMem32U = 0x35;
+let kExprI32StoreMem = 0x36;
+let kExprI64StoreMem = 0x37;
+let kExprF32StoreMem = 0x38;
+let kExprF64StoreMem = 0x39;
+let kExprI32StoreMem8 = 0x3a;
+let kExprI32StoreMem16 = 0x3b;
+let kExprI64StoreMem8 = 0x3c;
+let kExprI64StoreMem16 = 0x3d;
+let kExprI64StoreMem32 = 0x3e;
+let kExprMemorySize = 0x3f;
+let kExprGrowMemory = 0x40;
+let kExprI32Eqz = 0x45;
+let kExprI32Eq = 0x46;
+let kExprI32Ne = 0x47;
+let kExprI32LtS = 0x48;
+let kExprI32LtU = 0x49;
+let kExprI32GtS = 0x4a;
+let kExprI32GtU = 0x4b;
+let kExprI32LeS = 0x4c;
+let kExprI32LeU = 0x4d;
+let kExprI32GeS = 0x4e;
+let kExprI32GeU = 0x4f;
+let kExprI64Eqz = 0x50;
+let kExprI64Eq = 0x51;
+let kExprI64Ne = 0x52;
+let kExprI64LtS = 0x53;
+let kExprI64LtU = 0x54;
+let kExprI64GtS = 0x55;
+let kExprI64GtU = 0x56;
+let kExprI64LeS = 0x57;
+let kExprI64LeU = 0x58;
+let kExprI64GeS = 0x59;
+let kExprI64GeU = 0x5a;
+let kExprF32Eq = 0x5b;
+let kExprF32Ne = 0x5c;
+let kExprF32Lt = 0x5d;
+let kExprF32Gt = 0x5e;
+let kExprF32Le = 0x5f;
+let kExprF32Ge = 0x60;
+let kExprF64Eq = 0x61;
+let kExprF64Ne = 0x62;
+let kExprF64Lt = 0x63;
+let kExprF64Gt = 0x64;
+let kExprF64Le = 0x65;
+let kExprF64Ge = 0x66;
+let kExprI32Clz = 0x67;
+let kExprI32Ctz = 0x68;
+let kExprI32Popcnt = 0x69;
+let kExprI32Add = 0x6a;
+let kExprI32Sub = 0x6b;
+let kExprI32Mul = 0x6c;
+let kExprI32DivS = 0x6d;
+let kExprI32DivU = 0x6e;
+let kExprI32RemS = 0x6f;
+let kExprI32RemU = 0x70;
+let kExprI32And = 0x71;
+let kExprI32Ior = 0x72;
+let kExprI32Xor = 0x73;
+let kExprI32Shl = 0x74;
+let kExprI32ShrS = 0x75;
+let kExprI32ShrU = 0x76;
+let kExprI32Rol = 0x77;
+let kExprI32Ror = 0x78;
+let kExprI64Clz = 0x79;
+let kExprI64Ctz = 0x7a;
+let kExprI64Popcnt = 0x7b;
+let kExprI64Add = 0x7c;
+let kExprI64Sub = 0x7d;
+let kExprI64Mul = 0x7e;
+let kExprI64DivS = 0x7f;
+let kExprI64DivU = 0x80;
+let kExprI64RemS = 0x81;
+let kExprI64RemU = 0x82;
+let kExprI64And = 0x83;
+let kExprI64Ior = 0x84;
+let kExprI64Xor = 0x85;
+let kExprI64Shl = 0x86;
+let kExprI64ShrS = 0x87;
+let kExprI64ShrU = 0x88;
+let kExprI64Rol = 0x89;
+let kExprI64Ror = 0x8a;
+let kExprF32Abs = 0x8b;
+let kExprF32Neg = 0x8c;
+let kExprF32Ceil = 0x8d;
+let kExprF32Floor = 0x8e;
+let kExprF32Trunc = 0x8f;
+let kExprF32NearestInt = 0x90;
+let kExprF32Sqrt = 0x91;
+let kExprF32Add = 0x92;
+let kExprF32Sub = 0x93;
+let kExprF32Mul = 0x94;
+let kExprF32Div = 0x95;
+let kExprF32Min = 0x96;
+let kExprF32Max = 0x97;
+let kExprF32CopySign = 0x98;
+let kExprF64Abs = 0x99;
+let kExprF64Neg = 0x9a;
+let kExprF64Ceil = 0x9b;
+let kExprF64Floor = 0x9c;
+let kExprF64Trunc = 0x9d;
+let kExprF64NearestInt = 0x9e;
+let kExprF64Sqrt = 0x9f;
+let kExprF64Add = 0xa0;
+let kExprF64Sub = 0xa1;
+let kExprF64Mul = 0xa2;
+let kExprF64Div = 0xa3;
+let kExprF64Min = 0xa4;
+let kExprF64Max = 0xa5;
+let kExprF64CopySign = 0xa6;
+let kExprI32ConvertI64 = 0xa7;
+let kExprI32SConvertF32 = 0xa8;
+let kExprI32UConvertF32 = 0xa9;
+let kExprI32SConvertF64 = 0xaa;
+let kExprI32UConvertF64 = 0xab;
+let kExprI64SConvertI32 = 0xac;
+let kExprI64UConvertI32 = 0xad;
+let kExprI64SConvertF32 = 0xae;
+let kExprI64UConvertF32 = 0xaf;
+let kExprI64SConvertF64 = 0xb0;
+let kExprI64UConvertF64 = 0xb1;
+let kExprF32SConvertI32 = 0xb2;
+let kExprF32UConvertI32 = 0xb3;
+let kExprF32SConvertI64 = 0xb4;
+let kExprF32UConvertI64 = 0xb5;
+let kExprF32ConvertF64 = 0xb6;
+let kExprF64SConvertI32 = 0xb7;
+let kExprF64UConvertI32 = 0xb8;
+let kExprF64SConvertI64 = 0xb9;
+let kExprF64UConvertI64 = 0xba;
+let kExprF64ConvertF32 = 0xbb;
+let kExprI32ReinterpretF32 = 0xbc;
+let kExprI64ReinterpretF64 = 0xbd;
+let kExprF32ReinterpretI32 = 0xbe;
+let kExprF64ReinterpretI64 = 0xbf;
+
+let kTrapUnreachable          = 0;
+let kTrapMemOutOfBounds       = 1;
+let kTrapDivByZero            = 2;
+let kTrapDivUnrepresentable   = 3;
+let kTrapRemByZero            = 4;
+let kTrapFloatUnrepresentable = 5;
+let kTrapFuncInvalid          = 6;
+let kTrapFuncSigMismatch      = 7;
+let kTrapInvalidIndex         = 8;
+
+let kTrapMsgs = [
+  "unreachable",
+  "memory access out of bounds",
+  "divide by zero",
+  "divide result unrepresentable",
+  "remainder by zero",
+  "integer result unrepresentable",
+  "invalid function",
+  "function signature mismatch",
+  "invalid index into function table"
+];
+
+function assertTraps(trap, code) {
+    var threwException = true;
+    try {
+      if (typeof code === 'function') {
+        code();
+      } else {
+        eval(code);
+      }
+      threwException = false;
+    } catch (e) {
+      assertEquals("object", typeof e);
+      assertEquals(kTrapMsgs[trap], e.message);
+      // Success.
+      return;
+    }
+    throw new MjsUnitAssertionError("Did not trap, expected: " + kTrapMsgs[trap]);
+}
+
+function assertWasmThrows(value, code) {
+    assertEquals("number", typeof(value));
+    try {
+      if (typeof code === 'function') {
+        code();
+      } else {
+        eval(code);
+      }
+    } catch (e) {
+      assertEquals("number", typeof e);
+      assertEquals(value, e);
+      // Success.
+      return;
+    }
+    throw new MjsUnitAssertionError("Did not throw at all, expected: " + value);
+}
diff --git a/test/js-api/wasm-module-builder.js b/test/js-api/wasm-module-builder.js
new file mode 100644
index 000000000..6e9284e77
--- /dev/null
+++ b/test/js-api/wasm-module-builder.js
@@ -0,0 +1,555 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Used for encoding f32 and double constants to bits.
+let __buffer = new ArrayBuffer(8);
+let byte_view = new Int8Array(__buffer);
+let f32_view = new Float32Array(__buffer);
+let f64_view = new Float64Array(__buffer);
+
+class Binary extends Array {
+  emit_u8(val) {
+    this.push(val);
+  }
+
+  emit_u16(val) {
+    this.push(val & 0xff);
+    this.push((val >> 8) & 0xff);
+  }
+
+  emit_u32(val) {
+    this.push(val & 0xff);
+    this.push((val >> 8) & 0xff);
+    this.push((val >> 16) & 0xff);
+    this.push((val >> 24) & 0xff);
+  }
+
+  emit_u32v(val) {
+    while (true) {
+      let v = val & 0xff;
+      val = val >>> 7;
+      if (val == 0) {
+        this.push(v);
+        break;
+      }
+      this.push(v | 0x80);
+    }
+  }
+
+  emit_bytes(data) {
+    for (let i = 0; i < data.length; i++) {
+      this.push(data[i] & 0xff);
+    }
+  }
+
+  emit_string(string) {
+    // When testing illegal names, we pass a byte array directly.
+    if (string instanceof Array) {
+      this.emit_u32v(string.length);
+      this.emit_bytes(string);
+      return;
+    }
+
+    // This is the hacky way to convert a JavaScript string to a UTF8 encoded
+    // string only containing single-byte characters.
+    let string_utf8 = unescape(encodeURIComponent(string));
+    this.emit_u32v(string_utf8.length);
+    for (let i = 0; i < string_utf8.length; i++) {
+      this.emit_u8(string_utf8.charCodeAt(i));
+    }
+  }
+
+  emit_header() {
+    this.push(kWasmH0, kWasmH1, kWasmH2, kWasmH3,
+              kWasmV0, kWasmV1, kWasmV2, kWasmV3);
+  }
+
+  emit_section(section_code, content_generator) {
+    // Emit section name.
+    this.emit_u8(section_code);
+    // Emit the section to a temporary buffer: its full length isn't know yet.
+    let section = new Binary;
+    content_generator(section);
+    // Emit section length.
+    this.emit_u32v(section.length);
+    // Copy the temporary buffer.
+    this.push(...section);
+  }
+}
+
+class WasmFunctionBuilder {
+  constructor(module, name, type_index) {
+    this.module = module;
+    this.name = name;
+    this.type_index = type_index;
+    this.body = [];
+  }
+
+  exportAs(name) {
+    this.module.addExport(name, this.index);
+    return this;
+  }
+
+  exportFunc() {
+    this.exportAs(this.name);
+    return this;
+  }
+
+  addBody(body) {
+    this.body = body;
+    return this;
+  }
+
+  addLocals(locals) {
+    this.locals = locals;
+    return this;
+  }
+
+  end() {
+    return this.module;
+  }
+}
+
+class WasmGlobalBuilder {
+  constructor(module, type, mutable) {
+    this.module = module;
+    this.type = type;
+    this.mutable = mutable;
+    this.init = 0;
+  }
+
+  exportAs(name) {
+    this.module.exports.push({name: name, kind: kExternalGlobal,
+                              index: this.index});
+    return this;
+  }
+}
+
+class WasmModuleBuilder {
+  constructor() {
+    this.types = [];
+    this.imports = [];
+    this.exports = [];
+    this.globals = [];
+    this.functions = [];
+    this.function_table = [];
+    this.function_table_length = 0;
+    this.function_table_inits = [];
+    this.segments = [];
+    this.explicit = [];
+    this.num_imported_funcs = 0;
+    this.num_imported_globals = 0;
+    return this;
+  }
+
+  addStart(start_index) {
+    this.start_index = start_index;
+    return this;
+  }
+
+  addMemory(min, max, exp) {
+    this.memory = {min: min, max: max, exp: exp};
+    return this;
+  }
+
+  addExplicitSection(bytes) {
+    this.explicit.push(bytes);
+    return this;
+  }
+
+  addType(type) {
+    // TODO: canonicalize types?
+    this.types.push(type);
+    return this.types.length - 1;
+  }
+
+  addGlobal(local_type, mutable) {
+    let glob = new WasmGlobalBuilder(this, local_type, mutable);
+    glob.index = this.globals.length + this.num_imported_globals;
+    this.globals.push(glob);
+    return glob;
+  }
+
+  addFunction(name, type) {
+    let type_index = (typeof type) == "number" ? type : this.addType(type);
+    let func = new WasmFunctionBuilder(this, name, type_index);
+    func.index = this.functions.length + this.num_imported_funcs;
+    this.functions.push(func);
+    return func;
+  }
+
+  addImport(module = "", name, type) {
+    let type_index = (typeof type) == "number" ? type : this.addType(type);
+    this.imports.push({module: module, name: name, kind: kExternalFunction,
+                       type: type_index});
+    return this.num_imported_funcs++;
+  }
+
+  addImportedGlobal(module = "", name, type) {
+    let o = {module: module, name: name, kind: kExternalGlobal, type: type,
+             mutable: false}
+    this.imports.push(o);
+    return this.num_imported_globals++;
+  }
+
+  addImportedMemory(module = "", name, initial = 0, maximum) {
+    let o = {module: module, name: name, kind: kExternalMemory,
+             initial: initial, maximum: maximum};
+    this.imports.push(o);
+    return this;
+  }
+
+  addImportedTable(module = "", name, initial, maximum) {
+    let o = {module: module, name: name, kind: kExternalTable, initial: initial,
+             maximum: maximum};
+    this.imports.push(o);
+  }
+
+  addExport(name, index) {
+    this.exports.push({name: name, kind: kExternalFunction, index: index});
+    return this;
+  }
+
+  addExportOfKind(name, kind, index) {
+    this.exports.push({name: name, kind: kind, index: index});
+    return this;
+  }
+
+  addDataSegment(addr, data, is_global = false) {
+    this.segments.push({addr: addr, data: data, is_global: is_global});
+    return this.segments.length - 1;
+  }
+
+  exportMemoryAs(name) {
+    this.exports.push({name: name, kind: kExternalMemory, index: 0});
+  }
+
+  addFunctionTableInit(base, is_global, array) {
+    this.function_table_inits.push({base: base, is_global: is_global,
+                                    array: array});
+    if (!is_global) {
+      var length = base + array.length;
+      if (length > this.function_table_length) {
+        this.function_table_length = length;
+      }
+    }
+    return this;
+  }
+
+  appendToTable(array) {
+    return this.addFunctionTableInit(this.function_table.length, false, array);
+  }
+
+  setFunctionTableLength(length) {
+    this.function_table_length = length;
+    return this;
+  }
+
+  toArray(debug = false) {
+    let binary = new Binary;
+    let wasm = this;
+
+    // Add header
+    binary.emit_header();
+
+    // Add type section
+    if (wasm.types.length > 0) {
+      if (debug) print("emitting types @ " + binary.length);
+      binary.emit_section(kTypeSectionCode, section => {
+        section.emit_u32v(wasm.types.length);
+        for (let type of wasm.types) {
+          section.emit_u8(kWasmFunctionTypeForm);
+          section.emit_u32v(type.params.length);
+          for (let param of type.params) {
+            section.emit_u8(param);
+          }
+          section.emit_u32v(type.results.length);
+          for (let result of type.results) {
+            section.emit_u8(result);
+          }
+        }
+      });
+    }
+
+    // Add imports section
+    if (wasm.imports.length > 0) {
+      if (debug) print("emitting imports @ " + binary.length);
+      binary.emit_section(kImportSectionCode, section => {
+        section.emit_u32v(wasm.imports.length);
+        for (let imp of wasm.imports) {
+          section.emit_string(imp.module);
+          section.emit_string(imp.name || '');
+          section.emit_u8(imp.kind);
+          if (imp.kind == kExternalFunction) {
+            section.emit_u32v(imp.type);
+          } else if (imp.kind == kExternalGlobal) {
+            section.emit_u32v(imp.type);
+            section.emit_u8(imp.mutable);
+          } else if (imp.kind == kExternalMemory) {
+            var has_max = (typeof imp.maximum) != "undefined";
+            section.emit_u8(has_max ? 1 : 0); // flags
+            section.emit_u32v(imp.initial); // initial
+            if (has_max) section.emit_u32v(imp.maximum); // maximum
+          } else if (imp.kind == kExternalTable) {
+            section.emit_u8(kWasmAnyFunctionTypeForm);
+            var has_max = (typeof imp.maximum) != "undefined";
+            section.emit_u8(has_max ? 1 : 0); // flags
+            section.emit_u32v(imp.initial); // initial
+            if (has_max) section.emit_u32v(imp.maximum); // maximum
+          } else {
+            throw new Error("unknown/unsupported import kind " + imp.kind);
+          }
+        }
+      });
+    }
+
+    // Add functions declarations
+    let has_names = false;
+    let names = false;
+    if (wasm.functions.length > 0) {
+      if (debug) print("emitting function decls @ " + binary.length);
+      binary.emit_section(kFunctionSectionCode, section => {
+        section.emit_u32v(wasm.functions.length);
+        for (let func of wasm.functions) {
+          has_names = has_names || (func.name != undefined &&
+                                   func.name.length > 0);
+          section.emit_u32v(func.type_index);
+        }
+      });
+    }
+
+    // Add function_table.
+    if (wasm.function_table_length > 0) {
+      if (debug) print("emitting table @ " + binary.length);
+      binary.emit_section(kTableSectionCode, section => {
+        section.emit_u8(1);  // one table entry
+        section.emit_u8(kWasmAnyFunctionTypeForm);
+        section.emit_u8(1);
+        section.emit_u32v(wasm.function_table_length);
+        section.emit_u32v(wasm.function_table_length);
+      });
+    }
+
+    // Add memory section
+    if (wasm.memory != undefined) {
+      if (debug) print("emitting memory @ " + binary.length);
+      binary.emit_section(kMemorySectionCode, section => {
+        section.emit_u8(1);  // one memory entry
+        section.emit_u32v(kResizableMaximumFlag);
+        section.emit_u32v(wasm.memory.min);
+        section.emit_u32v(wasm.memory.max);
+      });
+    }
+
+    // Add global section.
+    if (wasm.globals.length > 0) {
+      if (debug) print ("emitting globals @ " + binary.length);
+      binary.emit_section(kGlobalSectionCode, section => {
+        section.emit_u32v(wasm.globals.length);
+        for (let global of wasm.globals) {
+          section.emit_u8(global.type);
+          section.emit_u8(global.mutable);
+          if ((typeof global.init_index) == "undefined") {
+            // Emit a constant initializer.
+            switch (global.type) {
+            case kWasmI32:
+              section.emit_u8(kExprI32Const);
+              section.emit_u32v(global.init);
+              break;
+            case kWasmI64:
+              section.emit_u8(kExprI64Const);
+              section.emit_u8(global.init);
+              break;
+            case kWasmF32:
+              section.emit_u8(kExprF32Const);
+              f32_view[0] = global.init;
+              section.emit_u8(byte_view[0]);
+              section.emit_u8(byte_view[1]);
+              section.emit_u8(byte_view[2]);
+              section.emit_u8(byte_view[3]);
+              break;
+            case kWasmF64:
+              section.emit_u8(kExprF64Const);
+              f64_view[0] = global.init;
+              section.emit_u8(byte_view[0]);
+              section.emit_u8(byte_view[1]);
+              section.emit_u8(byte_view[2]);
+              section.emit_u8(byte_view[3]);
+              section.emit_u8(byte_view[4]);
+              section.emit_u8(byte_view[5]);
+              section.emit_u8(byte_view[6]);
+              section.emit_u8(byte_view[7]);
+              break;
+            }
+          } else {
+            // Emit a global-index initializer.
+            section.emit_u8(kExprGetGlobal);
+            section.emit_u32v(global.init_index);
+          }
+          section.emit_u8(kExprEnd);  // end of init expression
+        }
+      });
+    }
+
+    // Add export table.
+    var mem_export = (wasm.memory != undefined && wasm.memory.exp);
+    var exports_count = wasm.exports.length + (mem_export ? 1 : 0);
+    if (exports_count > 0) {
+      if (debug) print("emitting exports @ " + binary.length);
+      binary.emit_section(kExportSectionCode, section => {
+        section.emit_u32v(exports_count);
+        for (let exp of wasm.exports) {
+          section.emit_string(exp.name);
+          section.emit_u8(exp.kind);
+          section.emit_u32v(exp.index);
+        }
+        if (mem_export) {
+          section.emit_string("memory");
+          section.emit_u8(kExternalMemory);
+          section.emit_u8(0);
+        }
+      });
+    }
+
+    // Add start function section.
+    if (wasm.start_index != undefined) {
+      if (debug) print("emitting start function @ " + binary.length);
+      binary.emit_section(kStartSectionCode, section => {
+        section.emit_u32v(wasm.start_index);
+      });
+    }
+
+    // Add table elements.
+    if (wasm.function_table_inits.length > 0) {
+      if (debug) print("emitting table @ " + binary.length);
+      binary.emit_section(kElementSectionCode, section => {
+        var inits = wasm.function_table_inits;
+        section.emit_u32v(inits.length);
+        section.emit_u8(0); // table index
+
+        for (let init of inits) {
+          if (init.is_global) {
+            section.emit_u8(kExprGetGlobal);
+          } else {
+            section.emit_u8(kExprI32Const);
+          }
+          section.emit_u32v(init.base);
+          section.emit_u8(kExprEnd);
+          section.emit_u32v(init.array.length);
+          for (let index of init.array) {
+            section.emit_u32v(index);
+          }
+        }
+      });
+    }
+
+    // Add function bodies.
+    if (wasm.functions.length > 0) {
+      // emit function bodies
+      if (debug) print("emitting code @ " + binary.length);
+      binary.emit_section(kCodeSectionCode, section => {
+        section.emit_u32v(wasm.functions.length);
+        for (let func of wasm.functions) {
+          // Function body length will be patched later.
+          let local_decls = [];
+          let l = func.locals;
+          if (l != undefined) {
+            let local_decls_count = 0;
+            if (l.i32_count > 0) {
+              local_decls.push({count: l.i32_count, type: kWasmI32});
+            }
+            if (l.i64_count > 0) {
+              local_decls.push({count: l.i64_count, type: kWasmI64});
+            }
+            if (l.f32_count > 0) {
+              local_decls.push({count: l.f32_count, type: kWasmF32});
+            }
+            if (l.f64_count > 0) {
+              local_decls.push({count: l.f64_count, type: kWasmF64});
+            }
+          }
+
+          let header = new Binary;
+          header.emit_u32v(local_decls.length);
+          for (let decl of local_decls) {
+            header.emit_u32v(decl.count);
+            header.emit_u8(decl.type);
+          }
+
+          section.emit_u32v(header.length + func.body.length);
+          section.emit_bytes(header);
+          section.emit_bytes(func.body);
+        }
+      });
+    }
+
+    // Add data segments.
+    if (wasm.segments.length > 0) {
+      if (debug) print("emitting data segments @ " + binary.length);
+      binary.emit_section(kDataSectionCode, section => {
+        section.emit_u32v(wasm.segments.length);
+        for (let seg of wasm.segments) {
+          section.emit_u8(0);  // linear memory index 0
+          if (seg.is_global) {
+            // initializer is a global variable
+            section.emit_u8(kExprGetGlobal);
+            section.emit_u32v(seg.addr);
+          } else {
+            // initializer is a constant
+            section.emit_u8(kExprI32Const);
+            section.emit_u32v(seg.addr);
+          }
+          section.emit_u8(kExprEnd);
+          section.emit_u32v(seg.data.length);
+          section.emit_bytes(seg.data);
+        }
+      });
+    }
+
+    // Add any explicitly added sections
+    for (let exp of wasm.explicit) {
+      if (debug) print("emitting explicit @ " + binary.length);
+      binary.emit_bytes(exp);
+    }
+
+    // Add function names.
+    if (has_names) {
+      if (debug) print("emitting names @ " + binary.length);
+      binary.emit_section(kUnknownSectionCode, section => {
+        section.emit_string("name");
+        var count = wasm.functions.length + wasm.num_imported_funcs;
+        section.emit_u32v(count);
+        for (var i = 0; i < wasm.num_imported_funcs; i++) {
+          section.emit_u8(0); // empty string
+          section.emit_u8(0); // local names count == 0
+        }
+        for (let func of wasm.functions) {
+          var name = func.name == undefined ? "" : func.name;
+          section.emit_string(name);
+          section.emit_u8(0);  // local names count == 0
+        }
+      });
+    }
+
+    return binary;
+  }
+
+  toBuffer(debug = false) {
+    let bytes = this.toArray(debug);
+    let buffer = new ArrayBuffer(bytes.length);
+    let view = new Uint8Array(buffer);
+    for (let i = 0; i < bytes.length; i++) {
+      let val = bytes[i];
+      if ((typeof val) == "string") val = val.charCodeAt(0);
+      view[i] = val | 0;
+    }
+    return new Uint8Array(buffer);
+  }
+
+  instantiate(...args) {
+    let module = new WebAssembly.Module(this.toBuffer());
+    let instance = new WebAssembly.Instance(module, ...args);
+    return instance;
+  }
+}

From f20e40f0437956b7a902d140c6c565d2d21db5e6 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Wed, 17 Oct 2018 13:35:00 +0200
Subject: [PATCH 306/329] Update documentation for jsapi tests.

---
 test/js-api/README.md | 84 ++++++++++++++++++++++++++++++++++---------
 1 file changed, 68 insertions(+), 16 deletions(-)

diff --git a/test/js-api/README.md b/test/js-api/README.md
index cc545909e..ca30ca42f 100644
--- a/test/js-api/README.md
+++ b/test/js-api/README.md
@@ -1,19 +1,71 @@
-This directory contains tests specific to the JavaScript API to WebAssembly, as
-described in [JS.md](https://github.com/WebAssembly/design/blob/master/JS.md).
+This directory contains tests specific to the [JavaScript API] to WebAssembly.
 
-## Harness
+These tests exist in the [web-platform-tests project], and are included here
+primarily to simplify sharing them between JavaScript engine implementers.
 
 These tests can be run in a pure JavaScript environment, that is, a JS shell
-(like V8 or spidermonkey's shells), provided a few libraries and functions
-emulating the
-[testharness.js](http://testthewebforward.org/docs/testharness-library.html)
-library.
-
-- The `../harness/index.js`, `../harness/wasm-constants.js` and
-  `../harness/wasm-module-builder.js` must be imported first.
-- A function `test(function, description)` that tries to run the function under
-  a try/catch and maybe asserts in case of failure.
-- A function `promise_test(function, description)` where `function` returns a
-  `Promise` run by `promise_test`; a rejection means a failure here.
-- Assertion functions: `assert_equals(x, y)`, `assert_not_equals(x, y)`,
-  `assert_true(x)`, `assert_false(x)`, `assert_unreached()`.
+(like V8 or spidermonkey's shells), as well as in the browser.
+
+The tests use the [testharness.js] library and the [multi-global tests] setup
+for smooth integrations with the web-platform-tests project and the existing
+test infrastructure in implementations.
+
+## Metadata
+
+All tests must have the `.any.js` extension.
+
+In order to be run in the JavaScript shell, a metadata comment to add the
+`jsshell` scope to the default set of scopes (`window` and `dedicatedworker`)
+is required at the start of the file:
+
+```js
+// META: global=jsshell
+```
+
+Additional JavaScript files can be imported with
+
+```js
+// META: script=helper-file.js
+
+```
+
+## Harness
+
+A single test file contains multiple subtests, which are created with one of
+the following functions:
+
+- For synchronous tests: `test(function, name)` runs the function immediately.
+  The test fails if any assertion fails or an exception is thrown while calling
+  the function.
+- For asynchronous tests: `promise_test(function, name)` where `function`
+  returns a `Promise`. The test fails if the returned `Promise` rejects.
+
+All assertions must be in one of those subtests.
+
+A number of assertion functions are provided, e.g.:
+
+- `assert_equals(x, y)`;
+- `assert_not_equals(x, y)`;
+- `assert_true(x)`;
+- `assert_false(x)`;
+- `assert_unreached()`;
+- `assert_throws(error, function)`: checks if `function` throws an appropriate
+  exception (a typical value for `error` would be `new TypeError()`);
+- `assert_class_string(object, class_name)`: checks if the result of calling
+  `Object.prototype.toString` on `object` uses `class_name`;
+- `promise_rejects`: `assert_throws`, but for `Promise`s.
+
+All the above functions also take an optional trailing description argument.
+
+Non-trivial code that runs before the subtests should be put in the function
+argument to `setup(function)`, to ensure any exceptions are handled gracefully.
+
+Finally, the harness also exposes a `format_value` function that provides a
+helpful stringification of its argument.
+
+See the [testharness.js] documentation for more information.
+
+[JavaScript API]: https://webassembly.github.io/spec/js-api/
+[web-platform-tests project]: https://github.com/web-platform-tests/wpt/tree/master/wasm/jsapi
+[testharness.js]: https://web-platform-tests.org/writing-tests/testharness-api.html
+[multi-global tests]: https://web-platform-tests.org/writing-tests/testharness.html#multi-global-tests

From 64bf5c7a2447416f4690dae7c8ea9d7e2b841366 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Thu, 18 Oct 2018 12:08:52 +0200
Subject: [PATCH 307/329] Editorial: Note status of memory growth errors

Notes the goals of #879
Also change the name of the grow_memory instruction to memory.grow
---
 document/js-api/index.bs | 16 +++++++++++++---
 1 file changed, 13 insertions(+), 3 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 2cc5a89ac..3f82f3e37 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -161,7 +161,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
         text: const
     text: address; url: exec/runtime.html#addresses
     text: signed_32; url: exec/numerics.html#aux-signed
-    text: grow_memory; url: exec/instructions.html#exec-grow-memory
+    text: memory.grow; url: exec/instructions.html#exec-memory-grow
     text: current frame; url: exec/conventions.html#exec-notation-textual
     text: 𝗆𝗈𝖽𝗎𝗅𝖾; url: exec/runtime.html#syntax-frame
     text: 𝗆𝖾𝗆𝖺𝖽𝖽𝗋𝗌; url: exec/runtime.html#syntax-moduleinst
@@ -612,9 +612,9 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     1. Return |ret|.
 </div>
 
-Immediately after a WebAssembly [=grow_memory=] instruction executes, perform the following steps:
+Immediately after a WebAssembly [=memory.grow=] instruction executes, perform the following steps:
 
-<div algorithm="grow_memory">
+<div algorithm="memory.grow">
     1. If the top of the stack is not [=𝗂𝟥𝟤.𝖼𝗈𝗇𝗌𝗍=] (−1), then:
         1. Let |frame| be the [=current frame=].
         1. Assert: due to validation, |frame|.[=𝗆𝗈𝖽𝗎𝗅𝖾=].[=𝗆𝖾𝗆𝖺𝖽𝖽𝗋𝗌=][0] exists.
@@ -996,6 +996,16 @@ The particular exception here is implementation-defined in both cases.
 
 Note: ECMAScript doesn't specify any sort of behavior on out-of-memory conditions; implementations have been observed to throw OOMError and to crash. Either is valid here.
 
+<div class="issue">
+    A failed allocation of a large table or memory may either result in
+        - a {{RangeError}}, as specified in the {{Memory}} {{Memory/grow()}} and {{Table}} {{Table/grow()}} operations
+        - returning -1 as the [=memory.grow=] instruction
+        - UA-specific OOM behavior as described in this section.
+    In a future revision, we may reconsider more reliable and recoverable errors for allocations of large amounts of memory.
+
+    See [Issue 879](https://github.com/WebAssembly/spec/issues/879) for further discussion.
+</div>
+
 <h2 id="limits">Implementation-defined Limits</h2>
 
 The WebAssembly core specification allows an implementation to define limits on the syntactic structure of the module.

From 7e3c46a072a13fbfc871a3b78ddf7bd7e50a0ddd Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Fri, 19 Oct 2018 11:56:59 -0700
Subject: [PATCH 308/329] [core test] Tests long encoding of a segment index
 (#892)

The spec says that a data/element segment are required to have a `0` for
the memory/table index, but they can be written using a long encoding,
like `0x80 0x00`.
---
 test/core/binary.wast | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/test/core/binary.wast b/test/core/binary.wast
index dd7cca106..5ca969f51 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -114,6 +114,26 @@
   "\0b"                                ;; end
 )
 
+;; Data segment memory index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\05\03\01"                          ;; Memory section with 1 entry
+  "\00\00"                             ;; no max, minimum 0
+  "\0b\07\01"                          ;; Data section with 1 entry
+  "\80\00"                             ;; Memory index 0, encoded with 2 bytes
+  "\41\00\0b\00"                       ;; (i32.const 0) with contents ""
+)
+
+;; Element segment table index can have non-minimal length
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\04\04\01"                          ;; Table section with 1 entry
+  "\70\00\00"                          ;; no max, minimum 0, anyfunc
+  "\09\07\01"                          ;; Element section with 1 entry
+  "\80\00"                             ;; Table index 0, encoded with 2 bytes
+  "\41\00\0b\00"                       ;; (i32.const 0) with no elements
+)
+
 ;; Unsigned LEB128 must not be overlong
 (assert_malformed
   (module binary

From b0e783867ebc917c2b69a55f55ca5500e298e356 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Wed, 24 Oct 2018 15:38:49 +0800
Subject: [PATCH 309/329] [test] Fix building error introduced in #883 (#900)

---
 test/build.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/build.py b/test/build.py
index e9fc3b3d7..c8d7e026c 100755
--- a/test/build.py
+++ b/test/build.py
@@ -84,7 +84,7 @@ def build_js(out_js_dir, include_harness=False):
 
     print('Copying JS tests to the JS out dir...')
     for path in os.listdir(JS_TESTS_DIR):
-        abspath = os.path.join(JS_TESTS_DIR, js_file)
+        abspath = os.path.join(JS_TESTS_DIR, path)
         if os.path.isdir(abspath):
             shutil.copytree(abspath, os.path.join(out_js_dir, path))
         else:

From c90bc9686f1a90b76fb2ec782256d26323164c91 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Fri, 26 Oct 2018 01:56:17 +0800
Subject: [PATCH 310/329] [test] Test 'tee_local' and 'set_global' in more
 operators (#901)

---
 test/core/block.wast         | 11 +++++++++++
 test/core/br.wast            |  9 +++++++++
 test/core/br_if.wast         | 19 +++++++++++++++++++
 test/core/br_table.wast      | 16 ++++++++++++++++
 test/core/call.wast          | 10 ++++++++++
 test/core/call_indirect.wast | 11 +++++++++++
 test/core/if.wast            | 23 +++++++++++++++++++++++
 test/core/loop.wast          | 10 ++++++++++
 test/core/nop.wast           | 30 ++++++++++++++++++++++++++++++
 test/core/return.wast        |  9 +++++++++
 test/core/unreachable.wast   |  9 +++++++++
 11 files changed, 157 insertions(+)

diff --git a/test/core/block.wast b/test/core/block.wast
index 50aaab7b3..e2ab21847 100644
--- a/test/core/block.wast
+++ b/test/core/block.wast
@@ -167,6 +167,15 @@
   (func (export "as-set_local-value") (result i32)
     (local i32) (set_local 0 (block (result i32) (i32.const 1))) (get_local 0)
   )
+  (func (export "as-tee_local-value") (result i32)
+    (local i32) (tee_local 0 (block (result i32) (i32.const 1)))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-set_global-value") (result i32)
+    (set_global $a (block (result i32) (i32.const 1)))
+    (get_global $a)
+  )
+
   (func (export "as-load-operand") (result i32)
     (i32.load (block (result i32) (i32.const 1)))
   )
@@ -277,6 +286,8 @@
 (assert_return (invoke "as-drop-operand"))
 (assert_return (invoke "as-br-value") (i32.const 1))
 (assert_return (invoke "as-set_local-value") (i32.const 1))
+(assert_return (invoke "as-tee_local-value") (i32.const 1))
+(assert_return (invoke "as-set_global-value") (i32.const 1))
 (assert_return (invoke "as-load-operand") (i32.const 1))
 
 (assert_return (invoke "as-unary-operand") (i32.const 0))
diff --git a/test/core/br.wast b/test/core/br.wast
index e801a1b47..6624af1fe 100644
--- a/test/core/br.wast
+++ b/test/core/br.wast
@@ -181,6 +181,13 @@
   (func (export "as-set_local-value") (result i32) (local f32)
     (block (result i32) (set_local 0 (br 0 (i32.const 17))) (i32.const -1))
   )
+  (func (export "as-tee_local-value") (result i32) (local i32)
+    (block (result i32) (tee_local 0 (br 0 (i32.const 1))))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-set_global-value") (result i32)
+    (block (result i32) (set_global $a (br 0 (i32.const 1))))
+  )
 
   (memory 1)
   (func (export "as-load-address") (result f32)
@@ -377,6 +384,8 @@
 (assert_return (invoke "as-call_indirect-last") (i32.const 23))
 
 (assert_return (invoke "as-set_local-value") (i32.const 17))
+(assert_return (invoke "as-tee_local-value") (i32.const 1))
+(assert_return (invoke "as-set_global-value") (i32.const 1))
 
 (assert_return (invoke "as-load-address") (f32.const 1.7))
 (assert_return (invoke "as-loadN-address") (i64.const 30))
diff --git a/test/core/br_if.wast b/test/core/br_if.wast
index 378e45fba..68044004f 100644
--- a/test/core/br_if.wast
+++ b/test/core/br_if.wast
@@ -205,6 +205,19 @@
       (i32.const -1)
     )
   )
+  (func (export "as-tee_local-value") (param i32) (result i32)
+    (block (result i32)
+      (tee_local 0 (br_if 0 (i32.const 1) (get_local 0)))
+      (return (i32.const -1))
+    )
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-set_global-value") (param i32) (result i32)
+    (block (result i32)
+      (set_global $a (br_if 0 (i32.const 1) (get_local 0)))
+      (return (i32.const -1))
+    )
+  )
 
   (func (export "as-unary-operand") (result f64)
     (block (result f64) (f64.neg (br_if 0 (f64.const 1.0) (i32.const 1))))
@@ -391,6 +404,12 @@
 (assert_return (invoke "as-set_local-value" (i32.const 0)) (i32.const -1))
 (assert_return (invoke "as-set_local-value" (i32.const 1)) (i32.const 17))
 
+(assert_return (invoke "as-tee_local-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-tee_local-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-set_global-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-set_global-value" (i32.const 1)) (i32.const 1))
+
 (assert_return (invoke "as-unary-operand") (f64.const 1.0))
 (assert_return (invoke "as-binary-left") (i32.const 1))
 (assert_return (invoke "as-binary-right") (i32.const 1))
diff --git a/test/core/br_table.wast b/test/core/br_table.wast
index 7dc787b6b..a211824c3 100644
--- a/test/core/br_table.wast
+++ b/test/core/br_table.wast
@@ -1027,6 +1027,20 @@
       (i32.const -1)
     )
   )
+  (func (export "as-tee_local-value") (result i32)
+    (local i32)
+    (block (result i32)
+      (set_local 0 (br_table 0 (i32.const 1) (i32.const 1)))
+      (i32.const -1)
+    )
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-set_global-value") (result i32)
+    (block (result i32)
+      (set_global $a (br_table 0 (i32.const 1) (i32.const 1)))
+      (i32.const -1)
+    )
+  )
 
   (memory 1)
   (func (export "as-load-address") (result f32)
@@ -1342,6 +1356,8 @@
 (assert_return (invoke "as-call_indirect-func") (i32.const 23))
 
 (assert_return (invoke "as-set_local-value") (i32.const 17))
+(assert_return (invoke "as-tee_local-value") (i32.const 1))
+(assert_return (invoke "as-set_global-value") (i32.const 1))
 
 (assert_return (invoke "as-load-address") (f32.const 1.7))
 (assert_return (invoke "as-loadN-address") (i64.const 30))
diff --git a/test/core/call.wast b/test/core/call.wast
index 7f81dbb97..9223f1d8c 100644
--- a/test/core/call.wast
+++ b/test/core/call.wast
@@ -186,6 +186,14 @@
   (func (export "as-set_local-value") (result i32)
     (local i32) (set_local 0 (call $const-i32)) (get_local 0)
   )
+  (func (export "as-tee_local-value") (result i32)
+    (local i32) (tee_local 0 (call $const-i32))
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-set_global-value") (result i32)
+    (set_global $a (call $const-i32))
+    (get_global $a)
+  )
   (func (export "as-load-operand") (result i32)
     (i32.load (call $const-i32))
   )
@@ -260,6 +268,8 @@
 (assert_return (invoke "as-drop-operand"))
 (assert_return (invoke "as-br-value") (i32.const 0x132))
 (assert_return (invoke "as-set_local-value") (i32.const 0x132))
+(assert_return (invoke "as-tee_local-value") (i32.const 0x132))
+(assert_return (invoke "as-set_global-value") (i32.const 0x132))
 (assert_return (invoke "as-load-operand") (i32.const 1))
 
 ;; Invalid typing
diff --git a/test/core/call_indirect.wast b/test/core/call_indirect.wast
index 938cf7ab9..bcd912a2d 100644
--- a/test/core/call_indirect.wast
+++ b/test/core/call_indirect.wast
@@ -371,6 +371,15 @@
   (func (export "as-set_local-value") (result f64)
     (local f64) (set_local 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) (get_local 0)
   )
+  (func (export "as-tee_local-value") (result f64)
+    (local f64) (tee_local 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7)))
+  )
+  (global $a (mut f64) (f64.const 10.0))
+  (func (export "as-set_global-value") (result f64)
+    (set_global $a (call_indirect (type $over-f64) (f64.const 1.0) (i32.const 7)))
+    (get_global $a)
+  )
+
   (func (export "as-load-operand") (result i32)
     (i32.load (call_indirect (type $out-i32) (i32.const 0)))
   )
@@ -508,6 +517,8 @@
 (assert_return (invoke "as-drop-operand"))
 (assert_return (invoke "as-br-value") (f32.const 1))
 (assert_return (invoke "as-set_local-value") (f64.const 1))
+(assert_return (invoke "as-tee_local-value") (f64.const 1))
+(assert_return (invoke "as-set_global-value") (f64.const 1.0))
 (assert_return (invoke "as-load-operand") (i32.const 1))
 
 ;; Invalid syntax
diff --git a/test/core/if.wast b/test/core/if.wast
index 1c2f90225..240668780 100644
--- a/test/core/if.wast
+++ b/test/core/if.wast
@@ -271,6 +271,23 @@
     )
     (get_local 0)
   )
+  (func (export "as-tee_local-value") (param i32) (result i32)
+    (tee_local 0
+      (if (result i32) (get_local 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    )
+  )
+  (global $a (mut i32) (i32.const 10))
+  (func (export "as-set_global-value") (param i32) (result i32)
+    (set_global $a
+      (if (result i32) (get_local 0)
+        (then (i32.const 1))
+        (else (i32.const 0))
+      )
+    ) (get_global $a)
+  )
   (func (export "as-load-operand") (param i32) (result i32)
     (i32.load
       (if (result i32) (get_local 0)
@@ -445,6 +462,12 @@
 (assert_return (invoke "as-set_local-value" (i32.const 0)) (i32.const 0))
 (assert_return (invoke "as-set_local-value" (i32.const 1)) (i32.const 1))
 
+(assert_return (invoke "as-tee_local-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-tee_local-value" (i32.const 1)) (i32.const 1))
+
+(assert_return (invoke "as-set_global-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-set_global-value" (i32.const 1)) (i32.const 1))
+
 (assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 0))
 (assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 0))
 
diff --git a/test/core/loop.wast b/test/core/loop.wast
index a250d0133..13b3f6fc9 100644
--- a/test/core/loop.wast
+++ b/test/core/loop.wast
@@ -158,6 +158,14 @@
   (func (export "as-set_local-value") (result i32)
     (local i32) (set_local 0 (loop (result i32) (i32.const 1))) (get_local 0)
   )
+  (func (export "as-tee_local-value") (result i32)
+    (local i32) (tee_local 0 (loop (result i32) (i32.const 1)))
+  )
+  (global $a (mut i32) (i32.const 0))
+  (func (export "as-set_global-value") (result i32)
+    (set_global $a (loop (result i32) (i32.const 1)))
+    (get_global $a)
+  )
   (func (export "as-load-operand") (result i32)
     (i32.load (loop (result i32) (i32.const 1)))
   )
@@ -327,6 +335,8 @@
 (assert_return (invoke "as-drop-operand"))
 (assert_return (invoke "as-br-value") (i32.const 1))
 (assert_return (invoke "as-set_local-value") (i32.const 1))
+(assert_return (invoke "as-tee_local-value") (i32.const 1))
+(assert_return (invoke "as-set_global-value") (i32.const 1))
 (assert_return (invoke "as-load-operand") (i32.const 1))
 
 (assert_return (invoke "as-unary-operand") (i32.const 0))
diff --git a/test/core/nop.wast b/test/core/nop.wast
index 67931a741..211685872 100644
--- a/test/core/nop.wast
+++ b/test/core/nop.wast
@@ -257,6 +257,28 @@
     (nop) (nop) (i32.const 2) (nop) (nop) (set_local 0) (get_local 0)
   )
 
+  (func (export "as-tee_local-first") (param i32) (result i32)
+    (nop) (i32.const 2) (tee_local 0)
+  )
+  (func (export "as-tee_local-last") (param i32) (result i32)
+    (i32.const 2) (nop) (tee_local 0)
+  )
+  (func (export "as-tee_local-everywhere") (param i32) (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (tee_local 0)
+  )
+
+  (global $a (mut i32) (i32.const 0))
+  (func (export "as-set_global-first") (result i32)
+    (nop) (i32.const 2) (set_global $a) (get_global $a)
+  )
+  (func (export "as-set_global-last") (result i32)
+    (i32.const 2) (nop) (set_global $a) (get_global $a)
+  )
+  (func (export "as-set_global-everywhere") (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (set_global 0)
+    (get_global $a)
+  )
+
   (func (export "as-load-first") (param i32) (result i32)
     (nop) (get_local 0) (i32.load)
   )
@@ -369,6 +391,14 @@
 (assert_return (invoke "as-set_local-last" (i32.const 1)) (i32.const 2))
 (assert_return (invoke "as-set_local-everywhere" (i32.const 1)) (i32.const 2))
 
+(assert_return (invoke "as-tee_local-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-tee_local-last" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-tee_local-everywhere" (i32.const 1)) (i32.const 2))
+
+(assert_return (invoke "as-set_global-first") (i32.const 2))
+(assert_return (invoke "as-set_global-last") (i32.const 2))
+(assert_return (invoke "as-set_global-everywhere") (i32.const 2))
+
 (assert_return (invoke "as-load-first" (i32.const 100)) (i32.const 0))
 (assert_return (invoke "as-load-last" (i32.const 100)) (i32.const 0))
 (assert_return (invoke "as-load-everywhere" (i32.const 100)) (i32.const 0))
diff --git a/test/core/return.wast b/test/core/return.wast
index 775baaa09..395ae8eb3 100644
--- a/test/core/return.wast
+++ b/test/core/return.wast
@@ -160,6 +160,13 @@
   (func (export "as-set_local-value") (result i32) (local f32)
     (set_local 0 (return (i32.const 17))) (i32.const -1)
   )
+  (func (export "as-tee_local-value") (result i32) (local i32)
+    (tee_local 0 (return (i32.const 1)))
+  )
+  (global $a (mut i32) (i32.const 0))
+  (func (export "as-set_global-value") (result i32)
+    (set_global $a (return (i32.const 1)))
+  )
 
   (memory 1)
   (func (export "as-load-address") (result f32)
@@ -275,6 +282,8 @@
 (assert_return (invoke "as-call_indirect-last") (i32.const 23))
 
 (assert_return (invoke "as-set_local-value") (i32.const 17))
+(assert_return (invoke "as-tee_local-value") (i32.const 1))
+(assert_return (invoke "as-set_global-value") (i32.const 1))
 
 (assert_return (invoke "as-load-address") (f32.const 1.7))
 (assert_return (invoke "as-loadN-address") (i64.const 30))
diff --git a/test/core/unreachable.wast b/test/core/unreachable.wast
index f9b888e02..791dd8338 100644
--- a/test/core/unreachable.wast
+++ b/test/core/unreachable.wast
@@ -154,6 +154,13 @@
   (func (export "as-set_local-value") (local f32)
     (set_local 0 (unreachable))
   )
+  (func (export "as-tee_local-value") (result f32) (local f32)
+    (tee_local 0 (unreachable))
+  )
+  (global $a (mut f32) (f32.const 0))
+  (func (export "as-set_global-value") (result f32)
+    (set_global $a (unreachable))
+  )
 
   (memory 1)
   (func (export "as-load-address") (result f32)
@@ -265,6 +272,8 @@
 (assert_trap (invoke "as-call_indirect-last") "unreachable")
 
 (assert_trap (invoke "as-set_local-value") "unreachable")
+(assert_trap (invoke "as-tee_local-value") "unreachable")
+(assert_trap (invoke "as-set_global-value") "unreachable")
 
 (assert_trap (invoke "as-load-address") "unreachable")
 (assert_trap (invoke "as-loadN-address") "unreachable")

From a56cf2ec042da382f0196fe14dcbd7ff2e973466 Mon Sep 17 00:00:00 2001
From: Daniel Ehrenberg <littledan@chromium.org>
Date: Wed, 31 Oct 2018 17:38:57 +0100
Subject: [PATCH 311/329] Editorial: Explicitly convert between list and
 sequence

JS/Web specs use mutable lists as a common data structure, whereas
the WebAssembly core specification uses a logical (immutable) sequence
data structure. This patch explicitly converts from a list to a
sequence to reduce ambiguity.
---
 document/js-api/index.bs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 3f82f3e37..80f414c91 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -165,6 +165,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df
     text: current frame; url: exec/conventions.html#exec-notation-textual
     text: 𝗆𝗈𝖽𝗎𝗅𝖾; url: exec/runtime.html#syntax-frame
     text: 𝗆𝖾𝗆𝖺𝖽𝖽𝗋𝗌; url: exec/runtime.html#syntax-moduleinst
+    text: sequence; url: syntax/conventions.html#grammar-notation
 </pre>
 
 <pre class='link-defaults'>
@@ -886,7 +887,8 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
         1. Otherwise, let |arg| be undefined.
         1. [=Append=] [=ToWebAssemblyValue=](|arg|, |t|) to |args|.
         1. Set |i| to |i| + 1.
-    1. Let (|store|, |ret|) be the result of [=invoke_func=](|store|, |funcaddr|, |args|).
+    1. Let |argsSeq| be a WebAssembly [=sequence=] containing the elements of |args|.
+    1. Let (|store|, |ret|) be the result of [=invoke_func=](|store|, |funcaddr|, |argsSeq|).
     1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
     1. If |ret| is [=error=], throw an exception. This exception should be a WebAssembly {{RuntimeError}} exception, unless otherwise indicated by <a href="#errors">the WebAssembly error mapping</a>.
     1. If |ret| is empty, return undefined.

From 5aaea96eceb1e1a3956d7cbb499920e5b8c1109f Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Thu, 8 Nov 2018 01:00:04 +0800
Subject: [PATCH 312/329] [test] Improve test coverage (#904)

---
 test/core/br_if.wast         |  51 ++++++-
 test/core/call.wast          |  36 +++++
 test/core/call_indirect.wast |  67 +++++++++
 test/core/memory.wast        | 268 +++++++++++++++++++++++++++++++++++
 test/core/memory_grow.wast   | 212 +++++++++++++++++++++++++++
 test/core/select.wast        |  31 ++++
 test/core/set_local.wast     |  52 +++++++
 test/core/tee_local.wast     | 239 +++++++++++++++++++++++++++++++
 8 files changed, 955 insertions(+), 1 deletion(-)

diff --git a/test/core/br_if.wast b/test/core/br_if.wast
index 68044004f..c9402c82f 100644
--- a/test/core/br_if.wast
+++ b/test/core/br_if.wast
@@ -219,6 +219,36 @@
     )
   )
 
+  (memory 1)
+  (func (export "as-load-address") (result i32)
+    (block (result i32) (i32.load (br_if 0 (i32.const 1) (i32.const 1))))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (block (result i32) (i32.load8_s (br_if 0 (i32.const 30) (i32.const 1))))
+  )
+
+  (func (export "as-store-address") (result i32)
+    (block (result i32)
+      (i32.store (br_if 0 (i32.const 30) (i32.const 1)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-store-value") (result i32)
+    (block (result i32)
+      (i32.store (i32.const 2) (br_if 0 (i32.const 31) (i32.const 1))) (i32.const -1)
+    )
+  )
+
+  (func (export "as-storeN-address") (result i32)
+    (block (result i32)
+      (i32.store8 (br_if 0 (i32.const 32) (i32.const 1)) (i32.const 7)) (i32.const -1)
+    )
+  )
+  (func (export "as-storeN-value") (result i32)
+    (block (result i32)
+      (i32.store16 (i32.const 2) (br_if 0 (i32.const 33) (i32.const 1))) (i32.const -1)
+    )
+  )
+
   (func (export "as-unary-operand") (result f64)
     (block (result f64) (f64.neg (br_if 0 (f64.const 1.0) (i32.const 1))))
   )
@@ -228,8 +258,16 @@
   (func (export "as-binary-right") (result i32)
     (block (result i32) (i32.sub (i32.const 10) (br_if 0 (i32.const 1) (i32.const 1))))
   )
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (br_if 0 (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (i32.le_u (br_if 0 (i32.const 1) (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (i32.ne (i32.const 10) (br_if 0 (i32.const 1) (i32.const 42))))
+  )
 
-  (memory 0)
   (func (export "as-memory.grow-size") (result i32)
     (block (result i32) (memory.grow (br_if 0 (i32.const 1) (i32.const 1))))
   )
@@ -410,9 +448,20 @@
 (assert_return (invoke "as-set_global-value" (i32.const 0)) (i32.const -1))
 (assert_return (invoke "as-set_global-value" (i32.const 1)) (i32.const 1))
 
+(assert_return (invoke "as-load-address") (i32.const 1))
+(assert_return (invoke "as-loadN-address") (i32.const 30))
+
+(assert_return (invoke "as-store-address") (i32.const 30))
+(assert_return (invoke "as-store-value") (i32.const 31))
+(assert_return (invoke "as-storeN-address") (i32.const 32))
+(assert_return (invoke "as-storeN-value") (i32.const 33))
+
 (assert_return (invoke "as-unary-operand") (f64.const 1.0))
 (assert_return (invoke "as-binary-left") (i32.const 1))
 (assert_return (invoke "as-binary-right") (i32.const 1))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
 (assert_return (invoke "as-memory.grow-size") (i32.const 1))
 
 (assert_return (invoke "nested-block-value" (i32.const 0)) (i32.const 21))
diff --git a/test/core/call.wast b/test/core/call.wast
index 9223f1d8c..c7cb98146 100644
--- a/test/core/call.wast
+++ b/test/core/call.wast
@@ -197,6 +197,34 @@
   (func (export "as-load-operand") (result i32)
     (i32.load (call $const-i32))
   )
+
+  (func $dummy (param i32) (result i32) (get_local 0))
+  (func $du (param f32) (result f32) (get_local 0))
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32) (f32.sqrt (call $du (f32.const 0x0p+0))))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32) (i32.add (call $dummy (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32) (i32.sub (i32.const 10) (call $dummy (i32.const 1))))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32) (i32.eqz (call $dummy (i32.const 1))))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32) (i32.le_u (call $dummy (i32.const 1)) (i32.const 10)))
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32) (i32.ne (i32.const 10) (call $dummy (i32.const 1))))
+  )
+
+  (func (export "as-convert-operand") (result i64)
+    (block (result i64) (i64.extend_s/i32 (call $dummy (i32.const 1))))
+  )
 )
 
 (assert_return (invoke "type-i32") (i32.const 0x132))
@@ -272,6 +300,14 @@
 (assert_return (invoke "as-set_global-value") (i32.const 0x132))
 (assert_return (invoke "as-load-operand") (i32.const 1))
 
+(assert_return (invoke "as-unary-operand") (f32.const 0x0p+0))
+(assert_return (invoke "as-binary-left") (i32.const 11))
+(assert_return (invoke "as-binary-right") (i32.const 9))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+(assert_return (invoke "as-convert-operand") (i64.const 1))
+
 ;; Invalid typing
 
 (assert_invalid
diff --git a/test/core/call_indirect.wast b/test/core/call_indirect.wast
index bcd912a2d..f227b7840 100644
--- a/test/core/call_indirect.wast
+++ b/test/core/call_indirect.wast
@@ -383,6 +383,65 @@
   (func (export "as-load-operand") (result i32)
     (i32.load (call_indirect (type $out-i32) (i32.const 0)))
   )
+
+  (func (export "as-unary-operand") (result f32)
+    (block (result f32)
+      (f32.sqrt
+        (call_indirect (type $over-f32) (f32.const 0x0p+0) (i32.const 6))
+      )
+    )
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (block (result i32)
+      (i32.add
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-binary-right") (result i32)
+    (block (result i32)
+      (i32.sub
+        (i32.const 10)
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (block (result i32)
+      (i32.eqz
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (block (result i32)
+      (i32.le_u
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+        (i32.const 10)
+      )
+    )
+  )
+  (func (export "as-compare-right") (result i32)
+    (block (result i32)
+      (i32.ne
+        (i32.const 10)
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
+  (func (export "as-convert-operand") (result i64)
+    (block (result i64)
+      (i64.extend_s/i32
+        (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
+      )
+    )
+  )
+
 )
 
 (assert_return (invoke "type-i32") (i32.const 0x132))
@@ -521,6 +580,14 @@
 (assert_return (invoke "as-set_global-value") (f64.const 1.0))
 (assert_return (invoke "as-load-operand") (i32.const 1))
 
+(assert_return (invoke "as-unary-operand") (f32.const 0x0p+0))
+(assert_return (invoke "as-binary-left") (i32.const 11))
+(assert_return (invoke "as-binary-right") (i32.const 9))
+(assert_return (invoke "as-test-operand") (i32.const 0))
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+(assert_return (invoke "as-convert-operand") (i64.const 1))
+
 ;; Invalid syntax
 
 (assert_malformed
diff --git a/test/core/memory.wast b/test/core/memory.wast
index 498fda60f..a3d87e554 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -211,6 +211,274 @@
 (assert_return (invoke "i64_load32_u" (i64.const 0xfedcba9856346543)) (i64.const 0x56346543))
 (assert_return (invoke "i64_load32_u" (i64.const 0x3456436598bacdef)) (i64.const 0x98bacdef))
 
+;; Load operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (i32.load (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (i32.load (i32.const 0))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.load (i32.const 0)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (i32.load (i32.const 0)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (i32.load (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (i32.load (i32.const 0)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (i32.load (i32.const 0))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i32)
+    (return (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (i32.load (i32.const 0))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.load (i32.const 0))) (else (i32.const 0))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 0)) (else (i32.load (i32.const 0)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (i32.load (i32.const 0)) (get_local 0) (get_local 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (get_local 0) (i32.load (i32.const 0)) (get_local 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (i32.load (i32.const 0)))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $f (i32.load (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $f (i32.const 1) (i32.load (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $f (i32.const 1) (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table anyfunc (elem $f))
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $sig)
+      (i32.load (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.load (i32.const 0)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.load (i32.const 0)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (i32.load (i32.const 0))
+    )
+  )
+
+  (func (export "as-set_local-value") (local i32)
+    (set_local 0 (i32.load (i32.const 0)))
+  )
+  (func (export "as-tee_local-value") (result i32) (local i32)
+    (tee_local 0 (i32.load (i32.const 0)))
+  )
+  (global $g (mut i32) (i32.const 0))
+  (func (export "as-set_global-value") (local i32)
+    (set_global $g (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-load-address") (result i32)
+    (i32.load (i32.load (i32.const 0)))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (i32.load8_s (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-store-address")
+    (i32.store (i32.load (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-store-value")
+    (i32.store (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (i32.load8_s (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i32.store16 (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.clz (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (i32.load (i32.const 100)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i32)
+    (i32.sub (i32.const 10) (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (i32.le_s (i32.load (i32.const 100)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (i32.ne (i32.const 10) (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (i32.load (i32.const 100)))
+  )
+)
+
+(assert_return (invoke "as-br-value") (i32.const 0))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 0))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 7))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 0))
+(assert_return (invoke "as-br_table-value-index") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 0))
+
+(assert_return (invoke "as-if-cond") (i32.const 1))
+(assert_return (invoke "as-if-then") (i32.const 0))
+(assert_return (invoke "as-if-else") (i32.const 0))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-select-cond") (i32.const 1))
+
+(assert_return (invoke "as-call-first") (i32.const -1))
+(assert_return (invoke "as-call-mid") (i32.const -1))
+(assert_return (invoke "as-call-last") (i32.const -1))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const -1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const -1))
+(assert_return (invoke "as-call_indirect-last") (i32.const -1))
+(assert_return (invoke "as-call_indirect-index") (i32.const -1))
+
+(assert_return (invoke "as-set_local-value"))
+(assert_return (invoke "as-tee_local-value") (i32.const 0))
+(assert_return (invoke "as-set_global-value"))
+
+(assert_return (invoke "as-load-address") (i32.const 0))
+(assert_return (invoke "as-loadN-address") (i32.const 0))
+(assert_return (invoke "as-store-address"))
+(assert_return (invoke "as-store-value"))
+(assert_return (invoke "as-storeN-address"))
+(assert_return (invoke "as-storeN-value"))
+
+(assert_return (invoke "as-unary-operand") (i32.const 32))
+
+(assert_return (invoke "as-binary-left") (i32.const 10))
+(assert_return (invoke "as-binary-right") (i32.const 10))
+
+(assert_return (invoke "as-test-operand") (i32.const 1))
+
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 1))
+
+;; Store operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+
+  (func (export "as-block-value")
+    (block (i32.store (i32.const 0) (i32.const 1)))
+  )
+  (func (export "as-loop-value")
+    (loop (i32.store (i32.const 0) (i32.const 1)))
+  )
+
+  (func (export "as-br-value")
+    (block (br 0 (i32.store (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-br_if-value")
+    (block
+      (br_if 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond")
+    (block
+      (br_if 0 (i32.const 6) (i32.store (i32.const 0) (i32.const 1)))
+    )
+  )
+  (func (export "as-br_table-value")
+    (block
+      (br_table 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1))
+    )
+  )
+
+  (func (export "as-return-value")
+    (return (i32.store (i32.const 0) (i32.const 1)))
+  )
+
+  (func (export "as-if-then")
+    (if (i32.const 1) (then (i32.store (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-if-else")
+    (if (i32.const 0) (then) (else (i32.store (i32.const 0) (i32.const 1))))
+  )
+)
+
+(assert_return (invoke "as-block-value"))
+(assert_return (invoke "as-loop-value"))
+
+(assert_return (invoke "as-br-value"))
+(assert_return (invoke "as-br_if-value"))
+(assert_return (invoke "as-br_if-value-cond"))
+(assert_return (invoke "as-br_table-value"))
+
+(assert_return (invoke "as-return-value"))
+
+(assert_return (invoke "as-if-then"))
+(assert_return (invoke "as-if-else"))
+
 (assert_malformed
   (module quote
     "(memory 1)"
diff --git a/test/core/memory_grow.wast b/test/core/memory_grow.wast
index cd1466016..c00354cfc 100644
--- a/test/core/memory_grow.wast
+++ b/test/core/memory_grow.wast
@@ -95,3 +95,215 @@
 (assert_return (invoke "check-memory-zero" (i32.const 0x40000) (i32.const 0x4_ffff)) (i32.const 0))
 (assert_return (invoke "grow" (i32.const 1)) (i32.const 5))
 (assert_return (invoke "check-memory-zero" (i32.const 0x50000) (i32.const 0x5_ffff)) (i32.const 0))
+
+;; As the argument of control constructs and instructions
+
+(module
+  (memory 1)
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (memory.grow (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (memory.grow (i32.const 0))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (memory.grow (i32.const 0)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (memory.grow (i32.const 0)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (memory.grow (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (memory.grow (i32.const 0)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (memory.grow (i32.const 0))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i32)
+    (return (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (memory.grow (i32.const 0))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (memory.grow (i32.const 0))) (else (i32.const 0))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 0)) (else (memory.grow (i32.const 0)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (memory.grow (i32.const 0)) (get_local 0) (get_local 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (get_local 0) (memory.grow (i32.const 0)) (get_local 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (memory.grow (i32.const 0)))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $f (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $f (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $f (i32.const 1) (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table anyfunc (elem $f))
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $sig)
+      (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (memory.grow (i32.const 0)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (memory.grow (i32.const 0)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (memory.grow (i32.const 0))
+    )
+  )
+
+  (func (export "as-set_local-value") (local i32)
+    (set_local 0 (memory.grow (i32.const 0)))
+  )
+  (func (export "as-tee_local-value") (result i32) (local i32)
+    (tee_local 0 (memory.grow (i32.const 0)))
+  )
+  (global $g (mut i32) (i32.const 0))
+  (func (export "as-set_global-value") (local i32)
+    (set_global $g (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-load-address") (result i32)
+    (i32.load (memory.grow (i32.const 0)))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (i32.load8_s (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-store-address")
+    (i32.store (memory.grow (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-store-value")
+    (i32.store (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (memory.grow (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i32.store16 (i32.const 2) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.clz (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (memory.grow (i32.const 0)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i32)
+    (i32.sub (i32.const 10) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (i32.le_s (memory.grow (i32.const 0)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (i32.ne (i32.const 10) (memory.grow (i32.const 0)))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (memory.grow (i32.const 0)))
+  )
+)
+
+(assert_return (invoke "as-br-value") (i32.const 1))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 1))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 6))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 1))
+(assert_return (invoke "as-br_table-value-index") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 1))
+
+(assert_return (invoke "as-if-cond") (i32.const 0))
+(assert_return (invoke "as-if-then") (i32.const 1))
+(assert_return (invoke "as-if-else") (i32.const 1))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-select-cond") (i32.const 0))
+
+(assert_return (invoke "as-call-first") (i32.const -1))
+(assert_return (invoke "as-call-mid") (i32.const -1))
+(assert_return (invoke "as-call-last") (i32.const -1))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const -1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const -1))
+(assert_return (invoke "as-call_indirect-last") (i32.const -1))
+(assert_trap (invoke "as-call_indirect-index") "undefined element")
+
+(assert_return (invoke "as-set_local-value"))
+(assert_return (invoke "as-tee_local-value") (i32.const 1))
+(assert_return (invoke "as-set_global-value"))
+
+(assert_return (invoke "as-load-address") (i32.const 0))
+(assert_return (invoke "as-loadN-address") (i32.const 0))
+(assert_return (invoke "as-store-address"))
+(assert_return (invoke "as-store-value"))
+(assert_return (invoke "as-storeN-address"))
+(assert_return (invoke "as-storeN-value"))
+
+(assert_return (invoke "as-unary-operand") (i32.const 31))
+
+(assert_return (invoke "as-binary-left") (i32.const 11))
+(assert_return (invoke "as-binary-right") (i32.const 9))
+
+(assert_return (invoke "as-test-operand") (i32.const 0))
+
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 1))
diff --git a/test/core/select.wast b/test/core/select.wast
index ba8074604..f98cd7486 100644
--- a/test/core/select.wast
+++ b/test/core/select.wast
@@ -152,6 +152,29 @@
       (select (i32.const 1) (i32.const 2) (get_local 0))
     )
   )
+  (func (export "as-test-operand") (param i32) (result i32)
+    (block (result i32)
+      (i32.eqz (select (i32.const 0) (i32.const 1) (get_local 0)))
+    )
+  )
+
+  (func (export "as-compare-left") (param i32) (result i32)
+    (block (result i32)
+      (i32.le_s (select (i32.const 1) (i32.const 2) (get_local 0)) (i32.const 1))
+    )
+  )
+  (func (export "as-compare-right") (param i32) (result i32)
+    (block (result i32)
+      (i32.ne (i32.const 1) (select (i32.const 0) (i32.const 1) (get_local 0)))
+    )
+  )
+
+  (func (export "as-convert-operand") (param i32) (result i32)
+    (block (result i32)
+      (i32.wrap/i64 (select (i64.const 1) (i64.const 0) (get_local 0)))
+    )
+  )
+
 )
 
 (assert_return (invoke "select_i32" (i32.const 1) (i32.const 2) (i32.const 1)) (i32.const 1))
@@ -254,6 +277,14 @@
 (assert_return (invoke "as-unary-operand" (i32.const 1)) (i32.const 1))
 (assert_return (invoke "as-binary-operand" (i32.const 0)) (i32.const 4))
 (assert_return (invoke "as-binary-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-test-operand" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-compare-left" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-compare-left" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-compare-right" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-compare-right" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-convert-operand" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-convert-operand" (i32.const 1)) (i32.const 1))
 
 (assert_invalid
   (module (func $arity-0 (select (nop) (nop) (i32.const 1))))
diff --git a/test/core/set_local.wast b/test/core/set_local.wast
index 5a006e114..e789f23f4 100644
--- a/test/core/set_local.wast
+++ b/test/core/set_local.wast
@@ -63,6 +63,45 @@
       )
     )
   )
+
+  ;; As parameter of control constructs and instructions
+
+  (func (export "as-block-value") (param i32)
+    (block (set_local 0 (i32.const 1)))
+  )
+  (func (export "as-loop-value") (param i32)
+    (loop (set_local 0 (i32.const 3)))
+  )
+
+  (func (export "as-br-value") (param i32)
+    (block (br 0 (set_local 0 (i32.const 9))))
+  )
+  (func (export "as-br_if-value") (param i32)
+    (block
+      (br_if 0 (set_local 0 (i32.const 8)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32)
+    (block
+      (br_if 0 (i32.const 6) (set_local 0 (i32.const 9)))
+    )
+  )
+  (func (export "as-br_table-value") (param i32)
+    (block
+      (br_table 0 (set_local 0 (i32.const 10)) (i32.const 1))
+    )
+  )
+
+  (func (export "as-return-value") (param i32)
+    (return (set_local 0 (i32.const 7)))
+  )
+
+  (func (export "as-if-then") (param i32)
+    (if (get_local 0) (then (set_local 0 (i32.const 3))))
+  )
+  (func (export "as-if-else") (param i32)
+    (if (get_local 0) (then) (else (set_local 0 (i32.const 1))))
+  )
 )
 
 (assert_return (invoke "type-local-i32"))
@@ -75,6 +114,19 @@
 (assert_return (invoke "type-param-f32" (f32.const 4.4)))
 (assert_return (invoke "type-param-f64" (f64.const 5.5)))
 
+(assert_return (invoke "as-block-value" (i32.const 0)))
+(assert_return (invoke "as-loop-value" (i32.const 0)))
+
+(assert_return (invoke "as-br-value" (i32.const 0)))
+(assert_return (invoke "as-br_if-value" (i32.const 0)))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 0)))
+(assert_return (invoke "as-br_table-value" (i32.const 0)))
+
+(assert_return (invoke "as-return-value" (i32.const 0)))
+
+(assert_return (invoke "as-if-then" (i32.const 1)))
+(assert_return (invoke "as-if-else" (i32.const 0)))
+
 (assert_return
   (invoke "type-mixed"
     (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5)
diff --git a/test/core/tee_local.wast b/test/core/tee_local.wast
index 452793e30..028d704ee 100644
--- a/test/core/tee_local.wast
+++ b/test/core/tee_local.wast
@@ -93,6 +93,188 @@
       )
     )
   )
+
+  (func $dummy)
+
+  (func (export "as-block-first") (param i32) (result i32)
+    (block (result i32) (tee_local 0 (i32.const 1)) (call $dummy))
+  )
+  (func (export "as-block-mid") (param i32) (result i32)
+    (block (result i32) (call $dummy) (tee_local 0 (i32.const 1)) (call $dummy))
+  )
+  (func (export "as-block-last") (param i32) (result i32)
+    (block (result i32) (call $dummy) (call $dummy) (tee_local 0 (i32.const 1)))
+  )
+
+  (func (export "as-loop-first") (param i32) (result i32)
+    (loop (result i32) (tee_local 0 (i32.const 3)) (call $dummy))
+  )
+  (func (export "as-loop-mid") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (tee_local 0 (i32.const 4)) (call $dummy))
+  )
+  (func (export "as-loop-last") (param i32) (result i32)
+    (loop (result i32) (call $dummy) (call $dummy) (tee_local 0 (i32.const 5)))
+  )
+
+  (func (export "as-br-value") (param i32) (result i32)
+    (block (result i32) (br 0 (tee_local 0 (i32.const 9))))
+  )
+
+  (func (export "as-br_if-cond") (param i32)
+    (block (br_if 0 (tee_local 0 (i32.const 1))))
+  )
+  (func (export "as-br_if-value") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (tee_local 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (param i32) (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (tee_local 0 (i32.const 9)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index") (param i32)
+    (block (br_table 0 0 0 (tee_local 0 (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (param i32) (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (tee_local 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (param i32) (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (tee_local 0 (i32.const 11))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (param i32) (result i32)
+    (return (tee_local 0 (i32.const 7)))
+  )
+
+  (func (export "as-if-cond") (param i32) (result i32)
+    (if (result i32) (tee_local 0 (i32.const 2))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (param i32) (result i32)
+    (if (result i32) (get_local 0)
+      (then (tee_local 0 (i32.const 3))) (else (get_local 0))
+    )
+  )
+  (func (export "as-if-else") (param i32) (result i32)
+    (if (result i32) (get_local 0)
+      (then (get_local 0)) (else (tee_local 0 (i32.const 4)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (tee_local 0 (i32.const 5)) (get_local 0) (get_local 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (get_local 0) (tee_local 0 (i32.const 6)) (get_local 1))
+  )
+  (func (export "as-select-cond") (param i32) (result i32)
+    (select (i32.const 0) (i32.const 1) (tee_local 0 (i32.const 7)))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (param i32) (result i32)
+    (call $f (tee_local 0 (i32.const 12)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (param i32) (result i32)
+    (call $f (i32.const 1) (tee_local 0 (i32.const 13)) (i32.const 3))
+  )
+  (func (export "as-call-last") (param i32) (result i32)
+    (call $f (i32.const 1) (i32.const 2) (tee_local 0 (i32.const 14)))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table anyfunc (elem $f))
+  (func (export "as-call_indirect-first") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (tee_local 0 (i32.const 1)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (tee_local 0 (i32.const 2)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (tee_local 0 (i32.const 3)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (param i32) (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (tee_local 0 (i32.const 0))
+    )
+  )
+
+  (func (export "as-set_local-value") (local i32)
+    (set_local 0 (tee_local 0 (i32.const 1)))
+  )
+  (func (export "as-tee_local-value") (param i32) (result i32)
+    (tee_local 0 (tee_local 0 (i32.const 1)))
+  )
+  (global $g (mut i32) (i32.const 0))
+  (func (export "as-set_global-value") (local i32)
+    (set_global $g (tee_local 0 (i32.const 1)))
+  )
+
+  (memory 1)
+  (func (export "as-load-address") (param i32) (result i32)
+    (i32.load (tee_local 0 (i32.const 1)))
+  )
+  (func (export "as-loadN-address") (param i32) (result i32)
+    (i32.load8_s (tee_local 0 (i32.const 3)))
+  )
+
+  (func (export "as-store-address") (param i32)
+    (i32.store (tee_local 0 (i32.const 30)) (i32.const 7))
+  )
+  (func (export "as-store-value") (param i32)
+    (i32.store (i32.const 2) (tee_local 0 (i32.const 1)))
+  )
+
+  (func (export "as-storeN-address") (param i32)
+    (i32.store8 (tee_local 0 (i32.const 1)) (i32.const 7))
+  )
+  (func (export "as-storeN-value") (param i32)
+    (i32.store16 (i32.const 2) (tee_local 0 (i32.const 1)))
+  )
+
+  (func (export "as-unary-operand") (param f32) (result f32)
+    (f32.neg (tee_local 0 (f32.const nan:0x0f1e2)))
+  )
+
+  (func (export "as-binary-left") (param i32) (result i32)
+    (i32.add (tee_local 0 (i32.const 3)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (param i32) (result i32)
+    (i32.sub (i32.const 10) (tee_local 0 (i32.const 4)))
+  )
+
+  (func (export "as-test-operand") (param i32) (result i32)
+    (i32.eqz (tee_local 0 (i32.const 0)))
+  )
+
+  (func (export "as-compare-left") (param i32) (result i32)
+    (i32.le_s (tee_local 0 (i32.const 43)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (param i32) (result i32)
+    (i32.ne (i32.const 10) (tee_local 0 (i32.const 42)))
+  )
+
+  (func (export "as-convert-operand") (param i64) (result i32)
+    (i32.wrap/i64 (tee_local 0 (i64.const 41)))
+  )
+
+  (func (export "as-memory.grow-size") (param i32) (result i32)
+    (memory.grow (tee_local 0 (i32.const 40)))
+  )
+
 )
 
 (assert_return (invoke "type-local-i32") (i32.const 0))
@@ -105,6 +287,63 @@
 (assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 11.1))
 (assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 12.2))
 
+(assert_return (invoke "as-block-first" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-block-mid" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-block-last" (i32.const 0)) (i32.const 1))
+
+(assert_return (invoke "as-loop-first" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "as-loop-mid" (i32.const 0)) (i32.const 4))
+(assert_return (invoke "as-loop-last" (i32.const 0)) (i32.const 5))
+
+(assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 9))
+
+(assert_return (invoke "as-br_if-cond" (i32.const 0)))
+(assert_return (invoke "as-br_if-value" (i32.const 0)) (i32.const 8))
+(assert_return (invoke "as-br_if-value-cond" (i32.const 0)) (i32.const 6))
+
+(assert_return (invoke "as-br_table-index" (i32.const 0)))
+(assert_return (invoke "as-br_table-value" (i32.const 0)) (i32.const 10))
+(assert_return (invoke "as-br_table-value-index" (i32.const 0)) (i32.const 6))
+
+(assert_return (invoke "as-return-value" (i32.const 0)) (i32.const 7))
+
+(assert_return (invoke "as-if-cond" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-if-then" (i32.const 1)) (i32.const 3))
+(assert_return (invoke "as-if-else" (i32.const 0)) (i32.const 4))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 5))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 6))
+(assert_return (invoke "as-select-cond" (i32.const 0)) (i32.const 0))
+
+(assert_return (invoke "as-call-first" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call-mid" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call-last" (i32.const 0)) (i32.const -1))
+
+(assert_return (invoke "as-call_indirect-first" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call_indirect-mid" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-call_indirect-index" (i32.const 0)) (i32.const -1))
+
+(assert_return (invoke "as-set_local-value"))
+(assert_return (invoke "as-tee_local-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-set_global-value"))
+
+(assert_return (invoke "as-load-address" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-loadN-address" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-store-address" (i32.const 0)))
+(assert_return (invoke "as-store-value" (i32.const 0)))
+(assert_return (invoke "as-storeN-address" (i32.const 0)))
+(assert_return (invoke "as-storeN-value" (i32.const 0)))
+
+(assert_return (invoke "as-unary-operand" (f32.const 0)) (f32.const -nan:0x0f1e2))
+(assert_return (invoke "as-binary-left" (i32.const 0)) (i32.const 13))
+(assert_return (invoke "as-binary-right" (i32.const 0)) (i32.const 6))
+(assert_return (invoke "as-test-operand" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-compare-left" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-compare-right" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-convert-operand" (i64.const 0)) (i32.const 41))
+(assert_return (invoke "as-memory.grow-size" (i32.const 0)) (i32.const 1))
+
 (assert_return
   (invoke "type-mixed"
     (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5)

From f4ce19869043c9668078d05b5113ec2f95ccbf99 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 20 Nov 2018 18:26:38 +0100
Subject: [PATCH 313/329] Fix renaming of .exe in winmake.bat

---
 interpreter/Makefile    | 2 +-
 interpreter/winmake.bat | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/interpreter/Makefile b/interpreter/Makefile
index 69a6b402b..7b44c1199 100644
--- a/interpreter/Makefile
+++ b/interpreter/Makefile
@@ -106,7 +106,7 @@ $(WINMAKE):	clean
 		| grep -v ocamldep \
 		| grep -v mkdir \
 		| sed s:`which ocaml`:ocaml:g \
-		| sed s:host/main.d.byte:%NAME%.exe: \
+		| sed s:main/main.d.byte:%NAME%.exe: \
 		>>$@
 
 
diff --git a/interpreter/winmake.bat b/interpreter/winmake.bat
index bc915bc24..5a9657e39 100644
--- a/interpreter/winmake.bat
+++ b/interpreter/winmake.bat
@@ -89,4 +89,4 @@ ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I text -I util -I binary -I
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/parser.d.cmo text/parser.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/arrange.d.cmo text/arrange.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o util/sexpr.d.cmo util/sexpr.ml
-ocamlc.opt bigarray.cma -g util/lib.d.cmo binary/utf8.d.cmo exec/float.d.cmo exec/f32.d.cmo exec/f64.d.cmo exec/numeric_error.d.cmo exec/int.d.cmo exec/i32.d.cmo exec/i64.d.cmo exec/i32_convert.d.cmo exec/f32_convert.d.cmo exec/i64_convert.d.cmo exec/f64_convert.d.cmo syntax/types.d.cmo syntax/values.d.cmo runtime/memory.d.cmo util/source.d.cmo syntax/ast.d.cmo exec/eval_numeric.d.cmo runtime/func.d.cmo runtime/global.d.cmo runtime/table.d.cmo runtime/instance.d.cmo util/error.d.cmo exec/eval.d.cmo host/env.d.cmo host/spectest.d.cmo main/flags.d.cmo script/import.d.cmo binary/encode.d.cmo syntax/operators.d.cmo binary/decode.d.cmo script/script.d.cmo text/parser.d.cmo text/lexer.d.cmo text/parse.d.cmo script/js.d.cmo util/sexpr.d.cmo text/arrange.d.cmo text/print.d.cmo valid/valid.d.cmo script/run.d.cmo main/main.d.cmo -o main/main.d.byte
+ocamlc.opt bigarray.cma -g util/lib.d.cmo binary/utf8.d.cmo exec/float.d.cmo exec/f32.d.cmo exec/f64.d.cmo exec/numeric_error.d.cmo exec/int.d.cmo exec/i32.d.cmo exec/i64.d.cmo exec/i32_convert.d.cmo exec/f32_convert.d.cmo exec/i64_convert.d.cmo exec/f64_convert.d.cmo syntax/types.d.cmo syntax/values.d.cmo runtime/memory.d.cmo util/source.d.cmo syntax/ast.d.cmo exec/eval_numeric.d.cmo runtime/func.d.cmo runtime/global.d.cmo runtime/table.d.cmo runtime/instance.d.cmo util/error.d.cmo exec/eval.d.cmo host/env.d.cmo host/spectest.d.cmo main/flags.d.cmo script/import.d.cmo binary/encode.d.cmo syntax/operators.d.cmo binary/decode.d.cmo script/script.d.cmo text/parser.d.cmo text/lexer.d.cmo text/parse.d.cmo script/js.d.cmo util/sexpr.d.cmo text/arrange.d.cmo text/print.d.cmo valid/valid.d.cmo script/run.d.cmo main/main.d.cmo -o main.exe

From e8222139162103144ff5263030d7e92982b4586c Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@chromium.org>
Date: Tue, 20 Nov 2018 20:43:52 +0100
Subject: [PATCH 314/329] wasm.exe, not main.exe

---
 interpreter/winmake.bat | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/winmake.bat b/interpreter/winmake.bat
index 5a9657e39..aa27c1463 100644
--- a/interpreter/winmake.bat
+++ b/interpreter/winmake.bat
@@ -89,4 +89,4 @@ ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I text -I util -I binary -I
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/parser.d.cmo text/parser.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I text -I util -I binary -I valid -I syntax -I runtime -I host -I script -I main -I exec -o text/arrange.d.cmo text/arrange.ml
 ocamlc.opt -c -w +a-4-27-42-44-45 -warn-error +a -g -I util -I binary -I valid -I syntax -I runtime -I host -I script -I text -I main -I exec -o util/sexpr.d.cmo util/sexpr.ml
-ocamlc.opt bigarray.cma -g util/lib.d.cmo binary/utf8.d.cmo exec/float.d.cmo exec/f32.d.cmo exec/f64.d.cmo exec/numeric_error.d.cmo exec/int.d.cmo exec/i32.d.cmo exec/i64.d.cmo exec/i32_convert.d.cmo exec/f32_convert.d.cmo exec/i64_convert.d.cmo exec/f64_convert.d.cmo syntax/types.d.cmo syntax/values.d.cmo runtime/memory.d.cmo util/source.d.cmo syntax/ast.d.cmo exec/eval_numeric.d.cmo runtime/func.d.cmo runtime/global.d.cmo runtime/table.d.cmo runtime/instance.d.cmo util/error.d.cmo exec/eval.d.cmo host/env.d.cmo host/spectest.d.cmo main/flags.d.cmo script/import.d.cmo binary/encode.d.cmo syntax/operators.d.cmo binary/decode.d.cmo script/script.d.cmo text/parser.d.cmo text/lexer.d.cmo text/parse.d.cmo script/js.d.cmo util/sexpr.d.cmo text/arrange.d.cmo text/print.d.cmo valid/valid.d.cmo script/run.d.cmo main/main.d.cmo -o main.exe
+ocamlc.opt bigarray.cma -g util/lib.d.cmo binary/utf8.d.cmo exec/float.d.cmo exec/f32.d.cmo exec/f64.d.cmo exec/numeric_error.d.cmo exec/int.d.cmo exec/i32.d.cmo exec/i64.d.cmo exec/i32_convert.d.cmo exec/f32_convert.d.cmo exec/i64_convert.d.cmo exec/f64_convert.d.cmo syntax/types.d.cmo syntax/values.d.cmo runtime/memory.d.cmo util/source.d.cmo syntax/ast.d.cmo exec/eval_numeric.d.cmo runtime/func.d.cmo runtime/global.d.cmo runtime/table.d.cmo runtime/instance.d.cmo util/error.d.cmo exec/eval.d.cmo host/env.d.cmo host/spectest.d.cmo main/flags.d.cmo script/import.d.cmo binary/encode.d.cmo syntax/operators.d.cmo binary/decode.d.cmo script/script.d.cmo text/parser.d.cmo text/lexer.d.cmo text/parse.d.cmo script/js.d.cmo util/sexpr.d.cmo text/arrange.d.cmo text/print.d.cmo valid/valid.d.cmo script/run.d.cmo main/main.d.cmo -o wasm.exe

From 758987548cfcdd47bf0f8e388c9dd0a7341996e1 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Tue, 27 Nov 2018 16:27:41 +0800
Subject: [PATCH 315/329] [test] Move tests in store_retval.wast to relevant
 test files (#918)

---
 test/core/get_local.wast    | 17 +++++++
 test/core/memory.wast       | 96 +++++++++++++++++++++++++++++++++++++
 test/core/set_local.wast    | 17 +++++++
 test/core/store_retval.wast | 55 ---------------------
 4 files changed, 130 insertions(+), 55 deletions(-)
 delete mode 100644 test/core/store_retval.wast

diff --git a/test/core/get_local.wast b/test/core/get_local.wast
index e1f9625b9..6b68355bf 100644
--- a/test/core/get_local.wast
+++ b/test/core/get_local.wast
@@ -116,6 +116,23 @@
   "type mismatch"
 )
 
+(assert_invalid
+  (module (func $i32-vs-empty (local i32) (get_local 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $i64-vs-empty (local i64) (get_local 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $f32-vs-empty (local f32) (get_local 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $f64-vs-empty (local f64) (get_local 0)))
+  "type mismatch"
+)
+
 
 ;; Invalid local index
 
diff --git a/test/core/memory.wast b/test/core/memory.wast
index a3d87e554..155e64f39 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -622,3 +622,99 @@
   )
   "unknown operator"
 )
+
+;; store should have no retval
+(assert_invalid
+  (module (memory 1) (func (param i32) (result i32) (i32.store (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param f32) (result f32) (f32.store (i32.const 0) (f32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param f64) (result f64) (f64.store (i32.const 0) (f64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i32) (result i32) (i32.store8 (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i32) (result i32) (i32.store16 (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store8 (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store16 (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store32 (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)
+
+;; load should have retval
+(assert_invalid
+  (module (memory 1) (func $load_i32 (i32.load (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_s_i32 (i32.load8_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_u_i32 (i32.load8_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_s_i32 (i32.load16_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_u_i32 (i32.load16_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load_i64 (i64.load (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_s_i64 (i64.load8_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_u_i64 (i64.load8_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_s_i64 (i64.load16_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_u_i64 (i64.load16_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load32_s_i64 (i64.load32_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load32_u_i64 (i64.load32_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load_f32 (f32.load (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load_f64 (f64.load (i32.const 0))))
+  "type mismatch"
+)
diff --git a/test/core/set_local.wast b/test/core/set_local.wast
index e789f23f4..97c560a3d 100644
--- a/test/core/set_local.wast
+++ b/test/core/set_local.wast
@@ -212,6 +212,23 @@
   "type mismatch"
 )
 
+(assert_invalid
+  (module (func $i32-vs-empty (param i32) (result i32) (set_local 0 (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $i64-vs-empty (param i64) (result i64) (set_local 0 (i64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $f32-vs-empty (param f32) (result f32) (set_local 0 (f32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $f64-vs-empty (param f64) (result f64) (set_local 0 (f64.const 1))))
+  "type mismatch"
+)
+
 
 ;; Invalid local index
 
diff --git a/test/core/store_retval.wast b/test/core/store_retval.wast
deleted file mode 100644
index a4d03582f..000000000
--- a/test/core/store_retval.wast
+++ /dev/null
@@ -1,55 +0,0 @@
-(assert_invalid
-  (module (func (param i32) (result i32) (set_local 0 (i32.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func (param i64) (result i64) (set_local 0 (i64.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func (param f32) (result f32) (set_local 0 (f32.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func (param f64) (result f64) (set_local 0 (f64.const 1))))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (memory 1) (func (param i32) (result i32) (i32.store (i32.const 0) (i32.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param i64) (result i64) (i64.store (i32.const 0) (i64.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param f32) (result f32) (f32.store (i32.const 0) (f32.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param f64) (result f64) (f64.store (i32.const 0) (f64.const 1))))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (memory 1) (func (param i32) (result i32) (i32.store8 (i32.const 0) (i32.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param i32) (result i32) (i32.store16 (i32.const 0) (i32.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param i64) (result i64) (i64.store8 (i32.const 0) (i64.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param i64) (result i64) (i64.store16 (i32.const 0) (i64.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param i64) (result i64) (i64.store32 (i32.const 0) (i64.const 1))))
-  "type mismatch"
-)
-

From 3dc2dc2932a1643799327520fde9f9b2e2d6b263 Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Tue, 27 Nov 2018 16:29:25 +0800
Subject: [PATCH 316/329] [test] Correct "br_if2" function in labels.wast
 (#920)

Fixed: function "br_if2" doesn't actually use `br_if`
---
 test/core/labels.wast | 13 ++++++++++---
 1 file changed, 10 insertions(+), 3 deletions(-)

diff --git a/test/core/labels.wast b/test/core/labels.wast
index 3df5006ba..5873687c6 100644
--- a/test/core/labels.wast
+++ b/test/core/labels.wast
@@ -227,16 +227,23 @@
           (i32.const 1)
         )
       )
-      (i32.const 1)
+      (i32.const 0)
     )
   )
 
   (func (export "br_if2") (result i32)
     (block $l0 (result i32)
       (if (i32.const 1)
-        (then (br $l0 (block $l1 (result i32) (br $l1 (i32.const 1)))))
+        (then
+          (drop
+            (br_if $l0
+              (block $l1 (result i32) (br $l1 (i32.const 1)))
+              (i32.const 1)
+            )
+          )
+        )
       )
-      (i32.const 1)
+      (i32.const 0)
     )
   )
 

From 6028a965953e4e5e632ffb9b1831a5dbe074d1ac Mon Sep 17 00:00:00 2001
From: Wanming Lin <wanming.lin@intel.com>
Date: Wed, 28 Nov 2018 14:53:20 +0800
Subject: [PATCH 317/329] [test] Split memory.wast (#922)

into {memory,load,store}.wast, to match the convention of having one file per construct.
---
 test/core/load.wast   | 366 ++++++++++++++++++++++++++++++
 test/core/memory.wast | 508 ------------------------------------------
 test/core/store.wast  | 146 ++++++++++++
 3 files changed, 512 insertions(+), 508 deletions(-)
 create mode 100644 test/core/load.wast
 create mode 100644 test/core/store.wast

diff --git a/test/core/load.wast b/test/core/load.wast
new file mode 100644
index 000000000..12ea96b2a
--- /dev/null
+++ b/test/core/load.wast
@@ -0,0 +1,366 @@
+;; Load operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+
+  (func (export "as-br-value") (result i32)
+    (block (result i32) (br 0 (i32.load (i32.const 0))))
+  )
+
+  (func (export "as-br_if-cond")
+    (block (br_if 0 (i32.load (i32.const 0))))
+  )
+  (func (export "as-br_if-value") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.load (i32.const 0)) (i32.const 1))) (i32.const 7)
+    )
+  )
+  (func (export "as-br_if-value-cond") (result i32)
+    (block (result i32)
+      (drop (br_if 0 (i32.const 6) (i32.load (i32.const 0)))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-br_table-index")
+    (block (br_table 0 0 0 (i32.load (i32.const 0))))
+  )
+  (func (export "as-br_table-value") (result i32)
+    (block (result i32)
+      (br_table 0 0 0 (i32.load (i32.const 0)) (i32.const 1)) (i32.const 7)
+    )
+  )
+  (func (export "as-br_table-value-index") (result i32)
+    (block (result i32)
+      (br_table 0 0 (i32.const 6) (i32.load (i32.const 0))) (i32.const 7)
+    )
+  )
+
+  (func (export "as-return-value") (result i32)
+    (return (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-if-cond") (result i32)
+    (if (result i32) (i32.load (i32.const 0))
+      (then (i32.const 0)) (else (i32.const 1))
+    )
+  )
+  (func (export "as-if-then") (result i32)
+    (if (result i32) (i32.const 1)
+      (then (i32.load (i32.const 0))) (else (i32.const 0))
+    )
+  )
+  (func (export "as-if-else") (result i32)
+    (if (result i32) (i32.const 0)
+      (then (i32.const 0)) (else (i32.load (i32.const 0)))
+    )
+  )
+
+  (func (export "as-select-first") (param i32 i32) (result i32)
+    (select (i32.load (i32.const 0)) (get_local 0) (get_local 1))
+  )
+  (func (export "as-select-second") (param i32 i32) (result i32)
+    (select (get_local 0) (i32.load (i32.const 0)) (get_local 1))
+  )
+  (func (export "as-select-cond") (result i32)
+    (select (i32.const 0) (i32.const 1) (i32.load (i32.const 0)))
+  )
+
+  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
+  (func (export "as-call-first") (result i32)
+    (call $f (i32.load (i32.const 0)) (i32.const 2) (i32.const 3))
+  )
+  (func (export "as-call-mid") (result i32)
+    (call $f (i32.const 1) (i32.load (i32.const 0)) (i32.const 3))
+  )
+  (func (export "as-call-last") (result i32)
+    (call $f (i32.const 1) (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (type $sig (func (param i32 i32 i32) (result i32)))
+  (table anyfunc (elem $f))
+  (func (export "as-call_indirect-first") (result i32)
+    (call_indirect (type $sig)
+      (i32.load (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-mid") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.load (i32.const 0)) (i32.const 3) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-last") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.load (i32.const 0)) (i32.const 0)
+    )
+  )
+  (func (export "as-call_indirect-index") (result i32)
+    (call_indirect (type $sig)
+      (i32.const 1) (i32.const 2) (i32.const 3) (i32.load (i32.const 0))
+    )
+  )
+
+  (func (export "as-set_local-value") (local i32)
+    (set_local 0 (i32.load (i32.const 0)))
+  )
+  (func (export "as-tee_local-value") (result i32) (local i32)
+    (tee_local 0 (i32.load (i32.const 0)))
+  )
+  (global $g (mut i32) (i32.const 0))
+  (func (export "as-set_global-value") (local i32)
+    (set_global $g (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-load-address") (result i32)
+    (i32.load (i32.load (i32.const 0)))
+  )
+  (func (export "as-loadN-address") (result i32)
+    (i32.load8_s (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-store-address")
+    (i32.store (i32.load (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-store-value")
+    (i32.store (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-storeN-address")
+    (i32.store8 (i32.load8_s (i32.const 0)) (i32.const 7))
+  )
+  (func (export "as-storeN-value")
+    (i32.store16 (i32.const 2) (i32.load (i32.const 0)))
+  )
+
+  (func (export "as-unary-operand") (result i32)
+    (i32.clz (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-binary-left") (result i32)
+    (i32.add (i32.load (i32.const 100)) (i32.const 10))
+  )
+  (func (export "as-binary-right") (result i32)
+    (i32.sub (i32.const 10) (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-test-operand") (result i32)
+    (i32.eqz (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-compare-left") (result i32)
+    (i32.le_s (i32.load (i32.const 100)) (i32.const 10))
+  )
+  (func (export "as-compare-right") (result i32)
+    (i32.ne (i32.const 10) (i32.load (i32.const 100)))
+  )
+
+  (func (export "as-memory.grow-size") (result i32)
+    (memory.grow (i32.load (i32.const 100)))
+  )
+)
+
+(assert_return (invoke "as-br-value") (i32.const 0))
+
+(assert_return (invoke "as-br_if-cond"))
+(assert_return (invoke "as-br_if-value") (i32.const 0))
+(assert_return (invoke "as-br_if-value-cond") (i32.const 7))
+
+(assert_return (invoke "as-br_table-index"))
+(assert_return (invoke "as-br_table-value") (i32.const 0))
+(assert_return (invoke "as-br_table-value-index") (i32.const 6))
+
+(assert_return (invoke "as-return-value") (i32.const 0))
+
+(assert_return (invoke "as-if-cond") (i32.const 1))
+(assert_return (invoke "as-if-then") (i32.const 0))
+(assert_return (invoke "as-if-else") (i32.const 0))
+
+(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 0))
+(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-select-cond") (i32.const 1))
+
+(assert_return (invoke "as-call-first") (i32.const -1))
+(assert_return (invoke "as-call-mid") (i32.const -1))
+(assert_return (invoke "as-call-last") (i32.const -1))
+
+(assert_return (invoke "as-call_indirect-first") (i32.const -1))
+(assert_return (invoke "as-call_indirect-mid") (i32.const -1))
+(assert_return (invoke "as-call_indirect-last") (i32.const -1))
+(assert_return (invoke "as-call_indirect-index") (i32.const -1))
+
+(assert_return (invoke "as-set_local-value"))
+(assert_return (invoke "as-tee_local-value") (i32.const 0))
+(assert_return (invoke "as-set_global-value"))
+
+(assert_return (invoke "as-load-address") (i32.const 0))
+(assert_return (invoke "as-loadN-address") (i32.const 0))
+(assert_return (invoke "as-store-address"))
+(assert_return (invoke "as-store-value"))
+(assert_return (invoke "as-storeN-address"))
+(assert_return (invoke "as-storeN-value"))
+
+(assert_return (invoke "as-unary-operand") (i32.const 32))
+
+(assert_return (invoke "as-binary-left") (i32.const 10))
+(assert_return (invoke "as-binary-right") (i32.const 10))
+
+(assert_return (invoke "as-test-operand") (i32.const 1))
+
+(assert_return (invoke "as-compare-left") (i32.const 1))
+(assert_return (invoke "as-compare-right") (i32.const 1))
+
+(assert_return (invoke "as-memory.grow-size") (i32.const 1))
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load32 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load32_u (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load32_s (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load64 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load64_u (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i32) (i32.load64_s (get_local 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i64) (i64.load64 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i64) (i64.load64_u (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result i64) (i64.load64_s (get_local 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f32) (f32.load32 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f32) (f32.load64 (get_local 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f64) (f64.load32 (get_local 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (result f64) (f64.load64 (get_local 0)))"
+  )
+  "unknown operator"
+)
+
+
+;; load should have retval
+
+(assert_invalid
+  (module (memory 1) (func $load_i32 (i32.load (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_s_i32 (i32.load8_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_u_i32 (i32.load8_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_s_i32 (i32.load16_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_u_i32 (i32.load16_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load_i64 (i64.load (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_s_i64 (i64.load8_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load8_u_i64 (i64.load8_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_s_i64 (i64.load16_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load16_u_i64 (i64.load16_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load32_s_i64 (i64.load32_s (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load32_u_i64 (i64.load32_u (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load_f32 (f32.load (i32.const 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func $load_f64 (f64.load (i32.const 0))))
+  "type mismatch"
+)
diff --git a/test/core/memory.wast b/test/core/memory.wast
index 155e64f39..a1646d2b0 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -210,511 +210,3 @@
 (assert_return (invoke "i64_load32_s" (i64.const 0x3456436598bacdef)) (i64.const 0xffffffff98bacdef))
 (assert_return (invoke "i64_load32_u" (i64.const 0xfedcba9856346543)) (i64.const 0x56346543))
 (assert_return (invoke "i64_load32_u" (i64.const 0x3456436598bacdef)) (i64.const 0x98bacdef))
-
-;; Load operator as the argument of control constructs and instructions
-
-(module
-  (memory 1)
-
-  (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (i32.load (i32.const 0))))
-  )
-
-  (func (export "as-br_if-cond")
-    (block (br_if 0 (i32.load (i32.const 0))))
-  )
-  (func (export "as-br_if-value") (result i32)
-    (block (result i32)
-      (drop (br_if 0 (i32.load (i32.const 0)) (i32.const 1))) (i32.const 7)
-    )
-  )
-  (func (export "as-br_if-value-cond") (result i32)
-    (block (result i32)
-      (drop (br_if 0 (i32.const 6) (i32.load (i32.const 0)))) (i32.const 7)
-    )
-  )
-
-  (func (export "as-br_table-index")
-    (block (br_table 0 0 0 (i32.load (i32.const 0))))
-  )
-  (func (export "as-br_table-value") (result i32)
-    (block (result i32)
-      (br_table 0 0 0 (i32.load (i32.const 0)) (i32.const 1)) (i32.const 7)
-    )
-  )
-  (func (export "as-br_table-value-index") (result i32)
-    (block (result i32)
-      (br_table 0 0 (i32.const 6) (i32.load (i32.const 0))) (i32.const 7)
-    )
-  )
-
-  (func (export "as-return-value") (result i32)
-    (return (i32.load (i32.const 0)))
-  )
-
-  (func (export "as-if-cond") (result i32)
-    (if (result i32) (i32.load (i32.const 0))
-      (then (i32.const 0)) (else (i32.const 1))
-    )
-  )
-  (func (export "as-if-then") (result i32)
-    (if (result i32) (i32.const 1)
-      (then (i32.load (i32.const 0))) (else (i32.const 0))
-    )
-  )
-  (func (export "as-if-else") (result i32)
-    (if (result i32) (i32.const 0)
-      (then (i32.const 0)) (else (i32.load (i32.const 0)))
-    )
-  )
-
-  (func (export "as-select-first") (param i32 i32) (result i32)
-    (select (i32.load (i32.const 0)) (get_local 0) (get_local 1))
-  )
-  (func (export "as-select-second") (param i32 i32) (result i32)
-    (select (get_local 0) (i32.load (i32.const 0)) (get_local 1))
-  )
-  (func (export "as-select-cond") (result i32)
-    (select (i32.const 0) (i32.const 1) (i32.load (i32.const 0)))
-  )
-
-  (func $f (param i32 i32 i32) (result i32) (i32.const -1))
-  (func (export "as-call-first") (result i32)
-    (call $f (i32.load (i32.const 0)) (i32.const 2) (i32.const 3))
-  )
-  (func (export "as-call-mid") (result i32)
-    (call $f (i32.const 1) (i32.load (i32.const 0)) (i32.const 3))
-  )
-  (func (export "as-call-last") (result i32)
-    (call $f (i32.const 1) (i32.const 2) (i32.load (i32.const 0)))
-  )
-
-  (type $sig (func (param i32 i32 i32) (result i32)))
-  (table anyfunc (elem $f))
-  (func (export "as-call_indirect-first") (result i32)
-    (call_indirect (type $sig)
-      (i32.load (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
-    )
-  )
-  (func (export "as-call_indirect-mid") (result i32)
-    (call_indirect (type $sig)
-      (i32.const 1) (i32.load (i32.const 0)) (i32.const 3) (i32.const 0)
-    )
-  )
-  (func (export "as-call_indirect-last") (result i32)
-    (call_indirect (type $sig)
-      (i32.const 1) (i32.const 2) (i32.load (i32.const 0)) (i32.const 0)
-    )
-  )
-  (func (export "as-call_indirect-index") (result i32)
-    (call_indirect (type $sig)
-      (i32.const 1) (i32.const 2) (i32.const 3) (i32.load (i32.const 0))
-    )
-  )
-
-  (func (export "as-set_local-value") (local i32)
-    (set_local 0 (i32.load (i32.const 0)))
-  )
-  (func (export "as-tee_local-value") (result i32) (local i32)
-    (tee_local 0 (i32.load (i32.const 0)))
-  )
-  (global $g (mut i32) (i32.const 0))
-  (func (export "as-set_global-value") (local i32)
-    (set_global $g (i32.load (i32.const 0)))
-  )
-
-  (func (export "as-load-address") (result i32)
-    (i32.load (i32.load (i32.const 0)))
-  )
-  (func (export "as-loadN-address") (result i32)
-    (i32.load8_s (i32.load (i32.const 0)))
-  )
-
-  (func (export "as-store-address")
-    (i32.store (i32.load (i32.const 0)) (i32.const 7))
-  )
-  (func (export "as-store-value")
-    (i32.store (i32.const 2) (i32.load (i32.const 0)))
-  )
-
-  (func (export "as-storeN-address")
-    (i32.store8 (i32.load8_s (i32.const 0)) (i32.const 7))
-  )
-  (func (export "as-storeN-value")
-    (i32.store16 (i32.const 2) (i32.load (i32.const 0)))
-  )
-
-  (func (export "as-unary-operand") (result i32)
-    (i32.clz (i32.load (i32.const 100)))
-  )
-
-  (func (export "as-binary-left") (result i32)
-    (i32.add (i32.load (i32.const 100)) (i32.const 10))
-  )
-  (func (export "as-binary-right") (result i32)
-    (i32.sub (i32.const 10) (i32.load (i32.const 100)))
-  )
-
-  (func (export "as-test-operand") (result i32)
-    (i32.eqz (i32.load (i32.const 100)))
-  )
-
-  (func (export "as-compare-left") (result i32)
-    (i32.le_s (i32.load (i32.const 100)) (i32.const 10))
-  )
-  (func (export "as-compare-right") (result i32)
-    (i32.ne (i32.const 10) (i32.load (i32.const 100)))
-  )
-
-  (func (export "as-memory.grow-size") (result i32)
-    (memory.grow (i32.load (i32.const 100)))
-  )
-)
-
-(assert_return (invoke "as-br-value") (i32.const 0))
-
-(assert_return (invoke "as-br_if-cond"))
-(assert_return (invoke "as-br_if-value") (i32.const 0))
-(assert_return (invoke "as-br_if-value-cond") (i32.const 7))
-
-(assert_return (invoke "as-br_table-index"))
-(assert_return (invoke "as-br_table-value") (i32.const 0))
-(assert_return (invoke "as-br_table-value-index") (i32.const 6))
-
-(assert_return (invoke "as-return-value") (i32.const 0))
-
-(assert_return (invoke "as-if-cond") (i32.const 1))
-(assert_return (invoke "as-if-then") (i32.const 0))
-(assert_return (invoke "as-if-else") (i32.const 0))
-
-(assert_return (invoke "as-select-first" (i32.const 0) (i32.const 1)) (i32.const 0))
-(assert_return (invoke "as-select-second" (i32.const 0) (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-select-cond") (i32.const 1))
-
-(assert_return (invoke "as-call-first") (i32.const -1))
-(assert_return (invoke "as-call-mid") (i32.const -1))
-(assert_return (invoke "as-call-last") (i32.const -1))
-
-(assert_return (invoke "as-call_indirect-first") (i32.const -1))
-(assert_return (invoke "as-call_indirect-mid") (i32.const -1))
-(assert_return (invoke "as-call_indirect-last") (i32.const -1))
-(assert_return (invoke "as-call_indirect-index") (i32.const -1))
-
-(assert_return (invoke "as-set_local-value"))
-(assert_return (invoke "as-tee_local-value") (i32.const 0))
-(assert_return (invoke "as-set_global-value"))
-
-(assert_return (invoke "as-load-address") (i32.const 0))
-(assert_return (invoke "as-loadN-address") (i32.const 0))
-(assert_return (invoke "as-store-address"))
-(assert_return (invoke "as-store-value"))
-(assert_return (invoke "as-storeN-address"))
-(assert_return (invoke "as-storeN-value"))
-
-(assert_return (invoke "as-unary-operand") (i32.const 32))
-
-(assert_return (invoke "as-binary-left") (i32.const 10))
-(assert_return (invoke "as-binary-right") (i32.const 10))
-
-(assert_return (invoke "as-test-operand") (i32.const 1))
-
-(assert_return (invoke "as-compare-left") (i32.const 1))
-(assert_return (invoke "as-compare-right") (i32.const 1))
-
-(assert_return (invoke "as-memory.grow-size") (i32.const 1))
-
-;; Store operator as the argument of control constructs and instructions
-
-(module
-  (memory 1)
-
-  (func (export "as-block-value")
-    (block (i32.store (i32.const 0) (i32.const 1)))
-  )
-  (func (export "as-loop-value")
-    (loop (i32.store (i32.const 0) (i32.const 1)))
-  )
-
-  (func (export "as-br-value")
-    (block (br 0 (i32.store (i32.const 0) (i32.const 1))))
-  )
-  (func (export "as-br_if-value")
-    (block
-      (br_if 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1))
-    )
-  )
-  (func (export "as-br_if-value-cond")
-    (block
-      (br_if 0 (i32.const 6) (i32.store (i32.const 0) (i32.const 1)))
-    )
-  )
-  (func (export "as-br_table-value")
-    (block
-      (br_table 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1))
-    )
-  )
-
-  (func (export "as-return-value")
-    (return (i32.store (i32.const 0) (i32.const 1)))
-  )
-
-  (func (export "as-if-then")
-    (if (i32.const 1) (then (i32.store (i32.const 0) (i32.const 1))))
-  )
-  (func (export "as-if-else")
-    (if (i32.const 0) (then) (else (i32.store (i32.const 0) (i32.const 1))))
-  )
-)
-
-(assert_return (invoke "as-block-value"))
-(assert_return (invoke "as-loop-value"))
-
-(assert_return (invoke "as-br-value"))
-(assert_return (invoke "as-br_if-value"))
-(assert_return (invoke "as-br_if-value-cond"))
-(assert_return (invoke "as-br_table-value"))
-
-(assert_return (invoke "as-return-value"))
-
-(assert_return (invoke "as-if-then"))
-(assert_return (invoke "as-if-else"))
-
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result i32) (i32.load32 (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result i32) (i32.load32_u (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result i32) (i32.load32_s (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result i32) (i32.load64 (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result i32) (i32.load64_u (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result i32) (i32.load64_s (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (i32.store32 (get_local 0) (i32.const 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (i32.store64 (get_local 0) (i64.const 0)))"
-  )
-  "unknown operator"
-)
-
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result i64) (i64.load64 (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result i64) (i64.load64_u (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result i64) (i64.load64_s (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (i64.store64 (get_local 0) (i64.const 0)))"
-  )
-  "unknown operator"
-)
-
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result f32) (f32.load32 (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result f32) (f32.load64 (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (f32.store32 (get_local 0) (f32.const 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (f32.store64 (get_local 0) (f64.const 0)))"
-  )
-  "unknown operator"
-)
-
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result f64) (f64.load32 (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (result f64) (f64.load64 (get_local 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (f64.store32 (get_local 0) (f32.const 0)))"
-  )
-  "unknown operator"
-)
-(assert_malformed
-  (module quote
-    "(memory 1)"
-    "(func (param i32) (f64.store64 (get_local 0) (f64.const 0)))"
-  )
-  "unknown operator"
-)
-
-;; store should have no retval
-(assert_invalid
-  (module (memory 1) (func (param i32) (result i32) (i32.store (i32.const 0) (i32.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param i64) (result i64) (i64.store (i32.const 0) (i64.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param f32) (result f32) (f32.store (i32.const 0) (f32.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param f64) (result f64) (f64.store (i32.const 0) (f64.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param i32) (result i32) (i32.store8 (i32.const 0) (i32.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param i32) (result i32) (i32.store16 (i32.const 0) (i32.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param i64) (result i64) (i64.store8 (i32.const 0) (i64.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param i64) (result i64) (i64.store16 (i32.const 0) (i64.const 1))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func (param i64) (result i64) (i64.store32 (i32.const 0) (i64.const 1))))
-  "type mismatch"
-)
-
-;; load should have retval
-(assert_invalid
-  (module (memory 1) (func $load_i32 (i32.load (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load8_s_i32 (i32.load8_s (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load8_u_i32 (i32.load8_u (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load16_s_i32 (i32.load16_s (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load16_u_i32 (i32.load16_u (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load_i64 (i64.load (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load8_s_i64 (i64.load8_s (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load8_u_i64 (i64.load8_u (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load16_s_i64 (i64.load16_s (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load16_u_i64 (i64.load16_u (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load32_s_i64 (i64.load32_s (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load32_u_i64 (i64.load32_u (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load_f32 (f32.load (i32.const 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (memory 1) (func $load_f64 (f64.load (i32.const 0))))
-  "type mismatch"
-)
diff --git a/test/core/store.wast b/test/core/store.wast
new file mode 100644
index 000000000..8c6c06595
--- /dev/null
+++ b/test/core/store.wast
@@ -0,0 +1,146 @@
+;; Store operator as the argument of control constructs and instructions
+
+(module
+  (memory 1)
+
+  (func (export "as-block-value")
+    (block (i32.store (i32.const 0) (i32.const 1)))
+  )
+  (func (export "as-loop-value")
+    (loop (i32.store (i32.const 0) (i32.const 1)))
+  )
+
+  (func (export "as-br-value")
+    (block (br 0 (i32.store (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-br_if-value")
+    (block
+      (br_if 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1))
+    )
+  )
+  (func (export "as-br_if-value-cond")
+    (block
+      (br_if 0 (i32.const 6) (i32.store (i32.const 0) (i32.const 1)))
+    )
+  )
+  (func (export "as-br_table-value")
+    (block
+      (br_table 0 (i32.store (i32.const 0) (i32.const 1)) (i32.const 1))
+    )
+  )
+
+  (func (export "as-return-value")
+    (return (i32.store (i32.const 0) (i32.const 1)))
+  )
+
+  (func (export "as-if-then")
+    (if (i32.const 1) (then (i32.store (i32.const 0) (i32.const 1))))
+  )
+  (func (export "as-if-else")
+    (if (i32.const 0) (then) (else (i32.store (i32.const 0) (i32.const 1))))
+  )
+)
+
+(assert_return (invoke "as-block-value"))
+(assert_return (invoke "as-loop-value"))
+
+(assert_return (invoke "as-br-value"))
+(assert_return (invoke "as-br_if-value"))
+(assert_return (invoke "as-br_if-value-cond"))
+(assert_return (invoke "as-br_table-value"))
+
+(assert_return (invoke "as-return-value"))
+
+(assert_return (invoke "as-if-then"))
+(assert_return (invoke "as-if-else"))
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (i32.store32 (get_local 0) (i32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (i32.store64 (get_local 0) (i64.const 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (i64.store64 (get_local 0) (i64.const 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f32.store32 (get_local 0) (f32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f32.store64 (get_local 0) (f64.const 0)))"
+  )
+  "unknown operator"
+)
+
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f64.store32 (get_local 0) (f32.const 0)))"
+  )
+  "unknown operator"
+)
+(assert_malformed
+  (module quote
+    "(memory 1)"
+    "(func (param i32) (f64.store64 (get_local 0) (f64.const 0)))"
+  )
+  "unknown operator"
+)
+;; store should have no retval
+
+(assert_invalid
+  (module (memory 1) (func (param i32) (result i32) (i32.store (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param f32) (result f32) (f32.store (i32.const 0) (f32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param f64) (result f64) (f64.store (i32.const 0) (f64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i32) (result i32) (i32.store8 (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i32) (result i32) (i32.store16 (i32.const 0) (i32.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store8 (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store16 (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (memory 1) (func (param i64) (result i64) (i64.store32 (i32.const 0) (i64.const 1))))
+  "type mismatch"
+)

From 2e1c417f8fd442444ac191e1488808caa55db0c6 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Wed, 28 Nov 2018 13:22:15 +0100
Subject: [PATCH 318/329] [spec] Properly rule out surrogate codepoints (#923)

---
 document/core/binary/values.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/document/core/binary/values.rst b/document/core/binary/values.rst
index 88065b8bb..dbb0c21e1 100644
--- a/document/core/binary/values.rst
+++ b/document/core/binary/values.rst
@@ -131,7 +131,7 @@ The auxiliary |utf8| function expressing this encoding is defined as follows:
       \end{array} \\
    \utf8(c) &=& b_1~b_2~b_3 &
      (\begin{array}[t]{@{}c@{~}l@{}}
-      \iff & \unicode{800} \leq c < \unicode{10000} \\
+      \iff & \unicode{800} \leq c < \unicode{D800} \vee \unicode{E000} \leq c < \unicode{10000} \\
       \wedge & c = 2^{12}(b_1-\hex{E0})+2^6(b_2-\hex{80})+(b_3-\hex{80})) \\
       \end{array} \\
    \utf8(c) &=& b_1~b_2~b_3~b_4 &

From 2e948dd17f06eb9a3b8ed84bc34b44c6497f7133 Mon Sep 17 00:00:00 2001
From: Ben Smith <binjimin@gmail.com>
Date: Wed, 28 Nov 2018 12:09:05 -0800
Subject: [PATCH 319/329] [core] Test function/code count mismatch (#921)

It is a validation error if the function section is present, and has a
non-zero count, and the code section is missing. However, if either
section has a zero count, then the other section may be absent.
---
 test/core/binary.wast | 55 ++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 54 insertions(+), 1 deletion(-)

diff --git a/test/core/binary.wast b/test/core/binary.wast
index 5ca969f51..cbf09cfd6 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -573,7 +573,7 @@
 )
 
 ;; No more than 2^32 locals.
-(assert_malformed 
+(assert_malformed
   (module binary
     "\00asm" "\01\00\00\00"
     "\01\04\01\60\00\00"       ;; Type section
@@ -588,3 +588,56 @@
   )
   "too many locals"
 )
+
+;; Function section has non-zero count, but code section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Code section has non-zero count, but function section is absent.
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count > code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"  ;; Type section
+    "\03\03\02\00\00"     ;; Function section with 2 functions
+    "\0a\04\01\02\00\0b"  ;; Code section with 1 empty function
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section count < code section count
+(assert_malformed
+  (module binary
+    "\00asm" "\01\00\00\00"
+    "\01\04\01\60\00\00"           ;; Type section
+    "\03\02\01\00"                 ;; Function section with 1 function
+    "\0a\07\02\02\00\0b\02\00\0b"  ;; Code section with 2 empty functions
+  )
+  "function and code section have inconsistent lengths"
+)
+
+;; Function section has zero count, and code section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\03\01\00"  ;; Function section with 0 functions
+)
+
+;; Code section has zero count, and function section is absent.
+(module binary
+  "\00asm" "\01\00\00\00"
+  "\0a\01\00"  ;; Code section with 0 functions
+)

From 76d26bbc70c51729536243bbd7c64241a6d993d3 Mon Sep 17 00:00:00 2001
From: Benjamin Bouvier <public@benj.me>
Date: Fri, 30 Nov 2018 14:41:37 +0100
Subject: [PATCH 320/329] Fixes #925: Remove link in test's README and update
 WPT link; (#927)

The directories built by the build.py script aren't checked in in the
repository, so don't try to link to them.
---
 test/README.md | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/test/README.md b/test/README.md
index 82f499e42..004c813ee 100644
--- a/test/README.md
+++ b/test/README.md
@@ -5,9 +5,6 @@ directories:
 * [`js-api/`](js-api/), tests for the JavaScript API.
 * [`html/`](html/), tests for the JavaScript API in a DOM environment.
 
-A [landing page](out/index.html) contains a condensed version made of all
-these tests, converted to HTML.
-
 A list of to-do's can be found [here](Todo.md).
 
 ## Multi-stage testing
@@ -20,7 +17,7 @@ runnning all of them in HTML.
 
 The HTML tests are just [Web Platform Tests](http://testthewebforward.org)
 using the
-[testharness.js](http://testthewebforward.org/docs/testharness-library.html)
+[testharness.js](https://web-platform-tests.org/writing-tests/testharness-api.html)
 library.
 
 Each wast test gets its equivalent JS test, and each JS test (including wast

From 994591e51c9df9e7ef980b04d660709b79982f75 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 6 Dec 2018 08:35:44 +0100
Subject: [PATCH 321/329] [spec/interpreter/tests] Rename instructions (#926)

* Rename {get,set,tee}_{local,global} to {local,global}.{get,set,tee}
* Rename anyfunc to funcref
* Rename conversion operators
---
 document/core/appendix/index-instructions.rst |  393 +-
 document/core/appendix/index-types.rst        |    2 +-
 document/core/appendix/properties.rst         |    8 +-
 document/core/binary/instructions.rst         |   70 +-
 document/core/binary/types.rst                |    2 +-
 document/core/exec/instructions.rst           |   70 +-
 document/core/exec/modules.rst                |    4 +-
 document/core/syntax/instructions.rst         |   36 +-
 document/core/syntax/types.rst                |    4 +-
 document/core/text/instructions.rst           |   70 +-
 document/core/text/types.rst                  |    2 +-
 document/core/util/macros.def                 |   24 +-
 document/core/valid/conventions.rst           |    4 +-
 document/core/valid/instructions.rst          |   46 +-
 document/core/valid/modules.rst               |    4 +-
 interpreter/binary/decode.ml                  |   54 +-
 interpreter/binary/encode.ml                  |   12 +-
 interpreter/exec/eval.ml                      |   16 +-
 interpreter/exec/eval_numeric.ml              |   36 +-
 interpreter/exec/f32_convert.ml               |   10 +-
 interpreter/exec/f32_convert.mli              |    8 +-
 interpreter/exec/f64_convert.ml               |   10 +-
 interpreter/exec/f64_convert.mli              |    8 +-
 interpreter/exec/i32_convert.ml               |    8 +-
 interpreter/exec/i32_convert.mli              |    8 +-
 interpreter/exec/i64_convert.ml               |   12 +-
 interpreter/exec/i64_convert.mli              |   12 +-
 interpreter/host/spectest.ml                  |    2 +-
 interpreter/script/js.ml                      |    2 +-
 interpreter/syntax/ast.ml                     |   10 +-
 interpreter/syntax/operators.ml               |   46 +-
 interpreter/syntax/types.ml                   |    4 +-
 interpreter/text/arrange.ml                   |   40 +-
 interpreter/text/lexer.mll                    |   62 +-
 interpreter/text/parser.mly                   |   16 +-
 interpreter/valid/valid.ml                    |   12 +-
 test/core/address.wast                        |  168 +-
 test/core/align.wast                          |  286 +-
 test/core/binary.wast                         |    2 +-
 test/core/block.wast                          |   54 +-
 test/core/br.wast                             |   34 +-
 test/core/br_if.wast                          |   70 +-
 test/core/br_table.wast                       |   88 +-
 test/core/call.wast                           |   74 +-
 test/core/call_indirect.wast                  |  172 +-
 test/core/conversions.wast                    |  584 +--
 test/core/data.wast                           |   20 +-
 test/core/elem.wast                           |   86 +-
 test/core/endianness.wast                     |   66 +-
 test/core/exports.wast                        |   52 +-
 test/core/f32.wast                            |   22 +-
 test/core/f32_bitwise.wast                    |    6 +-
 test/core/f32_cmp.wast                        |   12 +-
 test/core/f64.wast                            |   22 +-
 test/core/f64_bitwise.wast                    |    6 +-
 test/core/f64_cmp.wast                        |   12 +-
 test/core/fac.wast                            |   46 +-
 test/core/float_exprs.wast                    |  840 ++--
 test/core/float_literals.wast                 |  124 +-
 test/core/float_misc.wast                     |   58 +-
 test/core/forward.wast                        |    8 +-
 test/core/func.wast                           |   98 +-
 test/core/func_ptrs.wast                      |   22 +-
 test/core/get_local.wast                      |  165 -
 test/core/globals.wast                        |  116 +-
 test/core/i32.wast                            |   58 +-
 test/core/i64.wast                            |   58 +-
 test/core/if.wast                             |  152 +-
 test/core/imports.wast                        |  124 +-
 test/core/int_exprs.wast                      |  128 +-
 test/core/labels.wast                         |  130 +-
 test/core/left-to-right.wast                  |    2 +-
 test/core/linking.wast                        |   46 +-
 test/core/load.wast                           |   50 +-
 test/core/local_get.wast                      |  165 +
 test/core/{set_local.wast => local_set.wast}  |  140 +-
 test/core/{tee_local.wast => local_tee.wast}  |  234 +-
 test/core/loop.wast                           |  102 +-
 test/core/memory.wast                         |   22 +-
 test/core/memory_grow.wast                    |   46 +-
 test/core/memory_redundancy.wast              |   20 +-
 test/core/memory_trap.wast                    |   52 +-
 test/core/names.wast                          |    4 +-
 test/core/nop.wast                            |  174 +-
 test/core/return.wast                         |   30 +-
 test/core/select.wast                         |  106 +-
 test/core/skip-stack-guard-page.wast          | 4230 ++++++++---------
 test/core/stack.wast                          |   86 +-
 test/core/store.wast                          |   14 +-
 test/core/switch.wast                         |   32 +-
 test/core/traps.wast                          |   60 +-
 test/core/typecheck.wast                      |   58 +-
 test/core/unreachable.wast                    |   30 +-
 test/core/unreached-invalid.wast              |    8 +-
 94 files changed, 5400 insertions(+), 5401 deletions(-)
 delete mode 100644 test/core/get_local.wast
 create mode 100644 test/core/local_get.wast
 rename test/core/{set_local.wast => local_set.wast} (51%)
 rename test/core/{tee_local.wast => local_tee.wast} (58%)

diff --git a/document/core/appendix/index-instructions.rst b/document/core/appendix/index-instructions.rst
index a8f51ad38..3e294ba12 100644
--- a/document/core/appendix/index-instructions.rst
+++ b/document/core/appendix/index-instructions.rst
@@ -4,200 +4,199 @@
 Index of Instructions
 ---------------------
 
-===================================  ================  ==========================================  ========================================  ===============================================================
-Instruction                          Binary Opcode     Type                                        Validation                                Execution
-===================================  ================  ==========================================  ========================================  ===============================================================
-:math:`\UNREACHABLE`                 :math:`\hex{00}`  :math:`[t_1^\ast] \to [t_2^\ast]`           :ref:`validation <valid-unreachable>`     :ref:`execution <exec-unreachable>`
-:math:`\NOP`                         :math:`\hex{01}`  :math:`[] \to []`                           :ref:`validation <valid-nop>`             :ref:`execution <exec-nop>`
-:math:`\BLOCK~[t^?]`                 :math:`\hex{02}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-block>`           :ref:`execution <exec-block>`
-:math:`\LOOP~[t^?]`                  :math:`\hex{03}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-loop>`            :ref:`execution <exec-loop>`
-:math:`\IF~[t^?]`                    :math:`\hex{04}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-if>`              :ref:`execution <exec-if>`
-:math:`\ELSE`                        :math:`\hex{05}`                                                
-(reserved)                           :math:`\hex{06}`                                                  
-(reserved)                           :math:`\hex{07}`                                                  
-(reserved)                           :math:`\hex{08}`                                                  
-(reserved)                           :math:`\hex{09}`                                                  
-(reserved)                           :math:`\hex{0A}`                                                  
-:math:`\END`                         :math:`\hex{0B}`                                                  
-:math:`\BR~l`                        :math:`\hex{0C}`  :math:`[t_1^\ast~t^?] \to [t_2^\ast]`       :ref:`validation <valid-br>`              :ref:`execution <exec-br>`
-:math:`\BRIF~l`                      :math:`\hex{0D}`  :math:`[t^?~\I32] \to [t^?]`                :ref:`validation <valid-br_if>`           :ref:`execution <exec-br_if>`
-:math:`\BRTABLE~l^\ast~l`            :math:`\hex{0E}`  :math:`[t_1^\ast~t^?~\I32] \to [t_2^\ast]`  :ref:`validation <valid-br_table>`        :ref:`execution <exec-br_table>`
-:math:`\RETURN`                      :math:`\hex{0F}`  :math:`[t_1^\ast~t^?] \to [t_2^\ast]`       :ref:`validation <valid-return>`          :ref:`execution <exec-return>`
-:math:`\CALL~x`                      :math:`\hex{10}`  :math:`[t_1^\ast] \to [t_2^\ast]`           :ref:`validation <valid-call>`            :ref:`execution <exec-call>`
-:math:`\CALLINDIRECT~x`              :math:`\hex{11}`  :math:`[t_1^\ast~\I32] \to [t_2^\ast]`      :ref:`validation <valid-call_indirect>`   :ref:`execution <exec-call_indirect>`
-(reserved)                           :math:`\hex{12}`                                                  
-(reserved)                           :math:`\hex{13}`                                                  
-(reserved)                           :math:`\hex{14}`                                                  
-(reserved)                           :math:`\hex{15}`                                                  
-(reserved)                           :math:`\hex{16}`                                                  
-(reserved)                           :math:`\hex{17}`                                                  
-(reserved)                           :math:`\hex{18}`                                                  
-(reserved)                           :math:`\hex{19}`                                                  
-:math:`\DROP`                        :math:`\hex{1A}`  :math:`[t] \to []`                          :ref:`validation <valid-drop>`            :ref:`execution <exec-drop>`
-:math:`\SELECT`                      :math:`\hex{1B}`  :math:`[t~t~\I32] \to [t]`                  :ref:`validation <valid-select>`          :ref:`execution <exec-select>`
-(reserved)                           :math:`\hex{1C}`                                                  
-(reserved)                           :math:`\hex{1D}`                                                  
-(reserved)                           :math:`\hex{1E}`                                                  
-(reserved)                           :math:`\hex{1F}`                                                  
-:math:`\GETLOCAL~x`                  :math:`\hex{20}`  :math:`[] \to [t]`                          :ref:`validation <valid-get_local>`       :ref:`execution <exec-get_local>`
-:math:`\SETLOCAL~x`                  :math:`\hex{21}`  :math:`[t] \to []`                          :ref:`validation <valid-set_local>`       :ref:`execution <exec-set_local>`
-:math:`\TEELOCAL~x`                  :math:`\hex{22}`  :math:`[t] \to [t]`                         :ref:`validation <valid-tee_local>`       :ref:`execution <exec-tee_local>`
-:math:`\GETGLOBAL~x`                 :math:`\hex{23}`  :math:`[] \to [t]`                          :ref:`validation <valid-get_global>`      :ref:`execution <exec-get_global>`
-:math:`\SETGLOBAL~x`                 :math:`\hex{24}`  :math:`[t] \to []`                          :ref:`validation <valid-set_global>`      :ref:`execution <exec-set_global>`
-(reserved)                           :math:`\hex{25}`                                                  
-(reserved)                           :math:`\hex{26}`                                                  
-(reserved)                           :math:`\hex{27}`                                                  
-:math:`\I32.\LOAD~\memarg`           :math:`\hex{28}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
-:math:`\I64.\LOAD~\memarg`           :math:`\hex{29}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
-:math:`\F32.\LOAD~\memarg`           :math:`\hex{2A}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
-:math:`\F64.\LOAD~\memarg`           :math:`\hex{2B}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
-:math:`\I32.\LOAD\K{8\_s}~\memarg`   :math:`\hex{2C}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
-:math:`\I32.\LOAD\K{8\_u}~\memarg`   :math:`\hex{2D}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
-:math:`\I32.\LOAD\K{16\_s}~\memarg`  :math:`\hex{2E}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
-:math:`\I32.\LOAD\K{16\_u}~\memarg`  :math:`\hex{2F}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
-:math:`\I64.\LOAD\K{8\_s}~\memarg`   :math:`\hex{30}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
-:math:`\I64.\LOAD\K{8\_u}~\memarg`   :math:`\hex{31}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
-:math:`\I64.\LOAD\K{16\_s}~\memarg`  :math:`\hex{32}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
-:math:`\I64.\LOAD\K{16\_u}~\memarg`  :math:`\hex{33}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
-:math:`\I64.\LOAD\K{32\_s}~\memarg`  :math:`\hex{34}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
-:math:`\I64.\LOAD\K{32\_u}~\memarg`  :math:`\hex{35}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
-:math:`\I32.\STORE~\memarg`          :math:`\hex{36}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
-:math:`\I64.\STORE~\memarg`          :math:`\hex{37}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
-:math:`\F32.\STORE~\memarg`          :math:`\hex{38}`  :math:`[\I32~\F32] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
-:math:`\F64.\STORE~\memarg`          :math:`\hex{39}`  :math:`[\I32~\F64] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
-:math:`\I32.\STORE\K{8}~\memarg`     :math:`\hex{3A}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
-:math:`\I32.\STORE\K{16}~\memarg`    :math:`\hex{3B}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
-:math:`\I64.\STORE\K{8}~\memarg`     :math:`\hex{3C}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
-:math:`\I64.\STORE\K{16}~\memarg`    :math:`\hex{3D}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
-:math:`\I64.\STORE\K{32}~\memarg`    :math:`\hex{3E}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
-:math:`\MEMORYSIZE`                  :math:`\hex{3F}`  :math:`[] \to [\I32]`                       :ref:`validation <valid-memory.size>`     :ref:`execution <exec-memory.size>`
-:math:`\MEMORYGROW`                  :math:`\hex{40}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-memory.grow>`     :ref:`execution <exec-memory.grow>`
-:math:`\I32.\CONST~\i32`             :math:`\hex{41}`  :math:`[] \to [\I32]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
-:math:`\I64.\CONST~\i64`             :math:`\hex{42}`  :math:`[] \to [\I64]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
-:math:`\F32.\CONST~\f32`             :math:`\hex{43}`  :math:`[] \to [\F32]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
-:math:`\F64.\CONST~\f64`             :math:`\hex{44}`  :math:`[] \to [\F64]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
-:math:`\I32.\EQZ`                    :math:`\hex{45}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-testop>`          :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`
-:math:`\I32.\EQ`                     :math:`\hex{46}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`
-:math:`\I32.\NE`                     :math:`\hex{47}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`
-:math:`\I32.\LT\K{\_s}`              :math:`\hex{48}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`
-:math:`\I32.\LT\K{\_u}`              :math:`\hex{49}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`
-:math:`\I32.\GT\K{\_s}`              :math:`\hex{4A}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`
-:math:`\I32.\GT\K{\_u}`              :math:`\hex{4B}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`
-:math:`\I32.\LE\K{\_s}`              :math:`\hex{4C}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`
-:math:`\I32.\LE\K{\_u}`              :math:`\hex{4D}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`
-:math:`\I32.\GE\K{\_s}`              :math:`\hex{4E}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`
-:math:`\I32.\GE\K{\_u}`              :math:`\hex{4F}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`
-:math:`\I64.\EQZ`                    :math:`\hex{50}`  :math:`[\I64] \to [\I32]`                   :ref:`validation <valid-testop>`          :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`
-:math:`\I64.\EQ`                     :math:`\hex{51}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`
-:math:`\I64.\NE`                     :math:`\hex{52}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`
-:math:`\I64.\LT\K{\_s}`              :math:`\hex{53}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`
-:math:`\I64.\LT\K{\_u}`              :math:`\hex{54}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`
-:math:`\I64.\GT\K{\_s}`              :math:`\hex{55}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`
-:math:`\I64.\GT\K{\_u}`              :math:`\hex{56}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`
-:math:`\I64.\LE\K{\_s}`              :math:`\hex{57}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`
-:math:`\I64.\LE\K{\_u}`              :math:`\hex{58}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`
-:math:`\I64.\GE\K{\_s}`              :math:`\hex{59}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`
-:math:`\I64.\GE\K{\_u}`              :math:`\hex{5A}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`
-:math:`\F32.\EQ`                     :math:`\hex{5B}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`
-:math:`\F32.\NE`                     :math:`\hex{5C}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`
-:math:`\F32.\LT`                     :math:`\hex{5D}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`
-:math:`\F32.\GT`                     :math:`\hex{5E}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`
-:math:`\F32.\LE`                     :math:`\hex{5F}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`
-:math:`\F32.\GE`                     :math:`\hex{60}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`
-:math:`\F64.\EQ`                     :math:`\hex{61}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`
-:math:`\F64.\NE`                     :math:`\hex{62}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`
-:math:`\F64.\LT`                     :math:`\hex{63}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`
-:math:`\F64.\GT`                     :math:`\hex{64}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`
-:math:`\F64.\LE`                     :math:`\hex{65}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`
-:math:`\F64.\GE`                     :math:`\hex{66}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`
-:math:`\I32.\CLZ`                    :math:`\hex{67}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`
-:math:`\I32.\CTZ`                    :math:`\hex{68}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`
-:math:`\I32.\POPCNT`                 :math:`\hex{69}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`
-:math:`\I32.\ADD`                    :math:`\hex{6A}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`
-:math:`\I32.\SUB`                    :math:`\hex{6B}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`
-:math:`\I32.\MUL`                    :math:`\hex{6C}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`
-:math:`\I32.\DIV\K{\_s}`             :math:`\hex{6D}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`
-:math:`\I32.\DIV\K{\_u}`             :math:`\hex{6E}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`
-:math:`\I32.\REM\K{\_s}`             :math:`\hex{6F}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`
-:math:`\I32.\REM\K{\_u}`             :math:`\hex{70}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`
-:math:`\I32.\AND`                    :math:`\hex{71}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`
-:math:`\I32.\OR`                     :math:`\hex{72}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`
-:math:`\I32.\XOR`                    :math:`\hex{73}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`
-:math:`\I32.\SHL`                    :math:`\hex{74}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`
-:math:`\I32.\SHR\K{\_s}`             :math:`\hex{75}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`
-:math:`\I32.\SHR\K{\_u}`             :math:`\hex{76}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`
-:math:`\I32.\ROTL`                   :math:`\hex{77}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`
-:math:`\I32.\ROTR`                   :math:`\hex{78}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`
-:math:`\I64.\CLZ`                    :math:`\hex{79}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`
-:math:`\I64.\CTZ`                    :math:`\hex{7A}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`
-:math:`\I64.\POPCNT`                 :math:`\hex{7B}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`
-:math:`\I64.\ADD`                    :math:`\hex{7C}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`
-:math:`\I64.\SUB`                    :math:`\hex{7D}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`
-:math:`\I64.\MUL`                    :math:`\hex{7E}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`
-:math:`\I64.\DIV\K{\_s}`             :math:`\hex{7F}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`
-:math:`\I64.\DIV\K{\_u}`             :math:`\hex{80}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`
-:math:`\I64.\REM\K{\_s}`             :math:`\hex{81}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`
-:math:`\I64.\REM\K{\_u}`             :math:`\hex{82}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`
-:math:`\I64.\AND`                    :math:`\hex{83}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`
-:math:`\I64.\OR`                     :math:`\hex{84}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`
-:math:`\I64.\XOR`                    :math:`\hex{85}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`
-:math:`\I64.\SHL`                    :math:`\hex{86}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`
-:math:`\I64.\SHR\K{\_s}`             :math:`\hex{87}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`
-:math:`\I64.\SHR\K{\_u}`             :math:`\hex{88}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`
-:math:`\I64.\ROTL`                   :math:`\hex{89}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`
-:math:`\I64.\ROTR`                   :math:`\hex{8A}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`
-:math:`\F32.\ABS`                    :math:`\hex{8B}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`
-:math:`\F32.\NEG`                    :math:`\hex{8C}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`
-:math:`\F32.\CEIL`                   :math:`\hex{8D}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`
-:math:`\F32.\FLOOR`                  :math:`\hex{8E}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`
-:math:`\F32.\TRUNC`                  :math:`\hex{8F}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`
-:math:`\F32.\NEAREST`                :math:`\hex{90}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`
-:math:`\F32.\SQRT`                   :math:`\hex{91}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`
-:math:`\F32.\ADD`                    :math:`\hex{92}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`
-:math:`\F32.\SUB`                    :math:`\hex{93}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`
-:math:`\F32.\MUL`                    :math:`\hex{94}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`
-:math:`\F32.\DIV`                    :math:`\hex{95}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`
-:math:`\F32.\FMIN`                   :math:`\hex{96}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`
-:math:`\F32.\FMAX`                   :math:`\hex{97}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`
-:math:`\F32.\COPYSIGN`               :math:`\hex{98}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`
-:math:`\F64.\ABS`                    :math:`\hex{99}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`
-:math:`\F64.\NEG`                    :math:`\hex{9A}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`
-:math:`\F64.\CEIL`                   :math:`\hex{9B}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`
-:math:`\F64.\FLOOR`                  :math:`\hex{9C}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`
-:math:`\F64.\TRUNC`                  :math:`\hex{9D}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`
-:math:`\F64.\NEAREST`                :math:`\hex{9E}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`
-:math:`\F64.\SQRT`                   :math:`\hex{9F}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`
-:math:`\F64.\ADD`                    :math:`\hex{A0}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`
-:math:`\F64.\SUB`                    :math:`\hex{A1}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`
-:math:`\F64.\MUL`                    :math:`\hex{A2}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`
-:math:`\F64.\DIV`                    :math:`\hex{A3}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`
-:math:`\F64.\FMIN`                   :math:`\hex{A4}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`
-:math:`\F64.\FMAX`                   :math:`\hex{A5}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`
-:math:`\F64.\COPYSIGN`               :math:`\hex{A6}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`
-:math:`\I32.\WRAP\K{/}\I64`          :math:`\hex{A7}`  :math:`[\I64] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`
-:math:`\I32.\TRUNC\K{\_s/}\F32`      :math:`\hex{A8}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
-:math:`\I32.\TRUNC\K{\_u/}\F32`      :math:`\hex{A9}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
-:math:`\I32.\TRUNC\K{\_s/}\F64`      :math:`\hex{AA}`  :math:`[\F64] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
-:math:`\I32.\TRUNC\K{\_u/}\F64`      :math:`\hex{AB}`  :math:`[\F64] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
-:math:`\I64.\EXTEND\K{\_s/}\I32`     :math:`\hex{AC}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`
-:math:`\I64.\EXTEND\K{\_u/}\I32`     :math:`\hex{AD}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`
-:math:`\I64.\TRUNC\K{\_s/}\F32`      :math:`\hex{AE}`  :math:`[\F32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
-:math:`\I64.\TRUNC\K{\_u/}\F32`      :math:`\hex{AF}`  :math:`[\F32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
-:math:`\I64.\TRUNC\K{\_s/}\F64`      :math:`\hex{B0}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
-:math:`\I64.\TRUNC\K{\_u/}\F64`      :math:`\hex{B1}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
-:math:`\F32.\CONVERT\K{\_s/}\I32`    :math:`\hex{B2}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
-:math:`\F32.\CONVERT\K{\_u/}\I32`    :math:`\hex{B3}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
-:math:`\F32.\CONVERT\K{\_s/}\I64`    :math:`\hex{B4}`  :math:`[\I64] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
-:math:`\F32.\CONVERT\K{\_u/}\I64`    :math:`\hex{B5}`  :math:`[\I64] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
-:math:`\F32.\DEMOTE\K{/}\F64`        :math:`\hex{B6}`  :math:`[\F64] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`
-:math:`\F64.\CONVERT\K{\_s/}\I32`    :math:`\hex{B7}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
-:math:`\F64.\CONVERT\K{\_u/}\I32`    :math:`\hex{B8}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
-:math:`\F64.\CONVERT\K{\_s/}\I64`    :math:`\hex{B9}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
-:math:`\F64.\CONVERT\K{\_u/}\I64`    :math:`\hex{BA}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
-:math:`\F64.\PROMOTE\K{/}\F32`       :math:`\hex{BB}`  :math:`[\F32] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`
-:math:`\I32.\REINTERPRET\K{/}\F32`   :math:`\hex{BC}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\I64.\REINTERPRET\K{/}\F64`   :math:`\hex{BD}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\F32.\REINTERPRET\K{/}\I32`   :math:`\hex{BE}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-:math:`\F64.\REINTERPRET\K{/}\I64`   :math:`\hex{BF}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
-===================================  ================  ==========================================  ========================================  ===============================================================
-
+======================================  ================  ==========================================  ========================================  ===============================================================
+Instruction                             Binary Opcode     Type                                        Validation                                Execution
+======================================  ================  ==========================================  ========================================  ===============================================================
+:math:`\UNREACHABLE`                    :math:`\hex{00}`  :math:`[t_1^\ast] \to [t_2^\ast]`           :ref:`validation <valid-unreachable>`     :ref:`execution <exec-unreachable>`
+:math:`\NOP`                            :math:`\hex{01}`  :math:`[] \to []`                           :ref:`validation <valid-nop>`             :ref:`execution <exec-nop>`
+:math:`\BLOCK~[t^?]`                    :math:`\hex{02}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-block>`           :ref:`execution <exec-block>`
+:math:`\LOOP~[t^?]`                     :math:`\hex{03}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-loop>`            :ref:`execution <exec-loop>`
+:math:`\IF~[t^?]`                       :math:`\hex{04}`  :math:`[] \to [t^\ast]`                     :ref:`validation <valid-if>`              :ref:`execution <exec-if>`
+:math:`\ELSE`                           :math:`\hex{05}`                                                
+(reserved)                              :math:`\hex{06}`                                                  
+(reserved)                              :math:`\hex{07}`                                                  
+(reserved)                              :math:`\hex{08}`                                                  
+(reserved)                              :math:`\hex{09}`                                                  
+(reserved)                              :math:`\hex{0A}`                                                  
+:math:`\END`                            :math:`\hex{0B}`                                                  
+:math:`\BR~l`                           :math:`\hex{0C}`  :math:`[t_1^\ast~t^?] \to [t_2^\ast]`       :ref:`validation <valid-br>`              :ref:`execution <exec-br>`
+:math:`\BRIF~l`                         :math:`\hex{0D}`  :math:`[t^?~\I32] \to [t^?]`                :ref:`validation <valid-br_if>`           :ref:`execution <exec-br_if>`
+:math:`\BRTABLE~l^\ast~l`               :math:`\hex{0E}`  :math:`[t_1^\ast~t^?~\I32] \to [t_2^\ast]`  :ref:`validation <valid-br_table>`        :ref:`execution <exec-br_table>`
+:math:`\RETURN`                         :math:`\hex{0F}`  :math:`[t_1^\ast~t^?] \to [t_2^\ast]`       :ref:`validation <valid-return>`          :ref:`execution <exec-return>`
+:math:`\CALL~x`                         :math:`\hex{10}`  :math:`[t_1^\ast] \to [t_2^\ast]`           :ref:`validation <valid-call>`            :ref:`execution <exec-call>`
+:math:`\CALLINDIRECT~x`                 :math:`\hex{11}`  :math:`[t_1^\ast~\I32] \to [t_2^\ast]`      :ref:`validation <valid-call_indirect>`   :ref:`execution <exec-call_indirect>`
+(reserved)                              :math:`\hex{12}`                                                  
+(reserved)                              :math:`\hex{13}`                                                  
+(reserved)                              :math:`\hex{14}`                                                  
+(reserved)                              :math:`\hex{15}`                                                  
+(reserved)                              :math:`\hex{16}`                                                  
+(reserved)                              :math:`\hex{17}`                                                  
+(reserved)                              :math:`\hex{18}`                                                  
+(reserved)                              :math:`\hex{19}`                                                  
+:math:`\DROP`                           :math:`\hex{1A}`  :math:`[t] \to []`                          :ref:`validation <valid-drop>`            :ref:`execution <exec-drop>`
+:math:`\SELECT`                         :math:`\hex{1B}`  :math:`[t~t~\I32] \to [t]`                  :ref:`validation <valid-select>`          :ref:`execution <exec-select>`
+(reserved)                              :math:`\hex{1C}`                                                  
+(reserved)                              :math:`\hex{1D}`                                                  
+(reserved)                              :math:`\hex{1E}`                                                  
+(reserved)                              :math:`\hex{1F}`                                                  
+:math:`\LOCALGET~x`                     :math:`\hex{20}`  :math:`[] \to [t]`                          :ref:`validation <valid-local.get>`       :ref:`execution <exec-local.get>`
+:math:`\LOCALSET~x`                     :math:`\hex{21}`  :math:`[t] \to []`                          :ref:`validation <valid-local.set>`       :ref:`execution <exec-local.set>`
+:math:`\LOCALTEE~x`                     :math:`\hex{22}`  :math:`[t] \to [t]`                         :ref:`validation <valid-local.tee>`       :ref:`execution <exec-local.tee>`
+:math:`\GLOBALGET~x`                    :math:`\hex{23}`  :math:`[] \to [t]`                          :ref:`validation <valid-global.get>`      :ref:`execution <exec-global.get>`
+:math:`\GLOBALSET~x`                    :math:`\hex{24}`  :math:`[t] \to []`                          :ref:`validation <valid-global.set>`      :ref:`execution <exec-global.set>`
+(reserved)                              :math:`\hex{25}`                                                  
+(reserved)                              :math:`\hex{26}`                                                  
+(reserved)                              :math:`\hex{27}`                                                  
+:math:`\I32.\LOAD~\memarg`              :math:`\hex{28}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
+:math:`\I64.\LOAD~\memarg`              :math:`\hex{29}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
+:math:`\F32.\LOAD~\memarg`              :math:`\hex{2A}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
+:math:`\F64.\LOAD~\memarg`              :math:`\hex{2B}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-load>`            :ref:`execution <exec-load>`
+:math:`\I32.\LOAD\K{8\_s}~\memarg`      :math:`\hex{2C}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I32.\LOAD\K{8\_u}~\memarg`      :math:`\hex{2D}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I32.\LOAD\K{16\_s}~\memarg`     :math:`\hex{2E}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I32.\LOAD\K{16\_u}~\memarg`     :math:`\hex{2F}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{8\_s}~\memarg`      :math:`\hex{30}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{8\_u}~\memarg`      :math:`\hex{31}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{16\_s}~\memarg`     :math:`\hex{32}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{16\_u}~\memarg`     :math:`\hex{33}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{32\_s}~\memarg`     :math:`\hex{34}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I64.\LOAD\K{32\_u}~\memarg`     :math:`\hex{35}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-loadn>`           :ref:`execution <exec-loadn>`
+:math:`\I32.\STORE~\memarg`             :math:`\hex{36}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
+:math:`\I64.\STORE~\memarg`             :math:`\hex{37}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
+:math:`\F32.\STORE~\memarg`             :math:`\hex{38}`  :math:`[\I32~\F32] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
+:math:`\F64.\STORE~\memarg`             :math:`\hex{39}`  :math:`[\I32~\F64] \to []`                  :ref:`validation <valid-store>`           :ref:`execution <exec-store>`
+:math:`\I32.\STORE\K{8}~\memarg`        :math:`\hex{3A}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
+:math:`\I32.\STORE\K{16}~\memarg`       :math:`\hex{3B}`  :math:`[\I32~\I32] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
+:math:`\I64.\STORE\K{8}~\memarg`        :math:`\hex{3C}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
+:math:`\I64.\STORE\K{16}~\memarg`       :math:`\hex{3D}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
+:math:`\I64.\STORE\K{32}~\memarg`       :math:`\hex{3E}`  :math:`[\I32~\I64] \to []`                  :ref:`validation <valid-storen>`          :ref:`execution <exec-storen>`
+:math:`\MEMORYSIZE`                     :math:`\hex{3F}`  :math:`[] \to [\I32]`                       :ref:`validation <valid-memory.size>`     :ref:`execution <exec-memory.size>`
+:math:`\MEMORYGROW`                     :math:`\hex{40}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-memory.grow>`     :ref:`execution <exec-memory.grow>`
+:math:`\I32.\CONST~\i32`                :math:`\hex{41}`  :math:`[] \to [\I32]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
+:math:`\I64.\CONST~\i64`                :math:`\hex{42}`  :math:`[] \to [\I64]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
+:math:`\F32.\CONST~\f32`                :math:`\hex{43}`  :math:`[] \to [\F32]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
+:math:`\F64.\CONST~\f64`                :math:`\hex{44}`  :math:`[] \to [\F64]`                       :ref:`validation <valid-const>`           :ref:`execution <exec-const>`
+:math:`\I32.\EQZ`                       :math:`\hex{45}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-testop>`          :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`
+:math:`\I32.\EQ`                        :math:`\hex{46}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`
+:math:`\I32.\NE`                        :math:`\hex{47}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`
+:math:`\I32.\LT\K{\_s}`                 :math:`\hex{48}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`
+:math:`\I32.\LT\K{\_u}`                 :math:`\hex{49}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`
+:math:`\I32.\GT\K{\_s}`                 :math:`\hex{4A}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`
+:math:`\I32.\GT\K{\_u}`                 :math:`\hex{4B}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`
+:math:`\I32.\LE\K{\_s}`                 :math:`\hex{4C}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`
+:math:`\I32.\LE\K{\_u}`                 :math:`\hex{4D}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`
+:math:`\I32.\GE\K{\_s}`                 :math:`\hex{4E}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`
+:math:`\I32.\GE\K{\_u}`                 :math:`\hex{4F}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`
+:math:`\I64.\EQZ`                       :math:`\hex{50}`  :math:`[\I64] \to [\I32]`                   :ref:`validation <valid-testop>`          :ref:`execution <exec-testop>`, :ref:`operator <op-ieqz>`
+:math:`\I64.\EQ`                        :math:`\hex{51}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ieq>`
+:math:`\I64.\NE`                        :math:`\hex{52}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ine>`
+:math:`\I64.\LT\K{\_s}`                 :math:`\hex{53}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_s>`
+:math:`\I64.\LT\K{\_u}`                 :math:`\hex{54}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ilt_u>`
+:math:`\I64.\GT\K{\_s}`                 :math:`\hex{55}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_s>`
+:math:`\I64.\GT\K{\_u}`                 :math:`\hex{56}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-igt_u>`
+:math:`\I64.\LE\K{\_s}`                 :math:`\hex{57}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_s>`
+:math:`\I64.\LE\K{\_u}`                 :math:`\hex{58}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ile_u>`
+:math:`\I64.\GE\K{\_s}`                 :math:`\hex{59}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_s>`
+:math:`\I64.\GE\K{\_u}`                 :math:`\hex{5A}`  :math:`[\I64~\I64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-ige_u>`
+:math:`\F32.\EQ`                        :math:`\hex{5B}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`
+:math:`\F32.\NE`                        :math:`\hex{5C}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`
+:math:`\F32.\LT`                        :math:`\hex{5D}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`
+:math:`\F32.\GT`                        :math:`\hex{5E}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`
+:math:`\F32.\LE`                        :math:`\hex{5F}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`
+:math:`\F32.\GE`                        :math:`\hex{60}`  :math:`[\F32~\F32] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`
+:math:`\F64.\EQ`                        :math:`\hex{61}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-feq>`
+:math:`\F64.\NE`                        :math:`\hex{62}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fne>`
+:math:`\F64.\LT`                        :math:`\hex{63}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-flt>`
+:math:`\F64.\GT`                        :math:`\hex{64}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fgt>`
+:math:`\F64.\LE`                        :math:`\hex{65}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fle>`
+:math:`\F64.\GE`                        :math:`\hex{66}`  :math:`[\F64~\F64] \to [\I32]`              :ref:`validation <valid-relop>`           :ref:`execution <exec-relop>`, :ref:`operator <op-fge>`
+:math:`\I32.\CLZ`                       :math:`\hex{67}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`
+:math:`\I32.\CTZ`                       :math:`\hex{68}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`
+:math:`\I32.\POPCNT`                    :math:`\hex{69}`  :math:`[\I32] \to [\I32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`
+:math:`\I32.\ADD`                       :math:`\hex{6A}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`
+:math:`\I32.\SUB`                       :math:`\hex{6B}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`
+:math:`\I32.\MUL`                       :math:`\hex{6C}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`
+:math:`\I32.\DIV\K{\_s}`                :math:`\hex{6D}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`
+:math:`\I32.\DIV\K{\_u}`                :math:`\hex{6E}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`
+:math:`\I32.\REM\K{\_s}`                :math:`\hex{6F}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`
+:math:`\I32.\REM\K{\_u}`                :math:`\hex{70}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`
+:math:`\I32.\AND`                       :math:`\hex{71}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`
+:math:`\I32.\OR`                        :math:`\hex{72}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`
+:math:`\I32.\XOR`                       :math:`\hex{73}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`
+:math:`\I32.\SHL`                       :math:`\hex{74}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`
+:math:`\I32.\SHR\K{\_s}`                :math:`\hex{75}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`
+:math:`\I32.\SHR\K{\_u}`                :math:`\hex{76}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`
+:math:`\I32.\ROTL`                      :math:`\hex{77}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`
+:math:`\I32.\ROTR`                      :math:`\hex{78}`  :math:`[\I32~\I32] \to [\I32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`
+:math:`\I64.\CLZ`                       :math:`\hex{79}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-iclz>`
+:math:`\I64.\CTZ`                       :math:`\hex{7A}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ictz>`
+:math:`\I64.\POPCNT`                    :math:`\hex{7B}`  :math:`[\I64] \to [\I64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ipopcnt>`
+:math:`\I64.\ADD`                       :math:`\hex{7C}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iadd>`
+:math:`\I64.\SUB`                       :math:`\hex{7D}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-isub>`
+:math:`\I64.\MUL`                       :math:`\hex{7E}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-imul>`
+:math:`\I64.\DIV\K{\_s}`                :math:`\hex{7F}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_s>`
+:math:`\I64.\DIV\K{\_u}`                :math:`\hex{80}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-idiv_u>`
+:math:`\I64.\REM\K{\_s}`                :math:`\hex{81}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_s>`
+:math:`\I64.\REM\K{\_u}`                :math:`\hex{82}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irem_u>`
+:math:`\I64.\AND`                       :math:`\hex{83}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-iand>`
+:math:`\I64.\OR`                        :math:`\hex{84}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ior>`
+:math:`\I64.\XOR`                       :math:`\hex{85}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ixor>`
+:math:`\I64.\SHL`                       :math:`\hex{86}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishl>`
+:math:`\I64.\SHR\K{\_s}`                :math:`\hex{87}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_s>`
+:math:`\I64.\SHR\K{\_u}`                :math:`\hex{88}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-ishr_u>`
+:math:`\I64.\ROTL`                      :math:`\hex{89}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotl>`
+:math:`\I64.\ROTR`                      :math:`\hex{8A}`  :math:`[\I64~\I64] \to [\I64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-irotr>`
+:math:`\F32.\ABS`                       :math:`\hex{8B}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`
+:math:`\F32.\NEG`                       :math:`\hex{8C}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`
+:math:`\F32.\CEIL`                      :math:`\hex{8D}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`
+:math:`\F32.\FLOOR`                     :math:`\hex{8E}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`
+:math:`\F32.\TRUNC`                     :math:`\hex{8F}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`
+:math:`\F32.\NEAREST`                   :math:`\hex{90}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`
+:math:`\F32.\SQRT`                      :math:`\hex{91}`  :math:`[\F32] \to [\F32]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`
+:math:`\F32.\ADD`                       :math:`\hex{92}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`
+:math:`\F32.\SUB`                       :math:`\hex{93}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`
+:math:`\F32.\MUL`                       :math:`\hex{94}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`
+:math:`\F32.\DIV`                       :math:`\hex{95}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`
+:math:`\F32.\FMIN`                      :math:`\hex{96}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`
+:math:`\F32.\FMAX`                      :math:`\hex{97}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`
+:math:`\F32.\COPYSIGN`                  :math:`\hex{98}`  :math:`[\F32~\F32] \to [\F32]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`
+:math:`\F64.\ABS`                       :math:`\hex{99}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fabs>`
+:math:`\F64.\NEG`                       :math:`\hex{9A}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fneg>`
+:math:`\F64.\CEIL`                      :math:`\hex{9B}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fceil>`
+:math:`\F64.\FLOOR`                     :math:`\hex{9C}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ffloor>`
+:math:`\F64.\TRUNC`                     :math:`\hex{9D}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-ftrunc>`
+:math:`\F64.\NEAREST`                   :math:`\hex{9E}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fnearest>`
+:math:`\F64.\SQRT`                      :math:`\hex{9F}`  :math:`[\F64] \to [\F64]`                   :ref:`validation <valid-unop>`            :ref:`execution <exec-unop>`, :ref:`operator <op-fsqrt>`
+:math:`\F64.\ADD`                       :math:`\hex{A0}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fadd>`
+:math:`\F64.\SUB`                       :math:`\hex{A1}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fsub>`
+:math:`\F64.\MUL`                       :math:`\hex{A2}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmul>`
+:math:`\F64.\DIV`                       :math:`\hex{A3}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fdiv>`
+:math:`\F64.\FMIN`                      :math:`\hex{A4}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmin>`
+:math:`\F64.\FMAX`                      :math:`\hex{A5}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fmax>`
+:math:`\F64.\COPYSIGN`                  :math:`\hex{A6}`  :math:`[\F64~\F64] \to [\F64]`              :ref:`validation <valid-binop>`           :ref:`execution <exec-binop>`, :ref:`operator <op-fcopysign>`
+:math:`\I32.\WRAP\K{\_}\I64`            :math:`\hex{A7}`  :math:`[\I64] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-wrap>`
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_s}`    :math:`\hex{A8}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
+:math:`\I32.\TRUNC\K{\_}\F32\K{\_u}`    :math:`\hex{A9}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_s}`    :math:`\hex{AA}`  :math:`[\F64] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
+:math:`\I32.\TRUNC\K{\_}\F64\K{\_u}`    :math:`\hex{AB}`  :math:`[\F64] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_s}`   :math:`\hex{AC}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_s>`
+:math:`\I64.\EXTEND\K{\_}\I32\K{\_u}`   :math:`\hex{AD}`  :math:`[\I32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-extend_u>`
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_s}`    :math:`\hex{AE}`  :math:`[\F32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
+:math:`\I64.\TRUNC\K{\_}\F32\K{\_u}`    :math:`\hex{AF}`  :math:`[\F32] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_s}`    :math:`\hex{B0}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_s>`
+:math:`\I64.\TRUNC\K{\_}\F64\K{\_u}`    :math:`\hex{B1}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-trunc_u>`
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_s}`  :math:`\hex{B2}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
+:math:`\F32.\CONVERT\K{\_}\I32\K{\_u}`  :math:`\hex{B3}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_s}`  :math:`\hex{B4}`  :math:`[\I64] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
+:math:`\F32.\CONVERT\K{\_}\I64\K{\_u}`  :math:`\hex{B5}`  :math:`[\I64] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
+:math:`\F32.\DEMOTE\K{\_}\F64`          :math:`\hex{B6}`  :math:`[\F64] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-demote>`
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_s}`  :math:`\hex{B7}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
+:math:`\F64.\CONVERT\K{\_}\I32\K{\_u}`  :math:`\hex{B8}`  :math:`[\I32] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_s}`  :math:`\hex{B9}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_s>`
+:math:`\F64.\CONVERT\K{\_}\I64\K{\_u}`  :math:`\hex{BA}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-convert_u>`
+:math:`\F64.\PROMOTE\K{\_}\F32`         :math:`\hex{BB}`  :math:`[\F32] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-promote>`
+:math:`\I32.\REINTERPRET\K{\_}\F32`     :math:`\hex{BC}`  :math:`[\F32] \to [\I32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\I64.\REINTERPRET\K{\_}\F64`     :math:`\hex{BD}`  :math:`[\F64] \to [\I64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\F32.\REINTERPRET\K{\_}\I32`     :math:`\hex{BE}`  :math:`[\I32] \to [\F32]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+:math:`\F64.\REINTERPRET\K{\_}\I64`     :math:`\hex{BF}`  :math:`[\I64] \to [\F64]`                   :ref:`validation <valid-cvtop>`           :ref:`execution <exec-cvtop>`, :ref:`operator <op-reinterpret>`
+======================================  ================  ==========================================  ========================================  ===============================================================
diff --git a/document/core/appendix/index-types.rst b/document/core/appendix/index-types.rst
index 5b8197831..f3f22fbab 100644
--- a/document/core/appendix/index-types.rst
+++ b/document/core/appendix/index-types.rst
@@ -13,7 +13,7 @@ Category                                  Constructor
 :ref:`Value type <syntax-valtype>`        |F32|                                        :math:`\hex{7D}` (-3 as |Bs7|)
 :ref:`Value type <syntax-valtype>`        |F64|                                        :math:`\hex{7C}` (-4 as |Bs7|)
 (reserved)                                                                             :math:`\hex{7C}` .. :math:`\hex{71}`
-:ref:`Element type <syntax-elemtype>`     |ANYFUNC|                                    :math:`\hex{70}` (-16 as |Bs7|)
+:ref:`Element type <syntax-elemtype>`     |FUNCREF|                                    :math:`\hex{70}` (-16 as |Bs7|)
 (reserved)                                                                             :math:`\hex{6F}` .. :math:`\hex{61}`
 :ref:`Function type <syntax-functype>`    :math:`[\valtype^\ast] \to [\valtype^\ast]`  :math:`\hex{60}` (-32 as |Bs7|)
 (reserved)                                                                             :math:`\hex{5F}` .. :math:`\hex{41}`
diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst
index 31f2ec854..330f42dc4 100644
--- a/document/core/appendix/properties.rst
+++ b/document/core/appendix/properties.rst
@@ -220,7 +220,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
 
 * The :ref:`limits <syntax-limits>` :math:`\{\LMIN~n, \LMAX~m^?\}` must be :ref:`valid <valid-limits>`.
 
-* Then the table instance is valid with :ref:`table type <syntax-tabletype>` :math:`\{\LMIN~n, \LMAX~m^?\}~\ANYFUNC`.
+* Then the table instance is valid with :ref:`table type <syntax-tabletype>` :math:`\{\LMIN~n, \LMAX~m^?\}~\FUNCREF`.
 
 .. math::
    \frac{
@@ -228,7 +228,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co
      \qquad
      \vdashlimits \{\LMIN~n, \LMAX~m^?\} \ok
    }{
-     S \vdashtableinst \{ \TIELEM~(\X{fa}^?)^n, \TIMAX~m^? \} : \{\LMIN~n, \LMAX~m^?\}~\ANYFUNC
+     S \vdashtableinst \{ \TIELEM~(\X{fa}^?)^n, \TIMAX~m^? \} : \{\LMIN~n, \LMAX~m^?\}~\FUNCREF
    }
 
 
@@ -490,7 +490,7 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 :math:`\INITELEM~\tableaddr~o~x^n`
 ..................................
 
-* The :ref:`external table value <syntax-externval>` :math:`\EVTABLE~\tableaddr` must be :ref:`valid <valid-externval-table>` with some :ref:`external table type <syntax-externtype>` :math:`\ETTABLE~\limits~\ANYFUNC`.
+* The :ref:`external table value <syntax-externval>` :math:`\EVTABLE~\tableaddr` must be :ref:`valid <valid-externval-table>` with some :ref:`external table type <syntax-externtype>` :math:`\ETTABLE~\limits~\FUNCREF`.
 
 * The index :math:`o + n` must be smaller than or equal to :math:`\limits.\LMIN`.
 
@@ -502,7 +502,7 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera
 
 .. math::
    \frac{
-     S \vdashexternval \EVTABLE~\tableaddr : \ETTABLE~\limits~\ANYFUNC
+     S \vdashexternval \EVTABLE~\tableaddr : \ETTABLE~\limits~\FUNCREF
      \qquad
      o + n \leq \limits.\LMIN
      \qquad
diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst
index 7e4fbbb32..1d4a8af8a 100644
--- a/document/core/binary/instructions.rst
+++ b/document/core/binary/instructions.rst
@@ -93,20 +93,20 @@ Variable Instructions
 
 :ref:`Variable instructions <syntax-instr-variable>` are represented by byte codes followed by the encoding of the respective :ref:`index <syntax-index>`.
 
-.. _binary-get_local:
-.. _binary-set_local:
-.. _binary-tee_local:
-.. _binary-get_global:
-.. _binary-set_global:
+.. _binary-local.get:
+.. _binary-local.set:
+.. _binary-local.tee:
+.. _binary-global.get:
+.. _binary-global.set:
 
 .. math::
    \begin{array}{llclll}
    \production{instruction} & \Binstr &::=& \dots \\ &&|&
-     \hex{20}~~x{:}\Blocalidx &\Rightarrow& \GETLOCAL~x \\ &&|&
-     \hex{21}~~x{:}\Blocalidx &\Rightarrow& \SETLOCAL~x \\ &&|&
-     \hex{22}~~x{:}\Blocalidx &\Rightarrow& \TEELOCAL~x \\ &&|&
-     \hex{23}~~x{:}\Bglobalidx &\Rightarrow& \GETGLOBAL~x \\ &&|&
-     \hex{24}~~x{:}\Bglobalidx &\Rightarrow& \SETGLOBAL~x \\
+     \hex{20}~~x{:}\Blocalidx &\Rightarrow& \LOCALGET~x \\ &&|&
+     \hex{21}~~x{:}\Blocalidx &\Rightarrow& \LOCALSET~x \\ &&|&
+     \hex{22}~~x{:}\Blocalidx &\Rightarrow& \LOCALTEE~x \\ &&|&
+     \hex{23}~~x{:}\Bglobalidx &\Rightarrow& \GLOBALGET~x \\ &&|&
+     \hex{24}~~x{:}\Bglobalidx &\Rightarrow& \GLOBALSET~x \\
    \end{array}
 
 
@@ -336,31 +336,31 @@ All other numeric instructions are plain opcodes without any immediates.
 .. math::
    \begin{array}{llclll}
    \phantom{\production{instruction}} & \phantom{\Binstr} &\phantom{::=}& \phantom{\dots} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
-     \hex{A7} &\Rightarrow& \I32.\WRAP\K{/}\I64 \\ &&|&
-     \hex{A8} &\Rightarrow& \I32.\TRUNC\K{\_s/}\F32 \\ &&|&
-     \hex{A9} &\Rightarrow& \I32.\TRUNC\K{\_u/}\F32 \\ &&|&
-     \hex{AA} &\Rightarrow& \I32.\TRUNC\K{\_s/}\F64 \\ &&|&
-     \hex{AB} &\Rightarrow& \I32.\TRUNC\K{\_u/}\F64 \\ &&|&
-     \hex{AC} &\Rightarrow& \I64.\EXTEND\K{\_s/}\I32 \\ &&|&
-     \hex{AD} &\Rightarrow& \I64.\EXTEND\K{\_u/}\I32 \\ &&|&
-     \hex{AE} &\Rightarrow& \I64.\TRUNC\K{\_s/}\F32 \\ &&|&
-     \hex{AF} &\Rightarrow& \I64.\TRUNC\K{\_u/}\F32 \\ &&|&
-     \hex{B0} &\Rightarrow& \I64.\TRUNC\K{\_s/}\F64 \\ &&|&
-     \hex{B1} &\Rightarrow& \I64.\TRUNC\K{\_u/}\F64 \\ &&|&
-     \hex{B2} &\Rightarrow& \F32.\CONVERT\K{\_s/}\I32 \\ &&|&
-     \hex{B3} &\Rightarrow& \F32.\CONVERT\K{\_u/}\I32 \\ &&|&
-     \hex{B4} &\Rightarrow& \F32.\CONVERT\K{\_s/}\I64 \\ &&|&
-     \hex{B5} &\Rightarrow& \F32.\CONVERT\K{\_u/}\I64 \\ &&|&
-     \hex{B6} &\Rightarrow& \F32.\DEMOTE\K{/}\F64 \\ &&|&
-     \hex{B7} &\Rightarrow& \F64.\CONVERT\K{\_s/}\I32 \\ &&|&
-     \hex{B8} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I32 \\ &&|&
-     \hex{B9} &\Rightarrow& \F64.\CONVERT\K{\_s/}\I64 \\ &&|&
-     \hex{BA} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I64 \\ &&|&
-     \hex{BB} &\Rightarrow& \F64.\PROMOTE\K{/}\F32 \\ &&|&
-     \hex{BC} &\Rightarrow& \I32.\REINTERPRET\K{/}\F32 \\ &&|&
-     \hex{BD} &\Rightarrow& \I64.\REINTERPRET\K{/}\F64 \\ &&|&
-     \hex{BE} &\Rightarrow& \F32.\REINTERPRET\K{/}\I32 \\ &&|&
-     \hex{BF} &\Rightarrow& \F64.\REINTERPRET\K{/}\I64 \\
+     \hex{A7} &\Rightarrow& \I32.\WRAP\K{\_}\I64 \\ &&|&
+     \hex{A8} &\Rightarrow& \I32.\TRUNC\K{\_}\F32\K{\_s} \\ &&|&
+     \hex{A9} &\Rightarrow& \I32.\TRUNC\K{\_}\F32\K{\_u} \\ &&|&
+     \hex{AA} &\Rightarrow& \I32.\TRUNC\K{\_}\F64\K{\_s} \\ &&|&
+     \hex{AB} &\Rightarrow& \I32.\TRUNC\K{\_}\F64\K{\_u} \\ &&|&
+     \hex{AC} &\Rightarrow& \I64.\EXTEND\K{\_}\I32\K{\_s} \\ &&|&
+     \hex{AD} &\Rightarrow& \I64.\EXTEND\K{\_}\I32\K{\_u} \\ &&|&
+     \hex{AE} &\Rightarrow& \I64.\TRUNC\K{\_}\F32\K{\_s} \\ &&|&
+     \hex{AF} &\Rightarrow& \I64.\TRUNC\K{\_}\F32\K{\_u} \\ &&|&
+     \hex{B0} &\Rightarrow& \I64.\TRUNC\K{\_}\F64\K{\_s} \\ &&|&
+     \hex{B1} &\Rightarrow& \I64.\TRUNC\K{\_}\F64\K{\_u} \\ &&|&
+     \hex{B2} &\Rightarrow& \F32.\CONVERT\K{\_}\I32\K{\_s} \\ &&|&
+     \hex{B3} &\Rightarrow& \F32.\CONVERT\K{\_}\I32\K{\_u} \\ &&|&
+     \hex{B4} &\Rightarrow& \F32.\CONVERT\K{\_}\I64\K{\_s} \\ &&|&
+     \hex{B5} &\Rightarrow& \F32.\CONVERT\K{\_}\I64\K{\_u} \\ &&|&
+     \hex{B6} &\Rightarrow& \F32.\DEMOTE\K{\_}\F64 \\ &&|&
+     \hex{B7} &\Rightarrow& \F64.\CONVERT\K{\_}\I32\K{\_s} \\ &&|&
+     \hex{B8} &\Rightarrow& \F64.\CONVERT\K{\_}\I32\K{\_u} \\ &&|&
+     \hex{B9} &\Rightarrow& \F64.\CONVERT\K{\_}\I64\K{\_s} \\ &&|&
+     \hex{BA} &\Rightarrow& \F64.\CONVERT\K{\_}\I64\K{\_u} \\ &&|&
+     \hex{BB} &\Rightarrow& \F64.\PROMOTE\K{\_}\F32 \\ &&|&
+     \hex{BC} &\Rightarrow& \I32.\REINTERPRET\K{\_}\F32 \\ &&|&
+     \hex{BD} &\Rightarrow& \I64.\REINTERPRET\K{\_}\F64 \\ &&|&
+     \hex{BE} &\Rightarrow& \F32.\REINTERPRET\K{\_}\I32 \\ &&|&
+     \hex{BF} &\Rightarrow& \F64.\REINTERPRET\K{\_}\I64 \\
    \end{array}
 
 
diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst
index 961a285cb..c114211b3 100644
--- a/document/core/binary/types.rst
+++ b/document/core/binary/types.rst
@@ -115,7 +115,7 @@ Table Types
    \production{table type} & \Btabletype &::=&
      \X{et}{:}\Belemtype~~\X{lim}{:}\Blimits &\Rightarrow& \X{lim}~\X{et} \\
    \production{element type} & \Belemtype &::=&
-     \hex{70} &\Rightarrow& \ANYFUNC \\
+     \hex{70} &\Rightarrow& \FUNCREF \\
    \end{array}
 
 
diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst
index 326c8f18b..80b65c9aa 100644
--- a/document/core/exec/instructions.rst
+++ b/document/core/exec/instructions.rst
@@ -28,7 +28,7 @@ And for :ref:`conversion operators <exec-cvtop>`:
 
 .. math::
    \begin{array}{lll@{\qquad}l}
-   \X{cvtop}_{t_1,t_2}(c) &=& \X{cvtop}_{|t_1|,|t_2|}(c) \\
+   \X{cvtop}^{\sx^?}_{t_1,t_2}(c) &=& \X{cvtop}^{\sx^?}_{|t_1|,|t_2|}(c) \\
    \end{array}
 
 Where the underlying operators are partial, the corresponding instruction will :ref:`trap <trap>` when the result is not defined.
@@ -148,16 +148,16 @@ Where the underlying operators are non-deterministic, because they may return on
 
 .. _exec-cvtop:
 
-:math:`t_2\K{.}\cvtop/t_1`
-..........................
+:math:`t_2\K{.}\cvtop\K{\_}t_1\K{\_}\sx^?`
+..........................................
 
 1. Assert: due to :ref:`validation <valid-cvtop>`, a value of :ref:`value type <syntax-valtype>` :math:`t_1` is on the top of the stack.
 
 2. Pop the value :math:`t_1.\CONST~c_1` from the stack.
 
-3. If :math:`\cvtop_{t_1,t_2}(c_1)` is defined:
+3. If :math:`\cvtop^{\sx^?}_{t_1,t_2}(c_1)` is defined:
 
-   a. Let :math:`c_2` be a possible result of computing :math:`\cvtop_{t_1,t_2}(c_1)`.
+   a. Let :math:`c_2` be a possible result of computing :math:`\cvtop^{\sx^?}_{t_1,t_2}(c_1)`.
 
    b. Push the value :math:`t_2.\CONST~c_2` to the stack.
 
@@ -167,10 +167,10 @@ Where the underlying operators are non-deterministic, because they may return on
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   (t_1\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& (t_2\K{.}\CONST~c_2)
-     & (\iff c_2 \in \cvtop_{t_1,t_2}(c_1)) \\
-   (t_1\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{/}t_1 &\stepto& \TRAP
-     & (\iff \cvtop_{t_1,t_2}(c_1) = \{\})
+   (t_1\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{\_}t_1\K{\_}\sx^? &\stepto& (t_2\K{.}\CONST~c_2)
+     & (\iff c_2 \in \cvtop^{\sx^?}_{t_1,t_2}(c_1)) \\
+   (t_1\K{.}\CONST~c_1)~t_2\K{.}\cvtop\K{\_}t_1\K{\_}\sx^? &\stepto& \TRAP
+     & (\iff \cvtop^{\sx^?}_{t_1,t_2}(c_1) = \{\})
    \end{array}
 
 
@@ -237,14 +237,14 @@ Parametric Instructions
 Variable Instructions
 ~~~~~~~~~~~~~~~~~~~~~
 
-.. _exec-get_local:
+.. _exec-local.get:
 
-:math:`\GETLOCAL~x`
+:math:`\LOCALGET~x`
 ...................
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-get_local>`, :math:`F.\ALOCALS[x]` exists.
+2. Assert: due to :ref:`validation <valid-local.get>`, :math:`F.\ALOCALS[x]` exists.
 
 3. Let :math:`\val` be the value :math:`F.\ALOCALS[x]`.
 
@@ -252,21 +252,21 @@ Variable Instructions
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   F; (\GETLOCAL~x) &\stepto& F; \val
+   F; (\LOCALGET~x) &\stepto& F; \val
      & (\iff F.\ALOCALS[x] = \val) \\
    \end{array}
 
 
-.. _exec-set_local:
+.. _exec-local.set:
 
-:math:`\SETLOCAL~x`
+:math:`\LOCALSET~x`
 ...................
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-set_local>`, :math:`F.\ALOCALS[x]` exists.
+2. Assert: due to :ref:`validation <valid-local.set>`, :math:`F.\ALOCALS[x]` exists.
 
-3. Assert: due to :ref:`validation <valid-set_local>`, a value is on the top of the stack.
+3. Assert: due to :ref:`validation <valid-local.set>`, a value is on the top of the stack.
 
 4. Pop the value :math:`\val` from the stack.
 
@@ -274,17 +274,17 @@ Variable Instructions
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   F; \val~(\SETLOCAL~x) &\stepto& F'; \epsilon
+   F; \val~(\LOCALSET~x) &\stepto& F'; \epsilon
      & (\iff F' = F \with \ALOCALS[x] = \val) \\
    \end{array}
 
 
-.. _exec-tee_local:
+.. _exec-local.tee:
 
-:math:`\TEELOCAL~x`
+:math:`\LOCALTEE~x`
 ...................
 
-1. Assert: due to :ref:`validation <valid-tee_local>`, a value is on the top of the stack.
+1. Assert: due to :ref:`validation <valid-local.tee>`, a value is on the top of the stack.
 
 2. Pop the value :math:`\val` from the stack.
 
@@ -292,26 +292,26 @@ Variable Instructions
 
 4. Push the value :math:`\val` to the stack.
 
-5. :ref:`Execute <exec-set_local>` the instruction :math:`(\SETLOCAL~x)`.
+5. :ref:`Execute <exec-local.set>` the instruction :math:`(\LOCALSET~x)`.
 
 .. math::
    \begin{array}{lcl@{\qquad}l}
-   \val~(\TEELOCAL~x) &\stepto& \val~\val~(\SETLOCAL~x)
+   \val~(\LOCALTEE~x) &\stepto& \val~\val~(\LOCALSET~x)
    \end{array}
 
 
-.. _exec-get_global:
+.. _exec-global.get:
 
-:math:`\GETGLOBAL~x`
+:math:`\GLOBALGET~x`
 ....................
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-get_global>`, :math:`F.\AMODULE.\MIGLOBALS[x]` exists.
+2. Assert: due to :ref:`validation <valid-global.get>`, :math:`F.\AMODULE.\MIGLOBALS[x]` exists.
 
 3. Let :math:`a` be the :ref:`global address <syntax-globaladdr>` :math:`F.\AMODULE.\MIGLOBALS[x]`.
 
-4. Assert: due to :ref:`validation <valid-get_global>`, :math:`S.\SGLOBALS[a]` exists.
+4. Assert: due to :ref:`validation <valid-global.get>`, :math:`S.\SGLOBALS[a]` exists.
 
 5. Let :math:`\X{glob}` be the :ref:`global instance <syntax-globalinst>` :math:`S.\SGLOBALS[a]`.
 
@@ -322,29 +322,29 @@ Variable Instructions
 .. math::
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   S; F; (\GETGLOBAL~x) &\stepto& S; F; \val
+   S; F; (\GLOBALGET~x) &\stepto& S; F; \val
    \end{array}
    \\ \qquad
      (\iff S.\SGLOBALS[F.\AMODULE.\MIGLOBALS[x]].\GIVALUE = \val) \\
    \end{array}
 
 
-.. _exec-set_global:
+.. _exec-global.set:
 
-:math:`\SETGLOBAL~x`
+:math:`\GLOBALSET~x`
 ....................
 
 1. Let :math:`F` be the :ref:`current <exec-notation-textual>` :ref:`frame <syntax-frame>`.
 
-2. Assert: due to :ref:`validation <valid-set_global>`, :math:`F.\AMODULE.\MIGLOBALS[x]` exists.
+2. Assert: due to :ref:`validation <valid-global.set>`, :math:`F.\AMODULE.\MIGLOBALS[x]` exists.
 
 3. Let :math:`a` be the :ref:`global address <syntax-globaladdr>` :math:`F.\AMODULE.\MIGLOBALS[x]`.
 
-4. Assert: due to :ref:`validation <valid-set_global>`, :math:`S.\SGLOBALS[a]` exists.
+4. Assert: due to :ref:`validation <valid-global.set>`, :math:`S.\SGLOBALS[a]` exists.
 
 5. Let :math:`\X{glob}` be the :ref:`global instance <syntax-globalinst>` :math:`S.\SGLOBALS[a]`.
 
-6. Assert: due to :ref:`validation <valid-set_global>`, a value is on the top of the stack.
+6. Assert: due to :ref:`validation <valid-global.set>`, a value is on the top of the stack.
 
 7. Pop the value :math:`\val` from the stack.
 
@@ -353,14 +353,14 @@ Variable Instructions
 .. math::
    \begin{array}{l}
    \begin{array}{lcl@{\qquad}l}
-   S; F; \val~(\SETGLOBAL~x) &\stepto& S'; F; \epsilon
+   S; F; \val~(\GLOBALSET~x) &\stepto& S'; F; \epsilon
    \end{array}
    \\ \qquad
    (\iff S' = S \with \SGLOBALS[F.\AMODULE.\MIGLOBALS[x]].\GIVALUE = \val) \\
    \end{array}
 
 .. note::
-   :ref:`Validation <valid-set_global>` ensures that the global is, in fact, marked as mutable.
+   :ref:`Validation <valid-global.set>` ensures that the global is, in fact, marked as mutable.
 
 
 .. index:: memory instruction, memory index, store, frame, address, memory address, memory instance, store, frame, value, integer, limits, value type, bit width
diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst
index f6ae892d7..4d6e7b04c 100644
--- a/document/core/exec/modules.rst
+++ b/document/core/exec/modules.rst
@@ -43,13 +43,13 @@ The following auxiliary typing rules specify this typing relation relative to a
 
 * The store entry :math:`S.\STABLES[a]` must be a :ref:`table instance <syntax-tableinst>` :math:`\{\TIELEM~(\X{fa}^?)^n, \TIMAX~m^?\}`.
 
-* Then :math:`\EVTABLE~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETTABLE~(\{\LMIN~n, \LMAX~m^?\}~\ANYFUNC)`.
+* Then :math:`\EVTABLE~a` is valid with :ref:`external type <syntax-externtype>` :math:`\ETTABLE~(\{\LMIN~n, \LMAX~m^?\}~\FUNCREF)`.
 
 .. math::
    \frac{
      S.\STABLES[a] = \{ \TIELEM~(\X{fa}^?)^n, \TIMAX~m^? \}
    }{
-     S \vdashexternval \EVTABLE~a : \ETTABLE~(\{\LMIN~n, \LMAX~m^?\}~\ANYFUNC)
+     S \vdashexternval \EVTABLE~a : \ETTABLE~(\{\LMIN~n, \LMAX~m^?\}~\FUNCREF)
    }
 
 
diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst
index a952041f6..509d94184 100644
--- a/document/core/syntax/instructions.rst
+++ b/document/core/syntax/instructions.rst
@@ -64,14 +64,14 @@ These operations closely match respective operations available in hardware.
      \K{i}\X{nn}\K{.}\itestop \\&&|&
      \K{i}\X{nn}\K{.}\irelop ~|~
      \K{f}\X{nn}\K{.}\frelop \\&&|&
-     \K{i32.}\WRAP\K{/i64} ~|~
-     \K{i64.}\EXTEND\K{\_}\sx/\K{i32} ~|~
-     \K{i}\X{nn}\K{.}\TRUNC\K{\_}\sx/\K{f}\X{mm} \\&&|&
-     \K{f32.}\DEMOTE\K{/f64} ~|~
-     \K{f64.}\PROMOTE\K{/f32} ~|~
-     \K{f}\X{nn}\K{.}\CONVERT\K{\_}\sx/\K{i}\X{mm} \\&&|&
-     \K{i}\X{nn}\K{.}\REINTERPRET\K{/f}\X{nn} ~|~
-     \K{f}\X{nn}\K{.}\REINTERPRET\K{/i}\X{nn} \\&&|&
+     \K{i32.}\WRAP\K{\_i64} ~|~
+     \K{i64.}\EXTEND\K{\_i32}\K{\_}\sx ~|~
+     \K{i}\X{nn}\K{.}\TRUNC\K{\_f}\X{mm}\K{\_}\sx \\&&|&
+     \K{f32.}\DEMOTE\K{\_f64} ~|~
+     \K{f64.}\PROMOTE\K{\_f32} ~|~
+     \K{f}\X{nn}\K{.}\CONVERT\K{\_i}\X{mm}\K{\_}\sx \\&&|&
+     \K{i}\X{nn}\K{.}\REINTERPRET\K{\_f}\X{nn} ~|~
+     \K{f}\X{nn}\K{.}\REINTERPRET\K{\_i}\X{nn} \\&&|&
      \dots \\
    \production{integer unary operator} & \iunop &::=&
      \K{clz} ~|~
@@ -158,9 +158,9 @@ Occasionally, it is convenient to group operators together according to the foll
    \production{relational operator} & \relop &::=& \irelop ~|~ \frelop \\
    \production{conversion operator} & \cvtop &::=&
      \WRAP ~|~
-     \EXTEND\K{\_}\sx ~|~
-     \TRUNC\K{\_}\sx ~|~
-     \CONVERT\K{\_}\sx ~|~
+     \EXTEND ~|~
+     \TRUNC ~|~
+     \CONVERT ~|~
      \DEMOTE ~|~
      \PROMOTE ~|~
      \REINTERPRET \\
@@ -202,15 +202,15 @@ Variable instructions are concerned with access to :ref:`local <syntax-local>` o
    \begin{array}{llcl}
    \production{instruction} & \instr &::=&
      \dots \\&&|&
-     \GETLOCAL~\localidx \\&&|&
-     \SETLOCAL~\localidx \\&&|&
-     \TEELOCAL~\localidx \\&&|&
-     \GETGLOBAL~\globalidx \\&&|&
-     \SETGLOBAL~\globalidx \\
+     \LOCALGET~\localidx \\&&|&
+     \LOCALSET~\localidx \\&&|&
+     \LOCALTEE~\localidx \\&&|&
+     \GLOBALGET~\globalidx \\&&|&
+     \GLOBALSET~\globalidx \\
    \end{array}
 
 These instructions get or set the values of variables, respectively.
-The |TEELOCAL| instruction is like |SETLOCAL| but also returns its argument.
+The |LOCALTEE| instruction is like |LOCALSET| but also returns its argument.
 
 
 .. index:: ! memory instruction, memory, memory index, page size, little endian, trap
@@ -342,7 +342,7 @@ However, forward branches that target a control instruction with a non-empty res
 
 The |CALL| instruction invokes another :ref:`function <syntax-func>`, consuming the necessary arguments from the stack and returning the result values of the call.
 The |CALLINDIRECT| instruction calls a function indirectly through an operand indexing into a :ref:`table <syntax-table>`.
-Since tables may contain function elements of heterogeneous type |ANYFUNC|,
+Since tables may contain function elements of heterogeneous type |FUNCREF|,
 the callee is dynamically checked against the :ref:`function type <syntax-functype>` indexed by the instruction's immediate, and the call aborted with a :ref:`trap <trap>` if it does not match.
 
 .. note::
diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst
index b92d9c92c..be8106362 100644
--- a/document/core/syntax/types.rst
+++ b/document/core/syntax/types.rst
@@ -145,13 +145,13 @@ Table Types
    \production{table type} & \tabletype &::=&
      \limits~\elemtype \\
    \production{element type} & \elemtype &::=&
-     \ANYFUNC \\
+     \FUNCREF \\
    \end{array}
 
 Like memories, tables are constrained by limits for their minimum and optionally maximum size.
 The limits are given in numbers of entries.
 
-The element type |ANYFUNC| is the infinite union of all :ref:`function types <syntax-functype>`.
+The element type |FUNCREF| is the infinite union of all :ref:`function types <syntax-functype>`.
 A table of that type thus contains references to functions of heterogeneous type.
 
 .. note::
diff --git a/document/core/text/instructions.rst b/document/core/text/instructions.rst
index 025d80a1b..2ced672db 100644
--- a/document/core/text/instructions.rst
+++ b/document/core/text/instructions.rst
@@ -144,20 +144,20 @@ Parametric Instructions
 Variable Instructions
 ~~~~~~~~~~~~~~~~~~~~~
 
-.. _text-get_local:
-.. _text-set_local:
-.. _text-tee_local:
-.. _text-get_global:
-.. _text-set_global:
+.. _text-local.get:
+.. _text-local.set:
+.. _text-local.tee:
+.. _text-global.get:
+.. _text-global.set:
 
 .. math::
    \begin{array}{llclll}
    \production{instruction} & \Tplaininstr_I &::=& \dots \\ &&|&
-     \text{get\_local}~~x{:}\Tlocalidx_I &\Rightarrow& \GETLOCAL~x \\ &&|&
-     \text{set\_local}~~x{:}\Tlocalidx_I &\Rightarrow& \SETLOCAL~x \\ &&|&
-     \text{tee\_local}~~x{:}\Tlocalidx_I &\Rightarrow& \TEELOCAL~x \\ &&|&
-     \text{get\_global}~~x{:}\Tglobalidx_I &\Rightarrow& \GETGLOBAL~x \\ &&|&
-     \text{set\_global}~~x{:}\Tglobalidx_I &\Rightarrow& \SETGLOBAL~x \\
+     \text{local.get}~~x{:}\Tlocalidx_I &\Rightarrow& \LOCALGET~x \\ &&|&
+     \text{local.set}~~x{:}\Tlocalidx_I &\Rightarrow& \LOCALSET~x \\ &&|&
+     \text{local.tee}~~x{:}\Tlocalidx_I &\Rightarrow& \LOCALTEE~x \\ &&|&
+     \text{global.get}~~x{:}\Tglobalidx_I &\Rightarrow& \GLOBALGET~x \\ &&|&
+     \text{global.set}~~x{:}\Tglobalidx_I &\Rightarrow& \GLOBALSET~x \\
    \end{array}
 
 
@@ -386,31 +386,31 @@ Numeric Instructions
 .. math::
    \begin{array}{llclll}
    \phantom{\production{instruction}} & \phantom{\Tplaininstr_I} &\phantom{::=}& \phantom{thisisenough} && \phantom{thisshouldbeenough} \\[-2ex] &&|&
-     \text{i32.wrap/i64} &\Rightarrow& \I32.\WRAP\K{/}\I64 \\ &&|&
-     \text{i32.trunc\_s/f32} &\Rightarrow& \I32.\TRUNC\K{\_s/}\F32 \\ &&|&
-     \text{i32.trunc\_u/f32} &\Rightarrow& \I32.\TRUNC\K{\_u/}\F32 \\ &&|&
-     \text{i32.trunc\_s/f64} &\Rightarrow& \I32.\TRUNC\K{\_s/}\F64 \\ &&|&
-     \text{i32.trunc\_u/f64} &\Rightarrow& \I32.\TRUNC\K{\_u/}\F64 \\ &&|&
-     \text{i64.extend\_s/i32} &\Rightarrow& \I64.\EXTEND\K{\_s/}\I32 \\ &&|&
-     \text{i64.extend\_u/i32} &\Rightarrow& \I64.\EXTEND\K{\_u/}\I32 \\ &&|&
-     \text{i64.trunc\_s/f32} &\Rightarrow& \I64.\TRUNC\K{\_s/}\F32 \\ &&|&
-     \text{i64.trunc\_u/f32} &\Rightarrow& \I64.\TRUNC\K{\_u/}\F32 \\ &&|&
-     \text{i64.trunc\_s/f64} &\Rightarrow& \I64.\TRUNC\K{\_s/}\F64 \\ &&|&
-     \text{i64.trunc\_u/f64} &\Rightarrow& \I64.\TRUNC\K{\_u/}\F64 \\ &&|&
-     \text{f32.convert\_s/i32} &\Rightarrow& \F32.\CONVERT\K{\_s/}\I32 \\ &&|&
-     \text{f32.convert\_u/i32} &\Rightarrow& \F32.\CONVERT\K{\_u/}\I32 \\ &&|&
-     \text{f32.convert\_s/i64} &\Rightarrow& \F32.\CONVERT\K{\_s/}\I64 \\ &&|&
-     \text{f32.convert\_u/i64} &\Rightarrow& \F32.\CONVERT\K{\_u/}\I64 \\ &&|&
-     \text{f32.demote/f64} &\Rightarrow& \F32.\DEMOTE\K{/}\F64 \\ &&|&
-     \text{f64.convert\_s/i32} &\Rightarrow& \F64.\CONVERT\K{\_s/}\I32 \\ &&|&
-     \text{f64.convert\_u/i32} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I32 \\ &&|&
-     \text{f64.convert\_s/i64} &\Rightarrow& \F64.\CONVERT\K{\_s/}\I64 \\ &&|&
-     \text{f64.convert\_u/i64} &\Rightarrow& \F64.\CONVERT\K{\_u/}\I64 \\ &&|&
-     \text{f64.promote/f32} &\Rightarrow& \F64.\PROMOTE\K{/}\F32 \\ &&|&
-     \text{i32.reinterpret/f32} &\Rightarrow& \I32.\REINTERPRET\K{/}\F32 \\ &&|&
-     \text{i64.reinterpret/f64} &\Rightarrow& \I64.\REINTERPRET\K{/}\F64 \\ &&|&
-     \text{f32.reinterpret/i32} &\Rightarrow& \F32.\REINTERPRET\K{/}\I32 \\ &&|&
-     \text{f64.reinterpret/i64} &\Rightarrow& \F64.\REINTERPRET\K{/}\I64 \\
+     \text{i32.wrap\_i64} &\Rightarrow& \I32.\WRAP\K{\_}\I64 \\ &&|&
+     \text{i32.trunc\_f32\_s} &\Rightarrow& \I32.\TRUNC\K{\_}\F32\K{\_s} \\ &&|&
+     \text{i32.trunc\_f32\_u} &\Rightarrow& \I32.\TRUNC\K{\_}\F32\K{\_u} \\ &&|&
+     \text{i32.trunc\_f64\_s} &\Rightarrow& \I32.\TRUNC\K{\_}\F64\K{\_s} \\ &&|&
+     \text{i32.trunc\_f64\_u} &\Rightarrow& \I32.\TRUNC\K{\_}\F64\K{\_u} \\ &&|&
+     \text{i64.extend\_i32\_s} &\Rightarrow& \I64.\EXTEND\K{\_}\I32\K{\_s} \\ &&|&
+     \text{i64.extend\_i32\_u} &\Rightarrow& \I64.\EXTEND\K{\_}\I32\K{\_u} \\ &&|&
+     \text{i64.trunc\_f32\_s} &\Rightarrow& \I64.\TRUNC\K{\_}\F32\K{\_s} \\ &&|&
+     \text{i64.trunc\_f32\_u} &\Rightarrow& \I64.\TRUNC\K{\_}\F32\K{\_u} \\ &&|&
+     \text{i64.trunc\_f64\_s} &\Rightarrow& \I64.\TRUNC\K{\_}\F64\K{\_s} \\ &&|&
+     \text{i64.trunc\_f64\_u} &\Rightarrow& \I64.\TRUNC\K{\_}\F64\K{\_u} \\ &&|&
+     \text{f32.convert\_i32\_s} &\Rightarrow& \F32.\CONVERT\K{\_}\I32\K{\_s} \\ &&|&
+     \text{f32.convert\_i32\_u} &\Rightarrow& \F32.\CONVERT\K{\_}\I32\K{\_u} \\ &&|&
+     \text{f32.convert\_i64\_s} &\Rightarrow& \F32.\CONVERT\K{\_}\I64\K{\_s} \\ &&|&
+     \text{f32.convert\_i64\_u} &\Rightarrow& \F32.\CONVERT\K{\_}\I64\K{\_u} \\ &&|&
+     \text{f32.demote\_f64} &\Rightarrow& \F32.\DEMOTE\K{\_}\F64 \\ &&|&
+     \text{f64.convert\_i32\_s} &\Rightarrow& \F64.\CONVERT\K{\_}\I32\K{\_s} \\ &&|&
+     \text{f64.convert\_i32\_u} &\Rightarrow& \F64.\CONVERT\K{\_}\I32\K{\_u} \\ &&|&
+     \text{f64.convert\_i64\_s} &\Rightarrow& \F64.\CONVERT\K{\_}\I64\K{\_s} \\ &&|&
+     \text{f64.convert\_i64\_u} &\Rightarrow& \F64.\CONVERT\K{\_}\I64\K{\_u} \\ &&|&
+     \text{f64.promote\_f32} &\Rightarrow& \F64.\PROMOTE\K{\_}\F32 \\ &&|&
+     \text{i32.reinterpret\_f32} &\Rightarrow& \I32.\REINTERPRET\K{\_}\F32 \\ &&|&
+     \text{i64.reinterpret\_f64} &\Rightarrow& \I64.\REINTERPRET\K{\_}\F64 \\ &&|&
+     \text{f32.reinterpret\_i32} &\Rightarrow& \F32.\REINTERPRET\K{\_}\I32 \\ &&|&
+     \text{f64.reinterpret\_i64} &\Rightarrow& \F64.\REINTERPRET\K{\_}\I64 \\
    \end{array}
 
 
diff --git a/document/core/text/types.rst b/document/core/text/types.rst
index de5ed5f30..3943faa3a 100644
--- a/document/core/text/types.rst
+++ b/document/core/text/types.rst
@@ -120,7 +120,7 @@ Table Types
    \production{table type} & \Ttabletype &::=&
      \X{lim}{:}\Tlimits~~\X{et}{:}\Telemtype &\Rightarrow& \X{lim}~\X{et} \\
    \production{element type} & \Telemtype &::=&
-     \text{anyfunc} &\Rightarrow& \ANYFUNC \\
+     \text{funcref} &\Rightarrow& \FUNCREF \\
    \end{array}
 
 .. note::
diff --git a/document/core/util/macros.def b/document/core/util/macros.def
index b8dc96b3a..67d9b854f 100644
--- a/document/core/util/macros.def
+++ b/document/core/util/macros.def
@@ -171,7 +171,7 @@
 .. |F32| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f32}}
 .. |F64| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f64}}
 
-.. |ANYFUNC| mathdef:: \xref{syntax/types}{syntax-elemtype}{\K{anyfunc}}
+.. |FUNCREF| mathdef:: \xref{syntax/types}{syntax-elemtype}{\K{funcref}}
 
 .. |MVAR| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}}
 .. |MCONST| mathdef:: \xref{syntax/types}{syntax-mut}{\K{const}}
@@ -317,11 +317,11 @@
 .. |DROP| mathdef:: \xref{syntax/instructions}{syntax-instr-parametric}{\K{drop}}
 .. |SELECT| mathdef:: \xref{syntax/instructions}{syntax-instr-parametric}{\K{select}}
 
-.. |GETLOCAL| mathdef:: \xref{syntax/instructions}{syntax-instr-variable}{\K{get\_local}}
-.. |SETLOCAL| mathdef:: \xref{syntax/instructions}{syntax-instr-variable}{\K{set\_local}}
-.. |TEELOCAL| mathdef:: \xref{syntax/instructions}{syntax-instr-variable}{\K{tee\_local}}
-.. |GETGLOBAL| mathdef:: \xref{syntax/instructions}{syntax-instr-variable}{\K{get\_global}}
-.. |SETGLOBAL| mathdef:: \xref{syntax/instructions}{syntax-instr-variable}{\K{set\_global}}
+.. |LOCALGET| mathdef:: \xref{syntax/instructions}{syntax-instr-variable}{\K{local.get}}
+.. |LOCALSET| mathdef:: \xref{syntax/instructions}{syntax-instr-variable}{\K{local.set}}
+.. |LOCALTEE| mathdef:: \xref{syntax/instructions}{syntax-instr-variable}{\K{local.tee}}
+.. |GLOBALGET| mathdef:: \xref{syntax/instructions}{syntax-instr-variable}{\K{global.get}}
+.. |GLOBALSET| mathdef:: \xref{syntax/instructions}{syntax-instr-variable}{\K{global.set}}
 
 .. |LOAD| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{load}}
 .. |STORE| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{store}}
@@ -940,15 +940,15 @@
 .. |fge| mathdef:: \xref{exec/numerics}{op-fge}{\F{fge}}
 
 .. |extend| mathdef:: \xref{exec/numerics}{op-extend_u}{\F{extend}}
-.. |extendu| mathdef:: \xref{exec/numerics}{op-extend_u}{\F{extend\_u}}
-.. |extends| mathdef:: \xref{exec/numerics}{op-extend_s}{\F{extend\_s}}
+.. |extendu| mathdef:: \xref{exec/numerics}{op-extend_u}{\F{extend}^{\K{u}}}
+.. |extends| mathdef:: \xref{exec/numerics}{op-extend_s}{\F{extend}^{\K{s}}}
 .. |wrap| mathdef:: \xref{exec/numerics}{op-wrap}{\F{wrap}}
-.. |truncu| mathdef:: \xref{exec/numerics}{op-trunc_u}{\F{trunc\_u}}
-.. |truncs| mathdef:: \xref{exec/numerics}{op-trunc_s}{\F{trunc\_s}}
+.. |truncu| mathdef:: \xref{exec/numerics}{op-trunc_u}{\F{trunc}^{\K{u}}}
+.. |truncs| mathdef:: \xref{exec/numerics}{op-trunc_s}{\F{trunc}^{\K{s}}}
 .. |promote| mathdef:: \xref{exec/numerics}{op-promote}{\F{promote}}
 .. |demote| mathdef:: \xref{exec/numerics}{op-demote}{\F{demote}}
-.. |convertu| mathdef:: \xref{exec/numerics}{op-convert_u}{\F{convert\_u}}
-.. |converts| mathdef:: \xref{exec/numerics}{op-convert_s}{\F{convert\_s}}
+.. |convertu| mathdef:: \xref{exec/numerics}{op-convert_u}{\F{convert}^{\K{u}}}
+.. |converts| mathdef:: \xref{exec/numerics}{op-convert_s}{\F{convert}^{\K{s}}}
 .. |reinterpret| mathdef:: \xref{exec/numerics}{op-reinterpret}{\F{reinterpret}}
 
 
diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst
index 9e5f6f182..e316ff687 100644
--- a/document/core/valid/conventions.rst
+++ b/document/core/valid/conventions.rst
@@ -148,13 +148,13 @@ and there is one respective rule for each relevant construct :math:`A` of the ab
    (saying that it consumes two |I32| values and produces one),
    independent of any side conditions.
 
-   An instruction like |GETLOCAL| can be typed as follows:
+   An instruction like |LOCALGET| can be typed as follows:
 
    .. math::
       \frac{
         C.\CLOCALS[x] = t
       }{
-        C \vdash \GETLOCAL~x : [] \to [t]
+        C \vdash \LOCALGET~x : [] \to [t]
       }
 
    Here, the premise enforces that the immediate :ref:`local index <syntax-localidx>` :math:`x` exists in the context.
diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst
index 288c2a67b..3d4aecf0a 100644
--- a/document/core/valid/instructions.rst
+++ b/document/core/valid/instructions.rst
@@ -142,15 +142,15 @@ Numeric Instructions
 
 .. _valid-cvtop:
 
-:math:`t_2\K{.}\cvtop/t_1`
-..........................
+:math:`t_2\K{.}\cvtop\K{\_}t_1\K{\_}\sx^?`
+..........................................
 
 * The instruction is valid with type :math:`[t_1] \to [t_2]`.
 
 .. math::
    \frac{
    }{
-     C \vdashinstr t_2\K{.}\cvtop/t_1 : [t_1] \to [t_2]
+     C \vdashinstr t_2\K{.}\cvtop\K{\_}t_1\K{\_}\sx^? : [t_1] \to [t_2]
    }
 
 
@@ -201,9 +201,9 @@ Parametric Instructions
 Variable Instructions
 ~~~~~~~~~~~~~~~~~~~~~
 
-.. _valid-get_local:
+.. _valid-local.get:
 
-:math:`\GETLOCAL~x`
+:math:`\LOCALGET~x`
 ...................
 
 * The local :math:`C.\CLOCALS[x]` must be defined in the context.
@@ -216,13 +216,13 @@ Variable Instructions
    \frac{
      C.\CLOCALS[x] = t
    }{
-     C \vdashinstr \GETLOCAL~x : [] \to [t]
+     C \vdashinstr \LOCALGET~x : [] \to [t]
    }
 
 
-.. _valid-set_local:
+.. _valid-local.set:
 
-:math:`\SETLOCAL~x`
+:math:`\LOCALSET~x`
 ...................
 
 * The local :math:`C.\CLOCALS[x]` must be defined in the context.
@@ -235,13 +235,13 @@ Variable Instructions
    \frac{
      C.\CLOCALS[x] = t
    }{
-     C \vdashinstr \SETLOCAL~x : [t] \to []
+     C \vdashinstr \LOCALSET~x : [t] \to []
    }
 
 
-.. _valid-tee_local:
+.. _valid-local.tee:
 
-:math:`\TEELOCAL~x`
+:math:`\LOCALTEE~x`
 ...................
 
 * The local :math:`C.\CLOCALS[x]` must be defined in the context.
@@ -254,13 +254,13 @@ Variable Instructions
    \frac{
      C.\CLOCALS[x] = t
    }{
-     C \vdashinstr \TEELOCAL~x : [t] \to [t]
+     C \vdashinstr \LOCALTEE~x : [t] \to [t]
    }
 
 
-.. _valid-get_global:
+.. _valid-global.get:
 
-:math:`\GETGLOBAL~x`
+:math:`\GLOBALGET~x`
 ....................
 
 * The global :math:`C.\CGLOBALS[x]` must be defined in the context.
@@ -273,13 +273,13 @@ Variable Instructions
    \frac{
      C.\CGLOBALS[x] = \mut~t
    }{
-     C \vdashinstr \GETGLOBAL~x : [] \to [t]
+     C \vdashinstr \GLOBALGET~x : [] \to [t]
    }
 
 
-.. _valid-set_global:
+.. _valid-global.set:
 
-:math:`\SETGLOBAL~x`
+:math:`\GLOBALSET~x`
 ....................
 
 * The global :math:`C.\CGLOBALS[x]` must be defined in the context.
@@ -294,7 +294,7 @@ Variable Instructions
    \frac{
      C.\CGLOBALS[x] = \MVAR~t
    }{
-     C \vdashinstr \SETGLOBAL~x : [t] \to []
+     C \vdashinstr \GLOBALSET~x : [t] \to []
    }
 
 
@@ -676,7 +676,7 @@ Control Instructions
 
 * Let :math:`\limits~\elemtype` be the :ref:`table type <syntax-tabletype>` :math:`C.\CTABLES[0]`.
 
-* The :ref:`element type <syntax-elemtype>` :math:`\elemtype` must be |ANYFUNC|.
+* The :ref:`element type <syntax-elemtype>` :math:`\elemtype` must be |FUNCREF|.
 
 * The type :math:`C.\CTYPES[x]` must be defined in the context.
 
@@ -686,7 +686,7 @@ Control Instructions
 
 .. math::
    \frac{
-     C.\CTABLES[0] = \limits~\ANYFUNC
+     C.\CTABLES[0] = \limits~\FUNCREF
      \qquad
      C.\CTYPES[x] = [t_1^\ast] \to [t_2^\ast]
    }{
@@ -780,7 +780,7 @@ Constant Expressions
 
   * either of the form :math:`t.\CONST~c`,
 
-  * or of the form :math:`\GETGLOBAL~x`, in which case :math:`C.\CGLOBALS[x]` must be a :ref:`global type <syntax-globaltype>` of the form :math:`\CONST~t`.
+  * or of the form :math:`\GLOBALGET~x`, in which case :math:`C.\CGLOBALS[x]` must be a :ref:`global type <syntax-globaltype>` of the form :math:`\CONST~t`.
 
 .. math::
    \frac{
@@ -798,11 +798,11 @@ Constant Expressions
    \frac{
      C.\CGLOBALS[x] = \CONST~t
    }{
-     C \vdashinstrconst \GETGLOBAL~x \const
+     C \vdashinstrconst \GLOBALGET~x \const
    }
 
 .. note::
-   Currently, constant expressions occurring as initializers of :ref:`globals <syntax-global>` are further constrained in that contained |GETGLOBAL| instructions are only allowed to refer to *imported* globals.
+   Currently, constant expressions occurring as initializers of :ref:`globals <syntax-global>` are further constrained in that contained |GLOBALGET| instructions are only allowed to refer to *imported* globals.
    This is enforced in the :ref:`validation rule for modules <valid-module>` by constraining the context :math:`C` accordingly.
 
    The definition of constant expression may be extended in future versions of WebAssembly.
diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst
index d8dd82ee1..a7c93c418 100644
--- a/document/core/valid/modules.rst
+++ b/document/core/valid/modules.rst
@@ -154,7 +154,7 @@ Element segments :math:`\elem` are not classified by a type.
 
 * Let :math:`\limits~\elemtype` be the :ref:`table type <syntax-tabletype>` :math:`C.\CTABLES[x]`.
 
-* The :ref:`element type <syntax-elemtype>` :math:`\elemtype` must be |ANYFUNC|.
+* The :ref:`element type <syntax-elemtype>` :math:`\elemtype` must be |FUNCREF|.
 
 * The expression :math:`\expr` must be :ref:`valid <valid-expr>` with :ref:`result type <syntax-resulttype>` :math:`[\I32]`.
 
@@ -168,7 +168,7 @@ Element segments :math:`\elem` are not classified by a type.
 
 .. math::
    \frac{
-     C.\CTABLES[x] = \limits~\ANYFUNC
+     C.\CTABLES[x] = \limits~\FUNCREF
      \qquad
      C \vdashexpr \expr : [\I32]
      \qquad
diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 8358cb341..cff17feaa 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -72,8 +72,8 @@ let u32 s =
   Int32.(add lo (shift_left hi 16))
 
 let u64 s =
-  let lo = I64_convert.extend_u_i32 (u32 s) in
-  let hi = I64_convert.extend_u_i32 (u32 s) in
+  let lo = I64_convert.extend_i32_u (u32 s) in
+  let hi = I64_convert.extend_i32_u (u32 s) in
   Int64.(add lo (shift_left hi 32))
 
 let rec vuN n s =
@@ -141,7 +141,7 @@ let value_type s =
 
 let elem_type s =
   match vs7 s with
-  | -0x10 -> AnyFuncType
+  | -0x10 -> FuncRefType
   | _ -> error s (pos s - 1) "invalid element type"
 
 let stack_type s =
@@ -254,11 +254,11 @@ let rec instr s =
 
   | 0x1c | 0x1d | 0x1e | 0x1f as b -> illegal s pos b
 
-  | 0x20 -> get_local (at var s)
-  | 0x21 -> set_local (at var s)
-  | 0x22 -> tee_local (at var s)
-  | 0x23 -> get_global (at var s)
-  | 0x24 -> set_global (at var s)
+  | 0x20 -> local_get (at var s)
+  | 0x21 -> local_set (at var s)
+  | 0x22 -> local_tee (at var s)
+  | 0x23 -> global_get (at var s)
+  | 0x24 -> global_set (at var s)
 
   | 0x25 | 0x26 | 0x27 as b -> illegal s pos b
 
@@ -406,25 +406,25 @@ let rec instr s =
   | 0xa6 -> f64_copysign
 
   | 0xa7 -> i32_wrap_i64
-  | 0xa8 -> i32_trunc_s_f32
-  | 0xa9 -> i32_trunc_u_f32
-  | 0xaa -> i32_trunc_s_f64
-  | 0xab -> i32_trunc_u_f64
-  | 0xac -> i64_extend_s_i32
-  | 0xad -> i64_extend_u_i32
-  | 0xae -> i64_trunc_s_f32
-  | 0xaf -> i64_trunc_u_f32
-  | 0xb0 -> i64_trunc_s_f64
-  | 0xb1 -> i64_trunc_u_f64
-  | 0xb2 -> f32_convert_s_i32
-  | 0xb3 -> f32_convert_u_i32
-  | 0xb4 -> f32_convert_s_i64
-  | 0xb5 -> f32_convert_u_i64
+  | 0xa8 -> i32_trunc_f32_s
+  | 0xa9 -> i32_trunc_f32_u
+  | 0xaa -> i32_trunc_f64_s
+  | 0xab -> i32_trunc_f64_u
+  | 0xac -> i64_extend_i32_s
+  | 0xad -> i64_extend_i32_u
+  | 0xae -> i64_trunc_f32_s
+  | 0xaf -> i64_trunc_f32_u
+  | 0xb0 -> i64_trunc_f64_s
+  | 0xb1 -> i64_trunc_f64_u
+  | 0xb2 -> f32_convert_i32_s
+  | 0xb3 -> f32_convert_i32_u
+  | 0xb4 -> f32_convert_i64_s
+  | 0xb5 -> f32_convert_i64_u
   | 0xb6 -> f32_demote_f64
-  | 0xb7 -> f64_convert_s_i32
-  | 0xb8 -> f64_convert_u_i32
-  | 0xb9 -> f64_convert_s_i64
-  | 0xba -> f64_convert_u_i64
+  | 0xb7 -> f64_convert_i32_s
+  | 0xb8 -> f64_convert_i32_u
+  | 0xb9 -> f64_convert_i64_s
+  | 0xba -> f64_convert_i64_u
   | 0xbb -> f64_promote_f32
 
   | 0xbc -> i32_reinterpret_f32
@@ -579,7 +579,7 @@ let local s =
 let code _ s =
   let pos = pos s in
   let nts = vec local s in
-  let ns = List.map (fun (n, _) -> I64_convert.extend_u_i32 n) nts in
+  let ns = List.map (fun (n, _) -> I64_convert.extend_i32_u n) nts in
   require (I64.lt_u (List.fold_left I64.add 0L ns) 0x1_0000_0000L)
     s pos "too many locals";
   let locals = List.flatten (List.map (Lib.Fun.uncurry Lib.List32.make) nts) in
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 696dac418..e6f327567 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -97,7 +97,7 @@ let encode m =
       | F64Type -> vs7 (-0x04)
 
     let elem_type = function
-      | AnyFuncType -> vs7 (-0x10)
+      | FuncRefType -> vs7 (-0x10)
 
     let stack_type = function
       | [] -> vs7 (-0x40)
@@ -161,11 +161,11 @@ let encode m =
       | Drop -> op 0x1a
       | Select -> op 0x1b
 
-      | GetLocal x -> op 0x20; var x
-      | SetLocal x -> op 0x21; var x
-      | TeeLocal x -> op 0x22; var x
-      | GetGlobal x -> op 0x23; var x
-      | SetGlobal x -> op 0x24; var x
+      | LocalGet x -> op 0x20; var x
+      | LocalSet x -> op 0x21; var x
+      | LocalTee x -> op 0x22; var x
+      | GlobalGet x -> op 0x23; var x
+      | GlobalSet x -> op 0x24; var x
 
       | Load ({ty = I32Type; sz = None; _} as mo) -> op 0x28; memop mo
       | Load ({ty = I64Type; sz = None; _} as mo) -> op 0x29; memop mo
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index ca82b7345..ab58bd0d6 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -173,28 +173,28 @@ let rec step (c : config) : config =
       | Select, I32 i :: v2 :: v1 :: vs' ->
         v1 :: vs', []
 
-      | GetLocal x, vs ->
+      | LocalGet x, vs ->
         !(local frame x) :: vs, []
 
-      | SetLocal x, v :: vs' ->
+      | LocalSet x, v :: vs' ->
         local frame x := v;
         vs', []
 
-      | TeeLocal x, v :: vs' ->
+      | LocalTee x, v :: vs' ->
         local frame x := v;
         v :: vs', []
 
-      | GetGlobal x, vs ->
+      | GlobalGet x, vs ->
         Global.load (global frame.inst x) :: vs, []
 
-      | SetGlobal x, v :: vs' ->
+      | GlobalSet x, v :: vs' ->
         (try Global.store (global frame.inst x) v; vs', []
         with Global.NotMutable -> Crash.error e.at "write to immutable global"
            | Global.Type -> Crash.error e.at "type mismatch at global write")
 
       | Load {offset; ty; sz; _}, I32 i :: vs' ->
         let mem = memory frame.inst (0l @@ e.at) in
-        let addr = I64_convert.extend_u_i32 i in
+        let addr = I64_convert.extend_i32_u i in
         (try
           let v =
             match sz with
@@ -205,7 +205,7 @@ let rec step (c : config) : config =
 
       | Store {offset; sz; _}, v :: I32 i :: vs' ->
         let mem = memory frame.inst (0l @@ e.at) in
-        let addr = I64_convert.extend_u_i32 i in
+        let addr = I64_convert.extend_i32_u i in
         (try
           (match sz with
           | None -> Memory.store_value mem addr offset v
@@ -402,7 +402,7 @@ let init_memory (inst : module_inst) (seg : memory_segment) =
   let {index; offset = const; init} = seg.it in
   let mem = memory inst index in
   let offset' = i32 (eval_const inst const) const.at in
-  let offset = I64_convert.extend_u_i32 offset' in
+  let offset = I64_convert.extend_i32_u offset' in
   let end_ = Int64.(add offset (of_int (String.length init))) in
   let bound = Memory.bound mem in
   if I64.lt_u bound end_ || I64.lt_u end_ offset then
diff --git a/interpreter/exec/eval_numeric.ml b/interpreter/exec/eval_numeric.ml
index dd4025587..ea54cf991 100644
--- a/interpreter/exec/eval_numeric.ml
+++ b/interpreter/exec/eval_numeric.ml
@@ -126,10 +126,10 @@ struct
   let cvtop op v =
     match op with
     | WrapI64 -> I32 (I32_convert.wrap_i64 (I64Op.of_value 1 v))
-    | TruncSF32 -> I32 (I32_convert.trunc_s_f32 (F32Op.of_value 1 v))
-    | TruncUF32 -> I32 (I32_convert.trunc_u_f32 (F32Op.of_value 1 v))
-    | TruncSF64 -> I32 (I32_convert.trunc_s_f64 (F64Op.of_value 1 v))
-    | TruncUF64 -> I32 (I32_convert.trunc_u_f64 (F64Op.of_value 1 v))
+    | TruncSF32 -> I32 (I32_convert.trunc_f32_s (F32Op.of_value 1 v))
+    | TruncUF32 -> I32 (I32_convert.trunc_f32_u (F32Op.of_value 1 v))
+    | TruncSF64 -> I32 (I32_convert.trunc_f64_s (F64Op.of_value 1 v))
+    | TruncUF64 -> I32 (I32_convert.trunc_f64_u (F64Op.of_value 1 v))
     | ReinterpretFloat -> I32 (I32_convert.reinterpret_f32 (F32Op.of_value 1 v))
     | ExtendSI32 -> raise (TypeError (1, v, I32Type))
     | ExtendUI32 -> raise (TypeError (1, v, I32Type))
@@ -141,12 +141,12 @@ struct
 
   let cvtop op v =
     match op with
-    | ExtendSI32 -> I64 (I64_convert.extend_s_i32 (I32Op.of_value 1 v))
-    | ExtendUI32 -> I64 (I64_convert.extend_u_i32 (I32Op.of_value 1 v))
-    | TruncSF32 -> I64 (I64_convert.trunc_s_f32 (F32Op.of_value 1 v))
-    | TruncUF32 -> I64 (I64_convert.trunc_u_f32 (F32Op.of_value 1 v))
-    | TruncSF64 -> I64 (I64_convert.trunc_s_f64 (F64Op.of_value 1 v))
-    | TruncUF64 -> I64 (I64_convert.trunc_u_f64 (F64Op.of_value 1 v))
+    | ExtendSI32 -> I64 (I64_convert.extend_i32_s (I32Op.of_value 1 v))
+    | ExtendUI32 -> I64 (I64_convert.extend_i32_u (I32Op.of_value 1 v))
+    | TruncSF32 -> I64 (I64_convert.trunc_f32_s (F32Op.of_value 1 v))
+    | TruncUF32 -> I64 (I64_convert.trunc_f32_u (F32Op.of_value 1 v))
+    | TruncSF64 -> I64 (I64_convert.trunc_f64_s (F64Op.of_value 1 v))
+    | TruncUF64 -> I64 (I64_convert.trunc_f64_u (F64Op.of_value 1 v))
     | ReinterpretFloat -> I64 (I64_convert.reinterpret_f64 (F64Op.of_value 1 v))
     | WrapI64 -> raise (TypeError (1, v, I64Type))
 end
@@ -158,10 +158,10 @@ struct
   let cvtop op v =
     match op with
     | DemoteF64 -> F32 (F32_convert.demote_f64 (F64Op.of_value 1 v))
-    | ConvertSI32 -> F32 (F32_convert.convert_s_i32 (I32Op.of_value 1 v))
-    | ConvertUI32 -> F32 (F32_convert.convert_u_i32 (I32Op.of_value 1 v))
-    | ConvertSI64 -> F32 (F32_convert.convert_s_i64 (I64Op.of_value 1 v))
-    | ConvertUI64 -> F32 (F32_convert.convert_u_i64 (I64Op.of_value 1 v))
+    | ConvertSI32 -> F32 (F32_convert.convert_i32_s (I32Op.of_value 1 v))
+    | ConvertUI32 -> F32 (F32_convert.convert_i32_u (I32Op.of_value 1 v))
+    | ConvertSI64 -> F32 (F32_convert.convert_i64_s (I64Op.of_value 1 v))
+    | ConvertUI64 -> F32 (F32_convert.convert_i64_u (I64Op.of_value 1 v))
     | ReinterpretInt -> F32 (F32_convert.reinterpret_i32 (I32Op.of_value 1 v))
     | PromoteF32 -> raise (TypeError (1, v, F32Type))
 end
@@ -173,10 +173,10 @@ struct
   let cvtop op v =
     match op with
     | PromoteF32 -> F64 (F64_convert.promote_f32 (F32Op.of_value 1 v))
-    | ConvertSI32 -> F64 (F64_convert.convert_s_i32 (I32Op.of_value 1 v))
-    | ConvertUI32 -> F64 (F64_convert.convert_u_i32 (I32Op.of_value 1 v))
-    | ConvertSI64 -> F64 (F64_convert.convert_s_i64 (I64Op.of_value 1 v))
-    | ConvertUI64 -> F64 (F64_convert.convert_u_i64 (I64Op.of_value 1 v))
+    | ConvertSI32 -> F64 (F64_convert.convert_i32_s (I32Op.of_value 1 v))
+    | ConvertUI32 -> F64 (F64_convert.convert_i32_u (I32Op.of_value 1 v))
+    | ConvertSI64 -> F64 (F64_convert.convert_i64_s (I64Op.of_value 1 v))
+    | ConvertUI64 -> F64 (F64_convert.convert_i64_u (I64Op.of_value 1 v))
     | ReinterpretInt -> F64 (F64_convert.reinterpret_i64 (I64Op.of_value 1 v))
     | DemoteF64 -> raise (TypeError (1, v, F64Type))
 end
diff --git a/interpreter/exec/f32_convert.ml b/interpreter/exec/f32_convert.ml
index 78730010a..19ab155b5 100644
--- a/interpreter/exec/f32_convert.ml
+++ b/interpreter/exec/f32_convert.ml
@@ -10,20 +10,20 @@ let demote_f64 x =
   let nan32bits = Int32.logor 0x7fc00000l (I32_convert.wrap_i64 fields) in
   F32.of_bits nan32bits
 
-let convert_s_i32 x =
+let convert_i32_s x =
   F32.of_float (Int32.to_float x)
 
 (*
- * Similar to convert_u_i64 below, the high half of the i32 range are beyond
+ * Similar to convert_i64_u below, the high half of the i32 range are beyond
  * the range where f32 can represent odd numbers, though we do need to adjust
  * the least significant bit to round correctly.
  *)
-let convert_u_i32 x =
+let convert_i32_u x =
   F32.of_float
     Int32.(if x >= zero then to_float x else
            to_float (logor (shift_right_logical x 1) (logand x 1l)) *. 2.0)
 
-let convert_s_i64 x =
+let convert_i64_s x =
   F32.of_float (Int64.to_float x)
 
 (*
@@ -32,7 +32,7 @@ let convert_s_i64 x =
  * numbers, so we can shift the value right, do a conversion, and then scale it
  * back up, without worrying about losing the least-significant digit.
  *)
-let convert_u_i64 x =
+let convert_i64_u x =
   F32.of_float (if x >= Int64.zero then
     Int64.to_float x
   else
diff --git a/interpreter/exec/f32_convert.mli b/interpreter/exec/f32_convert.mli
index bcff3589b..1b1b579d9 100644
--- a/interpreter/exec/f32_convert.mli
+++ b/interpreter/exec/f32_convert.mli
@@ -1,8 +1,8 @@
 (* WebAssembly-compatible type conversions to f32 implementation *)
 
 val demote_f64 : F64.t -> F32.t
-val convert_s_i32 : I32.t -> F32.t
-val convert_u_i32 : I32.t -> F32.t
-val convert_s_i64 : I64.t -> F32.t
-val convert_u_i64 : I64.t -> F32.t
+val convert_i32_s : I32.t -> F32.t
+val convert_i32_u : I32.t -> F32.t
+val convert_i64_s : I64.t -> F32.t
+val convert_i64_u : I64.t -> F32.t
 val reinterpret_i32 : I32.t -> F32.t
diff --git a/interpreter/exec/f64_convert.ml b/interpreter/exec/f64_convert.ml
index 1403d2f03..1b44b8045 100644
--- a/interpreter/exec/f64_convert.ml
+++ b/interpreter/exec/f64_convert.ml
@@ -3,14 +3,14 @@
 let promote_f32 x =
   let xf = F32.to_float x in
   if xf = xf then F64.of_float xf else
-  let nan32bits = I64_convert.extend_u_i32 (F32.to_bits x) in
+  let nan32bits = I64_convert.extend_i32_u (F32.to_bits x) in
   let sign_field = Int64.(shift_left (shift_right_logical nan32bits 31) 63) in
   let significand_field = Int64.(shift_right_logical (shift_left nan32bits 41) 12) in
   let fields = Int64.logor sign_field significand_field in
   let nan64bits = Int64.logor 0x7ff8000000000000L fields in
   F64.of_bits nan64bits
 
-let convert_s_i32 x =
+let convert_i32_s x =
   F64.of_float (Int32.to_float x)
 
 (*
@@ -18,10 +18,10 @@ let convert_s_i32 x =
  * within the range where f32 can represent odd numbers, so we can't do the
  * shift. Instead, we can use int64 signed arithmetic.
  *)
-let convert_u_i32 x =
+let convert_i32_u x =
   F64.of_float Int64.(to_float (logand (of_int32 x) 0x00000000ffffffffL))
 
-let convert_s_i64 x =
+let convert_i64_s x =
   F64.of_float (Int64.to_float x)
 
 (*
@@ -30,7 +30,7 @@ let convert_s_i64 x =
  * numbers, so we can shift the value right, adjust the least significant
  * bit to round correctly, do a conversion, and then scale it back up.
  *)
-let convert_u_i64 x =
+let convert_i64_u x =
   F64.of_float
     Int64.(if x >= zero then to_float x else
            to_float (logor (shift_right_logical x 1) (logand x 1L)) *. 2.0)
diff --git a/interpreter/exec/f64_convert.mli b/interpreter/exec/f64_convert.mli
index a1209a3e7..9ed693be1 100644
--- a/interpreter/exec/f64_convert.mli
+++ b/interpreter/exec/f64_convert.mli
@@ -1,8 +1,8 @@
 (* WebAssembly-compatible type conversions to f64 implementation *)
 
 val promote_f32 : F32.t -> F64.t
-val convert_s_i32 : I32.t -> F64.t
-val convert_u_i32 : I32.t -> F64.t
-val convert_s_i64 : I64.t -> F64.t
-val convert_u_i64 : I64.t -> F64.t
+val convert_i32_s : I32.t -> F64.t
+val convert_i32_u : I32.t -> F64.t
+val convert_i64_s : I64.t -> F64.t
+val convert_i64_u : I64.t -> F64.t
 val reinterpret_i64 : I64.t -> F64.t
diff --git a/interpreter/exec/i32_convert.ml b/interpreter/exec/i32_convert.ml
index e6de75cb3..ac4b0f89a 100644
--- a/interpreter/exec/i32_convert.ml
+++ b/interpreter/exec/i32_convert.ml
@@ -2,7 +2,7 @@
 
 let wrap_i64 x = Int64.to_int32 x
 
-let trunc_s_f32 x =
+let trunc_f32_s x =
   if F32.ne x x then
     raise Numeric_error.InvalidConversionToInteger
   else
@@ -12,7 +12,7 @@ let trunc_s_f32 x =
     else
       Int32.of_float xf
 
-let trunc_u_f32 x =
+let trunc_f32_u x =
   if F32.ne x x then
     raise Numeric_error.InvalidConversionToInteger
   else
@@ -22,7 +22,7 @@ let trunc_u_f32 x =
     else
       Int64.(to_int32 (of_float xf))
 
-let trunc_s_f64 x =
+let trunc_f64_s x =
   if F64.ne x x then
     raise Numeric_error.InvalidConversionToInteger
   else
@@ -32,7 +32,7 @@ let trunc_s_f64 x =
     else
       Int32.of_float xf
 
-let trunc_u_f64 x =
+let trunc_f64_u x =
   if F64.ne x x then
     raise Numeric_error.InvalidConversionToInteger
   else
diff --git a/interpreter/exec/i32_convert.mli b/interpreter/exec/i32_convert.mli
index 2737aadd2..20e4eb40d 100644
--- a/interpreter/exec/i32_convert.mli
+++ b/interpreter/exec/i32_convert.mli
@@ -1,8 +1,8 @@
 (* WebAssembly-compatible type conversions to i32 implementation *)
 
 val wrap_i64 : I64.t -> I32.t
-val trunc_s_f32 : F32.t -> I32.t
-val trunc_u_f32 : F32.t -> I32.t
-val trunc_s_f64 : F64.t -> I32.t
-val trunc_u_f64 : F64.t -> I32.t
+val trunc_f32_s : F32.t -> I32.t
+val trunc_f32_u : F32.t -> I32.t
+val trunc_f64_s : F64.t -> I32.t
+val trunc_f64_u : F64.t -> I32.t
 val reinterpret_f32 : F32.t -> I32.t
diff --git a/interpreter/exec/i64_convert.ml b/interpreter/exec/i64_convert.ml
index 7ea8ee6e1..e5ebf1e41 100644
--- a/interpreter/exec/i64_convert.ml
+++ b/interpreter/exec/i64_convert.ml
@@ -1,10 +1,10 @@
 (* WebAssembly-compatible type conversions to i64 implementation *)
 
-let extend_s_i32 x = Int64.of_int32 x
+let extend_i32_s x = Int64.of_int32 x
 
-let extend_u_i32 x = Int64.logand (Int64.of_int32 x) 0x00000000ffffffffL
+let extend_i32_u x = Int64.logand (Int64.of_int32 x) 0x00000000ffffffffL
 
-let trunc_s_f32 x =
+let trunc_f32_s x =
   if F32.ne x x then
     raise Numeric_error.InvalidConversionToInteger
   else
@@ -14,7 +14,7 @@ let trunc_s_f32 x =
     else
       Int64.of_float xf
 
-let trunc_u_f32 x =
+let trunc_f32_u x =
   if F32.ne x x then
     raise Numeric_error.InvalidConversionToInteger
   else
@@ -26,7 +26,7 @@ let trunc_u_f32 x =
     else
       Int64.of_float xf
 
-let trunc_s_f64 x =
+let trunc_f64_s x =
   if F64.ne x x then
     raise Numeric_error.InvalidConversionToInteger
   else
@@ -36,7 +36,7 @@ let trunc_s_f64 x =
     else
       Int64.of_float xf
 
-let trunc_u_f64 x =
+let trunc_f64_u x =
   if F64.ne x x then
     raise Numeric_error.InvalidConversionToInteger
   else
diff --git a/interpreter/exec/i64_convert.mli b/interpreter/exec/i64_convert.mli
index 50a3b3a3e..02a0ce450 100644
--- a/interpreter/exec/i64_convert.mli
+++ b/interpreter/exec/i64_convert.mli
@@ -1,9 +1,9 @@
 (* WebAssembly-compatible type conversions to i64 implementation *)
 
-val extend_s_i32 : I32.t -> I64.t
-val extend_u_i32 : I32.t -> I64.t
-val trunc_s_f32 : F32.t -> I64.t
-val trunc_u_f32 : F32.t -> I64.t
-val trunc_s_f64 : F64.t -> I64.t
-val trunc_u_f64 : F64.t -> I64.t
+val extend_i32_s : I32.t -> I64.t
+val extend_i32_u : I32.t -> I64.t
+val trunc_f32_s : F32.t -> I64.t
+val trunc_f32_u : F32.t -> I64.t
+val trunc_f64_s : F64.t -> I64.t
+val trunc_f64_u : F64.t -> I64.t
 val reinterpret_f64 : F64.t -> I64.t
diff --git a/interpreter/host/spectest.ml b/interpreter/host/spectest.ml
index ae543f91e..78f3e994a 100644
--- a/interpreter/host/spectest.ml
+++ b/interpreter/host/spectest.ml
@@ -16,7 +16,7 @@ let global (GlobalType (t, _) as gt) =
     | F64Type -> F64 (F64.of_float 666.6)
   in Global.alloc gt v
 
-let table = Table.alloc (TableType ({min = 10l; max = Some 20l}, AnyFuncType))
+let table = Table.alloc (TableType ({min = 10l; max = Some 20l}, FuncRefType))
 let memory = Memory.alloc (MemoryType {min = 1l; max = Some 2l})
 let func f t = Func.alloc_host t (f t)
 
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 088751e47..6dfb391c9 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -215,7 +215,7 @@ let invoke ft lits at =
   List.map (fun lit -> Const lit @@ at) lits @ [Call (0l @@ at) @@ at]
 
 let get t at =
-  [], GlobalImport t @@ at, [GetGlobal (0l @@ at) @@ at]
+  [], GlobalImport t @@ at, [GlobalGet (0l @@ at) @@ at]
 
 let run ts at =
   [], []
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index 51b2f9213..089023fc1 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -82,11 +82,11 @@ and instr' =
   | Return                            (* break from function body *)
   | Call of var                       (* call function *)
   | CallIndirect of var               (* call function through table *)
-  | GetLocal of var                   (* read local variable *)
-  | SetLocal of var                   (* write local variable *)
-  | TeeLocal of var                   (* write local variable and keep value *)
-  | GetGlobal of var                  (* read global variable *)
-  | SetGlobal of var                  (* write global variable *)
+  | LocalGet of var                   (* read local variable *)
+  | LocalSet of var                   (* write local variable *)
+  | LocalTee of var                   (* write local variable and keep value *)
+  | GlobalGet of var                  (* read global variable *)
+  | GlobalSet of var                  (* write global variable *)
   | Load of loadop                    (* read memory at address *)
   | Store of storeop                  (* write memory at address *)
   | MemorySize                        (* size of linear memory *)
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index 2b84fcea0..ff7588fa0 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -25,11 +25,11 @@ let return = Return
 let call x = Call x
 let call_indirect x = CallIndirect x
 
-let get_local x = GetLocal x
-let set_local x = SetLocal x
-let tee_local x = TeeLocal x
-let get_global x = GetGlobal x
-let set_global x = SetGlobal x
+let local_get x = LocalGet x
+let local_set x = LocalSet x
+let local_tee x = LocalTee x
+let global_get x = GlobalGet x
+let global_set x = GlobalSet x
 
 let i32_load align offset = Load {ty = I32Type; align; offset; sz = None}
 let i64_load align offset = Load {ty = I64Type; align; offset; sz = None}
@@ -174,25 +174,25 @@ let f64_gt = Compare (F64 F64Op.Gt)
 let f64_ge = Compare (F64 F64Op.Ge)
 
 let i32_wrap_i64 = Convert (I32 I32Op.WrapI64)
-let i32_trunc_s_f32 = Convert (I32 I32Op.TruncSF32)
-let i32_trunc_u_f32 = Convert (I32 I32Op.TruncUF32)
-let i32_trunc_s_f64 = Convert (I32 I32Op.TruncSF64)
-let i32_trunc_u_f64 = Convert (I32 I32Op.TruncUF64)
-let i64_extend_s_i32 = Convert (I64 I64Op.ExtendSI32)
-let i64_extend_u_i32 = Convert (I64 I64Op.ExtendUI32)
-let i64_trunc_s_f32 = Convert (I64 I64Op.TruncSF32)
-let i64_trunc_u_f32 = Convert (I64 I64Op.TruncUF32)
-let i64_trunc_s_f64 = Convert (I64 I64Op.TruncSF64)
-let i64_trunc_u_f64 = Convert (I64 I64Op.TruncUF64)
-let f32_convert_s_i32 = Convert (F32 F32Op.ConvertSI32)
-let f32_convert_u_i32 = Convert (F32 F32Op.ConvertUI32)
-let f32_convert_s_i64 = Convert (F32 F32Op.ConvertSI64)
-let f32_convert_u_i64 = Convert (F32 F32Op.ConvertUI64)
+let i32_trunc_f32_s = Convert (I32 I32Op.TruncSF32)
+let i32_trunc_f32_u = Convert (I32 I32Op.TruncUF32)
+let i32_trunc_f64_s = Convert (I32 I32Op.TruncSF64)
+let i32_trunc_f64_u = Convert (I32 I32Op.TruncUF64)
+let i64_extend_i32_s = Convert (I64 I64Op.ExtendSI32)
+let i64_extend_i32_u = Convert (I64 I64Op.ExtendUI32)
+let i64_trunc_f32_s = Convert (I64 I64Op.TruncSF32)
+let i64_trunc_f32_u = Convert (I64 I64Op.TruncUF32)
+let i64_trunc_f64_s = Convert (I64 I64Op.TruncSF64)
+let i64_trunc_f64_u = Convert (I64 I64Op.TruncUF64)
+let f32_convert_i32_s = Convert (F32 F32Op.ConvertSI32)
+let f32_convert_i32_u = Convert (F32 F32Op.ConvertUI32)
+let f32_convert_i64_s = Convert (F32 F32Op.ConvertSI64)
+let f32_convert_i64_u = Convert (F32 F32Op.ConvertUI64)
 let f32_demote_f64 = Convert (F32 F32Op.DemoteF64)
-let f64_convert_s_i32 = Convert (F64 F64Op.ConvertSI32)
-let f64_convert_u_i32 = Convert (F64 F64Op.ConvertUI32)
-let f64_convert_s_i64 = Convert (F64 F64Op.ConvertSI64)
-let f64_convert_u_i64 = Convert (F64 F64Op.ConvertUI64)
+let f64_convert_i32_s = Convert (F64 F64Op.ConvertSI32)
+let f64_convert_i32_u = Convert (F64 F64Op.ConvertUI32)
+let f64_convert_i64_s = Convert (F64 F64Op.ConvertSI64)
+let f64_convert_i64_u = Convert (F64 F64Op.ConvertUI64)
 let f64_promote_f32 = Convert (F64 F64Op.PromoteF32)
 let i32_reinterpret_f32 = Convert (I32 I32Op.ReinterpretFloat)
 let i64_reinterpret_f64 = Convert (I64 I64Op.ReinterpretFloat)
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index f708e4b89..00b76f6c1 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -1,7 +1,7 @@
 (* Types *)
 
 type value_type = I32Type | I64Type | F32Type | F64Type
-type elem_type = AnyFuncType
+type elem_type = FuncRefType
 type stack_type = value_type list
 type func_type = FuncType of stack_type * stack_type
 
@@ -79,7 +79,7 @@ let string_of_value_types = function
   | ts -> "[" ^ String.concat " " (List.map string_of_value_type ts) ^ "]"
 
 let string_of_elem_type = function
-  | AnyFuncType -> "anyfunc"
+  | FuncRefType -> "funcref"
 
 let string_of_limits {min; max} =
   I32.to_string_u min ^
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index 76f279aba..8dd154d61 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -120,14 +120,14 @@ struct
     | Rotr -> "rotr"
 
   let cvtop xx = function
-    | ExtendSI32 -> "extend_s/i32"
-    | ExtendUI32 -> "extend_u/i32"
-    | WrapI64 -> "wrap/i64"
-    | TruncSF32 -> "trunc_s/f32"
-    | TruncUF32 -> "trunc_u/f32"
-    | TruncSF64 -> "trunc_s/f64"
-    | TruncUF64 -> "trunc_u/f64"
-    | ReinterpretFloat -> "reinterpret/f" ^ xx
+    | ExtendSI32 -> "extend_i32_s"
+    | ExtendUI32 -> "extend_i32_u"
+    | WrapI64 -> "wrap_i64"
+    | TruncSF32 -> "trunc_f32_s"
+    | TruncUF32 -> "trunc_f32_u"
+    | TruncSF64 -> "trunc_f64_s"
+    | TruncUF64 -> "trunc_f64_u"
+    | ReinterpretFloat -> "reinterpret_f" ^ xx
 end
 
 module FloatOp =
@@ -163,13 +163,13 @@ struct
     | CopySign -> "copysign"
 
   let cvtop xx = function
-    | ConvertSI32 -> "convert_s/i32"
-    | ConvertUI32 -> "convert_u/i32"
-    | ConvertSI64 -> "convert_s/i64"
-    | ConvertUI64 -> "convert_u/i64"
-    | PromoteF32 -> "promote/f32"
-    | DemoteF64 -> "demote/f64"
-    | ReinterpretInt -> "reinterpret/i" ^ xx
+    | ConvertSI32 -> "convert_i32_s"
+    | ConvertUI32 -> "convert_i32_u"
+    | ConvertSI64 -> "convert_i64_s"
+    | ConvertUI64 -> "convert_i64_u"
+    | PromoteF32 -> "promote_f32"
+    | DemoteF64 -> "demote_f64"
+    | ReinterpretInt -> "reinterpret_i" ^ xx
 end
 
 let oper (intop, floatop) op =
@@ -237,11 +237,11 @@ let rec instr e =
     | Return -> "return", []
     | Call x -> "call " ^ var x, []
     | CallIndirect x -> "call_indirect", [Node ("type " ^ var x, [])]
-    | GetLocal x -> "get_local " ^ var x, []
-    | SetLocal x -> "set_local " ^ var x, []
-    | TeeLocal x -> "tee_local " ^ var x, []
-    | GetGlobal x -> "get_global " ^ var x, []
-    | SetGlobal x -> "set_global " ^ var x, []
+    | LocalGet x -> "local.get " ^ var x, []
+    | LocalSet x -> "local.set " ^ var x, []
+    | LocalTee x -> "local.tee " ^ var x, []
+    | GlobalGet x -> "global.get " ^ var x, []
+    | GlobalSet x -> "global.set " ^ var x, []
     | Load op -> loadop op, []
     | Store op -> storeop op, []
     | MemorySize -> "memory.size", []
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index 3b67da7ce..dab48e045 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -173,7 +173,7 @@ rule token = parse
         (fun s -> let n = F64.of_string s.it in
           f64_const (n @@ s.at), Values.F64 n))
     }
-  | "anyfunc" { ANYFUNC }
+  | "funcref" { FUNCREF }
   | "mut" { MUT }
 
   | "nop" { NOP }
@@ -193,11 +193,11 @@ rule token = parse
   | "call" { CALL }
   | "call_indirect" { CALL_INDIRECT }
 
-  | "get_local" { GET_LOCAL }
-  | "set_local" { SET_LOCAL }
-  | "tee_local" { TEE_LOCAL }
-  | "get_global" { GET_GLOBAL }
-  | "set_global" { SET_GLOBAL }
+  | "local.get" { LOCAL_GET }
+  | "local.set" { LOCAL_SET }
+  | "local.tee" { LOCAL_TEE }
+  | "global.get" { GLOBAL_GET }
+  | "global.set" { GLOBAL_SET }
 
   | (nxx as t)".load"
     { LOAD (fun a o ->
@@ -288,31 +288,31 @@ rule token = parse
   | (fxx as t)".gt" { COMPARE (floatop t f32_gt f64_gt) }
   | (fxx as t)".ge" { COMPARE (floatop t f32_ge f64_ge) }
 
-  | "i32.wrap/i64" { CONVERT i32_wrap_i64 }
-  | "i64.extend_s/i32" { CONVERT i64_extend_s_i32 }
-  | "i64.extend_u/i32" { CONVERT i64_extend_u_i32 }
-  | "f32.demote/f64" { CONVERT f32_demote_f64 }
-  | "f64.promote/f32" { CONVERT f64_promote_f32 }
-  | (ixx as t)".trunc_s/f32"
-    { CONVERT (intop t i32_trunc_s_f32 i64_trunc_s_f32) }
-  | (ixx as t)".trunc_u/f32"
-    { CONVERT (intop t i32_trunc_u_f32 i64_trunc_u_f32) }
-  | (ixx as t)".trunc_s/f64"
-    { CONVERT (intop t i32_trunc_s_f64 i64_trunc_s_f64) }
-  | (ixx as t)".trunc_u/f64"
-    { CONVERT (intop t i32_trunc_u_f64 i64_trunc_u_f64) }
-  | (fxx as t)".convert_s/i32"
-    { CONVERT (floatop t f32_convert_s_i32 f64_convert_s_i32) }
-  | (fxx as t)".convert_u/i32"
-    { CONVERT (floatop t f32_convert_u_i32 f64_convert_u_i32) }
-  | (fxx as t)".convert_s/i64"
-    { CONVERT (floatop t f32_convert_s_i64 f64_convert_s_i64) }
-  | (fxx as t)".convert_u/i64"
-    { CONVERT (floatop t f32_convert_u_i64 f64_convert_u_i64) }
-  | "f32.reinterpret/i32" { CONVERT f32_reinterpret_i32 }
-  | "f64.reinterpret/i64" { CONVERT f64_reinterpret_i64 }
-  | "i32.reinterpret/f32" { CONVERT i32_reinterpret_f32 }
-  | "i64.reinterpret/f64" { CONVERT i64_reinterpret_f64 }
+  | "i32.wrap_i64" { CONVERT i32_wrap_i64 }
+  | "i64.extend_i32_s" { CONVERT i64_extend_i32_s }
+  | "i64.extend_i32_u" { CONVERT i64_extend_i32_u }
+  | "f32.demote_f64" { CONVERT f32_demote_f64 }
+  | "f64.promote_f32" { CONVERT f64_promote_f32 }
+  | (ixx as t)".trunc_f32_s"
+    { CONVERT (intop t i32_trunc_f32_s i64_trunc_f32_s) }
+  | (ixx as t)".trunc_f32_u"
+    { CONVERT (intop t i32_trunc_f32_u i64_trunc_f32_u) }
+  | (ixx as t)".trunc_f64_s"
+    { CONVERT (intop t i32_trunc_f64_s i64_trunc_f64_s) }
+  | (ixx as t)".trunc_f64_u"
+    { CONVERT (intop t i32_trunc_f64_u i64_trunc_f64_u) }
+  | (fxx as t)".convert_i32_s"
+    { CONVERT (floatop t f32_convert_i32_s f64_convert_i32_s) }
+  | (fxx as t)".convert_i32_u"
+    { CONVERT (floatop t f32_convert_i32_u f64_convert_i32_u) }
+  | (fxx as t)".convert_i64_s"
+    { CONVERT (floatop t f32_convert_i64_s f64_convert_i64_s) }
+  | (fxx as t)".convert_i64_u"
+    { CONVERT (floatop t f32_convert_i64_u f64_convert_i64_u) }
+  | "f32.reinterpret_i32" { CONVERT f32_reinterpret_i32 }
+  | "f64.reinterpret_i64" { CONVERT f64_reinterpret_i64 }
+  | "i32.reinterpret_f32" { CONVERT i32_reinterpret_f32 }
+  | "i64.reinterpret_f64" { CONVERT i64_reinterpret_f64 }
 
   | "memory.size" { MEMORY_SIZE }
   | "memory.grow" { MEMORY_GROW }
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index c72b3cf3f..670afd6ba 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -145,10 +145,10 @@ let inline_type_explicit (c : context) x ft at =
 
 %}
 
-%token NAT INT FLOAT STRING VAR VALUE_TYPE ANYFUNC MUT LPAR RPAR
+%token NAT INT FLOAT STRING VAR VALUE_TYPE FUNCREF MUT LPAR RPAR
 %token NOP DROP BLOCK END IF THEN ELSE SELECT LOOP BR BR_IF BR_TABLE
 %token CALL CALL_INDIRECT RETURN
-%token GET_LOCAL SET_LOCAL TEE_LOCAL GET_GLOBAL SET_GLOBAL
+%token LOCAL_GET LOCAL_SET LOCAL_TEE GLOBAL_GET GLOBAL_SET
 %token LOAD STORE OFFSET_EQ_NAT ALIGN_EQ_NAT
 %token CONST UNARY BINARY TEST COMPARE CONVERT
 %token UNREACHABLE MEMORY_SIZE MEMORY_GROW
@@ -205,7 +205,7 @@ value_type_list :
   | VALUE_TYPE value_type_list { $1 :: $2 }
 
 elem_type :
-  | ANYFUNC { AnyFuncType }
+  | FUNCREF { FuncRefType }
 
 global_type :
   | VALUE_TYPE { GlobalType ($1, Immutable) }
@@ -310,11 +310,11 @@ plain_instr :
       br_table xs x }
   | RETURN { fun c -> return }
   | CALL var { fun c -> call ($2 c func) }
-  | GET_LOCAL var { fun c -> get_local ($2 c local) }
-  | SET_LOCAL var { fun c -> set_local ($2 c local) }
-  | TEE_LOCAL var { fun c -> tee_local ($2 c local) }
-  | GET_GLOBAL var { fun c -> get_global ($2 c global) }
-  | SET_GLOBAL var { fun c -> set_global ($2 c global) }
+  | LOCAL_GET var { fun c -> local_get ($2 c local) }
+  | LOCAL_SET var { fun c -> local_set ($2 c local) }
+  | LOCAL_TEE var { fun c -> local_tee ($2 c local) }
+  | GLOBAL_GET var { fun c -> global_get ($2 c global) }
+  | GLOBAL_SET var { fun c -> global_set ($2 c global) }
   | LOAD offset_opt align_opt { fun c -> $1 $3 $2 }
   | STORE offset_opt align_opt { fun c -> $1 $3 $2 }
   | MEMORY_SIZE { fun c -> memory_size }
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index e3612bccf..ea78d1784 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -230,20 +230,20 @@ let rec check_instr (c : context) (e : instr) (s : infer_stack_type) : op_type =
 
 
 
-  | GetLocal x ->
+  | LocalGet x ->
     [] --> [local c x]
 
-  | SetLocal x ->
+  | LocalSet x ->
     [local c x] --> []
 
-  | TeeLocal x ->
+  | LocalTee x ->
     [local c x] --> [local c x]
 
-  | GetGlobal x ->
+  | GlobalGet x ->
     let GlobalType (t, mut) = global c x in
     [] --> [t]
 
-  | SetGlobal x ->
+  | GlobalSet x ->
     let GlobalType (t, mut) = global c x in
     require (mut = Mutable) x.at "global is immutable";
     [t] --> []
@@ -368,7 +368,7 @@ let check_func (c : context) (f : func) =
 let is_const (c : context) (e : instr) =
   match e.it with
   | Const _ -> true
-  | GetGlobal x -> let GlobalType (_, mut) = global c x in mut = Immutable
+  | GlobalGet x -> let GlobalType (_, mut) = global c x in mut = Immutable
   | _ -> false
 
 let check_const (c : context) (const : const) (t : value_type) =
diff --git a/test/core/address.wast b/test/core/address.wast
index 134d2dab3..e071cca50 100644
--- a/test/core/address.wast
+++ b/test/core/address.wast
@@ -5,99 +5,99 @@
   (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz")
 
   (func (export "8u_good1") (param $i i32) (result i32)
-    (i32.load8_u offset=0 (get_local $i))                   ;; 97 'a'
+    (i32.load8_u offset=0 (local.get $i))                   ;; 97 'a'
   )
   (func (export "8u_good2") (param $i i32) (result i32)
-    (i32.load8_u align=1 (get_local $i))                    ;; 97 'a'
+    (i32.load8_u align=1 (local.get $i))                    ;; 97 'a'
   )
   (func (export "8u_good3") (param $i i32) (result i32)
-    (i32.load8_u offset=1 align=1 (get_local $i))           ;; 98 'b'
+    (i32.load8_u offset=1 align=1 (local.get $i))           ;; 98 'b'
   )
   (func (export "8u_good4") (param $i i32) (result i32)
-    (i32.load8_u offset=2 align=1 (get_local $i))           ;; 99 'c'
+    (i32.load8_u offset=2 align=1 (local.get $i))           ;; 99 'c'
   )
   (func (export "8u_good5") (param $i i32) (result i32)
-    (i32.load8_u offset=25 align=1 (get_local $i))          ;; 122 'z'
+    (i32.load8_u offset=25 align=1 (local.get $i))          ;; 122 'z'
   )
 
   (func (export "8s_good1") (param $i i32) (result i32)
-    (i32.load8_s offset=0 (get_local $i))                   ;; 97 'a'
+    (i32.load8_s offset=0 (local.get $i))                   ;; 97 'a'
   )
   (func (export "8s_good2") (param $i i32) (result i32)
-    (i32.load8_s align=1 (get_local $i))                    ;; 97 'a'
+    (i32.load8_s align=1 (local.get $i))                    ;; 97 'a'
   )
   (func (export "8s_good3") (param $i i32) (result i32)
-    (i32.load8_s offset=1 align=1 (get_local $i))           ;; 98 'b'
+    (i32.load8_s offset=1 align=1 (local.get $i))           ;; 98 'b'
   )
   (func (export "8s_good4") (param $i i32) (result i32)
-    (i32.load8_s offset=2 align=1 (get_local $i))           ;; 99 'c'
+    (i32.load8_s offset=2 align=1 (local.get $i))           ;; 99 'c'
   )
   (func (export "8s_good5") (param $i i32) (result i32)
-    (i32.load8_s offset=25 align=1 (get_local $i))          ;; 122 'z'
+    (i32.load8_s offset=25 align=1 (local.get $i))          ;; 122 'z'
   )
 
   (func (export "16u_good1") (param $i i32) (result i32)
-    (i32.load16_u offset=0 (get_local $i))                  ;; 25185 'ab'
+    (i32.load16_u offset=0 (local.get $i))                  ;; 25185 'ab'
   )
   (func (export "16u_good2") (param $i i32) (result i32)
-    (i32.load16_u align=1 (get_local $i))                   ;; 25185 'ab'
+    (i32.load16_u align=1 (local.get $i))                   ;; 25185 'ab'
   )
   (func (export "16u_good3") (param $i i32) (result i32)
-    (i32.load16_u offset=1 align=1 (get_local $i))          ;; 25442 'bc'
+    (i32.load16_u offset=1 align=1 (local.get $i))          ;; 25442 'bc'
   )
   (func (export "16u_good4") (param $i i32) (result i32)
-    (i32.load16_u offset=2 align=2 (get_local $i))          ;; 25699 'cd'
+    (i32.load16_u offset=2 align=2 (local.get $i))          ;; 25699 'cd'
   )
   (func (export "16u_good5") (param $i i32) (result i32)
-    (i32.load16_u offset=25 align=2 (get_local $i))         ;; 122 'z\0'
+    (i32.load16_u offset=25 align=2 (local.get $i))         ;; 122 'z\0'
   )
 
   (func (export "16s_good1") (param $i i32) (result i32)
-    (i32.load16_s offset=0 (get_local $i))                  ;; 25185 'ab'
+    (i32.load16_s offset=0 (local.get $i))                  ;; 25185 'ab'
   )
   (func (export "16s_good2") (param $i i32) (result i32)
-    (i32.load16_s align=1 (get_local $i))                   ;; 25185 'ab'
+    (i32.load16_s align=1 (local.get $i))                   ;; 25185 'ab'
   )
   (func (export "16s_good3") (param $i i32) (result i32)
-    (i32.load16_s offset=1 align=1 (get_local $i))          ;; 25442 'bc'
+    (i32.load16_s offset=1 align=1 (local.get $i))          ;; 25442 'bc'
   )
   (func (export "16s_good4") (param $i i32) (result i32)
-    (i32.load16_s offset=2 align=2 (get_local $i))          ;; 25699 'cd'
+    (i32.load16_s offset=2 align=2 (local.get $i))          ;; 25699 'cd'
   )
   (func (export "16s_good5") (param $i i32) (result i32)
-    (i32.load16_s offset=25 align=2 (get_local $i))         ;; 122 'z\0'
+    (i32.load16_s offset=25 align=2 (local.get $i))         ;; 122 'z\0'
   )
 
   (func (export "32_good1") (param $i i32) (result i32)
-    (i32.load offset=0 (get_local $i))                      ;; 1684234849 'abcd'
+    (i32.load offset=0 (local.get $i))                      ;; 1684234849 'abcd'
   )
   (func (export "32_good2") (param $i i32) (result i32)
-    (i32.load align=1 (get_local $i))                       ;; 1684234849 'abcd'
+    (i32.load align=1 (local.get $i))                       ;; 1684234849 'abcd'
   )
   (func (export "32_good3") (param $i i32) (result i32)
-    (i32.load offset=1 align=1 (get_local $i))              ;; 1701077858 'bcde'
+    (i32.load offset=1 align=1 (local.get $i))              ;; 1701077858 'bcde'
   )
   (func (export "32_good4") (param $i i32) (result i32)
-    (i32.load offset=2 align=2 (get_local $i))              ;; 1717920867 'cdef'
+    (i32.load offset=2 align=2 (local.get $i))              ;; 1717920867 'cdef'
   )
   (func (export "32_good5") (param $i i32) (result i32)
-    (i32.load offset=25 align=4 (get_local $i))             ;; 122 'z\0\0\0'
+    (i32.load offset=25 align=4 (local.get $i))             ;; 122 'z\0\0\0'
   )
 
   (func (export "8u_bad") (param $i i32)
-    (drop (i32.load8_u offset=4294967295 (get_local $i)))
+    (drop (i32.load8_u offset=4294967295 (local.get $i)))
   )
   (func (export "8s_bad") (param $i i32)
-    (drop (i32.load8_s offset=4294967295 (get_local $i)))
+    (drop (i32.load8_s offset=4294967295 (local.get $i)))
   )
   (func (export "16u_bad") (param $i i32)
-    (drop (i32.load16_u offset=4294967295 (get_local $i)))
+    (drop (i32.load16_u offset=4294967295 (local.get $i)))
   )
   (func (export "16s_bad") (param $i i32)
-    (drop (i32.load16_s offset=4294967295 (get_local $i)))
+    (drop (i32.load16_s offset=4294967295 (local.get $i)))
   )
   (func (export "32_bad") (param $i i32)
-    (drop (i32.load offset=4294967295 (get_local $i)))
+    (drop (i32.load offset=4294967295 (local.get $i)))
   )
 )
 
@@ -218,137 +218,137 @@
   (data (i32.const 0) "abcdefghijklmnopqrstuvwxyz")
 
   (func (export "8u_good1") (param $i i32) (result i64)
-    (i64.load8_u offset=0 (get_local $i))                   ;; 97 'a'
+    (i64.load8_u offset=0 (local.get $i))                   ;; 97 'a'
   )
   (func (export "8u_good2") (param $i i32) (result i64)
-    (i64.load8_u align=1 (get_local $i))                    ;; 97 'a'
+    (i64.load8_u align=1 (local.get $i))                    ;; 97 'a'
   )
   (func (export "8u_good3") (param $i i32) (result i64)
-    (i64.load8_u offset=1 align=1 (get_local $i))           ;; 98 'b'
+    (i64.load8_u offset=1 align=1 (local.get $i))           ;; 98 'b'
   )
   (func (export "8u_good4") (param $i i32) (result i64)
-    (i64.load8_u offset=2 align=1 (get_local $i))           ;; 99 'c'
+    (i64.load8_u offset=2 align=1 (local.get $i))           ;; 99 'c'
   )
   (func (export "8u_good5") (param $i i32) (result i64)
-    (i64.load8_u offset=25 align=1 (get_local $i))          ;; 122 'z'
+    (i64.load8_u offset=25 align=1 (local.get $i))          ;; 122 'z'
   )
 
   (func (export "8s_good1") (param $i i32) (result i64)
-    (i64.load8_s offset=0 (get_local $i))                   ;; 97 'a'
+    (i64.load8_s offset=0 (local.get $i))                   ;; 97 'a'
   )
   (func (export "8s_good2") (param $i i32) (result i64)
-    (i64.load8_s align=1 (get_local $i))                    ;; 97 'a'
+    (i64.load8_s align=1 (local.get $i))                    ;; 97 'a'
   )
   (func (export "8s_good3") (param $i i32) (result i64)
-    (i64.load8_s offset=1 align=1 (get_local $i))           ;; 98 'b'
+    (i64.load8_s offset=1 align=1 (local.get $i))           ;; 98 'b'
   )
   (func (export "8s_good4") (param $i i32) (result i64)
-    (i64.load8_s offset=2 align=1 (get_local $i))           ;; 99 'c'
+    (i64.load8_s offset=2 align=1 (local.get $i))           ;; 99 'c'
   )
   (func (export "8s_good5") (param $i i32) (result i64)
-    (i64.load8_s offset=25 align=1 (get_local $i))          ;; 122 'z'
+    (i64.load8_s offset=25 align=1 (local.get $i))          ;; 122 'z'
   )
 
   (func (export "16u_good1") (param $i i32) (result i64)
-    (i64.load16_u offset=0 (get_local $i))                 ;; 25185 'ab'
+    (i64.load16_u offset=0 (local.get $i))                 ;; 25185 'ab'
   )
   (func (export "16u_good2") (param $i i32) (result i64)
-    (i64.load16_u align=1 (get_local $i))                  ;; 25185 'ab'
+    (i64.load16_u align=1 (local.get $i))                  ;; 25185 'ab'
   )
   (func (export "16u_good3") (param $i i32) (result i64)
-    (i64.load16_u offset=1 align=1 (get_local $i))         ;; 25442 'bc'
+    (i64.load16_u offset=1 align=1 (local.get $i))         ;; 25442 'bc'
   )
   (func (export "16u_good4") (param $i i32) (result i64)
-    (i64.load16_u offset=2 align=2 (get_local $i))         ;; 25699 'cd'
+    (i64.load16_u offset=2 align=2 (local.get $i))         ;; 25699 'cd'
   )
   (func (export "16u_good5") (param $i i32) (result i64)
-    (i64.load16_u offset=25 align=2 (get_local $i))        ;; 122 'z\0'
+    (i64.load16_u offset=25 align=2 (local.get $i))        ;; 122 'z\0'
   )
 
   (func (export "16s_good1") (param $i i32) (result i64)
-    (i64.load16_s offset=0 (get_local $i))                 ;; 25185 'ab'
+    (i64.load16_s offset=0 (local.get $i))                 ;; 25185 'ab'
   )
   (func (export "16s_good2") (param $i i32) (result i64)
-    (i64.load16_s align=1 (get_local $i))                  ;; 25185 'ab'
+    (i64.load16_s align=1 (local.get $i))                  ;; 25185 'ab'
   )
   (func (export "16s_good3") (param $i i32) (result i64)
-    (i64.load16_s offset=1 align=1 (get_local $i))         ;; 25442 'bc'
+    (i64.load16_s offset=1 align=1 (local.get $i))         ;; 25442 'bc'
   )
   (func (export "16s_good4") (param $i i32) (result i64)
-    (i64.load16_s offset=2 align=2 (get_local $i))         ;; 25699 'cd'
+    (i64.load16_s offset=2 align=2 (local.get $i))         ;; 25699 'cd'
   )
   (func (export "16s_good5") (param $i i32) (result i64)
-    (i64.load16_s offset=25 align=2 (get_local $i))        ;; 122 'z\0'
+    (i64.load16_s offset=25 align=2 (local.get $i))        ;; 122 'z\0'
   )
 
   (func (export "32u_good1") (param $i i32) (result i64)
-    (i64.load32_u offset=0 (get_local $i))                 ;; 1684234849 'abcd'
+    (i64.load32_u offset=0 (local.get $i))                 ;; 1684234849 'abcd'
   )
   (func (export "32u_good2") (param $i i32) (result i64)
-    (i64.load32_u align=1 (get_local $i))                  ;; 1684234849 'abcd'
+    (i64.load32_u align=1 (local.get $i))                  ;; 1684234849 'abcd'
   )
   (func (export "32u_good3") (param $i i32) (result i64)
-    (i64.load32_u offset=1 align=1 (get_local $i))         ;; 1701077858 'bcde'
+    (i64.load32_u offset=1 align=1 (local.get $i))         ;; 1701077858 'bcde'
   )
   (func (export "32u_good4") (param $i i32) (result i64)
-    (i64.load32_u offset=2 align=2 (get_local $i))         ;; 1717920867 'cdef'
+    (i64.load32_u offset=2 align=2 (local.get $i))         ;; 1717920867 'cdef'
   )
   (func (export "32u_good5") (param $i i32) (result i64)
-    (i64.load32_u offset=25 align=4 (get_local $i))        ;; 122 'z\0\0\0'
+    (i64.load32_u offset=25 align=4 (local.get $i))        ;; 122 'z\0\0\0'
   )
 
   (func (export "32s_good1") (param $i i32) (result i64)
-    (i64.load32_s offset=0 (get_local $i))                 ;; 1684234849 'abcd'
+    (i64.load32_s offset=0 (local.get $i))                 ;; 1684234849 'abcd'
   )
   (func (export "32s_good2") (param $i i32) (result i64)
-    (i64.load32_s align=1 (get_local $i))                  ;; 1684234849 'abcd'
+    (i64.load32_s align=1 (local.get $i))                  ;; 1684234849 'abcd'
   )
   (func (export "32s_good3") (param $i i32) (result i64)
-    (i64.load32_s offset=1 align=1 (get_local $i))         ;; 1701077858 'bcde'
+    (i64.load32_s offset=1 align=1 (local.get $i))         ;; 1701077858 'bcde'
   )
   (func (export "32s_good4") (param $i i32) (result i64)
-    (i64.load32_s offset=2 align=2 (get_local $i))         ;; 1717920867 'cdef'
+    (i64.load32_s offset=2 align=2 (local.get $i))         ;; 1717920867 'cdef'
   )
   (func (export "32s_good5") (param $i i32) (result i64)
-    (i64.load32_s offset=25 align=4 (get_local $i))        ;; 122 'z\0\0\0'
+    (i64.load32_s offset=25 align=4 (local.get $i))        ;; 122 'z\0\0\0'
   )
 
   (func (export "64_good1") (param $i i32) (result i64)
-    (i64.load offset=0 (get_local $i))                     ;; 0x6867666564636261 'abcdefgh'
+    (i64.load offset=0 (local.get $i))                     ;; 0x6867666564636261 'abcdefgh'
   )
   (func (export "64_good2") (param $i i32) (result i64)
-    (i64.load align=1 (get_local $i))                      ;; 0x6867666564636261 'abcdefgh'
+    (i64.load align=1 (local.get $i))                      ;; 0x6867666564636261 'abcdefgh'
   )
   (func (export "64_good3") (param $i i32) (result i64)
-    (i64.load offset=1 align=1 (get_local $i))             ;; 0x6968676665646362 'bcdefghi'
+    (i64.load offset=1 align=1 (local.get $i))             ;; 0x6968676665646362 'bcdefghi'
   )
   (func (export "64_good4") (param $i i32) (result i64)
-    (i64.load offset=2 align=2 (get_local $i))             ;; 0x6a69686766656463 'cdefghij'
+    (i64.load offset=2 align=2 (local.get $i))             ;; 0x6a69686766656463 'cdefghij'
   )
   (func (export "64_good5") (param $i i32) (result i64)
-    (i64.load offset=25 align=8 (get_local $i))            ;; 122 'z\0\0\0\0\0\0\0'
+    (i64.load offset=25 align=8 (local.get $i))            ;; 122 'z\0\0\0\0\0\0\0'
   )
 
   (func (export "8u_bad") (param $i i32)
-    (drop (i64.load8_u offset=4294967295 (get_local $i)))
+    (drop (i64.load8_u offset=4294967295 (local.get $i)))
   )
   (func (export "8s_bad") (param $i i32)
-    (drop (i64.load8_s offset=4294967295 (get_local $i)))
+    (drop (i64.load8_s offset=4294967295 (local.get $i)))
   )
   (func (export "16u_bad") (param $i i32)
-    (drop (i64.load16_u offset=4294967295 (get_local $i)))
+    (drop (i64.load16_u offset=4294967295 (local.get $i)))
   )
   (func (export "16s_bad") (param $i i32)
-    (drop (i64.load16_s offset=4294967295 (get_local $i)))
+    (drop (i64.load16_s offset=4294967295 (local.get $i)))
   )
   (func (export "32u_bad") (param $i i32)
-    (drop (i64.load32_u offset=4294967295 (get_local $i)))
+    (drop (i64.load32_u offset=4294967295 (local.get $i)))
   )
   (func (export "32s_bad") (param $i i32)
-    (drop (i64.load32_s offset=4294967295 (get_local $i)))
+    (drop (i64.load32_s offset=4294967295 (local.get $i)))
   )
   (func (export "64_bad") (param $i i32)
-    (drop (i64.load offset=4294967295 (get_local $i)))
+    (drop (i64.load offset=4294967295 (local.get $i)))
   )
 )
 
@@ -501,22 +501,22 @@
   (data (i32.const 0) "\00\00\00\00\00\00\a0\7f\01\00\d0\7f")
 
   (func (export "32_good1") (param $i i32) (result f32)
-    (f32.load offset=0 (get_local $i))                   ;; 0.0 '\00\00\00\00'
+    (f32.load offset=0 (local.get $i))                   ;; 0.0 '\00\00\00\00'
   )
   (func (export "32_good2") (param $i i32) (result f32)
-    (f32.load align=1 (get_local $i))                    ;; 0.0 '\00\00\00\00'
+    (f32.load align=1 (local.get $i))                    ;; 0.0 '\00\00\00\00'
   )
   (func (export "32_good3") (param $i i32) (result f32)
-    (f32.load offset=1 align=1 (get_local $i))           ;; 0.0 '\00\00\00\00'
+    (f32.load offset=1 align=1 (local.get $i))           ;; 0.0 '\00\00\00\00'
   )
   (func (export "32_good4") (param $i i32) (result f32)
-    (f32.load offset=2 align=2 (get_local $i))           ;; 0.0 '\00\00\00\00'
+    (f32.load offset=2 align=2 (local.get $i))           ;; 0.0 '\00\00\00\00'
   )
   (func (export "32_good5") (param $i i32) (result f32)
-    (f32.load offset=8 align=4 (get_local $i))           ;; nan:0x500001 '\01\00\d0\7f'
+    (f32.load offset=8 align=4 (local.get $i))           ;; nan:0x500001 '\01\00\d0\7f'
   )
   (func (export "32_bad") (param $i i32)
-    (drop (f32.load offset=4294967295 (get_local $i)))
+    (drop (f32.load offset=4294967295 (local.get $i)))
   )
 )
 
@@ -548,22 +548,22 @@
   (data (i32.const 0) "\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\f4\7f\01\00\00\00\00\00\fc\7f")
 
   (func (export "64_good1") (param $i i32) (result f64)
-    (f64.load offset=0 (get_local $i))                     ;; 0.0 '\00\00\00\00\00\00\00\00'
+    (f64.load offset=0 (local.get $i))                     ;; 0.0 '\00\00\00\00\00\00\00\00'
   )
   (func (export "64_good2") (param $i i32) (result f64)
-    (f64.load align=1 (get_local $i))                      ;; 0.0 '\00\00\00\00\00\00\00\00'
+    (f64.load align=1 (local.get $i))                      ;; 0.0 '\00\00\00\00\00\00\00\00'
   )
   (func (export "64_good3") (param $i i32) (result f64)
-    (f64.load offset=1 align=1 (get_local $i))             ;; 0.0 '\00\00\00\00\00\00\00\00'
+    (f64.load offset=1 align=1 (local.get $i))             ;; 0.0 '\00\00\00\00\00\00\00\00'
   )
   (func (export "64_good4") (param $i i32) (result f64)
-    (f64.load offset=2 align=2 (get_local $i))             ;; 0.0 '\00\00\00\00\00\00\00\00'
+    (f64.load offset=2 align=2 (local.get $i))             ;; 0.0 '\00\00\00\00\00\00\00\00'
   )
   (func (export "64_good5") (param $i i32) (result f64)
-    (f64.load offset=18 align=8 (get_local $i))            ;; nan:0xc000000000001 '\01\00\00\00\00\00\fc\7f'
+    (f64.load offset=18 align=8 (local.get $i))            ;; nan:0xc000000000001 '\01\00\00\00\00\00\fc\7f'
   )
   (func (export "64_bad") (param $i i32)
-    (drop (f64.load offset=4294967295 (get_local $i)))
+    (drop (f64.load offset=4294967295 (local.get $i)))
   )
 )
 
diff --git a/test/core/align.wast b/test/core/align.wast
index 7f877c4ec..2e2896466 100644
--- a/test/core/align.wast
+++ b/test/core/align.wast
@@ -462,63 +462,63 @@
 
   (func (export "f32_align_switch") (param i32) (result f32)
     (local f32 f32)
-    (set_local 1 (f32.const 10.0))
+    (local.set 1 (f32.const 10.0))
     (block $4
       (block $2
         (block $1
           (block $default
             (block $0
-              (br_table $0 $default $1 $2 $4 (get_local 0))
+              (br_table $0 $default $1 $2 $4 (local.get 0))
             ) ;; 0
-            (f32.store (i32.const 0) (get_local 1))
-            (set_local 2 (f32.load (i32.const 0)))
+            (f32.store (i32.const 0) (local.get 1))
+            (local.set 2 (f32.load (i32.const 0)))
             (br $4)
           ) ;; default
-          (f32.store align=1 (i32.const 0) (get_local 1))
-          (set_local 2 (f32.load align=1 (i32.const 0)))
+          (f32.store align=1 (i32.const 0) (local.get 1))
+          (local.set 2 (f32.load align=1 (i32.const 0)))
           (br $4)
         ) ;; 1
-        (f32.store align=2 (i32.const 0) (get_local 1))
-        (set_local 2 (f32.load align=2 (i32.const 0)))
+        (f32.store align=2 (i32.const 0) (local.get 1))
+        (local.set 2 (f32.load align=2 (i32.const 0)))
         (br $4)
       ) ;; 2
-      (f32.store align=4 (i32.const 0) (get_local 1))
-      (set_local 2 (f32.load align=4 (i32.const 0)))
+      (f32.store align=4 (i32.const 0) (local.get 1))
+      (local.set 2 (f32.load align=4 (i32.const 0)))
     ) ;; 4
-    (get_local 2)
+    (local.get 2)
   )
 
   (func (export "f64_align_switch") (param i32) (result f64)
     (local f64 f64)
-    (set_local 1 (f64.const 10.0))
+    (local.set 1 (f64.const 10.0))
     (block $8
       (block $4
         (block $2
           (block $1
             (block $default
               (block $0
-                (br_table $0 $default $1 $2 $4 $8 (get_local 0))
+                (br_table $0 $default $1 $2 $4 $8 (local.get 0))
               ) ;; 0
-              (f64.store (i32.const 0) (get_local 1))
-              (set_local 2 (f64.load (i32.const 0)))
+              (f64.store (i32.const 0) (local.get 1))
+              (local.set 2 (f64.load (i32.const 0)))
               (br $8)
             ) ;; default
-            (f64.store align=1 (i32.const 0) (get_local 1))
-            (set_local 2 (f64.load align=1 (i32.const 0)))
+            (f64.store align=1 (i32.const 0) (local.get 1))
+            (local.set 2 (f64.load align=1 (i32.const 0)))
             (br $8)
           ) ;; 1
-          (f64.store align=2 (i32.const 0) (get_local 1))
-          (set_local 2 (f64.load align=2 (i32.const 0)))
+          (f64.store align=2 (i32.const 0) (local.get 1))
+          (local.set 2 (f64.load align=2 (i32.const 0)))
           (br $8)
         ) ;; 2
-        (f64.store align=4 (i32.const 0) (get_local 1))
-        (set_local 2 (f64.load align=4 (i32.const 0)))
+        (f64.store align=4 (i32.const 0) (local.get 1))
+        (local.set 2 (f64.load align=4 (i32.const 0)))
         (br $8)
       ) ;; 4
-      (f64.store align=8 (i32.const 0) (get_local 1))
-      (set_local 2 (f64.load align=8 (i32.const 0)))
+      (f64.store align=8 (i32.const 0) (local.get 1))
+      (local.set 2 (f64.load align=8 (i32.const 0)))
     ) ;; 8
-    (get_local 2)
+    (local.get 2)
   )
 
   ;; $8s: i32/i64.load8_s, $8u: i32/i64.load8_u, $16s: i32/i64.load16_s, $16u: i32/i64.load16_u, $32: i32.load
@@ -526,114 +526,114 @@
 
   (func (export "i32_align_switch") (param i32 i32) (result i32)
     (local i32 i32)
-    (set_local 2 (i32.const 10))
+    (local.set 2 (i32.const 10))
     (block $32
       (block $16u
         (block $16s
           (block $8u
             (block $8s
               (block $0
-                (br_table $0 $8s $8u $16s $16u $32 (get_local 0))
+                (br_table $0 $8s $8u $16s $16u $32 (local.get 0))
               ) ;; 0
-              (if (i32.eq (get_local 1) (i32.const 0))
+              (if (i32.eq (local.get 1) (i32.const 0))
                 (then
-                  (i32.store8 (i32.const 0) (get_local 2))
-                  (set_local 3 (i32.load8_s (i32.const 0)))
+                  (i32.store8 (i32.const 0) (local.get 2))
+                  (local.set 3 (i32.load8_s (i32.const 0)))
                 )
               )
-              (if (i32.eq (get_local 1) (i32.const 1))
+              (if (i32.eq (local.get 1) (i32.const 1))
                 (then
-                  (i32.store8 align=1 (i32.const 0) (get_local 2))
-                  (set_local 3 (i32.load8_s align=1 (i32.const 0)))
+                  (i32.store8 align=1 (i32.const 0) (local.get 2))
+                  (local.set 3 (i32.load8_s align=1 (i32.const 0)))
                 )
               )
               (br $32)
             ) ;; 8s
-            (if (i32.eq (get_local 1) (i32.const 0))
+            (if (i32.eq (local.get 1) (i32.const 0))
               (then
-                (i32.store8 (i32.const 0) (get_local 2))
-                (set_local 3 (i32.load8_u (i32.const 0)))
+                (i32.store8 (i32.const 0) (local.get 2))
+                (local.set 3 (i32.load8_u (i32.const 0)))
               )
             )
-            (if (i32.eq (get_local 1) (i32.const 1))
+            (if (i32.eq (local.get 1) (i32.const 1))
               (then
-                (i32.store8 align=1 (i32.const 0) (get_local 2))
-                (set_local 3 (i32.load8_u align=1 (i32.const 0)))
+                (i32.store8 align=1 (i32.const 0) (local.get 2))
+                (local.set 3 (i32.load8_u align=1 (i32.const 0)))
               )
             )
             (br $32)
           ) ;; 8u
-          (if (i32.eq (get_local 1) (i32.const 0))
+          (if (i32.eq (local.get 1) (i32.const 0))
             (then
-              (i32.store16 (i32.const 0) (get_local 2))
-              (set_local 3 (i32.load16_s (i32.const 0)))
+              (i32.store16 (i32.const 0) (local.get 2))
+              (local.set 3 (i32.load16_s (i32.const 0)))
             )
           )
-          (if (i32.eq (get_local 1) (i32.const 1))
+          (if (i32.eq (local.get 1) (i32.const 1))
             (then
-              (i32.store16 align=1 (i32.const 0) (get_local 2))
-              (set_local 3 (i32.load16_s align=1 (i32.const 0)))
+              (i32.store16 align=1 (i32.const 0) (local.get 2))
+              (local.set 3 (i32.load16_s align=1 (i32.const 0)))
             )
           )
-          (if (i32.eq (get_local 1) (i32.const 2))
+          (if (i32.eq (local.get 1) (i32.const 2))
             (then
-              (i32.store16 align=2 (i32.const 0) (get_local 2))
-              (set_local 3 (i32.load16_s align=2 (i32.const 0)))
+              (i32.store16 align=2 (i32.const 0) (local.get 2))
+              (local.set 3 (i32.load16_s align=2 (i32.const 0)))
             )
           )
           (br $32)
         ) ;; 16s
-        (if (i32.eq (get_local 1) (i32.const 0))
+        (if (i32.eq (local.get 1) (i32.const 0))
           (then
-            (i32.store16 (i32.const 0) (get_local 2))
-            (set_local 3 (i32.load16_u (i32.const 0)))
+            (i32.store16 (i32.const 0) (local.get 2))
+            (local.set 3 (i32.load16_u (i32.const 0)))
           )
         )
-        (if (i32.eq (get_local 1) (i32.const 1))
+        (if (i32.eq (local.get 1) (i32.const 1))
           (then
-            (i32.store16 align=1 (i32.const 0) (get_local 2))
-            (set_local 3 (i32.load16_u align=1 (i32.const 0)))
+            (i32.store16 align=1 (i32.const 0) (local.get 2))
+            (local.set 3 (i32.load16_u align=1 (i32.const 0)))
           )
         )
-        (if (i32.eq (get_local 1) (i32.const 2))
+        (if (i32.eq (local.get 1) (i32.const 2))
           (then
-            (i32.store16 align=2 (i32.const 0) (get_local 2))
-            (set_local 3 (i32.load16_u align=2 (i32.const 0)))
+            (i32.store16 align=2 (i32.const 0) (local.get 2))
+            (local.set 3 (i32.load16_u align=2 (i32.const 0)))
           )
         )
         (br $32)
       ) ;; 16u
-      (if (i32.eq (get_local 1) (i32.const 0))
+      (if (i32.eq (local.get 1) (i32.const 0))
         (then
-          (i32.store (i32.const 0) (get_local 2))
-          (set_local 3 (i32.load (i32.const 0)))
+          (i32.store (i32.const 0) (local.get 2))
+          (local.set 3 (i32.load (i32.const 0)))
         )
       )
-      (if (i32.eq (get_local 1) (i32.const 1))
+      (if (i32.eq (local.get 1) (i32.const 1))
         (then
-          (i32.store align=1 (i32.const 0) (get_local 2))
-          (set_local 3 (i32.load align=1 (i32.const 0)))
+          (i32.store align=1 (i32.const 0) (local.get 2))
+          (local.set 3 (i32.load align=1 (i32.const 0)))
         )
       )
-      (if (i32.eq (get_local 1) (i32.const 2))
+      (if (i32.eq (local.get 1) (i32.const 2))
         (then
-          (i32.store align=2 (i32.const 0) (get_local 2))
-          (set_local 3 (i32.load align=2 (i32.const 0)))
+          (i32.store align=2 (i32.const 0) (local.get 2))
+          (local.set 3 (i32.load align=2 (i32.const 0)))
         )
       )
-      (if (i32.eq (get_local 1) (i32.const 4))
+      (if (i32.eq (local.get 1) (i32.const 4))
         (then
-          (i32.store align=4 (i32.const 0) (get_local 2))
-          (set_local 3 (i32.load align=4 (i32.const 0)))
+          (i32.store align=4 (i32.const 0) (local.get 2))
+          (local.set 3 (i32.load align=4 (i32.const 0)))
         )
       )
     ) ;; 32
-    (get_local 3)
+    (local.get 3)
   )
 
   (func (export "i64_align_switch") (param i32 i32) (result i64)
     (local i64 i64)
-    (set_local 2 (i64.const 10))
+    (local.set 2 (i64.const 10))
     (block $64
       (block $32u
         (block $32s
@@ -642,160 +642,160 @@
               (block $8u
                 (block $8s
                   (block $0
-                    (br_table $0 $8s $8u $16s $16u $32s $32u $64 (get_local 0))
+                    (br_table $0 $8s $8u $16s $16u $32s $32u $64 (local.get 0))
                   ) ;; 0
-                  (if (i32.eq (get_local 1) (i32.const 0))
+                  (if (i32.eq (local.get 1) (i32.const 0))
                     (then
-                      (i64.store8 (i32.const 0) (get_local 2))
-                      (set_local 3 (i64.load8_s (i32.const 0)))
+                      (i64.store8 (i32.const 0) (local.get 2))
+                      (local.set 3 (i64.load8_s (i32.const 0)))
                     )
                   )
-                  (if (i32.eq (get_local 1) (i32.const 1))
+                  (if (i32.eq (local.get 1) (i32.const 1))
                     (then
-                      (i64.store8 align=1 (i32.const 0) (get_local 2))
-                      (set_local 3 (i64.load8_s align=1 (i32.const 0)))
+                      (i64.store8 align=1 (i32.const 0) (local.get 2))
+                      (local.set 3 (i64.load8_s align=1 (i32.const 0)))
                     )
                   )
                   (br $64)
                 ) ;; 8s
-                (if (i32.eq (get_local 1) (i32.const 0))
+                (if (i32.eq (local.get 1) (i32.const 0))
                   (then
-                    (i64.store8 (i32.const 0) (get_local 2))
-                    (set_local 3 (i64.load8_u (i32.const 0)))
+                    (i64.store8 (i32.const 0) (local.get 2))
+                    (local.set 3 (i64.load8_u (i32.const 0)))
                   )
                 )
-                (if (i32.eq (get_local 1) (i32.const 1))
+                (if (i32.eq (local.get 1) (i32.const 1))
                   (then
-                    (i64.store8 align=1 (i32.const 0) (get_local 2))
-                    (set_local 3 (i64.load8_u align=1 (i32.const 0)))
+                    (i64.store8 align=1 (i32.const 0) (local.get 2))
+                    (local.set 3 (i64.load8_u align=1 (i32.const 0)))
                   )
                 )
                 (br $64)
               ) ;; 8u
-              (if (i32.eq (get_local 1) (i32.const 0))
+              (if (i32.eq (local.get 1) (i32.const 0))
                 (then
-                  (i64.store16 (i32.const 0) (get_local 2))
-                  (set_local 3 (i64.load16_s (i32.const 0)))
+                  (i64.store16 (i32.const 0) (local.get 2))
+                  (local.set 3 (i64.load16_s (i32.const 0)))
                 )
               )
-              (if (i32.eq (get_local 1) (i32.const 1))
+              (if (i32.eq (local.get 1) (i32.const 1))
                 (then
-                  (i64.store16 align=1 (i32.const 0) (get_local 2))
-                  (set_local 3 (i64.load16_s align=1 (i32.const 0)))
+                  (i64.store16 align=1 (i32.const 0) (local.get 2))
+                  (local.set 3 (i64.load16_s align=1 (i32.const 0)))
                 )
               )
-              (if (i32.eq (get_local 1) (i32.const 2))
+              (if (i32.eq (local.get 1) (i32.const 2))
                 (then
-                  (i64.store16 align=2 (i32.const 0) (get_local 2))
-                  (set_local 3 (i64.load16_s align=2 (i32.const 0)))
+                  (i64.store16 align=2 (i32.const 0) (local.get 2))
+                  (local.set 3 (i64.load16_s align=2 (i32.const 0)))
                 )
               )
               (br $64)
             ) ;; 16s
-            (if (i32.eq (get_local 1) (i32.const 0))
+            (if (i32.eq (local.get 1) (i32.const 0))
               (then
-                (i64.store16 (i32.const 0) (get_local 2))
-                (set_local 3 (i64.load16_u (i32.const 0)))
+                (i64.store16 (i32.const 0) (local.get 2))
+                (local.set 3 (i64.load16_u (i32.const 0)))
               )
             )
-            (if (i32.eq (get_local 1) (i32.const 1))
+            (if (i32.eq (local.get 1) (i32.const 1))
               (then
-                (i64.store16 align=1 (i32.const 0) (get_local 2))
-                (set_local 3 (i64.load16_u align=1 (i32.const 0)))
+                (i64.store16 align=1 (i32.const 0) (local.get 2))
+                (local.set 3 (i64.load16_u align=1 (i32.const 0)))
               )
             )
-            (if (i32.eq (get_local 1) (i32.const 2))
+            (if (i32.eq (local.get 1) (i32.const 2))
               (then
-                (i64.store16 align=2 (i32.const 0) (get_local 2))
-                (set_local 3 (i64.load16_u align=2 (i32.const 0)))
+                (i64.store16 align=2 (i32.const 0) (local.get 2))
+                (local.set 3 (i64.load16_u align=2 (i32.const 0)))
               )
             )
             (br $64)
           ) ;; 16u
-          (if (i32.eq (get_local 1) (i32.const 0))
+          (if (i32.eq (local.get 1) (i32.const 0))
             (then
-              (i64.store32 (i32.const 0) (get_local 2))
-              (set_local 3 (i64.load32_s (i32.const 0)))
+              (i64.store32 (i32.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s (i32.const 0)))
             )
           )
-          (if (i32.eq (get_local 1) (i32.const 1))
+          (if (i32.eq (local.get 1) (i32.const 1))
             (then
-              (i64.store32 align=1 (i32.const 0) (get_local 2))
-              (set_local 3 (i64.load32_s align=1 (i32.const 0)))
+              (i64.store32 align=1 (i32.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s align=1 (i32.const 0)))
             )
           )
-          (if (i32.eq (get_local 1) (i32.const 2))
+          (if (i32.eq (local.get 1) (i32.const 2))
             (then
-              (i64.store32 align=2 (i32.const 0) (get_local 2))
-              (set_local 3 (i64.load32_s align=2 (i32.const 0)))
+              (i64.store32 align=2 (i32.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s align=2 (i32.const 0)))
             )
           )
-          (if (i32.eq (get_local 1) (i32.const 4))
+          (if (i32.eq (local.get 1) (i32.const 4))
             (then
-              (i64.store32 align=4 (i32.const 0) (get_local 2))
-              (set_local 3 (i64.load32_s align=4 (i32.const 0)))
+              (i64.store32 align=4 (i32.const 0) (local.get 2))
+              (local.set 3 (i64.load32_s align=4 (i32.const 0)))
             )
           )
           (br $64)
         ) ;; 32s
-        (if (i32.eq (get_local 1) (i32.const 0))
+        (if (i32.eq (local.get 1) (i32.const 0))
           (then
-            (i64.store32 (i32.const 0) (get_local 2))
-            (set_local 3 (i64.load32_u (i32.const 0)))
+            (i64.store32 (i32.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u (i32.const 0)))
           )
         )
-        (if (i32.eq (get_local 1) (i32.const 1))
+        (if (i32.eq (local.get 1) (i32.const 1))
           (then
-            (i64.store32 align=1 (i32.const 0) (get_local 2))
-            (set_local 3 (i64.load32_u align=1 (i32.const 0)))
+            (i64.store32 align=1 (i32.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u align=1 (i32.const 0)))
           )
         )
-        (if (i32.eq (get_local 1) (i32.const 2))
+        (if (i32.eq (local.get 1) (i32.const 2))
           (then
-            (i64.store32 align=2 (i32.const 0) (get_local 2))
-            (set_local 3 (i64.load32_u align=2 (i32.const 0)))
+            (i64.store32 align=2 (i32.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u align=2 (i32.const 0)))
           )
         )
-        (if (i32.eq (get_local 1) (i32.const 4))
+        (if (i32.eq (local.get 1) (i32.const 4))
           (then
-            (i64.store32 align=4 (i32.const 0) (get_local 2))
-            (set_local 3 (i64.load32_u align=4 (i32.const 0)))
+            (i64.store32 align=4 (i32.const 0) (local.get 2))
+            (local.set 3 (i64.load32_u align=4 (i32.const 0)))
           )
         )
         (br $64)
       ) ;; 32u
-      (if (i32.eq (get_local 1) (i32.const 0))
+      (if (i32.eq (local.get 1) (i32.const 0))
         (then
-          (i64.store (i32.const 0) (get_local 2))
-          (set_local 3 (i64.load (i32.const 0)))
+          (i64.store (i32.const 0) (local.get 2))
+          (local.set 3 (i64.load (i32.const 0)))
         )
       )
-      (if (i32.eq (get_local 1) (i32.const 1))
+      (if (i32.eq (local.get 1) (i32.const 1))
         (then
-          (i64.store align=1 (i32.const 0) (get_local 2))
-          (set_local 3 (i64.load align=1 (i32.const 0)))
+          (i64.store align=1 (i32.const 0) (local.get 2))
+          (local.set 3 (i64.load align=1 (i32.const 0)))
         )
       )
-      (if (i32.eq (get_local 1) (i32.const 2))
+      (if (i32.eq (local.get 1) (i32.const 2))
         (then
-          (i64.store align=2 (i32.const 0) (get_local 2))
-          (set_local 3 (i64.load align=2 (i32.const 0)))
+          (i64.store align=2 (i32.const 0) (local.get 2))
+          (local.set 3 (i64.load align=2 (i32.const 0)))
         )
       )
-      (if (i32.eq (get_local 1) (i32.const 4))
+      (if (i32.eq (local.get 1) (i32.const 4))
         (then
-          (i64.store align=4 (i32.const 0) (get_local 2))
-          (set_local 3 (i64.load align=4 (i32.const 0)))
+          (i64.store align=4 (i32.const 0) (local.get 2))
+          (local.set 3 (i64.load align=4 (i32.const 0)))
         )
       )
-      (if (i32.eq (get_local 1) (i32.const 8))
+      (if (i32.eq (local.get 1) (i32.const 8))
         (then
-          (i64.store align=8 (i32.const 0) (get_local 2))
-          (set_local 3 (i64.load align=8 (i32.const 0)))
+          (i64.store align=8 (i32.const 0) (local.get 2))
+          (local.set 3 (i64.load align=8 (i32.const 0)))
         )
       )
     ) ;; 64
-    (get_local 3)
+    (local.get 3)
   )
 )
 
@@ -854,10 +854,10 @@
 (module
   (memory 1)
   (func (export "store") (param i32 i64)
-    (i64.store align=4 (get_local 0) (get_local 1))
+    (i64.store align=4 (local.get 0) (local.get 1))
   )
   (func (export "load") (param i32) (result i32)
-    (i32.load (get_local 0))
+    (i32.load (local.get 0))
   )
 )
 
diff --git a/test/core/binary.wast b/test/core/binary.wast
index cbf09cfd6..7ec8c4608 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -128,7 +128,7 @@
 (module binary
   "\00asm" "\01\00\00\00"
   "\04\04\01"                          ;; Table section with 1 entry
-  "\70\00\00"                          ;; no max, minimum 0, anyfunc
+  "\70\00\00"                          ;; no max, minimum 0, funcref
   "\09\07\01"                          ;; Element section with 1 entry
   "\80\00"                             ;; Table index 0, encoded with 2 bytes
   "\41\00\0b\00"                       ;; (i32.const 0) with no elements
diff --git a/test/core/block.wast b/test/core/block.wast
index e2ab21847..f1210c147 100644
--- a/test/core/block.wast
+++ b/test/core/block.wast
@@ -114,9 +114,9 @@
     (block (result i32) (i32.const 2) (block (result i32) (i32.const 1)) (br_table 0 0))
   )
 
-  (func $func (param i32 i32) (result i32) (get_local 0))
+  (func $func (param i32 i32) (result i32) (local.get 0))
   (type $check (func (param i32 i32) (result i32)))
-  (table anyfunc (elem $func))
+  (table funcref (elem $func))
   (func (export "as-call_indirect-first") (result i32)
     (block (result i32)
       (call_indirect (type $check)
@@ -150,7 +150,7 @@
     (memory.grow (block (result i32) (i32.const 1)))
   )
 
-  (func $f (param i32) (result i32) (get_local 0))
+  (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "as-call-value") (result i32)
     (call $f (block (result i32) (i32.const 1)))
@@ -164,16 +164,16 @@
   (func (export "as-br-value") (result i32)
     (block (result i32) (br 0 (block (result i32) (i32.const 1))))
   )
-  (func (export "as-set_local-value") (result i32)
-    (local i32) (set_local 0 (block (result i32) (i32.const 1))) (get_local 0)
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (block (result i32) (i32.const 1))) (local.get 0)
   )
-  (func (export "as-tee_local-value") (result i32)
-    (local i32) (tee_local 0 (block (result i32) (i32.const 1)))
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (block (result i32) (i32.const 1)))
   )
   (global $a (mut i32) (i32.const 10))
-  (func (export "as-set_global-value") (result i32)
-    (set_global $a (block (result i32) (i32.const 1)))
-    (get_global $a)
+  (func (export "as-global.set-value") (result i32)
+    (global.set $a (block (result i32) (i32.const 1)))
+    (global.get $a)
   )
 
   (func (export "as-load-operand") (result i32)
@@ -223,29 +223,29 @@
   )
   (func (export "break-inner") (result i32)
     (local i32)
-    (set_local 0 (i32.const 0))
-    (set_local 0 (i32.add (get_local 0) (block (result i32) (block (result i32) (br 1 (i32.const 0x1))))))
-    (set_local 0 (i32.add (get_local 0) (block (result i32) (block (br 0)) (i32.const 0x2))))
-    (set_local 0
-      (i32.add (get_local 0) (block (result i32) (i32.ctz (br 0 (i32.const 0x4)))))
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (block (result i32) (br 1 (i32.const 0x1))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (block (br 0)) (i32.const 0x2))))
+    (local.set 0
+      (i32.add (local.get 0) (block (result i32) (i32.ctz (br 0 (i32.const 0x4)))))
     )
-    (set_local 0
-      (i32.add (get_local 0) (block (result i32) (i32.ctz (block (result i32) (br 1 (i32.const 0x8))))))
+    (local.set 0
+      (i32.add (local.get 0) (block (result i32) (i32.ctz (block (result i32) (br 1 (i32.const 0x8))))))
     )
-    (get_local 0)
+    (local.get 0)
   )
 
   (func (export "effects") (result i32)
     (local i32)
     (block
-      (set_local 0 (i32.const 1))
-      (set_local 0 (i32.mul (get_local 0) (i32.const 3)))
-      (set_local 0 (i32.sub (get_local 0) (i32.const 5)))
-      (set_local 0 (i32.mul (get_local 0) (i32.const 7)))
+      (local.set 0 (i32.const 1))
+      (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
+      (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
+      (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
       (br 0)
-      (set_local 0 (i32.mul (get_local 0) (i32.const 100)))
+      (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
     )
-    (i32.eq (get_local 0) (i32.const -14))
+    (i32.eq (local.get 0) (i32.const -14))
   )
 )
 
@@ -285,9 +285,9 @@
 (assert_return (invoke "as-return-value") (i32.const 1))
 (assert_return (invoke "as-drop-operand"))
 (assert_return (invoke "as-br-value") (i32.const 1))
-(assert_return (invoke "as-set_local-value") (i32.const 1))
-(assert_return (invoke "as-tee_local-value") (i32.const 1))
-(assert_return (invoke "as-set_global-value") (i32.const 1))
+(assert_return (invoke "as-local.set-value") (i32.const 1))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
 (assert_return (invoke "as-load-operand") (i32.const 1))
 
 (assert_return (invoke "as-unary-operand") (i32.const 0))
diff --git a/test/core/br.wast b/test/core/br.wast
index 6624af1fe..8e16f6c39 100644
--- a/test/core/br.wast
+++ b/test/core/br.wast
@@ -95,16 +95,16 @@
   )
   (func (export "as-if-then") (param i32 i32) (result i32)
     (block (result i32)
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (br 1 (i32.const 3)))
-        (else (get_local 1))
+        (else (local.get 1))
       )
     )
   )
   (func (export "as-if-else") (param i32 i32) (result i32)
     (block (result i32)
-      (if (result i32) (get_local 0)
-        (then (get_local 1))
+      (if (result i32) (local.get 0)
+        (then (local.get 1))
         (else (br 1 (i32.const 4)))
       )
     )
@@ -112,12 +112,12 @@
 
   (func (export "as-select-first") (param i32 i32) (result i32)
     (block (result i32)
-      (select (br 0 (i32.const 5)) (get_local 0) (get_local 1))
+      (select (br 0 (i32.const 5)) (local.get 0) (local.get 1))
     )
   )
   (func (export "as-select-second") (param i32 i32) (result i32)
     (block (result i32)
-      (select (get_local 0) (br 0 (i32.const 6)) (get_local 1))
+      (select (local.get 0) (br 0 (i32.const 6)) (local.get 1))
     )
   )
   (func (export "as-select-cond") (result i32)
@@ -144,7 +144,7 @@
   )
 
   (type $sig (func (param i32 i32 i32) (result i32)))
-  (table anyfunc (elem $f))
+  (table funcref (elem $f))
   (func (export "as-call_indirect-func") (result i32)
     (block (result i32)
       (call_indirect (type $sig)
@@ -178,15 +178,15 @@
     )
   )
 
-  (func (export "as-set_local-value") (result i32) (local f32)
-    (block (result i32) (set_local 0 (br 0 (i32.const 17))) (i32.const -1))
+  (func (export "as-local.set-value") (result i32) (local f32)
+    (block (result i32) (local.set 0 (br 0 (i32.const 17))) (i32.const -1))
   )
-  (func (export "as-tee_local-value") (result i32) (local i32)
-    (block (result i32) (tee_local 0 (br 0 (i32.const 1))))
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (block (result i32) (local.tee 0 (br 0 (i32.const 1))))
   )
   (global $a (mut i32) (i32.const 10))
-  (func (export "as-set_global-value") (result i32)
-    (block (result i32) (set_global $a (br 0 (i32.const 1))))
+  (func (export "as-global.set-value") (result i32)
+    (block (result i32) (global.set $a (br 0 (i32.const 1))))
   )
 
   (memory 1)
@@ -242,7 +242,7 @@
   )
 
   (func (export "as-convert-operand") (result i32)
-    (block (result i32) (i32.wrap/i64 (br 0 (i32.const 41))))
+    (block (result i32) (i32.wrap_i64 (br 0 (i32.const 41))))
   )
 
   (func (export "as-memory.grow-size") (result i32)
@@ -383,9 +383,9 @@
 (assert_return (invoke "as-call_indirect-mid") (i32.const 22))
 (assert_return (invoke "as-call_indirect-last") (i32.const 23))
 
-(assert_return (invoke "as-set_local-value") (i32.const 17))
-(assert_return (invoke "as-tee_local-value") (i32.const 1))
-(assert_return (invoke "as-set_global-value") (i32.const 1))
+(assert_return (invoke "as-local.set-value") (i32.const 17))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
 
 (assert_return (invoke "as-load-address") (f32.const 1.7))
 (assert_return (invoke "as-loadN-address") (i64.const 30))
diff --git a/test/core/br_if.wast b/test/core/br_if.wast
index c9402c82f..34706757d 100644
--- a/test/core/br_if.wast
+++ b/test/core/br_if.wast
@@ -30,42 +30,42 @@
   )
 
   (func (export "as-block-first") (param i32) (result i32)
-    (block (br_if 0 (get_local 0)) (return (i32.const 2))) (i32.const 3)
+    (block (br_if 0 (local.get 0)) (return (i32.const 2))) (i32.const 3)
   )
   (func (export "as-block-mid") (param i32) (result i32)
-    (block (call $dummy) (br_if 0 (get_local 0)) (return (i32.const 2)))
+    (block (call $dummy) (br_if 0 (local.get 0)) (return (i32.const 2)))
     (i32.const 3)
   )
   (func (export "as-block-last") (param i32)
-    (block (call $dummy) (call $dummy) (br_if 0 (get_local 0)))
+    (block (call $dummy) (call $dummy) (br_if 0 (local.get 0)))
   )
   (func (export "as-block-first-value") (param i32) (result i32)
     (block (result i32)
-      (drop (br_if 0 (i32.const 10) (get_local 0))) (return (i32.const 11))
+      (drop (br_if 0 (i32.const 10) (local.get 0))) (return (i32.const 11))
     )
   )
   (func (export "as-block-mid-value") (param i32) (result i32)
     (block (result i32)
       (call $dummy)
-      (drop (br_if 0 (i32.const 20) (get_local 0)))
+      (drop (br_if 0 (i32.const 20) (local.get 0)))
       (return (i32.const 21))
     )
   )
   (func (export "as-block-last-value") (param i32) (result i32)
     (block (result i32)
-      (call $dummy) (call $dummy) (br_if 0 (i32.const 11) (get_local 0))
+      (call $dummy) (call $dummy) (br_if 0 (i32.const 11) (local.get 0))
     )
   )
 
   (func (export "as-loop-first") (param i32) (result i32)
-    (block (loop (br_if 1 (get_local 0)) (return (i32.const 2)))) (i32.const 3)
+    (block (loop (br_if 1 (local.get 0)) (return (i32.const 2)))) (i32.const 3)
   )
   (func (export "as-loop-mid") (param i32) (result i32)
-    (block (loop (call $dummy) (br_if 1 (get_local 0)) (return (i32.const 2))))
+    (block (loop (call $dummy) (br_if 1 (local.get 0)) (return (i32.const 2))))
     (i32.const 4)
   )
   (func (export "as-loop-last") (param i32)
-    (loop (call $dummy) (br_if 1 (get_local 0)))
+    (loop (call $dummy) (br_if 1 (local.get 0)))
   )
 
   (func (export "as-br-value") (result i32)
@@ -83,7 +83,7 @@
   )
   (func (export "as-br_if-value-cond") (param i32) (result i32)
     (block (result i32)
-      (drop (br_if 0 (i32.const 2) (br_if 0 (i32.const 1) (get_local 0))))
+      (drop (br_if 0 (i32.const 2) (br_if 0 (i32.const 1) (local.get 0))))
       (i32.const 4)
     )
   )
@@ -108,7 +108,7 @@
   (func (export "as-if-cond") (param i32) (result i32)
     (block (result i32)
       (if (result i32)
-        (br_if 0 (i32.const 1) (get_local 0))
+        (br_if 0 (i32.const 1) (local.get 0))
         (then (i32.const 2))
         (else (i32.const 3))
       )
@@ -116,23 +116,23 @@
   )
   (func (export "as-if-then") (param i32 i32)
     (block
-      (if (get_local 0) (then (br_if 1 (get_local 1))) (else (call $dummy)))
+      (if (local.get 0) (then (br_if 1 (local.get 1))) (else (call $dummy)))
     )
   )
   (func (export "as-if-else") (param i32 i32)
     (block
-      (if (get_local 0) (then (call $dummy)) (else (br_if 1 (get_local 1))))
+      (if (local.get 0) (then (call $dummy)) (else (br_if 1 (local.get 1))))
     )
   )
 
   (func (export "as-select-first") (param i32) (result i32)
     (block (result i32)
-      (select (br_if 0 (i32.const 3) (i32.const 10)) (i32.const 2) (get_local 0))
+      (select (br_if 0 (i32.const 3) (i32.const 10)) (i32.const 2) (local.get 0))
     )
   )
   (func (export "as-select-second") (param i32) (result i32)
     (block (result i32)
-      (select (i32.const 1) (br_if 0 (i32.const 3) (i32.const 10)) (get_local 0))
+      (select (i32.const 1) (br_if 0 (i32.const 3) (i32.const 10)) (local.get 0))
     )
   )
   (func (export "as-select-cond") (result i32)
@@ -164,9 +164,9 @@
     )
   )
 
-  (func $func (param i32 i32 i32) (result i32) (get_local 0))
+  (func $func (param i32 i32 i32) (result i32) (local.get 0))
   (type $check (func (param i32 i32 i32) (result i32)))
-  (table anyfunc (elem $func))
+  (table funcref (elem $func))
   (func (export "as-call_indirect-func") (result i32)
     (block (result i32)
       (call_indirect (type $check)
@@ -198,23 +198,23 @@
     )
   )
 
-  (func (export "as-set_local-value") (param i32) (result i32)
+  (func (export "as-local.set-value") (param i32) (result i32)
     (local i32)
     (block (result i32)
-      (set_local 0 (br_if 0 (i32.const 17) (get_local 0)))
+      (local.set 0 (br_if 0 (i32.const 17) (local.get 0)))
       (i32.const -1)
     )
   )
-  (func (export "as-tee_local-value") (param i32) (result i32)
+  (func (export "as-local.tee-value") (param i32) (result i32)
     (block (result i32)
-      (tee_local 0 (br_if 0 (i32.const 1) (get_local 0)))
+      (local.tee 0 (br_if 0 (i32.const 1) (local.get 0)))
       (return (i32.const -1))
     )
   )
   (global $a (mut i32) (i32.const 10))
-  (func (export "as-set_global-value") (param i32) (result i32)
+  (func (export "as-global.set-value") (param i32) (result i32)
     (block (result i32)
-      (set_global $a (br_if 0 (i32.const 1) (get_local 0)))
+      (global.set $a (br_if 0 (i32.const 1) (local.get 0)))
       (return (i32.const -1))
     )
   )
@@ -280,7 +280,7 @@
         (i32.add
           (i32.const 4)
           (block (result i32)
-            (drop (br_if 1 (i32.const 8) (get_local 0)))
+            (drop (br_if 1 (i32.const 8) (local.get 0)))
             (i32.const 16)
           )
         )
@@ -295,7 +295,7 @@
         (drop (i32.const 2))
         (br 0
           (block (result i32)
-            (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
           )
         )
         (i32.const 16)
@@ -310,7 +310,7 @@
         (drop (i32.const 2))
         (drop (br_if 0
           (block (result i32)
-            (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
           )
           (i32.const 1)
         ))
@@ -327,7 +327,7 @@
         (drop (br_if 0
           (i32.const 4)
           (block (result i32)
-            (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 1)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
           )
         ))
         (i32.const 16)
@@ -342,7 +342,7 @@
         (drop (i32.const 2))
         (br_table 0
           (block (result i32)
-            (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 4)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 4)
           )
           (i32.const 1)
         )
@@ -359,7 +359,7 @@
         (br_table 0
           (i32.const 4)
           (block (result i32)
-            (drop (br_if 1 (i32.const 8) (get_local 0))) (i32.const 1)
+            (drop (br_if 1 (i32.const 8) (local.get 0))) (i32.const 1)
           )
         )
         (i32.const 16)
@@ -439,14 +439,14 @@
 (assert_return (invoke "as-call_indirect-mid") (i32.const 4))
 (assert_return (invoke "as-call_indirect-last") (i32.const 4))
 
-(assert_return (invoke "as-set_local-value" (i32.const 0)) (i32.const -1))
-(assert_return (invoke "as-set_local-value" (i32.const 1)) (i32.const 17))
+(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 17))
 
-(assert_return (invoke "as-tee_local-value" (i32.const 0)) (i32.const -1))
-(assert_return (invoke "as-tee_local-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1))
 
-(assert_return (invoke "as-set_global-value" (i32.const 0)) (i32.const -1))
-(assert_return (invoke "as-set_global-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const -1))
+(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1))
 
 (assert_return (invoke "as-load-address") (i32.const 1))
 (assert_return (invoke "as-loadN-address") (i32.const 30))
diff --git a/test/core/br_table.wast b/test/core/br_table.wast
index a211824c3..7627feb31 100644
--- a/test/core/br_table.wast
+++ b/test/core/br_table.wast
@@ -31,19 +31,19 @@
   )
 
   (func (export "empty") (param i32) (result i32)
-    (block (br_table 0 (get_local 0)) (return (i32.const 21)))
+    (block (br_table 0 (local.get 0)) (return (i32.const 21)))
     (i32.const 22)
   )
   (func (export "empty-value") (param i32) (result i32)
     (block (result i32)
-      (br_table 0 (i32.const 33) (get_local 0)) (i32.const 31)
+      (br_table 0 (i32.const 33) (local.get 0)) (i32.const 31)
     )
   )
 
   (func (export "singleton") (param i32) (result i32)
     (block
       (block
-        (br_table 1 0 (get_local 0))
+        (br_table 1 0 (local.get 0))
         (return (i32.const 21))
       )
       (return (i32.const 20))
@@ -55,7 +55,7 @@
     (block (result i32)
       (drop
         (block (result i32)
-          (br_table 0 1 (i32.const 33) (get_local 0))
+          (br_table 0 1 (i32.const 33) (local.get 0))
           (return (i32.const 31))
         )
       )
@@ -69,7 +69,7 @@
         (block
           (block
             (block
-              (br_table 3 2 1 0 4 (get_local 0))
+              (br_table 3 2 1 0 4 (local.get 0))
               (return (i32.const 99))
             )
             (return (i32.const 100))
@@ -85,23 +85,23 @@
 
   (func (export "multiple-value") (param i32) (result i32)
     (local i32)
-    (set_local 1 (block (result i32)
-      (set_local 1 (block (result i32)
-        (set_local 1 (block (result i32)
-          (set_local 1 (block (result i32)
-            (set_local 1 (block (result i32)
-              (br_table 3 2 1 0 4 (i32.const 200) (get_local 0))
-              (return (i32.add (get_local 1) (i32.const 99)))
+    (local.set 1 (block (result i32)
+      (local.set 1 (block (result i32)
+        (local.set 1 (block (result i32)
+          (local.set 1 (block (result i32)
+            (local.set 1 (block (result i32)
+              (br_table 3 2 1 0 4 (i32.const 200) (local.get 0))
+              (return (i32.add (local.get 1) (i32.const 99)))
             ))
-            (return (i32.add (get_local 1) (i32.const 10)))
+            (return (i32.add (local.get 1) (i32.const 10)))
           ))
-          (return (i32.add (get_local 1) (i32.const 11)))
+          (return (i32.add (local.get 1) (i32.const 11)))
         ))
-        (return (i32.add (get_local 1) (i32.const 12)))
+        (return (i32.add (local.get 1) (i32.const 12)))
       ))
-      (return (i32.add (get_local 1) (i32.const 13)))
+      (return (i32.add (local.get 1) (i32.const 13)))
     ))
-    (i32.add (get_local 1) (i32.const 14))
+    (i32.add (local.get 1) (i32.const 14))
   )
 
   (func (export "large") (param i32) (result i32)
@@ -832,7 +832,7 @@
           0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
           0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
           0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
-          (get_local 0)
+          (local.get 0)
         )
         (return (i32.const -1))
       )
@@ -924,17 +924,17 @@
   (func (export "as-if-then") (param i32 i32) (result i32)
     (block (result i32)
       (if (result i32)
-        (get_local 0)
+        (local.get 0)
         (then (br_table 1 (i32.const 3) (i32.const 0)))
-        (else (get_local 1))
+        (else (local.get 1))
       )
     )
   )
   (func (export "as-if-else") (param i32 i32) (result i32)
     (block (result i32)
       (if (result i32)
-        (get_local 0)
-        (then (get_local 1))
+        (local.get 0)
+        (then (local.get 1))
         (else (br_table 1 0 (i32.const 4) (i32.const 0)))
       )
     )
@@ -943,14 +943,14 @@
   (func (export "as-select-first") (param i32 i32) (result i32)
     (block (result i32)
       (select
-        (br_table 0 (i32.const 5) (i32.const 0)) (get_local 0) (get_local 1)
+        (br_table 0 (i32.const 5) (i32.const 0)) (local.get 0) (local.get 1)
       )
     )
   )
   (func (export "as-select-second") (param i32 i32) (result i32)
     (block (result i32)
       (select
-        (get_local 0) (br_table 0 (i32.const 6) (i32.const 1)) (get_local 1)
+        (local.get 0) (br_table 0 (i32.const 6) (i32.const 1)) (local.get 1)
       )
     )
   )
@@ -986,7 +986,7 @@
   )
 
   (type $sig (func (param i32 i32 i32) (result i32)))
-  (table anyfunc (elem $f))
+  (table funcref (elem $f))
   (func (export "as-call_indirect-first") (result i32)
     (block (result i32)
       (call_indirect (type $sig)
@@ -1020,24 +1020,24 @@
     )
   )
 
-  (func (export "as-set_local-value") (result i32)
+  (func (export "as-local.set-value") (result i32)
     (local f32)
     (block (result i32)
-      (set_local 0 (br_table 0 (i32.const 17) (i32.const 1)))
+      (local.set 0 (br_table 0 (i32.const 17) (i32.const 1)))
       (i32.const -1)
     )
   )
-  (func (export "as-tee_local-value") (result i32)
+  (func (export "as-local.tee-value") (result i32)
     (local i32)
     (block (result i32)
-      (set_local 0 (br_table 0 (i32.const 1) (i32.const 1)))
+      (local.set 0 (br_table 0 (i32.const 1) (i32.const 1)))
       (i32.const -1)
     )
   )
   (global $a (mut i32) (i32.const 10))
-  (func (export "as-set_global-value") (result i32)
+  (func (export "as-global.set-value") (result i32)
     (block (result i32)
-      (set_global $a (br_table 0 (i32.const 1) (i32.const 1)))
+      (global.set $a (br_table 0 (i32.const 1) (i32.const 1)))
       (i32.const -1)
     )
   )
@@ -1108,7 +1108,7 @@
 
   (func (export "as-convert-operand") (result i32)
     (block (result i32)
-      (i32.wrap/i64 (br_table 0 (i32.const 41) (i32.const 0)))
+      (i32.wrap_i64 (br_table 0 (i32.const 41) (i32.const 0)))
     )
   )
 
@@ -1128,7 +1128,7 @@
               (drop (i32.const 4))
               (i32.add
                 (i32.const 8)
-                (br_table 0 1 2 (i32.const 16) (get_local 0))
+                (br_table 0 1 2 (i32.const 16) (local.get 0))
               )
             )
           )
@@ -1146,7 +1146,7 @@
           (drop
             (block (result i32)
               (drop (i32.const 4))
-              (br 0 (br_table 2 1 0 (i32.const 8) (get_local 0)))
+              (br 0 (br_table 2 1 0 (i32.const 8) (local.get 0)))
             )
           )
           (i32.const 16)
@@ -1166,7 +1166,7 @@
               (drop (i32.const 4))
               (drop
                 (br_if 0
-                  (br_table 0 1 2 (i32.const 8) (get_local 0))
+                  (br_table 0 1 2 (i32.const 8) (local.get 0))
                   (i32.const 1)
                 )
               )
@@ -1186,7 +1186,7 @@
         (block (result i32)
           (drop (i32.const 2))
           (drop
-            (br_if 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (get_local 0)))
+            (br_if 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0)))
           )
           (i32.const 16)
         )
@@ -1203,7 +1203,7 @@
           (drop
             (block (result i32)
               (drop (i32.const 4))
-              (br_table 0 (br_table 0 1 2 (i32.const 8) (get_local 0)) (i32.const 1))
+              (br_table 0 (br_table 0 1 2 (i32.const 8) (local.get 0)) (i32.const 1))
               (i32.const 32)
             )
           )
@@ -1219,7 +1219,7 @@
         (i32.const 1)
         (block (result i32)
           (drop (i32.const 2))
-          (br_table 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (get_local 0)))
+          (br_table 0 (i32.const 4) (br_table 0 1 0 (i32.const 8) (local.get 0)))
           (i32.const 16)
         )
       )
@@ -1227,17 +1227,17 @@
   )
 
   (func (export "nested-br_table-loop-block") (param i32) (result i32)
-    (set_local 0
+    (local.set 0
       (loop (result i32)
         (block
-          (br_table 1 0 0 (get_local 0))
+          (br_table 1 0 0 (local.get 0))
         )
         (i32.const 0)
       )
     )
     (loop (result i32)
       (block
-        (br_table 0 1 1 (get_local 0))
+        (br_table 0 1 1 (local.get 0))
       )
       (i32.const 3)
     )
@@ -1355,9 +1355,9 @@
 (assert_return (invoke "as-call_indirect-last") (i32.const 22))
 (assert_return (invoke "as-call_indirect-func") (i32.const 23))
 
-(assert_return (invoke "as-set_local-value") (i32.const 17))
-(assert_return (invoke "as-tee_local-value") (i32.const 1))
-(assert_return (invoke "as-set_global-value") (i32.const 1))
+(assert_return (invoke "as-local.set-value") (i32.const 17))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
 
 (assert_return (invoke "as-load-address") (f32.const 1.7))
 (assert_return (invoke "as-loadN-address") (i64.const 30))
diff --git a/test/core/call.wast b/test/core/call.wast
index c7cb98146..0eb0029d1 100644
--- a/test/core/call.wast
+++ b/test/core/call.wast
@@ -7,15 +7,15 @@
   (func $const-f32 (result f32) (f32.const 0xf32))
   (func $const-f64 (result f64) (f64.const 0xf64))
 
-  (func $id-i32 (param i32) (result i32) (get_local 0))
-  (func $id-i64 (param i64) (result i64) (get_local 0))
-  (func $id-f32 (param f32) (result f32) (get_local 0))
-  (func $id-f64 (param f64) (result f64) (get_local 0))
+  (func $id-i32 (param i32) (result i32) (local.get 0))
+  (func $id-i64 (param i64) (result i64) (local.get 0))
+  (func $id-f32 (param f32) (result f32) (local.get 0))
+  (func $id-f64 (param f64) (result f64) (local.get 0))
 
-  (func $f32-i32 (param f32 i32) (result i32) (get_local 1))
-  (func $i32-i64 (param i32 i64) (result i64) (get_local 1))
-  (func $f64-f32 (param f64 f32) (result f32) (get_local 1))
-  (func $i64-f64 (param i64 f64) (result f64) (get_local 1))
+  (func $f32-i32 (param f32 i32) (result i32) (local.get 1))
+  (func $i32-i64 (param i32 i64) (result i64) (local.get 1))
+  (func $f64-f32 (param f64 f32) (result f32) (local.get 1))
+  (func $i64-f64 (param i64 f64) (result f64) (local.get 1))
 
   ;; Typing
 
@@ -45,51 +45,51 @@
   ;; Recursion
 
   (func $fac (export "fac") (param i64) (result i64)
-    (if (result i64) (i64.eqz (get_local 0))
+    (if (result i64) (i64.eqz (local.get 0))
       (then (i64.const 1))
       (else
         (i64.mul
-          (get_local 0)
-          (call $fac (i64.sub (get_local 0) (i64.const 1)))
+          (local.get 0)
+          (call $fac (i64.sub (local.get 0) (i64.const 1)))
         )
       )
     )
   )
 
   (func $fac-acc (export "fac-acc") (param i64 i64) (result i64)
-    (if (result i64) (i64.eqz (get_local 0))
-      (then (get_local 1))
+    (if (result i64) (i64.eqz (local.get 0))
+      (then (local.get 1))
       (else
         (call $fac-acc
-          (i64.sub (get_local 0) (i64.const 1))
-          (i64.mul (get_local 0) (get_local 1))
+          (i64.sub (local.get 0) (i64.const 1))
+          (i64.mul (local.get 0) (local.get 1))
         )
       )
     )
   )
 
   (func $fib (export "fib") (param i64) (result i64)
-    (if (result i64) (i64.le_u (get_local 0) (i64.const 1))
+    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
       (then (i64.const 1))
       (else
         (i64.add
-          (call $fib (i64.sub (get_local 0) (i64.const 2)))
-          (call $fib (i64.sub (get_local 0) (i64.const 1)))
+          (call $fib (i64.sub (local.get 0) (i64.const 2)))
+          (call $fib (i64.sub (local.get 0) (i64.const 1)))
         )
       )
     )
   )
 
   (func $even (export "even") (param i64) (result i32)
-    (if (result i32) (i64.eqz (get_local 0))
+    (if (result i32) (i64.eqz (local.get 0))
       (then (i32.const 44))
-      (else (call $odd (i64.sub (get_local 0) (i64.const 1))))
+      (else (call $odd (i64.sub (local.get 0) (i64.const 1))))
     )
   )
   (func $odd (export "odd") (param i64) (result i32)
-    (if (result i32) (i64.eqz (get_local 0))
+    (if (result i32) (i64.eqz (local.get 0))
       (then (i32.const 99))
-      (else (call $even (i64.sub (get_local 0) (i64.const 1))))
+      (else (call $even (i64.sub (local.get 0) (i64.const 1))))
     )
   )
 
@@ -139,9 +139,9 @@
     (block (result i32) (i32.const 2) (call $const-i32) (br_table 0 0))
   )
 
-  (func $func (param i32 i32) (result i32) (get_local 0))
+  (func $func (param i32 i32) (result i32) (local.get 0))
   (type $check (func (param i32 i32) (result i32)))
-  (table anyfunc (elem $func))
+  (table funcref (elem $func))
   (func (export "as-call_indirect-first") (result i32)
     (block (result i32)
       (call_indirect (type $check)
@@ -183,23 +183,23 @@
   (func (export "as-br-value") (result i32)
     (block (result i32) (br 0 (call $const-i32)))
   )
-  (func (export "as-set_local-value") (result i32)
-    (local i32) (set_local 0 (call $const-i32)) (get_local 0)
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (call $const-i32)) (local.get 0)
   )
-  (func (export "as-tee_local-value") (result i32)
-    (local i32) (tee_local 0 (call $const-i32))
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (call $const-i32))
   )
   (global $a (mut i32) (i32.const 10))
-  (func (export "as-set_global-value") (result i32)
-    (set_global $a (call $const-i32))
-    (get_global $a)
+  (func (export "as-global.set-value") (result i32)
+    (global.set $a (call $const-i32))
+    (global.get $a)
   )
   (func (export "as-load-operand") (result i32)
     (i32.load (call $const-i32))
   )
 
-  (func $dummy (param i32) (result i32) (get_local 0))
-  (func $du (param f32) (result f32) (get_local 0))
+  (func $dummy (param i32) (result i32) (local.get 0))
+  (func $du (param f32) (result f32) (local.get 0))
   (func (export "as-unary-operand") (result f32)
     (block (result f32) (f32.sqrt (call $du (f32.const 0x0p+0))))
   )
@@ -223,7 +223,7 @@
   )
 
   (func (export "as-convert-operand") (result i64)
-    (block (result i64) (i64.extend_s/i32 (call $dummy (i32.const 1))))
+    (block (result i64) (i64.extend_i32_s (call $dummy (i32.const 1))))
   )
 )
 
@@ -295,9 +295,9 @@
 (assert_return (invoke "as-return-value") (i32.const 0x132))
 (assert_return (invoke "as-drop-operand"))
 (assert_return (invoke "as-br-value") (i32.const 0x132))
-(assert_return (invoke "as-set_local-value") (i32.const 0x132))
-(assert_return (invoke "as-tee_local-value") (i32.const 0x132))
-(assert_return (invoke "as-set_global-value") (i32.const 0x132))
+(assert_return (invoke "as-local.set-value") (i32.const 0x132))
+(assert_return (invoke "as-local.tee-value") (i32.const 0x132))
+(assert_return (invoke "as-global.set-value") (i32.const 0x132))
 (assert_return (invoke "as-load-operand") (i32.const 1))
 
 (assert_return (invoke "as-unary-operand") (f32.const 0x0p+0))
diff --git a/test/core/call_indirect.wast b/test/core/call_indirect.wast
index f227b7840..d4cfe867b 100644
--- a/test/core/call_indirect.wast
+++ b/test/core/call_indirect.wast
@@ -25,22 +25,22 @@
   (func $const-f32 (type $out-f32) (f32.const 0xf32))
   (func $const-f64 (type $out-f64) (f64.const 0xf64))
 
-  (func $id-i32 (type $over-i32) (get_local 0))
-  (func $id-i64 (type $over-i64) (get_local 0))
-  (func $id-f32 (type $over-f32) (get_local 0))
-  (func $id-f64 (type $over-f64) (get_local 0))
-
-  (func $i32-i64 (type $i32-i64) (get_local 1))
-  (func $i64-f64 (type $i64-f64) (get_local 1))
-  (func $f32-i32 (type $f32-i32) (get_local 1))
-  (func $f64-f32 (type $f64-f32) (get_local 1))
-
-  (func $over-i32-duplicate (type $over-i32-duplicate) (get_local 0))
-  (func $over-i64-duplicate (type $over-i64-duplicate) (get_local 0))
-  (func $over-f32-duplicate (type $over-f32-duplicate) (get_local 0))
-  (func $over-f64-duplicate (type $over-f64-duplicate) (get_local 0))
-
-  (table anyfunc
+  (func $id-i32 (type $over-i32) (local.get 0))
+  (func $id-i64 (type $over-i64) (local.get 0))
+  (func $id-f32 (type $over-f32) (local.get 0))
+  (func $id-f64 (type $over-f64) (local.get 0))
+
+  (func $i32-i64 (type $i32-i64) (local.get 1))
+  (func $i64-f64 (type $i64-f64) (local.get 1))
+  (func $f32-i32 (type $f32-i32) (local.get 1))
+  (func $f64-f32 (type $f64-f32) (local.get 1))
+
+  (func $over-i32-duplicate (type $over-i32-duplicate) (local.get 0))
+  (func $over-i64-duplicate (type $over-i64-duplicate) (local.get 0))
+  (func $over-f32-duplicate (type $over-f32-duplicate) (local.get 0))
+  (func $over-f64-duplicate (type $over-f64-duplicate) (local.get 0))
+
+  (table funcref
     (elem
       $const-i32 $const-i64 $const-f32 $const-f64
       $id-i32 $id-i64 $id-f32 $id-f64
@@ -130,32 +130,32 @@
   ;; Dispatch
 
   (func (export "dispatch") (param i32 i64) (result i64)
-    (call_indirect (type $over-i64) (get_local 1) (get_local 0))
+    (call_indirect (type $over-i64) (local.get 1) (local.get 0))
   )
 
   (func (export "dispatch-structural-i64") (param i32) (result i64)
-    (call_indirect (type $over-i64-duplicate) (i64.const 9) (get_local 0))
+    (call_indirect (type $over-i64-duplicate) (i64.const 9) (local.get 0))
   )
   (func (export "dispatch-structural-i32") (param i32) (result i32)
-    (call_indirect (type $over-i32-duplicate) (i32.const 9) (get_local 0))
+    (call_indirect (type $over-i32-duplicate) (i32.const 9) (local.get 0))
   )
   (func (export "dispatch-structural-f32") (param i32) (result f32)
-    (call_indirect (type $over-f32-duplicate) (f32.const 9.0) (get_local 0))
+    (call_indirect (type $over-f32-duplicate) (f32.const 9.0) (local.get 0))
   )
   (func (export "dispatch-structural-f64") (param i32) (result f64)
-    (call_indirect (type $over-f64-duplicate) (f64.const 9.0) (get_local 0))
+    (call_indirect (type $over-f64-duplicate) (f64.const 9.0) (local.get 0))
   )
 
   ;; Recursion
 
   (func $fac-i64 (export "fac-i64") (type $over-i64)
-    (if (result i64) (i64.eqz (get_local 0))
+    (if (result i64) (i64.eqz (local.get 0))
       (then (i64.const 1))
       (else
         (i64.mul
-          (get_local 0)
+          (local.get 0)
           (call_indirect (type $over-i64)
-            (i64.sub (get_local 0) (i64.const 1))
+            (i64.sub (local.get 0) (i64.const 1))
             (i32.const 12)
           )
         )
@@ -164,16 +164,16 @@
   )
 
   (func $fib-i64 (export "fib-i64") (type $over-i64)
-    (if (result i64) (i64.le_u (get_local 0) (i64.const 1))
+    (if (result i64) (i64.le_u (local.get 0) (i64.const 1))
       (then (i64.const 1))
       (else
         (i64.add
           (call_indirect (type $over-i64)
-            (i64.sub (get_local 0) (i64.const 2))
+            (i64.sub (local.get 0) (i64.const 2))
             (i32.const 13)
           )
           (call_indirect (type $over-i64)
-            (i64.sub (get_local 0) (i64.const 1))
+            (i64.sub (local.get 0) (i64.const 1))
             (i32.const 13)
           )
         )
@@ -182,13 +182,13 @@
   )
 
   (func $fac-i32 (export "fac-i32") (type $over-i32)
-    (if (result i32) (i32.eqz (get_local 0))
+    (if (result i32) (i32.eqz (local.get 0))
       (then (i32.const 1))
       (else
         (i32.mul
-          (get_local 0)
+          (local.get 0)
           (call_indirect (type $over-i32)
-            (i32.sub (get_local 0) (i32.const 1))
+            (i32.sub (local.get 0) (i32.const 1))
             (i32.const 23)
           )
         )
@@ -197,13 +197,13 @@
   )
 
   (func $fac-f32 (export "fac-f32") (type $over-f32)
-    (if (result f32) (f32.eq (get_local 0) (f32.const 0.0))
+    (if (result f32) (f32.eq (local.get 0) (f32.const 0.0))
       (then (f32.const 1.0))
       (else
         (f32.mul
-          (get_local 0)
+          (local.get 0)
           (call_indirect (type $over-f32)
-            (f32.sub (get_local 0) (f32.const 1.0))
+            (f32.sub (local.get 0) (f32.const 1.0))
             (i32.const 24)
           )
         )
@@ -212,13 +212,13 @@
   )
 
   (func $fac-f64 (export "fac-f64") (type $over-f64)
-    (if (result f64) (f64.eq (get_local 0) (f64.const 0.0))
+    (if (result f64) (f64.eq (local.get 0) (f64.const 0.0))
       (then (f64.const 1.0))
       (else
         (f64.mul
-          (get_local 0)
+          (local.get 0)
           (call_indirect (type $over-f64)
-            (f64.sub (get_local 0) (f64.const 1.0))
+            (f64.sub (local.get 0) (f64.const 1.0))
             (i32.const 25)
           )
         )
@@ -227,16 +227,16 @@
   )
 
   (func $fib-i32 (export "fib-i32") (type $over-i32)
-    (if (result i32) (i32.le_u (get_local 0) (i32.const 1))
+    (if (result i32) (i32.le_u (local.get 0) (i32.const 1))
       (then (i32.const 1))
       (else
         (i32.add
           (call_indirect (type $over-i32)
-            (i32.sub (get_local 0) (i32.const 2))
+            (i32.sub (local.get 0) (i32.const 2))
             (i32.const 26)
           )
           (call_indirect (type $over-i32)
-            (i32.sub (get_local 0) (i32.const 1))
+            (i32.sub (local.get 0) (i32.const 1))
             (i32.const 26)
           )
         )
@@ -245,16 +245,16 @@
   )
 
   (func $fib-f32 (export "fib-f32") (type $over-f32)
-    (if (result f32) (f32.le (get_local 0) (f32.const 1.0))
+    (if (result f32) (f32.le (local.get 0) (f32.const 1.0))
       (then (f32.const 1.0))
       (else
         (f32.add
           (call_indirect (type $over-f32)
-            (f32.sub (get_local 0) (f32.const 2.0))
+            (f32.sub (local.get 0) (f32.const 2.0))
             (i32.const 27)
           )
           (call_indirect (type $over-f32)
-            (f32.sub (get_local 0) (f32.const 1.0))
+            (f32.sub (local.get 0) (f32.const 1.0))
             (i32.const 27)
           )
         )
@@ -263,16 +263,16 @@
   )
 
   (func $fib-f64 (export "fib-f64") (type $over-f64)
-    (if (result f64) (f64.le (get_local 0) (f64.const 1.0))
+    (if (result f64) (f64.le (local.get 0) (f64.const 1.0))
       (then (f64.const 1.0))
       (else
         (f64.add
           (call_indirect (type $over-f64)
-            (f64.sub (get_local 0) (f64.const 2.0))
+            (f64.sub (local.get 0) (f64.const 2.0))
             (i32.const 28)
           )
           (call_indirect (type $over-f64)
-            (f64.sub (get_local 0) (f64.const 1.0))
+            (f64.sub (local.get 0) (f64.const 1.0))
             (i32.const 28)
           )
         )
@@ -281,22 +281,22 @@
   )
 
   (func $even (export "even") (param i32) (result i32)
-    (if (result i32) (i32.eqz (get_local 0))
+    (if (result i32) (i32.eqz (local.get 0))
       (then (i32.const 44))
       (else
         (call_indirect (type $over-i32)
-          (i32.sub (get_local 0) (i32.const 1))
+          (i32.sub (local.get 0) (i32.const 1))
           (i32.const 15)
         )
       )
     )
   )
   (func $odd (export "odd") (param i32) (result i32)
-    (if (result i32) (i32.eqz (get_local 0))
+    (if (result i32) (i32.eqz (local.get 0))
       (then (i32.const 99))
       (else
         (call_indirect (type $over-i32)
-          (i32.sub (get_local 0) (i32.const 1))
+          (i32.sub (local.get 0) (i32.const 1))
           (i32.const 14)
         )
       )
@@ -368,16 +368,16 @@
   (func (export "as-br-value") (result f32)
     (block (result f32) (br 0 (call_indirect (type $over-f32) (f32.const 1) (i32.const 6))))
   )
-  (func (export "as-set_local-value") (result f64)
-    (local f64) (set_local 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) (get_local 0)
+  (func (export "as-local.set-value") (result f64)
+    (local f64) (local.set 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7))) (local.get 0)
   )
-  (func (export "as-tee_local-value") (result f64)
-    (local f64) (tee_local 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7)))
+  (func (export "as-local.tee-value") (result f64)
+    (local f64) (local.tee 0 (call_indirect (type $over-f64) (f64.const 1) (i32.const 7)))
   )
   (global $a (mut f64) (f64.const 10.0))
-  (func (export "as-set_global-value") (result f64)
-    (set_global $a (call_indirect (type $over-f64) (f64.const 1.0) (i32.const 7)))
-    (get_global $a)
+  (func (export "as-global.set-value") (result f64)
+    (global.set $a (call_indirect (type $over-f64) (f64.const 1.0) (i32.const 7)))
+    (global.get $a)
   )
 
   (func (export "as-load-operand") (result i32)
@@ -436,7 +436,7 @@
 
   (func (export "as-convert-operand") (result i64)
     (block (result i64)
-      (i64.extend_s/i32
+      (i64.extend_i32_s
         (call_indirect (type $over-i32) (i32.const 1) (i32.const 4))
       )
     )
@@ -575,9 +575,9 @@
 (assert_return (invoke "as-return-value") (i32.const 1))
 (assert_return (invoke "as-drop-operand"))
 (assert_return (invoke "as-br-value") (f32.const 1))
-(assert_return (invoke "as-set_local-value") (f64.const 1))
-(assert_return (invoke "as-tee_local-value") (f64.const 1))
-(assert_return (invoke "as-set_global-value") (f64.const 1.0))
+(assert_return (invoke "as-local.set-value") (f64.const 1))
+(assert_return (invoke "as-local.tee-value") (f64.const 1))
+(assert_return (invoke "as-global.set-value") (f64.const 1.0))
 (assert_return (invoke "as-load-operand") (i32.const 1))
 
 (assert_return (invoke "as-unary-operand") (f32.const 0x0p+0))
@@ -593,7 +593,7 @@
 (assert_malformed
   (module quote
     "(type $sig (func (param i32) (result i32)))"
-    "(table 0 anyfunc)"
+    "(table 0 funcref)"
     "(func (result i32)"
     "  (call_indirect (type $sig) (result i32) (param i32)"
     "    (i32.const 0) (i32.const 0)"
@@ -605,7 +605,7 @@
 (assert_malformed
   (module quote
     "(type $sig (func (param i32) (result i32)))"
-    "(table 0 anyfunc)"
+    "(table 0 funcref)"
     "(func (result i32)"
     "  (call_indirect (param i32) (type $sig) (result i32)"
     "    (i32.const 0) (i32.const 0)"
@@ -617,7 +617,7 @@
 (assert_malformed
   (module quote
     "(type $sig (func (param i32) (result i32)))"
-    "(table 0 anyfunc)"
+    "(table 0 funcref)"
     "(func (result i32)"
     "  (call_indirect (param i32) (result i32) (type $sig)"
     "    (i32.const 0) (i32.const 0)"
@@ -629,7 +629,7 @@
 (assert_malformed
   (module quote
     "(type $sig (func (param i32) (result i32)))"
-    "(table 0 anyfunc)"
+    "(table 0 funcref)"
     "(func (result i32)"
     "  (call_indirect (result i32) (type $sig) (param i32)"
     "    (i32.const 0) (i32.const 0)"
@@ -641,7 +641,7 @@
 (assert_malformed
   (module quote
     "(type $sig (func (param i32) (result i32)))"
-    "(table 0 anyfunc)"
+    "(table 0 funcref)"
     "(func (result i32)"
     "  (call_indirect (result i32) (param i32) (type $sig)"
     "    (i32.const 0) (i32.const 0)"
@@ -652,7 +652,7 @@
 )
 (assert_malformed
   (module quote
-    "(table 0 anyfunc)"
+    "(table 0 funcref)"
     "(func (result i32)"
     "  (call_indirect (result i32) (param i32) (i32.const 0) (i32.const 0))"
     ")"
@@ -662,7 +662,7 @@
 
 (assert_malformed
   (module quote
-    "(table 0 anyfunc)"
+    "(table 0 funcref)"
     "(func (call_indirect (param $x i32) (i32.const 0) (i32.const 0)))"
   )
   "unexpected token"
@@ -670,7 +670,7 @@
 (assert_malformed
   (module quote
     "(type $sig (func))"
-    "(table 0 anyfunc)"
+    "(table 0 funcref)"
     "(func (result i32)"
     "  (call_indirect (type $sig) (result i32) (i32.const 0))"
     ")"
@@ -680,7 +680,7 @@
 (assert_malformed
   (module quote
     "(type $sig (func (param i32) (result i32)))"
-    "(table 0 anyfunc)"
+    "(table 0 funcref)"
     "(func (result i32)"
     "  (call_indirect (type $sig) (result i32) (i32.const 0))"
     ")"
@@ -690,7 +690,7 @@
 (assert_malformed
   (module quote
     "(type $sig (func (param i32) (result i32)))"
-    "(table 0 anyfunc)"
+    "(table 0 funcref)"
     "(func"
     "  (call_indirect (type $sig) (param i32) (i32.const 0) (i32.const 0))"
     ")"
@@ -700,7 +700,7 @@
 (assert_malformed
   (module quote
     "(type $sig (func (param i32 i32) (result i32)))"
-    "(table 0 anyfunc)"
+    "(table 0 funcref)"
     "(func (result i32)"
     "  (call_indirect (type $sig) (param i32) (result i32)"
     "    (i32.const 0) (i32.const 0)"
@@ -723,7 +723,7 @@
 (assert_invalid
   (module
     (type (func))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $type-void-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
   )
   "type mismatch"
@@ -731,7 +731,7 @@
 (assert_invalid
   (module
     (type (func (result i64)))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $type-num-vs-num (i32.eqz (call_indirect (type 0) (i32.const 0))))
   )
   "type mismatch"
@@ -740,7 +740,7 @@
 (assert_invalid
   (module
     (type (func (param i32)))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $arity-0-vs-1 (call_indirect (type 0) (i32.const 0)))
   )
   "type mismatch"
@@ -748,7 +748,7 @@
 (assert_invalid
   (module
     (type (func (param f64 i32)))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $arity-0-vs-2 (call_indirect (type 0) (i32.const 0)))
   )
   "type mismatch"
@@ -756,7 +756,7 @@
 (assert_invalid
   (module
     (type (func))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $arity-1-vs-0 (call_indirect (type 0) (i32.const 1) (i32.const 0)))
   )
   "type mismatch"
@@ -764,7 +764,7 @@
 (assert_invalid
   (module
     (type (func))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $arity-2-vs-0
       (call_indirect (type 0) (f64.const 2) (i32.const 1) (i32.const 0))
     )
@@ -775,7 +775,7 @@
 (assert_invalid
   (module
     (type (func (param i32)))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $type-func-void-vs-i32 (call_indirect (type 0) (i32.const 1) (nop)))
   )
   "type mismatch"
@@ -783,7 +783,7 @@
 (assert_invalid
   (module
     (type (func (param i32)))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $type-func-num-vs-i32 (call_indirect (type 0) (i32.const 0) (i64.const 1)))
   )
   "type mismatch"
@@ -792,7 +792,7 @@
 (assert_invalid
   (module
     (type (func (param i32 i32)))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $type-first-void-vs-num
       (call_indirect (type 0) (nop) (i32.const 1) (i32.const 0))
     )
@@ -802,7 +802,7 @@
 (assert_invalid
   (module
     (type (func (param i32 i32)))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $type-second-void-vs-num
       (call_indirect (type 0) (i32.const 1) (nop) (i32.const 0))
     )
@@ -812,7 +812,7 @@
 (assert_invalid
   (module
     (type (func (param i32 f64)))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $type-first-num-vs-num
       (call_indirect (type 0) (f64.const 1) (i32.const 1) (i32.const 0))
     )
@@ -822,7 +822,7 @@
 (assert_invalid
   (module
     (type (func (param f64 i32)))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $type-second-num-vs-num
       (call_indirect (type 0) (i32.const 1) (f64.const 1) (i32.const 0))
     )
@@ -835,14 +835,14 @@
 
 (assert_invalid
   (module
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $unbound-type (call_indirect (type 1) (i32.const 0)))
   )
   "unknown type"
 )
 (assert_invalid
   (module
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $large-type (call_indirect (type 1012321300) (i32.const 0)))
   )
   "unknown type"
@@ -852,6 +852,6 @@
 ;; Unbound function in table
 
 (assert_invalid
-  (module (table anyfunc (elem 0 0)))
+  (module (table funcref (elem 0 0)))
   "unknown function 0"
 )
diff --git a/test/core/conversions.wast b/test/core/conversions.wast
index e664e1a6e..e36bb95ec 100644
--- a/test/core/conversions.wast
+++ b/test/core/conversions.wast
@@ -1,44 +1,44 @@
 (module
-  (func (export "i64.extend_s_i32") (param $x i32) (result i64) (i64.extend_s/i32 (get_local $x)))
-  (func (export "i64.extend_u_i32") (param $x i32) (result i64) (i64.extend_u/i32 (get_local $x)))
-  (func (export "i32.wrap_i64") (param $x i64) (result i32) (i32.wrap/i64 (get_local $x)))
-  (func (export "i32.trunc_s_f32") (param $x f32) (result i32) (i32.trunc_s/f32 (get_local $x)))
-  (func (export "i32.trunc_u_f32") (param $x f32) (result i32) (i32.trunc_u/f32 (get_local $x)))
-  (func (export "i32.trunc_s_f64") (param $x f64) (result i32) (i32.trunc_s/f64 (get_local $x)))
-  (func (export "i32.trunc_u_f64") (param $x f64) (result i32) (i32.trunc_u/f64 (get_local $x)))
-  (func (export "i64.trunc_s_f32") (param $x f32) (result i64) (i64.trunc_s/f32 (get_local $x)))
-  (func (export "i64.trunc_u_f32") (param $x f32) (result i64) (i64.trunc_u/f32 (get_local $x)))
-  (func (export "i64.trunc_s_f64") (param $x f64) (result i64) (i64.trunc_s/f64 (get_local $x)))
-  (func (export "i64.trunc_u_f64") (param $x f64) (result i64) (i64.trunc_u/f64 (get_local $x)))
-  (func (export "f32.convert_s_i32") (param $x i32) (result f32) (f32.convert_s/i32 (get_local $x)))
-  (func (export "f32.convert_s_i64") (param $x i64) (result f32) (f32.convert_s/i64 (get_local $x)))
-  (func (export "f64.convert_s_i32") (param $x i32) (result f64) (f64.convert_s/i32 (get_local $x)))
-  (func (export "f64.convert_s_i64") (param $x i64) (result f64) (f64.convert_s/i64 (get_local $x)))
-  (func (export "f32.convert_u_i32") (param $x i32) (result f32) (f32.convert_u/i32 (get_local $x)))
-  (func (export "f32.convert_u_i64") (param $x i64) (result f32) (f32.convert_u/i64 (get_local $x)))
-  (func (export "f64.convert_u_i32") (param $x i32) (result f64) (f64.convert_u/i32 (get_local $x)))
-  (func (export "f64.convert_u_i64") (param $x i64) (result f64) (f64.convert_u/i64 (get_local $x)))
-  (func (export "f64.promote_f32") (param $x f32) (result f64) (f64.promote/f32 (get_local $x)))
-  (func (export "f32.demote_f64") (param $x f64) (result f32) (f32.demote/f64 (get_local $x)))
-  (func (export "f32.reinterpret_i32") (param $x i32) (result f32) (f32.reinterpret/i32 (get_local $x)))
-  (func (export "f64.reinterpret_i64") (param $x i64) (result f64) (f64.reinterpret/i64 (get_local $x)))
-  (func (export "i32.reinterpret_f32") (param $x f32) (result i32) (i32.reinterpret/f32 (get_local $x)))
-  (func (export "i64.reinterpret_f64") (param $x f64) (result i64) (i64.reinterpret/f64 (get_local $x)))
+  (func (export "i64.extend_i32_s") (param $x i32) (result i64) (i64.extend_i32_s (local.get $x)))
+  (func (export "i64.extend_i32_u") (param $x i32) (result i64) (i64.extend_i32_u (local.get $x)))
+  (func (export "i32.wrap_i64") (param $x i64) (result i32) (i32.wrap_i64 (local.get $x)))
+  (func (export "i32.trunc_f32_s") (param $x f32) (result i32) (i32.trunc_f32_s (local.get $x)))
+  (func (export "i32.trunc_f32_u") (param $x f32) (result i32) (i32.trunc_f32_u (local.get $x)))
+  (func (export "i32.trunc_f64_s") (param $x f64) (result i32) (i32.trunc_f64_s (local.get $x)))
+  (func (export "i32.trunc_f64_u") (param $x f64) (result i32) (i32.trunc_f64_u (local.get $x)))
+  (func (export "i64.trunc_f32_s") (param $x f32) (result i64) (i64.trunc_f32_s (local.get $x)))
+  (func (export "i64.trunc_f32_u") (param $x f32) (result i64) (i64.trunc_f32_u (local.get $x)))
+  (func (export "i64.trunc_f64_s") (param $x f64) (result i64) (i64.trunc_f64_s (local.get $x)))
+  (func (export "i64.trunc_f64_u") (param $x f64) (result i64) (i64.trunc_f64_u (local.get $x)))
+  (func (export "f32.convert_i32_s") (param $x i32) (result f32) (f32.convert_i32_s (local.get $x)))
+  (func (export "f32.convert_i64_s") (param $x i64) (result f32) (f32.convert_i64_s (local.get $x)))
+  (func (export "f64.convert_i32_s") (param $x i32) (result f64) (f64.convert_i32_s (local.get $x)))
+  (func (export "f64.convert_i64_s") (param $x i64) (result f64) (f64.convert_i64_s (local.get $x)))
+  (func (export "f32.convert_i32_u") (param $x i32) (result f32) (f32.convert_i32_u (local.get $x)))
+  (func (export "f32.convert_i64_u") (param $x i64) (result f32) (f32.convert_i64_u (local.get $x)))
+  (func (export "f64.convert_i32_u") (param $x i32) (result f64) (f64.convert_i32_u (local.get $x)))
+  (func (export "f64.convert_i64_u") (param $x i64) (result f64) (f64.convert_i64_u (local.get $x)))
+  (func (export "f64.promote_f32") (param $x f32) (result f64) (f64.promote_f32 (local.get $x)))
+  (func (export "f32.demote_f64") (param $x f64) (result f32) (f32.demote_f64 (local.get $x)))
+  (func (export "f32.reinterpret_i32") (param $x i32) (result f32) (f32.reinterpret_i32 (local.get $x)))
+  (func (export "f64.reinterpret_i64") (param $x i64) (result f64) (f64.reinterpret_i64 (local.get $x)))
+  (func (export "i32.reinterpret_f32") (param $x f32) (result i32) (i32.reinterpret_f32 (local.get $x)))
+  (func (export "i64.reinterpret_f64") (param $x f64) (result i64) (i64.reinterpret_f64 (local.get $x)))
 )
 
-(assert_return (invoke "i64.extend_s_i32" (i32.const 0)) (i64.const 0))
-(assert_return (invoke "i64.extend_s_i32" (i32.const 10000)) (i64.const 10000))
-(assert_return (invoke "i64.extend_s_i32" (i32.const -10000)) (i64.const -10000))
-(assert_return (invoke "i64.extend_s_i32" (i32.const -1)) (i64.const -1))
-(assert_return (invoke "i64.extend_s_i32" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
-(assert_return (invoke "i64.extend_s_i32" (i32.const 0x80000000)) (i64.const 0xffffffff80000000))
+(assert_return (invoke "i64.extend_i32_s" (i32.const 0)) (i64.const 0))
+(assert_return (invoke "i64.extend_i32_s" (i32.const 10000)) (i64.const 10000))
+(assert_return (invoke "i64.extend_i32_s" (i32.const -10000)) (i64.const -10000))
+(assert_return (invoke "i64.extend_i32_s" (i32.const -1)) (i64.const -1))
+(assert_return (invoke "i64.extend_i32_s" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
+(assert_return (invoke "i64.extend_i32_s" (i32.const 0x80000000)) (i64.const 0xffffffff80000000))
 
-(assert_return (invoke "i64.extend_u_i32" (i32.const 0)) (i64.const 0))
-(assert_return (invoke "i64.extend_u_i32" (i32.const 10000)) (i64.const 10000))
-(assert_return (invoke "i64.extend_u_i32" (i32.const -10000)) (i64.const 0x00000000ffffd8f0))
-(assert_return (invoke "i64.extend_u_i32" (i32.const -1)) (i64.const 0xffffffff))
-(assert_return (invoke "i64.extend_u_i32" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
-(assert_return (invoke "i64.extend_u_i32" (i32.const 0x80000000)) (i64.const 0x0000000080000000))
+(assert_return (invoke "i64.extend_i32_u" (i32.const 0)) (i64.const 0))
+(assert_return (invoke "i64.extend_i32_u" (i32.const 10000)) (i64.const 10000))
+(assert_return (invoke "i64.extend_i32_u" (i32.const -10000)) (i64.const 0x00000000ffffd8f0))
+(assert_return (invoke "i64.extend_i32_u" (i32.const -1)) (i64.const 0xffffffff))
+(assert_return (invoke "i64.extend_i32_u" (i32.const 0x7fffffff)) (i64.const 0x000000007fffffff))
+(assert_return (invoke "i64.extend_i32_u" (i32.const 0x80000000)) (i64.const 0x0000000080000000))
 
 (assert_return (invoke "i32.wrap_i64" (i64.const -1)) (i32.const -1))
 (assert_return (invoke "i32.wrap_i64" (i64.const -100000)) (i32.const -100000))
@@ -53,282 +53,282 @@
 (assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000000)) (i32.const 0x00000000))
 (assert_return (invoke "i32.wrap_i64" (i64.const 0x0000000100000001)) (i32.const 0x00000001))
 
-(assert_return (invoke "i32.trunc_s_f32" (f32.const 0.0)) (i32.const 0))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const -0.0)) (i32.const 0))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const 0x1p-149)) (i32.const 0))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const -0x1p-149)) (i32.const 0))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const 1.0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const 0x1.19999ap+0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const 1.5)) (i32.const 1))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const -1.0)) (i32.const -1))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const -0x1.19999ap+0)) (i32.const -1))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const -1.5)) (i32.const -1))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const -1.9)) (i32.const -1))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const -2.0)) (i32.const -2))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const 2147483520.0)) (i32.const 2147483520))
-(assert_return (invoke "i32.trunc_s_f32" (f32.const -2147483648.0)) (i32.const -2147483648))
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const 2147483648.0)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const -2147483904.0)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const inf)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const -inf)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const nan)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const -nan)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_s_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 0x1.19999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -0x1.19999ap+0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.5)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -1.9)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -2.0)) (i32.const -2))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const 2147483520.0)) (i32.const 2147483520))
+(assert_return (invoke "i32.trunc_f32_s" (f32.const -2147483648.0)) (i32.const -2147483648))
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const 2147483648.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -2147483904.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_s" (f32.const -nan:0x200000)) "invalid conversion to integer")
 
-(assert_return (invoke "i32.trunc_u_f32" (f32.const 0.0)) (i32.const 0))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const -0.0)) (i32.const 0))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const 0x1p-149)) (i32.const 0))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const -0x1p-149)) (i32.const 0))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const 1.0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const 0x1.19999ap+0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const 1.5)) (i32.const 1))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const 1.9)) (i32.const 1))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const 2.0)) (i32.const 2))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
-(assert_return (invoke "i32.trunc_u_f32" (f32.const 4294967040.0)) (i32.const -256))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const -0x1.ccccccp-1)) (i32.const 0))
-(assert_return (invoke "i32.trunc_u_f32" (f32.const -0x1.fffffep-1)) (i32.const 0))
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const 4294967296.0)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const -1.0)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const inf)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const -inf)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const nan)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const -nan)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_u_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1p-149)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 0x1.19999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 1.9)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 2.0)) (i32.const 2))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_return (invoke "i32.trunc_f32_u" (f32.const 4294967040.0)) (i32.const -256))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1.ccccccp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f32_u" (f32.const -0x1.fffffep-1)) (i32.const 0))
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const 4294967296.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -1.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f32_u" (f32.const -nan:0x200000)) "invalid conversion to integer")
 
-(assert_return (invoke "i32.trunc_s_f64" (f64.const 0.0)) (i32.const 0))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const -0.0)) (i32.const 0))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const 1.0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const 1.5)) (i32.const 1))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const -1.0)) (i32.const -1))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const -0x1.199999999999ap+0)) (i32.const -1))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const -1.5)) (i32.const -1))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const -1.9)) (i32.const -1))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const -2.0)) (i32.const -2))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const 2147483647.0)) (i32.const 2147483647))
-(assert_return (invoke "i32.trunc_s_f64" (f64.const -2147483648.0)) (i32.const -2147483648))
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const 2147483648.0)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const -2147483649.0)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const inf)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const -inf)) "integer overflow")
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const nan)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const -nan)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_s_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -0x1.199999999999ap+0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.5)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -1.9)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -2.0)) (i32.const -2))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const 2147483647.0)) (i32.const 2147483647))
+(assert_return (invoke "i32.trunc_f64_s" (f64.const -2147483648.0)) (i32.const -2147483648))
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const 2147483648.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -2147483649.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_s" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
 
-(assert_return (invoke "i32.trunc_u_f64" (f64.const 0.0)) (i32.const 0))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const -0.0)) (i32.const 0))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const 1.0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const 1.5)) (i32.const 1))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const 1.9)) (i32.const 1))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const 2.0)) (i32.const 2))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
-(assert_return (invoke "i32.trunc_u_f64" (f64.const 4294967295.0)) (i32.const -1))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0))
-(assert_return (invoke "i32.trunc_u_f64" (f64.const 1e8)) (i32.const 100000000))
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const 4294967296.0)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const -1.0)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const 1e16)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const 1e30)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const 9223372036854775808)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const inf)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const -inf)) "integer overflow")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const nan)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const -nan)) "invalid conversion to integer")
-(assert_trap (invoke "i32.trunc_u_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0.0)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x0.0000000000001p-1022)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 0x1.199999999999ap+0)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.5)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1.9)) (i32.const 1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 2.0)) (i32.const 2))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 2147483648)) (i32.const -2147483648)) ;; 0x1.00000p+31 -> 8000 0000
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 4294967295.0)) (i32.const -1))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i32.const 0))
+(assert_return (invoke "i32.trunc_f64_u" (f64.const 1e8)) (i32.const 100000000))
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 4294967296.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -1.0)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 1e16)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 1e30)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const 9223372036854775808)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i32.trunc_f64_u" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
 
-(assert_return (invoke "i64.trunc_s_f32" (f32.const 0.0)) (i64.const 0))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const -0.0)) (i64.const 0))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const 0x1p-149)) (i64.const 0))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const -0x1p-149)) (i64.const 0))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const 1.0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const 0x1.19999ap+0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const 1.5)) (i64.const 1))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const -1.0)) (i64.const -1))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const -0x1.19999ap+0)) (i64.const -1))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const -1.5)) (i64.const -1))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const -1.9)) (i64.const -1))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const -2.0)) (i64.const -2))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
-(assert_return (invoke "i64.trunc_s_f32" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
-(assert_return (invoke "i64.trunc_s_f32" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920))
-(assert_return (invoke "i64.trunc_s_f32" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808))
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const 9223372036854775808.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const -9223373136366403584.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const inf)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const -inf)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const nan)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const -nan)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_s_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 0x1.19999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -0x1.19999ap+0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.5)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -1.9)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -2.0)) (i64.const -2))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_return (invoke "i64.trunc_f32_s" (f32.const 9223371487098961920.0)) (i64.const 9223371487098961920))
+(assert_return (invoke "i64.trunc_f32_s" (f32.const -9223372036854775808.0)) (i64.const -9223372036854775808))
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const 9223372036854775808.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -9223373136366403584.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_s" (f32.const -nan:0x200000)) "invalid conversion to integer")
 
-(assert_return (invoke "i64.trunc_u_f32" (f32.const 0.0)) (i64.const 0))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const -0.0)) (i64.const 0))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const 0x1p-149)) (i64.const 0))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const -0x1p-149)) (i64.const 0))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const 1.0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const 0x1.19999ap+0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const 1.5)) (i64.const 1))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const 4294967296)) (i64.const 4294967296))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const 18446742974197923840.0)) (i64.const -1099511627776))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const -0x1.ccccccp-1)) (i64.const 0))
-(assert_return (invoke "i64.trunc_u_f32" (f32.const -0x1.fffffep-1)) (i64.const 0))
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const 18446744073709551616.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const -1.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const inf)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const -inf)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const nan)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const nan:0x200000)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const -nan)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_u_f32" (f32.const -nan:0x200000)) "invalid conversion to integer")
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1p-149)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 0x1.19999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 4294967296)) (i64.const 4294967296))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const 18446742974197923840.0)) (i64.const -1099511627776))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1.ccccccp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f32_u" (f32.const -0x1.fffffep-1)) (i64.const 0))
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const 18446744073709551616.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -1.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const nan:0x200000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f32_u" (f32.const -nan:0x200000)) "invalid conversion to integer")
 
-(assert_return (invoke "i64.trunc_s_f64" (f64.const 0.0)) (i64.const 0))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const -0.0)) (i64.const 0))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const 1.0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const 1.5)) (i64.const 1))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const -1.0)) (i64.const -1))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const -0x1.199999999999ap+0)) (i64.const -1))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const -1.5)) (i64.const -1))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const -1.9)) (i64.const -1))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const -2.0)) (i64.const -2))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
-(assert_return (invoke "i64.trunc_s_f64" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
-(assert_return (invoke "i64.trunc_s_f64" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784))
-(assert_return (invoke "i64.trunc_s_f64" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808))
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const 9223372036854775808.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const -9223372036854777856.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const inf)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const -inf)) "integer overflow")
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const nan)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const -nan)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_s_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -0x1.199999999999ap+0)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.5)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -1.9)) (i64.const -1))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -2.0)) (i64.const -2))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 4294967296)) (i64.const 4294967296)) ;; 0x1.00000p+32 -> 1 0000 0000
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -4294967296)) (i64.const -4294967296)) ;; -0x1.00000p+32 -> ffff ffff 0000 0000
+(assert_return (invoke "i64.trunc_f64_s" (f64.const 9223372036854774784.0)) (i64.const 9223372036854774784))
+(assert_return (invoke "i64.trunc_f64_s" (f64.const -9223372036854775808.0)) (i64.const -9223372036854775808))
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const 9223372036854775808.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -9223372036854777856.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_s" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
 
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 0.0)) (i64.const 0))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const -0.0)) (i64.const 0))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 1.0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 1.5)) (i64.const 1))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 4294967295)) (i64.const 0xffffffff))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 4294967296)) (i64.const 0x100000000))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 18446744073709549568.0)) (i64.const -2048))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 1e8)) (i64.const 100000000))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 1e16)) (i64.const 10000000000000000))
-(assert_return (invoke "i64.trunc_u_f64" (f64.const 9223372036854775808)) (i64.const -9223372036854775808))
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const 18446744073709551616.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const -1.0)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const inf)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const -inf)) "integer overflow")
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const nan)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const -nan)) "invalid conversion to integer")
-(assert_trap (invoke "i64.trunc_u_f64" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0.0)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x0.0000000000001p-1022)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1.0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 0x1.199999999999ap+0)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1.5)) (i64.const 1))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 4294967295)) (i64.const 0xffffffff))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 4294967296)) (i64.const 0x100000000))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 18446744073709549568.0)) (i64.const -2048))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x1.ccccccccccccdp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const -0x1.fffffffffffffp-1)) (i64.const 0))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1e8)) (i64.const 100000000))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 1e16)) (i64.const 10000000000000000))
+(assert_return (invoke "i64.trunc_f64_u" (f64.const 9223372036854775808)) (i64.const -9223372036854775808))
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const 18446744073709551616.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -1.0)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -inf)) "integer overflow")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const nan:0x4000000000000)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -nan)) "invalid conversion to integer")
+(assert_trap (invoke "i64.trunc_f64_u" (f64.const -nan:0x4000000000000)) "invalid conversion to integer")
 
-(assert_return (invoke "f32.convert_s_i32" (i32.const 1)) (f32.const 1.0))
-(assert_return (invoke "f32.convert_s_i32" (i32.const -1)) (f32.const -1.0))
-(assert_return (invoke "f32.convert_s_i32" (i32.const 0)) (f32.const 0.0))
-(assert_return (invoke "f32.convert_s_i32" (i32.const 2147483647)) (f32.const 2147483648))
-(assert_return (invoke "f32.convert_s_i32" (i32.const -2147483648)) (f32.const -2147483648))
-(assert_return (invoke "f32.convert_s_i32" (i32.const 1234567890)) (f32.const 0x1.26580cp+30))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -1)) (f32.const -1.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 2147483647)) (f32.const 2147483648))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -2147483648)) (f32.const -2147483648))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 1234567890)) (f32.const 0x1.26580cp+30))
 ;; Test rounding directions.
-(assert_return (invoke "f32.convert_s_i32" (i32.const 16777217)) (f32.const 16777216.0))
-(assert_return (invoke "f32.convert_s_i32" (i32.const -16777217)) (f32.const -16777216.0))
-(assert_return (invoke "f32.convert_s_i32" (i32.const 16777219)) (f32.const 16777220.0))
-(assert_return (invoke "f32.convert_s_i32" (i32.const -16777219)) (f32.const -16777220.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -16777217)) (f32.const -16777216.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_i32_s" (i32.const -16777219)) (f32.const -16777220.0))
 
-(assert_return (invoke "f32.convert_s_i64" (i64.const 1)) (f32.const 1.0))
-(assert_return (invoke "f32.convert_s_i64" (i64.const -1)) (f32.const -1.0))
-(assert_return (invoke "f32.convert_s_i64" (i64.const 0)) (f32.const 0.0))
-(assert_return (invoke "f32.convert_s_i64" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
-(assert_return (invoke "f32.convert_s_i64" (i64.const -9223372036854775808)) (f32.const -9223372036854775808))
-(assert_return (invoke "f32.convert_s_i64" (i64.const 314159265358979)) (f32.const 0x1.1db9e8p+48)) ;; PI
+(assert_return (invoke "f32.convert_i64_s" (i64.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -1)) (f32.const -1.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -9223372036854775808)) (f32.const -9223372036854775808))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 314159265358979)) (f32.const 0x1.1db9e8p+48)) ;; PI
 ;; Test rounding directions.
-(assert_return (invoke "f32.convert_s_i64" (i64.const 16777217)) (f32.const 16777216.0))
-(assert_return (invoke "f32.convert_s_i64" (i64.const -16777217)) (f32.const -16777216.0))
-(assert_return (invoke "f32.convert_s_i64" (i64.const 16777219)) (f32.const 16777220.0))
-(assert_return (invoke "f32.convert_s_i64" (i64.const -16777219)) (f32.const -16777220.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -16777217)) (f32.const -16777216.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_i64_s" (i64.const -16777219)) (f32.const -16777220.0))
 
-(assert_return (invoke "f64.convert_s_i32" (i32.const 1)) (f64.const 1.0))
-(assert_return (invoke "f64.convert_s_i32" (i32.const -1)) (f64.const -1.0))
-(assert_return (invoke "f64.convert_s_i32" (i32.const 0)) (f64.const 0.0))
-(assert_return (invoke "f64.convert_s_i32" (i32.const 2147483647)) (f64.const 2147483647))
-(assert_return (invoke "f64.convert_s_i32" (i32.const -2147483648)) (f64.const -2147483648))
-(assert_return (invoke "f64.convert_s_i32" (i32.const 987654321)) (f64.const 987654321))
+(assert_return (invoke "f64.convert_i32_s" (i32.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i32_s" (i32.const -1)) (f64.const -1.0))
+(assert_return (invoke "f64.convert_i32_s" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i32_s" (i32.const 2147483647)) (f64.const 2147483647))
+(assert_return (invoke "f64.convert_i32_s" (i32.const -2147483648)) (f64.const -2147483648))
+(assert_return (invoke "f64.convert_i32_s" (i32.const 987654321)) (f64.const 987654321))
 
-(assert_return (invoke "f64.convert_s_i64" (i64.const 1)) (f64.const 1.0))
-(assert_return (invoke "f64.convert_s_i64" (i64.const -1)) (f64.const -1.0))
-(assert_return (invoke "f64.convert_s_i64" (i64.const 0)) (f64.const 0.0))
-(assert_return (invoke "f64.convert_s_i64" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
-(assert_return (invoke "f64.convert_s_i64" (i64.const -9223372036854775808)) (f64.const -9223372036854775808))
-(assert_return (invoke "f64.convert_s_i64" (i64.const 4669201609102990)) (f64.const 4669201609102990)) ;; Feigenbaum
+(assert_return (invoke "f64.convert_i64_s" (i64.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -1)) (f64.const -1.0))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -9223372036854775808)) (f64.const -9223372036854775808))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 4669201609102990)) (f64.const 4669201609102990)) ;; Feigenbaum
 ;; Test rounding directions.
-(assert_return (invoke "f64.convert_s_i64" (i64.const 9007199254740993)) (f64.const 9007199254740992))
-(assert_return (invoke "f64.convert_s_i64" (i64.const -9007199254740993)) (f64.const -9007199254740992))
-(assert_return (invoke "f64.convert_s_i64" (i64.const 9007199254740995)) (f64.const 9007199254740996))
-(assert_return (invoke "f64.convert_s_i64" (i64.const -9007199254740995)) (f64.const -9007199254740996))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 9007199254740993)) (f64.const 9007199254740992))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -9007199254740993)) (f64.const -9007199254740992))
+(assert_return (invoke "f64.convert_i64_s" (i64.const 9007199254740995)) (f64.const 9007199254740996))
+(assert_return (invoke "f64.convert_i64_s" (i64.const -9007199254740995)) (f64.const -9007199254740996))
 
-(assert_return (invoke "f32.convert_u_i32" (i32.const 1)) (f32.const 1.0))
-(assert_return (invoke "f32.convert_u_i32" (i32.const 0)) (f32.const 0.0))
-(assert_return (invoke "f32.convert_u_i32" (i32.const 2147483647)) (f32.const 2147483648))
-(assert_return (invoke "f32.convert_u_i32" (i32.const -2147483648)) (f32.const 2147483648))
-(assert_return (invoke "f32.convert_u_i32" (i32.const 0x12345678)) (f32.const 0x1.234568p+28))
-(assert_return (invoke "f32.convert_u_i32" (i32.const 0xffffffff)) (f32.const 4294967296.0))
-(assert_return (invoke "f32.convert_u_i32" (i32.const 0x80000080)) (f32.const 0x1.000000p+31))
-(assert_return (invoke "f32.convert_u_i32" (i32.const 0x80000081)) (f32.const 0x1.000002p+31))
-(assert_return (invoke "f32.convert_u_i32" (i32.const 0x80000082)) (f32.const 0x1.000002p+31))
-(assert_return (invoke "f32.convert_u_i32" (i32.const 0xfffffe80)) (f32.const 0x1.fffffcp+31))
-(assert_return (invoke "f32.convert_u_i32" (i32.const 0xfffffe81)) (f32.const 0x1.fffffep+31))
-(assert_return (invoke "f32.convert_u_i32" (i32.const 0xfffffe82)) (f32.const 0x1.fffffep+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 2147483647)) (f32.const 2147483648))
+(assert_return (invoke "f32.convert_i32_u" (i32.const -2147483648)) (f32.const 2147483648))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x12345678)) (f32.const 0x1.234568p+28))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xffffffff)) (f32.const 4294967296.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000080)) (f32.const 0x1.000000p+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000081)) (f32.const 0x1.000002p+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0x80000082)) (f32.const 0x1.000002p+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe80)) (f32.const 0x1.fffffcp+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe81)) (f32.const 0x1.fffffep+31))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 0xfffffe82)) (f32.const 0x1.fffffep+31))
 ;; Test rounding directions.
-(assert_return (invoke "f32.convert_u_i32" (i32.const 16777217)) (f32.const 16777216.0))
-(assert_return (invoke "f32.convert_u_i32" (i32.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i32_u" (i32.const 16777219)) (f32.const 16777220.0))
 
-(assert_return (invoke "f32.convert_u_i64" (i64.const 1)) (f32.const 1.0))
-(assert_return (invoke "f32.convert_u_i64" (i64.const 0)) (f32.const 0.0))
-(assert_return (invoke "f32.convert_u_i64" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
-(assert_return (invoke "f32.convert_u_i64" (i64.const -9223372036854775808)) (f32.const 9223372036854775808))
-(assert_return (invoke "f32.convert_u_i64" (i64.const 0xffffffffffffffff)) (f32.const 18446744073709551616.0))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 1)) (f32.const 1.0))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0)) (f32.const 0.0))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 9223372036854775807)) (f32.const 9223372036854775807))
+(assert_return (invoke "f32.convert_i64_u" (i64.const -9223372036854775808)) (f32.const 9223372036854775808))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 0xffffffffffffffff)) (f32.const 18446744073709551616.0))
 ;; Test rounding directions.
-(assert_return (invoke "f32.convert_u_i64" (i64.const 16777217)) (f32.const 16777216.0))
-(assert_return (invoke "f32.convert_u_i64" (i64.const 16777219)) (f32.const 16777220.0))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 16777217)) (f32.const 16777216.0))
+(assert_return (invoke "f32.convert_i64_u" (i64.const 16777219)) (f32.const 16777220.0))
 
-(assert_return (invoke "f64.convert_u_i32" (i32.const 1)) (f64.const 1.0))
-(assert_return (invoke "f64.convert_u_i32" (i32.const 0)) (f64.const 0.0))
-(assert_return (invoke "f64.convert_u_i32" (i32.const 2147483647)) (f64.const 2147483647))
-(assert_return (invoke "f64.convert_u_i32" (i32.const -2147483648)) (f64.const 2147483648))
-(assert_return (invoke "f64.convert_u_i32" (i32.const 0xffffffff)) (f64.const 4294967295.0))
+(assert_return (invoke "f64.convert_i32_u" (i32.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i32_u" (i32.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i32_u" (i32.const 2147483647)) (f64.const 2147483647))
+(assert_return (invoke "f64.convert_i32_u" (i32.const -2147483648)) (f64.const 2147483648))
+(assert_return (invoke "f64.convert_i32_u" (i32.const 0xffffffff)) (f64.const 4294967295.0))
 
-(assert_return (invoke "f64.convert_u_i64" (i64.const 1)) (f64.const 1.0))
-(assert_return (invoke "f64.convert_u_i64" (i64.const 0)) (f64.const 0.0))
-(assert_return (invoke "f64.convert_u_i64" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
-(assert_return (invoke "f64.convert_u_i64" (i64.const -9223372036854775808)) (f64.const 9223372036854775808))
-(assert_return (invoke "f64.convert_u_i64" (i64.const 0xffffffffffffffff)) (f64.const 18446744073709551616.0))
-(assert_return (invoke "f64.convert_u_i64" (i64.const 0x8000000000000400)) (f64.const 0x1.0000000000000p+63))
-(assert_return (invoke "f64.convert_u_i64" (i64.const 0x8000000000000401)) (f64.const 0x1.0000000000001p+63))
-(assert_return (invoke "f64.convert_u_i64" (i64.const 0x8000000000000402)) (f64.const 0x1.0000000000001p+63))
-(assert_return (invoke "f64.convert_u_i64" (i64.const 0xfffffffffffff400)) (f64.const 0x1.ffffffffffffep+63))
-(assert_return (invoke "f64.convert_u_i64" (i64.const 0xfffffffffffff401)) (f64.const 0x1.fffffffffffffp+63))
-(assert_return (invoke "f64.convert_u_i64" (i64.const 0xfffffffffffff402)) (f64.const 0x1.fffffffffffffp+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 1)) (f64.const 1.0))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0)) (f64.const 0.0))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 9223372036854775807)) (f64.const 9223372036854775807))
+(assert_return (invoke "f64.convert_i64_u" (i64.const -9223372036854775808)) (f64.const 9223372036854775808))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xffffffffffffffff)) (f64.const 18446744073709551616.0))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000400)) (f64.const 0x1.0000000000000p+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000401)) (f64.const 0x1.0000000000001p+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0x8000000000000402)) (f64.const 0x1.0000000000001p+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff400)) (f64.const 0x1.ffffffffffffep+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff401)) (f64.const 0x1.fffffffffffffp+63))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 0xfffffffffffff402)) (f64.const 0x1.fffffffffffffp+63))
 ;; Test rounding directions.
-(assert_return (invoke "f64.convert_u_i64" (i64.const 9007199254740993)) (f64.const 9007199254740992))
-(assert_return (invoke "f64.convert_u_i64" (i64.const 9007199254740995)) (f64.const 9007199254740996))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 9007199254740993)) (f64.const 9007199254740992))
+(assert_return (invoke "f64.convert_i64_u" (i64.const 9007199254740995)) (f64.const 9007199254740996))
 
 (assert_return (invoke "f64.promote_f32" (f32.const 0.0)) (f64.const 0.0))
 (assert_return (invoke "f64.promote_f32" (f32.const -0.0)) (f64.const -0.0))
diff --git a/test/core/data.wast b/test/core/data.wast
index 46b95436f..32d05f5e8 100644
--- a/test/core/data.wast
+++ b/test/core/data.wast
@@ -50,28 +50,28 @@
 (module
   (global (import "spectest" "global_i32") i32)
   (memory 1)
-  (data (get_global 0) "a")
+  (data (global.get 0) "a")
 )
 (module
   (global (import "spectest" "global_i32") i32)
   (import "spectest" "memory" (memory 1))
-  (data (get_global 0) "a")
+  (data (global.get 0) "a")
 )
 
 (module
   (global $g (import "spectest" "global_i32") i32)
   (memory 1)
-  (data (get_global $g) "a")
+  (data (global.get $g) "a")
 )
 (module
   (global $g (import "spectest" "global_i32") i32)
   (import "spectest" "memory" (memory 1))
-  (data (get_global $g) "a")
+  (data (global.get $g) "a")
 )
 
 ;; Use of internal globals in constant expressions is not allowed in MVP.
-;; (module (memory 1) (data (get_global 0) "a") (global i32 (i32.const 0)))
-;; (module (memory 1) (data (get_global $g) "a") (global $g i32 (i32.const 0)))
+;; (module (memory 1) (data (global.get 0) "a") (global i32 (i32.const 0)))
+;; (module (memory 1) (data (global.get $g) "a") (global $g i32 (i32.const 0)))
 
 ;; Corner cases
 
@@ -137,13 +137,13 @@
 (module
   (global (import "spectest" "global_i32") i32)
   (import "spectest" "memory" (memory 0))
-  (data (get_global 0) "a")
+  (data (global.get 0) "a")
 )
 
 (module
   (global (import "spectest" "global_i32") i32)
   (import "spectest" "memory" (memory 0 3))
-  (data (get_global 0) "a")
+  (data (global.get 0) "a")
 )
 
 (module
@@ -211,7 +211,7 @@
   (module
     (global (import "spectest" "global_i32") i32)
     (memory 0)
-    (data (get_global 0) "a")
+    (data (global.get 0) "a")
   )
   "data segment does not fit"
 )
@@ -330,6 +330,6 @@
 
 ;; Use of internal globals in constant expressions is not allowed in MVP.
 ;; (assert_invalid
-;;   (module (memory 1) (data (get_global $g)) (global $g (mut i32) (i32.const 0)))
+;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
 ;;   "constant expression required"
 ;; )
diff --git a/test/core/elem.wast b/test/core/elem.wast
index 3c204c073..726a27fe2 100644
--- a/test/core/elem.wast
+++ b/test/core/elem.wast
@@ -2,7 +2,7 @@
 
 ;; Syntax
 (module
-  (table $t 10 anyfunc)
+  (table $t 10 funcref)
   (func $f)
   (elem (i32.const 0))
   (elem (i32.const 0) $f $f)
@@ -21,18 +21,18 @@
 ;; Basic use
 
 (module
-  (table 10 anyfunc)
+  (table 10 funcref)
   (func $f)
   (elem (i32.const 0) $f)
 )
 (module
-  (import "spectest" "table" (table 10 anyfunc))
+  (import "spectest" "table" (table 10 funcref))
   (func $f)
   (elem (i32.const 0) $f)
 )
 
 (module
-  (table 10 anyfunc)
+  (table 10 funcref)
   (func $f)
   (elem (i32.const 0) $f)
   (elem (i32.const 3) $f)
@@ -41,7 +41,7 @@
   (elem (i32.const 3) $f)
 )
 (module
-  (import "spectest" "table" (table 10 anyfunc))
+  (import "spectest" "table" (table 10 funcref))
   (func $f)
   (elem (i32.const 9) $f)
   (elem (i32.const 3) $f)
@@ -52,21 +52,21 @@
 
 (module
   (global (import "spectest" "global_i32") i32)
-  (table 1000 anyfunc)
+  (table 1000 funcref)
   (func $f)
-  (elem (get_global 0) $f)
+  (elem (global.get 0) $f)
 )
 
 (module
   (global $g (import "spectest" "global_i32") i32)
-  (table 1000 anyfunc)
+  (table 1000 funcref)
   (func $f)
-  (elem (get_global $g) $f)
+  (elem (global.get $g) $f)
 )
 
 (module
   (type $out-i32 (func (result i32)))
-  (table 10 anyfunc)
+  (table 10 funcref)
   (elem (i32.const 7) $const-i32-a)
   (elem (i32.const 9) $const-i32-b)
   (func $const-i32-a (type $out-i32) (i32.const 65))
@@ -84,55 +84,55 @@
 ;; Corner cases
 
 (module
-  (table 10 anyfunc)
+  (table 10 funcref)
   (func $f)
   (elem (i32.const 9) $f)
 )
 (module
-  (import "spectest" "table" (table 10 anyfunc))
+  (import "spectest" "table" (table 10 funcref))
   (func $f)
   (elem (i32.const 9) $f)
 )
 
 (module
-  (table 0 anyfunc)
+  (table 0 funcref)
   (elem (i32.const 0))
 )
 (module
-  (import "spectest" "table" (table 0 anyfunc))
+  (import "spectest" "table" (table 0 funcref))
   (elem (i32.const 0))
 )
 
 (module
-  (table 0 0 anyfunc)
+  (table 0 0 funcref)
   (elem (i32.const 0))
 )
 
 (module
-  (table 20 anyfunc)
+  (table 20 funcref)
   (elem (i32.const 20))
 )
 
 (module
-  (import "spectest" "table" (table 0 anyfunc))
+  (import "spectest" "table" (table 0 funcref))
   (func $f)
   (elem (i32.const 0) $f)
 )
 
 (module
-  (import "spectest" "table" (table 0 100 anyfunc))
+  (import "spectest" "table" (table 0 100 funcref))
   (func $f)
   (elem (i32.const 0) $f)
 )
 
 (module
-  (import "spectest" "table" (table 0 anyfunc))
+  (import "spectest" "table" (table 0 funcref))
   (func $f)
   (elem (i32.const 1) $f)
 )
 
 (module
-  (import "spectest" "table" (table 0 30 anyfunc))
+  (import "spectest" "table" (table 0 30 funcref))
   (func $f)
   (elem (i32.const 1) $f)
 )
@@ -141,7 +141,7 @@
 
 (assert_unlinkable
   (module
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func $f)
     (elem (i32.const 0) $f)
   )
@@ -150,7 +150,7 @@
 
 (assert_unlinkable
   (module
-    (table 0 0 anyfunc)
+    (table 0 0 funcref)
     (func $f)
     (elem (i32.const 0) $f)
   )
@@ -159,7 +159,7 @@
 
 (assert_unlinkable
   (module
-    (table 0 1 anyfunc)
+    (table 0 1 funcref)
     (func $f)
     (elem (i32.const 0) $f)
   )
@@ -168,7 +168,7 @@
 
 (assert_unlinkable
   (module
-    (table 0 anyfunc)
+    (table 0 funcref)
     (elem (i32.const 1))
   )
   "elements segment does not fit"
@@ -176,7 +176,7 @@
 
 (assert_unlinkable
   (module
-    (table 10 anyfunc)
+    (table 10 funcref)
     (func $f)
     (elem (i32.const 10) $f)
   )
@@ -184,7 +184,7 @@
 )
 (assert_unlinkable
   (module
-    (import "spectest" "table" (table 10 anyfunc))
+    (import "spectest" "table" (table 10 funcref))
     (func $f)
     (elem (i32.const 10) $f)
   )
@@ -193,7 +193,7 @@
 
 (assert_unlinkable
   (module
-    (table 10 20 anyfunc)
+    (table 10 20 funcref)
     (func $f)
     (elem (i32.const 10) $f)
   )
@@ -201,7 +201,7 @@
 )
 (assert_unlinkable
   (module
-    (import "spectest" "table" (table 10 anyfunc))
+    (import "spectest" "table" (table 10 funcref))
     (func $f)
     (elem (i32.const 10) $f)
   )
@@ -210,7 +210,7 @@
 
 (assert_unlinkable
   (module
-    (table 10 anyfunc)
+    (table 10 funcref)
     (func $f)
     (elem (i32.const -1) $f)
   )
@@ -218,7 +218,7 @@
 )
 (assert_unlinkable
   (module
-    (import "spectest" "table" (table 10 anyfunc))
+    (import "spectest" "table" (table 10 funcref))
     (func $f)
     (elem (i32.const -1) $f)
   )
@@ -227,7 +227,7 @@
 
 (assert_unlinkable
   (module
-    (table 10 anyfunc)
+    (table 10 funcref)
     (func $f)
     (elem (i32.const -10) $f)
   )
@@ -235,7 +235,7 @@
 )
 (assert_unlinkable
   (module
-    (import "spectest" "table" (table 10 anyfunc))
+    (import "spectest" "table" (table 10 funcref))
     (func $f)
     (elem (i32.const -10) $f)
   )
@@ -256,7 +256,7 @@
 
 (assert_invalid
   (module
-    (table 1 anyfunc)
+    (table 1 funcref)
     (elem (i64.const 0))
   )
   "type mismatch"
@@ -264,7 +264,7 @@
 
 (assert_invalid
   (module
-    (table 1 anyfunc)
+    (table 1 funcref)
     (elem (i32.ctz (i32.const 0)))
   )
   "constant expression required"
@@ -272,7 +272,7 @@
 
 (assert_invalid
   (module
-    (table 1 anyfunc)
+    (table 1 funcref)
     (elem (nop))
   )
   "constant expression required"
@@ -280,7 +280,7 @@
 
 (assert_invalid
   (module
-    (table 1 anyfunc)
+    (table 1 funcref)
     (elem (offset (nop) (i32.const 0)))
   )
   "constant expression required"
@@ -288,7 +288,7 @@
 
 (assert_invalid
   (module
-    (table 1 anyfunc)
+    (table 1 funcref)
     (elem (offset (i32.const 0) (nop)))
   )
   "constant expression required"
@@ -296,7 +296,7 @@
 
 ;; Use of internal globals in constant expressions is not allowed in MVP.
 ;; (assert_invalid
-;;   (module (memory 1) (data (get_global $g)) (global $g (mut i32) (i32.const 0)))
+;;   (module (memory 1) (data (global.get $g)) (global $g (mut i32) (i32.const 0)))
 ;;   "constant expression required"
 ;; )
 
@@ -304,7 +304,7 @@
 
 (module
   (type $out-i32 (func (result i32)))
-  (table 10 anyfunc)
+  (table 10 funcref)
   (elem (i32.const 9) $const-i32-a)
   (elem (i32.const 9) $const-i32-b)
   (func $const-i32-a (type $out-i32) (i32.const 65))
@@ -317,7 +317,7 @@
 
 (module
   (type $out-i32 (func (result i32)))
-  (import "spectest" "table" (table 10 anyfunc))
+  (import "spectest" "table" (table 10 funcref))
   (elem (i32.const 9) $const-i32-a)
   (elem (i32.const 9) $const-i32-b)
   (func $const-i32-a (type $out-i32) (i32.const 65))
@@ -332,7 +332,7 @@
 
 (module $module1
   (type $out-i32 (func (result i32)))
-  (table (export "shared-table") 10 anyfunc)
+  (table (export "shared-table") 10 funcref)
   (elem (i32.const 8) $const-i32-a)
   (elem (i32.const 9) $const-i32-b)
   (func $const-i32-a (type $out-i32) (i32.const 65))
@@ -356,7 +356,7 @@
 
 (module $module2
   (type $out-i32 (func (result i32)))
-  (import "module1" "shared-table" (table 10 anyfunc))
+  (import "module1" "shared-table" (table 10 funcref))
   (elem (i32.const 7) $const-i32-c)
   (elem (i32.const 8) $const-i32-d)
   (func $const-i32-c (type $out-i32) (i32.const 67))
@@ -369,7 +369,7 @@
 
 (module $module3
   (type $out-i32 (func (result i32)))
-  (import "module1" "shared-table" (table 10 anyfunc))
+  (import "module1" "shared-table" (table 10 funcref))
   (elem (i32.const 8) $const-i32-e)
   (elem (i32.const 9) $const-i32-f)
   (func $const-i32-e (type $out-i32) (i32.const 69))
diff --git a/test/core/endianness.wast b/test/core/endianness.wast
index 8dc0c2e2e..4f28a168f 100644
--- a/test/core/endianness.wast
+++ b/test/core/endianness.wast
@@ -3,130 +3,130 @@
 
   ;; Stores an i16 value in little-endian-format
   (func $i16_store_little (param $address i32) (param $value i32)
-    (i32.store8 (get_local $address) (get_local $value))
-    (i32.store8 (i32.add (get_local $address) (i32.const 1)) (i32.shr_u (get_local $value) (i32.const 8)))
+    (i32.store8 (local.get $address) (local.get $value))
+    (i32.store8 (i32.add (local.get $address) (i32.const 1)) (i32.shr_u (local.get $value) (i32.const 8)))
   )
 
   ;; Stores an i32 value in little-endian format
   (func $i32_store_little (param $address i32) (param $value i32)
-    (call $i16_store_little (get_local $address) (get_local $value))
-    (call $i16_store_little (i32.add (get_local $address) (i32.const 2)) (i32.shr_u (get_local $value) (i32.const 16)))
+    (call $i16_store_little (local.get $address) (local.get $value))
+    (call $i16_store_little (i32.add (local.get $address) (i32.const 2)) (i32.shr_u (local.get $value) (i32.const 16)))
   )
 
   ;; Stores an i64 value in little-endian format
   (func $i64_store_little (param $address i32) (param $value i64)
-    (call $i32_store_little (get_local $address) (i32.wrap/i64 (get_local $value)))
-    (call $i32_store_little (i32.add (get_local $address) (i32.const 4)) (i32.wrap/i64 (i64.shr_u (get_local $value) (i64.const 32))))
+    (call $i32_store_little (local.get $address) (i32.wrap_i64 (local.get $value)))
+    (call $i32_store_little (i32.add (local.get $address) (i32.const 4)) (i32.wrap_i64 (i64.shr_u (local.get $value) (i64.const 32))))
   )
 
   ;; Loads an i16 value in little-endian format
   (func $i16_load_little (param $address i32) (result i32)
     (i32.or
-      (i32.load8_u (get_local $address))
-      (i32.shl (i32.load8_u (i32.add (get_local $address) (i32.const 1))) (i32.const 8))
+      (i32.load8_u (local.get $address))
+      (i32.shl (i32.load8_u (i32.add (local.get $address) (i32.const 1))) (i32.const 8))
     )
   )
 
   ;; Loads an i32 value in little-endian format
   (func $i32_load_little (param $address i32) (result i32)
     (i32.or
-      (call $i16_load_little (get_local $address))
-      (i32.shl (call $i16_load_little (i32.add (get_local $address) (i32.const 2))) (i32.const 16))
+      (call $i16_load_little (local.get $address))
+      (i32.shl (call $i16_load_little (i32.add (local.get $address) (i32.const 2))) (i32.const 16))
     )
   )
 
   ;; Loads an i64 value in little-endian format
   (func $i64_load_little (param $address i32) (result i64)
     (i64.or
-      (i64.extend_u/i32 (call $i32_load_little (get_local $address)))
-      (i64.shl (i64.extend_u/i32 (call $i32_load_little (i32.add (get_local $address) (i32.const 4)))) (i64.const 32))
+      (i64.extend_i32_u (call $i32_load_little (local.get $address)))
+      (i64.shl (i64.extend_i32_u (call $i32_load_little (i32.add (local.get $address) (i32.const 4)))) (i64.const 32))
     )
   )
 
   (func (export "i32_load16_s") (param $value i32) (result i32)
-    (call $i16_store_little (i32.const 0) (get_local $value))
+    (call $i16_store_little (i32.const 0) (local.get $value))
     (i32.load16_s (i32.const 0))
   )
 
   (func (export "i32_load16_u") (param $value i32) (result i32)
-    (call $i16_store_little (i32.const 0) (get_local $value))
+    (call $i16_store_little (i32.const 0) (local.get $value))
     (i32.load16_u (i32.const 0))
   )
 
   (func (export "i32_load") (param $value i32) (result i32)
-    (call $i32_store_little (i32.const 0) (get_local $value))
+    (call $i32_store_little (i32.const 0) (local.get $value))
     (i32.load (i32.const 0))
   )
 
   (func (export "i64_load16_s") (param $value i64) (result i64)
-    (call $i16_store_little (i32.const 0) (i32.wrap/i64 (get_local $value)))
+    (call $i16_store_little (i32.const 0) (i32.wrap_i64 (local.get $value)))
     (i64.load16_s (i32.const 0))
   )
 
   (func (export "i64_load16_u") (param $value i64) (result i64)
-    (call $i16_store_little (i32.const 0) (i32.wrap/i64 (get_local $value)))
+    (call $i16_store_little (i32.const 0) (i32.wrap_i64 (local.get $value)))
     (i64.load16_u (i32.const 0))
   )
 
   (func (export "i64_load32_s") (param $value i64) (result i64)
-    (call $i32_store_little (i32.const 0) (i32.wrap/i64 (get_local $value)))
+    (call $i32_store_little (i32.const 0) (i32.wrap_i64 (local.get $value)))
     (i64.load32_s (i32.const 0))
   )
 
   (func (export "i64_load32_u") (param $value i64) (result i64)
-    (call $i32_store_little (i32.const 0) (i32.wrap/i64 (get_local $value)))
+    (call $i32_store_little (i32.const 0) (i32.wrap_i64 (local.get $value)))
     (i64.load32_u (i32.const 0))
   )
 
   (func (export "i64_load") (param $value i64) (result i64)
-    (call $i64_store_little (i32.const 0) (get_local $value))
+    (call $i64_store_little (i32.const 0) (local.get $value))
     (i64.load (i32.const 0))
   )
 
   (func (export "f32_load") (param $value f32) (result f32)
-    (call $i32_store_little (i32.const 0) (i32.reinterpret/f32 (get_local $value)))
+    (call $i32_store_little (i32.const 0) (i32.reinterpret_f32 (local.get $value)))
     (f32.load (i32.const 0))
   )
 
   (func (export "f64_load") (param $value f64) (result f64)
-    (call $i64_store_little (i32.const 0) (i64.reinterpret/f64 (get_local $value)))
+    (call $i64_store_little (i32.const 0) (i64.reinterpret_f64 (local.get $value)))
     (f64.load (i32.const 0))
   )
 
 
   (func (export "i32_store16") (param $value i32) (result i32)
-    (i32.store16 (i32.const 0) (get_local $value))
+    (i32.store16 (i32.const 0) (local.get $value))
     (call $i16_load_little (i32.const 0))
   )
 
   (func (export "i32_store") (param $value i32) (result i32)
-    (i32.store (i32.const 0) (get_local $value))
+    (i32.store (i32.const 0) (local.get $value))
     (call $i32_load_little (i32.const 0))
   )
 
   (func (export "i64_store16") (param $value i64) (result i64)
-    (i64.store16 (i32.const 0) (get_local $value))
-    (i64.extend_u/i32 (call $i16_load_little (i32.const 0)))
+    (i64.store16 (i32.const 0) (local.get $value))
+    (i64.extend_i32_u (call $i16_load_little (i32.const 0)))
   )
 
   (func (export "i64_store32") (param $value i64) (result i64)
-    (i64.store32 (i32.const 0) (get_local $value))
-    (i64.extend_u/i32 (call $i32_load_little (i32.const 0)))
+    (i64.store32 (i32.const 0) (local.get $value))
+    (i64.extend_i32_u (call $i32_load_little (i32.const 0)))
   )
 
   (func (export "i64_store") (param $value i64) (result i64)
-    (i64.store (i32.const 0) (get_local $value))
+    (i64.store (i32.const 0) (local.get $value))
     (call $i64_load_little (i32.const 0))
   )
 
   (func (export "f32_store") (param $value f32) (result f32)
-    (f32.store (i32.const 0) (get_local $value))
-    (f32.reinterpret/i32 (call $i32_load_little (i32.const 0)))
+    (f32.store (i32.const 0) (local.get $value))
+    (f32.reinterpret_i32 (call $i32_load_little (i32.const 0)))
   )
 
   (func (export "f64_store") (param $value f64) (result f64)
-    (f64.store (i32.const 0) (get_local $value))
-    (f64.reinterpret/i64 (call $i64_load_little (i32.const 0)))
+    (f64.store (i32.const 0) (local.get $value))
+    (f64.reinterpret_i64 (call $i64_load_little (i32.const 0)))
   )
 )
 
diff --git a/test/core/exports.wast b/test/core/exports.wast
index 6841aa873..ef1c4c17e 100644
--- a/test/core/exports.wast
+++ b/test/core/exports.wast
@@ -16,7 +16,7 @@
 (module $Func
   (export "e" (func $f))
   (func $f (param $n i32) (result i32)
-    (return (i32.add (get_local $n) (i32.const 1)))
+    (return (i32.add (local.get $n) (i32.const 1)))
   )
 )
 (assert_return (invoke "e" (i32.const 42)) (i32.const 43))
@@ -42,7 +42,7 @@
   "duplicate export name"
 )
 (assert_invalid
-  (module (func) (table 0 anyfunc) (export "a" (func 0)) (export "a" (table 0)))
+  (module (func) (table 0 funcref) (export "a" (func 0)) (export "a" (table 0)))
   "duplicate export name"
 )
 (assert_invalid
@@ -91,7 +91,7 @@
   "duplicate export name"
 )
 (assert_invalid
-  (module (global i32 (i32.const 0)) (table 0 anyfunc) (export "a" (global 0)) (export "a" (table 0)))
+  (module (global i32 (i32.const 0)) (table 0 funcref) (export "a" (global 0)) (export "a" (table 0)))
   "duplicate export name"
 )
 (assert_invalid
@@ -102,49 +102,49 @@
 
 ;; Tables
 
-(module (table 0 anyfunc) (export "a" (table 0)))
-(module (table 0 anyfunc) (export "a" (table 0)) (export "b" (table 0)))
+(module (table 0 funcref) (export "a" (table 0)))
+(module (table 0 funcref) (export "a" (table 0)) (export "b" (table 0)))
 ;; No multiple tables yet.
-;; (module (table 0 anyfunc) (table 0 anyfunc) (export "a" (table 0)) (export "b" (table 1)))
-
-(module (table (export "a") 0 anyfunc))
-(module (table (export "a") 0 1 anyfunc))
-(module (table 0 anyfunc) (export "a" (table 0)))
-(module (table 0 1 anyfunc) (export "a" (table 0)))
-(module (table $a (export "a") 0 anyfunc))
-(module (table $a (export "a") 0 1 anyfunc))
-(module (table $a 0 anyfunc) (export "a" (table $a)))
-(module (table $a 0 1 anyfunc) (export "a" (table $a)))
-(module (export "a" (table 0)) (table 0 anyfunc))
-(module (export "a" (table 0)) (table 0 1 anyfunc))
-(module (export "a" (table $a)) (table $a 0 anyfunc))
-(module (export "a" (table $a)) (table $a 0 1 anyfunc))
+;; (module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "b" (table 1)))
+
+(module (table (export "a") 0 funcref))
+(module (table (export "a") 0 1 funcref))
+(module (table 0 funcref) (export "a" (table 0)))
+(module (table 0 1 funcref) (export "a" (table 0)))
+(module (table $a (export "a") 0 funcref))
+(module (table $a (export "a") 0 1 funcref))
+(module (table $a 0 funcref) (export "a" (table $a)))
+(module (table $a 0 1 funcref) (export "a" (table $a)))
+(module (export "a" (table 0)) (table 0 funcref))
+(module (export "a" (table 0)) (table 0 1 funcref))
+(module (export "a" (table $a)) (table $a 0 funcref))
+(module (export "a" (table $a)) (table $a 0 1 funcref))
 
 (; TODO: access table ;)
 
 (assert_invalid
-  (module (table 0 anyfunc) (export "a" (table 1)))
+  (module (table 0 funcref) (export "a" (table 1)))
   "unknown table"
 )
 (assert_invalid
-  (module (table 0 anyfunc) (export "a" (table 0)) (export "a" (table 0)))
+  (module (table 0 funcref) (export "a" (table 0)) (export "a" (table 0)))
   "duplicate export name"
 )
 ;; No multiple tables yet.
 ;; (assert_invalid
-;;   (module (table 0 anyfunc) (table 0 anyfunc) (export "a" (table 0)) (export "a" (table 1)))
+;;   (module (table 0 funcref) (table 0 funcref) (export "a" (table 0)) (export "a" (table 1)))
 ;;   "duplicate export name"
 ;; )
 (assert_invalid
-  (module (table 0 anyfunc) (func) (export "a" (table 0)) (export "a" (func 0)))
+  (module (table 0 funcref) (func) (export "a" (table 0)) (export "a" (func 0)))
   "duplicate export name"
 )
 (assert_invalid
-  (module (table 0 anyfunc) (global i32 (i32.const 0)) (export "a" (table 0)) (export "a" (global 0)))
+  (module (table 0 funcref) (global i32 (i32.const 0)) (export "a" (table 0)) (export "a" (global 0)))
   "duplicate export name"
 )
 (assert_invalid
-  (module (table 0 anyfunc) (memory 0) (export "a" (table 0)) (export "a" (memory 0)))
+  (module (table 0 funcref) (memory 0) (export "a" (table 0)) (export "a" (memory 0)))
   "duplicate export name"
 )
 
@@ -193,6 +193,6 @@
   "duplicate export name"
 )
 (assert_invalid
-  (module (memory 0) (table 0 anyfunc) (export "a" (memory 0)) (export "a" (table 0)))
+  (module (memory 0) (table 0 funcref) (export "a" (memory 0)) (export "a" (table 0)))
   "duplicate export name"
 )
diff --git a/test/core/f32.wast b/test/core/f32.wast
index 2595a4ac9..f25ab91e4 100644
--- a/test/core/f32.wast
+++ b/test/core/f32.wast
@@ -3,17 +3,17 @@
 ;; f32_bitwise.wast and f32_cmp.wast).
 
 (module
-  (func (export "add") (param $x f32) (param $y f32) (result f32) (f32.add (get_local $x) (get_local $y)))
-  (func (export "sub") (param $x f32) (param $y f32) (result f32) (f32.sub (get_local $x) (get_local $y)))
-  (func (export "mul") (param $x f32) (param $y f32) (result f32) (f32.mul (get_local $x) (get_local $y)))
-  (func (export "div") (param $x f32) (param $y f32) (result f32) (f32.div (get_local $x) (get_local $y)))
-  (func (export "sqrt") (param $x f32) (result f32) (f32.sqrt (get_local $x)))
-  (func (export "min") (param $x f32) (param $y f32) (result f32) (f32.min (get_local $x) (get_local $y)))
-  (func (export "max") (param $x f32) (param $y f32) (result f32) (f32.max (get_local $x) (get_local $y)))
-  (func (export "ceil") (param $x f32) (result f32) (f32.ceil (get_local $x)))
-  (func (export "floor") (param $x f32) (result f32) (f32.floor (get_local $x)))
-  (func (export "trunc") (param $x f32) (result f32) (f32.trunc (get_local $x)))
-  (func (export "nearest") (param $x f32) (result f32) (f32.nearest (get_local $x)))
+  (func (export "add") (param $x f32) (param $y f32) (result f32) (f32.add (local.get $x) (local.get $y)))
+  (func (export "sub") (param $x f32) (param $y f32) (result f32) (f32.sub (local.get $x) (local.get $y)))
+  (func (export "mul") (param $x f32) (param $y f32) (result f32) (f32.mul (local.get $x) (local.get $y)))
+  (func (export "div") (param $x f32) (param $y f32) (result f32) (f32.div (local.get $x) (local.get $y)))
+  (func (export "sqrt") (param $x f32) (result f32) (f32.sqrt (local.get $x)))
+  (func (export "min") (param $x f32) (param $y f32) (result f32) (f32.min (local.get $x) (local.get $y)))
+  (func (export "max") (param $x f32) (param $y f32) (result f32) (f32.max (local.get $x) (local.get $y)))
+  (func (export "ceil") (param $x f32) (result f32) (f32.ceil (local.get $x)))
+  (func (export "floor") (param $x f32) (result f32) (f32.floor (local.get $x)))
+  (func (export "trunc") (param $x f32) (result f32) (f32.trunc (local.get $x)))
+  (func (export "nearest") (param $x f32) (result f32) (f32.nearest (local.get $x)))
 )
 
 (assert_return (invoke "add" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
diff --git a/test/core/f32_bitwise.wast b/test/core/f32_bitwise.wast
index 12bdb866e..ceee8981e 100644
--- a/test/core/f32_bitwise.wast
+++ b/test/core/f32_bitwise.wast
@@ -2,9 +2,9 @@
 ;; values.
 
 (module
-  (func (export "abs") (param $x f32) (result f32) (f32.abs (get_local $x)))
-  (func (export "neg") (param $x f32) (result f32) (f32.neg (get_local $x)))
-  (func (export "copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (get_local $x) (get_local $y)))
+  (func (export "abs") (param $x f32) (result f32) (f32.abs (local.get $x)))
+  (func (export "neg") (param $x f32) (result f32) (f32.neg (local.get $x)))
+  (func (export "copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (local.get $x) (local.get $y)))
 )
 
 (assert_return (invoke "copysign" (f32.const -0x0p+0) (f32.const -0x0p+0)) (f32.const -0x0p+0))
diff --git a/test/core/f32_cmp.wast b/test/core/f32_cmp.wast
index 5bae18bcd..e01153fea 100644
--- a/test/core/f32_cmp.wast
+++ b/test/core/f32_cmp.wast
@@ -2,12 +2,12 @@
 ;; special values.
 
 (module
-  (func (export "eq") (param $x f32) (param $y f32) (result i32) (f32.eq (get_local $x) (get_local $y)))
-  (func (export "ne") (param $x f32) (param $y f32) (result i32) (f32.ne (get_local $x) (get_local $y)))
-  (func (export "lt") (param $x f32) (param $y f32) (result i32) (f32.lt (get_local $x) (get_local $y)))
-  (func (export "le") (param $x f32) (param $y f32) (result i32) (f32.le (get_local $x) (get_local $y)))
-  (func (export "gt") (param $x f32) (param $y f32) (result i32) (f32.gt (get_local $x) (get_local $y)))
-  (func (export "ge") (param $x f32) (param $y f32) (result i32) (f32.ge (get_local $x) (get_local $y)))
+  (func (export "eq") (param $x f32) (param $y f32) (result i32) (f32.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x f32) (param $y f32) (result i32) (f32.ne (local.get $x) (local.get $y)))
+  (func (export "lt") (param $x f32) (param $y f32) (result i32) (f32.lt (local.get $x) (local.get $y)))
+  (func (export "le") (param $x f32) (param $y f32) (result i32) (f32.le (local.get $x) (local.get $y)))
+  (func (export "gt") (param $x f32) (param $y f32) (result i32) (f32.gt (local.get $x) (local.get $y)))
+  (func (export "ge") (param $x f32) (param $y f32) (result i32) (f32.ge (local.get $x) (local.get $y)))
 )
 
 (assert_return (invoke "eq" (f32.const -0x0p+0) (f32.const -0x0p+0)) (i32.const 1))
diff --git a/test/core/f64.wast b/test/core/f64.wast
index 50db4e708..0c48574e1 100644
--- a/test/core/f64.wast
+++ b/test/core/f64.wast
@@ -3,17 +3,17 @@
 ;; f64_bitwise.wast and f64_cmp.wast).
 
 (module
-  (func (export "add") (param $x f64) (param $y f64) (result f64) (f64.add (get_local $x) (get_local $y)))
-  (func (export "sub") (param $x f64) (param $y f64) (result f64) (f64.sub (get_local $x) (get_local $y)))
-  (func (export "mul") (param $x f64) (param $y f64) (result f64) (f64.mul (get_local $x) (get_local $y)))
-  (func (export "div") (param $x f64) (param $y f64) (result f64) (f64.div (get_local $x) (get_local $y)))
-  (func (export "sqrt") (param $x f64) (result f64) (f64.sqrt (get_local $x)))
-  (func (export "min") (param $x f64) (param $y f64) (result f64) (f64.min (get_local $x) (get_local $y)))
-  (func (export "max") (param $x f64) (param $y f64) (result f64) (f64.max (get_local $x) (get_local $y)))
-  (func (export "ceil") (param $x f64) (result f64) (f64.ceil (get_local $x)))
-  (func (export "floor") (param $x f64) (result f64) (f64.floor (get_local $x)))
-  (func (export "trunc") (param $x f64) (result f64) (f64.trunc (get_local $x)))
-  (func (export "nearest") (param $x f64) (result f64) (f64.nearest (get_local $x)))
+  (func (export "add") (param $x f64) (param $y f64) (result f64) (f64.add (local.get $x) (local.get $y)))
+  (func (export "sub") (param $x f64) (param $y f64) (result f64) (f64.sub (local.get $x) (local.get $y)))
+  (func (export "mul") (param $x f64) (param $y f64) (result f64) (f64.mul (local.get $x) (local.get $y)))
+  (func (export "div") (param $x f64) (param $y f64) (result f64) (f64.div (local.get $x) (local.get $y)))
+  (func (export "sqrt") (param $x f64) (result f64) (f64.sqrt (local.get $x)))
+  (func (export "min") (param $x f64) (param $y f64) (result f64) (f64.min (local.get $x) (local.get $y)))
+  (func (export "max") (param $x f64) (param $y f64) (result f64) (f64.max (local.get $x) (local.get $y)))
+  (func (export "ceil") (param $x f64) (result f64) (f64.ceil (local.get $x)))
+  (func (export "floor") (param $x f64) (result f64) (f64.floor (local.get $x)))
+  (func (export "trunc") (param $x f64) (result f64) (f64.trunc (local.get $x)))
+  (func (export "nearest") (param $x f64) (result f64) (f64.nearest (local.get $x)))
 )
 
 (assert_return (invoke "add" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
diff --git a/test/core/f64_bitwise.wast b/test/core/f64_bitwise.wast
index 86c64b54d..ca06b3220 100644
--- a/test/core/f64_bitwise.wast
+++ b/test/core/f64_bitwise.wast
@@ -2,9 +2,9 @@
 ;; values.
 
 (module
-  (func (export "abs") (param $x f64) (result f64) (f64.abs (get_local $x)))
-  (func (export "neg") (param $x f64) (result f64) (f64.neg (get_local $x)))
-  (func (export "copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (get_local $x) (get_local $y)))
+  (func (export "abs") (param $x f64) (result f64) (f64.abs (local.get $x)))
+  (func (export "neg") (param $x f64) (result f64) (f64.neg (local.get $x)))
+  (func (export "copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (local.get $x) (local.get $y)))
 )
 
 (assert_return (invoke "copysign" (f64.const -0x0p+0) (f64.const -0x0p+0)) (f64.const -0x0p+0))
diff --git a/test/core/f64_cmp.wast b/test/core/f64_cmp.wast
index 8fe9be4e5..9cb378cd8 100644
--- a/test/core/f64_cmp.wast
+++ b/test/core/f64_cmp.wast
@@ -2,12 +2,12 @@
 ;; special values.
 
 (module
-  (func (export "eq") (param $x f64) (param $y f64) (result i32) (f64.eq (get_local $x) (get_local $y)))
-  (func (export "ne") (param $x f64) (param $y f64) (result i32) (f64.ne (get_local $x) (get_local $y)))
-  (func (export "lt") (param $x f64) (param $y f64) (result i32) (f64.lt (get_local $x) (get_local $y)))
-  (func (export "le") (param $x f64) (param $y f64) (result i32) (f64.le (get_local $x) (get_local $y)))
-  (func (export "gt") (param $x f64) (param $y f64) (result i32) (f64.gt (get_local $x) (get_local $y)))
-  (func (export "ge") (param $x f64) (param $y f64) (result i32) (f64.ge (get_local $x) (get_local $y)))
+  (func (export "eq") (param $x f64) (param $y f64) (result i32) (f64.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x f64) (param $y f64) (result i32) (f64.ne (local.get $x) (local.get $y)))
+  (func (export "lt") (param $x f64) (param $y f64) (result i32) (f64.lt (local.get $x) (local.get $y)))
+  (func (export "le") (param $x f64) (param $y f64) (result i32) (f64.le (local.get $x) (local.get $y)))
+  (func (export "gt") (param $x f64) (param $y f64) (result i32) (f64.gt (local.get $x) (local.get $y)))
+  (func (export "ge") (param $x f64) (param $y f64) (result i32) (f64.ge (local.get $x) (local.get $y)))
 )
 
 (assert_return (invoke "eq" (f64.const -0x0p+0) (f64.const -0x0p+0)) (i32.const 1))
diff --git a/test/core/fac.wast b/test/core/fac.wast
index acc896231..ef10991a8 100644
--- a/test/core/fac.wast
+++ b/test/core/fac.wast
@@ -1,22 +1,22 @@
 (module
   ;; Recursive factorial
   (func (export "fac-rec") (param i64) (result i64)
-    (if (result i64) (i64.eq (get_local 0) (i64.const 0))
+    (if (result i64) (i64.eq (local.get 0) (i64.const 0))
       (then (i64.const 1))
       (else
-        (i64.mul (get_local 0) (call 0 (i64.sub (get_local 0) (i64.const 1))))
+        (i64.mul (local.get 0) (call 0 (i64.sub (local.get 0) (i64.const 1))))
       )
     )
   )
 
   ;; Recursive factorial named
   (func $fac-rec-named (export "fac-rec-named") (param $n i64) (result i64)
-    (if (result i64) (i64.eq (get_local $n) (i64.const 0))
+    (if (result i64) (i64.eq (local.get $n) (i64.const 0))
       (then (i64.const 1))
       (else
         (i64.mul
-          (get_local $n)
-          (call $fac-rec-named (i64.sub (get_local $n) (i64.const 1)))
+          (local.get $n)
+          (call $fac-rec-named (i64.sub (local.get $n) (i64.const 1)))
         )
       )
     )
@@ -25,59 +25,59 @@
   ;; Iterative factorial
   (func (export "fac-iter") (param i64) (result i64)
     (local i64 i64)
-    (set_local 1 (get_local 0))
-    (set_local 2 (i64.const 1))
+    (local.set 1 (local.get 0))
+    (local.set 2 (i64.const 1))
     (block
       (loop
         (if
-          (i64.eq (get_local 1) (i64.const 0))
+          (i64.eq (local.get 1) (i64.const 0))
           (then (br 2))
           (else
-            (set_local 2 (i64.mul (get_local 1) (get_local 2)))
-            (set_local 1 (i64.sub (get_local 1) (i64.const 1)))
+            (local.set 2 (i64.mul (local.get 1) (local.get 2)))
+            (local.set 1 (i64.sub (local.get 1) (i64.const 1)))
           )
         )
         (br 0)
       )
     )
-    (get_local 2)
+    (local.get 2)
   )
 
   ;; Iterative factorial named
   (func (export "fac-iter-named") (param $n i64) (result i64)
     (local $i i64)
     (local $res i64)
-    (set_local $i (get_local $n))
-    (set_local $res (i64.const 1))
+    (local.set $i (local.get $n))
+    (local.set $res (i64.const 1))
     (block $done
       (loop $loop
         (if
-          (i64.eq (get_local $i) (i64.const 0))
+          (i64.eq (local.get $i) (i64.const 0))
           (then (br $done))
           (else
-            (set_local $res (i64.mul (get_local $i) (get_local $res)))
-            (set_local $i (i64.sub (get_local $i) (i64.const 1)))
+            (local.set $res (i64.mul (local.get $i) (local.get $res)))
+            (local.set $i (i64.sub (local.get $i) (i64.const 1)))
           )
         )
         (br $loop)
       )
     )
-    (get_local $res)
+    (local.get $res)
   )
 
   ;; Optimized factorial.
   (func (export "fac-opt") (param i64) (result i64)
     (local i64)
-    (set_local 1 (i64.const 1))
+    (local.set 1 (i64.const 1))
     (block
-      (br_if 0 (i64.lt_s (get_local 0) (i64.const 2)))
+      (br_if 0 (i64.lt_s (local.get 0) (i64.const 2)))
       (loop
-        (set_local 1 (i64.mul (get_local 1) (get_local 0)))
-        (set_local 0 (i64.add (get_local 0) (i64.const -1)))
-        (br_if 0 (i64.gt_s (get_local 0) (i64.const 1)))
+        (local.set 1 (i64.mul (local.get 1) (local.get 0)))
+        (local.set 0 (i64.add (local.get 0) (i64.const -1)))
+        (br_if 0 (i64.gt_s (local.get 0) (i64.const 1)))
       )
     )
-    (get_local 1)
+    (local.get 1)
   )
 )
 
diff --git a/test/core/float_exprs.wast b/test/core/float_exprs.wast
index 0351de782..e6583634f 100644
--- a/test/core/float_exprs.wast
+++ b/test/core/float_exprs.wast
@@ -5,7 +5,7 @@
 
 (module
   (func (export "f64.no_contraction") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.add (f64.mul (get_local $x) (get_local $y)) (get_local $z)))
+    (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
 )
 
 (assert_return (invoke "f64.no_contraction" (f64.const -0x1.9e87ce14273afp-103) (f64.const 0x1.2515ad31db63ep+664) (f64.const 0x1.868c6685e6185p+533)) (f64.const -0x1.da94885b11493p+561))
@@ -18,9 +18,9 @@
 
 (module
   (func (export "f32.no_fma") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.add (f32.mul (get_local $x) (get_local $y)) (get_local $z)))
+    (f32.add (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
   (func (export "f64.no_fma") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.add (f64.mul (get_local $x) (get_local $y)) (get_local $z)))
+    (f64.add (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
 )
 
 (assert_return (invoke "f32.no_fma" (f32.const 0x1.a78402p+124) (f32.const 0x1.cf8548p-23) (f32.const 0x1.992adap+107)) (f32.const 0x1.a5262cp+107))
@@ -39,9 +39,9 @@
 
 (module
   (func (export "f32.no_fold_add_zero") (param $x f32) (result f32)
-    (f32.add (get_local $x) (f32.const 0.0)))
+    (f32.add (local.get $x) (f32.const 0.0)))
   (func (export "f64.no_fold_add_zero") (param $x f64) (result f64)
-    (f64.add (get_local $x) (f64.const 0.0)))
+    (f64.add (local.get $x) (f64.const 0.0)))
 )
 
 (assert_return (invoke "f32.no_fold_add_zero" (f32.const -0.0)) (f32.const 0.0))
@@ -53,9 +53,9 @@
 
 (module
   (func (export "f32.no_fold_zero_sub") (param $x f32) (result f32)
-    (f32.sub (f32.const 0.0) (get_local $x)))
+    (f32.sub (f32.const 0.0) (local.get $x)))
   (func (export "f64.no_fold_zero_sub") (param $x f64) (result f64)
-    (f64.sub (f64.const 0.0) (get_local $x)))
+    (f64.sub (f64.const 0.0) (local.get $x)))
 )
 
 (assert_return (invoke "f32.no_fold_zero_sub" (f32.const 0.0)) (f32.const 0.0))
@@ -67,9 +67,9 @@
 
 (module
   (func (export "f32.no_fold_sub_zero") (param $x f32) (result f32)
-    (f32.sub (get_local $x) (f32.const 0.0)))
+    (f32.sub (local.get $x) (f32.const 0.0)))
   (func (export "f64.no_fold_sub_zero") (param $x f64) (result f64)
-    (f64.sub (get_local $x) (f64.const 0.0)))
+    (f64.sub (local.get $x) (f64.const 0.0)))
 )
 
 (assert_return_arithmetic_nan (invoke "f32.no_fold_sub_zero" (f32.const nan:0x200000)))
@@ -79,9 +79,9 @@
 
 (module
   (func (export "f32.no_fold_mul_zero") (param $x f32) (result f32)
-    (f32.mul (get_local $x) (f32.const 0.0)))
+    (f32.mul (local.get $x) (f32.const 0.0)))
   (func (export "f64.no_fold_mul_zero") (param $x f64) (result f64)
-    (f64.mul (get_local $x) (f64.const 0.0)))
+    (f64.mul (local.get $x) (f64.const 0.0)))
 )
 
 (assert_return (invoke "f32.no_fold_mul_zero" (f32.const -0.0)) (f32.const -0.0))
@@ -98,9 +98,9 @@
 
 (module
   (func (export "f32.no_fold_mul_one") (param $x f32) (result f32)
-    (f32.mul (get_local $x) (f32.const 1.0)))
+    (f32.mul (local.get $x) (f32.const 1.0)))
   (func (export "f64.no_fold_mul_one") (param $x f64) (result f64)
-    (f64.mul (get_local $x) (f64.const 1.0)))
+    (f64.mul (local.get $x) (f64.const 1.0)))
 )
 
 (assert_return_arithmetic_nan (invoke "f32.no_fold_mul_one" (f32.const nan:0x200000)))
@@ -110,9 +110,9 @@
 
 (module
   (func (export "f32.no_fold_zero_div") (param $x f32) (result f32)
-    (f32.div (f32.const 0.0) (get_local $x)))
+    (f32.div (f32.const 0.0) (local.get $x)))
   (func (export "f64.no_fold_zero_div") (param $x f64) (result f64)
-    (f64.div (f64.const 0.0) (get_local $x)))
+    (f64.div (f64.const 0.0) (local.get $x)))
 )
 
 (assert_return_canonical_nan (invoke "f32.no_fold_zero_div" (f32.const 0.0)))
@@ -128,9 +128,9 @@
 
 (module
   (func (export "f32.no_fold_div_one") (param $x f32) (result f32)
-    (f32.div (get_local $x) (f32.const 1.0)))
+    (f32.div (local.get $x) (f32.const 1.0)))
   (func (export "f64.no_fold_div_one") (param $x f64) (result f64)
-    (f64.div (get_local $x) (f64.const 1.0)))
+    (f64.div (local.get $x) (f64.const 1.0)))
 )
 
 (assert_return_arithmetic_nan (invoke "f32.no_fold_div_one" (f32.const nan:0x200000)))
@@ -140,9 +140,9 @@
 
 (module
   (func (export "f32.no_fold_div_neg1") (param $x f32) (result f32)
-    (f32.div (get_local $x) (f32.const -1.0)))
+    (f32.div (local.get $x) (f32.const -1.0)))
   (func (export "f64.no_fold_div_neg1") (param $x f64) (result f64)
-    (f64.div (get_local $x) (f64.const -1.0)))
+    (f64.div (local.get $x) (f64.const -1.0)))
 )
 
 (assert_return_arithmetic_nan (invoke "f32.no_fold_div_neg1" (f32.const nan:0x200000)))
@@ -152,9 +152,9 @@
 
 (module
   (func (export "f32.no_fold_neg0_sub") (param $x f32) (result f32)
-    (f32.sub (f32.const -0.0) (get_local $x)))
+    (f32.sub (f32.const -0.0) (local.get $x)))
   (func (export "f64.no_fold_neg0_sub") (param $x f64) (result f64)
-    (f64.sub (f64.const -0.0) (get_local $x)))
+    (f64.sub (f64.const -0.0) (local.get $x)))
 )
 
 (assert_return_arithmetic_nan (invoke "f32.no_fold_neg0_sub" (f32.const nan:0x200000)))
@@ -164,9 +164,9 @@
 
 (module
   (func (export "f32.no_fold_neg1_mul") (param $x f32) (result f32)
-    (f32.mul (f32.const -1.0) (get_local $x)))
+    (f32.mul (f32.const -1.0) (local.get $x)))
   (func (export "f64.no_fold_neg1_mul") (param $x f64) (result f64)
-    (f64.mul (f64.const -1.0) (get_local $x)))
+    (f64.mul (f64.const -1.0) (local.get $x)))
 )
 
 (assert_return_arithmetic_nan (invoke "f32.no_fold_neg1_mul" (f32.const nan:0x200000)))
@@ -176,9 +176,9 @@
 
 (module
   (func (export "f32.no_fold_eq_self") (param $x f32) (result i32)
-    (f32.eq (get_local $x) (get_local $x)))
+    (f32.eq (local.get $x) (local.get $x)))
   (func (export "f64.no_fold_eq_self") (param $x f64) (result i32)
-    (f64.eq (get_local $x) (get_local $x)))
+    (f64.eq (local.get $x) (local.get $x)))
 )
 
 (assert_return (invoke "f32.no_fold_eq_self" (f32.const nan)) (i32.const 0))
@@ -188,9 +188,9 @@
 
 (module
   (func (export "f32.no_fold_ne_self") (param $x f32) (result i32)
-    (f32.ne (get_local $x) (get_local $x)))
+    (f32.ne (local.get $x) (local.get $x)))
   (func (export "f64.no_fold_ne_self") (param $x f64) (result i32)
-    (f64.ne (get_local $x) (get_local $x)))
+    (f64.ne (local.get $x) (local.get $x)))
 )
 
 (assert_return (invoke "f32.no_fold_ne_self" (f32.const nan)) (i32.const 1))
@@ -200,9 +200,9 @@
 
 (module
   (func (export "f32.no_fold_sub_self") (param $x f32) (result f32)
-    (f32.sub (get_local $x) (get_local $x)))
+    (f32.sub (local.get $x) (local.get $x)))
   (func (export "f64.no_fold_sub_self") (param $x f64) (result f64)
-    (f64.sub (get_local $x) (get_local $x)))
+    (f64.sub (local.get $x) (local.get $x)))
 )
 
 (assert_return_canonical_nan (invoke "f32.no_fold_sub_self" (f32.const inf)))
@@ -214,9 +214,9 @@
 
 (module
   (func (export "f32.no_fold_div_self") (param $x f32) (result f32)
-    (f32.div (get_local $x) (get_local $x)))
+    (f32.div (local.get $x) (local.get $x)))
   (func (export "f64.no_fold_div_self") (param $x f64) (result f64)
-    (f64.div (get_local $x) (get_local $x)))
+    (f64.div (local.get $x) (local.get $x)))
 )
 
 (assert_return_canonical_nan (invoke "f32.no_fold_div_self" (f32.const inf)))
@@ -232,9 +232,9 @@
 
 (module
   (func (export "f32.no_fold_div_3") (param $x f32) (result f32)
-    (f32.div (get_local $x) (f32.const 3.0)))
+    (f32.div (local.get $x) (f32.const 3.0)))
   (func (export "f64.no_fold_div_3") (param $x f64) (result f64)
-    (f64.div (get_local $x) (f64.const 3.0)))
+    (f64.div (local.get $x) (f64.const 3.0)))
 )
 
 (assert_return (invoke "f32.no_fold_div_3" (f32.const -0x1.359c26p+50)) (f32.const -0x1.9cd032p+48))
@@ -252,9 +252,9 @@
 
 (module
   (func (export "f32.no_factor") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.add (f32.mul (get_local $x) (get_local $z)) (f32.mul (get_local $y) (get_local $z))))
+    (f32.add (f32.mul (local.get $x) (local.get $z)) (f32.mul (local.get $y) (local.get $z))))
   (func (export "f64.no_factor") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.add (f64.mul (get_local $x) (get_local $z)) (f64.mul (get_local $y) (get_local $z))))
+    (f64.add (f64.mul (local.get $x) (local.get $z)) (f64.mul (local.get $y) (local.get $z))))
 )
 
 (assert_return (invoke "f32.no_factor" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7dp+109))
@@ -272,9 +272,9 @@
 
 (module
   (func (export "f32.no_distribute") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.mul (f32.add (get_local $x) (get_local $y)) (get_local $z)))
+    (f32.mul (f32.add (local.get $x) (local.get $y)) (local.get $z)))
   (func (export "f64.no_distribute") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.mul (f64.add (get_local $x) (get_local $y)) (get_local $z)))
+    (f64.mul (f64.add (local.get $x) (local.get $y)) (local.get $z)))
 )
 
 (assert_return (invoke "f32.no_distribute" (f32.const -0x1.4e2352p+40) (f32.const -0x1.842e2cp+49) (f32.const 0x1.eea602p+59)) (f32.const -0x1.77a7d2p+109))
@@ -292,9 +292,9 @@
 
 (module
   (func (export "f32.no_regroup_div_mul") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.mul (get_local $x) (f32.div (get_local $y) (get_local $z))))
+    (f32.mul (local.get $x) (f32.div (local.get $y) (local.get $z))))
   (func (export "f64.no_regroup_div_mul") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.mul (get_local $x) (f64.div (get_local $y) (get_local $z))))
+    (f64.mul (local.get $x) (f64.div (local.get $y) (local.get $z))))
 )
 
 (assert_return (invoke "f32.no_regroup_div_mul" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x1.2844cap-63))
@@ -312,9 +312,9 @@
 
 (module
   (func (export "f32.no_regroup_mul_div") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.div (f32.mul (get_local $x) (get_local $y)) (get_local $z)))
+    (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
   (func (export "f64.no_regroup_mul_div") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.div (f64.mul (get_local $x) (get_local $y)) (get_local $z)))
+    (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
 )
 
 (assert_return (invoke "f32.no_regroup_mul_div" (f32.const -0x1.2d14a6p-115) (f32.const -0x1.575a6cp-64) (f32.const 0x1.5cee0ep-116)) (f32.const 0x0p+0))
@@ -332,9 +332,9 @@
 
 (module
   (func (export "f32.no_reassociate_add") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
-    (f32.add (f32.add (f32.add (get_local $x) (get_local $y)) (get_local $z)) (get_local $w)))
+    (f32.add (f32.add (f32.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
   (func (export "f64.no_reassociate_add") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
-    (f64.add (f64.add (f64.add (get_local $x) (get_local $y)) (get_local $z)) (get_local $w)))
+    (f64.add (f64.add (f64.add (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
 )
 
 (assert_return (invoke "f32.no_reassociate_add" (f32.const -0x1.5f7ddcp+44) (f32.const 0x1.854e1p+34) (f32.const -0x1.b2068cp+47) (f32.const -0x1.209692p+41)) (f32.const -0x1.e26c76p+47))
@@ -352,9 +352,9 @@
 
 (module
   (func (export "f32.no_reassociate_mul") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
-    (f32.mul (f32.mul (f32.mul (get_local $x) (get_local $y)) (get_local $z)) (get_local $w)))
+    (f32.mul (f32.mul (f32.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
   (func (export "f64.no_reassociate_mul") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
-    (f64.mul (f64.mul (f64.mul (get_local $x) (get_local $y)) (get_local $z)) (get_local $w)))
+    (f64.mul (f64.mul (f64.mul (local.get $x) (local.get $y)) (local.get $z)) (local.get $w)))
 )
 
 (assert_return (invoke "f32.no_reassociate_mul" (f32.const 0x1.950ba8p-116) (f32.const 0x1.efdacep-33) (f32.const -0x1.5f9bcp+102) (f32.const 0x1.f04508p-56)) (f32.const -0x1.ff356ep-101))
@@ -372,9 +372,9 @@
 
 (module
   (func (export "f32.no_fold_div_0") (param $x f32) (result f32)
-    (f32.div (get_local $x) (f32.const 0.0)))
+    (f32.div (local.get $x) (f32.const 0.0)))
   (func (export "f64.no_fold_div_0") (param $x f64) (result f64)
-    (f64.div (get_local $x) (f64.const 0.0)))
+    (f64.div (local.get $x) (f64.const 0.0)))
 )
 
 (assert_return (invoke "f32.no_fold_div_0" (f32.const 1.0)) (f32.const inf))
@@ -398,9 +398,9 @@
 
 (module
   (func (export "f32.no_fold_div_neg0") (param $x f32) (result f32)
-    (f32.div (get_local $x) (f32.const -0.0)))
+    (f32.div (local.get $x) (f32.const -0.0)))
   (func (export "f64.no_fold_div_neg0") (param $x f64) (result f64)
-    (f64.div (get_local $x) (f64.const -0.0)))
+    (f64.div (local.get $x) (f64.const -0.0)))
 )
 
 (assert_return (invoke "f32.no_fold_div_neg0" (f32.const 1.0)) (f32.const -inf))
@@ -424,11 +424,11 @@
 
 (module
   (func (export "f32.no_fold_to_hypot") (param $x f32) (param $y f32) (result f32)
-    (f32.sqrt (f32.add (f32.mul (get_local $x) (get_local $x))
-                       (f32.mul (get_local $y) (get_local $y)))))
+    (f32.sqrt (f32.add (f32.mul (local.get $x) (local.get $x))
+                       (f32.mul (local.get $y) (local.get $y)))))
   (func (export "f64.no_fold_to_hypot") (param $x f64) (param $y f64) (result f64)
-    (f64.sqrt (f64.add (f64.mul (get_local $x) (get_local $x))
-                       (f64.mul (get_local $y) (get_local $y)))))
+    (f64.sqrt (f64.add (f64.mul (local.get $x) (local.get $x))
+                       (f64.mul (local.get $y) (local.get $y)))))
 )
 
 (assert_return (invoke "f32.no_fold_to_hypot" (f32.const 0x1.c2f338p-81) (f32.const 0x1.401b5ep-68)) (f32.const 0x1.401cccp-68))
@@ -446,7 +446,7 @@
 
 (module
   (func (export "f32.no_approximate_reciprocal") (param $x f32) (result f32)
-    (f32.div (f32.const 1.0) (get_local $x)))
+    (f32.div (f32.const 1.0) (local.get $x)))
 )
 
 (assert_return (invoke "f32.no_approximate_reciprocal" (f32.const -0x1.2900b6p-10)) (f32.const -0x1.b950d4p+9))
@@ -459,9 +459,9 @@
 
 (module
   (func (export "f32.no_approximate_reciprocal_sqrt") (param $x f32) (result f32)
-    (f32.div (f32.const 1.0) (f32.sqrt (get_local $x))))
+    (f32.div (f32.const 1.0) (f32.sqrt (local.get $x))))
   (func (export "f64.no_fuse_reciprocal_sqrt") (param $x f64) (result f64)
-    (f64.div (f64.const 1.0) (f64.sqrt (get_local $x))))
+    (f64.div (f64.const 1.0) (f64.sqrt (local.get $x))))
 )
 
 (assert_return (invoke "f32.no_approximate_reciprocal_sqrt" (f32.const 0x1.6af12ap-43)) (f32.const 0x1.300ed4p+21))
@@ -480,7 +480,7 @@
 
 (module
   (func (export "f32.no_approximate_sqrt_reciprocal") (param $x f32) (result f32)
-    (f32.sqrt (f32.div (f32.const 1.0) (get_local $x))))
+    (f32.sqrt (f32.div (f32.const 1.0) (local.get $x))))
 )
 
 (assert_return (invoke "f32.no_approximate_sqrt_reciprocal" (f32.const 0x1.a4c986p+60)) (f32.const 0x1.8f5ac6p-31))
@@ -493,13 +493,13 @@
 
 (module
   (func (export "i32.no_fold_f32_s") (param i32) (result i32)
-    (i32.trunc_s/f32 (f32.convert_s/i32 (get_local 0))))
+    (i32.trunc_f32_s (f32.convert_i32_s (local.get 0))))
   (func (export "i32.no_fold_f32_u") (param i32) (result i32)
-    (i32.trunc_u/f32 (f32.convert_u/i32 (get_local 0))))
+    (i32.trunc_f32_u (f32.convert_i32_u (local.get 0))))
   (func (export "i64.no_fold_f64_s") (param i64) (result i64)
-    (i64.trunc_s/f64 (f64.convert_s/i64 (get_local 0))))
+    (i64.trunc_f64_s (f64.convert_i64_s (local.get 0))))
   (func (export "i64.no_fold_f64_u") (param i64) (result i64)
-    (i64.trunc_u/f64 (f64.convert_u/i64 (get_local 0))))
+    (i64.trunc_f64_u (f64.convert_i64_u (local.get 0))))
 )
 
 (assert_return (invoke "i32.no_fold_f32_s" (i32.const 0x1000000)) (i32.const 0x1000000))
@@ -522,9 +522,9 @@
 
 (module
   (func (export "f32.no_fold_add_sub") (param $x f32) (param $y f32) (result f32)
-    (f32.sub (f32.add (get_local $x) (get_local $y)) (get_local $y)))
+    (f32.sub (f32.add (local.get $x) (local.get $y)) (local.get $y)))
   (func (export "f64.no_fold_add_sub") (param $x f64) (param $y f64) (result f64)
-    (f64.sub (f64.add (get_local $x) (get_local $y)) (get_local $y)))
+    (f64.sub (f64.add (local.get $x) (local.get $y)) (local.get $y)))
 )
 
 (assert_return (invoke "f32.no_fold_add_sub" (f32.const 0x1.b553e4p-47) (f32.const -0x1.67db2cp-26)) (f32.const 0x1.cp-47))
@@ -543,9 +543,9 @@
 
 (module
   (func (export "f32.no_fold_sub_add") (param $x f32) (param $y f32) (result f32)
-    (f32.add (f32.sub (get_local $x) (get_local $y)) (get_local $y)))
+    (f32.add (f32.sub (local.get $x) (local.get $y)) (local.get $y)))
   (func (export "f64.no_fold_sub_add") (param $x f64) (param $y f64) (result f64)
-    (f64.add (f64.sub (get_local $x) (get_local $y)) (get_local $y)))
+    (f64.add (f64.sub (local.get $x) (local.get $y)) (local.get $y)))
 )
 
 (assert_return (invoke "f32.no_fold_sub_add" (f32.const -0x1.523cb8p+9) (f32.const 0x1.93096cp+8)) (f32.const -0x1.523cbap+9))
@@ -564,9 +564,9 @@
 
 (module
   (func (export "f32.no_fold_mul_div") (param $x f32) (param $y f32) (result f32)
-    (f32.div (f32.mul (get_local $x) (get_local $y)) (get_local $y)))
+    (f32.div (f32.mul (local.get $x) (local.get $y)) (local.get $y)))
   (func (export "f64.no_fold_mul_div") (param $x f64) (param $y f64) (result f64)
-    (f64.div (f64.mul (get_local $x) (get_local $y)) (get_local $y)))
+    (f64.div (f64.mul (local.get $x) (local.get $y)) (local.get $y)))
 )
 
 (assert_return (invoke "f32.no_fold_mul_div" (f32.const -0x1.cd859ap+54) (f32.const 0x1.6ca936p-47)) (f32.const -0x1.cd8598p+54))
@@ -585,9 +585,9 @@
 
 (module
   (func (export "f32.no_fold_div_mul") (param $x f32) (param $y f32) (result f32)
-    (f32.mul (f32.div (get_local $x) (get_local $y)) (get_local $y)))
+    (f32.mul (f32.div (local.get $x) (local.get $y)) (local.get $y)))
   (func (export "f64.no_fold_div_mul") (param $x f64) (param $y f64) (result f64)
-    (f64.mul (f64.div (get_local $x) (get_local $y)) (get_local $y)))
+    (f64.mul (f64.div (local.get $x) (local.get $y)) (local.get $y)))
 )
 
 (assert_return (invoke "f32.no_fold_div_mul" (f32.const -0x1.dc6364p+38) (f32.const 0x1.d630ecp+29)) (f32.const -0x1.dc6362p+38))
@@ -606,9 +606,9 @@
 
 (module
   (func (export "f32.no_fold_div2_mul2") (param $x f32) (result f32)
-    (f32.mul (f32.div (get_local $x) (f32.const 2.0)) (f32.const 2.0)))
+    (f32.mul (f32.div (local.get $x) (f32.const 2.0)) (f32.const 2.0)))
   (func (export "f64.no_fold_div2_mul2") (param $x f64) (result f64)
-    (f64.mul (f64.div (get_local $x) (f64.const 2.0)) (f64.const 2.0)))
+    (f64.mul (f64.div (local.get $x) (f64.const 2.0)) (f64.const 2.0)))
 )
 
 (assert_return (invoke "f32.no_fold_div2_mul2" (f32.const 0x1.fffffep-126)) (f32.const 0x1p-125))
@@ -618,7 +618,7 @@
 
 (module
   (func (export "no_fold_demote_promote") (param $x f64) (result f64)
-    (f64.promote/f32 (f32.demote/f64 (get_local $x))))
+    (f64.promote_f32 (f32.demote_f64 (local.get $x))))
 )
 
 (assert_return (invoke "no_fold_demote_promote" (f64.const -0x1.dece272390f5dp-133)) (f64.const -0x1.decep-133))
@@ -632,7 +632,7 @@
 
 (module
   (func (export "no_fold_promote_demote") (param $x f32) (result f32)
-    (f32.demote/f64 (f64.promote/f32 (get_local $x))))
+    (f32.demote_f64 (f64.promote_f32 (local.get $x))))
 )
 
 (assert_return_arithmetic_nan (invoke "no_fold_promote_demote" (f32.const nan:0x200000)))
@@ -653,9 +653,9 @@
 
 (module
   (func (export "no_demote_mixed_add") (param $x f64) (param $y f32) (result f32)
-    (f32.demote/f64 (f64.add (get_local $x) (f64.promote/f32 (get_local $y)))))
+    (f32.demote_f64 (f64.add (local.get $x) (f64.promote_f32 (local.get $y)))))
   (func (export "no_demote_mixed_add_commuted") (param $y f32) (param $x f64) (result f32)
-    (f32.demote/f64 (f64.add (f64.promote/f32 (get_local $y)) (get_local $x))))
+    (f32.demote_f64 (f64.add (f64.promote_f32 (local.get $y)) (local.get $x))))
 )
 
 (assert_return (invoke "no_demote_mixed_add" (f64.const 0x1.f51a9d04854f9p-95) (f32.const 0x1.3f4e9cp-119)) (f32.const 0x1.f51a9ep-95))
@@ -674,7 +674,7 @@
 
 (module
   (func (export "no_demote_mixed_sub") (param $x f64) (param $y f32) (result f32)
-    (f32.demote/f64 (f64.sub (get_local $x) (f64.promote/f32 (get_local $y)))))
+    (f32.demote_f64 (f64.sub (local.get $x) (f64.promote_f32 (local.get $y)))))
 )
 
 (assert_return (invoke "no_demote_mixed_sub" (f64.const 0x1.a0a183220e9b1p+82) (f32.const 0x1.c5acf8p+61)) (f32.const 0x1.a0a174p+82))
@@ -687,37 +687,37 @@
 
 (module
   (func (export "f32.i32.no_fold_trunc_s_convert_s") (param $x f32) (result f32)
-    (f32.convert_s/i32 (i32.trunc_s/f32 (get_local $x))))
+    (f32.convert_i32_s (i32.trunc_f32_s (local.get $x))))
   (func (export "f32.i32.no_fold_trunc_u_convert_s") (param $x f32) (result f32)
-    (f32.convert_s/i32 (i32.trunc_u/f32 (get_local $x))))
+    (f32.convert_i32_s (i32.trunc_f32_u (local.get $x))))
   (func (export "f32.i32.no_fold_trunc_s_convert_u") (param $x f32) (result f32)
-    (f32.convert_u/i32 (i32.trunc_s/f32 (get_local $x))))
+    (f32.convert_i32_u (i32.trunc_f32_s (local.get $x))))
   (func (export "f32.i32.no_fold_trunc_u_convert_u") (param $x f32) (result f32)
-    (f32.convert_u/i32 (i32.trunc_u/f32 (get_local $x))))
+    (f32.convert_i32_u (i32.trunc_f32_u (local.get $x))))
   (func (export "f64.i32.no_fold_trunc_s_convert_s") (param $x f64) (result f64)
-    (f64.convert_s/i32 (i32.trunc_s/f64 (get_local $x))))
+    (f64.convert_i32_s (i32.trunc_f64_s (local.get $x))))
   (func (export "f64.i32.no_fold_trunc_u_convert_s") (param $x f64) (result f64)
-    (f64.convert_s/i32 (i32.trunc_u/f64 (get_local $x))))
+    (f64.convert_i32_s (i32.trunc_f64_u (local.get $x))))
   (func (export "f64.i32.no_fold_trunc_s_convert_u") (param $x f64) (result f64)
-    (f64.convert_u/i32 (i32.trunc_s/f64 (get_local $x))))
+    (f64.convert_i32_u (i32.trunc_f64_s (local.get $x))))
   (func (export "f64.i32.no_fold_trunc_u_convert_u") (param $x f64) (result f64)
-    (f64.convert_u/i32 (i32.trunc_u/f64 (get_local $x))))
+    (f64.convert_i32_u (i32.trunc_f64_u (local.get $x))))
   (func (export "f32.i64.no_fold_trunc_s_convert_s") (param $x f32) (result f32)
-    (f32.convert_s/i64 (i64.trunc_s/f32 (get_local $x))))
+    (f32.convert_i64_s (i64.trunc_f32_s (local.get $x))))
   (func (export "f32.i64.no_fold_trunc_u_convert_s") (param $x f32) (result f32)
-    (f32.convert_s/i64 (i64.trunc_u/f32 (get_local $x))))
+    (f32.convert_i64_s (i64.trunc_f32_u (local.get $x))))
   (func (export "f32.i64.no_fold_trunc_s_convert_u") (param $x f32) (result f32)
-    (f32.convert_u/i64 (i64.trunc_s/f32 (get_local $x))))
+    (f32.convert_i64_u (i64.trunc_f32_s (local.get $x))))
   (func (export "f32.i64.no_fold_trunc_u_convert_u") (param $x f32) (result f32)
-    (f32.convert_u/i64 (i64.trunc_u/f32 (get_local $x))))
+    (f32.convert_i64_u (i64.trunc_f32_u (local.get $x))))
   (func (export "f64.i64.no_fold_trunc_s_convert_s") (param $x f64) (result f64)
-    (f64.convert_s/i64 (i64.trunc_s/f64 (get_local $x))))
+    (f64.convert_i64_s (i64.trunc_f64_s (local.get $x))))
   (func (export "f64.i64.no_fold_trunc_u_convert_s") (param $x f64) (result f64)
-    (f64.convert_s/i64 (i64.trunc_u/f64 (get_local $x))))
+    (f64.convert_i64_s (i64.trunc_f64_u (local.get $x))))
   (func (export "f64.i64.no_fold_trunc_s_convert_u") (param $x f64) (result f64)
-    (f64.convert_u/i64 (i64.trunc_s/f64 (get_local $x))))
+    (f64.convert_i64_u (i64.trunc_f64_s (local.get $x))))
   (func (export "f64.i64.no_fold_trunc_u_convert_u") (param $x f64) (result f64)
-    (f64.convert_u/i64 (i64.trunc_u/f64 (get_local $x))))
+    (f64.convert_i64_u (i64.trunc_f64_u (local.get $x))))
 )
 
 (assert_return (invoke "f32.i32.no_fold_trunc_s_convert_s" (f32.const 1.5)) (f32.const 1.0))
@@ -762,23 +762,23 @@
 
 (module
   (memory 1 1)
-  (func (export "init") (param $i i32) (param $x f32) (f32.store (get_local $i) (get_local $x)))
+  (func (export "init") (param $i i32) (param $x f32) (f32.store (local.get $i) (local.get $x)))
 
   (func (export "run") (param $n i32) (param $z f32)
     (local $i i32)
     (block $exit
       (loop $cont
         (f32.store
-          (get_local $i)
-          (f32.div (f32.load (get_local $i)) (get_local $z))
+          (local.get $i)
+          (f32.div (f32.load (local.get $i)) (local.get $z))
         )
-        (set_local $i (i32.add (get_local $i) (i32.const 4)))
-        (br_if $cont (i32.lt_u (get_local $i) (get_local $n)))
+        (local.set $i (i32.add (local.get $i) (i32.const 4)))
+        (br_if $cont (i32.lt_u (local.get $i) (local.get $n)))
       )
     )
   )
 
-  (func (export "check") (param $i i32) (result f32) (f32.load (get_local $i)))
+  (func (export "check") (param $i i32) (result f32) (f32.load (local.get $i)))
 )
 
 (invoke "init" (i32.const  0) (f32.const 15.1))
@@ -797,23 +797,23 @@
 
 (module
   (memory 1 1)
-  (func (export "init") (param $i i32) (param $x f64) (f64.store (get_local $i) (get_local $x)))
+  (func (export "init") (param $i i32) (param $x f64) (f64.store (local.get $i) (local.get $x)))
 
   (func (export "run") (param $n i32) (param $z f64)
     (local $i i32)
     (block $exit
       (loop $cont
         (f64.store
-          (get_local $i)
-          (f64.div (f64.load (get_local $i)) (get_local $z))
+          (local.get $i)
+          (f64.div (f64.load (local.get $i)) (local.get $z))
         )
-        (set_local $i (i32.add (get_local $i) (i32.const 8)))
-        (br_if $cont (i32.lt_u (get_local $i) (get_local $n)))
+        (local.set $i (i32.add (local.get $i) (i32.const 8)))
+        (br_if $cont (i32.lt_u (local.get $i) (local.get $n)))
       )
     )
   )
 
-  (func (export "check") (param $i i32) (result f64) (f64.load (get_local $i)))
+  (func (export "check") (param $i i32) (result f64) (f64.load (local.get $i)))
 )
 
 (invoke "init" (i32.const  0) (f64.const 15.1))
@@ -833,15 +833,15 @@
 ;; Test that ult/ugt/etc. aren't folded to olt/ogt/etc.
 
 (module
-  (func (export "f32.ult") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.ge (get_local $x) (get_local $y))))
-  (func (export "f32.ule") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.gt (get_local $x) (get_local $y))))
-  (func (export "f32.ugt") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.le (get_local $x) (get_local $y))))
-  (func (export "f32.uge") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.lt (get_local $x) (get_local $y))))
+  (func (export "f32.ult") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.ge (local.get $x) (local.get $y))))
+  (func (export "f32.ule") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.gt (local.get $x) (local.get $y))))
+  (func (export "f32.ugt") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.le (local.get $x) (local.get $y))))
+  (func (export "f32.uge") (param $x f32) (param $y f32) (result i32) (i32.eqz (f32.lt (local.get $x) (local.get $y))))
 
-  (func (export "f64.ult") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.ge (get_local $x) (get_local $y))))
-  (func (export "f64.ule") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.gt (get_local $x) (get_local $y))))
-  (func (export "f64.ugt") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.le (get_local $x) (get_local $y))))
-  (func (export "f64.uge") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.lt (get_local $x) (get_local $y))))
+  (func (export "f64.ult") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.ge (local.get $x) (local.get $y))))
+  (func (export "f64.ule") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.gt (local.get $x) (local.get $y))))
+  (func (export "f64.ugt") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.le (local.get $x) (local.get $y))))
+  (func (export "f64.uge") (param $x f64) (param $y f64) (result i32) (i32.eqz (f64.lt (local.get $x) (local.get $y))))
 )
 
 (assert_return (invoke "f32.ult" (f32.const 3.0) (f32.const 2.0)) (i32.const 0))
@@ -880,15 +880,15 @@
 ;; Test that x<y?x:y, etc. using select aren't folded to min, etc.
 
 (module
-  (func (export "f32.no_fold_lt_select") (param $x f32) (param $y f32) (result f32) (select (get_local $x) (get_local $y) (f32.lt (get_local $x) (get_local $y))))
-  (func (export "f32.no_fold_le_select") (param $x f32) (param $y f32) (result f32) (select (get_local $x) (get_local $y) (f32.le (get_local $x) (get_local $y))))
-  (func (export "f32.no_fold_gt_select") (param $x f32) (param $y f32) (result f32) (select (get_local $x) (get_local $y) (f32.gt (get_local $x) (get_local $y))))
-  (func (export "f32.no_fold_ge_select") (param $x f32) (param $y f32) (result f32) (select (get_local $x) (get_local $y) (f32.ge (get_local $x) (get_local $y))))
+  (func (export "f32.no_fold_lt_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.lt (local.get $x) (local.get $y))))
+  (func (export "f32.no_fold_le_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.le (local.get $x) (local.get $y))))
+  (func (export "f32.no_fold_gt_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.gt (local.get $x) (local.get $y))))
+  (func (export "f32.no_fold_ge_select") (param $x f32) (param $y f32) (result f32) (select (local.get $x) (local.get $y) (f32.ge (local.get $x) (local.get $y))))
 
-  (func (export "f64.no_fold_lt_select") (param $x f64) (param $y f64) (result f64) (select (get_local $x) (get_local $y) (f64.lt (get_local $x) (get_local $y))))
-  (func (export "f64.no_fold_le_select") (param $x f64) (param $y f64) (result f64) (select (get_local $x) (get_local $y) (f64.le (get_local $x) (get_local $y))))
-  (func (export "f64.no_fold_gt_select") (param $x f64) (param $y f64) (result f64) (select (get_local $x) (get_local $y) (f64.gt (get_local $x) (get_local $y))))
-  (func (export "f64.no_fold_ge_select") (param $x f64) (param $y f64) (result f64) (select (get_local $x) (get_local $y) (f64.ge (get_local $x) (get_local $y))))
+  (func (export "f64.no_fold_lt_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.lt (local.get $x) (local.get $y))))
+  (func (export "f64.no_fold_le_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.le (local.get $x) (local.get $y))))
+  (func (export "f64.no_fold_gt_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.gt (local.get $x) (local.get $y))))
+  (func (export "f64.no_fold_ge_select") (param $x f64) (param $y f64) (result f64) (select (local.get $x) (local.get $y) (f64.ge (local.get $x) (local.get $y))))
 )
 
 (assert_return (invoke "f32.no_fold_lt_select" (f32.const 0.0) (f32.const nan)) (f32.const nan))
@@ -928,44 +928,44 @@
 
 (module
   (func (export "f32.no_fold_lt_if") (param $x f32) (param $y f32) (result f32)
-    (if (result f32) (f32.lt (get_local $x) (get_local $y))
-      (then (get_local $x)) (else (get_local $y))
+    (if (result f32) (f32.lt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
     )
   )
   (func (export "f32.no_fold_le_if") (param $x f32) (param $y f32) (result f32)
-    (if (result f32) (f32.le (get_local $x) (get_local $y))
-      (then (get_local $x)) (else (get_local $y))
+    (if (result f32) (f32.le (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
     )
   )
   (func (export "f32.no_fold_gt_if") (param $x f32) (param $y f32) (result f32)
-    (if (result f32) (f32.gt (get_local $x) (get_local $y))
-      (then (get_local $x)) (else (get_local $y))
+    (if (result f32) (f32.gt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
     )
   )
   (func (export "f32.no_fold_ge_if") (param $x f32) (param $y f32) (result f32)
-    (if (result f32) (f32.ge (get_local $x) (get_local $y))
-      (then (get_local $x)) (else (get_local $y))
+    (if (result f32) (f32.ge (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
     )
   )
 
   (func (export "f64.no_fold_lt_if") (param $x f64) (param $y f64) (result f64)
-    (if (result f64) (f64.lt (get_local $x) (get_local $y))
-      (then (get_local $x)) (else (get_local $y))
+    (if (result f64) (f64.lt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
     )
   )
   (func (export "f64.no_fold_le_if") (param $x f64) (param $y f64) (result f64)
-    (if (result f64) (f64.le (get_local $x) (get_local $y))
-      (then (get_local $x)) (else (get_local $y))
+    (if (result f64) (f64.le (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
     )
   )
   (func (export "f64.no_fold_gt_if") (param $x f64) (param $y f64) (result f64)
-    (if (result f64) (f64.gt (get_local $x) (get_local $y))
-      (then (get_local $x)) (else (get_local $y))
+    (if (result f64) (f64.gt (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
     )
   )
   (func (export "f64.no_fold_ge_if") (param $x f64) (param $y f64) (result f64)
-    (if (result f64) (f64.ge (get_local $x) (get_local $y))
-      (then (get_local $x)) (else (get_local $y))
+    (if (result f64) (f64.ge (local.get $x) (local.get $y))
+      (then (local.get $x)) (else (local.get $y))
     )
   )
 )
@@ -1006,15 +1006,15 @@
 ;; Test that x<0?-x:x, etc. using select aren't folded to abs.
 
 (module
-  (func (export "f32.no_fold_lt_select_to_abs") (param $x f32) (result f32) (select (f32.neg (get_local $x)) (get_local $x) (f32.lt (get_local $x) (f32.const 0.0))))
-  (func (export "f32.no_fold_le_select_to_abs") (param $x f32) (result f32) (select (f32.neg (get_local $x)) (get_local $x) (f32.le (get_local $x) (f32.const -0.0))))
-  (func (export "f32.no_fold_gt_select_to_abs") (param $x f32) (result f32) (select (get_local $x) (f32.neg (get_local $x)) (f32.gt (get_local $x) (f32.const -0.0))))
-  (func (export "f32.no_fold_ge_select_to_abs") (param $x f32) (result f32) (select (get_local $x) (f32.neg (get_local $x)) (f32.ge (get_local $x) (f32.const 0.0))))
+  (func (export "f32.no_fold_lt_select_to_abs") (param $x f32) (result f32) (select (f32.neg (local.get $x)) (local.get $x) (f32.lt (local.get $x) (f32.const 0.0))))
+  (func (export "f32.no_fold_le_select_to_abs") (param $x f32) (result f32) (select (f32.neg (local.get $x)) (local.get $x) (f32.le (local.get $x) (f32.const -0.0))))
+  (func (export "f32.no_fold_gt_select_to_abs") (param $x f32) (result f32) (select (local.get $x) (f32.neg (local.get $x)) (f32.gt (local.get $x) (f32.const -0.0))))
+  (func (export "f32.no_fold_ge_select_to_abs") (param $x f32) (result f32) (select (local.get $x) (f32.neg (local.get $x)) (f32.ge (local.get $x) (f32.const 0.0))))
 
-  (func (export "f64.no_fold_lt_select_to_abs") (param $x f64) (result f64) (select (f64.neg (get_local $x)) (get_local $x) (f64.lt (get_local $x) (f64.const 0.0))))
-  (func (export "f64.no_fold_le_select_to_abs") (param $x f64) (result f64) (select (f64.neg (get_local $x)) (get_local $x) (f64.le (get_local $x) (f64.const -0.0))))
-  (func (export "f64.no_fold_gt_select_to_abs") (param $x f64) (result f64) (select (get_local $x) (f64.neg (get_local $x)) (f64.gt (get_local $x) (f64.const -0.0))))
-  (func (export "f64.no_fold_ge_select_to_abs") (param $x f64) (result f64) (select (get_local $x) (f64.neg (get_local $x)) (f64.ge (get_local $x) (f64.const 0.0))))
+  (func (export "f64.no_fold_lt_select_to_abs") (param $x f64) (result f64) (select (f64.neg (local.get $x)) (local.get $x) (f64.lt (local.get $x) (f64.const 0.0))))
+  (func (export "f64.no_fold_le_select_to_abs") (param $x f64) (result f64) (select (f64.neg (local.get $x)) (local.get $x) (f64.le (local.get $x) (f64.const -0.0))))
+  (func (export "f64.no_fold_gt_select_to_abs") (param $x f64) (result f64) (select (local.get $x) (f64.neg (local.get $x)) (f64.gt (local.get $x) (f64.const -0.0))))
+  (func (export "f64.no_fold_ge_select_to_abs") (param $x f64) (result f64) (select (local.get $x) (f64.neg (local.get $x)) (f64.ge (local.get $x) (f64.const 0.0))))
 )
 
 (assert_return (invoke "f32.no_fold_lt_select_to_abs" (f32.const nan:0x200000)) (f32.const nan:0x200000))
@@ -1054,44 +1054,44 @@
 
 (module
   (func (export "f32.no_fold_lt_if_to_abs") (param $x f32) (result f32)
-    (if (result f32) (f32.lt (get_local $x) (f32.const 0.0))
-      (then (f32.neg (get_local $x))) (else (get_local $x))
+    (if (result f32) (f32.lt (local.get $x) (f32.const 0.0))
+      (then (f32.neg (local.get $x))) (else (local.get $x))
     )
   )
   (func (export "f32.no_fold_le_if_to_abs") (param $x f32) (result f32)
-    (if (result f32) (f32.le (get_local $x) (f32.const -0.0))
-      (then (f32.neg (get_local $x))) (else (get_local $x))
+    (if (result f32) (f32.le (local.get $x) (f32.const -0.0))
+      (then (f32.neg (local.get $x))) (else (local.get $x))
     )
   )
   (func (export "f32.no_fold_gt_if_to_abs") (param $x f32) (result f32)
-    (if (result f32) (f32.gt (get_local $x) (f32.const -0.0))
-      (then (get_local $x)) (else (f32.neg (get_local $x)))
+    (if (result f32) (f32.gt (local.get $x) (f32.const -0.0))
+      (then (local.get $x)) (else (f32.neg (local.get $x)))
     )
   )
   (func (export "f32.no_fold_ge_if_to_abs") (param $x f32) (result f32)
-    (if (result f32) (f32.ge (get_local $x) (f32.const 0.0))
-      (then (get_local $x)) (else (f32.neg (get_local $x)))
+    (if (result f32) (f32.ge (local.get $x) (f32.const 0.0))
+      (then (local.get $x)) (else (f32.neg (local.get $x)))
     )
   )
 
   (func (export "f64.no_fold_lt_if_to_abs") (param $x f64) (result f64)
-    (if (result f64) (f64.lt (get_local $x) (f64.const 0.0))
-      (then (f64.neg (get_local $x))) (else (get_local $x))
+    (if (result f64) (f64.lt (local.get $x) (f64.const 0.0))
+      (then (f64.neg (local.get $x))) (else (local.get $x))
     )
   )
   (func (export "f64.no_fold_le_if_to_abs") (param $x f64) (result f64)
-    (if (result f64) (f64.le (get_local $x) (f64.const -0.0))
-      (then (f64.neg (get_local $x))) (else (get_local $x))
+    (if (result f64) (f64.le (local.get $x) (f64.const -0.0))
+      (then (f64.neg (local.get $x))) (else (local.get $x))
     )
   )
   (func (export "f64.no_fold_gt_if_to_abs") (param $x f64) (result f64)
-    (if (result f64) (f64.gt (get_local $x) (f64.const -0.0))
-      (then (get_local $x)) (else (f64.neg (get_local $x)))
+    (if (result f64) (f64.gt (local.get $x) (f64.const -0.0))
+      (then (local.get $x)) (else (f64.neg (local.get $x)))
     )
   )
   (func (export "f64.no_fold_ge_if_to_abs") (param $x f64) (result f64)
-    (if (result f64) (f64.ge (get_local $x) (f64.const 0.0))
-      (then (get_local $x)) (else (f64.neg (get_local $x)))
+    (if (result f64) (f64.ge (local.get $x) (f64.const 0.0))
+      (then (local.get $x)) (else (f64.neg (local.get $x)))
     )
   )
 )
@@ -1154,13 +1154,13 @@
     (local $q f32)
     (local $z0 f32)
     (local $z1 f32)
-    (set_local $x (f32.const 156.25))
-    (set_local $r (f32.const 208.333333334))
-    (set_local $q (f32.const 1.77951304201))
-    (set_local $z0 (f32.div (f32.mul (f32.neg (get_local $r)) (get_local $x)) (f32.sub (f32.mul (get_local $x) (get_local $q)) (get_local $r))))
-    (set_local $z1 (f32.div (f32.mul (f32.neg (get_local $r)) (get_local $x)) (f32.sub (f32.mul (get_local $x) (get_local $q)) (get_local $r))))
-    (block (br_if 0 (f32.eq (get_local $z0) (get_local $z1))) (unreachable))
-    (get_local $z1)
+    (local.set $x (f32.const 156.25))
+    (local.set $r (f32.const 208.333333334))
+    (local.set $q (f32.const 1.77951304201))
+    (local.set $z0 (f32.div (f32.mul (f32.neg (local.get $r)) (local.get $x)) (f32.sub (f32.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (local.set $z1 (f32.div (f32.mul (f32.neg (local.get $r)) (local.get $x)) (f32.sub (f32.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (block (br_if 0 (f32.eq (local.get $z0) (local.get $z1))) (unreachable))
+    (local.get $z1)
   )
 )
 
@@ -1173,13 +1173,13 @@
     (local $q f64)
     (local $z0 f64)
     (local $z1 f64)
-    (set_local $x (f64.const 156.25))
-    (set_local $r (f64.const 208.333333334))
-    (set_local $q (f64.const 1.77951304201))
-    (set_local $z0 (f64.div (f64.mul (f64.neg (get_local $r)) (get_local $x)) (f64.sub (f64.mul (get_local $x) (get_local $q)) (get_local $r))))
-    (set_local $z1 (f64.div (f64.mul (f64.neg (get_local $r)) (get_local $x)) (f64.sub (f64.mul (get_local $x) (get_local $q)) (get_local $r))))
-    (block (br_if 0 (f64.eq (get_local $z0) (get_local $z1))) (unreachable))
-    (get_local $z1)
+    (local.set $x (f64.const 156.25))
+    (local.set $r (f64.const 208.333333334))
+    (local.set $q (f64.const 1.77951304201))
+    (local.set $z0 (f64.div (f64.mul (f64.neg (local.get $r)) (local.get $x)) (f64.sub (f64.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (local.set $z1 (f64.div (f64.mul (f64.neg (local.get $r)) (local.get $x)) (f64.sub (f64.mul (local.get $x) (local.get $q)) (local.get $r))))
+    (block (br_if 0 (f64.eq (local.get $z0) (local.get $z1))) (unreachable))
+    (local.get $z1)
   )
 )
 
@@ -1190,7 +1190,7 @@
 
 (module
   (func (export "llvm_pr26746") (param $x f32) (result f32)
-    (f32.sub (f32.const 0.0) (f32.sub (f32.const -0.0) (get_local $x)))
+    (f32.sub (f32.const 0.0) (f32.sub (f32.const -0.0) (local.get $x)))
   )
 )
 
@@ -1201,7 +1201,7 @@
 
 (module
   (func (export "llvm_pr27153") (param $x i32) (result f32)
-    (f32.add (f32.convert_s/i32 (i32.and (get_local $x) (i32.const 268435455))) (f32.const -8388608.0))
+    (f32.add (f32.convert_i32_s (i32.and (local.get $x) (i32.const 268435455))) (f32.const -8388608.0))
   )
 )
 
@@ -1212,8 +1212,8 @@
 
 (module
   (func (export "llvm_pr27036") (param $x i32) (param $y i32) (result f32)
-    (f32.add (f32.convert_s/i32 (i32.or (get_local $x) (i32.const -25034805)))
-             (f32.convert_s/i32 (i32.and (get_local $y) (i32.const 14942208))))
+    (f32.add (f32.convert_i32_s (i32.or (local.get $x) (i32.const -25034805)))
+             (f32.convert_i32_s (i32.and (local.get $y) (i32.const 14942208))))
   )
 )
 
@@ -1229,15 +1229,15 @@
 ;; covered elsewhere.
 (module
   (func (export "thepast0") (param $a f64) (param $b f64) (param $c f64) (param $d f64) (result f64)
-    (f64.div (f64.mul (get_local $a) (get_local $b)) (f64.mul (get_local $c) (get_local $d)))
+    (f64.div (f64.mul (local.get $a) (local.get $b)) (f64.mul (local.get $c) (local.get $d)))
   )
 
   (func (export "thepast1") (param $a f64) (param $b f64) (param $c f64) (result f64)
-    (f64.sub (f64.mul (get_local $a) (get_local $b)) (get_local $c))
+    (f64.sub (f64.mul (local.get $a) (local.get $b)) (local.get $c))
   )
 
   (func (export "thepast2") (param $a f32) (param $b f32) (param $c f32) (result f32)
-    (f32.mul (f32.mul (get_local $a) (get_local $b)) (get_local $c))
+    (f32.mul (f32.mul (local.get $a) (local.get $b)) (local.get $c))
   )
 )
 
@@ -1250,7 +1250,7 @@
 
 (module
   (func (export "inverse") (param $x f32) (result f32)
-    (f32.div (f32.const 1.0) (get_local $x))
+    (f32.div (f32.const 1.0) (local.get $x))
   )
 )
 
@@ -1261,11 +1261,11 @@
 
 (module
   (func (export "f32_sqrt_minus_2") (param $x f32) (result f32)
-    (f32.sub (f32.sqrt (get_local $x)) (f32.const 2.0))
+    (f32.sub (f32.sqrt (local.get $x)) (f32.const 2.0))
   )
 
   (func (export "f64_sqrt_minus_2") (param $x f64) (result f64)
-    (f64.sub (f64.sqrt (get_local $x)) (f64.const 2.0))
+    (f64.sub (f64.sqrt (local.get $x)) (f64.const 2.0))
   )
 )
 
@@ -1276,10 +1276,10 @@
 
 (module
   (func (export "f32.no_fold_recip_recip") (param $x f32) (result f32)
-    (f32.div (f32.const 1.0) (f32.div (f32.const 1.0) (get_local $x))))
+    (f32.div (f32.const 1.0) (f32.div (f32.const 1.0) (local.get $x))))
 
   (func (export "f64.no_fold_recip_recip") (param $x f64) (result f64)
-    (f64.div (f64.const 1.0) (f64.div (f64.const 1.0) (get_local $x))))
+    (f64.div (f64.const 1.0) (f64.div (f64.const 1.0) (local.get $x))))
 )
 
 (assert_return (invoke "f32.no_fold_recip_recip" (f32.const -0x1.e8bf18p+65)) (f32.const -0x1.e8bf16p+65))
@@ -1308,12 +1308,12 @@
 
 (module
   (func (export "f32.no_algebraic_factoring") (param $x f32) (param $y f32) (result f32)
-    (f32.mul (f32.add (get_local $x) (get_local $y))
-             (f32.sub (get_local $x) (get_local $y))))
+    (f32.mul (f32.add (local.get $x) (local.get $y))
+             (f32.sub (local.get $x) (local.get $y))))
 
   (func (export "f64.no_algebraic_factoring") (param $x f64) (param $y f64) (result f64)
-    (f64.mul (f64.add (get_local $x) (get_local $y))
-             (f64.sub (get_local $x) (get_local $y))))
+    (f64.mul (f64.add (local.get $x) (local.get $y))
+             (f64.sub (local.get $x) (local.get $y))))
 )
 
 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const -0x1.ef678ep-55) (f32.const 0x1.c160b8p-54)) (f32.const -0x1.129402p-107))
@@ -1332,12 +1332,12 @@
 
 (module
   (func (export "f32.no_algebraic_factoring") (param $x f32) (param $y f32) (result f32)
-    (f32.sub (f32.mul (get_local $x) (get_local $x))
-             (f32.mul (get_local $y) (get_local $y))))
+    (f32.sub (f32.mul (local.get $x) (local.get $x))
+             (f32.mul (local.get $y) (local.get $y))))
 
   (func (export "f64.no_algebraic_factoring") (param $x f64) (param $y f64) (result f64)
-    (f64.sub (f64.mul (get_local $x) (get_local $x))
-             (f64.mul (get_local $y) (get_local $y))))
+    (f64.sub (f64.mul (local.get $x) (local.get $x))
+             (f64.mul (local.get $y) (local.get $y))))
 )
 
 (assert_return (invoke "f32.no_algebraic_factoring" (f32.const 0x1.8e2c14p-46) (f32.const 0x1.bad59ap-39)) (f32.const -0x1.7efe5p-77))
@@ -1368,23 +1368,23 @@
     (param $k i32)
     (local $x0 f32) (local $x1 f32) (local $x2 f32) (local $x3 f32)
     (local $y0 f32) (local $y1 f32) (local $y2 f32) (local $y3 f32)
-    (set_local $x0 (f32.load offset=0 (get_local $i)))
-    (set_local $x1 (f32.load offset=4 (get_local $i)))
-    (set_local $x2 (f32.load offset=8 (get_local $i)))
-    (set_local $x3 (f32.load offset=12 (get_local $i)))
-    (set_local $y0 (f32.load offset=0 (get_local $j)))
-    (set_local $y1 (f32.load offset=4 (get_local $j)))
-    (set_local $y2 (f32.load offset=8 (get_local $j)))
-    (set_local $y3 (f32.load offset=12 (get_local $j)))
-    (f32.store offset=0 (get_local $k) (f32.add (get_local $x0) (get_local $y0)))
-    (f32.store offset=4 (get_local $k) (f32.add (get_local $x1) (get_local $y1)))
-    (f32.store offset=8 (get_local $k) (f32.add (get_local $x2) (get_local $y2)))
-    (f32.store offset=12 (get_local $k) (f32.add (get_local $x3) (get_local $y3)))
+    (local.set $x0 (f32.load offset=0 (local.get $i)))
+    (local.set $x1 (f32.load offset=4 (local.get $i)))
+    (local.set $x2 (f32.load offset=8 (local.get $i)))
+    (local.set $x3 (f32.load offset=12 (local.get $i)))
+    (local.set $y0 (f32.load offset=0 (local.get $j)))
+    (local.set $y1 (f32.load offset=4 (local.get $j)))
+    (local.set $y2 (f32.load offset=8 (local.get $j)))
+    (local.set $y3 (f32.load offset=12 (local.get $j)))
+    (f32.store offset=0 (local.get $k) (f32.add (local.get $x0) (local.get $y0)))
+    (f32.store offset=4 (local.get $k) (f32.add (local.get $x1) (local.get $y1)))
+    (f32.store offset=8 (local.get $k) (f32.add (local.get $x2) (local.get $y2)))
+    (f32.store offset=12 (local.get $k) (f32.add (local.get $x3) (local.get $y3)))
   )
 
   (func (export "f32.load")
     (param $k i32) (result f32)
-    (f32.load (get_local $k))
+    (f32.load (local.get $k))
   )
 )
 
@@ -1407,23 +1407,23 @@
     (param $k i32)
     (local $x0 f64) (local $x1 f64) (local $x2 f64) (local $x3 f64)
     (local $y0 f64) (local $y1 f64) (local $y2 f64) (local $y3 f64)
-    (set_local $x0 (f64.load offset=0 (get_local $i)))
-    (set_local $x1 (f64.load offset=8 (get_local $i)))
-    (set_local $x2 (f64.load offset=16 (get_local $i)))
-    (set_local $x3 (f64.load offset=24 (get_local $i)))
-    (set_local $y0 (f64.load offset=0 (get_local $j)))
-    (set_local $y1 (f64.load offset=8 (get_local $j)))
-    (set_local $y2 (f64.load offset=16 (get_local $j)))
-    (set_local $y3 (f64.load offset=24 (get_local $j)))
-    (f64.store offset=0 (get_local $k) (f64.add (get_local $x0) (get_local $y0)))
-    (f64.store offset=8 (get_local $k) (f64.add (get_local $x1) (get_local $y1)))
-    (f64.store offset=16 (get_local $k) (f64.add (get_local $x2) (get_local $y2)))
-    (f64.store offset=24 (get_local $k) (f64.add (get_local $x3) (get_local $y3)))
+    (local.set $x0 (f64.load offset=0 (local.get $i)))
+    (local.set $x1 (f64.load offset=8 (local.get $i)))
+    (local.set $x2 (f64.load offset=16 (local.get $i)))
+    (local.set $x3 (f64.load offset=24 (local.get $i)))
+    (local.set $y0 (f64.load offset=0 (local.get $j)))
+    (local.set $y1 (f64.load offset=8 (local.get $j)))
+    (local.set $y2 (f64.load offset=16 (local.get $j)))
+    (local.set $y3 (f64.load offset=24 (local.get $j)))
+    (f64.store offset=0 (local.get $k) (f64.add (local.get $x0) (local.get $y0)))
+    (f64.store offset=8 (local.get $k) (f64.add (local.get $x1) (local.get $y1)))
+    (f64.store offset=16 (local.get $k) (f64.add (local.get $x2) (local.get $y2)))
+    (f64.store offset=24 (local.get $k) (f64.add (local.get $x3) (local.get $y3)))
   )
 
   (func (export "f64.load")
     (param $k i32) (result f64)
-    (f64.load (get_local $k))
+    (f64.load (local.get $k))
   )
 )
 
@@ -1489,41 +1489,41 @@
     (local $t f32)
     (block $exit
       (loop $top
-        (set_local $t
+        (local.set $t
           (f32.sub
             (f32.sub
-              (tee_local $sum
+              (local.tee $sum
                 (f32.add
-                  (get_local $c)
-                  (tee_local $t
-                    (f32.sub (f32.load (get_local $p)) (get_local $t))
+                  (local.get $c)
+                  (local.tee $t
+                    (f32.sub (f32.load (local.get $p)) (local.get $t))
                   )
                 )
               )
-              (get_local $c)
+              (local.get $c)
             )
-            (get_local $t)
+            (local.get $t)
           )
         )
-        (set_local $p (i32.add (get_local $p) (i32.const 4)))
-        (set_local $c (get_local $sum))
-        (br_if $top (tee_local $n (i32.add (get_local $n) (i32.const -1))))
+        (local.set $p (i32.add (local.get $p) (i32.const 4)))
+        (local.set $c (local.get $sum))
+        (br_if $top (local.tee $n (i32.add (local.get $n) (i32.const -1))))
       )
     )
-    (get_local $sum)
+    (local.get $sum)
   )
 
   (func (export "f32.plain_sum") (param $p i32) (param $n i32) (result f32)
     (local $sum f32)
     (block $exit
       (loop $top
-        (set_local $sum (f32.add (get_local $sum) (f32.load (get_local $p))))
-        (set_local $p (i32.add (get_local $p) (i32.const 4)))
-        (set_local $n (i32.add (get_local $n) (i32.const -1)))
-        (br_if $top (get_local $n))
+        (local.set $sum (f32.add (local.get $sum) (f32.load (local.get $p))))
+        (local.set $p (i32.add (local.get $p) (i32.const 4)))
+        (local.set $n (i32.add (local.get $n) (i32.const -1)))
+        (br_if $top (local.get $n))
       )
     )
-    (get_local $sum)
+    (local.get $sum)
   )
 )
 
@@ -1540,41 +1540,41 @@
     (local $t f64)
     (block $exit
       (loop $top
-        (set_local $t
+        (local.set $t
           (f64.sub
             (f64.sub
-              (tee_local $sum
+              (local.tee $sum
                 (f64.add
-                  (get_local $c)
-                  (tee_local $t
-                    (f64.sub (f64.load (get_local $p)) (get_local $t))
+                  (local.get $c)
+                  (local.tee $t
+                    (f64.sub (f64.load (local.get $p)) (local.get $t))
                   )
                 )
               )
-              (get_local $c)
+              (local.get $c)
             )
-            (get_local $t)
+            (local.get $t)
           )
         )
-        (set_local $p (i32.add (get_local $p) (i32.const 8)))
-        (set_local $c (get_local $sum))
-        (br_if $top (tee_local $n (i32.add (get_local $n) (i32.const -1))))
+        (local.set $p (i32.add (local.get $p) (i32.const 8)))
+        (local.set $c (local.get $sum))
+        (br_if $top (local.tee $n (i32.add (local.get $n) (i32.const -1))))
       )
     )
-    (get_local $sum)
+    (local.get $sum)
   )
 
   (func (export "f64.plain_sum") (param $p i32) (param $n i32) (result f64)
     (local $sum f64)
     (block $exit
       (loop $top
-        (set_local $sum (f64.add (get_local $sum) (f64.load (get_local $p))))
-        (set_local $p (i32.add (get_local $p) (i32.const 8)))
-        (set_local $n (i32.add (get_local $n) (i32.const -1)))
-        (br_if $top (get_local $n))
+        (local.set $sum (f64.add (local.get $sum) (f64.load (local.get $p))))
+        (local.set $p (i32.add (local.get $p) (i32.const 8)))
+        (local.set $n (i32.add (local.get $n) (i32.const -1)))
+        (br_if $top (local.get $n))
       )
     )
-    (get_local $sum)
+    (local.get $sum)
   )
 )
 
@@ -1585,10 +1585,10 @@
 
 (module
   (func (export "f32.no_fold_neg_sub") (param $x f32) (param $y f32) (result f32)
-    (f32.neg (f32.sub (get_local $x) (get_local $y))))
+    (f32.neg (f32.sub (local.get $x) (local.get $y))))
 
   (func (export "f64.no_fold_neg_sub") (param $x f64) (param $y f64) (result f64)
-    (f64.neg (f64.sub (get_local $x) (get_local $y))))
+    (f64.neg (f64.sub (local.get $x) (local.get $y))))
 )
 
 (assert_return (invoke "f32.no_fold_neg_sub" (f32.const -0.0) (f32.const -0.0)) (f32.const -0.0))
@@ -1605,10 +1605,10 @@
 
 (module
   (func (export "f32.no_fold_neg_add") (param $x f32) (param $y f32) (result f32)
-    (f32.neg (f32.add (get_local $x) (get_local $y))))
+    (f32.neg (f32.add (local.get $x) (local.get $y))))
 
   (func (export "f64.no_fold_neg_add") (param $x f64) (param $y f64) (result f64)
-    (f64.neg (f64.add (get_local $x) (get_local $y))))
+    (f64.neg (f64.add (local.get $x) (local.get $y))))
 )
 
 (assert_return (invoke "f32.no_fold_neg_add" (f32.const -0.0) (f32.const -0.0)) (f32.const 0.0))
@@ -1625,10 +1625,10 @@
 
 (module
   (func (export "f32.no_fold_add_neg_neg") (param $x f32) (param $y f32) (result f32)
-    (f32.add (f32.neg (get_local $x)) (f32.neg (get_local $y))))
+    (f32.add (f32.neg (local.get $x)) (f32.neg (local.get $y))))
 
   (func (export "f64.no_fold_add_neg_neg") (param $x f64) (param $y f64) (result f64)
-    (f64.add (f64.neg (get_local $x)) (f64.neg (get_local $y))))
+    (f64.add (f64.neg (local.get $x)) (f64.neg (local.get $y))))
 )
 
 (assert_return (invoke "f32.no_fold_add_neg_neg" (f32.const -0.0) (f32.const -0.0)) (f32.const 0.0))
@@ -1645,10 +1645,10 @@
 
 (module
   (func (export "f32.no_fold_add_neg") (param $x f32) (result f32)
-    (f32.add (f32.neg (get_local $x)) (get_local $x)))
+    (f32.add (f32.neg (local.get $x)) (local.get $x)))
 
   (func (export "f64.no_fold_add_neg") (param $x f64) (result f64)
-    (f64.add (f64.neg (get_local $x)) (get_local $x)))
+    (f64.add (f64.neg (local.get $x)) (local.get $x)))
 )
 
 (assert_return (invoke "f32.no_fold_add_neg" (f32.const 0.0)) (f32.const 0.0))
@@ -1666,15 +1666,15 @@
 (module
   (func (export "f32.no_fold_6x_via_add") (param $x f32) (result f32)
     (f32.add (f32.add (f32.add (f32.add (f32.add
-    (get_local $x)
-    (get_local $x)) (get_local $x)) (get_local $x))
-    (get_local $x)) (get_local $x)))
+    (local.get $x)
+    (local.get $x)) (local.get $x)) (local.get $x))
+    (local.get $x)) (local.get $x)))
 
   (func (export "f64.no_fold_6x_via_add") (param $x f64) (result f64)
     (f64.add (f64.add (f64.add (f64.add (f64.add
-    (get_local $x)
-    (get_local $x)) (get_local $x)) (get_local $x))
-    (get_local $x)) (get_local $x)))
+    (local.get $x)
+    (local.get $x)) (local.get $x)) (local.get $x))
+    (local.get $x)) (local.get $x)))
 )
 
 (assert_return (invoke "f32.no_fold_6x_via_add" (f32.const -0x1.598a0cp+99)) (f32.const -0x1.03278ap+102))
@@ -1694,10 +1694,10 @@
 
 (module
   (func (export "f32.no_fold_div_div") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.div (f32.div (get_local $x) (get_local $y)) (get_local $z)))
+    (f32.div (f32.div (local.get $x) (local.get $y)) (local.get $z)))
 
   (func (export "f64.no_fold_div_div") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.div (f64.div (get_local $x) (get_local $y)) (get_local $z)))
+    (f64.div (f64.div (local.get $x) (local.get $y)) (local.get $z)))
 )
 
 (assert_return (invoke "f32.no_fold_div_div" (f32.const -0x1.f70228p+78) (f32.const -0x1.fbc612p-16) (f32.const -0x1.8c379p+10)) (f32.const -0x1.47b43cp+83))
@@ -1718,10 +1718,10 @@
 
 (module
   (func (export "f32.no_fold_mul_divs") (param $x f32) (param $y f32) (param $z f32) (param $w f32) (result f32)
-    (f32.mul (f32.div (get_local $x) (get_local $y)) (f32.div (get_local $z) (get_local $w))))
+    (f32.mul (f32.div (local.get $x) (local.get $y)) (f32.div (local.get $z) (local.get $w))))
 
   (func (export "f64.no_fold_mul_divs") (param $x f64) (param $y f64) (param $z f64) (param $w f64) (result f64)
-    (f64.mul (f64.div (get_local $x) (get_local $y)) (f64.div (get_local $z) (get_local $w))))
+    (f64.mul (f64.div (local.get $x) (local.get $y)) (f64.div (local.get $z) (local.get $w))))
 )
 
 (assert_return (invoke "f32.no_fold_mul_divs" (f32.const -0x1.c483bep-109) (f32.const 0x1.ee1c3cp-92) (f32.const 0x1.800756p-88) (f32.const -0x1.95b972p+4)) (f32.const 0x1.bbd30cp-110))
@@ -1740,10 +1740,10 @@
 
 (module
   (func (export "f32.no_fold_add_divs") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.add (f32.div (get_local $x) (get_local $z)) (f32.div (get_local $y) (get_local $z))))
+    (f32.add (f32.div (local.get $x) (local.get $z)) (f32.div (local.get $y) (local.get $z))))
 
   (func (export "f64.no_fold_add_divs") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.add (f64.div (get_local $x) (get_local $z)) (f64.div (get_local $y) (get_local $z))))
+    (f64.add (f64.div (local.get $x) (local.get $z)) (f64.div (local.get $y) (local.get $z))))
 )
 
 (assert_return (invoke "f32.no_fold_add_divs" (f32.const 0x1.795e7p+8) (f32.const -0x1.48a5eep-5) (f32.const -0x1.9a244cp+126)) (f32.const -0x1.d709b6p-119))
@@ -1762,10 +1762,10 @@
 
 (module
   (func (export "f32.no_fold_sqrt_square") (param $x f32) (result f32)
-    (f32.sqrt (f32.mul (get_local $x) (get_local $x))))
+    (f32.sqrt (f32.mul (local.get $x) (local.get $x))))
 
   (func (export "f64.no_fold_sqrt_square") (param $x f64) (result f64)
-    (f64.sqrt (f64.mul (get_local $x) (get_local $x))))
+    (f64.sqrt (f64.mul (local.get $x) (local.get $x))))
 )
 
 (assert_return (invoke "f32.no_fold_sqrt_square" (f32.const -0x1.5cb316p-66)) (f32.const 0x1.5cb322p-66))
@@ -1784,10 +1784,10 @@
 
 (module
   (func (export "f32.no_fold_mul_sqrts") (param $x f32) (param $y f32) (result f32)
-    (f32.mul (f32.sqrt (get_local $x)) (f32.sqrt (get_local $y))))
+    (f32.mul (f32.sqrt (local.get $x)) (f32.sqrt (local.get $y))))
 
   (func (export "f64.no_fold_mul_sqrts") (param $x f64) (param $y f64) (result f64)
-    (f64.mul (f64.sqrt (get_local $x)) (f64.sqrt (get_local $y))))
+    (f64.mul (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y))))
 )
 
 (assert_return_canonical_nan (invoke "f32.no_fold_mul_sqrts" (f32.const 0x1.dddda8p-125) (f32.const -0x1.25d22ap-83)))
@@ -1806,10 +1806,10 @@
 
 (module
   (func (export "f32.no_fold_div_sqrts") (param $x f32) (param $y f32) (result f32)
-    (f32.div (f32.sqrt (get_local $x)) (f32.sqrt (get_local $y))))
+    (f32.div (f32.sqrt (local.get $x)) (f32.sqrt (local.get $y))))
 
   (func (export "f64.no_fold_div_sqrts") (param $x f64) (param $y f64) (result f64)
-    (f64.div (f64.sqrt (get_local $x)) (f64.sqrt (get_local $y))))
+    (f64.div (f64.sqrt (local.get $x)) (f64.sqrt (local.get $y))))
 )
 
 (assert_return_canonical_nan (invoke "f32.no_fold_div_sqrts" (f32.const -0x1.bea9bap+25) (f32.const -0x1.db776ep-58)))
@@ -1828,10 +1828,10 @@
 
 (module
   (func (export "f32.no_fold_mul_sqrt_div") (param $x f32) (param $y f32) (result f32)
-    (f32.div (f32.mul (get_local $x) (f32.sqrt (get_local $y))) (get_local $y)))
+    (f32.div (f32.mul (local.get $x) (f32.sqrt (local.get $y))) (local.get $y)))
 
   (func (export "f64.no_fold_mul_sqrt_div") (param $x f64) (param $y f64) (result f64)
-    (f64.div (f64.mul (get_local $x) (f64.sqrt (get_local $y))) (get_local $y)))
+    (f64.div (f64.mul (local.get $x) (f64.sqrt (local.get $y))) (local.get $y)))
 )
 
 (assert_return (invoke "f32.no_fold_mul_sqrt_div" (f32.const -0x1.f4a7cap+81) (f32.const 0x1.c09adep+92)) (f32.const -inf))
@@ -1851,10 +1851,10 @@
 
 (module
   (func (export "f32.no_flush_intermediate_subnormal") (param $x f32) (param $y f32) (param $z f32) (result f32)
-    (f32.mul (f32.mul (get_local $x) (get_local $y)) (get_local $z)))
+    (f32.mul (f32.mul (local.get $x) (local.get $y)) (local.get $z)))
 
   (func (export "f64.no_flush_intermediate_subnormal") (param $x f64) (param $y f64) (param $z f64) (result f64)
-    (f64.mul (f64.mul (get_local $x) (get_local $y)) (get_local $z)))
+    (f64.mul (f64.mul (local.get $x) (local.get $y)) (local.get $z)))
 )
 
 (assert_return (invoke "f32.no_flush_intermediate_subnormal" (f32.const 0x1p-126) (f32.const 0x1p-23) (f32.const 0x1p23)) (f32.const 0x1p-126))
@@ -1865,25 +1865,25 @@
 
 (module
   (func (export "f32.recoding_eq") (param $x f32) (param $y f32) (result i32)
-    (f32.eq (f32.mul (get_local $x) (get_local $y)) (get_local $x)))
+    (f32.eq (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
 
   (func (export "f32.recoding_le") (param $x f32) (param $y f32) (result i32)
-    (f32.le (f32.mul (get_local $x) (get_local $y)) (get_local $x)))
+    (f32.le (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
 
   (func (export "f32.recoding_lt") (param $x f32) (param $y f32) (result i32)
-    (f32.lt (f32.mul (get_local $x) (get_local $y)) (get_local $x)))
+    (f32.lt (f32.mul (local.get $x) (local.get $y)) (local.get $x)))
 
   (func (export "f64.recoding_eq") (param $x f64) (param $y f64) (result i32)
-    (f64.eq (f64.mul (get_local $x) (get_local $y)) (get_local $x)))
+    (f64.eq (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
 
   (func (export "f64.recoding_le") (param $x f64) (param $y f64) (result i32)
-    (f64.le (f64.mul (get_local $x) (get_local $y)) (get_local $x)))
+    (f64.le (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
 
   (func (export "f64.recoding_lt") (param $x f64) (param $y f64) (result i32)
-    (f64.lt (f64.mul (get_local $x) (get_local $y)) (get_local $x)))
+    (f64.lt (f64.mul (local.get $x) (local.get $y)) (local.get $x)))
 
   (func (export "recoding_demote") (param $x f64) (param $y f32) (result f32)
-    (f32.mul (f32.demote/f64 (get_local $x)) (get_local $y)))
+    (f32.mul (f32.demote_f64 (local.get $x)) (local.get $y)))
 )
 
 (assert_return (invoke "f32.recoding_eq" (f32.const -inf) (f32.const 3.0)) (i32.const 1))
@@ -1909,10 +1909,10 @@
 
 (module
   (func (export "f32.no_extended_precision_div") (param $x f32) (param $y f32) (param $z f32) (result i32)
-    (f32.eq (f32.div (get_local $x) (get_local $y)) (get_local $z)))
+    (f32.eq (f32.div (local.get $x) (local.get $y)) (local.get $z)))
 
   (func (export "f64.no_extended_precision_div") (param $x f64) (param $y f64) (param $z f64) (result i32)
-    (f64.eq (f64.div (get_local $x) (get_local $y)) (get_local $z)))
+    (f64.eq (f64.div (local.get $x) (local.get $y)) (local.get $z)))
 )
 
 (assert_return (invoke "f32.no_extended_precision_div" (f32.const 3.0) (f32.const 7.0) (f32.const 0x1.b6db6ep-2)) (i32.const 1))
@@ -1925,10 +1925,10 @@
 
 (module
   (func (export "f32.no_distribute_exact") (param $x f32) (result f32)
-    (f32.add (f32.mul (f32.const -8.0) (get_local $x)) (f32.mul (f32.const 8.0) (get_local $x))))
+    (f32.add (f32.mul (f32.const -8.0) (local.get $x)) (f32.mul (f32.const 8.0) (local.get $x))))
 
   (func (export "f64.no_distribute_exact") (param $x f64) (result f64)
-    (f64.add (f64.mul (f64.const -8.0) (get_local $x)) (f64.mul (f64.const 8.0) (get_local $x))))
+    (f64.add (f64.mul (f64.const -8.0) (local.get $x)) (f64.mul (f64.const 8.0) (local.get $x))))
 )
 
 (assert_return (invoke "f32.no_distribute_exact" (f32.const -0.0)) (f32.const 0.0))
@@ -1939,34 +1939,34 @@
 ;; https://xkcd.com/1047/
 (module
   (func (export "f32.sqrt") (param f32) (result f32)
-    (f32.sqrt (get_local 0)))
+    (f32.sqrt (local.get 0)))
 
   (func (export "f32.xkcd_sqrt_2") (param f32) (param f32) (param f32) (param f32) (result f32)
-    (f32.add (f32.div (get_local 0) (get_local 1)) (f32.div (get_local 2) (f32.sub (get_local 3) (get_local 2)))))
+    (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (f32.sub (local.get 3) (local.get 2)))))
 
   (func (export "f32.xkcd_sqrt_3") (param f32) (param f32) (param f32) (result f32)
-    (f32.div (f32.mul (get_local 0) (get_local 1)) (get_local 2)))
+    (f32.div (f32.mul (local.get 0) (local.get 1)) (local.get 2)))
 
   (func (export "f32.xkcd_sqrt_5") (param f32) (param f32) (param f32) (result f32)
-    (f32.add (f32.div (get_local 0) (get_local 1)) (f32.div (get_local 2) (get_local 0))))
+    (f32.add (f32.div (local.get 0) (local.get 1)) (f32.div (local.get 2) (local.get 0))))
 
   (func (export "f32.xkcd_better_sqrt_5") (param f32) (param f32) (param f32) (param f32) (result f32)
-    (f32.div (f32.add (get_local 0) (f32.mul (get_local 1) (get_local 2))) (f32.sub (get_local 3) (f32.mul (get_local 1) (get_local 2)))))
+    (f32.div (f32.add (local.get 0) (f32.mul (local.get 1) (local.get 2))) (f32.sub (local.get 3) (f32.mul (local.get 1) (local.get 2)))))
 
   (func (export "f64.sqrt") (param f64) (result f64)
-    (f64.sqrt (get_local 0)))
+    (f64.sqrt (local.get 0)))
 
   (func (export "f64.xkcd_sqrt_2") (param f64) (param f64) (param f64) (param f64) (result f64)
-    (f64.add (f64.div (get_local 0) (get_local 1)) (f64.div (get_local 2) (f64.sub (get_local 3) (get_local 2)))))
+    (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (f64.sub (local.get 3) (local.get 2)))))
 
   (func (export "f64.xkcd_sqrt_3") (param f64) (param f64) (param f64) (result f64)
-    (f64.div (f64.mul (get_local 0) (get_local 1)) (get_local 2)))
+    (f64.div (f64.mul (local.get 0) (local.get 1)) (local.get 2)))
 
   (func (export "f64.xkcd_sqrt_5") (param f64) (param f64) (param f64) (result f64)
-    (f64.add (f64.div (get_local 0) (get_local 1)) (f64.div (get_local 2) (get_local 0))))
+    (f64.add (f64.div (local.get 0) (local.get 1)) (f64.div (local.get 2) (local.get 0))))
 
   (func (export "f64.xkcd_better_sqrt_5") (param f64) (param f64) (param f64) (param f64) (result f64)
-    (f64.div (f64.add (get_local 0) (f64.mul (get_local 1) (get_local 2))) (f64.sub (get_local 3) (f64.mul (get_local 1) (get_local 2)))))
+    (f64.div (f64.add (local.get 0) (f64.mul (local.get 1) (local.get 2))) (f64.sub (local.get 3) (f64.mul (local.get 1) (local.get 2)))))
 )
 
 (assert_return (invoke "f32.sqrt" (f32.const 2.0)) (f32.const 0x1.6a09e6p+0))
@@ -1996,10 +1996,10 @@
           (f32.add
             (f32.sub
               (f32.add
-                (tee_local $0 (f32.add (get_local $0) (get_local $0)))
+                (local.tee $0 (f32.add (local.get $0) (local.get $0)))
                 (f32.const 1)
               )
-              (get_local $0)
+              (local.get $0)
             )
             (f32.const -1)
           )
@@ -2013,18 +2013,18 @@
           (f32.sub
             (f32.sub
               (f32.add
-                (get_local $0)
-                (tee_local $1 (f32.add (get_local $1) (f32.const 1)))
+                (local.get $0)
+                (local.tee $1 (f32.add (local.get $1) (f32.const 1)))
               )
-              (get_local $0)
+              (local.get $0)
             )
-            (get_local $1)
+            (local.get $1)
           )
           (f32.const 0)
         )
       )
     )
-    (get_local $1)
+    (local.get $1)
   )
 
   (func (export "f64.compute_radix") (param $0 f64) (param $1 f64) (result f64)
@@ -2034,10 +2034,10 @@
           (f64.add
             (f64.sub
               (f64.add
-                (tee_local $0 (f64.add (get_local $0) (get_local $0)))
+                (local.tee $0 (f64.add (local.get $0) (local.get $0)))
                 (f64.const 1)
               )
-              (get_local $0)
+              (local.get $0)
             )
             (f64.const -1)
           )
@@ -2051,18 +2051,18 @@
           (f64.sub
             (f64.sub
               (f64.add
-                (get_local $0)
-                (tee_local $1 (f64.add (get_local $1) (f64.const 1)))
+                (local.get $0)
+                (local.tee $1 (f64.add (local.get $1) (f64.const 1)))
               )
-              (get_local $0)
+              (local.get $0)
             )
-            (get_local $1)
+            (local.get $1)
           )
           (f64.const 0)
         )
       )
     )
-    (get_local $1)
+    (local.get $1)
   )
 )
 
@@ -2074,10 +2074,10 @@
 
 (module
   (func (export "f32.no_fold_sub1_mul_add") (param $x f32) (param $y f32) (result f32)
-    (f32.add (f32.mul (f32.sub (get_local $x) (f32.const 1.0)) (get_local $y)) (get_local $y)))
+    (f32.add (f32.mul (f32.sub (local.get $x) (f32.const 1.0)) (local.get $y)) (local.get $y)))
 
   (func (export "f64.no_fold_sub1_mul_add") (param $x f64) (param $y f64) (result f64)
-    (f64.add (f64.mul (f64.sub (get_local $x) (f64.const 1.0)) (get_local $y)) (get_local $y)))
+    (f64.add (f64.mul (f64.sub (local.get $x) (f64.const 1.0)) (local.get $y)) (local.get $y)))
 )
 
 (assert_return (invoke "f32.no_fold_sub1_mul_add" (f32.const 0x1p-32) (f32.const 1.0)) (f32.const 0x0p+0))
@@ -2088,16 +2088,16 @@
 
 (module
   (func (export "f32.no_fold_add_le_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32)
-    (f32.le (f32.add (get_local $x) (get_local $z)) (f32.add (get_local $y) (get_local $z))))
+    (f32.le (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z))))
 
   (func (export "f32.no_fold_add_ge_monotonicity") (param $x f32) (param $y f32) (param $z f32) (result i32)
-    (f32.ge (f32.add (get_local $x) (get_local $z)) (f32.add (get_local $y) (get_local $z))))
+    (f32.ge (f32.add (local.get $x) (local.get $z)) (f32.add (local.get $y) (local.get $z))))
 
   (func (export "f64.no_fold_add_le_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32)
-    (f64.le (f64.add (get_local $x) (get_local $z)) (f64.add (get_local $y) (get_local $z))))
+    (f64.le (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z))))
 
   (func (export "f64.no_fold_add_ge_monotonicity") (param $x f64) (param $y f64) (param $z f64) (result i32)
-    (f64.ge (f64.add (get_local $x) (get_local $z)) (f64.add (get_local $y) (get_local $z))))
+    (f64.ge (f64.add (local.get $x) (local.get $z)) (f64.add (local.get $y) (local.get $z))))
 )
 
 (assert_return (invoke "f32.no_fold_add_le_monotonicity" (f32.const 0.0) (f32.const 0.0) (f32.const nan)) (i32.const 0))
@@ -2109,28 +2109,28 @@
 
 (module
   (func (export "f32.not_lt") (param $x f32) (param $y f32) (result i32)
-    (i32.eqz (f32.lt (get_local $x) (get_local $y))))
+    (i32.eqz (f32.lt (local.get $x) (local.get $y))))
 
   (func (export "f32.not_le") (param $x f32) (param $y f32) (result i32)
-    (i32.eqz (f32.le (get_local $x) (get_local $y))))
+    (i32.eqz (f32.le (local.get $x) (local.get $y))))
 
   (func (export "f32.not_gt") (param $x f32) (param $y f32) (result i32)
-    (i32.eqz (f32.gt (get_local $x) (get_local $y))))
+    (i32.eqz (f32.gt (local.get $x) (local.get $y))))
 
   (func (export "f32.not_ge") (param $x f32) (param $y f32) (result i32)
-    (i32.eqz (f32.ge (get_local $x) (get_local $y))))
+    (i32.eqz (f32.ge (local.get $x) (local.get $y))))
 
   (func (export "f64.not_lt") (param $x f64) (param $y f64) (result i32)
-    (i32.eqz (f64.lt (get_local $x) (get_local $y))))
+    (i32.eqz (f64.lt (local.get $x) (local.get $y))))
 
   (func (export "f64.not_le") (param $x f64) (param $y f64) (result i32)
-    (i32.eqz (f64.le (get_local $x) (get_local $y))))
+    (i32.eqz (f64.le (local.get $x) (local.get $y))))
 
   (func (export "f64.not_gt") (param $x f64) (param $y f64) (result i32)
-    (i32.eqz (f64.gt (get_local $x) (get_local $y))))
+    (i32.eqz (f64.gt (local.get $x) (local.get $y))))
 
   (func (export "f64.not_ge") (param $x f64) (param $y f64) (result i32)
-    (i32.eqz (f64.ge (get_local $x) (get_local $y))))
+    (i32.eqz (f64.ge (local.get $x) (local.get $y))))
 )
 
 (assert_return (invoke "f32.not_lt" (f32.const nan) (f32.const 0.0)) (i32.const 1))
@@ -2165,14 +2165,14 @@
   (func (export "f32.epsilon") (result f32)
     (local $x f32)
     (local $result f32)
-    (set_local $x (f32.const 1))
+    (local.set $x (f32.const 1))
     (loop $loop
       (br_if $loop
         (f32.gt
           (f32.add
-            (tee_local $x
+            (local.tee $x
               (f32.mul
-                (tee_local $result (get_local $x))
+                (local.tee $result (local.get $x))
                 (f32.const 0.5)
               )
             )
@@ -2182,20 +2182,20 @@
         )
       )
     )
-    (get_local $result)
+    (local.get $result)
   )
 
   (func (export "f64.epsilon") (result f64)
     (local $x f64)
     (local $result f64)
-    (set_local $x (f64.const 1))
+    (local.set $x (f64.const 1))
     (loop $loop
       (br_if $loop
         (f64.gt
           (f64.add
-            (tee_local $x
+            (local.tee $x
               (f64.mul
-                (tee_local $result (get_local $x))
+                (local.tee $result (local.get $x))
                 (f64.const 0.5)
               )
             )
@@ -2205,7 +2205,7 @@
         )
       )
     )
-    (get_local $result)
+    (local.get $result)
   )
 )
 
@@ -2217,22 +2217,22 @@
 
 (module
   (func (export "f32.no_trichotomy_lt") (param $x f32) (param $y f32) (result i32)
-    (i32.or (f32.lt (get_local $x) (get_local $y)) (f32.ge (get_local $x) (get_local $y))))
+    (i32.or (f32.lt (local.get $x) (local.get $y)) (f32.ge (local.get $x) (local.get $y))))
   (func (export "f32.no_trichotomy_le") (param $x f32) (param $y f32) (result i32)
-    (i32.or (f32.le (get_local $x) (get_local $y)) (f32.gt (get_local $x) (get_local $y))))
+    (i32.or (f32.le (local.get $x) (local.get $y)) (f32.gt (local.get $x) (local.get $y))))
   (func (export "f32.no_trichotomy_gt") (param $x f32) (param $y f32) (result i32)
-    (i32.or (f32.gt (get_local $x) (get_local $y)) (f32.le (get_local $x) (get_local $y))))
+    (i32.or (f32.gt (local.get $x) (local.get $y)) (f32.le (local.get $x) (local.get $y))))
   (func (export "f32.no_trichotomy_ge") (param $x f32) (param $y f32) (result i32)
-    (i32.or (f32.ge (get_local $x) (get_local $y)) (f32.lt (get_local $x) (get_local $y))))
+    (i32.or (f32.ge (local.get $x) (local.get $y)) (f32.lt (local.get $x) (local.get $y))))
 
   (func (export "f64.no_trichotomy_lt") (param $x f64) (param $y f64) (result i32)
-    (i32.or (f64.lt (get_local $x) (get_local $y)) (f64.ge (get_local $x) (get_local $y))))
+    (i32.or (f64.lt (local.get $x) (local.get $y)) (f64.ge (local.get $x) (local.get $y))))
   (func (export "f64.no_trichotomy_le") (param $x f64) (param $y f64) (result i32)
-    (i32.or (f64.le (get_local $x) (get_local $y)) (f64.gt (get_local $x) (get_local $y))))
+    (i32.or (f64.le (local.get $x) (local.get $y)) (f64.gt (local.get $x) (local.get $y))))
   (func (export "f64.no_trichotomy_gt") (param $x f64) (param $y f64) (result i32)
-    (i32.or (f64.gt (get_local $x) (get_local $y)) (f64.le (get_local $x) (get_local $y))))
+    (i32.or (f64.gt (local.get $x) (local.get $y)) (f64.le (local.get $x) (local.get $y))))
   (func (export "f64.no_trichotomy_ge") (param $x f64) (param $y f64) (result i32)
-    (i32.or (f64.ge (get_local $x) (get_local $y)) (f64.lt (get_local $x) (get_local $y))))
+    (i32.or (f64.ge (local.get $x) (local.get $y)) (f64.lt (local.get $x) (local.get $y))))
 )
 
 (assert_return (invoke "f32.no_trichotomy_lt" (f32.const 0.0) (f32.const nan)) (i32.const 0))
@@ -2250,79 +2250,79 @@
 (module
   (func (export "f32.arithmetic_nan_bitpattern")
         (param $x i32) (param $y i32) (result i32)
-    (i32.and (i32.reinterpret/f32
+    (i32.and (i32.reinterpret_f32
                (f32.div
-                 (f32.reinterpret/i32 (get_local $x))
-                 (f32.reinterpret/i32 (get_local $y))))
+                 (f32.reinterpret_i32 (local.get $x))
+                 (f32.reinterpret_i32 (local.get $y))))
              (i32.const 0x7fc00000)))
   (func (export "f32.canonical_nan_bitpattern")
         (param $x i32) (param $y i32) (result i32)
-    (i32.and (i32.reinterpret/f32
+    (i32.and (i32.reinterpret_f32
                (f32.div
-                 (f32.reinterpret/i32 (get_local $x))
-                 (f32.reinterpret/i32 (get_local $y))))
+                 (f32.reinterpret_i32 (local.get $x))
+                 (f32.reinterpret_i32 (local.get $y))))
              (i32.const 0x7fffffff)))
   (func (export "f32.nonarithmetic_nan_bitpattern")
         (param $x i32) (result i32)
-    (i32.reinterpret/f32 (f32.neg (f32.reinterpret/i32 (get_local $x)))))
+    (i32.reinterpret_f32 (f32.neg (f32.reinterpret_i32 (local.get $x)))))
 
   (func (export "f64.arithmetic_nan_bitpattern")
         (param $x i64) (param $y i64) (result i64)
-    (i64.and (i64.reinterpret/f64
+    (i64.and (i64.reinterpret_f64
                (f64.div
-                 (f64.reinterpret/i64 (get_local $x))
-                 (f64.reinterpret/i64 (get_local $y))))
+                 (f64.reinterpret_i64 (local.get $x))
+                 (f64.reinterpret_i64 (local.get $y))))
              (i64.const 0x7ff8000000000000)))
   (func (export "f64.canonical_nan_bitpattern")
         (param $x i64) (param $y i64) (result i64)
-    (i64.and (i64.reinterpret/f64
+    (i64.and (i64.reinterpret_f64
                (f64.div
-                 (f64.reinterpret/i64 (get_local $x))
-                 (f64.reinterpret/i64 (get_local $y))))
+                 (f64.reinterpret_i64 (local.get $x))
+                 (f64.reinterpret_i64 (local.get $y))))
              (i64.const 0x7fffffffffffffff)))
   (func (export "f64.nonarithmetic_nan_bitpattern")
         (param $x i64) (result i64)
-    (i64.reinterpret/f64 (f64.neg (f64.reinterpret/i64 (get_local $x)))))
+    (i64.reinterpret_f64 (f64.neg (f64.reinterpret_i64 (local.get $x)))))
 
   ;; Versions of no_fold testcases that only care about NaN bitpatterns.
   (func (export "f32.no_fold_sub_zero") (param $x i32) (result i32)
-    (i32.and (i32.reinterpret/f32 (f32.sub (f32.reinterpret/i32 (get_local $x)) (f32.const 0.0)))
+    (i32.and (i32.reinterpret_f32 (f32.sub (f32.reinterpret_i32 (local.get $x)) (f32.const 0.0)))
              (i32.const 0x7fc00000)))
   (func (export "f32.no_fold_neg0_sub") (param $x i32) (result i32)
-    (i32.and (i32.reinterpret/f32 (f32.sub (f32.const -0.0) (f32.reinterpret/i32 (get_local $x))))
+    (i32.and (i32.reinterpret_f32 (f32.sub (f32.const -0.0) (f32.reinterpret_i32 (local.get $x))))
              (i32.const 0x7fc00000)))
   (func (export "f32.no_fold_mul_one") (param $x i32) (result i32)
-    (i32.and (i32.reinterpret/f32 (f32.mul (f32.reinterpret/i32 (get_local $x)) (f32.const 1.0)))
+    (i32.and (i32.reinterpret_f32 (f32.mul (f32.reinterpret_i32 (local.get $x)) (f32.const 1.0)))
              (i32.const 0x7fc00000)))
   (func (export "f32.no_fold_neg1_mul") (param $x i32) (result i32)
-    (i32.and (i32.reinterpret/f32 (f32.mul (f32.const -1.0) (f32.reinterpret/i32 (get_local $x))))
+    (i32.and (i32.reinterpret_f32 (f32.mul (f32.const -1.0) (f32.reinterpret_i32 (local.get $x))))
              (i32.const 0x7fc00000)))
   (func (export "f32.no_fold_div_one") (param $x i32) (result i32)
-    (i32.and (i32.reinterpret/f32 (f32.div (f32.reinterpret/i32 (get_local $x)) (f32.const 1.0)))
+    (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $x)) (f32.const 1.0)))
              (i32.const 0x7fc00000)))
   (func (export "f32.no_fold_div_neg1") (param $x i32) (result i32)
-    (i32.and (i32.reinterpret/f32 (f32.div (f32.reinterpret/i32 (get_local $x)) (f32.const -1.0)))
+    (i32.and (i32.reinterpret_f32 (f32.div (f32.reinterpret_i32 (local.get $x)) (f32.const -1.0)))
              (i32.const 0x7fc00000)))
   (func (export "f64.no_fold_sub_zero") (param $x i64) (result i64)
-    (i64.and (i64.reinterpret/f64 (f64.sub (f64.reinterpret/i64 (get_local $x)) (f64.const 0.0)))
+    (i64.and (i64.reinterpret_f64 (f64.sub (f64.reinterpret_i64 (local.get $x)) (f64.const 0.0)))
              (i64.const 0x7ff8000000000000)))
   (func (export "f64.no_fold_neg0_sub") (param $x i64) (result i64)
-    (i64.and (i64.reinterpret/f64 (f64.sub (f64.const -0.0) (f64.reinterpret/i64 (get_local $x))))
+    (i64.and (i64.reinterpret_f64 (f64.sub (f64.const -0.0) (f64.reinterpret_i64 (local.get $x))))
              (i64.const 0x7ff8000000000000)))
   (func (export "f64.no_fold_mul_one") (param $x i64) (result i64)
-    (i64.and (i64.reinterpret/f64 (f64.mul (f64.reinterpret/i64 (get_local $x)) (f64.const 1.0)))
+    (i64.and (i64.reinterpret_f64 (f64.mul (f64.reinterpret_i64 (local.get $x)) (f64.const 1.0)))
              (i64.const 0x7ff8000000000000)))
   (func (export "f64.no_fold_neg1_mul") (param $x i64) (result i64)
-    (i64.and (i64.reinterpret/f64 (f64.mul (f64.const -1.0) (f64.reinterpret/i64 (get_local $x))))
+    (i64.and (i64.reinterpret_f64 (f64.mul (f64.const -1.0) (f64.reinterpret_i64 (local.get $x))))
              (i64.const 0x7ff8000000000000)))
   (func (export "f64.no_fold_div_one") (param $x i64) (result i64)
-    (i64.and (i64.reinterpret/f64 (f64.div (f64.reinterpret/i64 (get_local $x)) (f64.const 1.0)))
+    (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $x)) (f64.const 1.0)))
              (i64.const 0x7ff8000000000000)))
   (func (export "f64.no_fold_div_neg1") (param $x i64) (result i64)
-    (i64.and (i64.reinterpret/f64 (f64.div (f64.reinterpret/i64 (get_local $x)) (f64.const -1.0)))
+    (i64.and (i64.reinterpret_f64 (f64.div (f64.reinterpret_i64 (local.get $x)) (f64.const -1.0)))
              (i64.const 0x7ff8000000000000)))
   (func (export "no_fold_promote_demote") (param $x i32) (result i32)
-    (i32.and (i32.reinterpret/f32 (f32.demote/f64 (f64.promote/f32 (f32.reinterpret/i32 (get_local $x)))))
+    (i32.and (i32.reinterpret_f32 (f32.demote_f64 (f64.promote_f32 (f32.reinterpret_i32 (local.get $x)))))
              (i32.const 0x7fc00000)))
 )
 
@@ -2369,20 +2369,20 @@
         (param $y0 f64) (param $y1 f64) (param $y2 f64) (param $y3 f64)
         (result f64)
     (f64.add (f64.add (f64.add
-      (f64.mul (get_local $x0) (get_local $y0))
-      (f64.mul (get_local $x1) (get_local $y1)))
-      (f64.mul (get_local $x2) (get_local $y2)))
-      (f64.mul (get_local $x3) (get_local $y3)))
+      (f64.mul (local.get $x0) (local.get $y0))
+      (f64.mul (local.get $x1) (local.get $y1)))
+      (f64.mul (local.get $x2) (local.get $y2)))
+      (f64.mul (local.get $x3) (local.get $y3)))
   )
 
   (func (export "with_binary_sum_collapse")
         (param $x0 f64) (param $x1 f64) (param $x2 f64) (param $x3 f64)
         (param $y0 f64) (param $y1 f64) (param $y2 f64) (param $y3 f64)
         (result f64)
-      (f64.add (f64.add (f64.mul (get_local $x0) (get_local $y0))
-                        (f64.mul (get_local $x1) (get_local $y1)))
-               (f64.add (f64.mul (get_local $x2) (get_local $y2))
-                        (f64.mul (get_local $x3) (get_local $y3))))
+      (f64.add (f64.add (f64.mul (local.get $x0) (local.get $y0))
+                        (f64.mul (local.get $x1) (local.get $y1)))
+               (f64.add (f64.mul (local.get $x2) (local.get $y2))
+                        (f64.mul (local.get $x3) (local.get $y3))))
   )
 )
 
@@ -2400,12 +2400,12 @@
 (module
   (func (export "f32.contract2fma")
         (param $x f32) (param $y f32) (result f32)
-    (f32.sqrt (f32.sub (f32.mul (get_local $x) (get_local $x))
-                       (f32.mul (get_local $y) (get_local $y)))))
+    (f32.sqrt (f32.sub (f32.mul (local.get $x) (local.get $x))
+                       (f32.mul (local.get $y) (local.get $y)))))
   (func (export "f64.contract2fma")
         (param $x f64) (param $y f64) (result f64)
-    (f64.sqrt (f64.sub (f64.mul (get_local $x) (get_local $x))
-                       (f64.mul (get_local $y) (get_local $y)))))
+    (f64.sqrt (f64.sub (f64.mul (local.get $x) (local.get $x))
+                       (f64.mul (local.get $y) (local.get $y)))))
 )
 
 (assert_return (invoke "f32.contract2fma" (f32.const 1.0) (f32.const 1.0)) (f32.const 0.0))
@@ -2421,10 +2421,10 @@
 (module
   (func (export "f32.division_by_small_number")
         (param $a f32) (param $b f32) (param $c f32) (result f32)
-    (f32.sub (get_local $a) (f32.div (get_local $b) (get_local $c))))
+    (f32.sub (local.get $a) (f32.div (local.get $b) (local.get $c))))
   (func (export "f64.division_by_small_number")
         (param $a f64) (param $b f64) (param $c f64) (result f64)
-    (f64.sub (get_local $a) (f64.div (get_local $b) (get_local $c))))
+    (f64.sub (local.get $a) (f64.div (local.get $b) (local.get $c))))
 )
 
 (assert_return (invoke "f32.division_by_small_number" (f32.const 112000000) (f32.const 100000) (f32.const 0.0009)) (f32.const 888888))
@@ -2435,9 +2435,9 @@
 
 (module
   (func (export "f32.golden_ratio") (param $a f32) (param $b f32) (param $c f32) (result f32)
-    (f32.mul (get_local 0) (f32.add (get_local 1) (f32.sqrt (get_local 2)))))
+    (f32.mul (local.get 0) (f32.add (local.get 1) (f32.sqrt (local.get 2)))))
   (func (export "f64.golden_ratio") (param $a f64) (param $b f64) (param $c f64) (result f64)
-    (f64.mul (get_local 0) (f64.add (get_local 1) (f64.sqrt (get_local 2)))))
+    (f64.mul (local.get 0) (f64.add (local.get 1) (f64.sqrt (local.get 2)))))
 )
 
 (assert_return (invoke "f32.golden_ratio" (f32.const 0.5) (f32.const 1.0) (f32.const 5.0)) (f32.const 1.618034))
@@ -2449,13 +2449,13 @@
 (module
   (func (export "f32.silver_means") (param $n f32) (result f32)
     (f32.mul (f32.const 0.5)
-             (f32.add (get_local $n)
-                      (f32.sqrt (f32.add (f32.mul (get_local $n) (get_local $n))
+             (f32.add (local.get $n)
+                      (f32.sqrt (f32.add (f32.mul (local.get $n) (local.get $n))
                                          (f32.const 4.0))))))
   (func (export "f64.silver_means") (param $n f64) (result f64)
     (f64.mul (f64.const 0.5)
-             (f64.add (get_local $n)
-                      (f64.sqrt (f64.add (f64.mul (get_local $n) (get_local $n))
+             (f64.add (local.get $n)
+                      (f64.sqrt (f64.add (f64.mul (local.get $n) (local.get $n))
                                          (f64.const 4.0))))))
 )
 
@@ -2477,7 +2477,7 @@
 
 (module
   (func (export "point_four") (param $four f64) (param $ten f64) (result i32)
-    (f64.lt (f64.div (get_local $four) (get_local $ten)) (f64.const 0.4)))
+    (f64.lt (f64.div (local.get $four) (local.get $ten)) (f64.const 0.4)))
 )
 
 (assert_return (invoke "point_four" (f64.const 4.0) (f64.const 10.0)) (i32.const 0))
@@ -2489,64 +2489,64 @@
   (func (export "tau") (param i32) (result f64)
     (local f64 f64 f64 f64)
     f64.const 0x0p+0
-    set_local 1
+    local.set 1
     block
-      get_local 0
+      local.get 0
       i32.const 1
       i32.lt_s
       br_if 0
       f64.const 0x1p+0
-      set_local 2
+      local.set 2
       f64.const 0x0p+0
-      set_local 3
+      local.set 3
       loop
-        get_local 1
-        get_local 2
+        local.get 1
+        local.get 2
         f64.const 0x1p+3
-        get_local 3
+        local.get 3
         f64.const 0x1p+3
         f64.mul
-        tee_local 4
+        local.tee 4
         f64.const 0x1p+0
         f64.add
         f64.div
         f64.const 0x1p+2
-        get_local 4
+        local.get 4
         f64.const 0x1p+2
         f64.add
         f64.div
         f64.sub
         f64.const 0x1p+1
-        get_local 4
+        local.get 4
         f64.const 0x1.4p+2
         f64.add
         f64.div
         f64.sub
         f64.const 0x1p+1
-        get_local 4
+        local.get 4
         f64.const 0x1.8p+2
         f64.add
         f64.div
         f64.sub
         f64.mul
         f64.add
-        set_local 1
-        get_local 3
+        local.set 1
+        local.get 3
         f64.const 0x1p+0
         f64.add
-        set_local 3
-        get_local 2
+        local.set 3
+        local.get 2
         f64.const 0x1p-4
         f64.mul
-        set_local 2
-        get_local 0
+        local.set 2
+        local.get 0
         i32.const -1
         i32.add
-        tee_local 0
+        local.tee 0
         br_if 0
       end
     end
-    get_local 1
+    local.get 1
   )
 )
 
@@ -2557,13 +2557,13 @@
 
 (module
   (func (export "f32.no_fold_conditional_inc") (param $x f32) (param $y f32) (result f32)
-    (select (get_local $x)
-            (f32.add (get_local $x) (f32.const 1.0))
-            (f32.lt (get_local $y) (f32.const 0.0))))
+    (select (local.get $x)
+            (f32.add (local.get $x) (f32.const 1.0))
+            (f32.lt (local.get $y) (f32.const 0.0))))
   (func (export "f64.no_fold_conditional_inc") (param $x f64) (param $y f64) (result f64)
-    (select (get_local $x)
-            (f64.add (get_local $x) (f64.const 1.0))
-            (f64.lt (get_local $y) (f64.const 0.0))))
+    (select (local.get $x)
+            (f64.add (local.get $x) (f64.const 1.0))
+            (f64.lt (local.get $y) (f64.const 0.0))))
 )
 
 (assert_return (invoke "f32.no_fold_conditional_inc" (f32.const -0.0) (f32.const -1.0)) (f32.const -0.0))
diff --git a/test/core/float_literals.wast b/test/core/float_literals.wast
index 28acabec2..fefb91fbb 100644
--- a/test/core/float_literals.wast
+++ b/test/core/float_literals.wast
@@ -2,82 +2,82 @@
 
 (module
   ;; f32 special values
-  (func (export "f32.nan") (result i32) (i32.reinterpret/f32 (f32.const nan)))
-  (func (export "f32.positive_nan") (result i32) (i32.reinterpret/f32 (f32.const +nan)))
-  (func (export "f32.negative_nan") (result i32) (i32.reinterpret/f32 (f32.const -nan)))
-  (func (export "f32.plain_nan") (result i32) (i32.reinterpret/f32 (f32.const nan:0x400000)))
-  (func (export "f32.informally_known_as_plain_snan") (result i32) (i32.reinterpret/f32 (f32.const nan:0x200000)))
-  (func (export "f32.all_ones_nan") (result i32) (i32.reinterpret/f32 (f32.const -nan:0x7fffff)))
-  (func (export "f32.misc_nan") (result i32) (i32.reinterpret/f32 (f32.const nan:0x012345)))
-  (func (export "f32.misc_positive_nan") (result i32) (i32.reinterpret/f32 (f32.const +nan:0x304050)))
-  (func (export "f32.misc_negative_nan") (result i32) (i32.reinterpret/f32 (f32.const -nan:0x2abcde)))
-  (func (export "f32.infinity") (result i32) (i32.reinterpret/f32 (f32.const inf)))
-  (func (export "f32.positive_infinity") (result i32) (i32.reinterpret/f32 (f32.const +inf)))
-  (func (export "f32.negative_infinity") (result i32) (i32.reinterpret/f32 (f32.const -inf)))
+  (func (export "f32.nan") (result i32) (i32.reinterpret_f32 (f32.const nan)))
+  (func (export "f32.positive_nan") (result i32) (i32.reinterpret_f32 (f32.const +nan)))
+  (func (export "f32.negative_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan)))
+  (func (export "f32.plain_nan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x400000)))
+  (func (export "f32.informally_known_as_plain_snan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x200000)))
+  (func (export "f32.all_ones_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan:0x7fffff)))
+  (func (export "f32.misc_nan") (result i32) (i32.reinterpret_f32 (f32.const nan:0x012345)))
+  (func (export "f32.misc_positive_nan") (result i32) (i32.reinterpret_f32 (f32.const +nan:0x304050)))
+  (func (export "f32.misc_negative_nan") (result i32) (i32.reinterpret_f32 (f32.const -nan:0x2abcde)))
+  (func (export "f32.infinity") (result i32) (i32.reinterpret_f32 (f32.const inf)))
+  (func (export "f32.positive_infinity") (result i32) (i32.reinterpret_f32 (f32.const +inf)))
+  (func (export "f32.negative_infinity") (result i32) (i32.reinterpret_f32 (f32.const -inf)))
 
   ;; f32 numbers
-  (func (export "f32.zero") (result i32) (i32.reinterpret/f32 (f32.const 0x0.0p0)))
-  (func (export "f32.positive_zero") (result i32) (i32.reinterpret/f32 (f32.const +0x0.0p0)))
-  (func (export "f32.negative_zero") (result i32) (i32.reinterpret/f32 (f32.const -0x0.0p0)))
-  (func (export "f32.misc") (result i32) (i32.reinterpret/f32 (f32.const 0x1.921fb6p+2)))
-  (func (export "f32.min_positive") (result i32) (i32.reinterpret/f32 (f32.const 0x1p-149)))
-  (func (export "f32.min_normal") (result i32) (i32.reinterpret/f32 (f32.const 0x1p-126)))
-  (func (export "f32.max_finite") (result i32) (i32.reinterpret/f32 (f32.const 0x1.fffffep+127)))
-  (func (export "f32.max_subnormal") (result i32) (i32.reinterpret/f32 (f32.const 0x1.fffffcp-127)))
-  (func (export "f32.trailing_dot") (result i32) (i32.reinterpret/f32 (f32.const 0x1.p10)))
+  (func (export "f32.zero") (result i32) (i32.reinterpret_f32 (f32.const 0x0.0p0)))
+  (func (export "f32.positive_zero") (result i32) (i32.reinterpret_f32 (f32.const +0x0.0p0)))
+  (func (export "f32.negative_zero") (result i32) (i32.reinterpret_f32 (f32.const -0x0.0p0)))
+  (func (export "f32.misc") (result i32) (i32.reinterpret_f32 (f32.const 0x1.921fb6p+2)))
+  (func (export "f32.min_positive") (result i32) (i32.reinterpret_f32 (f32.const 0x1p-149)))
+  (func (export "f32.min_normal") (result i32) (i32.reinterpret_f32 (f32.const 0x1p-126)))
+  (func (export "f32.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffep+127)))
+  (func (export "f32.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 0x1.fffffcp-127)))
+  (func (export "f32.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 0x1.p10)))
 
   ;; f32 in decimal format
-  (func (export "f32_dec.zero") (result i32) (i32.reinterpret/f32 (f32.const 0.0e0)))
-  (func (export "f32_dec.positive_zero") (result i32) (i32.reinterpret/f32 (f32.const +0.0e0)))
-  (func (export "f32_dec.negative_zero") (result i32) (i32.reinterpret/f32 (f32.const -0.0e0)))
-  (func (export "f32_dec.misc") (result i32) (i32.reinterpret/f32 (f32.const 6.28318548202514648)))
-  (func (export "f32_dec.min_positive") (result i32) (i32.reinterpret/f32 (f32.const 1.4013e-45)))
-  (func (export "f32_dec.min_normal") (result i32) (i32.reinterpret/f32 (f32.const 1.1754944e-38)))
-  (func (export "f32_dec.max_subnormal") (result i32) (i32.reinterpret/f32 (f32.const 1.1754942e-38)))
-  (func (export "f32_dec.max_finite") (result i32) (i32.reinterpret/f32 (f32.const 3.4028234e+38)))
-  (func (export "f32_dec.trailing_dot") (result i32) (i32.reinterpret/f32 (f32.const 1.e10)))
+  (func (export "f32_dec.zero") (result i32) (i32.reinterpret_f32 (f32.const 0.0e0)))
+  (func (export "f32_dec.positive_zero") (result i32) (i32.reinterpret_f32 (f32.const +0.0e0)))
+  (func (export "f32_dec.negative_zero") (result i32) (i32.reinterpret_f32 (f32.const -0.0e0)))
+  (func (export "f32_dec.misc") (result i32) (i32.reinterpret_f32 (f32.const 6.28318548202514648)))
+  (func (export "f32_dec.min_positive") (result i32) (i32.reinterpret_f32 (f32.const 1.4013e-45)))
+  (func (export "f32_dec.min_normal") (result i32) (i32.reinterpret_f32 (f32.const 1.1754944e-38)))
+  (func (export "f32_dec.max_subnormal") (result i32) (i32.reinterpret_f32 (f32.const 1.1754942e-38)))
+  (func (export "f32_dec.max_finite") (result i32) (i32.reinterpret_f32 (f32.const 3.4028234e+38)))
+  (func (export "f32_dec.trailing_dot") (result i32) (i32.reinterpret_f32 (f32.const 1.e10)))
 
   ;; https://twitter.com/Archivd/status/994637336506912768
-  (func (export "f32_dec.root_beer_float") (result i32) (i32.reinterpret/f32 (f32.const 1.000000119)))
+  (func (export "f32_dec.root_beer_float") (result i32) (i32.reinterpret_f32 (f32.const 1.000000119)))
 
   ;; f64 special values
-  (func (export "f64.nan") (result i64) (i64.reinterpret/f64 (f64.const nan)))
-  (func (export "f64.positive_nan") (result i64) (i64.reinterpret/f64 (f64.const +nan)))
-  (func (export "f64.negative_nan") (result i64) (i64.reinterpret/f64 (f64.const -nan)))
-  (func (export "f64.plain_nan") (result i64) (i64.reinterpret/f64 (f64.const nan:0x8000000000000)))
-  (func (export "f64.informally_known_as_plain_snan") (result i64) (i64.reinterpret/f64 (f64.const nan:0x4000000000000)))
-  (func (export "f64.all_ones_nan") (result i64) (i64.reinterpret/f64 (f64.const -nan:0xfffffffffffff)))
-  (func (export "f64.misc_nan") (result i64) (i64.reinterpret/f64 (f64.const nan:0x0123456789abc)))
-  (func (export "f64.misc_positive_nan") (result i64) (i64.reinterpret/f64 (f64.const +nan:0x3040506070809)))
-  (func (export "f64.misc_negative_nan") (result i64) (i64.reinterpret/f64 (f64.const -nan:0x2abcdef012345)))
-  (func (export "f64.infinity") (result i64) (i64.reinterpret/f64 (f64.const inf)))
-  (func (export "f64.positive_infinity") (result i64) (i64.reinterpret/f64 (f64.const +inf)))
-  (func (export "f64.negative_infinity") (result i64) (i64.reinterpret/f64 (f64.const -inf)))
+  (func (export "f64.nan") (result i64) (i64.reinterpret_f64 (f64.const nan)))
+  (func (export "f64.positive_nan") (result i64) (i64.reinterpret_f64 (f64.const +nan)))
+  (func (export "f64.negative_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan)))
+  (func (export "f64.plain_nan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x8000000000000)))
+  (func (export "f64.informally_known_as_plain_snan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x4000000000000)))
+  (func (export "f64.all_ones_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan:0xfffffffffffff)))
+  (func (export "f64.misc_nan") (result i64) (i64.reinterpret_f64 (f64.const nan:0x0123456789abc)))
+  (func (export "f64.misc_positive_nan") (result i64) (i64.reinterpret_f64 (f64.const +nan:0x3040506070809)))
+  (func (export "f64.misc_negative_nan") (result i64) (i64.reinterpret_f64 (f64.const -nan:0x2abcdef012345)))
+  (func (export "f64.infinity") (result i64) (i64.reinterpret_f64 (f64.const inf)))
+  (func (export "f64.positive_infinity") (result i64) (i64.reinterpret_f64 (f64.const +inf)))
+  (func (export "f64.negative_infinity") (result i64) (i64.reinterpret_f64 (f64.const -inf)))
 
   ;; f64 numbers
-  (func (export "f64.zero") (result i64) (i64.reinterpret/f64 (f64.const 0x0.0p0)))
-  (func (export "f64.positive_zero") (result i64) (i64.reinterpret/f64 (f64.const +0x0.0p0)))
-  (func (export "f64.negative_zero") (result i64) (i64.reinterpret/f64 (f64.const -0x0.0p0)))
-  (func (export "f64.misc") (result i64) (i64.reinterpret/f64 (f64.const 0x1.921fb54442d18p+2)))
-  (func (export "f64.min_positive") (result i64) (i64.reinterpret/f64 (f64.const 0x0.0000000000001p-1022)))
-  (func (export "f64.min_normal") (result i64) (i64.reinterpret/f64 (f64.const 0x1p-1022)))
-  (func (export "f64.max_subnormal") (result i64) (i64.reinterpret/f64 (f64.const 0x0.fffffffffffffp-1022)))
-  (func (export "f64.max_finite") (result i64) (i64.reinterpret/f64 (f64.const 0x1.fffffffffffffp+1023)))
-  (func (export "f64.trailing_dot") (result i64) (i64.reinterpret/f64 (f64.const 0x1.p100)))
+  (func (export "f64.zero") (result i64) (i64.reinterpret_f64 (f64.const 0x0.0p0)))
+  (func (export "f64.positive_zero") (result i64) (i64.reinterpret_f64 (f64.const +0x0.0p0)))
+  (func (export "f64.negative_zero") (result i64) (i64.reinterpret_f64 (f64.const -0x0.0p0)))
+  (func (export "f64.misc") (result i64) (i64.reinterpret_f64 (f64.const 0x1.921fb54442d18p+2)))
+  (func (export "f64.min_positive") (result i64) (i64.reinterpret_f64 (f64.const 0x0.0000000000001p-1022)))
+  (func (export "f64.min_normal") (result i64) (i64.reinterpret_f64 (f64.const 0x1p-1022)))
+  (func (export "f64.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 0x0.fffffffffffffp-1022)))
+  (func (export "f64.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 0x1.fffffffffffffp+1023)))
+  (func (export "f64.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 0x1.p100)))
 
   ;; f64 numbers in decimal format
-  (func (export "f64_dec.zero") (result i64) (i64.reinterpret/f64 (f64.const 0.0e0)))
-  (func (export "f64_dec.positive_zero") (result i64) (i64.reinterpret/f64 (f64.const +0.0e0)))
-  (func (export "f64_dec.negative_zero") (result i64) (i64.reinterpret/f64 (f64.const -0.0e0)))
-  (func (export "f64_dec.misc") (result i64) (i64.reinterpret/f64 (f64.const 6.28318530717958623)))
-  (func (export "f64_dec.min_positive") (result i64) (i64.reinterpret/f64 (f64.const 4.94066e-324)))
-  (func (export "f64_dec.min_normal") (result i64) (i64.reinterpret/f64 (f64.const 2.2250738585072012e-308)))
-  (func (export "f64_dec.max_subnormal") (result i64) (i64.reinterpret/f64 (f64.const 2.2250738585072011e-308)))
-  (func (export "f64_dec.max_finite") (result i64) (i64.reinterpret/f64 (f64.const 1.7976931348623157e+308)))
-  (func (export "f64_dec.trailing_dot") (result i64) (i64.reinterpret/f64 (f64.const 1.e100)))
+  (func (export "f64_dec.zero") (result i64) (i64.reinterpret_f64 (f64.const 0.0e0)))
+  (func (export "f64_dec.positive_zero") (result i64) (i64.reinterpret_f64 (f64.const +0.0e0)))
+  (func (export "f64_dec.negative_zero") (result i64) (i64.reinterpret_f64 (f64.const -0.0e0)))
+  (func (export "f64_dec.misc") (result i64) (i64.reinterpret_f64 (f64.const 6.28318530717958623)))
+  (func (export "f64_dec.min_positive") (result i64) (i64.reinterpret_f64 (f64.const 4.94066e-324)))
+  (func (export "f64_dec.min_normal") (result i64) (i64.reinterpret_f64 (f64.const 2.2250738585072012e-308)))
+  (func (export "f64_dec.max_subnormal") (result i64) (i64.reinterpret_f64 (f64.const 2.2250738585072011e-308)))
+  (func (export "f64_dec.max_finite") (result i64) (i64.reinterpret_f64 (f64.const 1.7976931348623157e+308)))
+  (func (export "f64_dec.trailing_dot") (result i64) (i64.reinterpret_f64 (f64.const 1.e100)))
 
   ;; https://twitter.com/Archivd/status/994637336506912768
-  (func (export "f64_dec.root_beer_float") (result i64) (i64.reinterpret/f64 (f64.const 1.000000119)))
+  (func (export "f64_dec.root_beer_float") (result i64) (i64.reinterpret_f64 (f64.const 1.000000119)))
 
   (func (export "f32-dec-sep1") (result f32) (f32.const 1_000_000))
   (func (export "f32-dec-sep2") (result f32) (f32.const 1_0_0_0))
diff --git a/test/core/float_misc.wast b/test/core/float_misc.wast
index 313534326..1aad1a35a 100644
--- a/test/core/float_misc.wast
+++ b/test/core/float_misc.wast
@@ -15,35 +15,35 @@
 ;; covering additional miscellaneous interesting cases.
 
 (module
-  (func (export "f32.add") (param $x f32) (param $y f32) (result f32) (f32.add (get_local $x) (get_local $y)))
-  (func (export "f32.sub") (param $x f32) (param $y f32) (result f32) (f32.sub (get_local $x) (get_local $y)))
-  (func (export "f32.mul") (param $x f32) (param $y f32) (result f32) (f32.mul (get_local $x) (get_local $y)))
-  (func (export "f32.div") (param $x f32) (param $y f32) (result f32) (f32.div (get_local $x) (get_local $y)))
-  (func (export "f32.sqrt") (param $x f32) (result f32) (f32.sqrt (get_local $x)))
-  (func (export "f32.abs") (param $x f32) (result f32) (f32.abs (get_local $x)))
-  (func (export "f32.neg") (param $x f32) (result f32) (f32.neg (get_local $x)))
-  (func (export "f32.copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (get_local $x) (get_local $y)))
-  (func (export "f32.ceil") (param $x f32) (result f32) (f32.ceil (get_local $x)))
-  (func (export "f32.floor") (param $x f32) (result f32) (f32.floor (get_local $x)))
-  (func (export "f32.trunc") (param $x f32) (result f32) (f32.trunc (get_local $x)))
-  (func (export "f32.nearest") (param $x f32) (result f32) (f32.nearest (get_local $x)))
-  (func (export "f32.min") (param $x f32) (param $y f32) (result f32) (f32.min (get_local $x) (get_local $y)))
-  (func (export "f32.max") (param $x f32) (param $y f32) (result f32) (f32.max (get_local $x) (get_local $y)))
-
-  (func (export "f64.add") (param $x f64) (param $y f64) (result f64) (f64.add (get_local $x) (get_local $y)))
-  (func (export "f64.sub") (param $x f64) (param $y f64) (result f64) (f64.sub (get_local $x) (get_local $y)))
-  (func (export "f64.mul") (param $x f64) (param $y f64) (result f64) (f64.mul (get_local $x) (get_local $y)))
-  (func (export "f64.div") (param $x f64) (param $y f64) (result f64) (f64.div (get_local $x) (get_local $y)))
-  (func (export "f64.sqrt") (param $x f64) (result f64) (f64.sqrt (get_local $x)))
-  (func (export "f64.abs") (param $x f64) (result f64) (f64.abs (get_local $x)))
-  (func (export "f64.neg") (param $x f64) (result f64) (f64.neg (get_local $x)))
-  (func (export "f64.copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (get_local $x) (get_local $y)))
-  (func (export "f64.ceil") (param $x f64) (result f64) (f64.ceil (get_local $x)))
-  (func (export "f64.floor") (param $x f64) (result f64) (f64.floor (get_local $x)))
-  (func (export "f64.trunc") (param $x f64) (result f64) (f64.trunc (get_local $x)))
-  (func (export "f64.nearest") (param $x f64) (result f64) (f64.nearest (get_local $x)))
-  (func (export "f64.min") (param $x f64) (param $y f64) (result f64) (f64.min (get_local $x) (get_local $y)))
-  (func (export "f64.max") (param $x f64) (param $y f64) (result f64) (f64.max (get_local $x) (get_local $y)))
+  (func (export "f32.add") (param $x f32) (param $y f32) (result f32) (f32.add (local.get $x) (local.get $y)))
+  (func (export "f32.sub") (param $x f32) (param $y f32) (result f32) (f32.sub (local.get $x) (local.get $y)))
+  (func (export "f32.mul") (param $x f32) (param $y f32) (result f32) (f32.mul (local.get $x) (local.get $y)))
+  (func (export "f32.div") (param $x f32) (param $y f32) (result f32) (f32.div (local.get $x) (local.get $y)))
+  (func (export "f32.sqrt") (param $x f32) (result f32) (f32.sqrt (local.get $x)))
+  (func (export "f32.abs") (param $x f32) (result f32) (f32.abs (local.get $x)))
+  (func (export "f32.neg") (param $x f32) (result f32) (f32.neg (local.get $x)))
+  (func (export "f32.copysign") (param $x f32) (param $y f32) (result f32) (f32.copysign (local.get $x) (local.get $y)))
+  (func (export "f32.ceil") (param $x f32) (result f32) (f32.ceil (local.get $x)))
+  (func (export "f32.floor") (param $x f32) (result f32) (f32.floor (local.get $x)))
+  (func (export "f32.trunc") (param $x f32) (result f32) (f32.trunc (local.get $x)))
+  (func (export "f32.nearest") (param $x f32) (result f32) (f32.nearest (local.get $x)))
+  (func (export "f32.min") (param $x f32) (param $y f32) (result f32) (f32.min (local.get $x) (local.get $y)))
+  (func (export "f32.max") (param $x f32) (param $y f32) (result f32) (f32.max (local.get $x) (local.get $y)))
+
+  (func (export "f64.add") (param $x f64) (param $y f64) (result f64) (f64.add (local.get $x) (local.get $y)))
+  (func (export "f64.sub") (param $x f64) (param $y f64) (result f64) (f64.sub (local.get $x) (local.get $y)))
+  (func (export "f64.mul") (param $x f64) (param $y f64) (result f64) (f64.mul (local.get $x) (local.get $y)))
+  (func (export "f64.div") (param $x f64) (param $y f64) (result f64) (f64.div (local.get $x) (local.get $y)))
+  (func (export "f64.sqrt") (param $x f64) (result f64) (f64.sqrt (local.get $x)))
+  (func (export "f64.abs") (param $x f64) (result f64) (f64.abs (local.get $x)))
+  (func (export "f64.neg") (param $x f64) (result f64) (f64.neg (local.get $x)))
+  (func (export "f64.copysign") (param $x f64) (param $y f64) (result f64) (f64.copysign (local.get $x) (local.get $y)))
+  (func (export "f64.ceil") (param $x f64) (result f64) (f64.ceil (local.get $x)))
+  (func (export "f64.floor") (param $x f64) (result f64) (f64.floor (local.get $x)))
+  (func (export "f64.trunc") (param $x f64) (result f64) (f64.trunc (local.get $x)))
+  (func (export "f64.nearest") (param $x f64) (result f64) (f64.nearest (local.get $x)))
+  (func (export "f64.min") (param $x f64) (param $y f64) (result f64) (f64.min (local.get $x) (local.get $y)))
+  (func (export "f64.max") (param $x f64) (param $y f64) (result f64) (f64.max (local.get $x) (local.get $y)))
 )
 
 ;; Miscellaneous values.
diff --git a/test/core/forward.wast b/test/core/forward.wast
index 7074ed743..7bb3770d7 100644
--- a/test/core/forward.wast
+++ b/test/core/forward.wast
@@ -1,15 +1,15 @@
 (module
   (func $even (export "even") (param $n i32) (result i32)
-    (if (result i32) (i32.eq (get_local $n) (i32.const 0))
+    (if (result i32) (i32.eq (local.get $n) (i32.const 0))
       (then (i32.const 1))
-      (else (call $odd (i32.sub (get_local $n) (i32.const 1))))
+      (else (call $odd (i32.sub (local.get $n) (i32.const 1))))
     )
   )
 
   (func $odd (export "odd") (param $n i32) (result i32)
-    (if (result i32) (i32.eq (get_local $n) (i32.const 0))
+    (if (result i32) (i32.eq (local.get $n) (i32.const 0))
       (then (i32.const 0))
-      (else (call $even (i32.sub (get_local $n) (i32.const 1))))
+      (else (call $even (i32.sub (local.get $n) (i32.const 1))))
     )
   )
 )
diff --git a/test/core/func.wast b/test/core/func.wast
index 768a924a2..a6b05f53c 100644
--- a/test/core/func.wast
+++ b/test/core/func.wast
@@ -64,44 +64,44 @@
 
   ;; Typing of locals
 
-  (func (export "local-first-i32") (result i32) (local i32 i32) (get_local 0))
-  (func (export "local-first-i64") (result i64) (local i64 i64) (get_local 0))
-  (func (export "local-first-f32") (result f32) (local f32 f32) (get_local 0))
-  (func (export "local-first-f64") (result f64) (local f64 f64) (get_local 0))
-  (func (export "local-second-i32") (result i32) (local i32 i32) (get_local 1))
-  (func (export "local-second-i64") (result i64) (local i64 i64) (get_local 1))
-  (func (export "local-second-f32") (result f32) (local f32 f32) (get_local 1))
-  (func (export "local-second-f64") (result f64) (local f64 f64) (get_local 1))
+  (func (export "local-first-i32") (result i32) (local i32 i32) (local.get 0))
+  (func (export "local-first-i64") (result i64) (local i64 i64) (local.get 0))
+  (func (export "local-first-f32") (result f32) (local f32 f32) (local.get 0))
+  (func (export "local-first-f64") (result f64) (local f64 f64) (local.get 0))
+  (func (export "local-second-i32") (result i32) (local i32 i32) (local.get 1))
+  (func (export "local-second-i64") (result i64) (local i64 i64) (local.get 1))
+  (func (export "local-second-f32") (result f32) (local f32 f32) (local.get 1))
+  (func (export "local-second-f64") (result f64) (local f64 f64) (local.get 1))
   (func (export "local-mixed") (result f64)
     (local f32) (local $x i32) (local i64 i32) (local) (local f64 i32)
-    (drop (f32.neg (get_local 0)))
-    (drop (i32.eqz (get_local 1)))
-    (drop (i64.eqz (get_local 2)))
-    (drop (i32.eqz (get_local 3)))
-    (drop (f64.neg (get_local 4)))
-    (drop (i32.eqz (get_local 5)))
-    (get_local 4)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
   )
 
   ;; Typing of parameters
 
-  (func (export "param-first-i32") (param i32 i32) (result i32) (get_local 0))
-  (func (export "param-first-i64") (param i64 i64) (result i64) (get_local 0))
-  (func (export "param-first-f32") (param f32 f32) (result f32) (get_local 0))
-  (func (export "param-first-f64") (param f64 f64) (result f64) (get_local 0))
-  (func (export "param-second-i32") (param i32 i32) (result i32) (get_local 1))
-  (func (export "param-second-i64") (param i64 i64) (result i64) (get_local 1))
-  (func (export "param-second-f32") (param f32 f32) (result f32) (get_local 1))
-  (func (export "param-second-f64") (param f64 f64) (result f64) (get_local 1))
+  (func (export "param-first-i32") (param i32 i32) (result i32) (local.get 0))
+  (func (export "param-first-i64") (param i64 i64) (result i64) (local.get 0))
+  (func (export "param-first-f32") (param f32 f32) (result f32) (local.get 0))
+  (func (export "param-first-f64") (param f64 f64) (result f64) (local.get 0))
+  (func (export "param-second-i32") (param i32 i32) (result i32) (local.get 1))
+  (func (export "param-second-i64") (param i64 i64) (result i64) (local.get 1))
+  (func (export "param-second-f32") (param f32 f32) (result f32) (local.get 1))
+  (func (export "param-second-f64") (param f64 f64) (result f64) (local.get 1))
   (func (export "param-mixed") (param f32 i32) (param) (param $x i64) (param i32 f64 i32)
     (result f64)
-    (drop (f32.neg (get_local 0)))
-    (drop (i32.eqz (get_local 1)))
-    (drop (i64.eqz (get_local 2)))
-    (drop (i32.eqz (get_local 3)))
-    (drop (f64.neg (get_local 4)))
-    (drop (i32.eqz (get_local 5)))
-    (get_local 4)
+    (drop (f32.neg (local.get 0)))
+    (drop (i32.eqz (local.get 1)))
+    (drop (i64.eqz (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (f64.neg (local.get 4)))
+    (drop (i32.eqz (local.get 5)))
+    (local.get 4)
   )
 
   ;; Typing of result
@@ -136,25 +136,25 @@
   )
 
   (func (export "break-br_if-empty") (param i32)
-    (br_if 0 (get_local 0))
+    (br_if 0 (local.get 0))
   )
   (func (export "break-br_if-num") (param i32) (result i32)
-    (drop (br_if 0 (i32.const 50) (get_local 0))) (i32.const 51)
+    (drop (br_if 0 (i32.const 50) (local.get 0))) (i32.const 51)
   )
 
   (func (export "break-br_table-empty") (param i32)
-    (br_table 0 0 0 (get_local 0))
+    (br_table 0 0 0 (local.get 0))
   )
   (func (export "break-br_table-num") (param i32) (result i32)
-    (br_table 0 0 (i32.const 50) (get_local 0)) (i32.const 51)
+    (br_table 0 0 (i32.const 50) (local.get 0)) (i32.const 51)
   )
   (func (export "break-br_table-nested-empty") (param i32)
-    (block (br_table 0 1 0 (get_local 0)))
+    (block (br_table 0 1 0 (local.get 0)))
   )
   (func (export "break-br_table-nested-num") (param i32) (result i32)
     (i32.add
       (block (result i32)
-        (br_table 0 1 0 (i32.const 50) (get_local 0)) (i32.const 51)
+        (br_table 0 1 0 (i32.const 50) (local.get 0)) (i32.const 51)
       )
       (i32.const 2)
     )
@@ -162,10 +162,10 @@
 
   ;; Default initialization of locals
 
-  (func (export "init-local-i32") (result i32) (local i32) (get_local 0))
-  (func (export "init-local-i64") (result i64) (local i64) (get_local 0))
-  (func (export "init-local-f32") (result f32) (local f32) (get_local 0))
-  (func (export "init-local-f64") (result f64) (local f64) (get_local 0))
+  (func (export "init-local-i32") (result i32) (local i32) (local.get 0))
+  (func (export "init-local-i64") (result i64) (local i64) (local.get 0))
+  (func (export "init-local-f32") (result f32) (local f32) (local.get 0))
+  (func (export "init-local-f64") (result f64) (local f64) (local.get 0))
 )
 
 (assert_return (invoke "type-use-1"))
@@ -325,7 +325,7 @@
 
   (type $empty-sig-duplicate (func))
   (type $complex-sig-duplicate (func (param i64 i64 f64 i64 f64 i64 f32 i32)))
-  (table anyfunc
+  (table funcref
     (elem
       $complex-sig-3 $empty-sig-2 $complex-sig-1 $complex-sig-3 $empty-sig-1
       $complex-sig-4 $complex-sig-5
@@ -458,15 +458,15 @@
 ;; Invalid typing of locals
 
 (assert_invalid
-  (module (func $type-local-num-vs-num (result i64) (local i32) (get_local 0)))
+  (module (func $type-local-num-vs-num (result i64) (local i32) (local.get 0)))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-local-num-vs-num (local f32) (i32.eqz (get_local 0))))
+  (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.get 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (get_local 1))))
+  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.get 1))))
   "type mismatch"
 )
 
@@ -474,15 +474,15 @@
 ;; Invalid typing of parameters
 
 (assert_invalid
-  (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0)))
+  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0))))
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1))))
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))
   "type mismatch"
 )
 
@@ -652,10 +652,10 @@
   "unexpected token"
 )
 (assert_malformed
-  (module quote "(func (local i32) (result i32) (get_local 0))")
+  (module quote "(func (local i32) (result i32) (local.get 0))")
   "unexpected token"
 )
 (assert_malformed
-  (module quote "(func (result i32) (param i32) (get_local 0))")
+  (module quote "(func (result i32) (param i32) (local.get 0))")
   "unexpected token"
 )
diff --git a/test/core/func_ptrs.wast b/test/core/func_ptrs.wast
index 2b74869d7..f6f8e2c42 100644
--- a/test/core/func_ptrs.wast
+++ b/test/core/func_ptrs.wast
@@ -13,15 +13,15 @@
   (func (type $S))
 
   (func (export "one") (type 4) (i32.const 13))
-  (func (export "two") (type $T) (i32.add (get_local 0) (i32.const 1)))
+  (func (export "two") (type $T) (i32.add (local.get 0) (i32.const 1)))
 
   ;; Both signature and parameters are allowed (and required to match)
   ;; since this allows the naming of parameters.
   (func (export "three") (type $T) (param $a i32) (result i32)
-    (i32.sub (get_local 0) (i32.const 2))
+    (i32.sub (local.get 0) (i32.const 2))
   )
 
-  (func (export "four") (type $U) (call $print (get_local 0)))
+  (func (export "four") (type $U) (call $print (local.get 0)))
 )
 
 (assert_return (invoke "one") (i32.const 13))
@@ -33,15 +33,15 @@
 (assert_invalid (module (elem (i32.const 0) 0) (func)) "unknown table")
 
 (assert_invalid
-  (module (table 1 anyfunc) (elem (i64.const 0)))
+  (module (table 1 funcref) (elem (i64.const 0)))
   "type mismatch"
 )
 (assert_invalid
-  (module (table 1 anyfunc) (elem (i32.ctz (i32.const 0))))
+  (module (table 1 funcref) (elem (i32.ctz (i32.const 0))))
   "constant expression required"
 )
 (assert_invalid
-  (module (table 1 anyfunc) (elem (nop)))
+  (module (table 1 funcref) (elem (nop)))
   "constant expression required"
 )
 
@@ -51,7 +51,7 @@
 (module
   (type $T (func (param) (result i32)))
   (type $U (func (param) (result i32)))
-  (table anyfunc (elem $t1 $t2 $t3 $u1 $u2 $t1 $t3))
+  (table funcref (elem $t1 $t2 $t3 $u1 $u2 $t1 $t3))
 
   (func $t1 (type $T) (i32.const 1))
   (func $t2 (type $T) (i32.const 2))
@@ -60,11 +60,11 @@
   (func $u2 (type $U) (i32.const 5))
 
   (func (export "callt") (param $i i32) (result i32)
-    (call_indirect (type $T) (get_local $i))
+    (call_indirect (type $T) (local.get $i))
   )
 
   (func (export "callu") (param $i i32) (result i32)
-    (call_indirect (type $U) (get_local $i))
+    (call_indirect (type $U) (local.get $i))
   )
 )
 
@@ -92,13 +92,13 @@
 
 (module
   (type $T (func (result i32)))
-  (table anyfunc (elem 0 1))
+  (table funcref (elem 0 1))
 
   (func $t1 (type $T) (i32.const 1))
   (func $t2 (type $T) (i32.const 2))
 
   (func (export "callt") (param $i i32) (result i32)
-    (call_indirect (type $T) (get_local $i))
+    (call_indirect (type $T) (local.get $i))
   )
 )
 
diff --git a/test/core/get_local.wast b/test/core/get_local.wast
deleted file mode 100644
index 6b68355bf..000000000
--- a/test/core/get_local.wast
+++ /dev/null
@@ -1,165 +0,0 @@
-;; Test `get_local` operator
-
-(module
-  ;; Typing
-
-  (func (export "type-local-i32") (result i32) (local i32) (get_local 0))
-  (func (export "type-local-i64") (result i64) (local i64) (get_local 0))
-  (func (export "type-local-f32") (result f32) (local f32) (get_local 0))
-  (func (export "type-local-f64") (result f64) (local f64) (get_local 0))
-
-  (func (export "type-param-i32") (param i32) (result i32) (get_local 0))
-  (func (export "type-param-i64") (param i64) (result i64) (get_local 0))
-  (func (export "type-param-f32") (param f32) (result f32) (get_local 0))
-  (func (export "type-param-f64") (param f64) (result f64) (get_local 0))
-
-  (func (export "type-mixed") (param i64 f32 f64 i32 i32)
-    (local f32 i64 i64 f64)
-    (drop (i64.eqz (get_local 0)))
-    (drop (f32.neg (get_local 1)))
-    (drop (f64.neg (get_local 2)))
-    (drop (i32.eqz (get_local 3)))
-    (drop (i32.eqz (get_local 4)))
-    (drop (f32.neg (get_local 5)))
-    (drop (i64.eqz (get_local 6)))
-    (drop (i64.eqz (get_local 7)))
-    (drop (f64.neg (get_local 8)))
-  )
-
-  ;; Reading
-
-  (func (export "read") (param i64 f32 f64 i32 i32) (result f64)
-    (local f32 i64 i64 f64)
-    (set_local 5 (f32.const 5.5))
-    (set_local 6 (i64.const 6))
-    (set_local 8 (f64.const 8))
-    (f64.add
-      (f64.convert_u/i64 (get_local 0))
-      (f64.add
-        (f64.promote/f32 (get_local 1))
-        (f64.add
-          (get_local 2)
-          (f64.add
-            (f64.convert_u/i32 (get_local 3))
-            (f64.add
-              (f64.convert_s/i32 (get_local 4))
-              (f64.add
-                (f64.promote/f32 (get_local 5))
-                (f64.add
-                  (f64.convert_u/i64 (get_local 6))
-                  (f64.add
-                    (f64.convert_u/i64 (get_local 7))
-                    (get_local 8)
-                  )
-                )
-              )
-            )
-          )
-        )
-      )
-    )
-  )
-)
-
-(assert_return (invoke "type-local-i32") (i32.const 0))
-(assert_return (invoke "type-local-i64") (i64.const 0))
-(assert_return (invoke "type-local-f32") (f32.const 0))
-(assert_return (invoke "type-local-f64") (f64.const 0))
-
-(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 2))
-(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 3))
-(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 4.4))
-(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 5.5))
-
-(assert_return
-  (invoke "type-mixed"
-    (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5)
-  )
-)
-
-(assert_return
-  (invoke "read"
-    (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5)
-  )
-  (f64.const 34.8)
-)
-
-
-;; Invalid typing of access to locals
-
-(assert_invalid
-  (module (func $type-local-num-vs-num (result i64) (local i32) (get_local 0)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-local-num-vs-num (local f32) (i32.eqz (get_local 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (get_local 1))))
-  "type mismatch"
-)
-
-
-;; Invalid typing of access to parameters
-
-(assert_invalid
-  (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0))))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1))))
-  "type mismatch"
-)
-
-(assert_invalid
-  (module (func $i32-vs-empty (local i32) (get_local 0)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $i64-vs-empty (local i64) (get_local 0)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $f32-vs-empty (local f32) (get_local 0)))
-  "type mismatch"
-)
-(assert_invalid
-  (module (func $f64-vs-empty (local f64) (get_local 0)))
-  "type mismatch"
-)
-
-
-;; Invalid local index
-
-(assert_invalid
-  (module (func $unbound-local (local i32 i64) (get_local 3)))
-  "unknown local"
-)
-(assert_invalid
-  (module (func $large-local (local i32 i64) (get_local 14324343)))
-  "unknown local"
-)
-
-(assert_invalid
-  (module (func $unbound-param (param i32 i64) (get_local 2)))
-  "unknown local"
-)
-(assert_invalid
-  (module (func $large-param (local i32 i64) (get_local 714324343)))
-  "unknown local"
-)
-
-(assert_invalid
-  (module (func $unbound-mixed (param i32) (local i32 i64) (get_local 3)))
-  "unknown local"
-)
-(assert_invalid
-  (module (func $large-mixed (param i64) (local i32 i64) (get_local 214324343)))
-  "unknown local"
-)
-
diff --git a/test/core/globals.wast b/test/core/globals.wast
index 5a7c6d39f..7d6a7dc5c 100644
--- a/test/core/globals.wast
+++ b/test/core/globals.wast
@@ -11,19 +11,19 @@
   (global (;6;) (mut f64) (f64.const -14))
   (global $y (mut i64) (i64.const -15))
 
-  (func (export "get-a") (result i32) (get_global $a))
-  (func (export "get-b") (result i64) (get_global $b))
-  (func (export "get-x") (result i32) (get_global $x))
-  (func (export "get-y") (result i64) (get_global $y))
-  (func (export "set-x") (param i32) (set_global $x (get_local 0)))
-  (func (export "set-y") (param i64) (set_global $y (get_local 0)))
-
-  (func (export "get-1") (result f32) (get_global 1))
-  (func (export "get-2") (result f64) (get_global 2))
-  (func (export "get-5") (result f32) (get_global 5))
-  (func (export "get-6") (result f64) (get_global 6))
-  (func (export "set-5") (param f32) (set_global 5 (get_local 0)))
-  (func (export "set-6") (param f64) (set_global 6 (get_local 0)))
+  (func (export "get-a") (result i32) (global.get $a))
+  (func (export "get-b") (result i64) (global.get $b))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i64) (global.get $y))
+  (func (export "set-x") (param i32) (global.set $x (local.get 0)))
+  (func (export "set-y") (param i64) (global.set $y (local.get 0)))
+
+  (func (export "get-1") (result f32) (global.get 1))
+  (func (export "get-2") (result f64) (global.get 2))
+  (func (export "get-5") (result f32) (global.get 5))
+  (func (export "get-6") (result f64) (global.get 6))
+  (func (export "set-5") (param f32) (global.set 5 (local.get 0)))
+  (func (export "set-6") (param f64) (global.set 6 (local.get 0)))
 
   ;; As the argument of control constructs and instructions
 
@@ -32,148 +32,148 @@
   (func $dummy)
 
   (func (export "as-select-first") (result i32)
-    (select (get_global $x) (i32.const 2) (i32.const 3))
+    (select (global.get $x) (i32.const 2) (i32.const 3))
   )
   (func (export "as-select-mid") (result i32)
-    (select (i32.const 2) (get_global $x) (i32.const 3))
+    (select (i32.const 2) (global.get $x) (i32.const 3))
   )
   (func (export "as-select-last") (result i32)
-    (select (i32.const 2) (i32.const 3) (get_global $x))
+    (select (i32.const 2) (i32.const 3) (global.get $x))
   )
 
   (func (export "as-loop-first") (result i32)
     (loop (result i32)
-      (get_global $x) (call $dummy) (call $dummy)
+      (global.get $x) (call $dummy) (call $dummy)
     )
   )
   (func (export "as-loop-mid") (result i32)
     (loop (result i32)
-      (call $dummy) (get_global $x) (call $dummy)
+      (call $dummy) (global.get $x) (call $dummy)
     )
   )
   (func (export "as-loop-last") (result i32)
     (loop (result i32)
-      (call $dummy) (call $dummy) (get_global $x)
+      (call $dummy) (call $dummy) (global.get $x)
     )
   )
 
   (func (export "as-if-condition") (result i32)
-    (if (result i32) (get_global $x)
+    (if (result i32) (global.get $x)
       (then (call $dummy) (i32.const 2))
       (else (call $dummy) (i32.const 3))
     )
   )
   (func (export "as-if-then") (result i32)
     (if (result i32) (i32.const 1)
-      (then (get_global $x)) (else (i32.const 2))
+      (then (global.get $x)) (else (i32.const 2))
     )
   )
   (func (export "as-if-else") (result i32)
     (if (result i32) (i32.const 0)
-      (then (i32.const 2)) (else (get_global $x))
+      (then (i32.const 2)) (else (global.get $x))
     )
   )
 
   (func (export "as-br_if-first") (result i32)
     (block (result i32)
-      (br_if 0 (get_global $x) (i32.const 2))
+      (br_if 0 (global.get $x) (i32.const 2))
       (return (i32.const 3))
     )
   )
   (func (export "as-br_if-last") (result i32)
     (block (result i32)
-      (br_if 0 (i32.const 2) (get_global $x))
+      (br_if 0 (i32.const 2) (global.get $x))
       (return (i32.const 3))
     )
   )
 
   (func (export "as-br_table-first") (result i32)
     (block (result i32)
-      (get_global $x) (i32.const 2) (br_table 0 0)
+      (global.get $x) (i32.const 2) (br_table 0 0)
     )
   )
   (func (export "as-br_table-last") (result i32)
     (block (result i32)
-      (i32.const 2) (get_global $x) (br_table 0 0)
+      (i32.const 2) (global.get $x) (br_table 0 0)
     )
   )
 
-  (func $func (param i32 i32) (result i32) (get_local 0))
+  (func $func (param i32 i32) (result i32) (local.get 0))
   (type $check (func (param i32 i32) (result i32)))
-  (table anyfunc (elem $func))
+  (table funcref (elem $func))
   (func (export "as-call_indirect-first") (result i32)
     (block (result i32)
       (call_indirect (type $check)
-        (get_global $x) (i32.const 2) (i32.const 0)
+        (global.get $x) (i32.const 2) (i32.const 0)
       )
     )
   )
   (func (export "as-call_indirect-mid") (result i32)
     (block (result i32)
       (call_indirect (type $check)
-        (i32.const 2) (get_global $x) (i32.const 0)
+        (i32.const 2) (global.get $x) (i32.const 0)
       )
     )
   )
  (func (export "as-call_indirect-last") (result i32)
     (block (result i32)
       (call_indirect (type $check)
-        (i32.const 2) (i32.const 0) (get_global $x)
+        (i32.const 2) (i32.const 0) (global.get $x)
       )
     )
   )
 
   (func (export "as-store-first")
-    (get_global $x) (i32.const 1) (i32.store)
+    (global.get $x) (i32.const 1) (i32.store)
   )
   (func (export "as-store-last")
-    (i32.const 0) (get_global $x) (i32.store)
+    (i32.const 0) (global.get $x) (i32.store)
   )
   (func (export "as-load-operand") (result i32)
-    (i32.load (get_global $x))
+    (i32.load (global.get $x))
   )
   (func (export "as-memory.grow-value") (result i32)
-    (memory.grow (get_global $x))
+    (memory.grow (global.get $x))
   )
 
-  (func $f (param i32) (result i32) (get_local 0))
+  (func $f (param i32) (result i32) (local.get 0))
   (func (export "as-call-value") (result i32)
-    (call $f (get_global $x))
+    (call $f (global.get $x))
   )
 
   (func (export "as-return-value") (result i32)
-    (get_global $x) (return)
+    (global.get $x) (return)
   )
   (func (export "as-drop-operand")
-    (drop (get_global $x))
+    (drop (global.get $x))
   )
   (func (export "as-br-value") (result i32)
-    (block (result i32) (br 0 (get_global $x)))
+    (block (result i32) (br 0 (global.get $x)))
   )
 
-  (func (export "as-set_local-value") (param i32) (result i32)
-    (set_local 0 (get_global $x))
-    (get_local 0)
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local.set 0 (global.get $x))
+    (local.get 0)
   )
-  (func (export "as-tee_local-value") (param i32) (result i32)
-    (tee_local 0 (get_global $x))
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (global.get $x))
   )
-  (func (export "as-set_global-value") (result i32)
-    (set_global $x (get_global $x))
-    (get_global $x)
+  (func (export "as-global.set-value") (result i32)
+    (global.set $x (global.get $x))
+    (global.get $x)
   )
 
   (func (export "as-unary-operand") (result i32)
-    (i32.eqz (get_global $x))
+    (i32.eqz (global.get $x))
   )
   (func (export "as-binary-operand") (result i32)
     (i32.mul
-      (get_global $x) (get_global $x)
+      (global.get $x) (global.get $x)
     )
   )
   (func (export "as-compare-operand") (result i32)
     (i32.gt_u
-      (get_global 0) (i32.const 1)
+      (global.get 0) (i32.const 1)
     )
   )
 )
@@ -231,16 +231,16 @@
 (assert_return (invoke "as-drop-operand"))
 (assert_return (invoke "as-br-value") (i32.const 6))
 
-(assert_return (invoke "as-set_local-value" (i32.const 1)) (i32.const 6))
-(assert_return (invoke "as-tee_local-value" (i32.const 1)) (i32.const 6))
-(assert_return (invoke "as-set_global-value") (i32.const 6))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 6))
+(assert_return (invoke "as-global.set-value") (i32.const 6))
 
 (assert_return (invoke "as-unary-operand") (i32.const 0))
 (assert_return (invoke "as-binary-operand") (i32.const 36))
 (assert_return (invoke "as-compare-operand") (i32.const 1))
 
 (assert_invalid
-  (module (global f32 (f32.const 0)) (func (set_global 0 (i32.const 1))))
+  (module (global f32 (f32.const 0)) (func (global.set 0 (i32.const 1))))
   "global is immutable"
 )
 
@@ -254,7 +254,7 @@
 )
 
 (assert_invalid
-  (module (global f32 (get_local 0)))
+  (module (global f32 (local.get 0)))
   "constant expression required"
 )
 
@@ -289,12 +289,12 @@
 )
 
 (assert_invalid
-  (module (global i32 (get_global 0)))
+  (module (global i32 (global.get 0)))
   "unknown global"
 )
 
 (assert_invalid
-  (module (global i32 (get_global 1)) (global i32 (i32.const 0)))
+  (module (global i32 (global.get 1)) (global i32 (i32.const 0)))
   "unknown global"
 )
 
diff --git a/test/core/i32.wast b/test/core/i32.wast
index bd8722e61..c30d66789 100644
--- a/test/core/i32.wast
+++ b/test/core/i32.wast
@@ -1,35 +1,35 @@
 ;; i32 operations
 
 (module
-  (func (export "add") (param $x i32) (param $y i32) (result i32) (i32.add (get_local $x) (get_local $y)))
-  (func (export "sub") (param $x i32) (param $y i32) (result i32) (i32.sub (get_local $x) (get_local $y)))
-  (func (export "mul") (param $x i32) (param $y i32) (result i32) (i32.mul (get_local $x) (get_local $y)))
-  (func (export "div_s") (param $x i32) (param $y i32) (result i32) (i32.div_s (get_local $x) (get_local $y)))
-  (func (export "div_u") (param $x i32) (param $y i32) (result i32) (i32.div_u (get_local $x) (get_local $y)))
-  (func (export "rem_s") (param $x i32) (param $y i32) (result i32) (i32.rem_s (get_local $x) (get_local $y)))
-  (func (export "rem_u") (param $x i32) (param $y i32) (result i32) (i32.rem_u (get_local $x) (get_local $y)))
-  (func (export "and") (param $x i32) (param $y i32) (result i32) (i32.and (get_local $x) (get_local $y)))
-  (func (export "or") (param $x i32) (param $y i32) (result i32) (i32.or (get_local $x) (get_local $y)))
-  (func (export "xor") (param $x i32) (param $y i32) (result i32) (i32.xor (get_local $x) (get_local $y)))
-  (func (export "shl") (param $x i32) (param $y i32) (result i32) (i32.shl (get_local $x) (get_local $y)))
-  (func (export "shr_s") (param $x i32) (param $y i32) (result i32) (i32.shr_s (get_local $x) (get_local $y)))
-  (func (export "shr_u") (param $x i32) (param $y i32) (result i32) (i32.shr_u (get_local $x) (get_local $y)))
-  (func (export "rotl") (param $x i32) (param $y i32) (result i32) (i32.rotl (get_local $x) (get_local $y)))
-  (func (export "rotr") (param $x i32) (param $y i32) (result i32) (i32.rotr (get_local $x) (get_local $y)))
-  (func (export "clz") (param $x i32) (result i32) (i32.clz (get_local $x)))
-  (func (export "ctz") (param $x i32) (result i32) (i32.ctz (get_local $x)))
-  (func (export "popcnt") (param $x i32) (result i32) (i32.popcnt (get_local $x)))
-  (func (export "eqz") (param $x i32) (result i32) (i32.eqz (get_local $x)))
-  (func (export "eq") (param $x i32) (param $y i32) (result i32) (i32.eq (get_local $x) (get_local $y)))
-  (func (export "ne") (param $x i32) (param $y i32) (result i32) (i32.ne (get_local $x) (get_local $y)))
-  (func (export "lt_s") (param $x i32) (param $y i32) (result i32) (i32.lt_s (get_local $x) (get_local $y)))
-  (func (export "lt_u") (param $x i32) (param $y i32) (result i32) (i32.lt_u (get_local $x) (get_local $y)))
-  (func (export "le_s") (param $x i32) (param $y i32) (result i32) (i32.le_s (get_local $x) (get_local $y)))
-  (func (export "le_u") (param $x i32) (param $y i32) (result i32) (i32.le_u (get_local $x) (get_local $y)))
-  (func (export "gt_s") (param $x i32) (param $y i32) (result i32) (i32.gt_s (get_local $x) (get_local $y)))
-  (func (export "gt_u") (param $x i32) (param $y i32) (result i32) (i32.gt_u (get_local $x) (get_local $y)))
-  (func (export "ge_s") (param $x i32) (param $y i32) (result i32) (i32.ge_s (get_local $x) (get_local $y)))
-  (func (export "ge_u") (param $x i32) (param $y i32) (result i32) (i32.ge_u (get_local $x) (get_local $y)))
+  (func (export "add") (param $x i32) (param $y i32) (result i32) (i32.add (local.get $x) (local.get $y)))
+  (func (export "sub") (param $x i32) (param $y i32) (result i32) (i32.sub (local.get $x) (local.get $y)))
+  (func (export "mul") (param $x i32) (param $y i32) (result i32) (i32.mul (local.get $x) (local.get $y)))
+  (func (export "div_s") (param $x i32) (param $y i32) (result i32) (i32.div_s (local.get $x) (local.get $y)))
+  (func (export "div_u") (param $x i32) (param $y i32) (result i32) (i32.div_u (local.get $x) (local.get $y)))
+  (func (export "rem_s") (param $x i32) (param $y i32) (result i32) (i32.rem_s (local.get $x) (local.get $y)))
+  (func (export "rem_u") (param $x i32) (param $y i32) (result i32) (i32.rem_u (local.get $x) (local.get $y)))
+  (func (export "and") (param $x i32) (param $y i32) (result i32) (i32.and (local.get $x) (local.get $y)))
+  (func (export "or") (param $x i32) (param $y i32) (result i32) (i32.or (local.get $x) (local.get $y)))
+  (func (export "xor") (param $x i32) (param $y i32) (result i32) (i32.xor (local.get $x) (local.get $y)))
+  (func (export "shl") (param $x i32) (param $y i32) (result i32) (i32.shl (local.get $x) (local.get $y)))
+  (func (export "shr_s") (param $x i32) (param $y i32) (result i32) (i32.shr_s (local.get $x) (local.get $y)))
+  (func (export "shr_u") (param $x i32) (param $y i32) (result i32) (i32.shr_u (local.get $x) (local.get $y)))
+  (func (export "rotl") (param $x i32) (param $y i32) (result i32) (i32.rotl (local.get $x) (local.get $y)))
+  (func (export "rotr") (param $x i32) (param $y i32) (result i32) (i32.rotr (local.get $x) (local.get $y)))
+  (func (export "clz") (param $x i32) (result i32) (i32.clz (local.get $x)))
+  (func (export "ctz") (param $x i32) (result i32) (i32.ctz (local.get $x)))
+  (func (export "popcnt") (param $x i32) (result i32) (i32.popcnt (local.get $x)))
+  (func (export "eqz") (param $x i32) (result i32) (i32.eqz (local.get $x)))
+  (func (export "eq") (param $x i32) (param $y i32) (result i32) (i32.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x i32) (param $y i32) (result i32) (i32.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x i32) (param $y i32) (result i32) (i32.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x i32) (param $y i32) (result i32) (i32.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x i32) (param $y i32) (result i32) (i32.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x i32) (param $y i32) (result i32) (i32.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x i32) (param $y i32) (result i32) (i32.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x i32) (param $y i32) (result i32) (i32.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x i32) (param $y i32) (result i32) (i32.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x i32) (param $y i32) (result i32) (i32.ge_u (local.get $x) (local.get $y)))
 )
 
 (assert_return (invoke "add" (i32.const 1) (i32.const 1)) (i32.const 2))
diff --git a/test/core/i64.wast b/test/core/i64.wast
index 6bb8a31e9..b3510b8dc 100644
--- a/test/core/i64.wast
+++ b/test/core/i64.wast
@@ -1,35 +1,35 @@
 ;; i64 operations
 
 (module
-  (func (export "add") (param $x i64) (param $y i64) (result i64) (i64.add (get_local $x) (get_local $y)))
-  (func (export "sub") (param $x i64) (param $y i64) (result i64) (i64.sub (get_local $x) (get_local $y)))
-  (func (export "mul") (param $x i64) (param $y i64) (result i64) (i64.mul (get_local $x) (get_local $y)))
-  (func (export "div_s") (param $x i64) (param $y i64) (result i64) (i64.div_s (get_local $x) (get_local $y)))
-  (func (export "div_u") (param $x i64) (param $y i64) (result i64) (i64.div_u (get_local $x) (get_local $y)))
-  (func (export "rem_s") (param $x i64) (param $y i64) (result i64) (i64.rem_s (get_local $x) (get_local $y)))
-  (func (export "rem_u") (param $x i64) (param $y i64) (result i64) (i64.rem_u (get_local $x) (get_local $y)))
-  (func (export "and") (param $x i64) (param $y i64) (result i64) (i64.and (get_local $x) (get_local $y)))
-  (func (export "or") (param $x i64) (param $y i64) (result i64) (i64.or (get_local $x) (get_local $y)))
-  (func (export "xor") (param $x i64) (param $y i64) (result i64) (i64.xor (get_local $x) (get_local $y)))
-  (func (export "shl") (param $x i64) (param $y i64) (result i64) (i64.shl (get_local $x) (get_local $y)))
-  (func (export "shr_s") (param $x i64) (param $y i64) (result i64) (i64.shr_s (get_local $x) (get_local $y)))
-  (func (export "shr_u") (param $x i64) (param $y i64) (result i64) (i64.shr_u (get_local $x) (get_local $y)))
-  (func (export "rotl") (param $x i64) (param $y i64) (result i64) (i64.rotl (get_local $x) (get_local $y)))
-  (func (export "rotr") (param $x i64) (param $y i64) (result i64) (i64.rotr (get_local $x) (get_local $y)))
-  (func (export "clz") (param $x i64) (result i64) (i64.clz (get_local $x)))
-  (func (export "ctz") (param $x i64) (result i64) (i64.ctz (get_local $x)))
-  (func (export "popcnt") (param $x i64) (result i64) (i64.popcnt (get_local $x)))
-  (func (export "eqz") (param $x i64) (result i32) (i64.eqz (get_local $x)))
-  (func (export "eq") (param $x i64) (param $y i64) (result i32) (i64.eq (get_local $x) (get_local $y)))
-  (func (export "ne") (param $x i64) (param $y i64) (result i32) (i64.ne (get_local $x) (get_local $y)))
-  (func (export "lt_s") (param $x i64) (param $y i64) (result i32) (i64.lt_s (get_local $x) (get_local $y)))
-  (func (export "lt_u") (param $x i64) (param $y i64) (result i32) (i64.lt_u (get_local $x) (get_local $y)))
-  (func (export "le_s") (param $x i64) (param $y i64) (result i32) (i64.le_s (get_local $x) (get_local $y)))
-  (func (export "le_u") (param $x i64) (param $y i64) (result i32) (i64.le_u (get_local $x) (get_local $y)))
-  (func (export "gt_s") (param $x i64) (param $y i64) (result i32) (i64.gt_s (get_local $x) (get_local $y)))
-  (func (export "gt_u") (param $x i64) (param $y i64) (result i32) (i64.gt_u (get_local $x) (get_local $y)))
-  (func (export "ge_s") (param $x i64) (param $y i64) (result i32) (i64.ge_s (get_local $x) (get_local $y)))
-  (func (export "ge_u") (param $x i64) (param $y i64) (result i32) (i64.ge_u (get_local $x) (get_local $y)))
+  (func (export "add") (param $x i64) (param $y i64) (result i64) (i64.add (local.get $x) (local.get $y)))
+  (func (export "sub") (param $x i64) (param $y i64) (result i64) (i64.sub (local.get $x) (local.get $y)))
+  (func (export "mul") (param $x i64) (param $y i64) (result i64) (i64.mul (local.get $x) (local.get $y)))
+  (func (export "div_s") (param $x i64) (param $y i64) (result i64) (i64.div_s (local.get $x) (local.get $y)))
+  (func (export "div_u") (param $x i64) (param $y i64) (result i64) (i64.div_u (local.get $x) (local.get $y)))
+  (func (export "rem_s") (param $x i64) (param $y i64) (result i64) (i64.rem_s (local.get $x) (local.get $y)))
+  (func (export "rem_u") (param $x i64) (param $y i64) (result i64) (i64.rem_u (local.get $x) (local.get $y)))
+  (func (export "and") (param $x i64) (param $y i64) (result i64) (i64.and (local.get $x) (local.get $y)))
+  (func (export "or") (param $x i64) (param $y i64) (result i64) (i64.or (local.get $x) (local.get $y)))
+  (func (export "xor") (param $x i64) (param $y i64) (result i64) (i64.xor (local.get $x) (local.get $y)))
+  (func (export "shl") (param $x i64) (param $y i64) (result i64) (i64.shl (local.get $x) (local.get $y)))
+  (func (export "shr_s") (param $x i64) (param $y i64) (result i64) (i64.shr_s (local.get $x) (local.get $y)))
+  (func (export "shr_u") (param $x i64) (param $y i64) (result i64) (i64.shr_u (local.get $x) (local.get $y)))
+  (func (export "rotl") (param $x i64) (param $y i64) (result i64) (i64.rotl (local.get $x) (local.get $y)))
+  (func (export "rotr") (param $x i64) (param $y i64) (result i64) (i64.rotr (local.get $x) (local.get $y)))
+  (func (export "clz") (param $x i64) (result i64) (i64.clz (local.get $x)))
+  (func (export "ctz") (param $x i64) (result i64) (i64.ctz (local.get $x)))
+  (func (export "popcnt") (param $x i64) (result i64) (i64.popcnt (local.get $x)))
+  (func (export "eqz") (param $x i64) (result i32) (i64.eqz (local.get $x)))
+  (func (export "eq") (param $x i64) (param $y i64) (result i32) (i64.eq (local.get $x) (local.get $y)))
+  (func (export "ne") (param $x i64) (param $y i64) (result i32) (i64.ne (local.get $x) (local.get $y)))
+  (func (export "lt_s") (param $x i64) (param $y i64) (result i32) (i64.lt_s (local.get $x) (local.get $y)))
+  (func (export "lt_u") (param $x i64) (param $y i64) (result i32) (i64.lt_u (local.get $x) (local.get $y)))
+  (func (export "le_s") (param $x i64) (param $y i64) (result i32) (i64.le_s (local.get $x) (local.get $y)))
+  (func (export "le_u") (param $x i64) (param $y i64) (result i32) (i64.le_u (local.get $x) (local.get $y)))
+  (func (export "gt_s") (param $x i64) (param $y i64) (result i32) (i64.gt_s (local.get $x) (local.get $y)))
+  (func (export "gt_u") (param $x i64) (param $y i64) (result i32) (i64.gt_u (local.get $x) (local.get $y)))
+  (func (export "ge_s") (param $x i64) (param $y i64) (result i32) (i64.ge_s (local.get $x) (local.get $y)))
+  (func (export "ge_u") (param $x i64) (param $y i64) (result i32) (i64.ge_u (local.get $x) (local.get $y)))
 )
 
 (assert_return (invoke "add" (i64.const 1) (i64.const 1)) (i64.const 2))
diff --git a/test/core/if.wast b/test/core/if.wast
index 240668780..fb40518de 100644
--- a/test/core/if.wast
+++ b/test/core/if.wast
@@ -7,41 +7,41 @@
   (func $dummy)
 
   (func (export "empty") (param i32)
-    (if (get_local 0) (then))
-    (if (get_local 0) (then) (else))
-    (if $l (get_local 0) (then))
-    (if $l (get_local 0) (then) (else))
+    (if (local.get 0) (then))
+    (if (local.get 0) (then) (else))
+    (if $l (local.get 0) (then))
+    (if $l (local.get 0) (then) (else))
   )
 
   (func (export "singular") (param i32) (result i32)
-    (if (get_local 0) (then (nop)))
-    (if (get_local 0) (then (nop)) (else (nop)))
-    (if (result i32) (get_local 0) (then (i32.const 7)) (else (i32.const 8)))
+    (if (local.get 0) (then (nop)))
+    (if (local.get 0) (then (nop)) (else (nop)))
+    (if (result i32) (local.get 0) (then (i32.const 7)) (else (i32.const 8)))
   )
 
   (func (export "multi") (param i32) (result i32)
-    (if (get_local 0) (then (call $dummy) (call $dummy) (call $dummy)))
-    (if (get_local 0) (then) (else (call $dummy) (call $dummy) (call $dummy)))
-    (if (result i32) (get_local 0)
+    (if (local.get 0) (then (call $dummy) (call $dummy) (call $dummy)))
+    (if (local.get 0) (then) (else (call $dummy) (call $dummy) (call $dummy)))
+    (if (result i32) (local.get 0)
       (then (call $dummy) (call $dummy) (i32.const 8))
       (else (call $dummy) (call $dummy) (i32.const 9))
     )
   )
 
   (func (export "nested") (param i32 i32) (result i32)
-    (if (result i32) (get_local 0)
+    (if (result i32) (local.get 0)
       (then
-        (if (get_local 1) (then (call $dummy) (block) (nop)))
-        (if (get_local 1) (then) (else (call $dummy) (block) (nop)))
-        (if (result i32) (get_local 1)
+        (if (local.get 1) (then (call $dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
           (then (call $dummy) (i32.const 9))
           (else (call $dummy) (i32.const 10))
         )
       )
       (else
-        (if (get_local 1) (then (call $dummy) (block) (nop)))
-        (if (get_local 1) (then) (else (call $dummy) (block) (nop)))
-        (if (result i32) (get_local 1)
+        (if (local.get 1) (then (call $dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $dummy) (block) (nop)))
+        (if (result i32) (local.get 1)
           (then (call $dummy) (i32.const 10))
           (else (call $dummy) (i32.const 11))
         )
@@ -51,7 +51,7 @@
 
   (func (export "as-select-first") (param i32) (result i32)
     (select
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (call $dummy) (i32.const 1))
         (else (call $dummy) (i32.const 0))
       )
@@ -61,7 +61,7 @@
   (func (export "as-select-mid") (param i32) (result i32)
     (select
       (i32.const 2)
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (call $dummy) (i32.const 1))
         (else (call $dummy) (i32.const 0))
       )
@@ -71,7 +71,7 @@
   (func (export "as-select-last") (param i32) (result i32)
     (select
       (i32.const 2) (i32.const 3)
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (call $dummy) (i32.const 1))
         (else (call $dummy) (i32.const 0))
       )
@@ -80,7 +80,7 @@
 
   (func (export "as-loop-first") (param i32) (result i32)
     (loop (result i32)
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (call $dummy) (i32.const 1))
         (else (call $dummy) (i32.const 0))
       )
@@ -90,7 +90,7 @@
   (func (export "as-loop-mid") (param i32) (result i32)
     (loop (result i32)
       (call $dummy)
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (call $dummy) (i32.const 1))
         (else (call $dummy) (i32.const 0))
       )
@@ -100,7 +100,7 @@
   (func (export "as-loop-last") (param i32) (result i32)
     (loop (result i32)
       (call $dummy) (call $dummy)
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (call $dummy) (i32.const 1))
         (else (call $dummy) (i32.const 0))
       )
@@ -109,7 +109,7 @@
 
   (func (export "as-if-condition") (param i32) (result i32)
     (if (result i32)
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (i32.const 1)) (else (i32.const 0))
       )
       (then (call $dummy) (i32.const 2))
@@ -120,7 +120,7 @@
   (func (export "as-br_if-first") (param i32) (result i32)
     (block (result i32)
       (br_if 0
-        (if (result i32) (get_local 0)
+        (if (result i32) (local.get 0)
           (then (call $dummy) (i32.const 1))
           (else (call $dummy) (i32.const 0))
         )
@@ -133,7 +133,7 @@
     (block (result i32)
       (br_if 0
         (i32.const 2)
-        (if (result i32) (get_local 0)
+        (if (result i32) (local.get 0)
           (then (call $dummy) (i32.const 1))
           (else (call $dummy) (i32.const 0))
         )
@@ -144,7 +144,7 @@
 
   (func (export "as-br_table-first") (param i32) (result i32)
     (block (result i32)
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (call $dummy) (i32.const 1))
         (else (call $dummy) (i32.const 0))
       )
@@ -155,7 +155,7 @@
   (func (export "as-br_table-last") (param i32) (result i32)
     (block (result i32)
       (i32.const 2)
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (call $dummy) (i32.const 1))
         (else (call $dummy) (i32.const 0))
       )
@@ -163,13 +163,13 @@
     )
   )
 
-  (func $func (param i32 i32) (result i32) (get_local 0))
+  (func $func (param i32 i32) (result i32) (local.get 0))
   (type $check (func (param i32 i32) (result i32)))
-  (table anyfunc (elem $func))
+  (table funcref (elem $func))
   (func (export "as-call_indirect-first") (param i32) (result i32)
     (block (result i32)
       (call_indirect (type $check)
-        (if (result i32) (get_local 0)
+        (if (result i32) (local.get 0)
           (then (call $dummy) (i32.const 1))
           (else (call $dummy) (i32.const 0))
         )
@@ -181,7 +181,7 @@
     (block (result i32)
       (call_indirect (type $check)
         (i32.const 2)
-        (if (result i32) (get_local 0)
+        (if (result i32) (local.get 0)
           (then (call $dummy) (i32.const 1))
           (else (call $dummy) (i32.const 0))
         )
@@ -193,7 +193,7 @@
     (block (result i32)
       (call_indirect (type $check)
         (i32.const 2) (i32.const 0)
-        (if (result i32) (get_local 0)
+        (if (result i32) (local.get 0)
           (then (call $dummy) (i32.const 1))
           (else (call $dummy) (i32.const 0))
         )
@@ -202,7 +202,7 @@
   )
 
   (func (export "as-store-first") (param i32)
-    (if (result i32) (get_local 0)
+    (if (result i32) (local.get 0)
       (then (call $dummy) (i32.const 1))
       (else (call $dummy) (i32.const 0))
     )
@@ -211,7 +211,7 @@
   )
   (func (export "as-store-last") (param i32)
     (i32.const 2)
-    (if (result i32) (get_local 0)
+    (if (result i32) (local.get 0)
       (then (call $dummy) (i32.const 1))
       (else (call $dummy) (i32.const 0))
     )
@@ -220,32 +220,32 @@
 
   (func (export "as-memory.grow-value") (param i32) (result i32)
     (memory.grow
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (i32.const 1))
         (else (i32.const 0))
       )
     )
   )
 
-  (func $f (param i32) (result i32) (get_local 0))
+  (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "as-call-value") (param i32) (result i32)
     (call $f
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (i32.const 1))
         (else (i32.const 0))
       )
     )
   )
   (func (export "as-return-value") (param i32) (result i32)
-    (if (result i32) (get_local 0)
+    (if (result i32) (local.get 0)
       (then (i32.const 1))
       (else (i32.const 0)))
     (return)
   )
   (func (export "as-drop-operand") (param i32)
     (drop
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (i32.const 1))
         (else (i32.const 0))
       )
@@ -254,43 +254,43 @@
   (func (export "as-br-value") (param i32) (result i32)
     (block (result i32)
       (br 0
-        (if (result i32) (get_local 0)
+        (if (result i32) (local.get 0)
           (then (i32.const 1))
           (else (i32.const 0))
         )
       )
     )
   )
-  (func (export "as-set_local-value") (param i32) (result i32)
+  (func (export "as-local.set-value") (param i32) (result i32)
     (local i32)
-    (set_local 0
-      (if (result i32) (get_local 0)
+    (local.set 0
+      (if (result i32) (local.get 0)
         (then (i32.const 1))
         (else (i32.const 0))
       )
     )
-    (get_local 0)
+    (local.get 0)
   )
-  (func (export "as-tee_local-value") (param i32) (result i32)
-    (tee_local 0
-      (if (result i32) (get_local 0)
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0
+      (if (result i32) (local.get 0)
         (then (i32.const 1))
         (else (i32.const 0))
       )
     )
   )
   (global $a (mut i32) (i32.const 10))
-  (func (export "as-set_global-value") (param i32) (result i32)
-    (set_global $a
-      (if (result i32) (get_local 0)
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (global.set $a
+      (if (result i32) (local.get 0)
         (then (i32.const 1))
         (else (i32.const 0))
       )
-    ) (get_global $a)
+    ) (global.get $a)
   )
   (func (export "as-load-operand") (param i32) (result i32)
     (i32.load
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (i32.const 11))
         (else (i32.const 10))
       )
@@ -299,7 +299,7 @@
 
   (func (export "as-unary-operand") (param i32) (result i32)
     (i32.ctz
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (call $dummy) (i32.const 13))
         (else (call $dummy) (i32.const -13))
       )
@@ -307,11 +307,11 @@
   )
   (func (export "as-binary-operand") (param i32 i32) (result i32)
     (i32.mul
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (call $dummy) (i32.const 3))
         (else (call $dummy) (i32.const -3))
       )
-      (if (result i32) (get_local 1)
+      (if (result i32) (local.get 1)
         (then (call $dummy) (i32.const 4))
         (else (call $dummy) (i32.const -5))
       )
@@ -319,7 +319,7 @@
   )
   (func (export "as-test-operand") (param i32) (result i32)
     (i32.eqz
-      (if (result i32) (get_local 0)
+      (if (result i32) (local.get 0)
         (then (call $dummy) (i32.const 13))
         (else (call $dummy) (i32.const 0))
       )
@@ -327,11 +327,11 @@
   )
   (func (export "as-compare-operand") (param i32 i32) (result i32)
     (f32.gt
-      (if (result f32) (get_local 0)
+      (if (result f32) (local.get 0)
         (then (call $dummy) (f32.const 3))
         (else (call $dummy) (f32.const -3))
       )
-      (if (result f32) (get_local 1)
+      (if (result f32) (local.get 1)
         (then (call $dummy) (f32.const 4))
         (else (call $dummy) (f32.const -4))
       )
@@ -352,7 +352,7 @@
   )
 
   (func (export "break-value") (param i32) (result i32)
-    (if (result i32) (get_local 0)
+    (if (result i32) (local.get 0)
       (then (br 0 (i32.const 18)) (i32.const 19))
       (else (br 0 (i32.const 21)) (i32.const 20))
     )
@@ -361,23 +361,23 @@
   (func (export "effects") (param i32) (result i32)
     (local i32)
     (if
-      (block (result i32) (set_local 1 (i32.const 1)) (get_local 0))
+      (block (result i32) (local.set 1 (i32.const 1)) (local.get 0))
       (then
-        (set_local 1 (i32.mul (get_local 1) (i32.const 3)))
-        (set_local 1 (i32.sub (get_local 1) (i32.const 5)))
-        (set_local 1 (i32.mul (get_local 1) (i32.const 7)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 7)))
         (br 0)
-        (set_local 1 (i32.mul (get_local 1) (i32.const 100)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 100)))
       )
       (else
-        (set_local 1 (i32.mul (get_local 1) (i32.const 5)))
-        (set_local 1 (i32.sub (get_local 1) (i32.const 7)))
-        (set_local 1 (i32.mul (get_local 1) (i32.const 3)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 5)))
+        (local.set 1 (i32.sub (local.get 1) (i32.const 7)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 3)))
         (br 0)
-        (set_local 1 (i32.mul (get_local 1) (i32.const 1000)))
+        (local.set 1 (i32.mul (local.get 1) (i32.const 1000)))
       )
     )
-    (get_local 1)
+    (local.get 1)
   )
 )
 
@@ -459,14 +459,14 @@
 (assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 0))
 (assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1))
 
-(assert_return (invoke "as-set_local-value" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-set_local-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 1))
 
-(assert_return (invoke "as-tee_local-value" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-tee_local-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1))
 
-(assert_return (invoke "as-set_global-value" (i32.const 0)) (i32.const 0))
-(assert_return (invoke "as-set_global-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1))
 
 (assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 0))
 (assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 0))
diff --git a/test/core/imports.wast b/test/core/imports.wast
index 691550bd3..721182f37 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -6,12 +6,12 @@
   (func (export "func-f32") (param f32))
   (func (export "func->i32") (result i32) (i32.const 22))
   (func (export "func->f32") (result f32) (f32.const 11))
-  (func (export "func-i32->i32") (param i32) (result i32) (get_local 0))
-  (func (export "func-i64->i64") (param i64) (result i64) (get_local 0))
+  (func (export "func-i32->i32") (param i32) (result i32) (local.get 0))
+  (func (export "func-i64->i64") (param i64) (result i64) (local.get 0))
   (global (export "global-i32") i32 (i32.const 55))
   (global (export "global-f32") f32 (f32.const 44))
-  (table (export "table-10-inf") 10 anyfunc)
-  ;; (table (export "table-10-20") 10 20 anyfunc)
+  (table (export "table-10-inf") 10 funcref)
+  ;; (table (export "table-10-20") 10 20 funcref)
   (memory (export "memory-2-inf") 2)
   ;; (memory (export "memory-2-4") 2 4)
 )
@@ -51,36 +51,36 @@
   (func (import "spectest" "print_i32") (type $forward))
   (type $forward (func (param i32)))
 
-  (table anyfunc (elem $print_i32 $print_f64))
+  (table funcref (elem $print_i32 $print_f64))
 
   (func (export "print32") (param $i i32)
     (local $x f32)
-    (set_local $x (f32.convert_s/i32 (get_local $i)))
-    (call 0 (get_local $i))
+    (local.set $x (f32.convert_i32_s (local.get $i)))
+    (call 0 (local.get $i))
     (call $print_i32_f32
-      (i32.add (get_local $i) (i32.const 1))
+      (i32.add (local.get $i) (i32.const 1))
       (f32.const 42)
     )
-    (call $print_i32 (get_local $i))
-    (call $print_i32-2 (get_local $i))
-    (call $print_f32 (get_local $x))
-    (call_indirect (type $func_i32) (get_local $i) (i32.const 0))
+    (call $print_i32 (local.get $i))
+    (call $print_i32-2 (local.get $i))
+    (call $print_f32 (local.get $x))
+    (call_indirect (type $func_i32) (local.get $i) (i32.const 0))
   )
 
   (func (export "print64") (param $i i64)
     (local $x f64)
-    (set_local $x (f64.convert_s/i64 (call $i64->i64 (get_local $i))))
+    (local.set $x (f64.convert_i64_s (call $i64->i64 (local.get $i))))
     ;; JavaScript can't handle i64 yet.
-    ;; (call 1 (get_local $i))
+    ;; (call 1 (local.get $i))
     (call $print_f64_f64
-      (f64.add (get_local $x) (f64.const 1))
+      (f64.add (local.get $x) (f64.const 1))
       (f64.const 53)
     )
     ;; JavaScript can't handle i64 yet.
-    ;; (call $print_i64 (get_local $i))
-    (call $print_f64 (get_local $x))
-    (call $print_f64-2 (get_local $x))
-    (call_indirect (type $func_f64) (get_local $x) (i32.const 1))
+    ;; (call $print_i64 (local.get $i))
+    (call $print_f64 (local.get $x))
+    (call $print_f64-2 (local.get $x))
+    (call_indirect (type $func_f64) (local.get $x) (i32.const 1))
   )
 )
 
@@ -217,10 +217,10 @@
   (import "spectest" "global_f32" (global f32))
   (import "spectest" "global_f64" (global f64))
 
-  (func (export "get-0") (result i32) (get_global 0))
-  (func (export "get-1") (result i32) (get_global 1))
-  (func (export "get-x") (result i32) (get_global $x))
-  (func (export "get-y") (result i32) (get_global $y))
+  (func (export "get-0") (result i32) (global.get 0))
+  (func (export "get-1") (result i32) (global.get 1))
+  (func (export "get-x") (result i32) (global.get $x))
+  (func (export "get-y") (result i32) (global.get $y))
 )
 
 (assert_return (invoke "get-0") (i32.const 666))
@@ -270,11 +270,11 @@
 
 (module
   (type (func (result i32)))
-  (import "spectest" "table" (table 10 20 anyfunc))
+  (import "spectest" "table" (table 10 20 funcref))
   (elem 0 (i32.const 1) $f $g)
 
   (func (export "call") (param i32) (result i32)
-    (call_indirect (type 0) (get_local 0))
+    (call_indirect (type 0) (local.get 0))
   )
   (func $f (result i32) (i32.const 11))
   (func $g (result i32) (i32.const 22))
@@ -289,11 +289,11 @@
 
 (module
   (type (func (result i32)))
-  (table (import "spectest" "table") 10 20 anyfunc)
+  (table (import "spectest" "table") 10 20 funcref)
   (elem 0 (i32.const 1) $f $g)
 
   (func (export "call") (param i32) (result i32)
-    (call_indirect (type 0) (get_local 0))
+    (call_indirect (type 0) (local.get 0))
   )
   (func $f (result i32) (i32.const 11))
   (func $g (result i32) (i32.const 22))
@@ -307,70 +307,70 @@
 
 
 (assert_invalid
-  (module (import "" "" (table 10 anyfunc)) (import "" "" (table 10 anyfunc)))
+  (module (import "" "" (table 10 funcref)) (import "" "" (table 10 funcref)))
   "multiple tables"
 )
 (assert_invalid
-  (module (import "" "" (table 10 anyfunc)) (table 10 anyfunc))
+  (module (import "" "" (table 10 funcref)) (table 10 funcref))
   "multiple tables"
 )
 (assert_invalid
-  (module (table 10 anyfunc) (table 10 anyfunc))
+  (module (table 10 funcref) (table 10 funcref))
   "multiple tables"
 )
 
-(module (import "test" "table-10-inf" (table 10 anyfunc)))
-(module (import "test" "table-10-inf" (table 5 anyfunc)))
-(module (import "test" "table-10-inf" (table 0 anyfunc)))
-(module (import "spectest" "table" (table 10 anyfunc)))
-(module (import "spectest" "table" (table 5 anyfunc)))
-(module (import "spectest" "table" (table 0 anyfunc)))
-(module (import "spectest" "table" (table 10 20 anyfunc)))
-(module (import "spectest" "table" (table 5 20 anyfunc)))
-(module (import "spectest" "table" (table 0 20 anyfunc)))
-(module (import "spectest" "table" (table 10 25 anyfunc)))
-(module (import "spectest" "table" (table 5 25 anyfunc)))
+(module (import "test" "table-10-inf" (table 10 funcref)))
+(module (import "test" "table-10-inf" (table 5 funcref)))
+(module (import "test" "table-10-inf" (table 0 funcref)))
+(module (import "spectest" "table" (table 10 funcref)))
+(module (import "spectest" "table" (table 5 funcref)))
+(module (import "spectest" "table" (table 0 funcref)))
+(module (import "spectest" "table" (table 10 20 funcref)))
+(module (import "spectest" "table" (table 5 20 funcref)))
+(module (import "spectest" "table" (table 0 20 funcref)))
+(module (import "spectest" "table" (table 10 25 funcref)))
+(module (import "spectest" "table" (table 5 25 funcref)))
 
 (assert_unlinkable
-  (module (import "test" "unknown" (table 10 anyfunc)))
+  (module (import "test" "unknown" (table 10 funcref)))
   "unknown import"
 )
 (assert_unlinkable
-  (module (import "spectest" "unknown" (table 10 anyfunc)))
+  (module (import "spectest" "unknown" (table 10 funcref)))
   "unknown import"
 )
 
 (assert_unlinkable
-  (module (import "test" "table-10-inf" (table 12 anyfunc)))
+  (module (import "test" "table-10-inf" (table 12 funcref)))
   "incompatible import type"
 )
 (assert_unlinkable
-  (module (import "test" "table-10-inf" (table 10 20 anyfunc)))
+  (module (import "test" "table-10-inf" (table 10 20 funcref)))
   "incompatible import type"
 )
 (assert_unlinkable
-  (module (import "spectest" "table" (table 12 anyfunc)))
+  (module (import "spectest" "table" (table 12 funcref)))
   "incompatible import type"
 )
 (assert_unlinkable
-  (module (import "spectest" "table" (table 10 15 anyfunc)))
+  (module (import "spectest" "table" (table 10 15 funcref)))
   "incompatible import type"
 )
 
 (assert_unlinkable
-  (module (import "test" "func" (table 10 anyfunc)))
+  (module (import "test" "func" (table 10 funcref)))
   "incompatible import type"
 )
 (assert_unlinkable
-  (module (import "test" "global-i32" (table 10 anyfunc)))
+  (module (import "test" "global-i32" (table 10 funcref)))
   "incompatible import type"
 )
 (assert_unlinkable
-  (module (import "test" "memory-2-inf" (table 10 anyfunc)))
+  (module (import "test" "memory-2-inf" (table 10 funcref)))
   "incompatible import type"
 )
 (assert_unlinkable
-  (module (import "spectest" "print_i32" (table 10 anyfunc)))
+  (module (import "spectest" "print_i32" (table 10 funcref)))
   "incompatible import type"
 )
 
@@ -382,7 +382,7 @@
   (import "spectest" "memory" (memory 1 2))
   (data 0 (i32.const 10) "\10")
 
-  (func (export "load") (param i32) (result i32) (i32.load (get_local 0)))
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
 )
 
 (assert_return (invoke "load" (i32.const 0)) (i32.const 0))
@@ -394,7 +394,7 @@
   (memory (import "spectest" "memory") 1 2)
   (data 0 (i32.const 10) "\10")
 
-  (func (export "load") (param i32) (result i32) (i32.load (get_local 0)))
+  (func (export "load") (param i32) (result i32) (i32.load (local.get 0)))
 )
 (assert_return (invoke "load" (i32.const 0)) (i32.const 0))
 (assert_return (invoke "load" (i32.const 10)) (i32.const 16))
@@ -486,7 +486,7 @@
 
 (module
   (import "spectest" "memory" (memory 0 3))  ;; actual has max size 2
-  (func (export "grow") (param i32) (result i32) (memory.grow (get_local 0)))
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
 )
 (assert_return (invoke "grow" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "grow" (i32.const 1)) (i32.const 1))
@@ -506,7 +506,7 @@
   "import after function"
 )
 (assert_malformed
-  (module quote "(func) (import \"\" \"\" (table 0 anyfunc))")
+  (module quote "(func) (import \"\" \"\" (table 0 funcref))")
   "import after function"
 )
 (assert_malformed
@@ -523,7 +523,7 @@
   "import after global"
 )
 (assert_malformed
-  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 anyfunc))")
+  (module quote "(global i64 (i64.const 0)) (import \"\" \"\" (table 0 funcref))")
   "import after global"
 )
 (assert_malformed
@@ -532,19 +532,19 @@
 )
 
 (assert_malformed
-  (module quote "(table 0 anyfunc) (import \"\" \"\" (func))")
+  (module quote "(table 0 funcref) (import \"\" \"\" (func))")
   "import after table"
 )
 (assert_malformed
-  (module quote "(table 0 anyfunc) (import \"\" \"\" (global i32))")
+  (module quote "(table 0 funcref) (import \"\" \"\" (global i32))")
   "import after table"
 )
 (assert_malformed
-  (module quote "(table 0 anyfunc) (import \"\" \"\" (table 0 anyfunc))")
+  (module quote "(table 0 funcref) (import \"\" \"\" (table 0 funcref))")
   "import after table"
 )
 (assert_malformed
-  (module quote "(table 0 anyfunc) (import \"\" \"\" (memory 0))")
+  (module quote "(table 0 funcref) (import \"\" \"\" (memory 0))")
   "import after table"
 )
 
@@ -557,7 +557,7 @@
   "import after memory"
 )
 (assert_malformed
-  (module quote "(memory 0) (import \"\" \"\" (table 1 3 anyfunc))")
+  (module quote "(memory 0) (import \"\" \"\" (table 1 3 funcref))")
   "import after memory"
 )
 (assert_malformed
@@ -584,7 +584,7 @@
     (import "not wasm" "overloaded" (global i64))
     (import "not wasm" "overloaded" (global f32))
     (import "not wasm" "overloaded" (global f64))
-    (import "not wasm" "overloaded" (table 0 anyfunc))
+    (import "not wasm" "overloaded" (table 0 funcref))
     (import "not wasm" "overloaded" (memory 0))
   )
   "unknown import"
diff --git a/test/core/int_exprs.wast b/test/core/int_exprs.wast
index 99396a8b0..22e1fbcb5 100644
--- a/test/core/int_exprs.wast
+++ b/test/core/int_exprs.wast
@@ -5,14 +5,14 @@
 
 (module
   (func (export "i32.no_fold_cmp_s_offset") (param $x i32) (param $y i32) (result i32)
-    (i32.lt_s (i32.add (get_local $x) (i32.const 1)) (i32.add (get_local $y) (i32.const 1))))
+    (i32.lt_s (i32.add (local.get $x) (i32.const 1)) (i32.add (local.get $y) (i32.const 1))))
   (func (export "i32.no_fold_cmp_u_offset") (param $x i32) (param $y i32) (result i32)
-    (i32.lt_u (i32.add (get_local $x) (i32.const 1)) (i32.add (get_local $y) (i32.const 1))))
+    (i32.lt_u (i32.add (local.get $x) (i32.const 1)) (i32.add (local.get $y) (i32.const 1))))
 
   (func (export "i64.no_fold_cmp_s_offset") (param $x i64) (param $y i64) (result i32)
-    (i64.lt_s (i64.add (get_local $x) (i64.const 1)) (i64.add (get_local $y) (i64.const 1))))
+    (i64.lt_s (i64.add (local.get $x) (i64.const 1)) (i64.add (local.get $y) (i64.const 1))))
   (func (export "i64.no_fold_cmp_u_offset") (param $x i64) (param $y i64) (result i32)
-    (i64.lt_u (i64.add (get_local $x) (i64.const 1)) (i64.add (get_local $y) (i64.const 1))))
+    (i64.lt_u (i64.add (local.get $x) (i64.const 1)) (i64.add (local.get $y) (i64.const 1))))
 )
 
 (assert_return (invoke "i32.no_fold_cmp_s_offset" (i32.const 0x7fffffff) (i32.const 0)) (i32.const 1))
@@ -24,7 +24,7 @@
 
 (module
   (func (export "i64.no_fold_wrap_extend_s") (param $x i64) (result i64)
-    (i64.extend_s/i32 (i32.wrap/i64 (get_local $x))))
+    (i64.extend_i32_s (i32.wrap_i64 (local.get $x))))
 )
 
 (assert_return (invoke "i64.no_fold_wrap_extend_s" (i64.const 0x0010203040506070)) (i64.const 0x0000000040506070))
@@ -34,7 +34,7 @@
 
 (module
   (func (export "i64.no_fold_wrap_extend_u") (param $x i64) (result i64)
-    (i64.extend_u/i32 (i32.wrap/i64 (get_local $x))))
+    (i64.extend_i32_u (i32.wrap_i64 (local.get $x))))
 )
 
 (assert_return (invoke "i64.no_fold_wrap_extend_u" (i64.const 0x0010203040506070)) (i64.const 0x0000000040506070))
@@ -43,14 +43,14 @@
 
 (module
   (func (export "i32.no_fold_shl_shr_s") (param $x i32) (result i32)
-    (i32.shr_s (i32.shl (get_local $x) (i32.const 1)) (i32.const 1)))
+    (i32.shr_s (i32.shl (local.get $x) (i32.const 1)) (i32.const 1)))
   (func (export "i32.no_fold_shl_shr_u") (param $x i32) (result i32)
-    (i32.shr_u (i32.shl (get_local $x) (i32.const 1)) (i32.const 1)))
+    (i32.shr_u (i32.shl (local.get $x) (i32.const 1)) (i32.const 1)))
 
   (func (export "i64.no_fold_shl_shr_s") (param $x i64) (result i64)
-    (i64.shr_s (i64.shl (get_local $x) (i64.const 1)) (i64.const 1)))
+    (i64.shr_s (i64.shl (local.get $x) (i64.const 1)) (i64.const 1)))
   (func (export "i64.no_fold_shl_shr_u") (param $x i64) (result i64)
-    (i64.shr_u (i64.shl (get_local $x) (i64.const 1)) (i64.const 1)))
+    (i64.shr_u (i64.shl (local.get $x) (i64.const 1)) (i64.const 1)))
 )
 
 (assert_return (invoke "i32.no_fold_shl_shr_s" (i32.const 0x80000000)) (i32.const 0))
@@ -62,14 +62,14 @@
 
 (module
   (func (export "i32.no_fold_shr_s_shl") (param $x i32) (result i32)
-    (i32.shl (i32.shr_s (get_local $x) (i32.const 1)) (i32.const 1)))
+    (i32.shl (i32.shr_s (local.get $x) (i32.const 1)) (i32.const 1)))
   (func (export "i32.no_fold_shr_u_shl") (param $x i32) (result i32)
-    (i32.shl (i32.shr_u (get_local $x) (i32.const 1)) (i32.const 1)))
+    (i32.shl (i32.shr_u (local.get $x) (i32.const 1)) (i32.const 1)))
 
   (func (export "i64.no_fold_shr_s_shl") (param $x i64) (result i64)
-    (i64.shl (i64.shr_s (get_local $x) (i64.const 1)) (i64.const 1)))
+    (i64.shl (i64.shr_s (local.get $x) (i64.const 1)) (i64.const 1)))
   (func (export "i64.no_fold_shr_u_shl") (param $x i64) (result i64)
-    (i64.shl (i64.shr_u (get_local $x) (i64.const 1)) (i64.const 1)))
+    (i64.shl (i64.shr_u (local.get $x) (i64.const 1)) (i64.const 1)))
 )
 
 (assert_return (invoke "i32.no_fold_shr_s_shl" (i32.const 1)) (i32.const 0))
@@ -81,14 +81,14 @@
 
 (module
   (func (export "i32.no_fold_div_s_mul") (param $x i32) (result i32)
-    (i32.mul (i32.div_s (get_local $x) (i32.const 6)) (i32.const 6)))
+    (i32.mul (i32.div_s (local.get $x) (i32.const 6)) (i32.const 6)))
   (func (export "i32.no_fold_div_u_mul") (param $x i32) (result i32)
-    (i32.mul (i32.div_u (get_local $x) (i32.const 6)) (i32.const 6)))
+    (i32.mul (i32.div_u (local.get $x) (i32.const 6)) (i32.const 6)))
 
   (func (export "i64.no_fold_div_s_mul") (param $x i64) (result i64)
-    (i64.mul (i64.div_s (get_local $x) (i64.const 6)) (i64.const 6)))
+    (i64.mul (i64.div_s (local.get $x) (i64.const 6)) (i64.const 6)))
   (func (export "i64.no_fold_div_u_mul") (param $x i64) (result i64)
-    (i64.mul (i64.div_u (get_local $x) (i64.const 6)) (i64.const 6)))
+    (i64.mul (i64.div_u (local.get $x) (i64.const 6)) (i64.const 6)))
 )
 
 (assert_return (invoke "i32.no_fold_div_s_mul" (i32.const 1)) (i32.const 0))
@@ -100,14 +100,14 @@
 
 (module
   (func (export "i32.no_fold_div_s_self") (param $x i32) (result i32)
-    (i32.div_s (get_local $x) (get_local $x)))
+    (i32.div_s (local.get $x) (local.get $x)))
   (func (export "i32.no_fold_div_u_self") (param $x i32) (result i32)
-    (i32.div_u (get_local $x) (get_local $x)))
+    (i32.div_u (local.get $x) (local.get $x)))
 
   (func (export "i64.no_fold_div_s_self") (param $x i64) (result i64)
-    (i64.div_s (get_local $x) (get_local $x)))
+    (i64.div_s (local.get $x) (local.get $x)))
   (func (export "i64.no_fold_div_u_self") (param $x i64) (result i64)
-    (i64.div_u (get_local $x) (get_local $x)))
+    (i64.div_u (local.get $x) (local.get $x)))
 )
 
 (assert_trap (invoke "i32.no_fold_div_s_self" (i32.const 0)) "integer divide by zero")
@@ -119,14 +119,14 @@
 
 (module
   (func (export "i32.no_fold_rem_s_self") (param $x i32) (result i32)
-    (i32.rem_s (get_local $x) (get_local $x)))
+    (i32.rem_s (local.get $x) (local.get $x)))
   (func (export "i32.no_fold_rem_u_self") (param $x i32) (result i32)
-    (i32.rem_u (get_local $x) (get_local $x)))
+    (i32.rem_u (local.get $x) (local.get $x)))
 
   (func (export "i64.no_fold_rem_s_self") (param $x i64) (result i64)
-    (i64.rem_s (get_local $x) (get_local $x)))
+    (i64.rem_s (local.get $x) (local.get $x)))
   (func (export "i64.no_fold_rem_u_self") (param $x i64) (result i64)
-    (i64.rem_u (get_local $x) (get_local $x)))
+    (i64.rem_u (local.get $x) (local.get $x)))
 )
 
 (assert_trap (invoke "i32.no_fold_rem_s_self" (i32.const 0)) "integer divide by zero")
@@ -138,14 +138,14 @@
 
 (module
   (func (export "i32.no_fold_mul_div_s") (param $x i32) (result i32)
-    (i32.div_s (i32.mul (get_local $x) (i32.const 6)) (i32.const 6)))
+    (i32.div_s (i32.mul (local.get $x) (i32.const 6)) (i32.const 6)))
   (func (export "i32.no_fold_mul_div_u") (param $x i32) (result i32)
-    (i32.div_u (i32.mul (get_local $x) (i32.const 6)) (i32.const 6)))
+    (i32.div_u (i32.mul (local.get $x) (i32.const 6)) (i32.const 6)))
 
   (func (export "i64.no_fold_mul_div_s") (param $x i64) (result i64)
-    (i64.div_s (i64.mul (get_local $x) (i64.const 6)) (i64.const 6)))
+    (i64.div_s (i64.mul (local.get $x) (i64.const 6)) (i64.const 6)))
   (func (export "i64.no_fold_mul_div_u") (param $x i64) (result i64)
-    (i64.div_u (i64.mul (get_local $x) (i64.const 6)) (i64.const 6)))
+    (i64.div_u (i64.mul (local.get $x) (i64.const 6)) (i64.const 6)))
 )
 
 (assert_return (invoke "i32.no_fold_mul_div_s" (i32.const 0x80000000)) (i32.const 0))
@@ -157,10 +157,10 @@
 
 (module
   (func (export "i32.no_fold_div_s_2") (param $x i32) (result i32)
-    (i32.div_s (get_local $x) (i32.const 2)))
+    (i32.div_s (local.get $x) (i32.const 2)))
 
   (func (export "i64.no_fold_div_s_2") (param $x i64) (result i64)
-    (i64.div_s (get_local $x) (i64.const 2)))
+    (i64.div_s (local.get $x) (i64.const 2)))
 )
 
 (assert_return (invoke "i32.no_fold_div_s_2" (i32.const -11)) (i32.const -5))
@@ -170,10 +170,10 @@
 
 (module
   (func (export "i32.no_fold_rem_s_2") (param $x i32) (result i32)
-    (i32.rem_s (get_local $x) (i32.const 2)))
+    (i32.rem_s (local.get $x) (i32.const 2)))
 
   (func (export "i64.no_fold_rem_s_2") (param $x i64) (result i64)
-    (i64.rem_s (get_local $x) (i64.const 2)))
+    (i64.rem_s (local.get $x) (i64.const 2)))
 )
 
 (assert_return (invoke "i32.no_fold_rem_s_2" (i32.const -11)) (i32.const -1))
@@ -183,14 +183,14 @@
 
 (module
   (func (export "i32.div_s_0") (param $x i32) (result i32)
-    (i32.div_s (get_local $x) (i32.const 0)))
+    (i32.div_s (local.get $x) (i32.const 0)))
   (func (export "i32.div_u_0") (param $x i32) (result i32)
-    (i32.div_u (get_local $x) (i32.const 0)))
+    (i32.div_u (local.get $x) (i32.const 0)))
 
   (func (export "i64.div_s_0") (param $x i64) (result i64)
-    (i64.div_s (get_local $x) (i64.const 0)))
+    (i64.div_s (local.get $x) (i64.const 0)))
   (func (export "i64.div_u_0") (param $x i64) (result i64)
-    (i64.div_u (get_local $x) (i64.const 0)))
+    (i64.div_u (local.get $x) (i64.const 0)))
 )
 
 (assert_trap (invoke "i32.div_s_0" (i32.const 71)) "integer divide by zero")
@@ -202,14 +202,14 @@
 
 (module
   (func (export "i32.div_s_3") (param $x i32) (result i32)
-    (i32.div_s (get_local $x) (i32.const 3)))
+    (i32.div_s (local.get $x) (i32.const 3)))
   (func (export "i32.div_u_3") (param $x i32) (result i32)
-    (i32.div_u (get_local $x) (i32.const 3)))
+    (i32.div_u (local.get $x) (i32.const 3)))
 
   (func (export "i64.div_s_3") (param $x i64) (result i64)
-    (i64.div_s (get_local $x) (i64.const 3)))
+    (i64.div_s (local.get $x) (i64.const 3)))
   (func (export "i64.div_u_3") (param $x i64) (result i64)
-    (i64.div_u (get_local $x) (i64.const 3)))
+    (i64.div_u (local.get $x) (i64.const 3)))
 )
 
 (assert_return (invoke "i32.div_s_3" (i32.const 71)) (i32.const 23))
@@ -225,14 +225,14 @@
 
 (module
   (func (export "i32.div_s_5") (param $x i32) (result i32)
-    (i32.div_s (get_local $x) (i32.const 5)))
+    (i32.div_s (local.get $x) (i32.const 5)))
   (func (export "i32.div_u_5") (param $x i32) (result i32)
-    (i32.div_u (get_local $x) (i32.const 5)))
+    (i32.div_u (local.get $x) (i32.const 5)))
 
   (func (export "i64.div_s_5") (param $x i64) (result i64)
-    (i64.div_s (get_local $x) (i64.const 5)))
+    (i64.div_s (local.get $x) (i64.const 5)))
   (func (export "i64.div_u_5") (param $x i64) (result i64)
-    (i64.div_u (get_local $x) (i64.const 5)))
+    (i64.div_u (local.get $x) (i64.const 5)))
 )
 
 (assert_return (invoke "i32.div_s_5" (i32.const 71)) (i32.const 14))
@@ -248,14 +248,14 @@
 
 (module
   (func (export "i32.div_s_7") (param $x i32) (result i32)
-    (i32.div_s (get_local $x) (i32.const 7)))
+    (i32.div_s (local.get $x) (i32.const 7)))
   (func (export "i32.div_u_7") (param $x i32) (result i32)
-    (i32.div_u (get_local $x) (i32.const 7)))
+    (i32.div_u (local.get $x) (i32.const 7)))
 
   (func (export "i64.div_s_7") (param $x i64) (result i64)
-    (i64.div_s (get_local $x) (i64.const 7)))
+    (i64.div_s (local.get $x) (i64.const 7)))
   (func (export "i64.div_u_7") (param $x i64) (result i64)
-    (i64.div_u (get_local $x) (i64.const 7)))
+    (i64.div_u (local.get $x) (i64.const 7)))
 )
 
 (assert_return (invoke "i32.div_s_7" (i32.const 71)) (i32.const 10))
@@ -271,14 +271,14 @@
 
 (module
   (func (export "i32.rem_s_3") (param $x i32) (result i32)
-    (i32.rem_s (get_local $x) (i32.const 3)))
+    (i32.rem_s (local.get $x) (i32.const 3)))
   (func (export "i32.rem_u_3") (param $x i32) (result i32)
-    (i32.rem_u (get_local $x) (i32.const 3)))
+    (i32.rem_u (local.get $x) (i32.const 3)))
 
   (func (export "i64.rem_s_3") (param $x i64) (result i64)
-    (i64.rem_s (get_local $x) (i64.const 3)))
+    (i64.rem_s (local.get $x) (i64.const 3)))
   (func (export "i64.rem_u_3") (param $x i64) (result i64)
-    (i64.rem_u (get_local $x) (i64.const 3)))
+    (i64.rem_u (local.get $x) (i64.const 3)))
 )
 
 (assert_return (invoke "i32.rem_s_3" (i32.const 71)) (i32.const 2))
@@ -294,14 +294,14 @@
 
 (module
   (func (export "i32.rem_s_5") (param $x i32) (result i32)
-    (i32.rem_s (get_local $x) (i32.const 5)))
+    (i32.rem_s (local.get $x) (i32.const 5)))
   (func (export "i32.rem_u_5") (param $x i32) (result i32)
-    (i32.rem_u (get_local $x) (i32.const 5)))
+    (i32.rem_u (local.get $x) (i32.const 5)))
 
   (func (export "i64.rem_s_5") (param $x i64) (result i64)
-    (i64.rem_s (get_local $x) (i64.const 5)))
+    (i64.rem_s (local.get $x) (i64.const 5)))
   (func (export "i64.rem_u_5") (param $x i64) (result i64)
-    (i64.rem_u (get_local $x) (i64.const 5)))
+    (i64.rem_u (local.get $x) (i64.const 5)))
 )
 
 (assert_return (invoke "i32.rem_s_5" (i32.const 71)) (i32.const 1))
@@ -317,14 +317,14 @@
 
 (module
   (func (export "i32.rem_s_7") (param $x i32) (result i32)
-    (i32.rem_s (get_local $x) (i32.const 7)))
+    (i32.rem_s (local.get $x) (i32.const 7)))
   (func (export "i32.rem_u_7") (param $x i32) (result i32)
-    (i32.rem_u (get_local $x) (i32.const 7)))
+    (i32.rem_u (local.get $x) (i32.const 7)))
 
   (func (export "i64.rem_s_7") (param $x i64) (result i64)
-    (i64.rem_s (get_local $x) (i64.const 7)))
+    (i64.rem_s (local.get $x) (i64.const 7)))
   (func (export "i64.rem_u_7") (param $x i64) (result i64)
-    (i64.rem_u (get_local $x) (i64.const 7)))
+    (i64.rem_u (local.get $x) (i64.const 7)))
 )
 
 (assert_return (invoke "i32.rem_s_7" (i32.const 71)) (i32.const 1))
@@ -340,10 +340,10 @@
 
 (module
   (func (export "i32.no_fold_div_neg1") (param $x i32) (result i32)
-    (i32.div_s (get_local $x) (i32.const -1)))
+    (i32.div_s (local.get $x) (i32.const -1)))
 
   (func (export "i64.no_fold_div_neg1") (param $x i64) (result i64)
-    (i64.div_s (get_local $x) (i64.const -1)))
+    (i64.div_s (local.get $x) (i64.const -1)))
 )
 
 (assert_trap (invoke "i32.no_fold_div_neg1" (i32.const 0x80000000)) "integer overflow")
diff --git a/test/core/labels.wast b/test/core/labels.wast
index 5873687c6..6fbf6292d 100644
--- a/test/core/labels.wast
+++ b/test/core/labels.wast
@@ -8,12 +8,12 @@
 
   (func (export "loop1") (result i32)
     (local $i i32)
-    (set_local $i (i32.const 0))
+    (local.set $i (i32.const 0))
     (block $exit (result i32)
       (loop $cont (result i32)
-        (set_local $i (i32.add (get_local $i) (i32.const 1)))
-        (if (i32.eq (get_local $i) (i32.const 5))
-          (then (br $exit (get_local $i)))
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (if (i32.eq (local.get $i) (i32.const 5))
+          (then (br $exit (local.get $i)))
         )
         (br $cont)
       )
@@ -22,17 +22,17 @@
 
   (func (export "loop2") (result i32)
     (local $i i32)
-    (set_local $i (i32.const 0))
+    (local.set $i (i32.const 0))
     (block $exit (result i32)
       (loop $cont (result i32)
-        (set_local $i (i32.add (get_local $i) (i32.const 1)))
-        (if (i32.eq (get_local $i) (i32.const 5))
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (if (i32.eq (local.get $i) (i32.const 5))
           (then (br $cont))
         )
-        (if (i32.eq (get_local $i) (i32.const 8))
-          (then (br $exit (get_local $i)))
+        (if (i32.eq (local.get $i) (i32.const 8))
+          (then (br $exit (local.get $i)))
         )
-        (set_local $i (i32.add (get_local $i) (i32.const 1)))
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
         (br $cont)
       )
     )
@@ -40,26 +40,26 @@
 
   (func (export "loop3") (result i32)
     (local $i i32)
-    (set_local $i (i32.const 0))
+    (local.set $i (i32.const 0))
     (block $exit (result i32)
       (loop $cont (result i32)
-        (set_local $i (i32.add (get_local $i) (i32.const 1)))
-        (if (i32.eq (get_local $i) (i32.const 5))
-          (then (br $exit (get_local $i)))
+        (local.set $i (i32.add (local.get $i) (i32.const 1)))
+        (if (i32.eq (local.get $i) (i32.const 5))
+          (then (br $exit (local.get $i)))
         )
-        (get_local $i)
+        (local.get $i)
       )
     )
   )
 
   (func (export "loop4") (param $max i32) (result i32)
     (local $i i32)
-    (set_local $i (i32.const 1))
+    (local.set $i (i32.const 1))
     (block $exit (result i32)
       (loop $cont (result i32)
-        (set_local $i (i32.add (get_local $i) (get_local $i)))
-        (if (i32.gt_u (get_local $i) (get_local $max))
-          (then (br $exit (get_local $i)))
+        (local.set $i (i32.add (local.get $i) (local.get $i)))
+        (if (i32.gt_u (local.get $i) (local.get $max))
+          (then (br $exit (local.get $i)))
         )
         (br $cont)
       )
@@ -82,76 +82,76 @@
 
   (func (export "if") (result i32)
     (local $i i32)
-    (set_local $i (i32.const 0))
+    (local.set $i (i32.const 0))
     (block
       (if $l
         (i32.const 1)
-        (then (br $l) (set_local $i (i32.const 666)))
+        (then (br $l) (local.set $i (i32.const 666)))
       )
-      (set_local $i (i32.add (get_local $i) (i32.const 1)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (if $l
         (i32.const 1)
-        (then (br $l) (set_local $i (i32.const 666)))
-        (else (set_local $i (i32.const 888)))
+        (then (br $l) (local.set $i (i32.const 666)))
+        (else (local.set $i (i32.const 888)))
       )
-      (set_local $i (i32.add (get_local $i) (i32.const 1)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (if $l
         (i32.const 1)
-        (then (br $l) (set_local $i (i32.const 666)))
-        (else (set_local $i (i32.const 888)))
+        (then (br $l) (local.set $i (i32.const 666)))
+        (else (local.set $i (i32.const 888)))
       )
-      (set_local $i (i32.add (get_local $i) (i32.const 1)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (if $l
         (i32.const 0)
-        (then (set_local $i (i32.const 888)))
-        (else (br $l) (set_local $i (i32.const 666)))
+        (then (local.set $i (i32.const 888)))
+        (else (br $l) (local.set $i (i32.const 666)))
       )
-      (set_local $i (i32.add (get_local $i) (i32.const 1)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (if $l
         (i32.const 0)
-        (then (set_local $i (i32.const 888)))
-        (else (br $l) (set_local $i (i32.const 666)))
+        (then (local.set $i (i32.const 888)))
+        (else (br $l) (local.set $i (i32.const 666)))
       )
-      (set_local $i (i32.add (get_local $i) (i32.const 1)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
     )
-    (get_local $i)
+    (local.get $i)
   )
 
   (func (export "if2") (result i32)
     (local $i i32)
-    (set_local $i (i32.const 0))
+    (local.set $i (i32.const 0))
     (block
       (if
         (i32.const 1)
-        (then (br 0) (set_local $i (i32.const 666)))
+        (then (br 0) (local.set $i (i32.const 666)))
       )
-      (set_local $i (i32.add (get_local $i) (i32.const 1)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (if
         (i32.const 1)
-        (then (br 0) (set_local $i (i32.const 666)))
-        (else (set_local $i (i32.const 888)))
+        (then (br 0) (local.set $i (i32.const 666)))
+        (else (local.set $i (i32.const 888)))
       )
-      (set_local $i (i32.add (get_local $i) (i32.const 1)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (if
         (i32.const 1)
-        (then (br 0) (set_local $i (i32.const 666)))
-        (else (set_local $i (i32.const 888)))
+        (then (br 0) (local.set $i (i32.const 666)))
+        (else (local.set $i (i32.const 888)))
       )
-      (set_local $i (i32.add (get_local $i) (i32.const 1)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (if
         (i32.const 0)
-        (then (set_local $i (i32.const 888)))
-        (else (br 0) (set_local $i (i32.const 666)))
+        (then (local.set $i (i32.const 888)))
+        (else (br 0) (local.set $i (i32.const 666)))
       )
-      (set_local $i (i32.add (get_local $i) (i32.const 1)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
       (if
         (i32.const 0)
-        (then (set_local $i (i32.const 888)))
-        (else (br 0) (set_local $i (i32.const 666)))
+        (then (local.set $i (i32.const 888)))
+        (else (br 0) (local.set $i (i32.const 666)))
       )
-      (set_local $i (i32.add (get_local $i) (i32.const 1)))
+      (local.set $i (i32.add (local.get $i) (i32.const 1)))
     )
-    (get_local $i)
+    (local.get $i)
   )
 
   (func (export "switch") (param i32) (result i32)
@@ -163,7 +163,7 @@
               (block $3
                 (block $2
                   (block $1
-                    (br_table $0 $1 $2 $3 $default (get_local 0))
+                    (br_table $0 $1 $2 $3 $default (local.get 0))
                   ) ;; 1
                 ) ;; 2
                 (br $exit (i32.const 2))
@@ -181,7 +181,7 @@
     (block $default
       (block $1
         (block $0
-          (br_table $0 $1 (get_local 0))
+          (br_table $0 $1 (local.get 0))
           (br $default)
         ) ;; 0
         (return (i32.const 0))
@@ -192,30 +192,30 @@
 
   (func (export "br_if0") (result i32)
     (local $i i32)
-    (set_local $i (i32.const 0))
+    (local.set $i (i32.const 0))
     (block $outer (result i32)
       (block $inner
         (br_if $inner (i32.const 0))
-        (set_local $i (i32.or (get_local $i) (i32.const 0x1)))
+        (local.set $i (i32.or (local.get $i) (i32.const 0x1)))
         (br_if $inner (i32.const 1))
-        (set_local $i (i32.or (get_local $i) (i32.const 0x2)))
+        (local.set $i (i32.or (local.get $i) (i32.const 0x2)))
       )
       (drop (br_if $outer
         (block (result i32)
-          (set_local $i (i32.or (get_local $i) (i32.const 0x4)))
-          (get_local $i)
+          (local.set $i (i32.or (local.get $i) (i32.const 0x4)))
+          (local.get $i)
         )
         (i32.const 0)
       ))
-      (set_local $i (i32.or (get_local $i) (i32.const 0x8)))
+      (local.set $i (i32.or (local.get $i) (i32.const 0x8)))
       (drop (br_if $outer
         (block (result i32)
-          (set_local $i (i32.or (get_local $i) (i32.const 0x10)))
-          (get_local $i)
+          (local.set $i (i32.or (local.get $i) (i32.const 0x10)))
+          (local.get $i)
         )
         (i32.const 1)
       ))
-      (set_local $i (i32.or (get_local $i) (i32.const 0x20))) (get_local $i)
+      (local.set $i (i32.or (local.get $i) (i32.const 0x20))) (local.get $i)
     )
   )
 
@@ -253,15 +253,15 @@
       (i32.add
         (block $l0 (result i32)
           (drop (br_if $l0
-            (block (result i32) (set_local $i1 (i32.const 1)) (get_local $i1))
-            (block (result i32) (set_local $i1 (i32.const 2)) (get_local $i1))
+            (block (result i32) (local.set $i1 (i32.const 1)) (local.get $i1))
+            (block (result i32) (local.set $i1 (i32.const 2)) (local.get $i1))
           ))
           (i32.const 0)
         )
         (i32.const 0)
       )
     )
-    (get_local $i1)
+    (local.get $i1)
   )
 
   (func (export "br") (result i32)
diff --git a/test/core/left-to-right.wast b/test/core/left-to-right.wast
index 65d3809ac..634aa9c86 100644
--- a/test/core/left-to-right.wast
+++ b/test/core/left-to-right.wast
@@ -5,7 +5,7 @@
   (type $i64_T (func (param i64 i64) (result i32)))
   (type $f32_T (func (param f32 f32) (result i32)))
   (type $f64_T (func (param f64 f64) (result i32)))
-  (table anyfunc
+  (table funcref
     (elem $i32_t0 $i32_t1 $i64_t0 $i64_t1 $f32_t0 $f32_t1 $f64_t0 $f64_t1)
   )
 
diff --git a/test/core/linking.wast b/test/core/linking.wast
index e2fc8b8f2..67ff7dd92 100644
--- a/test/core/linking.wast
+++ b/test/core/linking.wast
@@ -38,12 +38,12 @@
 
 (module $Mg
   (global $glob (export "glob") i32 (i32.const 42))
-  (func (export "get") (result i32) (get_global $glob))
+  (func (export "get") (result i32) (global.get $glob))
 
   ;; export mutable globals
   (global $mut_glob (export "mut_glob") (mut i32) (i32.const 142))
-  (func (export "get_mut") (result i32) (get_global $mut_glob))
-  (func (export "set_mut") (param i32) (set_global $mut_glob (get_local 0)))
+  (func (export "get_mut") (result i32) (global.get $mut_glob))
+  (func (export "set_mut") (param i32) (global.set $mut_glob (local.get 0)))
 )
 (register "Mg" $Mg)
 
@@ -57,7 +57,7 @@
   (export "Mg.glob" (global $x))
   (export "Mg.get" (func $f))
   (global $glob (export "glob") i32 (i32.const 43))
-  (func (export "get") (result i32) (get_global $glob))
+  (func (export "get") (result i32) (global.get $glob))
 
   (export "Mg.mut_glob" (global $mut_glob))
   (export "Mg.get_mut" (func $get_mut))
@@ -98,13 +98,13 @@
   (type (func (result i32)))
   (type (func))
 
-  (table (export "tab") 10 anyfunc)
+  (table (export "tab") 10 funcref)
   (elem (i32.const 2) $g $g $g $g)
   (func $g (result i32) (i32.const 4))
   (func (export "h") (result i32) (i32.const -4))
 
   (func (export "call") (param i32) (result i32)
-    (call_indirect (type 0) (get_local 0))
+    (call_indirect (type 0) (local.get 0))
   )
 )
 (register "Mt" $Mt)
@@ -116,15 +116,15 @@
   (func $f (import "Mt" "call") (param i32) (result i32))
   (func $h (import "Mt" "h") (result i32))
 
-  (table anyfunc (elem $g $g $g $h $f))
+  (table funcref (elem $g $g $g $h $f))
   (func $g (result i32) (i32.const 5))
 
   (export "Mt.call" (func $f))
   (func (export "call Mt.call") (param i32) (result i32)
-    (call $f (get_local 0))
+    (call $f (local.get 0))
   )
   (func (export "call") (param i32) (result i32)
-    (call_indirect (type 1) (get_local 0))
+    (call_indirect (type 1) (local.get 0))
   )
 )
 
@@ -155,12 +155,12 @@
   (type (func (result i32)))
 
   (func $h (import "Mt" "h") (result i32))
-  (table (import "Mt" "tab") 5 anyfunc)
+  (table (import "Mt" "tab") 5 funcref)
   (elem (i32.const 1) $i $h)
   (func $i (result i32) (i32.const 6))
 
   (func (export "call") (param i32) (result i32)
-    (call_indirect (type 0) (get_local 0))
+    (call_indirect (type 0) (local.get 0))
   )
 )
 
@@ -190,7 +190,7 @@
 (assert_trap (invoke $Ot "call" (i32.const 20)) "undefined")
 
 (module
-  (table (import "Mt" "tab") 0 anyfunc)
+  (table (import "Mt" "tab") 0 funcref)
   (elem (i32.const 9) $f)
   (func $f)
 )
@@ -199,13 +199,13 @@
 (register "G1" $G1)
 (module $G2
   (global (import "G1" "g") i32)
-  (global (export "g") i32 (get_global 0))
+  (global (export "g") i32 (global.get 0))
 )
 (assert_return (get $G2 "g") (i32.const 5))
 
 (assert_unlinkable
   (module
-    (table (import "Mt" "tab") 0 anyfunc)
+    (table (import "Mt" "tab") 0 funcref)
     (elem (i32.const 10) $f)
     (func $f)
   )
@@ -214,7 +214,7 @@
 
 (assert_unlinkable
   (module
-    (table (import "Mt" "tab") 10 anyfunc)
+    (table (import "Mt" "tab") 10 funcref)
     (memory (import "Mt" "mem") 1)  ;; does not exist
     (func $f (result i32) (i32.const 0))
     (elem (i32.const 7) $f)
@@ -226,7 +226,7 @@
 
 (assert_unlinkable
   (module
-    (table (import "Mt" "tab") 10 anyfunc)
+    (table (import "Mt" "tab") 10 funcref)
     (func $f (result i32) (i32.const 0))
     (elem (i32.const 7) $f)
     (elem (i32.const 12) $f)  ;; out of bounds
@@ -237,7 +237,7 @@
 
 (assert_unlinkable
   (module
-    (table (import "Mt" "tab") 10 anyfunc)
+    (table (import "Mt" "tab") 10 funcref)
     (func $f (result i32) (i32.const 0))
     (elem (i32.const 7) $f)
     (memory 1)
@@ -255,7 +255,7 @@
   (data (i32.const 10) "\00\01\02\03\04\05\06\07\08\09")
 
   (func (export "load") (param $a i32) (result i32)
-    (i32.load8_u (get_local 0))
+    (i32.load8_u (local.get 0))
   )
 )
 (register "Mm" $Mm)
@@ -268,7 +268,7 @@
 
   (export "Mm.load" (func $loadM))
   (func (export "load") (param $a i32) (result i32)
-    (i32.load8_u (get_local 0))
+    (i32.load8_u (local.get 0))
   )
 )
 
@@ -281,7 +281,7 @@
   (data (i32.const 5) "\a0\a1\a2\a3\a4\a5\a6\a7")
 
   (func (export "load") (param $a i32) (result i32)
-    (i32.load8_u (get_local 0))
+    (i32.load8_u (local.get 0))
   )
 )
 
@@ -307,7 +307,7 @@
   (memory (import "Mm" "mem") 1 8)
 
   (func (export "grow") (param $a i32) (result i32)
-    (memory.grow (get_local 0))
+    (memory.grow (local.get 0))
   )
 )
 
@@ -324,7 +324,7 @@
   (module
     (func $host (import "spectest" "print"))
     (memory (import "Mm" "mem") 1)
-    (table (import "Mm" "tab") 0 anyfunc)  ;; does not exist
+    (table (import "Mm" "tab") 0 funcref)  ;; does not exist
     (data (i32.const 0) "abc")
   )
   "unknown import"
@@ -345,7 +345,7 @@
   (module
     (memory (import "Mm" "mem") 1)
     (data (i32.const 0) "abc")
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func)
     (elem (i32.const 0) 0) ;; out of bounds
   )
diff --git a/test/core/load.wast b/test/core/load.wast
index 12ea96b2a..67c29e97a 100644
--- a/test/core/load.wast
+++ b/test/core/load.wast
@@ -56,10 +56,10 @@
   )
 
   (func (export "as-select-first") (param i32 i32) (result i32)
-    (select (i32.load (i32.const 0)) (get_local 0) (get_local 1))
+    (select (i32.load (i32.const 0)) (local.get 0) (local.get 1))
   )
   (func (export "as-select-second") (param i32 i32) (result i32)
-    (select (get_local 0) (i32.load (i32.const 0)) (get_local 1))
+    (select (local.get 0) (i32.load (i32.const 0)) (local.get 1))
   )
   (func (export "as-select-cond") (result i32)
     (select (i32.const 0) (i32.const 1) (i32.load (i32.const 0)))
@@ -77,7 +77,7 @@
   )
 
   (type $sig (func (param i32 i32 i32) (result i32)))
-  (table anyfunc (elem $f))
+  (table funcref (elem $f))
   (func (export "as-call_indirect-first") (result i32)
     (call_indirect (type $sig)
       (i32.load (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
@@ -99,15 +99,15 @@
     )
   )
 
-  (func (export "as-set_local-value") (local i32)
-    (set_local 0 (i32.load (i32.const 0)))
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (i32.load (i32.const 0)))
   )
-  (func (export "as-tee_local-value") (result i32) (local i32)
-    (tee_local 0 (i32.load (i32.const 0)))
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (i32.load (i32.const 0)))
   )
   (global $g (mut i32) (i32.const 0))
-  (func (export "as-set_global-value") (local i32)
-    (set_global $g (i32.load (i32.const 0)))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $g (i32.load (i32.const 0)))
   )
 
   (func (export "as-load-address") (result i32)
@@ -187,9 +187,9 @@
 (assert_return (invoke "as-call_indirect-last") (i32.const -1))
 (assert_return (invoke "as-call_indirect-index") (i32.const -1))
 
-(assert_return (invoke "as-set_local-value"))
-(assert_return (invoke "as-tee_local-value") (i32.const 0))
-(assert_return (invoke "as-set_global-value"))
+(assert_return (invoke "as-local.set-value"))
+(assert_return (invoke "as-local.tee-value") (i32.const 0))
+(assert_return (invoke "as-global.set-value"))
 
 (assert_return (invoke "as-load-address") (i32.const 0))
 (assert_return (invoke "as-loadN-address") (i32.const 0))
@@ -213,42 +213,42 @@
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result i32) (i32.load32 (get_local 0)))"
+    "(func (param i32) (result i32) (i32.load32 (local.get 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result i32) (i32.load32_u (get_local 0)))"
+    "(func (param i32) (result i32) (i32.load32_u (local.get 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result i32) (i32.load32_s (get_local 0)))"
+    "(func (param i32) (result i32) (i32.load32_s (local.get 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result i32) (i32.load64 (get_local 0)))"
+    "(func (param i32) (result i32) (i32.load64 (local.get 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result i32) (i32.load64_u (get_local 0)))"
+    "(func (param i32) (result i32) (i32.load64_u (local.get 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result i32) (i32.load64_s (get_local 0)))"
+    "(func (param i32) (result i32) (i32.load64_s (local.get 0)))"
   )
   "unknown operator"
 )
@@ -256,21 +256,21 @@
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result i64) (i64.load64 (get_local 0)))"
+    "(func (param i32) (result i64) (i64.load64 (local.get 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result i64) (i64.load64_u (get_local 0)))"
+    "(func (param i32) (result i64) (i64.load64_u (local.get 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result i64) (i64.load64_s (get_local 0)))"
+    "(func (param i32) (result i64) (i64.load64_s (local.get 0)))"
   )
   "unknown operator"
 )
@@ -278,14 +278,14 @@
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result f32) (f32.load32 (get_local 0)))"
+    "(func (param i32) (result f32) (f32.load32 (local.get 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result f32) (f32.load64 (get_local 0)))"
+    "(func (param i32) (result f32) (f32.load64 (local.get 0)))"
   )
   "unknown operator"
 )
@@ -293,14 +293,14 @@
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result f64) (f64.load32 (get_local 0)))"
+    "(func (param i32) (result f64) (f64.load32 (local.get 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (result f64) (f64.load64 (get_local 0)))"
+    "(func (param i32) (result f64) (f64.load64 (local.get 0)))"
   )
   "unknown operator"
 )
diff --git a/test/core/local_get.wast b/test/core/local_get.wast
new file mode 100644
index 000000000..d38962f08
--- /dev/null
+++ b/test/core/local_get.wast
@@ -0,0 +1,165 @@
+;; Test `local.get` operator
+
+(module
+  ;; Typing
+
+  (func (export "type-local-i32") (result i32) (local i32) (local.get 0))
+  (func (export "type-local-i64") (result i64) (local i64) (local.get 0))
+  (func (export "type-local-f32") (result f32) (local f32) (local.get 0))
+  (func (export "type-local-f64") (result f64) (local f64) (local.get 0))
+
+  (func (export "type-param-i32") (param i32) (result i32) (local.get 0))
+  (func (export "type-param-i64") (param i64) (result i64) (local.get 0))
+  (func (export "type-param-f32") (param f32) (result f32) (local.get 0))
+  (func (export "type-param-f64") (param f64) (result f64) (local.get 0))
+
+  (func (export "type-mixed") (param i64 f32 f64 i32 i32)
+    (local f32 i64 i64 f64)
+    (drop (i64.eqz (local.get 0)))
+    (drop (f32.neg (local.get 1)))
+    (drop (f64.neg (local.get 2)))
+    (drop (i32.eqz (local.get 3)))
+    (drop (i32.eqz (local.get 4)))
+    (drop (f32.neg (local.get 5)))
+    (drop (i64.eqz (local.get 6)))
+    (drop (i64.eqz (local.get 7)))
+    (drop (f64.neg (local.get 8)))
+  )
+
+  ;; Reading
+
+  (func (export "read") (param i64 f32 f64 i32 i32) (result f64)
+    (local f32 i64 i64 f64)
+    (local.set 5 (f32.const 5.5))
+    (local.set 6 (i64.const 6))
+    (local.set 8 (f64.const 8))
+    (f64.add
+      (f64.convert_i64_u (local.get 0))
+      (f64.add
+        (f64.promote_f32 (local.get 1))
+        (f64.add
+          (local.get 2)
+          (f64.add
+            (f64.convert_i32_u (local.get 3))
+            (f64.add
+              (f64.convert_i32_s (local.get 4))
+              (f64.add
+                (f64.promote_f32 (local.get 5))
+                (f64.add
+                  (f64.convert_i64_u (local.get 6))
+                  (f64.add
+                    (f64.convert_i64_u (local.get 7))
+                    (local.get 8)
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+)
+
+(assert_return (invoke "type-local-i32") (i32.const 0))
+(assert_return (invoke "type-local-i64") (i64.const 0))
+(assert_return (invoke "type-local-f32") (f32.const 0))
+(assert_return (invoke "type-local-f64") (f64.const 0))
+
+(assert_return (invoke "type-param-i32" (i32.const 2)) (i32.const 2))
+(assert_return (invoke "type-param-i64" (i64.const 3)) (i64.const 3))
+(assert_return (invoke "type-param-f32" (f32.const 4.4)) (f32.const 4.4))
+(assert_return (invoke "type-param-f64" (f64.const 5.5)) (f64.const 5.5))
+
+(assert_return
+  (invoke "type-mixed"
+    (i64.const 1) (f32.const 2.2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+)
+
+(assert_return
+  (invoke "read"
+    (i64.const 1) (f32.const 2) (f64.const 3.3) (i32.const 4) (i32.const 5)
+  )
+  (f64.const 34.8)
+)
+
+
+;; Invalid typing of access to locals
+
+(assert_invalid
+  (module (func $type-local-num-vs-num (result i64) (local i32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+
+;; Invalid typing of access to parameters
+
+(assert_invalid
+  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (func $i32-vs-empty (local i32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $i64-vs-empty (local i64) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $f32-vs-empty (local f32) (local.get 0)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func $f64-vs-empty (local f64) (local.get 0)))
+  "type mismatch"
+)
+
+
+;; Invalid local index
+
+(assert_invalid
+  (module (func $unbound-local (local i32 i64) (local.get 3)))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-local (local i32 i64) (local.get 14324343)))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-param (param i32 i64) (local.get 2)))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-param (local i32 i64) (local.get 714324343)))
+  "unknown local"
+)
+
+(assert_invalid
+  (module (func $unbound-mixed (param i32) (local i32 i64) (local.get 3)))
+  "unknown local"
+)
+(assert_invalid
+  (module (func $large-mixed (param i64) (local i32 i64) (local.get 214324343)))
+  "unknown local"
+)
+
diff --git a/test/core/set_local.wast b/test/core/local_set.wast
similarity index 51%
rename from test/core/set_local.wast
rename to test/core/local_set.wast
index 97c560a3d..d041e6f48 100644
--- a/test/core/set_local.wast
+++ b/test/core/local_set.wast
@@ -1,58 +1,58 @@
-;; Test `set_local` operator
+;; Test `local.set` operator
 
 (module
   ;; Typing
 
-  (func (export "type-local-i32") (local i32) (set_local 0 (i32.const 0)))
-  (func (export "type-local-i64") (local i64) (set_local 0 (i64.const 0)))
-  (func (export "type-local-f32") (local f32) (set_local 0 (f32.const 0)))
-  (func (export "type-local-f64") (local f64) (set_local 0 (f64.const 0)))
+  (func (export "type-local-i32") (local i32) (local.set 0 (i32.const 0)))
+  (func (export "type-local-i64") (local i64) (local.set 0 (i64.const 0)))
+  (func (export "type-local-f32") (local f32) (local.set 0 (f32.const 0)))
+  (func (export "type-local-f64") (local f64) (local.set 0 (f64.const 0)))
 
-  (func (export "type-param-i32") (param i32) (set_local 0 (i32.const 10)))
-  (func (export "type-param-i64") (param i64) (set_local 0 (i64.const 11)))
-  (func (export "type-param-f32") (param f32) (set_local 0 (f32.const 11.1)))
-  (func (export "type-param-f64") (param f64) (set_local 0 (f64.const 12.2)))
+  (func (export "type-param-i32") (param i32) (local.set 0 (i32.const 10)))
+  (func (export "type-param-i64") (param i64) (local.set 0 (i64.const 11)))
+  (func (export "type-param-f32") (param f32) (local.set 0 (f32.const 11.1)))
+  (func (export "type-param-f64") (param f64) (local.set 0 (f64.const 12.2)))
 
   (func (export "type-mixed") (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64)
-    (set_local 0 (i64.const 0))
-    (set_local 1 (f32.const 0))
-    (set_local 2 (f64.const 0))
-    (set_local 3 (i32.const 0))
-    (set_local 4 (i32.const 0))
-    (set_local 5 (f32.const 0))
-    (set_local 6 (i64.const 0))
-    (set_local 7 (i64.const 0))
-    (set_local 8 (f64.const 0))
+    (local.set 0 (i64.const 0))
+    (local.set 1 (f32.const 0))
+    (local.set 2 (f64.const 0))
+    (local.set 3 (i32.const 0))
+    (local.set 4 (i32.const 0))
+    (local.set 5 (f32.const 0))
+    (local.set 6 (i64.const 0))
+    (local.set 7 (i64.const 0))
+    (local.set 8 (f64.const 0))
   )
 
   ;; Writing
 
   (func (export "write") (param i64 f32 f64 i32 i32) (result i64)
     (local f32 i64 i64 f64)
-    (set_local 1 (f32.const -0.3))
-    (set_local 3 (i32.const 40))
-    (set_local 4 (i32.const -7))
-    (set_local 5 (f32.const 5.5))
-    (set_local 6 (i64.const 6))
-    (set_local 8 (f64.const 8))
-    (i64.trunc_s/f64
+    (local.set 1 (f32.const -0.3))
+    (local.set 3 (i32.const 40))
+    (local.set 4 (i32.const -7))
+    (local.set 5 (f32.const 5.5))
+    (local.set 6 (i64.const 6))
+    (local.set 8 (f64.const 8))
+    (i64.trunc_f64_s
       (f64.add
-        (f64.convert_u/i64 (get_local 0))
+        (f64.convert_i64_u (local.get 0))
         (f64.add
-          (f64.promote/f32 (get_local 1))
+          (f64.promote_f32 (local.get 1))
           (f64.add
-            (get_local 2)
+            (local.get 2)
             (f64.add
-              (f64.convert_u/i32 (get_local 3))
+              (f64.convert_i32_u (local.get 3))
               (f64.add
-                (f64.convert_s/i32 (get_local 4))
+                (f64.convert_i32_s (local.get 4))
                 (f64.add
-                  (f64.promote/f32 (get_local 5))
+                  (f64.promote_f32 (local.get 5))
                   (f64.add
-                    (f64.convert_u/i64 (get_local 6))
+                    (f64.convert_i64_u (local.get 6))
                     (f64.add
-                      (f64.convert_u/i64 (get_local 7))
-                      (get_local 8)
+                      (f64.convert_i64_u (local.get 7))
+                      (local.get 8)
                     )
                   )
                 )
@@ -67,40 +67,40 @@
   ;; As parameter of control constructs and instructions
 
   (func (export "as-block-value") (param i32)
-    (block (set_local 0 (i32.const 1)))
+    (block (local.set 0 (i32.const 1)))
   )
   (func (export "as-loop-value") (param i32)
-    (loop (set_local 0 (i32.const 3)))
+    (loop (local.set 0 (i32.const 3)))
   )
 
   (func (export "as-br-value") (param i32)
-    (block (br 0 (set_local 0 (i32.const 9))))
+    (block (br 0 (local.set 0 (i32.const 9))))
   )
   (func (export "as-br_if-value") (param i32)
     (block
-      (br_if 0 (set_local 0 (i32.const 8)) (i32.const 1))
+      (br_if 0 (local.set 0 (i32.const 8)) (i32.const 1))
     )
   )
   (func (export "as-br_if-value-cond") (param i32)
     (block
-      (br_if 0 (i32.const 6) (set_local 0 (i32.const 9)))
+      (br_if 0 (i32.const 6) (local.set 0 (i32.const 9)))
     )
   )
   (func (export "as-br_table-value") (param i32)
     (block
-      (br_table 0 (set_local 0 (i32.const 10)) (i32.const 1))
+      (br_table 0 (local.set 0 (i32.const 10)) (i32.const 1))
     )
   )
 
   (func (export "as-return-value") (param i32)
-    (return (set_local 0 (i32.const 7)))
+    (return (local.set 0 (i32.const 7)))
   )
 
   (func (export "as-if-then") (param i32)
-    (if (get_local 0) (then (set_local 0 (i32.const 3))))
+    (if (local.get 0) (then (local.set 0 (i32.const 3))))
   )
   (func (export "as-if-else") (param i32)
-    (if (get_local 0) (then) (else (set_local 0 (i32.const 1))))
+    (if (local.get 0) (then) (else (local.set 0 (i32.const 1))))
   )
 )
 
@@ -145,37 +145,37 @@
 
 (assert_invalid
   (module (func $type-local-num-vs-num (result i64) (local i32)
-    (set_local 0 (i32.const 0))
+    (local.set 0 (i32.const 0))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-local-num-vs-num (local f32)
-    (i32.eqz (set_local 0 (f32.const 0)))
+    (i32.eqz (local.set 0 (f32.const 0)))
   ))
   "type mismatch"
 )
 (assert_invalid
   (module (func $type-local-num-vs-num (local f64 i64)
-    (f64.neg (set_local 1 (i64.const 0)))
+    (f64.neg (local.set 1 (i64.const 0)))
   ))
   "type mismatch"
 )
 
 (assert_invalid
-  (module (func $type-local-arg-void-vs-num (local i32) (set_local 0 (nop))))
+  (module (func $type-local-arg-void-vs-num (local i32) (local.set 0 (nop))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-local-arg-num-vs-num (local i32) (set_local 0 (f32.const 0))))
+  (module (func $type-local-arg-num-vs-num (local i32) (local.set 0 (f32.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-local-arg-num-vs-num (local f32) (set_local 0 (f64.const 0))))
+  (module (func $type-local-arg-num-vs-num (local f32) (local.set 0 (f64.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-local-arg-num-vs-num (local f64 i64) (set_local 1 (f64.const 0))))
+  (module (func $type-local-arg-num-vs-num (local f64 i64) (local.set 1 (f64.const 0))))
   "type mismatch"
 )
 
@@ -183,49 +183,49 @@
 ;; Invalid typing of access to parameters
 
 (assert_invalid
-  (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0)))
+  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0))))
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1))))
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))
   "type mismatch"
 )
 
 (assert_invalid
-  (module (func $type-param-arg-void-vs-num (param i32) (set_local 0 (nop))))
+  (module (func $type-param-arg-void-vs-num (param i32) (local.set 0 (nop))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-arg-num-vs-num (param i32) (set_local 0 (f32.const 0))))
+  (module (func $type-param-arg-num-vs-num (param i32) (local.set 0 (f32.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-arg-num-vs-num (param f32) (set_local 0 (f64.const 0))))
+  (module (func $type-param-arg-num-vs-num (param f32) (local.set 0 (f64.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-arg-num-vs-num (param f64 i64) (set_local 1 (f64.const 0))))
+  (module (func $type-param-arg-num-vs-num (param f64 i64) (local.set 1 (f64.const 0))))
   "type mismatch"
 )
 
 (assert_invalid
-  (module (func $i32-vs-empty (param i32) (result i32) (set_local 0 (i32.const 1))))
+  (module (func $i32-vs-empty (param i32) (result i32) (local.set 0 (i32.const 1))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $i64-vs-empty (param i64) (result i64) (set_local 0 (i64.const 1))))
+  (module (func $i64-vs-empty (param i64) (result i64) (local.set 0 (i64.const 1))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $f32-vs-empty (param f32) (result f32) (set_local 0 (f32.const 1))))
+  (module (func $f32-vs-empty (param f32) (result f32) (local.set 0 (f32.const 1))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $f64-vs-empty (param f64) (result f64) (set_local 0 (f64.const 1))))
+  (module (func $f64-vs-empty (param f64) (result f64) (local.set 0 (f64.const 1))))
   "type mismatch"
 )
 
@@ -233,42 +233,42 @@
 ;; Invalid local index
 
 (assert_invalid
-  (module (func $unbound-local (local i32 i64) (get_local 3)))
+  (module (func $unbound-local (local i32 i64) (local.get 3)))
   "unknown local"
 )
 (assert_invalid
-  (module (func $large-local (local i32 i64) (get_local 14324343)))
+  (module (func $large-local (local i32 i64) (local.get 14324343)))
   "unknown local"
 )
 
 (assert_invalid
-  (module (func $unbound-param (param i32 i64) (get_local 2)))
+  (module (func $unbound-param (param i32 i64) (local.get 2)))
   "unknown local"
 )
 (assert_invalid
-  (module (func $large-param (local i32 i64) (get_local 714324343)))
+  (module (func $large-param (local i32 i64) (local.get 714324343)))
   "unknown local"
 )
 
 (assert_invalid
-  (module (func $unbound-mixed (param i32) (local i32 i64) (get_local 3)))
+  (module (func $unbound-mixed (param i32) (local i32 i64) (local.get 3)))
   "unknown local"
 )
 (assert_invalid
-  (module (func $large-mixed (param i64) (local i32 i64) (get_local 214324343)))
+  (module (func $large-mixed (param i64) (local i32 i64) (local.get 214324343)))
   "unknown local"
 )
 
 (assert_invalid
-  (module (func $type-mixed-arg-num-vs-num (param f32) (local i32) (set_local 1 (f32.const 0))))
+  (module (func $type-mixed-arg-num-vs-num (param f32) (local i32) (local.set 1 (f32.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-mixed-arg-num-vs-num (param i64 i32) (local f32) (set_local 1 (f32.const 0))))
+  (module (func $type-mixed-arg-num-vs-num (param i64 i32) (local f32) (local.set 1 (f32.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-mixed-arg-num-vs-num (param i64) (local f64 i64) (set_local 1 (i64.const 0))))
+  (module (func $type-mixed-arg-num-vs-num (param i64) (local f64 i64) (local.set 1 (i64.const 0))))
   "type mismatch"
 )
 
diff --git a/test/core/tee_local.wast b/test/core/local_tee.wast
similarity index 58%
rename from test/core/tee_local.wast
rename to test/core/local_tee.wast
index 028d704ee..90b20ff2a 100644
--- a/test/core/tee_local.wast
+++ b/test/core/local_tee.wast
@@ -1,57 +1,57 @@
-;; Test `tee_local` operator
+;; Test `local.tee` operator
 
 (module
   ;; Typing
 
-  (func (export "type-local-i32") (result i32) (local i32) (tee_local 0 (i32.const 0)))
-  (func (export "type-local-i64") (result i64) (local i64) (tee_local 0 (i64.const 0)))
-  (func (export "type-local-f32") (result f32) (local f32) (tee_local 0 (f32.const 0)))
-  (func (export "type-local-f64") (result f64) (local f64) (tee_local 0 (f64.const 0)))
+  (func (export "type-local-i32") (result i32) (local i32) (local.tee 0 (i32.const 0)))
+  (func (export "type-local-i64") (result i64) (local i64) (local.tee 0 (i64.const 0)))
+  (func (export "type-local-f32") (result f32) (local f32) (local.tee 0 (f32.const 0)))
+  (func (export "type-local-f64") (result f64) (local f64) (local.tee 0 (f64.const 0)))
 
-  (func (export "type-param-i32") (param i32) (result i32) (tee_local 0 (i32.const 10)))
-  (func (export "type-param-i64") (param i64) (result i64) (tee_local 0 (i64.const 11)))
-  (func (export "type-param-f32") (param f32) (result f32) (tee_local 0 (f32.const 11.1)))
-  (func (export "type-param-f64") (param f64) (result f64) (tee_local 0 (f64.const 12.2)))
+  (func (export "type-param-i32") (param i32) (result i32) (local.tee 0 (i32.const 10)))
+  (func (export "type-param-i64") (param i64) (result i64) (local.tee 0 (i64.const 11)))
+  (func (export "type-param-f32") (param f32) (result f32) (local.tee 0 (f32.const 11.1)))
+  (func (export "type-param-f64") (param f64) (result f64) (local.tee 0 (f64.const 12.2)))
 
   (func (export "type-mixed") (param i64 f32 f64 i32 i32) (local f32 i64 i64 f64)
-    (drop (i64.eqz (tee_local 0 (i64.const 0))))
-    (drop (f32.neg (tee_local 1 (f32.const 0))))
-    (drop (f64.neg (tee_local 2 (f64.const 0))))
-    (drop (i32.eqz (tee_local 3 (i32.const 0))))
-    (drop (i32.eqz (tee_local 4 (i32.const 0))))
-    (drop (f32.neg (tee_local 5 (f32.const 0))))
-    (drop (i64.eqz (tee_local 6 (i64.const 0))))
-    (drop (i64.eqz (tee_local 7 (i64.const 0))))
-    (drop (f64.neg (tee_local 8 (f64.const 0))))
+    (drop (i64.eqz (local.tee 0 (i64.const 0))))
+    (drop (f32.neg (local.tee 1 (f32.const 0))))
+    (drop (f64.neg (local.tee 2 (f64.const 0))))
+    (drop (i32.eqz (local.tee 3 (i32.const 0))))
+    (drop (i32.eqz (local.tee 4 (i32.const 0))))
+    (drop (f32.neg (local.tee 5 (f32.const 0))))
+    (drop (i64.eqz (local.tee 6 (i64.const 0))))
+    (drop (i64.eqz (local.tee 7 (i64.const 0))))
+    (drop (f64.neg (local.tee 8 (f64.const 0))))
   )
 
   ;; Writing
 
   (func (export "write") (param i64 f32 f64 i32 i32) (result i64) (local f32 i64 i64 f64)
-    (drop (tee_local 1 (f32.const -0.3)))
-    (drop (tee_local 3 (i32.const 40)))
-    (drop (tee_local 4 (i32.const -7)))
-    (drop (tee_local 5 (f32.const 5.5)))
-    (drop (tee_local 6 (i64.const 6)))
-    (drop (tee_local 8 (f64.const 8)))
-    (i64.trunc_s/f64
+    (drop (local.tee 1 (f32.const -0.3)))
+    (drop (local.tee 3 (i32.const 40)))
+    (drop (local.tee 4 (i32.const -7)))
+    (drop (local.tee 5 (f32.const 5.5)))
+    (drop (local.tee 6 (i64.const 6)))
+    (drop (local.tee 8 (f64.const 8)))
+    (i64.trunc_f64_s
       (f64.add
-        (f64.convert_u/i64 (get_local 0))
+        (f64.convert_i64_u (local.get 0))
         (f64.add
-          (f64.promote/f32 (get_local 1))
+          (f64.promote_f32 (local.get 1))
           (f64.add
-            (get_local 2)
+            (local.get 2)
             (f64.add
-              (f64.convert_u/i32 (get_local 3))
+              (f64.convert_i32_u (local.get 3))
               (f64.add
-                (f64.convert_s/i32 (get_local 4))
+                (f64.convert_i32_s (local.get 4))
                 (f64.add
-                  (f64.promote/f32 (get_local 5))
+                  (f64.promote_f32 (local.get 5))
                   (f64.add
-                    (f64.convert_u/i64 (get_local 6))
+                    (f64.convert_i64_u (local.get 6))
                     (f64.add
-                      (f64.convert_u/i64 (get_local 7))
-                      (get_local 8)
+                      (f64.convert_i64_u (local.get 7))
+                      (local.get 8)
                     )
                   )
                 )
@@ -68,22 +68,22 @@
   (func (export "result") (param i64 f32 f64 i32 i32) (result f64)
     (local f32 i64 i64 f64)
     (f64.add
-      (f64.convert_u/i64 (tee_local 0 (i64.const 1)))
+      (f64.convert_i64_u (local.tee 0 (i64.const 1)))
       (f64.add
-        (f64.promote/f32 (tee_local 1 (f32.const 2)))
+        (f64.promote_f32 (local.tee 1 (f32.const 2)))
         (f64.add
-          (tee_local 2 (f64.const 3.3))
+          (local.tee 2 (f64.const 3.3))
           (f64.add
-            (f64.convert_u/i32 (tee_local 3 (i32.const 4)))
+            (f64.convert_i32_u (local.tee 3 (i32.const 4)))
             (f64.add
-              (f64.convert_s/i32 (tee_local 4 (i32.const 5)))
+              (f64.convert_i32_s (local.tee 4 (i32.const 5)))
               (f64.add
-                (f64.promote/f32 (tee_local 5 (f32.const 5.5)))
+                (f64.promote_f32 (local.tee 5 (f32.const 5.5)))
                 (f64.add
-                  (f64.convert_u/i64 (tee_local 6 (i64.const 6)))
+                  (f64.convert_i64_u (local.tee 6 (i64.const 6)))
                   (f64.add
-                    (f64.convert_u/i64 (tee_local 7 (i64.const 0)))
-                    (tee_local 8 (f64.const 8))
+                    (f64.convert_i64_u (local.tee 7 (i64.const 0)))
+                    (local.tee 8 (f64.const 8))
                   )
                 )
               )
@@ -97,182 +97,182 @@
   (func $dummy)
 
   (func (export "as-block-first") (param i32) (result i32)
-    (block (result i32) (tee_local 0 (i32.const 1)) (call $dummy))
+    (block (result i32) (local.tee 0 (i32.const 1)) (call $dummy))
   )
   (func (export "as-block-mid") (param i32) (result i32)
-    (block (result i32) (call $dummy) (tee_local 0 (i32.const 1)) (call $dummy))
+    (block (result i32) (call $dummy) (local.tee 0 (i32.const 1)) (call $dummy))
   )
   (func (export "as-block-last") (param i32) (result i32)
-    (block (result i32) (call $dummy) (call $dummy) (tee_local 0 (i32.const 1)))
+    (block (result i32) (call $dummy) (call $dummy) (local.tee 0 (i32.const 1)))
   )
 
   (func (export "as-loop-first") (param i32) (result i32)
-    (loop (result i32) (tee_local 0 (i32.const 3)) (call $dummy))
+    (loop (result i32) (local.tee 0 (i32.const 3)) (call $dummy))
   )
   (func (export "as-loop-mid") (param i32) (result i32)
-    (loop (result i32) (call $dummy) (tee_local 0 (i32.const 4)) (call $dummy))
+    (loop (result i32) (call $dummy) (local.tee 0 (i32.const 4)) (call $dummy))
   )
   (func (export "as-loop-last") (param i32) (result i32)
-    (loop (result i32) (call $dummy) (call $dummy) (tee_local 0 (i32.const 5)))
+    (loop (result i32) (call $dummy) (call $dummy) (local.tee 0 (i32.const 5)))
   )
 
   (func (export "as-br-value") (param i32) (result i32)
-    (block (result i32) (br 0 (tee_local 0 (i32.const 9))))
+    (block (result i32) (br 0 (local.tee 0 (i32.const 9))))
   )
 
   (func (export "as-br_if-cond") (param i32)
-    (block (br_if 0 (tee_local 0 (i32.const 1))))
+    (block (br_if 0 (local.tee 0 (i32.const 1))))
   )
   (func (export "as-br_if-value") (param i32) (result i32)
     (block (result i32)
-      (drop (br_if 0 (tee_local 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
+      (drop (br_if 0 (local.tee 0 (i32.const 8)) (i32.const 1))) (i32.const 7)
     )
   )
   (func (export "as-br_if-value-cond") (param i32) (result i32)
     (block (result i32)
-      (drop (br_if 0 (i32.const 6) (tee_local 0 (i32.const 9)))) (i32.const 7)
+      (drop (br_if 0 (i32.const 6) (local.tee 0 (i32.const 9)))) (i32.const 7)
     )
   )
 
   (func (export "as-br_table-index") (param i32)
-    (block (br_table 0 0 0 (tee_local 0 (i32.const 0))))
+    (block (br_table 0 0 0 (local.tee 0 (i32.const 0))))
   )
   (func (export "as-br_table-value") (param i32) (result i32)
     (block (result i32)
-      (br_table 0 0 0 (tee_local 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
+      (br_table 0 0 0 (local.tee 0 (i32.const 10)) (i32.const 1)) (i32.const 7)
     )
   )
   (func (export "as-br_table-value-index") (param i32) (result i32)
     (block (result i32)
-      (br_table 0 0 (i32.const 6) (tee_local 0 (i32.const 11))) (i32.const 7)
+      (br_table 0 0 (i32.const 6) (local.tee 0 (i32.const 11))) (i32.const 7)
     )
   )
 
   (func (export "as-return-value") (param i32) (result i32)
-    (return (tee_local 0 (i32.const 7)))
+    (return (local.tee 0 (i32.const 7)))
   )
 
   (func (export "as-if-cond") (param i32) (result i32)
-    (if (result i32) (tee_local 0 (i32.const 2))
+    (if (result i32) (local.tee 0 (i32.const 2))
       (then (i32.const 0)) (else (i32.const 1))
     )
   )
   (func (export "as-if-then") (param i32) (result i32)
-    (if (result i32) (get_local 0)
-      (then (tee_local 0 (i32.const 3))) (else (get_local 0))
+    (if (result i32) (local.get 0)
+      (then (local.tee 0 (i32.const 3))) (else (local.get 0))
     )
   )
   (func (export "as-if-else") (param i32) (result i32)
-    (if (result i32) (get_local 0)
-      (then (get_local 0)) (else (tee_local 0 (i32.const 4)))
+    (if (result i32) (local.get 0)
+      (then (local.get 0)) (else (local.tee 0 (i32.const 4)))
     )
   )
 
   (func (export "as-select-first") (param i32 i32) (result i32)
-    (select (tee_local 0 (i32.const 5)) (get_local 0) (get_local 1))
+    (select (local.tee 0 (i32.const 5)) (local.get 0) (local.get 1))
   )
   (func (export "as-select-second") (param i32 i32) (result i32)
-    (select (get_local 0) (tee_local 0 (i32.const 6)) (get_local 1))
+    (select (local.get 0) (local.tee 0 (i32.const 6)) (local.get 1))
   )
   (func (export "as-select-cond") (param i32) (result i32)
-    (select (i32.const 0) (i32.const 1) (tee_local 0 (i32.const 7)))
+    (select (i32.const 0) (i32.const 1) (local.tee 0 (i32.const 7)))
   )
 
   (func $f (param i32 i32 i32) (result i32) (i32.const -1))
   (func (export "as-call-first") (param i32) (result i32)
-    (call $f (tee_local 0 (i32.const 12)) (i32.const 2) (i32.const 3))
+    (call $f (local.tee 0 (i32.const 12)) (i32.const 2) (i32.const 3))
   )
   (func (export "as-call-mid") (param i32) (result i32)
-    (call $f (i32.const 1) (tee_local 0 (i32.const 13)) (i32.const 3))
+    (call $f (i32.const 1) (local.tee 0 (i32.const 13)) (i32.const 3))
   )
   (func (export "as-call-last") (param i32) (result i32)
-    (call $f (i32.const 1) (i32.const 2) (tee_local 0 (i32.const 14)))
+    (call $f (i32.const 1) (i32.const 2) (local.tee 0 (i32.const 14)))
   )
 
   (type $sig (func (param i32 i32 i32) (result i32)))
-  (table anyfunc (elem $f))
+  (table funcref (elem $f))
   (func (export "as-call_indirect-first") (param i32) (result i32)
     (call_indirect (type $sig)
-      (tee_local 0 (i32.const 1)) (i32.const 2) (i32.const 3) (i32.const 0)
+      (local.tee 0 (i32.const 1)) (i32.const 2) (i32.const 3) (i32.const 0)
     )
   )
   (func (export "as-call_indirect-mid") (param i32) (result i32)
     (call_indirect (type $sig)
-      (i32.const 1) (tee_local 0 (i32.const 2)) (i32.const 3) (i32.const 0)
+      (i32.const 1) (local.tee 0 (i32.const 2)) (i32.const 3) (i32.const 0)
     )
   )
   (func (export "as-call_indirect-last") (param i32) (result i32)
     (call_indirect (type $sig)
-      (i32.const 1) (i32.const 2) (tee_local 0 (i32.const 3)) (i32.const 0)
+      (i32.const 1) (i32.const 2) (local.tee 0 (i32.const 3)) (i32.const 0)
     )
   )
   (func (export "as-call_indirect-index") (param i32) (result i32)
     (call_indirect (type $sig)
-      (i32.const 1) (i32.const 2) (i32.const 3) (tee_local 0 (i32.const 0))
+      (i32.const 1) (i32.const 2) (i32.const 3) (local.tee 0 (i32.const 0))
     )
   )
 
-  (func (export "as-set_local-value") (local i32)
-    (set_local 0 (tee_local 0 (i32.const 1)))
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (local.tee 0 (i32.const 1)))
   )
-  (func (export "as-tee_local-value") (param i32) (result i32)
-    (tee_local 0 (tee_local 0 (i32.const 1)))
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (local.tee 0 (i32.const 1)))
   )
   (global $g (mut i32) (i32.const 0))
   (func (export "as-set_global-value") (local i32)
-    (set_global $g (tee_local 0 (i32.const 1)))
+    (global.set $g (local.tee 0 (i32.const 1)))
   )
 
   (memory 1)
   (func (export "as-load-address") (param i32) (result i32)
-    (i32.load (tee_local 0 (i32.const 1)))
+    (i32.load (local.tee 0 (i32.const 1)))
   )
   (func (export "as-loadN-address") (param i32) (result i32)
-    (i32.load8_s (tee_local 0 (i32.const 3)))
+    (i32.load8_s (local.tee 0 (i32.const 3)))
   )
 
   (func (export "as-store-address") (param i32)
-    (i32.store (tee_local 0 (i32.const 30)) (i32.const 7))
+    (i32.store (local.tee 0 (i32.const 30)) (i32.const 7))
   )
   (func (export "as-store-value") (param i32)
-    (i32.store (i32.const 2) (tee_local 0 (i32.const 1)))
+    (i32.store (i32.const 2) (local.tee 0 (i32.const 1)))
   )
 
   (func (export "as-storeN-address") (param i32)
-    (i32.store8 (tee_local 0 (i32.const 1)) (i32.const 7))
+    (i32.store8 (local.tee 0 (i32.const 1)) (i32.const 7))
   )
   (func (export "as-storeN-value") (param i32)
-    (i32.store16 (i32.const 2) (tee_local 0 (i32.const 1)))
+    (i32.store16 (i32.const 2) (local.tee 0 (i32.const 1)))
   )
 
   (func (export "as-unary-operand") (param f32) (result f32)
-    (f32.neg (tee_local 0 (f32.const nan:0x0f1e2)))
+    (f32.neg (local.tee 0 (f32.const nan:0x0f1e2)))
   )
 
   (func (export "as-binary-left") (param i32) (result i32)
-    (i32.add (tee_local 0 (i32.const 3)) (i32.const 10))
+    (i32.add (local.tee 0 (i32.const 3)) (i32.const 10))
   )
   (func (export "as-binary-right") (param i32) (result i32)
-    (i32.sub (i32.const 10) (tee_local 0 (i32.const 4)))
+    (i32.sub (i32.const 10) (local.tee 0 (i32.const 4)))
   )
 
   (func (export "as-test-operand") (param i32) (result i32)
-    (i32.eqz (tee_local 0 (i32.const 0)))
+    (i32.eqz (local.tee 0 (i32.const 0)))
   )
 
   (func (export "as-compare-left") (param i32) (result i32)
-    (i32.le_s (tee_local 0 (i32.const 43)) (i32.const 10))
+    (i32.le_s (local.tee 0 (i32.const 43)) (i32.const 10))
   )
   (func (export "as-compare-right") (param i32) (result i32)
-    (i32.ne (i32.const 10) (tee_local 0 (i32.const 42)))
+    (i32.ne (i32.const 10) (local.tee 0 (i32.const 42)))
   )
 
   (func (export "as-convert-operand") (param i64) (result i32)
-    (i32.wrap/i64 (tee_local 0 (i64.const 41)))
+    (i32.wrap_i64 (local.tee 0 (i64.const 41)))
   )
 
   (func (export "as-memory.grow-size") (param i32) (result i32)
-    (memory.grow (tee_local 0 (i32.const 40)))
+    (memory.grow (local.tee 0 (i32.const 40)))
   )
 
 )
@@ -324,8 +324,8 @@
 (assert_return (invoke "as-call_indirect-last" (i32.const 0)) (i32.const -1))
 (assert_return (invoke "as-call_indirect-index" (i32.const 0)) (i32.const -1))
 
-(assert_return (invoke "as-set_local-value"))
-(assert_return (invoke "as-tee_local-value" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "as-local.set-value"))
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "as-set_global-value"))
 
 (assert_return (invoke "as-load-address" (i32.const 0)) (i32.const 0))
@@ -368,32 +368,32 @@
 ;; Invalid typing of access to locals
 
 (assert_invalid
-  (module (func $type-local-num-vs-num (result i64) (local i32) (tee_local 0 (i32.const 0))))
+  (module (func $type-local-num-vs-num (result i64) (local i32) (local.tee 0 (i32.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-local-num-vs-num (local f32) (i32.eqz (tee_local 0 (f32.const 0)))))
+  (module (func $type-local-num-vs-num (local f32) (i32.eqz (local.tee 0 (f32.const 0)))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (tee_local 1 (i64.const 0)))))
+  (module (func $type-local-num-vs-num (local f64 i64) (f64.neg (local.tee 1 (i64.const 0)))))
   "type mismatch"
 )
 
 (assert_invalid
-  (module (func $type-local-arg-void-vs-num (local i32) (tee_local 0 (nop))))
+  (module (func $type-local-arg-void-vs-num (local i32) (local.tee 0 (nop))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-local-arg-num-vs-num (local i32) (tee_local 0 (f32.const 0))))
+  (module (func $type-local-arg-num-vs-num (local i32) (local.tee 0 (f32.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-local-arg-num-vs-num (local f32) (tee_local 0 (f64.const 0))))
+  (module (func $type-local-arg-num-vs-num (local f32) (local.tee 0 (f64.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-local-arg-num-vs-num (local f64 i64) (tee_local 1 (f64.const 0))))
+  (module (func $type-local-arg-num-vs-num (local f64 i64) (local.tee 1 (f64.const 0))))
   "type mismatch"
 )
 
@@ -401,32 +401,32 @@
 ;; Invalid typing of access to parameters
 
 (assert_invalid
-  (module (func $type-param-num-vs-num (param i32) (result i64) (get_local 0)))
+  (module (func $type-param-num-vs-num (param i32) (result i64) (local.get 0)))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-num-vs-num (param f32) (i32.eqz (get_local 0))))
+  (module (func $type-param-num-vs-num (param f32) (i32.eqz (local.get 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (get_local 1))))
+  (module (func $type-param-num-vs-num (param f64 i64) (f64.neg (local.get 1))))
   "type mismatch"
 )
 
 (assert_invalid
-  (module (func $type-param-arg-void-vs-num (param i32) (tee_local 0 (nop))))
+  (module (func $type-param-arg-void-vs-num (param i32) (local.tee 0 (nop))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-arg-num-vs-num (param i32) (tee_local 0 (f32.const 0))))
+  (module (func $type-param-arg-num-vs-num (param i32) (local.tee 0 (f32.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-arg-num-vs-num (param f32) (tee_local 0 (f64.const 0))))
+  (module (func $type-param-arg-num-vs-num (param f32) (local.tee 0 (f64.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-param-arg-num-vs-num (param f64 i64) (tee_local 1 (f64.const 0))))
+  (module (func $type-param-arg-num-vs-num (param f64 i64) (local.tee 1 (f64.const 0))))
   "type mismatch"
 )
 
@@ -434,42 +434,42 @@
 ;; Invalid local index
 
 (assert_invalid
-  (module (func $unbound-local (local i32 i64) (get_local 3)))
+  (module (func $unbound-local (local i32 i64) (local.get 3)))
   "unknown local"
 )
 (assert_invalid
-  (module (func $large-local (local i32 i64) (get_local 14324343)))
+  (module (func $large-local (local i32 i64) (local.get 14324343)))
   "unknown local"
 )
 
 (assert_invalid
-  (module (func $unbound-param (param i32 i64) (get_local 2)))
+  (module (func $unbound-param (param i32 i64) (local.get 2)))
   "unknown local"
 )
 (assert_invalid
-  (module (func $large-param (local i32 i64) (get_local 714324343)))
+  (module (func $large-param (local i32 i64) (local.get 714324343)))
   "unknown local"
 )
 
 (assert_invalid
-  (module (func $unbound-mixed (param i32) (local i32 i64) (get_local 3)))
+  (module (func $unbound-mixed (param i32) (local i32 i64) (local.get 3)))
   "unknown local"
 )
 (assert_invalid
-  (module (func $large-mixed (param i64) (local i32 i64) (get_local 214324343)))
+  (module (func $large-mixed (param i64) (local i32 i64) (local.get 214324343)))
   "unknown local"
 )
 
 (assert_invalid
-  (module (func $type-mixed-arg-num-vs-num (param f32) (local i32) (tee_local 1 (f32.const 0))))
+  (module (func $type-mixed-arg-num-vs-num (param f32) (local i32) (local.tee 1 (f32.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-mixed-arg-num-vs-num (param i64 i32) (local f32) (tee_local 1 (f32.const 0))))
+  (module (func $type-mixed-arg-num-vs-num (param i64 i32) (local f32) (local.tee 1 (f32.const 0))))
   "type mismatch"
 )
 (assert_invalid
-  (module (func $type-mixed-arg-num-vs-num (param i64) (local f64 i64) (tee_local 1 (i64.const 0))))
+  (module (func $type-mixed-arg-num-vs-num (param i64) (local f64 i64) (local.tee 1 (i64.const 0))))
   "type mismatch"
 )
 
diff --git a/test/core/loop.wast b/test/core/loop.wast
index 13b3f6fc9..3900581ee 100644
--- a/test/core/loop.wast
+++ b/test/core/loop.wast
@@ -105,9 +105,9 @@
     (block (result i32) (i32.const 2) (loop (result i32) (i32.const 1)) (br_table 0 0))
   )
 
-  (func $func (param i32 i32) (result i32) (get_local 0))
+  (func $func (param i32 i32) (result i32) (local.get 0))
   (type $check (func (param i32 i32) (result i32)))
-  (table anyfunc (elem $func))
+  (table funcref (elem $func))
   (func (export "as-call_indirect-first") (result i32)
     (block (result i32)
       (call_indirect (type $check)
@@ -141,7 +141,7 @@
     (memory.grow (loop (result i32) (i32.const 1)))
   )
 
-  (func $f (param i32) (result i32) (get_local 0))
+  (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "as-call-value") (result i32)
     (call $f (loop (result i32) (i32.const 1)))
@@ -155,16 +155,16 @@
   (func (export "as-br-value") (result i32)
     (block (result i32) (br 0 (loop (result i32) (i32.const 1))))
   )
-  (func (export "as-set_local-value") (result i32)
-    (local i32) (set_local 0 (loop (result i32) (i32.const 1))) (get_local 0)
+  (func (export "as-local.set-value") (result i32)
+    (local i32) (local.set 0 (loop (result i32) (i32.const 1))) (local.get 0)
   )
-  (func (export "as-tee_local-value") (result i32)
-    (local i32) (tee_local 0 (loop (result i32) (i32.const 1)))
+  (func (export "as-local.tee-value") (result i32)
+    (local i32) (local.tee 0 (loop (result i32) (i32.const 1)))
   )
   (global $a (mut i32) (i32.const 0))
-  (func (export "as-set_global-value") (result i32)
-    (set_global $a (loop (result i32) (i32.const 1)))
-    (get_global $a)
+  (func (export "as-global.set-value") (result i32)
+    (global.set $a (loop (result i32) (i32.const 1)))
+    (global.get $a)
   )
   (func (export "as-load-operand") (result i32)
     (i32.load (loop (result i32) (i32.const 1)))
@@ -217,88 +217,88 @@
   )
   (func (export "break-inner") (result i32)
     (local i32)
-    (set_local 0 (i32.const 0))
-    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1)))))))
-    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2)))))))
-    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4))))))))
-    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (i32.ctz (br 1 (i32.const 0x8)))))))
-    (set_local 0 (i32.add (get_local 0) (block (result i32) (loop (result i32) (i32.ctz (loop (result i32) (br 2 (i32.const 0x10))))))))
-    (get_local 0)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (br 2 (i32.const 0x1)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (loop (result i32) (br 2 (i32.const 0x2)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (block (result i32) (loop (result i32) (br 1 (i32.const 0x4))))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (br 1 (i32.const 0x8)))))))
+    (local.set 0 (i32.add (local.get 0) (block (result i32) (loop (result i32) (i32.ctz (loop (result i32) (br 2 (i32.const 0x10))))))))
+    (local.get 0)
   )
   (func (export "cont-inner") (result i32)
     (local i32)
-    (set_local 0 (i32.const 0))
-    (set_local 0 (i32.add (get_local 0) (loop (result i32) (loop (result i32) (br 1)))))
-    (set_local 0 (i32.add (get_local 0) (loop (result i32) (i32.ctz (br 0)))))
-    (set_local 0 (i32.add (get_local 0) (loop (result i32) (i32.ctz (loop (result i32) (br 1))))))
-    (get_local 0)
+    (local.set 0 (i32.const 0))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (loop (result i32) (br 1)))))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (br 0)))))
+    (local.set 0 (i32.add (local.get 0) (loop (result i32) (i32.ctz (loop (result i32) (br 1))))))
+    (local.get 0)
   )
 
   (func $fx (export "effects") (result i32)
     (local i32)
     (block
       (loop
-        (set_local 0 (i32.const 1))
-        (set_local 0 (i32.mul (get_local 0) (i32.const 3)))
-        (set_local 0 (i32.sub (get_local 0) (i32.const 5)))
-        (set_local 0 (i32.mul (get_local 0) (i32.const 7)))
+        (local.set 0 (i32.const 1))
+        (local.set 0 (i32.mul (local.get 0) (i32.const 3)))
+        (local.set 0 (i32.sub (local.get 0) (i32.const 5)))
+        (local.set 0 (i32.mul (local.get 0) (i32.const 7)))
         (br 1)
-        (set_local 0 (i32.mul (get_local 0) (i32.const 100)))
+        (local.set 0 (i32.mul (local.get 0) (i32.const 100)))
       )
     )
-    (i32.eq (get_local 0) (i32.const -14))
+    (i32.eq (local.get 0) (i32.const -14))
   )
 
   (func (export "while") (param i64) (result i64)
     (local i64)
-    (set_local 1 (i64.const 1))
+    (local.set 1 (i64.const 1))
     (block
       (loop
-        (br_if 1 (i64.eqz (get_local 0)))
-        (set_local 1 (i64.mul (get_local 0) (get_local 1)))
-        (set_local 0 (i64.sub (get_local 0) (i64.const 1)))
+        (br_if 1 (i64.eqz (local.get 0)))
+        (local.set 1 (i64.mul (local.get 0) (local.get 1)))
+        (local.set 0 (i64.sub (local.get 0) (i64.const 1)))
         (br 0)
       )
     )
-    (get_local 1)
+    (local.get 1)
   )
 
   (func (export "for") (param i64) (result i64)
     (local i64 i64)
-    (set_local 1 (i64.const 1))
-    (set_local 2 (i64.const 2))
+    (local.set 1 (i64.const 1))
+    (local.set 2 (i64.const 2))
     (block
       (loop
-        (br_if 1 (i64.gt_u (get_local 2) (get_local 0)))
-        (set_local 1 (i64.mul (get_local 1) (get_local 2)))
-        (set_local 2 (i64.add (get_local 2) (i64.const 1)))
+        (br_if 1 (i64.gt_u (local.get 2) (local.get 0)))
+        (local.set 1 (i64.mul (local.get 1) (local.get 2)))
+        (local.set 2 (i64.add (local.get 2) (i64.const 1)))
         (br 0)
       )
     )
-    (get_local 1)
+    (local.get 1)
   )
 
   (func (export "nesting") (param f32 f32) (result f32)
     (local f32 f32)
     (block
       (loop
-        (br_if 1 (f32.eq (get_local 0) (f32.const 0)))
-        (set_local 2 (get_local 1))
+        (br_if 1 (f32.eq (local.get 0) (f32.const 0)))
+        (local.set 2 (local.get 1))
         (block
           (loop
-            (br_if 1 (f32.eq (get_local 2) (f32.const 0)))
-            (br_if 3 (f32.lt (get_local 2) (f32.const 0)))
-            (set_local 3 (f32.add (get_local 3) (get_local 2)))
-            (set_local 2 (f32.sub (get_local 2) (f32.const 2)))
+            (br_if 1 (f32.eq (local.get 2) (f32.const 0)))
+            (br_if 3 (f32.lt (local.get 2) (f32.const 0)))
+            (local.set 3 (f32.add (local.get 3) (local.get 2)))
+            (local.set 2 (f32.sub (local.get 2) (f32.const 2)))
             (br 0)
           )
         )
-        (set_local 3 (f32.div (get_local 3) (get_local 0)))
-        (set_local 0 (f32.sub (get_local 0) (f32.const 1)))
+        (local.set 3 (f32.div (local.get 3) (local.get 0)))
+        (local.set 0 (f32.sub (local.get 0) (f32.const 1)))
         (br 0)
       )
     )
-    (get_local 3)
+    (local.get 3)
   )
 )
 
@@ -334,9 +334,9 @@
 (assert_return (invoke "as-return-value") (i32.const 1))
 (assert_return (invoke "as-drop-operand"))
 (assert_return (invoke "as-br-value") (i32.const 1))
-(assert_return (invoke "as-set_local-value") (i32.const 1))
-(assert_return (invoke "as-tee_local-value") (i32.const 1))
-(assert_return (invoke "as-set_global-value") (i32.const 1))
+(assert_return (invoke "as-local.set-value") (i32.const 1))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
 (assert_return (invoke "as-load-operand") (i32.const 1))
 
 (assert_return (invoke "as-unary-operand") (i32.const 0))
diff --git a/test/core/memory.wast b/test/core/memory.wast
index a1646d2b0..d0f4e6306 100644
--- a/test/core/memory.wast
+++ b/test/core/memory.wast
@@ -110,7 +110,7 @@
     (if
       (f64.eq
         (f64.load (i32.const 8))
-        (f64.reinterpret/i64 (i64.const -12345))
+        (f64.reinterpret_i64 (i64.const -12345))
       )
       (then (return (f64.const 0)))
     )
@@ -121,43 +121,43 @@
 
   ;; Sign and zero extending memory loads
   (func (export "i32_load8_s") (param $i i32) (result i32)
-	(i32.store8 (i32.const 8) (get_local $i))
+	(i32.store8 (i32.const 8) (local.get $i))
 	(i32.load8_s (i32.const 8))
   )
   (func (export "i32_load8_u") (param $i i32) (result i32)
-	(i32.store8 (i32.const 8) (get_local $i))
+	(i32.store8 (i32.const 8) (local.get $i))
 	(i32.load8_u (i32.const 8))
   )
   (func (export "i32_load16_s") (param $i i32) (result i32)
-	(i32.store16 (i32.const 8) (get_local $i))
+	(i32.store16 (i32.const 8) (local.get $i))
 	(i32.load16_s (i32.const 8))
   )
   (func (export "i32_load16_u") (param $i i32) (result i32)
-	(i32.store16 (i32.const 8) (get_local $i))
+	(i32.store16 (i32.const 8) (local.get $i))
 	(i32.load16_u (i32.const 8))
   )
   (func (export "i64_load8_s") (param $i i64) (result i64)
-	(i64.store8 (i32.const 8) (get_local $i))
+	(i64.store8 (i32.const 8) (local.get $i))
 	(i64.load8_s (i32.const 8))
   )
   (func (export "i64_load8_u") (param $i i64) (result i64)
-	(i64.store8 (i32.const 8) (get_local $i))
+	(i64.store8 (i32.const 8) (local.get $i))
 	(i64.load8_u (i32.const 8))
   )
   (func (export "i64_load16_s") (param $i i64) (result i64)
-	(i64.store16 (i32.const 8) (get_local $i))
+	(i64.store16 (i32.const 8) (local.get $i))
 	(i64.load16_s (i32.const 8))
   )
   (func (export "i64_load16_u") (param $i i64) (result i64)
-	(i64.store16 (i32.const 8) (get_local $i))
+	(i64.store16 (i32.const 8) (local.get $i))
 	(i64.load16_u (i32.const 8))
   )
   (func (export "i64_load32_s") (param $i i64) (result i64)
-	(i64.store32 (i32.const 8) (get_local $i))
+	(i64.store32 (i32.const 8) (local.get $i))
 	(i64.load32_s (i32.const 8))
   )
   (func (export "i64_load32_u") (param $i i64) (result i64)
-	(i64.store32 (i32.const 8) (get_local $i))
+	(i64.store32 (i32.const 8) (local.get $i))
 	(i64.load32_u (i32.const 8))
   )
 )
diff --git a/test/core/memory_grow.wast b/test/core/memory_grow.wast
index c00354cfc..9ce338e60 100644
--- a/test/core/memory_grow.wast
+++ b/test/core/memory_grow.wast
@@ -7,7 +7,7 @@
     (func (export "load_at_page_size") (result i32) (i32.load (i32.const 0x10000)))
     (func (export "store_at_page_size") (i32.store (i32.const 0x10000) (i32.const 3)))
 
-    (func (export "grow") (param $sz i32) (result i32) (memory.grow (get_local $sz)))
+    (func (export "grow") (param $sz i32) (result i32) (memory.grow (local.get $sz)))
     (func (export "size") (result i32) (memory.size))
 )
 
@@ -35,7 +35,7 @@
 
 (module
   (memory 0)
-  (func (export "grow") (param i32) (result i32) (memory.grow (get_local 0)))
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
 )
 
 (assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
@@ -49,7 +49,7 @@
 
 (module
   (memory 0 10)
-  (func (export "grow") (param i32) (result i32) (memory.grow (get_local 0)))
+  (func (export "grow") (param i32) (result i32) (memory.grow (local.get 0)))
 )
 
 (assert_return (invoke "grow" (i32.const 0)) (i32.const 0))
@@ -66,21 +66,21 @@
 (module
   (memory 1)
   (func (export "grow") (param i32) (result i32)
-    (memory.grow (get_local 0))
+    (memory.grow (local.get 0))
   )
   (func (export "check-memory-zero") (param i32 i32) (result i32)
     (local i32)
-    (set_local 2 (i32.const 1))
+    (local.set 2 (i32.const 1))
     (block
       (loop
-        (set_local 2 (i32.load8_u (get_local 0)))
-        (br_if 1 (i32.ne (get_local 2) (i32.const 0)))
-        (br_if 1 (i32.ge_u (get_local 0) (get_local 1)))
-        (set_local 0 (i32.add (get_local 0) (i32.const 1)))
-        (br_if 0 (i32.le_u (get_local 0) (get_local 1)))
+        (local.set 2 (i32.load8_u (local.get 0)))
+        (br_if 1 (i32.ne (local.get 2) (i32.const 0)))
+        (br_if 1 (i32.ge_u (local.get 0) (local.get 1)))
+        (local.set 0 (i32.add (local.get 0) (i32.const 1)))
+        (br_if 0 (i32.le_u (local.get 0) (local.get 1)))
       )
     )
-    (get_local 2)
+    (local.get 2)
   )
 )
 
@@ -154,10 +154,10 @@
   )
 
   (func (export "as-select-first") (param i32 i32) (result i32)
-    (select (memory.grow (i32.const 0)) (get_local 0) (get_local 1))
+    (select (memory.grow (i32.const 0)) (local.get 0) (local.get 1))
   )
   (func (export "as-select-second") (param i32 i32) (result i32)
-    (select (get_local 0) (memory.grow (i32.const 0)) (get_local 1))
+    (select (local.get 0) (memory.grow (i32.const 0)) (local.get 1))
   )
   (func (export "as-select-cond") (result i32)
     (select (i32.const 0) (i32.const 1) (memory.grow (i32.const 0)))
@@ -175,7 +175,7 @@
   )
 
   (type $sig (func (param i32 i32 i32) (result i32)))
-  (table anyfunc (elem $f))
+  (table funcref (elem $f))
   (func (export "as-call_indirect-first") (result i32)
     (call_indirect (type $sig)
       (memory.grow (i32.const 0)) (i32.const 2) (i32.const 3) (i32.const 0)
@@ -197,15 +197,15 @@
     )
   )
 
-  (func (export "as-set_local-value") (local i32)
-    (set_local 0 (memory.grow (i32.const 0)))
+  (func (export "as-local.set-value") (local i32)
+    (local.set 0 (memory.grow (i32.const 0)))
   )
-  (func (export "as-tee_local-value") (result i32) (local i32)
-    (tee_local 0 (memory.grow (i32.const 0)))
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (memory.grow (i32.const 0)))
   )
   (global $g (mut i32) (i32.const 0))
-  (func (export "as-set_global-value") (local i32)
-    (set_global $g (memory.grow (i32.const 0)))
+  (func (export "as-global.set-value") (local i32)
+    (global.set $g (memory.grow (i32.const 0)))
   )
 
   (func (export "as-load-address") (result i32)
@@ -285,9 +285,9 @@
 (assert_return (invoke "as-call_indirect-last") (i32.const -1))
 (assert_trap (invoke "as-call_indirect-index") "undefined element")
 
-(assert_return (invoke "as-set_local-value"))
-(assert_return (invoke "as-tee_local-value") (i32.const 1))
-(assert_return (invoke "as-set_global-value"))
+(assert_return (invoke "as-local.set-value"))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value"))
 
 (assert_return (invoke "as-load-address") (i32.const 0))
 (assert_return (invoke "as-loadN-address") (i32.const 0))
diff --git a/test/core/memory_redundancy.wast b/test/core/memory_redundancy.wast
index f16adc41b..dd317311b 100644
--- a/test/core/memory_redundancy.wast
+++ b/test/core/memory_redundancy.wast
@@ -21,18 +21,18 @@
   (func (export "test_redundant_load") (result i32)
     (local $t i32)
     (local $s i32)
-    (set_local $t (i32.load (i32.const 8)))
+    (local.set $t (i32.load (i32.const 8)))
     (i32.store (i32.const 5) (i32.const 0x80000000))
-    (set_local $s (i32.load (i32.const 8)))
-    (i32.add (get_local $t) (get_local $s))
+    (local.set $s (i32.load (i32.const 8)))
+    (i32.add (local.get $t) (local.get $s))
   )
 
   (func (export "test_dead_store") (result f32)
     (local $t f32)
     (i32.store (i32.const 8) (i32.const 0x23232323))
-    (set_local $t (f32.load (i32.const 11)))
+    (local.set $t (f32.load (i32.const 11)))
     (i32.store (i32.const 8) (i32.const 0))
-    (get_local $t)
+    (local.get $t)
   )
 
   ;; A function named "malloc" which implementations nonetheless shouldn't
@@ -48,11 +48,11 @@
      (result i32)
      (local $x i32)
      (local $y i32)
-     (set_local $x (call $malloc (i32.const 4)))
-     (set_local $y (call $malloc (i32.const 4)))
-     (i32.store (get_local $x) (i32.const 42))
-     (i32.store (get_local $y) (i32.const 43))
-     (i32.load (get_local $x))
+     (local.set $x (call $malloc (i32.const 4)))
+     (local.set $y (call $malloc (i32.const 4)))
+     (i32.store (local.get $x) (i32.const 42))
+     (i32.store (local.get $y) (i32.const 43))
+     (i32.load (local.get $x))
   )
 )
 
diff --git a/test/core/memory_trap.wast b/test/core/memory_trap.wast
index b79627d7c..a4156fe2c 100644
--- a/test/core/memory_trap.wast
+++ b/test/core/memory_trap.wast
@@ -6,15 +6,15 @@
     )
 
     (func (export "store") (param $i i32) (param $v i32)
-      (i32.store (i32.add (call $addr_limit) (get_local $i)) (get_local $v))
+      (i32.store (i32.add (call $addr_limit) (local.get $i)) (local.get $v))
     )
 
     (func (export "load") (param $i i32) (result i32)
-      (i32.load (i32.add (call $addr_limit) (get_local $i)))
+      (i32.load (i32.add (call $addr_limit) (local.get $i)))
     )
 
     (func (export "memory.grow") (param i32) (result i32)
-      (memory.grow (get_local 0))
+      (memory.grow (local.get 0))
     )
 )
 
@@ -38,73 +38,73 @@
   (data (i32.const 0xfff8) "abcdefgh")
 
   (func (export "i32.load") (param $a i32) (result i32)
-    (i32.load (get_local $a))
+    (i32.load (local.get $a))
   )
   (func (export "i64.load") (param $a i32) (result i64)
-    (i64.load (get_local $a))
+    (i64.load (local.get $a))
   )
   (func (export "f32.load") (param $a i32) (result f32)
-    (f32.load (get_local $a))
+    (f32.load (local.get $a))
   )
   (func (export "f64.load") (param $a i32) (result f64)
-    (f64.load (get_local $a))
+    (f64.load (local.get $a))
   )
   (func (export "i32.load8_s") (param $a i32) (result i32)
-    (i32.load8_s (get_local $a))
+    (i32.load8_s (local.get $a))
   )
   (func (export "i32.load8_u") (param $a i32) (result i32)
-    (i32.load8_u (get_local $a))
+    (i32.load8_u (local.get $a))
   )
   (func (export "i32.load16_s") (param $a i32) (result i32)
-    (i32.load16_s (get_local $a))
+    (i32.load16_s (local.get $a))
   )
   (func (export "i32.load16_u") (param $a i32) (result i32)
-    (i32.load16_u (get_local $a))
+    (i32.load16_u (local.get $a))
   )
   (func (export "i64.load8_s") (param $a i32) (result i64)
-    (i64.load8_s (get_local $a))
+    (i64.load8_s (local.get $a))
   )
   (func (export "i64.load8_u") (param $a i32) (result i64)
-    (i64.load8_u (get_local $a))
+    (i64.load8_u (local.get $a))
   )
   (func (export "i64.load16_s") (param $a i32) (result i64)
-    (i64.load16_s (get_local $a))
+    (i64.load16_s (local.get $a))
   )
   (func (export "i64.load16_u") (param $a i32) (result i64)
-    (i64.load16_u (get_local $a))
+    (i64.load16_u (local.get $a))
   )
   (func (export "i64.load32_s") (param $a i32) (result i64)
-    (i64.load32_s (get_local $a))
+    (i64.load32_s (local.get $a))
   )
   (func (export "i64.load32_u") (param $a i32) (result i64)
-    (i64.load32_u (get_local $a))
+    (i64.load32_u (local.get $a))
   )
   (func (export "i32.store") (param $a i32) (param $v i32)
-    (i32.store (get_local $a) (get_local $v))
+    (i32.store (local.get $a) (local.get $v))
   )
   (func (export "i64.store") (param $a i32) (param $v i64)
-    (i64.store (get_local $a) (get_local $v))
+    (i64.store (local.get $a) (local.get $v))
   )
   (func (export "f32.store") (param $a i32) (param $v f32)
-    (f32.store (get_local $a) (get_local $v))
+    (f32.store (local.get $a) (local.get $v))
   )
   (func (export "f64.store") (param $a i32) (param $v f64)
-    (f64.store (get_local $a) (get_local $v))
+    (f64.store (local.get $a) (local.get $v))
   )
   (func (export "i32.store8") (param $a i32) (param $v i32)
-    (i32.store8 (get_local $a) (get_local $v))
+    (i32.store8 (local.get $a) (local.get $v))
   )
   (func (export "i32.store16") (param $a i32) (param $v i32)
-    (i32.store16 (get_local $a) (get_local $v))
+    (i32.store16 (local.get $a) (local.get $v))
   )
   (func (export "i64.store8") (param $a i32) (param $v i64)
-    (i64.store8 (get_local $a) (get_local $v))
+    (i64.store8 (local.get $a) (local.get $v))
   )
   (func (export "i64.store16") (param $a i32) (param $v i64)
-    (i64.store16 (get_local $a) (get_local $v))
+    (i64.store16 (local.get $a) (local.get $v))
   )
   (func (export "i64.store32") (param $a i32) (param $v i64)
-    (i64.store32 (get_local $a) (get_local $v))
+    (i64.store32 (local.get $a) (local.get $v))
   )
 )
 
diff --git a/test/core/names.wast b/test/core/names.wast
index 2ed6ca575..2b1867079 100644
--- a/test/core/names.wast
+++ b/test/core/names.wast
@@ -1088,8 +1088,8 @@
   (import "spectest" "print_i32" (func (param i32)))
   (func (import "spectest" "print_i32") (param i32))
   (func (param i32) (param i32)
-    (call 0 (get_local 0))
-    (call 1 (get_local 1))
+    (call 0 (local.get 0))
+    (call 1 (local.get 1))
   )
   (export "print32" (func 2))
 )
diff --git a/test/core/nop.wast b/test/core/nop.wast
index 211685872..e8fe2de4b 100644
--- a/test/core/nop.wast
+++ b/test/core/nop.wast
@@ -4,7 +4,7 @@
   ;; Auxiliary definitions
   (func $dummy)
   (func $3-ary (param i32 i32 i32) (result i32)
-    get_local 0 get_local 1 get_local 2 i32.sub i32.add
+    local.get 0 local.get 1 local.get 2 i32.sub i32.add
   )
   (memory 1)
 
@@ -22,30 +22,30 @@
   )
 
   (func (export "as-drop-first") (param i32)
-    (nop) (get_local 0) (drop)
+    (nop) (local.get 0) (drop)
   )
   (func (export "as-drop-last") (param i32)
-    (get_local 0) (nop) (drop)
+    (local.get 0) (nop) (drop)
   )
   (func (export "as-drop-everywhere") (param i32)
-    (nop) (nop) (get_local 0) (nop) (nop) (drop)
+    (nop) (nop) (local.get 0) (nop) (nop) (drop)
   )
 
   (func (export "as-select-first") (param i32) (result i32)
-    (nop) (get_local 0) (get_local 0) (get_local 0) (select)
+    (nop) (local.get 0) (local.get 0) (local.get 0) (select)
   )
   (func (export "as-select-mid1") (param i32) (result i32)
-    (get_local 0) (nop) (get_local 0) (get_local 0) (select)
+    (local.get 0) (nop) (local.get 0) (local.get 0) (select)
   )
   (func (export "as-select-mid2") (param i32) (result i32)
-    (get_local 0) (get_local 0) (nop) (get_local 0) (select)
+    (local.get 0) (local.get 0) (nop) (local.get 0) (select)
   )
   (func (export "as-select-last") (param i32) (result i32)
-    (get_local 0) (get_local 0) (get_local 0) (nop) (select)
+    (local.get 0) (local.get 0) (local.get 0) (nop) (select)
   )
   (func (export "as-select-everywhere") (param i32) (result i32)
-    (nop) (get_local 0) (nop) (nop) (get_local 0)
-    (nop) (nop) (get_local 0) (nop) (nop) (select)
+    (nop) (local.get 0) (nop) (nop) (local.get 0)
+    (nop) (nop) (local.get 0) (nop) (nop) (select)
   )
 
   (func (export "as-block-first") (result i32)
@@ -79,143 +79,143 @@
   )
 
   (func (export "as-if-condition") (param i32)
-    (get_local 0) (nop) (if (then (call $dummy)))
+    (local.get 0) (nop) (if (then (call $dummy)))
   )
   (func (export "as-if-then") (param i32)
-    (if (get_local 0) (then (nop)) (else (call $dummy)))
+    (if (local.get 0) (then (nop)) (else (call $dummy)))
   )
   (func (export "as-if-else") (param i32)
-    (if (get_local 0) (then (call $dummy)) (else (nop)))
+    (if (local.get 0) (then (call $dummy)) (else (nop)))
   )
 
   (func (export "as-br-first") (param i32) (result i32)
-    (block (result i32) (nop) (get_local 0) (br 0))
+    (block (result i32) (nop) (local.get 0) (br 0))
   )
   (func (export "as-br-last") (param i32) (result i32)
-    (block (result i32) (get_local 0) (nop) (br 0))
+    (block (result i32) (local.get 0) (nop) (br 0))
   )
   (func (export "as-br-everywhere") (param i32) (result i32)
-    (block (result i32) (nop) (nop) (get_local 0) (nop) (nop) (br 0))
+    (block (result i32) (nop) (nop) (local.get 0) (nop) (nop) (br 0))
   )
 
   (func (export "as-br_if-first") (param i32) (result i32)
-    (block (result i32) (nop) (get_local 0) (get_local 0) (br_if 0))
+    (block (result i32) (nop) (local.get 0) (local.get 0) (br_if 0))
   )
   (func (export "as-br_if-mid") (param i32) (result i32)
-    (block (result i32) (get_local 0) (nop) (get_local 0) (br_if 0))
+    (block (result i32) (local.get 0) (nop) (local.get 0) (br_if 0))
   )
   (func (export "as-br_if-last") (param i32) (result i32)
-    (block (result i32) (get_local 0) (get_local 0) (nop) (br_if 0))
+    (block (result i32) (local.get 0) (local.get 0) (nop) (br_if 0))
   )
   (func (export "as-br_if-everywhere") (param i32) (result i32)
     (block (result i32)
-      (nop) (nop) (get_local 0) (nop) (nop) (get_local 0) (nop) (nop)
+      (nop) (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop)
       (br_if 0)
     )
   )
 
   (func (export "as-br_table-first") (param i32) (result i32)
-    (block (result i32) (nop) (get_local 0) (get_local 0) (br_table 0 0))
+    (block (result i32) (nop) (local.get 0) (local.get 0) (br_table 0 0))
   )
   (func (export "as-br_table-mid") (param i32) (result i32)
-    (block (result i32) (get_local 0) (nop) (get_local 0) (br_table 0 0))
+    (block (result i32) (local.get 0) (nop) (local.get 0) (br_table 0 0))
   )
   (func (export "as-br_table-last") (param i32) (result i32)
-    (block (result i32) (get_local 0) (get_local 0) (nop) (br_table 0 0))
+    (block (result i32) (local.get 0) (local.get 0) (nop) (br_table 0 0))
   )
   (func (export "as-br_table-everywhere") (param i32) (result i32)
     (block (result i32)
-      (nop) (nop) (get_local 0) (nop) (nop) (get_local 0) (nop) (nop)
+      (nop) (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop)
       (br_table 0 0)
     )
   )
 
   (func (export "as-return-first") (param i32) (result i32)
-    (nop) (get_local 0) (return)
+    (nop) (local.get 0) (return)
   )
   (func (export "as-return-last") (param i32) (result i32)
-    (get_local 0) (nop) (return)
+    (local.get 0) (nop) (return)
   )
   (func (export "as-return-everywhere") (param i32) (result i32)
-    (nop) (nop) (get_local 0) (nop) (nop) (return)
+    (nop) (nop) (local.get 0) (nop) (nop) (return)
   )
 
   (func (export "as-call-first") (param i32 i32 i32) (result i32)
-    (nop) (get_local 0) (get_local 1) (get_local 2) (call $3-ary)
+    (nop) (local.get 0) (local.get 1) (local.get 2) (call $3-ary)
   )
   (func (export "as-call-mid1") (param i32 i32 i32) (result i32)
-    (get_local 0) (nop) (get_local 1) (get_local 2) (call $3-ary)
+    (local.get 0) (nop) (local.get 1) (local.get 2) (call $3-ary)
   )
   (func (export "as-call-mid2") (param i32 i32 i32) (result i32)
-    (get_local 0) (get_local 1) (nop) (get_local 2) (call $3-ary)
+    (local.get 0) (local.get 1) (nop) (local.get 2) (call $3-ary)
   )
   (func (export "as-call-last") (param i32 i32 i32) (result i32)
-    (get_local 0) (get_local 1) (get_local 2) (nop) (call $3-ary)
+    (local.get 0) (local.get 1) (local.get 2) (nop) (call $3-ary)
   )
   (func (export "as-call-everywhere") (param i32 i32 i32) (result i32)
-    (nop) (nop) (get_local 0) (nop) (nop) (get_local 1)
-    (nop) (nop) (get_local 2) (nop) (nop) (call $3-ary)
+    (nop) (nop) (local.get 0) (nop) (nop) (local.get 1)
+    (nop) (nop) (local.get 2) (nop) (nop) (call $3-ary)
   )
 
   (func (export "as-unary-first") (param i32) (result i32)
-    (nop) (get_local 0) (i32.ctz)
+    (nop) (local.get 0) (i32.ctz)
   )
   (func (export "as-unary-last") (param i32) (result i32)
-    (get_local 0) (nop) (i32.ctz)
+    (local.get 0) (nop) (i32.ctz)
   )
   (func (export "as-unary-everywhere") (param i32) (result i32)
-    (nop) (nop) (get_local 0) (nop) (nop) (i32.ctz)
+    (nop) (nop) (local.get 0) (nop) (nop) (i32.ctz)
   )
 
   (func (export "as-binary-first") (param i32) (result i32)
-    (nop) (get_local 0) (get_local 0) (i32.add)
+    (nop) (local.get 0) (local.get 0) (i32.add)
   )
   (func (export "as-binary-mid") (param i32) (result i32)
-    (get_local 0) (nop) (get_local 0) (i32.add)
+    (local.get 0) (nop) (local.get 0) (i32.add)
   )
   (func (export "as-binary-last") (param i32) (result i32)
-    (get_local 0) (get_local 0) (nop) (i32.add)
+    (local.get 0) (local.get 0) (nop) (i32.add)
   )
   (func (export "as-binary-everywhere") (param i32) (result i32)
-    (nop) (get_local 0) (nop) (nop) (get_local 0) (nop) (nop) (i32.add)
+    (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop) (i32.add)
   )
 
   (func (export "as-test-first") (param i32) (result i32)
-    (nop) (get_local 0) (i32.eqz)
+    (nop) (local.get 0) (i32.eqz)
   )
   (func (export "as-test-last") (param i32) (result i32)
-    (get_local 0) (nop) (i32.eqz)
+    (local.get 0) (nop) (i32.eqz)
   )
   (func (export "as-test-everywhere") (param i32) (result i32)
-    (nop) (nop) (get_local 0) (nop) (nop) i32.eqz
+    (nop) (nop) (local.get 0) (nop) (nop) i32.eqz
   )
 
   (func (export "as-compare-first") (param i32) (result i32)
-    (nop) (get_local 0) (get_local 0) (i32.ne)
+    (nop) (local.get 0) (local.get 0) (i32.ne)
   )
   (func (export "as-compare-mid") (param i32) (result i32)
-    (get_local 0) (nop) (get_local 0) (i32.ne)
+    (local.get 0) (nop) (local.get 0) (i32.ne)
   )
   (func (export "as-compare-last") (param i32) (result i32)
-    (get_local 0) (get_local 0) (nop) (i32.lt_u)
+    (local.get 0) (local.get 0) (nop) (i32.lt_u)
   )
   (func (export "as-compare-everywhere") (param i32) (result i32)
-    (nop) (get_local 0) (nop) (nop) (get_local 0) (nop) (nop) (i32.le_s)
+    (nop) (local.get 0) (nop) (nop) (local.get 0) (nop) (nop) (i32.le_s)
   )
 
   (func (export "as-memory.grow-first") (param i32) (result i32)
-    (nop) (get_local 0) (memory.grow)
+    (nop) (local.get 0) (memory.grow)
   )
   (func (export "as-memory.grow-last") (param i32) (result i32)
-    (get_local 0) (nop) (memory.grow)
+    (local.get 0) (nop) (memory.grow)
   )
   (func (export "as-memory.grow-everywhere") (param i32) (result i32)
-    (nop) (nop) (get_local 0) (nop) (nop) (memory.grow)
+    (nop) (nop) (local.get 0) (nop) (nop) (memory.grow)
   )
 
-  (func $func (param i32 i32) (result i32) (get_local 0))
+  (func $func (param i32 i32) (result i32) (local.get 0))
   (type $check (func (param i32 i32) (result i32)))
-  (table anyfunc (elem $func))
+  (table funcref (elem $func))
   (func (export "as-call_indirect-first") (result i32)
     (block (result i32)
       (nop) (i32.const 1) (i32.const 2) (i32.const 0)
@@ -247,59 +247,59 @@
     )
   )
 
-  (func (export "as-set_local-first") (param i32) (result i32)
-    (nop) (i32.const 2) (set_local 0) (get_local 0)
+  (func (export "as-local.set-first") (param i32) (result i32)
+    (nop) (i32.const 2) (local.set 0) (local.get 0)
   )
-  (func (export "as-set_local-last") (param i32) (result i32)
-    (i32.const 2) (nop) (set_local 0) (get_local 0)
+  (func (export "as-local.set-last") (param i32) (result i32)
+    (i32.const 2) (nop) (local.set 0) (local.get 0)
   )
-  (func (export "as-set_local-everywhere") (param i32) (result i32)
-    (nop) (nop) (i32.const 2) (nop) (nop) (set_local 0) (get_local 0)
+  (func (export "as-local.set-everywhere") (param i32) (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (local.set 0) (local.get 0)
   )
 
-  (func (export "as-tee_local-first") (param i32) (result i32)
-    (nop) (i32.const 2) (tee_local 0)
+  (func (export "as-local.tee-first") (param i32) (result i32)
+    (nop) (i32.const 2) (local.tee 0)
   )
-  (func (export "as-tee_local-last") (param i32) (result i32)
-    (i32.const 2) (nop) (tee_local 0)
+  (func (export "as-local.tee-last") (param i32) (result i32)
+    (i32.const 2) (nop) (local.tee 0)
   )
-  (func (export "as-tee_local-everywhere") (param i32) (result i32)
-    (nop) (nop) (i32.const 2) (nop) (nop) (tee_local 0)
+  (func (export "as-local.tee-everywhere") (param i32) (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (local.tee 0)
   )
 
   (global $a (mut i32) (i32.const 0))
-  (func (export "as-set_global-first") (result i32)
-    (nop) (i32.const 2) (set_global $a) (get_global $a)
+  (func (export "as-global.set-first") (result i32)
+    (nop) (i32.const 2) (global.set $a) (global.get $a)
   )
-  (func (export "as-set_global-last") (result i32)
-    (i32.const 2) (nop) (set_global $a) (get_global $a)
+  (func (export "as-global.set-last") (result i32)
+    (i32.const 2) (nop) (global.set $a) (global.get $a)
   )
-  (func (export "as-set_global-everywhere") (result i32)
-    (nop) (nop) (i32.const 2) (nop) (nop) (set_global 0)
-    (get_global $a)
+  (func (export "as-global.set-everywhere") (result i32)
+    (nop) (nop) (i32.const 2) (nop) (nop) (global.set 0)
+    (global.get $a)
   )
 
   (func (export "as-load-first") (param i32) (result i32)
-    (nop) (get_local 0) (i32.load)
+    (nop) (local.get 0) (i32.load)
   )
   (func (export "as-load-last") (param i32) (result i32)
-    (get_local 0) (nop) (i32.load)
+    (local.get 0) (nop) (i32.load)
   )
   (func (export "as-load-everywhere") (param i32) (result i32)
-    (nop) (nop) (get_local 0) (nop) (nop) (i32.load)
+    (nop) (nop) (local.get 0) (nop) (nop) (i32.load)
   )
 
   (func (export "as-store-first") (param i32 i32)
-    (nop) (get_local 0) (get_local 1) (i32.store)
+    (nop) (local.get 0) (local.get 1) (i32.store)
   )
   (func (export "as-store-mid") (param i32 i32)
-    (get_local 0) (nop) (get_local 1) (i32.store)
+    (local.get 0) (nop) (local.get 1) (i32.store)
   )
   (func (export "as-store-last") (param i32 i32)
-    (get_local 0) (get_local 1) (nop) (i32.store)
+    (local.get 0) (local.get 1) (nop) (i32.store)
   )
   (func (export "as-store-everywhere") (param i32 i32)
-    (nop) (nop) (get_local 0) (nop) (nop) (get_local 1) (nop) (nop) (i32.store)
+    (nop) (nop) (local.get 0) (nop) (nop) (local.get 1) (nop) (nop) (i32.store)
   )
 )
 
@@ -387,17 +387,17 @@
 (assert_return (invoke "as-call_indirect-last") (i32.const 1))
 (assert_return (invoke "as-call_indirect-everywhere") (i32.const 1))
 
-(assert_return (invoke "as-set_local-first" (i32.const 1)) (i32.const 2))
-(assert_return (invoke "as-set_local-last" (i32.const 1)) (i32.const 2))
-(assert_return (invoke "as-set_local-everywhere" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-local.set-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-local.set-last" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-local.set-everywhere" (i32.const 1)) (i32.const 2))
 
-(assert_return (invoke "as-tee_local-first" (i32.const 1)) (i32.const 2))
-(assert_return (invoke "as-tee_local-last" (i32.const 1)) (i32.const 2))
-(assert_return (invoke "as-tee_local-everywhere" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-local.tee-first" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-local.tee-last" (i32.const 1)) (i32.const 2))
+(assert_return (invoke "as-local.tee-everywhere" (i32.const 1)) (i32.const 2))
 
-(assert_return (invoke "as-set_global-first") (i32.const 2))
-(assert_return (invoke "as-set_global-last") (i32.const 2))
-(assert_return (invoke "as-set_global-everywhere") (i32.const 2))
+(assert_return (invoke "as-global.set-first") (i32.const 2))
+(assert_return (invoke "as-global.set-last") (i32.const 2))
+(assert_return (invoke "as-global.set-everywhere") (i32.const 2))
 
 (assert_return (invoke "as-load-first" (i32.const 100)) (i32.const 0))
 (assert_return (invoke "as-load-last" (i32.const 100)) (i32.const 0))
diff --git a/test/core/return.wast b/test/core/return.wast
index 395ae8eb3..05ee62168 100644
--- a/test/core/return.wast
+++ b/test/core/return.wast
@@ -104,20 +104,20 @@
   )
   (func (export "as-if-then") (param i32 i32) (result i32)
     (if (result i32)
-      (get_local 0) (then (return (i32.const 3))) (else (get_local 1))
+      (local.get 0) (then (return (i32.const 3))) (else (local.get 1))
     )
   )
   (func (export "as-if-else") (param i32 i32) (result i32)
     (if (result i32)
-      (get_local 0) (then (get_local 1)) (else (return (i32.const 4)))
+      (local.get 0) (then (local.get 1)) (else (return (i32.const 4)))
     )
   )
 
   (func (export "as-select-first") (param i32 i32) (result i32)
-    (select (return (i32.const 5)) (get_local 0) (get_local 1))
+    (select (return (i32.const 5)) (local.get 0) (local.get 1))
   )
   (func (export "as-select-second") (param i32 i32) (result i32)
-    (select (get_local 0) (return (i32.const 6)) (get_local 1))
+    (select (local.get 0) (return (i32.const 6)) (local.get 1))
   )
   (func (export "as-select-cond") (result i32)
     (select (i32.const 0) (i32.const 1) (return (i32.const 7)))
@@ -135,7 +135,7 @@
   )
 
   (type $sig (func (param i32 i32 i32) (result i32)))
-  (table anyfunc (elem $f))
+  (table funcref (elem $f))
   (func (export "as-call_indirect-func") (result i32)
     (call_indirect (type $sig)
       (return (i32.const 20)) (i32.const 1) (i32.const 2) (i32.const 3)
@@ -157,15 +157,15 @@
     )
   )
 
-  (func (export "as-set_local-value") (result i32) (local f32)
-    (set_local 0 (return (i32.const 17))) (i32.const -1)
+  (func (export "as-local.set-value") (result i32) (local f32)
+    (local.set 0 (return (i32.const 17))) (i32.const -1)
   )
-  (func (export "as-tee_local-value") (result i32) (local i32)
-    (tee_local 0 (return (i32.const 1)))
+  (func (export "as-local.tee-value") (result i32) (local i32)
+    (local.tee 0 (return (i32.const 1)))
   )
   (global $a (mut i32) (i32.const 0))
-  (func (export "as-set_global-value") (result i32)
-    (set_global $a (return (i32.const 1)))
+  (func (export "as-global.set-value") (result i32)
+    (global.set $a (return (i32.const 1)))
   )
 
   (memory 1)
@@ -213,7 +213,7 @@
   )
 
   (func (export "as-convert-operand") (result i32)
-    (i32.wrap/i64 (return (i32.const 41)))
+    (i32.wrap_i64 (return (i32.const 41)))
   )
 
   (func (export "as-memory.grow-size") (result i32)
@@ -281,9 +281,9 @@
 (assert_return (invoke "as-call_indirect-mid") (i32.const 22))
 (assert_return (invoke "as-call_indirect-last") (i32.const 23))
 
-(assert_return (invoke "as-set_local-value") (i32.const 17))
-(assert_return (invoke "as-tee_local-value") (i32.const 1))
-(assert_return (invoke "as-set_global-value") (i32.const 1))
+(assert_return (invoke "as-local.set-value") (i32.const 17))
+(assert_return (invoke "as-local.tee-value") (i32.const 1))
+(assert_return (invoke "as-global.set-value") (i32.const 1))
 
 (assert_return (invoke "as-load-address") (f32.const 1.7))
 (assert_return (invoke "as-loadN-address") (i64.const 30))
diff --git a/test/core/select.wast b/test/core/select.wast
index f98cd7486..df4980d79 100644
--- a/test/core/select.wast
+++ b/test/core/select.wast
@@ -5,23 +5,23 @@
   (func $dummy)
 
   (func (export "select_i32") (param $lhs i32) (param $rhs i32) (param $cond i32) (result i32)
-   (select (get_local $lhs) (get_local $rhs) (get_local $cond)))
+   (select (local.get $lhs) (local.get $rhs) (local.get $cond)))
 
   (func (export "select_i64") (param $lhs i64) (param $rhs i64) (param $cond i32) (result i64)
-   (select (get_local $lhs) (get_local $rhs) (get_local $cond)))
+   (select (local.get $lhs) (local.get $rhs) (local.get $cond)))
 
   (func (export "select_f32") (param $lhs f32) (param $rhs f32) (param $cond i32) (result f32)
-   (select (get_local $lhs) (get_local $rhs) (get_local $cond)))
+   (select (local.get $lhs) (local.get $rhs) (local.get $cond)))
 
   (func (export "select_f64") (param $lhs f64) (param $rhs f64) (param $cond i32) (result f64)
-   (select (get_local $lhs) (get_local $rhs) (get_local $cond)))
+   (select (local.get $lhs) (local.get $rhs) (local.get $cond)))
 
   ;; Check that both sides of the select are evaluated
   (func (export "select_trap_l") (param $cond i32) (result i32)
-    (select (unreachable) (i32.const 0) (get_local $cond))
+    (select (unreachable) (i32.const 0) (local.get $cond))
   )
   (func (export "select_trap_r") (param $cond i32) (result i32)
-    (select (i32.const 0) (unreachable) (get_local $cond))
+    (select (i32.const 0) (unreachable) (local.get $cond))
   )
 
   (func (export "select_unreached")
@@ -35,143 +35,143 @@
   ;; As the argument of control constructs and instructions
 
   (func (export "as-select-first") (param i32) (result i32)
-    (select (select (i32.const 0) (i32.const 1) (get_local 0)) (i32.const 2) (i32.const 3))
+    (select (select (i32.const 0) (i32.const 1) (local.get 0)) (i32.const 2) (i32.const 3))
   )
   (func (export "as-select-mid") (param i32) (result i32)
-    (select (i32.const 2) (select (i32.const 0) (i32.const 1) (get_local 0)) (i32.const 3))
+    (select (i32.const 2) (select (i32.const 0) (i32.const 1) (local.get 0)) (i32.const 3))
   )
   (func (export "as-select-last") (param i32) (result i32)
-    (select (i32.const 2) (i32.const 3) (select (i32.const 0) (i32.const 1) (get_local 0)))
+    (select (i32.const 2) (i32.const 3) (select (i32.const 0) (i32.const 1) (local.get 0)))
   )
 
   (func (export "as-loop-first") (param i32) (result i32)
-    (loop (result i32) (select (i32.const 2) (i32.const 3) (get_local 0)) (call $dummy) (call $dummy))
+    (loop (result i32) (select (i32.const 2) (i32.const 3) (local.get 0)) (call $dummy) (call $dummy))
   )
   (func (export "as-loop-mid") (param i32) (result i32)
-    (loop (result i32) (call $dummy) (select (i32.const 2) (i32.const 3) (get_local 0)) (call $dummy))
+    (loop (result i32) (call $dummy) (select (i32.const 2) (i32.const 3) (local.get 0)) (call $dummy))
   )
   (func (export "as-loop-last") (param i32) (result i32)
-    (loop (result i32) (call $dummy) (call $dummy) (select (i32.const 2) (i32.const 3) (get_local 0)))
+    (loop (result i32) (call $dummy) (call $dummy) (select (i32.const 2) (i32.const 3) (local.get 0)))
   )
 
   (func (export "as-if-condition") (param i32)
-    (select (i32.const 2) (i32.const 3) (get_local 0)) (if (then (call $dummy)))
+    (select (i32.const 2) (i32.const 3) (local.get 0)) (if (then (call $dummy)))
   )
   (func (export "as-if-then") (param i32) (result i32)
-    (if (result i32) (i32.const 1) (then (select (i32.const 2) (i32.const 3) (get_local 0))) (else (i32.const 4)))
+    (if (result i32) (i32.const 1) (then (select (i32.const 2) (i32.const 3) (local.get 0))) (else (i32.const 4)))
   )
   (func (export "as-if-else") (param i32) (result i32)
-    (if (result i32) (i32.const 0) (then (i32.const 2)) (else (select (i32.const 2) (i32.const 3) (get_local 0))))
+    (if (result i32) (i32.const 0) (then (i32.const 2)) (else (select (i32.const 2) (i32.const 3) (local.get 0))))
   )
 
   (func (export "as-br_if-first") (param i32) (result i32)
-    (block (result i32) (br_if 0 (select (i32.const 2) (i32.const 3) (get_local 0)) (i32.const 4)))
+    (block (result i32) (br_if 0 (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 4)))
   )
   (func (export "as-br_if-last") (param i32) (result i32)
-    (block (result i32) (br_if 0 (i32.const 2) (select (i32.const 2) (i32.const 3) (get_local 0))))
+    (block (result i32) (br_if 0 (i32.const 2) (select (i32.const 2) (i32.const 3) (local.get 0))))
   )
 
   (func (export "as-br_table-first") (param i32) (result i32)
-    (block (result i32) (select (i32.const 2) (i32.const 3) (get_local 0)) (i32.const 2) (br_table 0 0))
+    (block (result i32) (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 2) (br_table 0 0))
   )
   (func (export "as-br_table-last") (param i32) (result i32)
-    (block (result i32) (i32.const 2) (select (i32.const 2) (i32.const 3) (get_local 0)) (br_table 0 0))
+    (block (result i32) (i32.const 2) (select (i32.const 2) (i32.const 3) (local.get 0)) (br_table 0 0))
   )
 
-  (func $func (param i32 i32) (result i32) (get_local 0))
+  (func $func (param i32 i32) (result i32) (local.get 0))
   (type $check (func (param i32 i32) (result i32)))
-  (table anyfunc (elem $func))
+  (table funcref (elem $func))
   (func (export "as-call_indirect-first") (param i32) (result i32)
     (block (result i32)
       (call_indirect (type $check)
-        (select (i32.const 2) (i32.const 3) (get_local 0)) (i32.const 1) (i32.const 0)
+        (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 1) (i32.const 0)
       )
     )
   )
   (func (export "as-call_indirect-mid") (param i32) (result i32)
     (block (result i32)
       (call_indirect (type $check)
-        (i32.const 1) (select (i32.const 2) (i32.const 3) (get_local 0)) (i32.const 0)
+        (i32.const 1) (select (i32.const 2) (i32.const 3) (local.get 0)) (i32.const 0)
       )
     )
   )
   (func (export "as-call_indirect-last") (param i32) (result i32)
     (block (result i32)
       (call_indirect (type $check)
-        (i32.const 1) (i32.const 4) (select (i32.const 2) (i32.const 3) (get_local 0))
+        (i32.const 1) (i32.const 4) (select (i32.const 2) (i32.const 3) (local.get 0))
       )
     )
   )
 
   (func (export "as-store-first") (param i32)
-    (select (i32.const 0) (i32.const 4) (get_local 0)) (i32.const 1) (i32.store)
+    (select (i32.const 0) (i32.const 4) (local.get 0)) (i32.const 1) (i32.store)
   )
   (func (export "as-store-last") (param i32)
-    (i32.const 8) (select (i32.const 1) (i32.const 2) (get_local 0)) (i32.store)
+    (i32.const 8) (select (i32.const 1) (i32.const 2) (local.get 0)) (i32.store)
   )
 
   (func (export "as-memory.grow-value") (param i32) (result i32)
-    (memory.grow (select (i32.const 1) (i32.const 2) (get_local 0)))
+    (memory.grow (select (i32.const 1) (i32.const 2) (local.get 0)))
   )
 
-  (func $f (param i32) (result i32) (get_local 0))
+  (func $f (param i32) (result i32) (local.get 0))
 
   (func (export "as-call-value") (param i32) (result i32)
-    (call $f (select (i32.const 1) (i32.const 2) (get_local 0)))
+    (call $f (select (i32.const 1) (i32.const 2) (local.get 0)))
   )
   (func (export "as-return-value") (param i32) (result i32)
-    (select (i32.const 1) (i32.const 2) (get_local 0)) (return)
+    (select (i32.const 1) (i32.const 2) (local.get 0)) (return)
   )
   (func (export "as-drop-operand") (param i32)
-    (drop (select (i32.const 1) (i32.const 2) (get_local 0)))
+    (drop (select (i32.const 1) (i32.const 2) (local.get 0)))
   )
   (func (export "as-br-value") (param i32) (result i32)
-    (block (result i32) (br 0 (select (i32.const 1) (i32.const 2) (get_local 0))))
+    (block (result i32) (br 0 (select (i32.const 1) (i32.const 2) (local.get 0))))
   )
-  (func (export "as-set_local-value") (param i32) (result i32)
-    (local i32) (set_local 0 (select (i32.const 1) (i32.const 2) (get_local 0))) (get_local 0)
+  (func (export "as-local.set-value") (param i32) (result i32)
+    (local i32) (local.set 0 (select (i32.const 1) (i32.const 2) (local.get 0))) (local.get 0)
   )
-  (func (export "as-tee_local-value") (param i32) (result i32)
-    (tee_local 0 (select (i32.const 1) (i32.const 2) (get_local 0)))
+  (func (export "as-local.tee-value") (param i32) (result i32)
+    (local.tee 0 (select (i32.const 1) (i32.const 2) (local.get 0)))
   )
   (global $a (mut i32) (i32.const 10))
-  (func (export "as-set_global-value") (param i32) (result i32)
-    (set_global $a (select (i32.const 1) (i32.const 2) (get_local 0)))
-    (get_global $a)
+  (func (export "as-global.set-value") (param i32) (result i32)
+    (global.set $a (select (i32.const 1) (i32.const 2) (local.get 0)))
+    (global.get $a)
   )
   (func (export "as-load-operand") (param i32) (result i32)
-    (i32.load (select (i32.const 0) (i32.const 4) (get_local 0)))
+    (i32.load (select (i32.const 0) (i32.const 4) (local.get 0)))
   )
 
   (func (export "as-unary-operand") (param i32) (result i32)
-    (i32.eqz (select (i32.const 0) (i32.const 1) (get_local 0)))
+    (i32.eqz (select (i32.const 0) (i32.const 1) (local.get 0)))
   )
   (func (export "as-binary-operand") (param i32) (result i32)
     (i32.mul
-      (select (i32.const 1) (i32.const 2) (get_local 0))
-      (select (i32.const 1) (i32.const 2) (get_local 0))
+      (select (i32.const 1) (i32.const 2) (local.get 0))
+      (select (i32.const 1) (i32.const 2) (local.get 0))
     )
   )
   (func (export "as-test-operand") (param i32) (result i32)
     (block (result i32)
-      (i32.eqz (select (i32.const 0) (i32.const 1) (get_local 0)))
+      (i32.eqz (select (i32.const 0) (i32.const 1) (local.get 0)))
     )
   )
 
   (func (export "as-compare-left") (param i32) (result i32)
     (block (result i32)
-      (i32.le_s (select (i32.const 1) (i32.const 2) (get_local 0)) (i32.const 1))
+      (i32.le_s (select (i32.const 1) (i32.const 2) (local.get 0)) (i32.const 1))
     )
   )
   (func (export "as-compare-right") (param i32) (result i32)
     (block (result i32)
-      (i32.ne (i32.const 1) (select (i32.const 0) (i32.const 1) (get_local 0)))
+      (i32.ne (i32.const 1) (select (i32.const 0) (i32.const 1) (local.get 0)))
     )
   )
 
   (func (export "as-convert-operand") (param i32) (result i32)
     (block (result i32)
-      (i32.wrap/i64 (select (i64.const 1) (i64.const 0) (get_local 0)))
+      (i32.wrap_i64 (select (i64.const 1) (i64.const 0) (local.get 0)))
     )
   )
 
@@ -264,12 +264,12 @@
 (assert_return (invoke "as-drop-operand" (i32.const 1)))
 (assert_return (invoke "as-br-value" (i32.const 0)) (i32.const 2))
 (assert_return (invoke "as-br-value" (i32.const 1)) (i32.const 1))
-(assert_return (invoke "as-set_local-value" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-set_local-value" (i32.const 1)) (i32.const 1))
-(assert_return (invoke "as-tee_local-value" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-tee_local-value" (i32.const 1)) (i32.const 1))
-(assert_return (invoke "as-set_global-value" (i32.const 0)) (i32.const 2))
-(assert_return (invoke "as-set_global-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-local.set-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-local.set-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-local.tee-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-local.tee-value" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "as-global.set-value" (i32.const 0)) (i32.const 2))
+(assert_return (invoke "as-global.set-value" (i32.const 1)) (i32.const 1))
 (assert_return (invoke "as-load-operand" (i32.const 0)) (i32.const 1))
 (assert_return (invoke "as-load-operand" (i32.const 1)) (i32.const 1))
 
diff --git a/test/core/skip-stack-guard-page.wast b/test/core/skip-stack-guard-page.wast
index f2449dc85..a472e6814 100644
--- a/test/core/skip-stack-guard-page.wast
+++ b/test/core/skip-stack-guard-page.wast
@@ -5,9 +5,9 @@
 
   (func $test-guard-page-skip
     (param $depth i32)
-    (if (i32.eq (get_local $depth) (i32.const 0))
+    (if (i32.eq (local.get $depth) (i32.const 0))
       (then (call $function-with-many-locals))
-      (else (call $test-guard-page-skip (i32.sub (get_local $depth) (i32.const 1))))
+      (else (call $test-guard-page-skip (i32.sub (local.get $depth) (i32.const 1))))
     )
   )
 
@@ -155,2120 +155,2120 @@
     (call $function-with-many-locals)
 
     ;; load from memory into the locals
-    (set_local 0x000 (i64.load offset=0x000 align=1 (i32.const 0)))
-    (set_local 0x001 (i64.load offset=0x001 align=1 (i32.const 0)))
-    (set_local 0x002 (i64.load offset=0x002 align=1 (i32.const 0)))
-    (set_local 0x003 (i64.load offset=0x003 align=1 (i32.const 0)))
-    (set_local 0x004 (i64.load offset=0x004 align=1 (i32.const 0)))
-    (set_local 0x005 (i64.load offset=0x005 align=1 (i32.const 0)))
-    (set_local 0x006 (i64.load offset=0x006 align=1 (i32.const 0)))
-    (set_local 0x007 (i64.load offset=0x007 align=1 (i32.const 0)))
-    (set_local 0x008 (i64.load offset=0x008 align=1 (i32.const 0)))
-    (set_local 0x009 (i64.load offset=0x009 align=1 (i32.const 0)))
-    (set_local 0x00a (i64.load offset=0x00a align=1 (i32.const 0)))
-    (set_local 0x00b (i64.load offset=0x00b align=1 (i32.const 0)))
-    (set_local 0x00c (i64.load offset=0x00c align=1 (i32.const 0)))
-    (set_local 0x00d (i64.load offset=0x00d align=1 (i32.const 0)))
-    (set_local 0x00e (i64.load offset=0x00e align=1 (i32.const 0)))
-    (set_local 0x00f (i64.load offset=0x00f align=1 (i32.const 0)))
-    (set_local 0x010 (i64.load offset=0x010 align=1 (i32.const 0)))
-    (set_local 0x011 (i64.load offset=0x011 align=1 (i32.const 0)))
-    (set_local 0x012 (i64.load offset=0x012 align=1 (i32.const 0)))
-    (set_local 0x013 (i64.load offset=0x013 align=1 (i32.const 0)))
-    (set_local 0x014 (i64.load offset=0x014 align=1 (i32.const 0)))
-    (set_local 0x015 (i64.load offset=0x015 align=1 (i32.const 0)))
-    (set_local 0x016 (i64.load offset=0x016 align=1 (i32.const 0)))
-    (set_local 0x017 (i64.load offset=0x017 align=1 (i32.const 0)))
-    (set_local 0x018 (i64.load offset=0x018 align=1 (i32.const 0)))
-    (set_local 0x019 (i64.load offset=0x019 align=1 (i32.const 0)))
-    (set_local 0x01a (i64.load offset=0x01a align=1 (i32.const 0)))
-    (set_local 0x01b (i64.load offset=0x01b align=1 (i32.const 0)))
-    (set_local 0x01c (i64.load offset=0x01c align=1 (i32.const 0)))
-    (set_local 0x01d (i64.load offset=0x01d align=1 (i32.const 0)))
-    (set_local 0x01e (i64.load offset=0x01e align=1 (i32.const 0)))
-    (set_local 0x01f (i64.load offset=0x01f align=1 (i32.const 0)))
-    (set_local 0x020 (i64.load offset=0x020 align=1 (i32.const 0)))
-    (set_local 0x021 (i64.load offset=0x021 align=1 (i32.const 0)))
-    (set_local 0x022 (i64.load offset=0x022 align=1 (i32.const 0)))
-    (set_local 0x023 (i64.load offset=0x023 align=1 (i32.const 0)))
-    (set_local 0x024 (i64.load offset=0x024 align=1 (i32.const 0)))
-    (set_local 0x025 (i64.load offset=0x025 align=1 (i32.const 0)))
-    (set_local 0x026 (i64.load offset=0x026 align=1 (i32.const 0)))
-    (set_local 0x027 (i64.load offset=0x027 align=1 (i32.const 0)))
-    (set_local 0x028 (i64.load offset=0x028 align=1 (i32.const 0)))
-    (set_local 0x029 (i64.load offset=0x029 align=1 (i32.const 0)))
-    (set_local 0x02a (i64.load offset=0x02a align=1 (i32.const 0)))
-    (set_local 0x02b (i64.load offset=0x02b align=1 (i32.const 0)))
-    (set_local 0x02c (i64.load offset=0x02c align=1 (i32.const 0)))
-    (set_local 0x02d (i64.load offset=0x02d align=1 (i32.const 0)))
-    (set_local 0x02e (i64.load offset=0x02e align=1 (i32.const 0)))
-    (set_local 0x02f (i64.load offset=0x02f align=1 (i32.const 0)))
-    (set_local 0x030 (i64.load offset=0x030 align=1 (i32.const 0)))
-    (set_local 0x031 (i64.load offset=0x031 align=1 (i32.const 0)))
-    (set_local 0x032 (i64.load offset=0x032 align=1 (i32.const 0)))
-    (set_local 0x033 (i64.load offset=0x033 align=1 (i32.const 0)))
-    (set_local 0x034 (i64.load offset=0x034 align=1 (i32.const 0)))
-    (set_local 0x035 (i64.load offset=0x035 align=1 (i32.const 0)))
-    (set_local 0x036 (i64.load offset=0x036 align=1 (i32.const 0)))
-    (set_local 0x037 (i64.load offset=0x037 align=1 (i32.const 0)))
-    (set_local 0x038 (i64.load offset=0x038 align=1 (i32.const 0)))
-    (set_local 0x039 (i64.load offset=0x039 align=1 (i32.const 0)))
-    (set_local 0x03a (i64.load offset=0x03a align=1 (i32.const 0)))
-    (set_local 0x03b (i64.load offset=0x03b align=1 (i32.const 0)))
-    (set_local 0x03c (i64.load offset=0x03c align=1 (i32.const 0)))
-    (set_local 0x03d (i64.load offset=0x03d align=1 (i32.const 0)))
-    (set_local 0x03e (i64.load offset=0x03e align=1 (i32.const 0)))
-    (set_local 0x03f (i64.load offset=0x03f align=1 (i32.const 0)))
-    (set_local 0x040 (i64.load offset=0x040 align=1 (i32.const 0)))
-    (set_local 0x041 (i64.load offset=0x041 align=1 (i32.const 0)))
-    (set_local 0x042 (i64.load offset=0x042 align=1 (i32.const 0)))
-    (set_local 0x043 (i64.load offset=0x043 align=1 (i32.const 0)))
-    (set_local 0x044 (i64.load offset=0x044 align=1 (i32.const 0)))
-    (set_local 0x045 (i64.load offset=0x045 align=1 (i32.const 0)))
-    (set_local 0x046 (i64.load offset=0x046 align=1 (i32.const 0)))
-    (set_local 0x047 (i64.load offset=0x047 align=1 (i32.const 0)))
-    (set_local 0x048 (i64.load offset=0x048 align=1 (i32.const 0)))
-    (set_local 0x049 (i64.load offset=0x049 align=1 (i32.const 0)))
-    (set_local 0x04a (i64.load offset=0x04a align=1 (i32.const 0)))
-    (set_local 0x04b (i64.load offset=0x04b align=1 (i32.const 0)))
-    (set_local 0x04c (i64.load offset=0x04c align=1 (i32.const 0)))
-    (set_local 0x04d (i64.load offset=0x04d align=1 (i32.const 0)))
-    (set_local 0x04e (i64.load offset=0x04e align=1 (i32.const 0)))
-    (set_local 0x04f (i64.load offset=0x04f align=1 (i32.const 0)))
-    (set_local 0x050 (i64.load offset=0x050 align=1 (i32.const 0)))
-    (set_local 0x051 (i64.load offset=0x051 align=1 (i32.const 0)))
-    (set_local 0x052 (i64.load offset=0x052 align=1 (i32.const 0)))
-    (set_local 0x053 (i64.load offset=0x053 align=1 (i32.const 0)))
-    (set_local 0x054 (i64.load offset=0x054 align=1 (i32.const 0)))
-    (set_local 0x055 (i64.load offset=0x055 align=1 (i32.const 0)))
-    (set_local 0x056 (i64.load offset=0x056 align=1 (i32.const 0)))
-    (set_local 0x057 (i64.load offset=0x057 align=1 (i32.const 0)))
-    (set_local 0x058 (i64.load offset=0x058 align=1 (i32.const 0)))
-    (set_local 0x059 (i64.load offset=0x059 align=1 (i32.const 0)))
-    (set_local 0x05a (i64.load offset=0x05a align=1 (i32.const 0)))
-    (set_local 0x05b (i64.load offset=0x05b align=1 (i32.const 0)))
-    (set_local 0x05c (i64.load offset=0x05c align=1 (i32.const 0)))
-    (set_local 0x05d (i64.load offset=0x05d align=1 (i32.const 0)))
-    (set_local 0x05e (i64.load offset=0x05e align=1 (i32.const 0)))
-    (set_local 0x05f (i64.load offset=0x05f align=1 (i32.const 0)))
-    (set_local 0x060 (i64.load offset=0x060 align=1 (i32.const 0)))
-    (set_local 0x061 (i64.load offset=0x061 align=1 (i32.const 0)))
-    (set_local 0x062 (i64.load offset=0x062 align=1 (i32.const 0)))
-    (set_local 0x063 (i64.load offset=0x063 align=1 (i32.const 0)))
-    (set_local 0x064 (i64.load offset=0x064 align=1 (i32.const 0)))
-    (set_local 0x065 (i64.load offset=0x065 align=1 (i32.const 0)))
-    (set_local 0x066 (i64.load offset=0x066 align=1 (i32.const 0)))
-    (set_local 0x067 (i64.load offset=0x067 align=1 (i32.const 0)))
-    (set_local 0x068 (i64.load offset=0x068 align=1 (i32.const 0)))
-    (set_local 0x069 (i64.load offset=0x069 align=1 (i32.const 0)))
-    (set_local 0x06a (i64.load offset=0x06a align=1 (i32.const 0)))
-    (set_local 0x06b (i64.load offset=0x06b align=1 (i32.const 0)))
-    (set_local 0x06c (i64.load offset=0x06c align=1 (i32.const 0)))
-    (set_local 0x06d (i64.load offset=0x06d align=1 (i32.const 0)))
-    (set_local 0x06e (i64.load offset=0x06e align=1 (i32.const 0)))
-    (set_local 0x06f (i64.load offset=0x06f align=1 (i32.const 0)))
-    (set_local 0x070 (i64.load offset=0x070 align=1 (i32.const 0)))
-    (set_local 0x071 (i64.load offset=0x071 align=1 (i32.const 0)))
-    (set_local 0x072 (i64.load offset=0x072 align=1 (i32.const 0)))
-    (set_local 0x073 (i64.load offset=0x073 align=1 (i32.const 0)))
-    (set_local 0x074 (i64.load offset=0x074 align=1 (i32.const 0)))
-    (set_local 0x075 (i64.load offset=0x075 align=1 (i32.const 0)))
-    (set_local 0x076 (i64.load offset=0x076 align=1 (i32.const 0)))
-    (set_local 0x077 (i64.load offset=0x077 align=1 (i32.const 0)))
-    (set_local 0x078 (i64.load offset=0x078 align=1 (i32.const 0)))
-    (set_local 0x079 (i64.load offset=0x079 align=1 (i32.const 0)))
-    (set_local 0x07a (i64.load offset=0x07a align=1 (i32.const 0)))
-    (set_local 0x07b (i64.load offset=0x07b align=1 (i32.const 0)))
-    (set_local 0x07c (i64.load offset=0x07c align=1 (i32.const 0)))
-    (set_local 0x07d (i64.load offset=0x07d align=1 (i32.const 0)))
-    (set_local 0x07e (i64.load offset=0x07e align=1 (i32.const 0)))
-    (set_local 0x07f (i64.load offset=0x07f align=1 (i32.const 0)))
-    (set_local 0x080 (i64.load offset=0x080 align=1 (i32.const 0)))
-    (set_local 0x081 (i64.load offset=0x081 align=1 (i32.const 0)))
-    (set_local 0x082 (i64.load offset=0x082 align=1 (i32.const 0)))
-    (set_local 0x083 (i64.load offset=0x083 align=1 (i32.const 0)))
-    (set_local 0x084 (i64.load offset=0x084 align=1 (i32.const 0)))
-    (set_local 0x085 (i64.load offset=0x085 align=1 (i32.const 0)))
-    (set_local 0x086 (i64.load offset=0x086 align=1 (i32.const 0)))
-    (set_local 0x087 (i64.load offset=0x087 align=1 (i32.const 0)))
-    (set_local 0x088 (i64.load offset=0x088 align=1 (i32.const 0)))
-    (set_local 0x089 (i64.load offset=0x089 align=1 (i32.const 0)))
-    (set_local 0x08a (i64.load offset=0x08a align=1 (i32.const 0)))
-    (set_local 0x08b (i64.load offset=0x08b align=1 (i32.const 0)))
-    (set_local 0x08c (i64.load offset=0x08c align=1 (i32.const 0)))
-    (set_local 0x08d (i64.load offset=0x08d align=1 (i32.const 0)))
-    (set_local 0x08e (i64.load offset=0x08e align=1 (i32.const 0)))
-    (set_local 0x08f (i64.load offset=0x08f align=1 (i32.const 0)))
-    (set_local 0x090 (i64.load offset=0x090 align=1 (i32.const 0)))
-    (set_local 0x091 (i64.load offset=0x091 align=1 (i32.const 0)))
-    (set_local 0x092 (i64.load offset=0x092 align=1 (i32.const 0)))
-    (set_local 0x093 (i64.load offset=0x093 align=1 (i32.const 0)))
-    (set_local 0x094 (i64.load offset=0x094 align=1 (i32.const 0)))
-    (set_local 0x095 (i64.load offset=0x095 align=1 (i32.const 0)))
-    (set_local 0x096 (i64.load offset=0x096 align=1 (i32.const 0)))
-    (set_local 0x097 (i64.load offset=0x097 align=1 (i32.const 0)))
-    (set_local 0x098 (i64.load offset=0x098 align=1 (i32.const 0)))
-    (set_local 0x099 (i64.load offset=0x099 align=1 (i32.const 0)))
-    (set_local 0x09a (i64.load offset=0x09a align=1 (i32.const 0)))
-    (set_local 0x09b (i64.load offset=0x09b align=1 (i32.const 0)))
-    (set_local 0x09c (i64.load offset=0x09c align=1 (i32.const 0)))
-    (set_local 0x09d (i64.load offset=0x09d align=1 (i32.const 0)))
-    (set_local 0x09e (i64.load offset=0x09e align=1 (i32.const 0)))
-    (set_local 0x09f (i64.load offset=0x09f align=1 (i32.const 0)))
-    (set_local 0x0a0 (i64.load offset=0x0a0 align=1 (i32.const 0)))
-    (set_local 0x0a1 (i64.load offset=0x0a1 align=1 (i32.const 0)))
-    (set_local 0x0a2 (i64.load offset=0x0a2 align=1 (i32.const 0)))
-    (set_local 0x0a3 (i64.load offset=0x0a3 align=1 (i32.const 0)))
-    (set_local 0x0a4 (i64.load offset=0x0a4 align=1 (i32.const 0)))
-    (set_local 0x0a5 (i64.load offset=0x0a5 align=1 (i32.const 0)))
-    (set_local 0x0a6 (i64.load offset=0x0a6 align=1 (i32.const 0)))
-    (set_local 0x0a7 (i64.load offset=0x0a7 align=1 (i32.const 0)))
-    (set_local 0x0a8 (i64.load offset=0x0a8 align=1 (i32.const 0)))
-    (set_local 0x0a9 (i64.load offset=0x0a9 align=1 (i32.const 0)))
-    (set_local 0x0aa (i64.load offset=0x0aa align=1 (i32.const 0)))
-    (set_local 0x0ab (i64.load offset=0x0ab align=1 (i32.const 0)))
-    (set_local 0x0ac (i64.load offset=0x0ac align=1 (i32.const 0)))
-    (set_local 0x0ad (i64.load offset=0x0ad align=1 (i32.const 0)))
-    (set_local 0x0ae (i64.load offset=0x0ae align=1 (i32.const 0)))
-    (set_local 0x0af (i64.load offset=0x0af align=1 (i32.const 0)))
-    (set_local 0x0b0 (i64.load offset=0x0b0 align=1 (i32.const 0)))
-    (set_local 0x0b1 (i64.load offset=0x0b1 align=1 (i32.const 0)))
-    (set_local 0x0b2 (i64.load offset=0x0b2 align=1 (i32.const 0)))
-    (set_local 0x0b3 (i64.load offset=0x0b3 align=1 (i32.const 0)))
-    (set_local 0x0b4 (i64.load offset=0x0b4 align=1 (i32.const 0)))
-    (set_local 0x0b5 (i64.load offset=0x0b5 align=1 (i32.const 0)))
-    (set_local 0x0b6 (i64.load offset=0x0b6 align=1 (i32.const 0)))
-    (set_local 0x0b7 (i64.load offset=0x0b7 align=1 (i32.const 0)))
-    (set_local 0x0b8 (i64.load offset=0x0b8 align=1 (i32.const 0)))
-    (set_local 0x0b9 (i64.load offset=0x0b9 align=1 (i32.const 0)))
-    (set_local 0x0ba (i64.load offset=0x0ba align=1 (i32.const 0)))
-    (set_local 0x0bb (i64.load offset=0x0bb align=1 (i32.const 0)))
-    (set_local 0x0bc (i64.load offset=0x0bc align=1 (i32.const 0)))
-    (set_local 0x0bd (i64.load offset=0x0bd align=1 (i32.const 0)))
-    (set_local 0x0be (i64.load offset=0x0be align=1 (i32.const 0)))
-    (set_local 0x0bf (i64.load offset=0x0bf align=1 (i32.const 0)))
-    (set_local 0x0c0 (i64.load offset=0x0c0 align=1 (i32.const 0)))
-    (set_local 0x0c1 (i64.load offset=0x0c1 align=1 (i32.const 0)))
-    (set_local 0x0c2 (i64.load offset=0x0c2 align=1 (i32.const 0)))
-    (set_local 0x0c3 (i64.load offset=0x0c3 align=1 (i32.const 0)))
-    (set_local 0x0c4 (i64.load offset=0x0c4 align=1 (i32.const 0)))
-    (set_local 0x0c5 (i64.load offset=0x0c5 align=1 (i32.const 0)))
-    (set_local 0x0c6 (i64.load offset=0x0c6 align=1 (i32.const 0)))
-    (set_local 0x0c7 (i64.load offset=0x0c7 align=1 (i32.const 0)))
-    (set_local 0x0c8 (i64.load offset=0x0c8 align=1 (i32.const 0)))
-    (set_local 0x0c9 (i64.load offset=0x0c9 align=1 (i32.const 0)))
-    (set_local 0x0ca (i64.load offset=0x0ca align=1 (i32.const 0)))
-    (set_local 0x0cb (i64.load offset=0x0cb align=1 (i32.const 0)))
-    (set_local 0x0cc (i64.load offset=0x0cc align=1 (i32.const 0)))
-    (set_local 0x0cd (i64.load offset=0x0cd align=1 (i32.const 0)))
-    (set_local 0x0ce (i64.load offset=0x0ce align=1 (i32.const 0)))
-    (set_local 0x0cf (i64.load offset=0x0cf align=1 (i32.const 0)))
-    (set_local 0x0d0 (i64.load offset=0x0d0 align=1 (i32.const 0)))
-    (set_local 0x0d1 (i64.load offset=0x0d1 align=1 (i32.const 0)))
-    (set_local 0x0d2 (i64.load offset=0x0d2 align=1 (i32.const 0)))
-    (set_local 0x0d3 (i64.load offset=0x0d3 align=1 (i32.const 0)))
-    (set_local 0x0d4 (i64.load offset=0x0d4 align=1 (i32.const 0)))
-    (set_local 0x0d5 (i64.load offset=0x0d5 align=1 (i32.const 0)))
-    (set_local 0x0d6 (i64.load offset=0x0d6 align=1 (i32.const 0)))
-    (set_local 0x0d7 (i64.load offset=0x0d7 align=1 (i32.const 0)))
-    (set_local 0x0d8 (i64.load offset=0x0d8 align=1 (i32.const 0)))
-    (set_local 0x0d9 (i64.load offset=0x0d9 align=1 (i32.const 0)))
-    (set_local 0x0da (i64.load offset=0x0da align=1 (i32.const 0)))
-    (set_local 0x0db (i64.load offset=0x0db align=1 (i32.const 0)))
-    (set_local 0x0dc (i64.load offset=0x0dc align=1 (i32.const 0)))
-    (set_local 0x0dd (i64.load offset=0x0dd align=1 (i32.const 0)))
-    (set_local 0x0de (i64.load offset=0x0de align=1 (i32.const 0)))
-    (set_local 0x0df (i64.load offset=0x0df align=1 (i32.const 0)))
-    (set_local 0x0e0 (i64.load offset=0x0e0 align=1 (i32.const 0)))
-    (set_local 0x0e1 (i64.load offset=0x0e1 align=1 (i32.const 0)))
-    (set_local 0x0e2 (i64.load offset=0x0e2 align=1 (i32.const 0)))
-    (set_local 0x0e3 (i64.load offset=0x0e3 align=1 (i32.const 0)))
-    (set_local 0x0e4 (i64.load offset=0x0e4 align=1 (i32.const 0)))
-    (set_local 0x0e5 (i64.load offset=0x0e5 align=1 (i32.const 0)))
-    (set_local 0x0e6 (i64.load offset=0x0e6 align=1 (i32.const 0)))
-    (set_local 0x0e7 (i64.load offset=0x0e7 align=1 (i32.const 0)))
-    (set_local 0x0e8 (i64.load offset=0x0e8 align=1 (i32.const 0)))
-    (set_local 0x0e9 (i64.load offset=0x0e9 align=1 (i32.const 0)))
-    (set_local 0x0ea (i64.load offset=0x0ea align=1 (i32.const 0)))
-    (set_local 0x0eb (i64.load offset=0x0eb align=1 (i32.const 0)))
-    (set_local 0x0ec (i64.load offset=0x0ec align=1 (i32.const 0)))
-    (set_local 0x0ed (i64.load offset=0x0ed align=1 (i32.const 0)))
-    (set_local 0x0ee (i64.load offset=0x0ee align=1 (i32.const 0)))
-    (set_local 0x0ef (i64.load offset=0x0ef align=1 (i32.const 0)))
-    (set_local 0x0f0 (i64.load offset=0x0f0 align=1 (i32.const 0)))
-    (set_local 0x0f1 (i64.load offset=0x0f1 align=1 (i32.const 0)))
-    (set_local 0x0f2 (i64.load offset=0x0f2 align=1 (i32.const 0)))
-    (set_local 0x0f3 (i64.load offset=0x0f3 align=1 (i32.const 0)))
-    (set_local 0x0f4 (i64.load offset=0x0f4 align=1 (i32.const 0)))
-    (set_local 0x0f5 (i64.load offset=0x0f5 align=1 (i32.const 0)))
-    (set_local 0x0f6 (i64.load offset=0x0f6 align=1 (i32.const 0)))
-    (set_local 0x0f7 (i64.load offset=0x0f7 align=1 (i32.const 0)))
-    (set_local 0x0f8 (i64.load offset=0x0f8 align=1 (i32.const 0)))
-    (set_local 0x0f9 (i64.load offset=0x0f9 align=1 (i32.const 0)))
-    (set_local 0x0fa (i64.load offset=0x0fa align=1 (i32.const 0)))
-    (set_local 0x0fb (i64.load offset=0x0fb align=1 (i32.const 0)))
-    (set_local 0x0fc (i64.load offset=0x0fc align=1 (i32.const 0)))
-    (set_local 0x0fd (i64.load offset=0x0fd align=1 (i32.const 0)))
-    (set_local 0x0fe (i64.load offset=0x0fe align=1 (i32.const 0)))
-    (set_local 0x0ff (i64.load offset=0x0ff align=1 (i32.const 0)))
-    (set_local 0x100 (i64.load offset=0x100 align=1 (i32.const 0)))
-    (set_local 0x101 (i64.load offset=0x101 align=1 (i32.const 0)))
-    (set_local 0x102 (i64.load offset=0x102 align=1 (i32.const 0)))
-    (set_local 0x103 (i64.load offset=0x103 align=1 (i32.const 0)))
-    (set_local 0x104 (i64.load offset=0x104 align=1 (i32.const 0)))
-    (set_local 0x105 (i64.load offset=0x105 align=1 (i32.const 0)))
-    (set_local 0x106 (i64.load offset=0x106 align=1 (i32.const 0)))
-    (set_local 0x107 (i64.load offset=0x107 align=1 (i32.const 0)))
-    (set_local 0x108 (i64.load offset=0x108 align=1 (i32.const 0)))
-    (set_local 0x109 (i64.load offset=0x109 align=1 (i32.const 0)))
-    (set_local 0x10a (i64.load offset=0x10a align=1 (i32.const 0)))
-    (set_local 0x10b (i64.load offset=0x10b align=1 (i32.const 0)))
-    (set_local 0x10c (i64.load offset=0x10c align=1 (i32.const 0)))
-    (set_local 0x10d (i64.load offset=0x10d align=1 (i32.const 0)))
-    (set_local 0x10e (i64.load offset=0x10e align=1 (i32.const 0)))
-    (set_local 0x10f (i64.load offset=0x10f align=1 (i32.const 0)))
-    (set_local 0x110 (i64.load offset=0x110 align=1 (i32.const 0)))
-    (set_local 0x111 (i64.load offset=0x111 align=1 (i32.const 0)))
-    (set_local 0x112 (i64.load offset=0x112 align=1 (i32.const 0)))
-    (set_local 0x113 (i64.load offset=0x113 align=1 (i32.const 0)))
-    (set_local 0x114 (i64.load offset=0x114 align=1 (i32.const 0)))
-    (set_local 0x115 (i64.load offset=0x115 align=1 (i32.const 0)))
-    (set_local 0x116 (i64.load offset=0x116 align=1 (i32.const 0)))
-    (set_local 0x117 (i64.load offset=0x117 align=1 (i32.const 0)))
-    (set_local 0x118 (i64.load offset=0x118 align=1 (i32.const 0)))
-    (set_local 0x119 (i64.load offset=0x119 align=1 (i32.const 0)))
-    (set_local 0x11a (i64.load offset=0x11a align=1 (i32.const 0)))
-    (set_local 0x11b (i64.load offset=0x11b align=1 (i32.const 0)))
-    (set_local 0x11c (i64.load offset=0x11c align=1 (i32.const 0)))
-    (set_local 0x11d (i64.load offset=0x11d align=1 (i32.const 0)))
-    (set_local 0x11e (i64.load offset=0x11e align=1 (i32.const 0)))
-    (set_local 0x11f (i64.load offset=0x11f align=1 (i32.const 0)))
-    (set_local 0x120 (i64.load offset=0x120 align=1 (i32.const 0)))
-    (set_local 0x121 (i64.load offset=0x121 align=1 (i32.const 0)))
-    (set_local 0x122 (i64.load offset=0x122 align=1 (i32.const 0)))
-    (set_local 0x123 (i64.load offset=0x123 align=1 (i32.const 0)))
-    (set_local 0x124 (i64.load offset=0x124 align=1 (i32.const 0)))
-    (set_local 0x125 (i64.load offset=0x125 align=1 (i32.const 0)))
-    (set_local 0x126 (i64.load offset=0x126 align=1 (i32.const 0)))
-    (set_local 0x127 (i64.load offset=0x127 align=1 (i32.const 0)))
-    (set_local 0x128 (i64.load offset=0x128 align=1 (i32.const 0)))
-    (set_local 0x129 (i64.load offset=0x129 align=1 (i32.const 0)))
-    (set_local 0x12a (i64.load offset=0x12a align=1 (i32.const 0)))
-    (set_local 0x12b (i64.load offset=0x12b align=1 (i32.const 0)))
-    (set_local 0x12c (i64.load offset=0x12c align=1 (i32.const 0)))
-    (set_local 0x12d (i64.load offset=0x12d align=1 (i32.const 0)))
-    (set_local 0x12e (i64.load offset=0x12e align=1 (i32.const 0)))
-    (set_local 0x12f (i64.load offset=0x12f align=1 (i32.const 0)))
-    (set_local 0x130 (i64.load offset=0x130 align=1 (i32.const 0)))
-    (set_local 0x131 (i64.load offset=0x131 align=1 (i32.const 0)))
-    (set_local 0x132 (i64.load offset=0x132 align=1 (i32.const 0)))
-    (set_local 0x133 (i64.load offset=0x133 align=1 (i32.const 0)))
-    (set_local 0x134 (i64.load offset=0x134 align=1 (i32.const 0)))
-    (set_local 0x135 (i64.load offset=0x135 align=1 (i32.const 0)))
-    (set_local 0x136 (i64.load offset=0x136 align=1 (i32.const 0)))
-    (set_local 0x137 (i64.load offset=0x137 align=1 (i32.const 0)))
-    (set_local 0x138 (i64.load offset=0x138 align=1 (i32.const 0)))
-    (set_local 0x139 (i64.load offset=0x139 align=1 (i32.const 0)))
-    (set_local 0x13a (i64.load offset=0x13a align=1 (i32.const 0)))
-    (set_local 0x13b (i64.load offset=0x13b align=1 (i32.const 0)))
-    (set_local 0x13c (i64.load offset=0x13c align=1 (i32.const 0)))
-    (set_local 0x13d (i64.load offset=0x13d align=1 (i32.const 0)))
-    (set_local 0x13e (i64.load offset=0x13e align=1 (i32.const 0)))
-    (set_local 0x13f (i64.load offset=0x13f align=1 (i32.const 0)))
-    (set_local 0x140 (i64.load offset=0x140 align=1 (i32.const 0)))
-    (set_local 0x141 (i64.load offset=0x141 align=1 (i32.const 0)))
-    (set_local 0x142 (i64.load offset=0x142 align=1 (i32.const 0)))
-    (set_local 0x143 (i64.load offset=0x143 align=1 (i32.const 0)))
-    (set_local 0x144 (i64.load offset=0x144 align=1 (i32.const 0)))
-    (set_local 0x145 (i64.load offset=0x145 align=1 (i32.const 0)))
-    (set_local 0x146 (i64.load offset=0x146 align=1 (i32.const 0)))
-    (set_local 0x147 (i64.load offset=0x147 align=1 (i32.const 0)))
-    (set_local 0x148 (i64.load offset=0x148 align=1 (i32.const 0)))
-    (set_local 0x149 (i64.load offset=0x149 align=1 (i32.const 0)))
-    (set_local 0x14a (i64.load offset=0x14a align=1 (i32.const 0)))
-    (set_local 0x14b (i64.load offset=0x14b align=1 (i32.const 0)))
-    (set_local 0x14c (i64.load offset=0x14c align=1 (i32.const 0)))
-    (set_local 0x14d (i64.load offset=0x14d align=1 (i32.const 0)))
-    (set_local 0x14e (i64.load offset=0x14e align=1 (i32.const 0)))
-    (set_local 0x14f (i64.load offset=0x14f align=1 (i32.const 0)))
-    (set_local 0x150 (i64.load offset=0x150 align=1 (i32.const 0)))
-    (set_local 0x151 (i64.load offset=0x151 align=1 (i32.const 0)))
-    (set_local 0x152 (i64.load offset=0x152 align=1 (i32.const 0)))
-    (set_local 0x153 (i64.load offset=0x153 align=1 (i32.const 0)))
-    (set_local 0x154 (i64.load offset=0x154 align=1 (i32.const 0)))
-    (set_local 0x155 (i64.load offset=0x155 align=1 (i32.const 0)))
-    (set_local 0x156 (i64.load offset=0x156 align=1 (i32.const 0)))
-    (set_local 0x157 (i64.load offset=0x157 align=1 (i32.const 0)))
-    (set_local 0x158 (i64.load offset=0x158 align=1 (i32.const 0)))
-    (set_local 0x159 (i64.load offset=0x159 align=1 (i32.const 0)))
-    (set_local 0x15a (i64.load offset=0x15a align=1 (i32.const 0)))
-    (set_local 0x15b (i64.load offset=0x15b align=1 (i32.const 0)))
-    (set_local 0x15c (i64.load offset=0x15c align=1 (i32.const 0)))
-    (set_local 0x15d (i64.load offset=0x15d align=1 (i32.const 0)))
-    (set_local 0x15e (i64.load offset=0x15e align=1 (i32.const 0)))
-    (set_local 0x15f (i64.load offset=0x15f align=1 (i32.const 0)))
-    (set_local 0x160 (i64.load offset=0x160 align=1 (i32.const 0)))
-    (set_local 0x161 (i64.load offset=0x161 align=1 (i32.const 0)))
-    (set_local 0x162 (i64.load offset=0x162 align=1 (i32.const 0)))
-    (set_local 0x163 (i64.load offset=0x163 align=1 (i32.const 0)))
-    (set_local 0x164 (i64.load offset=0x164 align=1 (i32.const 0)))
-    (set_local 0x165 (i64.load offset=0x165 align=1 (i32.const 0)))
-    (set_local 0x166 (i64.load offset=0x166 align=1 (i32.const 0)))
-    (set_local 0x167 (i64.load offset=0x167 align=1 (i32.const 0)))
-    (set_local 0x168 (i64.load offset=0x168 align=1 (i32.const 0)))
-    (set_local 0x169 (i64.load offset=0x169 align=1 (i32.const 0)))
-    (set_local 0x16a (i64.load offset=0x16a align=1 (i32.const 0)))
-    (set_local 0x16b (i64.load offset=0x16b align=1 (i32.const 0)))
-    (set_local 0x16c (i64.load offset=0x16c align=1 (i32.const 0)))
-    (set_local 0x16d (i64.load offset=0x16d align=1 (i32.const 0)))
-    (set_local 0x16e (i64.load offset=0x16e align=1 (i32.const 0)))
-    (set_local 0x16f (i64.load offset=0x16f align=1 (i32.const 0)))
-    (set_local 0x170 (i64.load offset=0x170 align=1 (i32.const 0)))
-    (set_local 0x171 (i64.load offset=0x171 align=1 (i32.const 0)))
-    (set_local 0x172 (i64.load offset=0x172 align=1 (i32.const 0)))
-    (set_local 0x173 (i64.load offset=0x173 align=1 (i32.const 0)))
-    (set_local 0x174 (i64.load offset=0x174 align=1 (i32.const 0)))
-    (set_local 0x175 (i64.load offset=0x175 align=1 (i32.const 0)))
-    (set_local 0x176 (i64.load offset=0x176 align=1 (i32.const 0)))
-    (set_local 0x177 (i64.load offset=0x177 align=1 (i32.const 0)))
-    (set_local 0x178 (i64.load offset=0x178 align=1 (i32.const 0)))
-    (set_local 0x179 (i64.load offset=0x179 align=1 (i32.const 0)))
-    (set_local 0x17a (i64.load offset=0x17a align=1 (i32.const 0)))
-    (set_local 0x17b (i64.load offset=0x17b align=1 (i32.const 0)))
-    (set_local 0x17c (i64.load offset=0x17c align=1 (i32.const 0)))
-    (set_local 0x17d (i64.load offset=0x17d align=1 (i32.const 0)))
-    (set_local 0x17e (i64.load offset=0x17e align=1 (i32.const 0)))
-    (set_local 0x17f (i64.load offset=0x17f align=1 (i32.const 0)))
-    (set_local 0x180 (i64.load offset=0x180 align=1 (i32.const 0)))
-    (set_local 0x181 (i64.load offset=0x181 align=1 (i32.const 0)))
-    (set_local 0x182 (i64.load offset=0x182 align=1 (i32.const 0)))
-    (set_local 0x183 (i64.load offset=0x183 align=1 (i32.const 0)))
-    (set_local 0x184 (i64.load offset=0x184 align=1 (i32.const 0)))
-    (set_local 0x185 (i64.load offset=0x185 align=1 (i32.const 0)))
-    (set_local 0x186 (i64.load offset=0x186 align=1 (i32.const 0)))
-    (set_local 0x187 (i64.load offset=0x187 align=1 (i32.const 0)))
-    (set_local 0x188 (i64.load offset=0x188 align=1 (i32.const 0)))
-    (set_local 0x189 (i64.load offset=0x189 align=1 (i32.const 0)))
-    (set_local 0x18a (i64.load offset=0x18a align=1 (i32.const 0)))
-    (set_local 0x18b (i64.load offset=0x18b align=1 (i32.const 0)))
-    (set_local 0x18c (i64.load offset=0x18c align=1 (i32.const 0)))
-    (set_local 0x18d (i64.load offset=0x18d align=1 (i32.const 0)))
-    (set_local 0x18e (i64.load offset=0x18e align=1 (i32.const 0)))
-    (set_local 0x18f (i64.load offset=0x18f align=1 (i32.const 0)))
-    (set_local 0x190 (i64.load offset=0x190 align=1 (i32.const 0)))
-    (set_local 0x191 (i64.load offset=0x191 align=1 (i32.const 0)))
-    (set_local 0x192 (i64.load offset=0x192 align=1 (i32.const 0)))
-    (set_local 0x193 (i64.load offset=0x193 align=1 (i32.const 0)))
-    (set_local 0x194 (i64.load offset=0x194 align=1 (i32.const 0)))
-    (set_local 0x195 (i64.load offset=0x195 align=1 (i32.const 0)))
-    (set_local 0x196 (i64.load offset=0x196 align=1 (i32.const 0)))
-    (set_local 0x197 (i64.load offset=0x197 align=1 (i32.const 0)))
-    (set_local 0x198 (i64.load offset=0x198 align=1 (i32.const 0)))
-    (set_local 0x199 (i64.load offset=0x199 align=1 (i32.const 0)))
-    (set_local 0x19a (i64.load offset=0x19a align=1 (i32.const 0)))
-    (set_local 0x19b (i64.load offset=0x19b align=1 (i32.const 0)))
-    (set_local 0x19c (i64.load offset=0x19c align=1 (i32.const 0)))
-    (set_local 0x19d (i64.load offset=0x19d align=1 (i32.const 0)))
-    (set_local 0x19e (i64.load offset=0x19e align=1 (i32.const 0)))
-    (set_local 0x19f (i64.load offset=0x19f align=1 (i32.const 0)))
-    (set_local 0x1a0 (i64.load offset=0x1a0 align=1 (i32.const 0)))
-    (set_local 0x1a1 (i64.load offset=0x1a1 align=1 (i32.const 0)))
-    (set_local 0x1a2 (i64.load offset=0x1a2 align=1 (i32.const 0)))
-    (set_local 0x1a3 (i64.load offset=0x1a3 align=1 (i32.const 0)))
-    (set_local 0x1a4 (i64.load offset=0x1a4 align=1 (i32.const 0)))
-    (set_local 0x1a5 (i64.load offset=0x1a5 align=1 (i32.const 0)))
-    (set_local 0x1a6 (i64.load offset=0x1a6 align=1 (i32.const 0)))
-    (set_local 0x1a7 (i64.load offset=0x1a7 align=1 (i32.const 0)))
-    (set_local 0x1a8 (i64.load offset=0x1a8 align=1 (i32.const 0)))
-    (set_local 0x1a9 (i64.load offset=0x1a9 align=1 (i32.const 0)))
-    (set_local 0x1aa (i64.load offset=0x1aa align=1 (i32.const 0)))
-    (set_local 0x1ab (i64.load offset=0x1ab align=1 (i32.const 0)))
-    (set_local 0x1ac (i64.load offset=0x1ac align=1 (i32.const 0)))
-    (set_local 0x1ad (i64.load offset=0x1ad align=1 (i32.const 0)))
-    (set_local 0x1ae (i64.load offset=0x1ae align=1 (i32.const 0)))
-    (set_local 0x1af (i64.load offset=0x1af align=1 (i32.const 0)))
-    (set_local 0x1b0 (i64.load offset=0x1b0 align=1 (i32.const 0)))
-    (set_local 0x1b1 (i64.load offset=0x1b1 align=1 (i32.const 0)))
-    (set_local 0x1b2 (i64.load offset=0x1b2 align=1 (i32.const 0)))
-    (set_local 0x1b3 (i64.load offset=0x1b3 align=1 (i32.const 0)))
-    (set_local 0x1b4 (i64.load offset=0x1b4 align=1 (i32.const 0)))
-    (set_local 0x1b5 (i64.load offset=0x1b5 align=1 (i32.const 0)))
-    (set_local 0x1b6 (i64.load offset=0x1b6 align=1 (i32.const 0)))
-    (set_local 0x1b7 (i64.load offset=0x1b7 align=1 (i32.const 0)))
-    (set_local 0x1b8 (i64.load offset=0x1b8 align=1 (i32.const 0)))
-    (set_local 0x1b9 (i64.load offset=0x1b9 align=1 (i32.const 0)))
-    (set_local 0x1ba (i64.load offset=0x1ba align=1 (i32.const 0)))
-    (set_local 0x1bb (i64.load offset=0x1bb align=1 (i32.const 0)))
-    (set_local 0x1bc (i64.load offset=0x1bc align=1 (i32.const 0)))
-    (set_local 0x1bd (i64.load offset=0x1bd align=1 (i32.const 0)))
-    (set_local 0x1be (i64.load offset=0x1be align=1 (i32.const 0)))
-    (set_local 0x1bf (i64.load offset=0x1bf align=1 (i32.const 0)))
-    (set_local 0x1c0 (i64.load offset=0x1c0 align=1 (i32.const 0)))
-    (set_local 0x1c1 (i64.load offset=0x1c1 align=1 (i32.const 0)))
-    (set_local 0x1c2 (i64.load offset=0x1c2 align=1 (i32.const 0)))
-    (set_local 0x1c3 (i64.load offset=0x1c3 align=1 (i32.const 0)))
-    (set_local 0x1c4 (i64.load offset=0x1c4 align=1 (i32.const 0)))
-    (set_local 0x1c5 (i64.load offset=0x1c5 align=1 (i32.const 0)))
-    (set_local 0x1c6 (i64.load offset=0x1c6 align=1 (i32.const 0)))
-    (set_local 0x1c7 (i64.load offset=0x1c7 align=1 (i32.const 0)))
-    (set_local 0x1c8 (i64.load offset=0x1c8 align=1 (i32.const 0)))
-    (set_local 0x1c9 (i64.load offset=0x1c9 align=1 (i32.const 0)))
-    (set_local 0x1ca (i64.load offset=0x1ca align=1 (i32.const 0)))
-    (set_local 0x1cb (i64.load offset=0x1cb align=1 (i32.const 0)))
-    (set_local 0x1cc (i64.load offset=0x1cc align=1 (i32.const 0)))
-    (set_local 0x1cd (i64.load offset=0x1cd align=1 (i32.const 0)))
-    (set_local 0x1ce (i64.load offset=0x1ce align=1 (i32.const 0)))
-    (set_local 0x1cf (i64.load offset=0x1cf align=1 (i32.const 0)))
-    (set_local 0x1d0 (i64.load offset=0x1d0 align=1 (i32.const 0)))
-    (set_local 0x1d1 (i64.load offset=0x1d1 align=1 (i32.const 0)))
-    (set_local 0x1d2 (i64.load offset=0x1d2 align=1 (i32.const 0)))
-    (set_local 0x1d3 (i64.load offset=0x1d3 align=1 (i32.const 0)))
-    (set_local 0x1d4 (i64.load offset=0x1d4 align=1 (i32.const 0)))
-    (set_local 0x1d5 (i64.load offset=0x1d5 align=1 (i32.const 0)))
-    (set_local 0x1d6 (i64.load offset=0x1d6 align=1 (i32.const 0)))
-    (set_local 0x1d7 (i64.load offset=0x1d7 align=1 (i32.const 0)))
-    (set_local 0x1d8 (i64.load offset=0x1d8 align=1 (i32.const 0)))
-    (set_local 0x1d9 (i64.load offset=0x1d9 align=1 (i32.const 0)))
-    (set_local 0x1da (i64.load offset=0x1da align=1 (i32.const 0)))
-    (set_local 0x1db (i64.load offset=0x1db align=1 (i32.const 0)))
-    (set_local 0x1dc (i64.load offset=0x1dc align=1 (i32.const 0)))
-    (set_local 0x1dd (i64.load offset=0x1dd align=1 (i32.const 0)))
-    (set_local 0x1de (i64.load offset=0x1de align=1 (i32.const 0)))
-    (set_local 0x1df (i64.load offset=0x1df align=1 (i32.const 0)))
-    (set_local 0x1e0 (i64.load offset=0x1e0 align=1 (i32.const 0)))
-    (set_local 0x1e1 (i64.load offset=0x1e1 align=1 (i32.const 0)))
-    (set_local 0x1e2 (i64.load offset=0x1e2 align=1 (i32.const 0)))
-    (set_local 0x1e3 (i64.load offset=0x1e3 align=1 (i32.const 0)))
-    (set_local 0x1e4 (i64.load offset=0x1e4 align=1 (i32.const 0)))
-    (set_local 0x1e5 (i64.load offset=0x1e5 align=1 (i32.const 0)))
-    (set_local 0x1e6 (i64.load offset=0x1e6 align=1 (i32.const 0)))
-    (set_local 0x1e7 (i64.load offset=0x1e7 align=1 (i32.const 0)))
-    (set_local 0x1e8 (i64.load offset=0x1e8 align=1 (i32.const 0)))
-    (set_local 0x1e9 (i64.load offset=0x1e9 align=1 (i32.const 0)))
-    (set_local 0x1ea (i64.load offset=0x1ea align=1 (i32.const 0)))
-    (set_local 0x1eb (i64.load offset=0x1eb align=1 (i32.const 0)))
-    (set_local 0x1ec (i64.load offset=0x1ec align=1 (i32.const 0)))
-    (set_local 0x1ed (i64.load offset=0x1ed align=1 (i32.const 0)))
-    (set_local 0x1ee (i64.load offset=0x1ee align=1 (i32.const 0)))
-    (set_local 0x1ef (i64.load offset=0x1ef align=1 (i32.const 0)))
-    (set_local 0x1f0 (i64.load offset=0x1f0 align=1 (i32.const 0)))
-    (set_local 0x1f1 (i64.load offset=0x1f1 align=1 (i32.const 0)))
-    (set_local 0x1f2 (i64.load offset=0x1f2 align=1 (i32.const 0)))
-    (set_local 0x1f3 (i64.load offset=0x1f3 align=1 (i32.const 0)))
-    (set_local 0x1f4 (i64.load offset=0x1f4 align=1 (i32.const 0)))
-    (set_local 0x1f5 (i64.load offset=0x1f5 align=1 (i32.const 0)))
-    (set_local 0x1f6 (i64.load offset=0x1f6 align=1 (i32.const 0)))
-    (set_local 0x1f7 (i64.load offset=0x1f7 align=1 (i32.const 0)))
-    (set_local 0x1f8 (i64.load offset=0x1f8 align=1 (i32.const 0)))
-    (set_local 0x1f9 (i64.load offset=0x1f9 align=1 (i32.const 0)))
-    (set_local 0x1fa (i64.load offset=0x1fa align=1 (i32.const 0)))
-    (set_local 0x1fb (i64.load offset=0x1fb align=1 (i32.const 0)))
-    (set_local 0x1fc (i64.load offset=0x1fc align=1 (i32.const 0)))
-    (set_local 0x1fd (i64.load offset=0x1fd align=1 (i32.const 0)))
-    (set_local 0x1fe (i64.load offset=0x1fe align=1 (i32.const 0)))
-    (set_local 0x1ff (i64.load offset=0x1ff align=1 (i32.const 0)))
-    (set_local 0x200 (i64.load offset=0x200 align=1 (i32.const 0)))
-    (set_local 0x201 (i64.load offset=0x201 align=1 (i32.const 0)))
-    (set_local 0x202 (i64.load offset=0x202 align=1 (i32.const 0)))
-    (set_local 0x203 (i64.load offset=0x203 align=1 (i32.const 0)))
-    (set_local 0x204 (i64.load offset=0x204 align=1 (i32.const 0)))
-    (set_local 0x205 (i64.load offset=0x205 align=1 (i32.const 0)))
-    (set_local 0x206 (i64.load offset=0x206 align=1 (i32.const 0)))
-    (set_local 0x207 (i64.load offset=0x207 align=1 (i32.const 0)))
-    (set_local 0x208 (i64.load offset=0x208 align=1 (i32.const 0)))
-    (set_local 0x209 (i64.load offset=0x209 align=1 (i32.const 0)))
-    (set_local 0x20a (i64.load offset=0x20a align=1 (i32.const 0)))
-    (set_local 0x20b (i64.load offset=0x20b align=1 (i32.const 0)))
-    (set_local 0x20c (i64.load offset=0x20c align=1 (i32.const 0)))
-    (set_local 0x20d (i64.load offset=0x20d align=1 (i32.const 0)))
-    (set_local 0x20e (i64.load offset=0x20e align=1 (i32.const 0)))
-    (set_local 0x20f (i64.load offset=0x20f align=1 (i32.const 0)))
-    (set_local 0x210 (i64.load offset=0x210 align=1 (i32.const 0)))
-    (set_local 0x211 (i64.load offset=0x211 align=1 (i32.const 0)))
-    (set_local 0x212 (i64.load offset=0x212 align=1 (i32.const 0)))
-    (set_local 0x213 (i64.load offset=0x213 align=1 (i32.const 0)))
-    (set_local 0x214 (i64.load offset=0x214 align=1 (i32.const 0)))
-    (set_local 0x215 (i64.load offset=0x215 align=1 (i32.const 0)))
-    (set_local 0x216 (i64.load offset=0x216 align=1 (i32.const 0)))
-    (set_local 0x217 (i64.load offset=0x217 align=1 (i32.const 0)))
-    (set_local 0x218 (i64.load offset=0x218 align=1 (i32.const 0)))
-    (set_local 0x219 (i64.load offset=0x219 align=1 (i32.const 0)))
-    (set_local 0x21a (i64.load offset=0x21a align=1 (i32.const 0)))
-    (set_local 0x21b (i64.load offset=0x21b align=1 (i32.const 0)))
-    (set_local 0x21c (i64.load offset=0x21c align=1 (i32.const 0)))
-    (set_local 0x21d (i64.load offset=0x21d align=1 (i32.const 0)))
-    (set_local 0x21e (i64.load offset=0x21e align=1 (i32.const 0)))
-    (set_local 0x21f (i64.load offset=0x21f align=1 (i32.const 0)))
-    (set_local 0x220 (i64.load offset=0x220 align=1 (i32.const 0)))
-    (set_local 0x221 (i64.load offset=0x221 align=1 (i32.const 0)))
-    (set_local 0x222 (i64.load offset=0x222 align=1 (i32.const 0)))
-    (set_local 0x223 (i64.load offset=0x223 align=1 (i32.const 0)))
-    (set_local 0x224 (i64.load offset=0x224 align=1 (i32.const 0)))
-    (set_local 0x225 (i64.load offset=0x225 align=1 (i32.const 0)))
-    (set_local 0x226 (i64.load offset=0x226 align=1 (i32.const 0)))
-    (set_local 0x227 (i64.load offset=0x227 align=1 (i32.const 0)))
-    (set_local 0x228 (i64.load offset=0x228 align=1 (i32.const 0)))
-    (set_local 0x229 (i64.load offset=0x229 align=1 (i32.const 0)))
-    (set_local 0x22a (i64.load offset=0x22a align=1 (i32.const 0)))
-    (set_local 0x22b (i64.load offset=0x22b align=1 (i32.const 0)))
-    (set_local 0x22c (i64.load offset=0x22c align=1 (i32.const 0)))
-    (set_local 0x22d (i64.load offset=0x22d align=1 (i32.const 0)))
-    (set_local 0x22e (i64.load offset=0x22e align=1 (i32.const 0)))
-    (set_local 0x22f (i64.load offset=0x22f align=1 (i32.const 0)))
-    (set_local 0x230 (i64.load offset=0x230 align=1 (i32.const 0)))
-    (set_local 0x231 (i64.load offset=0x231 align=1 (i32.const 0)))
-    (set_local 0x232 (i64.load offset=0x232 align=1 (i32.const 0)))
-    (set_local 0x233 (i64.load offset=0x233 align=1 (i32.const 0)))
-    (set_local 0x234 (i64.load offset=0x234 align=1 (i32.const 0)))
-    (set_local 0x235 (i64.load offset=0x235 align=1 (i32.const 0)))
-    (set_local 0x236 (i64.load offset=0x236 align=1 (i32.const 0)))
-    (set_local 0x237 (i64.load offset=0x237 align=1 (i32.const 0)))
-    (set_local 0x238 (i64.load offset=0x238 align=1 (i32.const 0)))
-    (set_local 0x239 (i64.load offset=0x239 align=1 (i32.const 0)))
-    (set_local 0x23a (i64.load offset=0x23a align=1 (i32.const 0)))
-    (set_local 0x23b (i64.load offset=0x23b align=1 (i32.const 0)))
-    (set_local 0x23c (i64.load offset=0x23c align=1 (i32.const 0)))
-    (set_local 0x23d (i64.load offset=0x23d align=1 (i32.const 0)))
-    (set_local 0x23e (i64.load offset=0x23e align=1 (i32.const 0)))
-    (set_local 0x23f (i64.load offset=0x23f align=1 (i32.const 0)))
-    (set_local 0x240 (i64.load offset=0x240 align=1 (i32.const 0)))
-    (set_local 0x241 (i64.load offset=0x241 align=1 (i32.const 0)))
-    (set_local 0x242 (i64.load offset=0x242 align=1 (i32.const 0)))
-    (set_local 0x243 (i64.load offset=0x243 align=1 (i32.const 0)))
-    (set_local 0x244 (i64.load offset=0x244 align=1 (i32.const 0)))
-    (set_local 0x245 (i64.load offset=0x245 align=1 (i32.const 0)))
-    (set_local 0x246 (i64.load offset=0x246 align=1 (i32.const 0)))
-    (set_local 0x247 (i64.load offset=0x247 align=1 (i32.const 0)))
-    (set_local 0x248 (i64.load offset=0x248 align=1 (i32.const 0)))
-    (set_local 0x249 (i64.load offset=0x249 align=1 (i32.const 0)))
-    (set_local 0x24a (i64.load offset=0x24a align=1 (i32.const 0)))
-    (set_local 0x24b (i64.load offset=0x24b align=1 (i32.const 0)))
-    (set_local 0x24c (i64.load offset=0x24c align=1 (i32.const 0)))
-    (set_local 0x24d (i64.load offset=0x24d align=1 (i32.const 0)))
-    (set_local 0x24e (i64.load offset=0x24e align=1 (i32.const 0)))
-    (set_local 0x24f (i64.load offset=0x24f align=1 (i32.const 0)))
-    (set_local 0x250 (i64.load offset=0x250 align=1 (i32.const 0)))
-    (set_local 0x251 (i64.load offset=0x251 align=1 (i32.const 0)))
-    (set_local 0x252 (i64.load offset=0x252 align=1 (i32.const 0)))
-    (set_local 0x253 (i64.load offset=0x253 align=1 (i32.const 0)))
-    (set_local 0x254 (i64.load offset=0x254 align=1 (i32.const 0)))
-    (set_local 0x255 (i64.load offset=0x255 align=1 (i32.const 0)))
-    (set_local 0x256 (i64.load offset=0x256 align=1 (i32.const 0)))
-    (set_local 0x257 (i64.load offset=0x257 align=1 (i32.const 0)))
-    (set_local 0x258 (i64.load offset=0x258 align=1 (i32.const 0)))
-    (set_local 0x259 (i64.load offset=0x259 align=1 (i32.const 0)))
-    (set_local 0x25a (i64.load offset=0x25a align=1 (i32.const 0)))
-    (set_local 0x25b (i64.load offset=0x25b align=1 (i32.const 0)))
-    (set_local 0x25c (i64.load offset=0x25c align=1 (i32.const 0)))
-    (set_local 0x25d (i64.load offset=0x25d align=1 (i32.const 0)))
-    (set_local 0x25e (i64.load offset=0x25e align=1 (i32.const 0)))
-    (set_local 0x25f (i64.load offset=0x25f align=1 (i32.const 0)))
-    (set_local 0x260 (i64.load offset=0x260 align=1 (i32.const 0)))
-    (set_local 0x261 (i64.load offset=0x261 align=1 (i32.const 0)))
-    (set_local 0x262 (i64.load offset=0x262 align=1 (i32.const 0)))
-    (set_local 0x263 (i64.load offset=0x263 align=1 (i32.const 0)))
-    (set_local 0x264 (i64.load offset=0x264 align=1 (i32.const 0)))
-    (set_local 0x265 (i64.load offset=0x265 align=1 (i32.const 0)))
-    (set_local 0x266 (i64.load offset=0x266 align=1 (i32.const 0)))
-    (set_local 0x267 (i64.load offset=0x267 align=1 (i32.const 0)))
-    (set_local 0x268 (i64.load offset=0x268 align=1 (i32.const 0)))
-    (set_local 0x269 (i64.load offset=0x269 align=1 (i32.const 0)))
-    (set_local 0x26a (i64.load offset=0x26a align=1 (i32.const 0)))
-    (set_local 0x26b (i64.load offset=0x26b align=1 (i32.const 0)))
-    (set_local 0x26c (i64.load offset=0x26c align=1 (i32.const 0)))
-    (set_local 0x26d (i64.load offset=0x26d align=1 (i32.const 0)))
-    (set_local 0x26e (i64.load offset=0x26e align=1 (i32.const 0)))
-    (set_local 0x26f (i64.load offset=0x26f align=1 (i32.const 0)))
-    (set_local 0x270 (i64.load offset=0x270 align=1 (i32.const 0)))
-    (set_local 0x271 (i64.load offset=0x271 align=1 (i32.const 0)))
-    (set_local 0x272 (i64.load offset=0x272 align=1 (i32.const 0)))
-    (set_local 0x273 (i64.load offset=0x273 align=1 (i32.const 0)))
-    (set_local 0x274 (i64.load offset=0x274 align=1 (i32.const 0)))
-    (set_local 0x275 (i64.load offset=0x275 align=1 (i32.const 0)))
-    (set_local 0x276 (i64.load offset=0x276 align=1 (i32.const 0)))
-    (set_local 0x277 (i64.load offset=0x277 align=1 (i32.const 0)))
-    (set_local 0x278 (i64.load offset=0x278 align=1 (i32.const 0)))
-    (set_local 0x279 (i64.load offset=0x279 align=1 (i32.const 0)))
-    (set_local 0x27a (i64.load offset=0x27a align=1 (i32.const 0)))
-    (set_local 0x27b (i64.load offset=0x27b align=1 (i32.const 0)))
-    (set_local 0x27c (i64.load offset=0x27c align=1 (i32.const 0)))
-    (set_local 0x27d (i64.load offset=0x27d align=1 (i32.const 0)))
-    (set_local 0x27e (i64.load offset=0x27e align=1 (i32.const 0)))
-    (set_local 0x27f (i64.load offset=0x27f align=1 (i32.const 0)))
-    (set_local 0x280 (i64.load offset=0x280 align=1 (i32.const 0)))
-    (set_local 0x281 (i64.load offset=0x281 align=1 (i32.const 0)))
-    (set_local 0x282 (i64.load offset=0x282 align=1 (i32.const 0)))
-    (set_local 0x283 (i64.load offset=0x283 align=1 (i32.const 0)))
-    (set_local 0x284 (i64.load offset=0x284 align=1 (i32.const 0)))
-    (set_local 0x285 (i64.load offset=0x285 align=1 (i32.const 0)))
-    (set_local 0x286 (i64.load offset=0x286 align=1 (i32.const 0)))
-    (set_local 0x287 (i64.load offset=0x287 align=1 (i32.const 0)))
-    (set_local 0x288 (i64.load offset=0x288 align=1 (i32.const 0)))
-    (set_local 0x289 (i64.load offset=0x289 align=1 (i32.const 0)))
-    (set_local 0x28a (i64.load offset=0x28a align=1 (i32.const 0)))
-    (set_local 0x28b (i64.load offset=0x28b align=1 (i32.const 0)))
-    (set_local 0x28c (i64.load offset=0x28c align=1 (i32.const 0)))
-    (set_local 0x28d (i64.load offset=0x28d align=1 (i32.const 0)))
-    (set_local 0x28e (i64.load offset=0x28e align=1 (i32.const 0)))
-    (set_local 0x28f (i64.load offset=0x28f align=1 (i32.const 0)))
-    (set_local 0x290 (i64.load offset=0x290 align=1 (i32.const 0)))
-    (set_local 0x291 (i64.load offset=0x291 align=1 (i32.const 0)))
-    (set_local 0x292 (i64.load offset=0x292 align=1 (i32.const 0)))
-    (set_local 0x293 (i64.load offset=0x293 align=1 (i32.const 0)))
-    (set_local 0x294 (i64.load offset=0x294 align=1 (i32.const 0)))
-    (set_local 0x295 (i64.load offset=0x295 align=1 (i32.const 0)))
-    (set_local 0x296 (i64.load offset=0x296 align=1 (i32.const 0)))
-    (set_local 0x297 (i64.load offset=0x297 align=1 (i32.const 0)))
-    (set_local 0x298 (i64.load offset=0x298 align=1 (i32.const 0)))
-    (set_local 0x299 (i64.load offset=0x299 align=1 (i32.const 0)))
-    (set_local 0x29a (i64.load offset=0x29a align=1 (i32.const 0)))
-    (set_local 0x29b (i64.load offset=0x29b align=1 (i32.const 0)))
-    (set_local 0x29c (i64.load offset=0x29c align=1 (i32.const 0)))
-    (set_local 0x29d (i64.load offset=0x29d align=1 (i32.const 0)))
-    (set_local 0x29e (i64.load offset=0x29e align=1 (i32.const 0)))
-    (set_local 0x29f (i64.load offset=0x29f align=1 (i32.const 0)))
-    (set_local 0x2a0 (i64.load offset=0x2a0 align=1 (i32.const 0)))
-    (set_local 0x2a1 (i64.load offset=0x2a1 align=1 (i32.const 0)))
-    (set_local 0x2a2 (i64.load offset=0x2a2 align=1 (i32.const 0)))
-    (set_local 0x2a3 (i64.load offset=0x2a3 align=1 (i32.const 0)))
-    (set_local 0x2a4 (i64.load offset=0x2a4 align=1 (i32.const 0)))
-    (set_local 0x2a5 (i64.load offset=0x2a5 align=1 (i32.const 0)))
-    (set_local 0x2a6 (i64.load offset=0x2a6 align=1 (i32.const 0)))
-    (set_local 0x2a7 (i64.load offset=0x2a7 align=1 (i32.const 0)))
-    (set_local 0x2a8 (i64.load offset=0x2a8 align=1 (i32.const 0)))
-    (set_local 0x2a9 (i64.load offset=0x2a9 align=1 (i32.const 0)))
-    (set_local 0x2aa (i64.load offset=0x2aa align=1 (i32.const 0)))
-    (set_local 0x2ab (i64.load offset=0x2ab align=1 (i32.const 0)))
-    (set_local 0x2ac (i64.load offset=0x2ac align=1 (i32.const 0)))
-    (set_local 0x2ad (i64.load offset=0x2ad align=1 (i32.const 0)))
-    (set_local 0x2ae (i64.load offset=0x2ae align=1 (i32.const 0)))
-    (set_local 0x2af (i64.load offset=0x2af align=1 (i32.const 0)))
-    (set_local 0x2b0 (i64.load offset=0x2b0 align=1 (i32.const 0)))
-    (set_local 0x2b1 (i64.load offset=0x2b1 align=1 (i32.const 0)))
-    (set_local 0x2b2 (i64.load offset=0x2b2 align=1 (i32.const 0)))
-    (set_local 0x2b3 (i64.load offset=0x2b3 align=1 (i32.const 0)))
-    (set_local 0x2b4 (i64.load offset=0x2b4 align=1 (i32.const 0)))
-    (set_local 0x2b5 (i64.load offset=0x2b5 align=1 (i32.const 0)))
-    (set_local 0x2b6 (i64.load offset=0x2b6 align=1 (i32.const 0)))
-    (set_local 0x2b7 (i64.load offset=0x2b7 align=1 (i32.const 0)))
-    (set_local 0x2b8 (i64.load offset=0x2b8 align=1 (i32.const 0)))
-    (set_local 0x2b9 (i64.load offset=0x2b9 align=1 (i32.const 0)))
-    (set_local 0x2ba (i64.load offset=0x2ba align=1 (i32.const 0)))
-    (set_local 0x2bb (i64.load offset=0x2bb align=1 (i32.const 0)))
-    (set_local 0x2bc (i64.load offset=0x2bc align=1 (i32.const 0)))
-    (set_local 0x2bd (i64.load offset=0x2bd align=1 (i32.const 0)))
-    (set_local 0x2be (i64.load offset=0x2be align=1 (i32.const 0)))
-    (set_local 0x2bf (i64.load offset=0x2bf align=1 (i32.const 0)))
-    (set_local 0x2c0 (i64.load offset=0x2c0 align=1 (i32.const 0)))
-    (set_local 0x2c1 (i64.load offset=0x2c1 align=1 (i32.const 0)))
-    (set_local 0x2c2 (i64.load offset=0x2c2 align=1 (i32.const 0)))
-    (set_local 0x2c3 (i64.load offset=0x2c3 align=1 (i32.const 0)))
-    (set_local 0x2c4 (i64.load offset=0x2c4 align=1 (i32.const 0)))
-    (set_local 0x2c5 (i64.load offset=0x2c5 align=1 (i32.const 0)))
-    (set_local 0x2c6 (i64.load offset=0x2c6 align=1 (i32.const 0)))
-    (set_local 0x2c7 (i64.load offset=0x2c7 align=1 (i32.const 0)))
-    (set_local 0x2c8 (i64.load offset=0x2c8 align=1 (i32.const 0)))
-    (set_local 0x2c9 (i64.load offset=0x2c9 align=1 (i32.const 0)))
-    (set_local 0x2ca (i64.load offset=0x2ca align=1 (i32.const 0)))
-    (set_local 0x2cb (i64.load offset=0x2cb align=1 (i32.const 0)))
-    (set_local 0x2cc (i64.load offset=0x2cc align=1 (i32.const 0)))
-    (set_local 0x2cd (i64.load offset=0x2cd align=1 (i32.const 0)))
-    (set_local 0x2ce (i64.load offset=0x2ce align=1 (i32.const 0)))
-    (set_local 0x2cf (i64.load offset=0x2cf align=1 (i32.const 0)))
-    (set_local 0x2d0 (i64.load offset=0x2d0 align=1 (i32.const 0)))
-    (set_local 0x2d1 (i64.load offset=0x2d1 align=1 (i32.const 0)))
-    (set_local 0x2d2 (i64.load offset=0x2d2 align=1 (i32.const 0)))
-    (set_local 0x2d3 (i64.load offset=0x2d3 align=1 (i32.const 0)))
-    (set_local 0x2d4 (i64.load offset=0x2d4 align=1 (i32.const 0)))
-    (set_local 0x2d5 (i64.load offset=0x2d5 align=1 (i32.const 0)))
-    (set_local 0x2d6 (i64.load offset=0x2d6 align=1 (i32.const 0)))
-    (set_local 0x2d7 (i64.load offset=0x2d7 align=1 (i32.const 0)))
-    (set_local 0x2d8 (i64.load offset=0x2d8 align=1 (i32.const 0)))
-    (set_local 0x2d9 (i64.load offset=0x2d9 align=1 (i32.const 0)))
-    (set_local 0x2da (i64.load offset=0x2da align=1 (i32.const 0)))
-    (set_local 0x2db (i64.load offset=0x2db align=1 (i32.const 0)))
-    (set_local 0x2dc (i64.load offset=0x2dc align=1 (i32.const 0)))
-    (set_local 0x2dd (i64.load offset=0x2dd align=1 (i32.const 0)))
-    (set_local 0x2de (i64.load offset=0x2de align=1 (i32.const 0)))
-    (set_local 0x2df (i64.load offset=0x2df align=1 (i32.const 0)))
-    (set_local 0x2e0 (i64.load offset=0x2e0 align=1 (i32.const 0)))
-    (set_local 0x2e1 (i64.load offset=0x2e1 align=1 (i32.const 0)))
-    (set_local 0x2e2 (i64.load offset=0x2e2 align=1 (i32.const 0)))
-    (set_local 0x2e3 (i64.load offset=0x2e3 align=1 (i32.const 0)))
-    (set_local 0x2e4 (i64.load offset=0x2e4 align=1 (i32.const 0)))
-    (set_local 0x2e5 (i64.load offset=0x2e5 align=1 (i32.const 0)))
-    (set_local 0x2e6 (i64.load offset=0x2e6 align=1 (i32.const 0)))
-    (set_local 0x2e7 (i64.load offset=0x2e7 align=1 (i32.const 0)))
-    (set_local 0x2e8 (i64.load offset=0x2e8 align=1 (i32.const 0)))
-    (set_local 0x2e9 (i64.load offset=0x2e9 align=1 (i32.const 0)))
-    (set_local 0x2ea (i64.load offset=0x2ea align=1 (i32.const 0)))
-    (set_local 0x2eb (i64.load offset=0x2eb align=1 (i32.const 0)))
-    (set_local 0x2ec (i64.load offset=0x2ec align=1 (i32.const 0)))
-    (set_local 0x2ed (i64.load offset=0x2ed align=1 (i32.const 0)))
-    (set_local 0x2ee (i64.load offset=0x2ee align=1 (i32.const 0)))
-    (set_local 0x2ef (i64.load offset=0x2ef align=1 (i32.const 0)))
-    (set_local 0x2f0 (i64.load offset=0x2f0 align=1 (i32.const 0)))
-    (set_local 0x2f1 (i64.load offset=0x2f1 align=1 (i32.const 0)))
-    (set_local 0x2f2 (i64.load offset=0x2f2 align=1 (i32.const 0)))
-    (set_local 0x2f3 (i64.load offset=0x2f3 align=1 (i32.const 0)))
-    (set_local 0x2f4 (i64.load offset=0x2f4 align=1 (i32.const 0)))
-    (set_local 0x2f5 (i64.load offset=0x2f5 align=1 (i32.const 0)))
-    (set_local 0x2f6 (i64.load offset=0x2f6 align=1 (i32.const 0)))
-    (set_local 0x2f7 (i64.load offset=0x2f7 align=1 (i32.const 0)))
-    (set_local 0x2f8 (i64.load offset=0x2f8 align=1 (i32.const 0)))
-    (set_local 0x2f9 (i64.load offset=0x2f9 align=1 (i32.const 0)))
-    (set_local 0x2fa (i64.load offset=0x2fa align=1 (i32.const 0)))
-    (set_local 0x2fb (i64.load offset=0x2fb align=1 (i32.const 0)))
-    (set_local 0x2fc (i64.load offset=0x2fc align=1 (i32.const 0)))
-    (set_local 0x2fd (i64.load offset=0x2fd align=1 (i32.const 0)))
-    (set_local 0x2fe (i64.load offset=0x2fe align=1 (i32.const 0)))
-    (set_local 0x2ff (i64.load offset=0x2ff align=1 (i32.const 0)))
-    (set_local 0x300 (i64.load offset=0x300 align=1 (i32.const 0)))
-    (set_local 0x301 (i64.load offset=0x301 align=1 (i32.const 0)))
-    (set_local 0x302 (i64.load offset=0x302 align=1 (i32.const 0)))
-    (set_local 0x303 (i64.load offset=0x303 align=1 (i32.const 0)))
-    (set_local 0x304 (i64.load offset=0x304 align=1 (i32.const 0)))
-    (set_local 0x305 (i64.load offset=0x305 align=1 (i32.const 0)))
-    (set_local 0x306 (i64.load offset=0x306 align=1 (i32.const 0)))
-    (set_local 0x307 (i64.load offset=0x307 align=1 (i32.const 0)))
-    (set_local 0x308 (i64.load offset=0x308 align=1 (i32.const 0)))
-    (set_local 0x309 (i64.load offset=0x309 align=1 (i32.const 0)))
-    (set_local 0x30a (i64.load offset=0x30a align=1 (i32.const 0)))
-    (set_local 0x30b (i64.load offset=0x30b align=1 (i32.const 0)))
-    (set_local 0x30c (i64.load offset=0x30c align=1 (i32.const 0)))
-    (set_local 0x30d (i64.load offset=0x30d align=1 (i32.const 0)))
-    (set_local 0x30e (i64.load offset=0x30e align=1 (i32.const 0)))
-    (set_local 0x30f (i64.load offset=0x30f align=1 (i32.const 0)))
-    (set_local 0x310 (i64.load offset=0x310 align=1 (i32.const 0)))
-    (set_local 0x311 (i64.load offset=0x311 align=1 (i32.const 0)))
-    (set_local 0x312 (i64.load offset=0x312 align=1 (i32.const 0)))
-    (set_local 0x313 (i64.load offset=0x313 align=1 (i32.const 0)))
-    (set_local 0x314 (i64.load offset=0x314 align=1 (i32.const 0)))
-    (set_local 0x315 (i64.load offset=0x315 align=1 (i32.const 0)))
-    (set_local 0x316 (i64.load offset=0x316 align=1 (i32.const 0)))
-    (set_local 0x317 (i64.load offset=0x317 align=1 (i32.const 0)))
-    (set_local 0x318 (i64.load offset=0x318 align=1 (i32.const 0)))
-    (set_local 0x319 (i64.load offset=0x319 align=1 (i32.const 0)))
-    (set_local 0x31a (i64.load offset=0x31a align=1 (i32.const 0)))
-    (set_local 0x31b (i64.load offset=0x31b align=1 (i32.const 0)))
-    (set_local 0x31c (i64.load offset=0x31c align=1 (i32.const 0)))
-    (set_local 0x31d (i64.load offset=0x31d align=1 (i32.const 0)))
-    (set_local 0x31e (i64.load offset=0x31e align=1 (i32.const 0)))
-    (set_local 0x31f (i64.load offset=0x31f align=1 (i32.const 0)))
-    (set_local 0x320 (i64.load offset=0x320 align=1 (i32.const 0)))
-    (set_local 0x321 (i64.load offset=0x321 align=1 (i32.const 0)))
-    (set_local 0x322 (i64.load offset=0x322 align=1 (i32.const 0)))
-    (set_local 0x323 (i64.load offset=0x323 align=1 (i32.const 0)))
-    (set_local 0x324 (i64.load offset=0x324 align=1 (i32.const 0)))
-    (set_local 0x325 (i64.load offset=0x325 align=1 (i32.const 0)))
-    (set_local 0x326 (i64.load offset=0x326 align=1 (i32.const 0)))
-    (set_local 0x327 (i64.load offset=0x327 align=1 (i32.const 0)))
-    (set_local 0x328 (i64.load offset=0x328 align=1 (i32.const 0)))
-    (set_local 0x329 (i64.load offset=0x329 align=1 (i32.const 0)))
-    (set_local 0x32a (i64.load offset=0x32a align=1 (i32.const 0)))
-    (set_local 0x32b (i64.load offset=0x32b align=1 (i32.const 0)))
-    (set_local 0x32c (i64.load offset=0x32c align=1 (i32.const 0)))
-    (set_local 0x32d (i64.load offset=0x32d align=1 (i32.const 0)))
-    (set_local 0x32e (i64.load offset=0x32e align=1 (i32.const 0)))
-    (set_local 0x32f (i64.load offset=0x32f align=1 (i32.const 0)))
-    (set_local 0x330 (i64.load offset=0x330 align=1 (i32.const 0)))
-    (set_local 0x331 (i64.load offset=0x331 align=1 (i32.const 0)))
-    (set_local 0x332 (i64.load offset=0x332 align=1 (i32.const 0)))
-    (set_local 0x333 (i64.load offset=0x333 align=1 (i32.const 0)))
-    (set_local 0x334 (i64.load offset=0x334 align=1 (i32.const 0)))
-    (set_local 0x335 (i64.load offset=0x335 align=1 (i32.const 0)))
-    (set_local 0x336 (i64.load offset=0x336 align=1 (i32.const 0)))
-    (set_local 0x337 (i64.load offset=0x337 align=1 (i32.const 0)))
-    (set_local 0x338 (i64.load offset=0x338 align=1 (i32.const 0)))
-    (set_local 0x339 (i64.load offset=0x339 align=1 (i32.const 0)))
-    (set_local 0x33a (i64.load offset=0x33a align=1 (i32.const 0)))
-    (set_local 0x33b (i64.load offset=0x33b align=1 (i32.const 0)))
-    (set_local 0x33c (i64.load offset=0x33c align=1 (i32.const 0)))
-    (set_local 0x33d (i64.load offset=0x33d align=1 (i32.const 0)))
-    (set_local 0x33e (i64.load offset=0x33e align=1 (i32.const 0)))
-    (set_local 0x33f (i64.load offset=0x33f align=1 (i32.const 0)))
-    (set_local 0x340 (i64.load offset=0x340 align=1 (i32.const 0)))
-    (set_local 0x341 (i64.load offset=0x341 align=1 (i32.const 0)))
-    (set_local 0x342 (i64.load offset=0x342 align=1 (i32.const 0)))
-    (set_local 0x343 (i64.load offset=0x343 align=1 (i32.const 0)))
-    (set_local 0x344 (i64.load offset=0x344 align=1 (i32.const 0)))
-    (set_local 0x345 (i64.load offset=0x345 align=1 (i32.const 0)))
-    (set_local 0x346 (i64.load offset=0x346 align=1 (i32.const 0)))
-    (set_local 0x347 (i64.load offset=0x347 align=1 (i32.const 0)))
-    (set_local 0x348 (i64.load offset=0x348 align=1 (i32.const 0)))
-    (set_local 0x349 (i64.load offset=0x349 align=1 (i32.const 0)))
-    (set_local 0x34a (i64.load offset=0x34a align=1 (i32.const 0)))
-    (set_local 0x34b (i64.load offset=0x34b align=1 (i32.const 0)))
-    (set_local 0x34c (i64.load offset=0x34c align=1 (i32.const 0)))
-    (set_local 0x34d (i64.load offset=0x34d align=1 (i32.const 0)))
-    (set_local 0x34e (i64.load offset=0x34e align=1 (i32.const 0)))
-    (set_local 0x34f (i64.load offset=0x34f align=1 (i32.const 0)))
-    (set_local 0x350 (i64.load offset=0x350 align=1 (i32.const 0)))
-    (set_local 0x351 (i64.load offset=0x351 align=1 (i32.const 0)))
-    (set_local 0x352 (i64.load offset=0x352 align=1 (i32.const 0)))
-    (set_local 0x353 (i64.load offset=0x353 align=1 (i32.const 0)))
-    (set_local 0x354 (i64.load offset=0x354 align=1 (i32.const 0)))
-    (set_local 0x355 (i64.load offset=0x355 align=1 (i32.const 0)))
-    (set_local 0x356 (i64.load offset=0x356 align=1 (i32.const 0)))
-    (set_local 0x357 (i64.load offset=0x357 align=1 (i32.const 0)))
-    (set_local 0x358 (i64.load offset=0x358 align=1 (i32.const 0)))
-    (set_local 0x359 (i64.load offset=0x359 align=1 (i32.const 0)))
-    (set_local 0x35a (i64.load offset=0x35a align=1 (i32.const 0)))
-    (set_local 0x35b (i64.load offset=0x35b align=1 (i32.const 0)))
-    (set_local 0x35c (i64.load offset=0x35c align=1 (i32.const 0)))
-    (set_local 0x35d (i64.load offset=0x35d align=1 (i32.const 0)))
-    (set_local 0x35e (i64.load offset=0x35e align=1 (i32.const 0)))
-    (set_local 0x35f (i64.load offset=0x35f align=1 (i32.const 0)))
-    (set_local 0x360 (i64.load offset=0x360 align=1 (i32.const 0)))
-    (set_local 0x361 (i64.load offset=0x361 align=1 (i32.const 0)))
-    (set_local 0x362 (i64.load offset=0x362 align=1 (i32.const 0)))
-    (set_local 0x363 (i64.load offset=0x363 align=1 (i32.const 0)))
-    (set_local 0x364 (i64.load offset=0x364 align=1 (i32.const 0)))
-    (set_local 0x365 (i64.load offset=0x365 align=1 (i32.const 0)))
-    (set_local 0x366 (i64.load offset=0x366 align=1 (i32.const 0)))
-    (set_local 0x367 (i64.load offset=0x367 align=1 (i32.const 0)))
-    (set_local 0x368 (i64.load offset=0x368 align=1 (i32.const 0)))
-    (set_local 0x369 (i64.load offset=0x369 align=1 (i32.const 0)))
-    (set_local 0x36a (i64.load offset=0x36a align=1 (i32.const 0)))
-    (set_local 0x36b (i64.load offset=0x36b align=1 (i32.const 0)))
-    (set_local 0x36c (i64.load offset=0x36c align=1 (i32.const 0)))
-    (set_local 0x36d (i64.load offset=0x36d align=1 (i32.const 0)))
-    (set_local 0x36e (i64.load offset=0x36e align=1 (i32.const 0)))
-    (set_local 0x36f (i64.load offset=0x36f align=1 (i32.const 0)))
-    (set_local 0x370 (i64.load offset=0x370 align=1 (i32.const 0)))
-    (set_local 0x371 (i64.load offset=0x371 align=1 (i32.const 0)))
-    (set_local 0x372 (i64.load offset=0x372 align=1 (i32.const 0)))
-    (set_local 0x373 (i64.load offset=0x373 align=1 (i32.const 0)))
-    (set_local 0x374 (i64.load offset=0x374 align=1 (i32.const 0)))
-    (set_local 0x375 (i64.load offset=0x375 align=1 (i32.const 0)))
-    (set_local 0x376 (i64.load offset=0x376 align=1 (i32.const 0)))
-    (set_local 0x377 (i64.load offset=0x377 align=1 (i32.const 0)))
-    (set_local 0x378 (i64.load offset=0x378 align=1 (i32.const 0)))
-    (set_local 0x379 (i64.load offset=0x379 align=1 (i32.const 0)))
-    (set_local 0x37a (i64.load offset=0x37a align=1 (i32.const 0)))
-    (set_local 0x37b (i64.load offset=0x37b align=1 (i32.const 0)))
-    (set_local 0x37c (i64.load offset=0x37c align=1 (i32.const 0)))
-    (set_local 0x37d (i64.load offset=0x37d align=1 (i32.const 0)))
-    (set_local 0x37e (i64.load offset=0x37e align=1 (i32.const 0)))
-    (set_local 0x37f (i64.load offset=0x37f align=1 (i32.const 0)))
-    (set_local 0x380 (i64.load offset=0x380 align=1 (i32.const 0)))
-    (set_local 0x381 (i64.load offset=0x381 align=1 (i32.const 0)))
-    (set_local 0x382 (i64.load offset=0x382 align=1 (i32.const 0)))
-    (set_local 0x383 (i64.load offset=0x383 align=1 (i32.const 0)))
-    (set_local 0x384 (i64.load offset=0x384 align=1 (i32.const 0)))
-    (set_local 0x385 (i64.load offset=0x385 align=1 (i32.const 0)))
-    (set_local 0x386 (i64.load offset=0x386 align=1 (i32.const 0)))
-    (set_local 0x387 (i64.load offset=0x387 align=1 (i32.const 0)))
-    (set_local 0x388 (i64.load offset=0x388 align=1 (i32.const 0)))
-    (set_local 0x389 (i64.load offset=0x389 align=1 (i32.const 0)))
-    (set_local 0x38a (i64.load offset=0x38a align=1 (i32.const 0)))
-    (set_local 0x38b (i64.load offset=0x38b align=1 (i32.const 0)))
-    (set_local 0x38c (i64.load offset=0x38c align=1 (i32.const 0)))
-    (set_local 0x38d (i64.load offset=0x38d align=1 (i32.const 0)))
-    (set_local 0x38e (i64.load offset=0x38e align=1 (i32.const 0)))
-    (set_local 0x38f (i64.load offset=0x38f align=1 (i32.const 0)))
-    (set_local 0x390 (i64.load offset=0x390 align=1 (i32.const 0)))
-    (set_local 0x391 (i64.load offset=0x391 align=1 (i32.const 0)))
-    (set_local 0x392 (i64.load offset=0x392 align=1 (i32.const 0)))
-    (set_local 0x393 (i64.load offset=0x393 align=1 (i32.const 0)))
-    (set_local 0x394 (i64.load offset=0x394 align=1 (i32.const 0)))
-    (set_local 0x395 (i64.load offset=0x395 align=1 (i32.const 0)))
-    (set_local 0x396 (i64.load offset=0x396 align=1 (i32.const 0)))
-    (set_local 0x397 (i64.load offset=0x397 align=1 (i32.const 0)))
-    (set_local 0x398 (i64.load offset=0x398 align=1 (i32.const 0)))
-    (set_local 0x399 (i64.load offset=0x399 align=1 (i32.const 0)))
-    (set_local 0x39a (i64.load offset=0x39a align=1 (i32.const 0)))
-    (set_local 0x39b (i64.load offset=0x39b align=1 (i32.const 0)))
-    (set_local 0x39c (i64.load offset=0x39c align=1 (i32.const 0)))
-    (set_local 0x39d (i64.load offset=0x39d align=1 (i32.const 0)))
-    (set_local 0x39e (i64.load offset=0x39e align=1 (i32.const 0)))
-    (set_local 0x39f (i64.load offset=0x39f align=1 (i32.const 0)))
-    (set_local 0x3a0 (i64.load offset=0x3a0 align=1 (i32.const 0)))
-    (set_local 0x3a1 (i64.load offset=0x3a1 align=1 (i32.const 0)))
-    (set_local 0x3a2 (i64.load offset=0x3a2 align=1 (i32.const 0)))
-    (set_local 0x3a3 (i64.load offset=0x3a3 align=1 (i32.const 0)))
-    (set_local 0x3a4 (i64.load offset=0x3a4 align=1 (i32.const 0)))
-    (set_local 0x3a5 (i64.load offset=0x3a5 align=1 (i32.const 0)))
-    (set_local 0x3a6 (i64.load offset=0x3a6 align=1 (i32.const 0)))
-    (set_local 0x3a7 (i64.load offset=0x3a7 align=1 (i32.const 0)))
-    (set_local 0x3a8 (i64.load offset=0x3a8 align=1 (i32.const 0)))
-    (set_local 0x3a9 (i64.load offset=0x3a9 align=1 (i32.const 0)))
-    (set_local 0x3aa (i64.load offset=0x3aa align=1 (i32.const 0)))
-    (set_local 0x3ab (i64.load offset=0x3ab align=1 (i32.const 0)))
-    (set_local 0x3ac (i64.load offset=0x3ac align=1 (i32.const 0)))
-    (set_local 0x3ad (i64.load offset=0x3ad align=1 (i32.const 0)))
-    (set_local 0x3ae (i64.load offset=0x3ae align=1 (i32.const 0)))
-    (set_local 0x3af (i64.load offset=0x3af align=1 (i32.const 0)))
-    (set_local 0x3b0 (i64.load offset=0x3b0 align=1 (i32.const 0)))
-    (set_local 0x3b1 (i64.load offset=0x3b1 align=1 (i32.const 0)))
-    (set_local 0x3b2 (i64.load offset=0x3b2 align=1 (i32.const 0)))
-    (set_local 0x3b3 (i64.load offset=0x3b3 align=1 (i32.const 0)))
-    (set_local 0x3b4 (i64.load offset=0x3b4 align=1 (i32.const 0)))
-    (set_local 0x3b5 (i64.load offset=0x3b5 align=1 (i32.const 0)))
-    (set_local 0x3b6 (i64.load offset=0x3b6 align=1 (i32.const 0)))
-    (set_local 0x3b7 (i64.load offset=0x3b7 align=1 (i32.const 0)))
-    (set_local 0x3b8 (i64.load offset=0x3b8 align=1 (i32.const 0)))
-    (set_local 0x3b9 (i64.load offset=0x3b9 align=1 (i32.const 0)))
-    (set_local 0x3ba (i64.load offset=0x3ba align=1 (i32.const 0)))
-    (set_local 0x3bb (i64.load offset=0x3bb align=1 (i32.const 0)))
-    (set_local 0x3bc (i64.load offset=0x3bc align=1 (i32.const 0)))
-    (set_local 0x3bd (i64.load offset=0x3bd align=1 (i32.const 0)))
-    (set_local 0x3be (i64.load offset=0x3be align=1 (i32.const 0)))
-    (set_local 0x3bf (i64.load offset=0x3bf align=1 (i32.const 0)))
-    (set_local 0x3c0 (i64.load offset=0x3c0 align=1 (i32.const 0)))
-    (set_local 0x3c1 (i64.load offset=0x3c1 align=1 (i32.const 0)))
-    (set_local 0x3c2 (i64.load offset=0x3c2 align=1 (i32.const 0)))
-    (set_local 0x3c3 (i64.load offset=0x3c3 align=1 (i32.const 0)))
-    (set_local 0x3c4 (i64.load offset=0x3c4 align=1 (i32.const 0)))
-    (set_local 0x3c5 (i64.load offset=0x3c5 align=1 (i32.const 0)))
-    (set_local 0x3c6 (i64.load offset=0x3c6 align=1 (i32.const 0)))
-    (set_local 0x3c7 (i64.load offset=0x3c7 align=1 (i32.const 0)))
-    (set_local 0x3c8 (i64.load offset=0x3c8 align=1 (i32.const 0)))
-    (set_local 0x3c9 (i64.load offset=0x3c9 align=1 (i32.const 0)))
-    (set_local 0x3ca (i64.load offset=0x3ca align=1 (i32.const 0)))
-    (set_local 0x3cb (i64.load offset=0x3cb align=1 (i32.const 0)))
-    (set_local 0x3cc (i64.load offset=0x3cc align=1 (i32.const 0)))
-    (set_local 0x3cd (i64.load offset=0x3cd align=1 (i32.const 0)))
-    (set_local 0x3ce (i64.load offset=0x3ce align=1 (i32.const 0)))
-    (set_local 0x3cf (i64.load offset=0x3cf align=1 (i32.const 0)))
-    (set_local 0x3d0 (i64.load offset=0x3d0 align=1 (i32.const 0)))
-    (set_local 0x3d1 (i64.load offset=0x3d1 align=1 (i32.const 0)))
-    (set_local 0x3d2 (i64.load offset=0x3d2 align=1 (i32.const 0)))
-    (set_local 0x3d3 (i64.load offset=0x3d3 align=1 (i32.const 0)))
-    (set_local 0x3d4 (i64.load offset=0x3d4 align=1 (i32.const 0)))
-    (set_local 0x3d5 (i64.load offset=0x3d5 align=1 (i32.const 0)))
-    (set_local 0x3d6 (i64.load offset=0x3d6 align=1 (i32.const 0)))
-    (set_local 0x3d7 (i64.load offset=0x3d7 align=1 (i32.const 0)))
-    (set_local 0x3d8 (i64.load offset=0x3d8 align=1 (i32.const 0)))
-    (set_local 0x3d9 (i64.load offset=0x3d9 align=1 (i32.const 0)))
-    (set_local 0x3da (i64.load offset=0x3da align=1 (i32.const 0)))
-    (set_local 0x3db (i64.load offset=0x3db align=1 (i32.const 0)))
-    (set_local 0x3dc (i64.load offset=0x3dc align=1 (i32.const 0)))
-    (set_local 0x3dd (i64.load offset=0x3dd align=1 (i32.const 0)))
-    (set_local 0x3de (i64.load offset=0x3de align=1 (i32.const 0)))
-    (set_local 0x3df (i64.load offset=0x3df align=1 (i32.const 0)))
-    (set_local 0x3e0 (i64.load offset=0x3e0 align=1 (i32.const 0)))
-    (set_local 0x3e1 (i64.load offset=0x3e1 align=1 (i32.const 0)))
-    (set_local 0x3e2 (i64.load offset=0x3e2 align=1 (i32.const 0)))
-    (set_local 0x3e3 (i64.load offset=0x3e3 align=1 (i32.const 0)))
-    (set_local 0x3e4 (i64.load offset=0x3e4 align=1 (i32.const 0)))
-    (set_local 0x3e5 (i64.load offset=0x3e5 align=1 (i32.const 0)))
-    (set_local 0x3e6 (i64.load offset=0x3e6 align=1 (i32.const 0)))
-    (set_local 0x3e7 (i64.load offset=0x3e7 align=1 (i32.const 0)))
-    (set_local 0x3e8 (i64.load offset=0x3e8 align=1 (i32.const 0)))
-    (set_local 0x3e9 (i64.load offset=0x3e9 align=1 (i32.const 0)))
-    (set_local 0x3ea (i64.load offset=0x3ea align=1 (i32.const 0)))
-    (set_local 0x3eb (i64.load offset=0x3eb align=1 (i32.const 0)))
-    (set_local 0x3ec (i64.load offset=0x3ec align=1 (i32.const 0)))
-    (set_local 0x3ed (i64.load offset=0x3ed align=1 (i32.const 0)))
-    (set_local 0x3ee (i64.load offset=0x3ee align=1 (i32.const 0)))
-    (set_local 0x3ef (i64.load offset=0x3ef align=1 (i32.const 0)))
-    (set_local 0x3f0 (i64.load offset=0x3f0 align=1 (i32.const 0)))
-    (set_local 0x3f1 (i64.load offset=0x3f1 align=1 (i32.const 0)))
-    (set_local 0x3f2 (i64.load offset=0x3f2 align=1 (i32.const 0)))
-    (set_local 0x3f3 (i64.load offset=0x3f3 align=1 (i32.const 0)))
-    (set_local 0x3f4 (i64.load offset=0x3f4 align=1 (i32.const 0)))
-    (set_local 0x3f5 (i64.load offset=0x3f5 align=1 (i32.const 0)))
-    (set_local 0x3f6 (i64.load offset=0x3f6 align=1 (i32.const 0)))
-    (set_local 0x3f7 (i64.load offset=0x3f7 align=1 (i32.const 0)))
-    (set_local 0x3f8 (i64.load offset=0x3f8 align=1 (i32.const 0)))
-    (set_local 0x3f9 (i64.load offset=0x3f9 align=1 (i32.const 0)))
-    (set_local 0x3fa (i64.load offset=0x3fa align=1 (i32.const 0)))
-    (set_local 0x3fb (i64.load offset=0x3fb align=1 (i32.const 0)))
-    (set_local 0x3fc (i64.load offset=0x3fc align=1 (i32.const 0)))
-    (set_local 0x3fd (i64.load offset=0x3fd align=1 (i32.const 0)))
-    (set_local 0x3fe (i64.load offset=0x3fe align=1 (i32.const 0)))
-    (set_local 0x3ff (i64.load offset=0x3ff align=1 (i32.const 0)))
-    (set_local 0x400 (i64.load offset=0x400 align=1 (i32.const 0)))
-    (set_local 0x401 (i64.load offset=0x401 align=1 (i32.const 0)))
-    (set_local 0x402 (i64.load offset=0x402 align=1 (i32.const 0)))
-    (set_local 0x403 (i64.load offset=0x403 align=1 (i32.const 0)))
-    (set_local 0x404 (i64.load offset=0x404 align=1 (i32.const 0)))
-    (set_local 0x405 (i64.load offset=0x405 align=1 (i32.const 0)))
-    (set_local 0x406 (i64.load offset=0x406 align=1 (i32.const 0)))
-    (set_local 0x407 (i64.load offset=0x407 align=1 (i32.const 0)))
-    (set_local 0x408 (i64.load offset=0x408 align=1 (i32.const 0)))
-    (set_local 0x409 (i64.load offset=0x409 align=1 (i32.const 0)))
-    (set_local 0x40a (i64.load offset=0x40a align=1 (i32.const 0)))
-    (set_local 0x40b (i64.load offset=0x40b align=1 (i32.const 0)))
-    (set_local 0x40c (i64.load offset=0x40c align=1 (i32.const 0)))
-    (set_local 0x40d (i64.load offset=0x40d align=1 (i32.const 0)))
-    (set_local 0x40e (i64.load offset=0x40e align=1 (i32.const 0)))
-    (set_local 0x40f (i64.load offset=0x40f align=1 (i32.const 0)))
-    (set_local 0x410 (i64.load offset=0x410 align=1 (i32.const 0)))
-    (set_local 0x411 (i64.load offset=0x411 align=1 (i32.const 0)))
-    (set_local 0x412 (i64.load offset=0x412 align=1 (i32.const 0)))
-    (set_local 0x413 (i64.load offset=0x413 align=1 (i32.const 0)))
-    (set_local 0x414 (i64.load offset=0x414 align=1 (i32.const 0)))
-    (set_local 0x415 (i64.load offset=0x415 align=1 (i32.const 0)))
-    (set_local 0x416 (i64.load offset=0x416 align=1 (i32.const 0)))
-    (set_local 0x417 (i64.load offset=0x417 align=1 (i32.const 0)))
-    (set_local 0x418 (i64.load offset=0x418 align=1 (i32.const 0)))
-    (set_local 0x419 (i64.load offset=0x419 align=1 (i32.const 0)))
-    (set_local 0x41a (i64.load offset=0x41a align=1 (i32.const 0)))
-    (set_local 0x41b (i64.load offset=0x41b align=1 (i32.const 0)))
-    (set_local 0x41c (i64.load offset=0x41c align=1 (i32.const 0)))
-    (set_local 0x41d (i64.load offset=0x41d align=1 (i32.const 0)))
-    (set_local 0x41e (i64.load offset=0x41e align=1 (i32.const 0)))
-    (set_local 0x41f (i64.load offset=0x41f align=1 (i32.const 0)))
+    (local.set 0x000 (i64.load offset=0x000 align=1 (i32.const 0)))
+    (local.set 0x001 (i64.load offset=0x001 align=1 (i32.const 0)))
+    (local.set 0x002 (i64.load offset=0x002 align=1 (i32.const 0)))
+    (local.set 0x003 (i64.load offset=0x003 align=1 (i32.const 0)))
+    (local.set 0x004 (i64.load offset=0x004 align=1 (i32.const 0)))
+    (local.set 0x005 (i64.load offset=0x005 align=1 (i32.const 0)))
+    (local.set 0x006 (i64.load offset=0x006 align=1 (i32.const 0)))
+    (local.set 0x007 (i64.load offset=0x007 align=1 (i32.const 0)))
+    (local.set 0x008 (i64.load offset=0x008 align=1 (i32.const 0)))
+    (local.set 0x009 (i64.load offset=0x009 align=1 (i32.const 0)))
+    (local.set 0x00a (i64.load offset=0x00a align=1 (i32.const 0)))
+    (local.set 0x00b (i64.load offset=0x00b align=1 (i32.const 0)))
+    (local.set 0x00c (i64.load offset=0x00c align=1 (i32.const 0)))
+    (local.set 0x00d (i64.load offset=0x00d align=1 (i32.const 0)))
+    (local.set 0x00e (i64.load offset=0x00e align=1 (i32.const 0)))
+    (local.set 0x00f (i64.load offset=0x00f align=1 (i32.const 0)))
+    (local.set 0x010 (i64.load offset=0x010 align=1 (i32.const 0)))
+    (local.set 0x011 (i64.load offset=0x011 align=1 (i32.const 0)))
+    (local.set 0x012 (i64.load offset=0x012 align=1 (i32.const 0)))
+    (local.set 0x013 (i64.load offset=0x013 align=1 (i32.const 0)))
+    (local.set 0x014 (i64.load offset=0x014 align=1 (i32.const 0)))
+    (local.set 0x015 (i64.load offset=0x015 align=1 (i32.const 0)))
+    (local.set 0x016 (i64.load offset=0x016 align=1 (i32.const 0)))
+    (local.set 0x017 (i64.load offset=0x017 align=1 (i32.const 0)))
+    (local.set 0x018 (i64.load offset=0x018 align=1 (i32.const 0)))
+    (local.set 0x019 (i64.load offset=0x019 align=1 (i32.const 0)))
+    (local.set 0x01a (i64.load offset=0x01a align=1 (i32.const 0)))
+    (local.set 0x01b (i64.load offset=0x01b align=1 (i32.const 0)))
+    (local.set 0x01c (i64.load offset=0x01c align=1 (i32.const 0)))
+    (local.set 0x01d (i64.load offset=0x01d align=1 (i32.const 0)))
+    (local.set 0x01e (i64.load offset=0x01e align=1 (i32.const 0)))
+    (local.set 0x01f (i64.load offset=0x01f align=1 (i32.const 0)))
+    (local.set 0x020 (i64.load offset=0x020 align=1 (i32.const 0)))
+    (local.set 0x021 (i64.load offset=0x021 align=1 (i32.const 0)))
+    (local.set 0x022 (i64.load offset=0x022 align=1 (i32.const 0)))
+    (local.set 0x023 (i64.load offset=0x023 align=1 (i32.const 0)))
+    (local.set 0x024 (i64.load offset=0x024 align=1 (i32.const 0)))
+    (local.set 0x025 (i64.load offset=0x025 align=1 (i32.const 0)))
+    (local.set 0x026 (i64.load offset=0x026 align=1 (i32.const 0)))
+    (local.set 0x027 (i64.load offset=0x027 align=1 (i32.const 0)))
+    (local.set 0x028 (i64.load offset=0x028 align=1 (i32.const 0)))
+    (local.set 0x029 (i64.load offset=0x029 align=1 (i32.const 0)))
+    (local.set 0x02a (i64.load offset=0x02a align=1 (i32.const 0)))
+    (local.set 0x02b (i64.load offset=0x02b align=1 (i32.const 0)))
+    (local.set 0x02c (i64.load offset=0x02c align=1 (i32.const 0)))
+    (local.set 0x02d (i64.load offset=0x02d align=1 (i32.const 0)))
+    (local.set 0x02e (i64.load offset=0x02e align=1 (i32.const 0)))
+    (local.set 0x02f (i64.load offset=0x02f align=1 (i32.const 0)))
+    (local.set 0x030 (i64.load offset=0x030 align=1 (i32.const 0)))
+    (local.set 0x031 (i64.load offset=0x031 align=1 (i32.const 0)))
+    (local.set 0x032 (i64.load offset=0x032 align=1 (i32.const 0)))
+    (local.set 0x033 (i64.load offset=0x033 align=1 (i32.const 0)))
+    (local.set 0x034 (i64.load offset=0x034 align=1 (i32.const 0)))
+    (local.set 0x035 (i64.load offset=0x035 align=1 (i32.const 0)))
+    (local.set 0x036 (i64.load offset=0x036 align=1 (i32.const 0)))
+    (local.set 0x037 (i64.load offset=0x037 align=1 (i32.const 0)))
+    (local.set 0x038 (i64.load offset=0x038 align=1 (i32.const 0)))
+    (local.set 0x039 (i64.load offset=0x039 align=1 (i32.const 0)))
+    (local.set 0x03a (i64.load offset=0x03a align=1 (i32.const 0)))
+    (local.set 0x03b (i64.load offset=0x03b align=1 (i32.const 0)))
+    (local.set 0x03c (i64.load offset=0x03c align=1 (i32.const 0)))
+    (local.set 0x03d (i64.load offset=0x03d align=1 (i32.const 0)))
+    (local.set 0x03e (i64.load offset=0x03e align=1 (i32.const 0)))
+    (local.set 0x03f (i64.load offset=0x03f align=1 (i32.const 0)))
+    (local.set 0x040 (i64.load offset=0x040 align=1 (i32.const 0)))
+    (local.set 0x041 (i64.load offset=0x041 align=1 (i32.const 0)))
+    (local.set 0x042 (i64.load offset=0x042 align=1 (i32.const 0)))
+    (local.set 0x043 (i64.load offset=0x043 align=1 (i32.const 0)))
+    (local.set 0x044 (i64.load offset=0x044 align=1 (i32.const 0)))
+    (local.set 0x045 (i64.load offset=0x045 align=1 (i32.const 0)))
+    (local.set 0x046 (i64.load offset=0x046 align=1 (i32.const 0)))
+    (local.set 0x047 (i64.load offset=0x047 align=1 (i32.const 0)))
+    (local.set 0x048 (i64.load offset=0x048 align=1 (i32.const 0)))
+    (local.set 0x049 (i64.load offset=0x049 align=1 (i32.const 0)))
+    (local.set 0x04a (i64.load offset=0x04a align=1 (i32.const 0)))
+    (local.set 0x04b (i64.load offset=0x04b align=1 (i32.const 0)))
+    (local.set 0x04c (i64.load offset=0x04c align=1 (i32.const 0)))
+    (local.set 0x04d (i64.load offset=0x04d align=1 (i32.const 0)))
+    (local.set 0x04e (i64.load offset=0x04e align=1 (i32.const 0)))
+    (local.set 0x04f (i64.load offset=0x04f align=1 (i32.const 0)))
+    (local.set 0x050 (i64.load offset=0x050 align=1 (i32.const 0)))
+    (local.set 0x051 (i64.load offset=0x051 align=1 (i32.const 0)))
+    (local.set 0x052 (i64.load offset=0x052 align=1 (i32.const 0)))
+    (local.set 0x053 (i64.load offset=0x053 align=1 (i32.const 0)))
+    (local.set 0x054 (i64.load offset=0x054 align=1 (i32.const 0)))
+    (local.set 0x055 (i64.load offset=0x055 align=1 (i32.const 0)))
+    (local.set 0x056 (i64.load offset=0x056 align=1 (i32.const 0)))
+    (local.set 0x057 (i64.load offset=0x057 align=1 (i32.const 0)))
+    (local.set 0x058 (i64.load offset=0x058 align=1 (i32.const 0)))
+    (local.set 0x059 (i64.load offset=0x059 align=1 (i32.const 0)))
+    (local.set 0x05a (i64.load offset=0x05a align=1 (i32.const 0)))
+    (local.set 0x05b (i64.load offset=0x05b align=1 (i32.const 0)))
+    (local.set 0x05c (i64.load offset=0x05c align=1 (i32.const 0)))
+    (local.set 0x05d (i64.load offset=0x05d align=1 (i32.const 0)))
+    (local.set 0x05e (i64.load offset=0x05e align=1 (i32.const 0)))
+    (local.set 0x05f (i64.load offset=0x05f align=1 (i32.const 0)))
+    (local.set 0x060 (i64.load offset=0x060 align=1 (i32.const 0)))
+    (local.set 0x061 (i64.load offset=0x061 align=1 (i32.const 0)))
+    (local.set 0x062 (i64.load offset=0x062 align=1 (i32.const 0)))
+    (local.set 0x063 (i64.load offset=0x063 align=1 (i32.const 0)))
+    (local.set 0x064 (i64.load offset=0x064 align=1 (i32.const 0)))
+    (local.set 0x065 (i64.load offset=0x065 align=1 (i32.const 0)))
+    (local.set 0x066 (i64.load offset=0x066 align=1 (i32.const 0)))
+    (local.set 0x067 (i64.load offset=0x067 align=1 (i32.const 0)))
+    (local.set 0x068 (i64.load offset=0x068 align=1 (i32.const 0)))
+    (local.set 0x069 (i64.load offset=0x069 align=1 (i32.const 0)))
+    (local.set 0x06a (i64.load offset=0x06a align=1 (i32.const 0)))
+    (local.set 0x06b (i64.load offset=0x06b align=1 (i32.const 0)))
+    (local.set 0x06c (i64.load offset=0x06c align=1 (i32.const 0)))
+    (local.set 0x06d (i64.load offset=0x06d align=1 (i32.const 0)))
+    (local.set 0x06e (i64.load offset=0x06e align=1 (i32.const 0)))
+    (local.set 0x06f (i64.load offset=0x06f align=1 (i32.const 0)))
+    (local.set 0x070 (i64.load offset=0x070 align=1 (i32.const 0)))
+    (local.set 0x071 (i64.load offset=0x071 align=1 (i32.const 0)))
+    (local.set 0x072 (i64.load offset=0x072 align=1 (i32.const 0)))
+    (local.set 0x073 (i64.load offset=0x073 align=1 (i32.const 0)))
+    (local.set 0x074 (i64.load offset=0x074 align=1 (i32.const 0)))
+    (local.set 0x075 (i64.load offset=0x075 align=1 (i32.const 0)))
+    (local.set 0x076 (i64.load offset=0x076 align=1 (i32.const 0)))
+    (local.set 0x077 (i64.load offset=0x077 align=1 (i32.const 0)))
+    (local.set 0x078 (i64.load offset=0x078 align=1 (i32.const 0)))
+    (local.set 0x079 (i64.load offset=0x079 align=1 (i32.const 0)))
+    (local.set 0x07a (i64.load offset=0x07a align=1 (i32.const 0)))
+    (local.set 0x07b (i64.load offset=0x07b align=1 (i32.const 0)))
+    (local.set 0x07c (i64.load offset=0x07c align=1 (i32.const 0)))
+    (local.set 0x07d (i64.load offset=0x07d align=1 (i32.const 0)))
+    (local.set 0x07e (i64.load offset=0x07e align=1 (i32.const 0)))
+    (local.set 0x07f (i64.load offset=0x07f align=1 (i32.const 0)))
+    (local.set 0x080 (i64.load offset=0x080 align=1 (i32.const 0)))
+    (local.set 0x081 (i64.load offset=0x081 align=1 (i32.const 0)))
+    (local.set 0x082 (i64.load offset=0x082 align=1 (i32.const 0)))
+    (local.set 0x083 (i64.load offset=0x083 align=1 (i32.const 0)))
+    (local.set 0x084 (i64.load offset=0x084 align=1 (i32.const 0)))
+    (local.set 0x085 (i64.load offset=0x085 align=1 (i32.const 0)))
+    (local.set 0x086 (i64.load offset=0x086 align=1 (i32.const 0)))
+    (local.set 0x087 (i64.load offset=0x087 align=1 (i32.const 0)))
+    (local.set 0x088 (i64.load offset=0x088 align=1 (i32.const 0)))
+    (local.set 0x089 (i64.load offset=0x089 align=1 (i32.const 0)))
+    (local.set 0x08a (i64.load offset=0x08a align=1 (i32.const 0)))
+    (local.set 0x08b (i64.load offset=0x08b align=1 (i32.const 0)))
+    (local.set 0x08c (i64.load offset=0x08c align=1 (i32.const 0)))
+    (local.set 0x08d (i64.load offset=0x08d align=1 (i32.const 0)))
+    (local.set 0x08e (i64.load offset=0x08e align=1 (i32.const 0)))
+    (local.set 0x08f (i64.load offset=0x08f align=1 (i32.const 0)))
+    (local.set 0x090 (i64.load offset=0x090 align=1 (i32.const 0)))
+    (local.set 0x091 (i64.load offset=0x091 align=1 (i32.const 0)))
+    (local.set 0x092 (i64.load offset=0x092 align=1 (i32.const 0)))
+    (local.set 0x093 (i64.load offset=0x093 align=1 (i32.const 0)))
+    (local.set 0x094 (i64.load offset=0x094 align=1 (i32.const 0)))
+    (local.set 0x095 (i64.load offset=0x095 align=1 (i32.const 0)))
+    (local.set 0x096 (i64.load offset=0x096 align=1 (i32.const 0)))
+    (local.set 0x097 (i64.load offset=0x097 align=1 (i32.const 0)))
+    (local.set 0x098 (i64.load offset=0x098 align=1 (i32.const 0)))
+    (local.set 0x099 (i64.load offset=0x099 align=1 (i32.const 0)))
+    (local.set 0x09a (i64.load offset=0x09a align=1 (i32.const 0)))
+    (local.set 0x09b (i64.load offset=0x09b align=1 (i32.const 0)))
+    (local.set 0x09c (i64.load offset=0x09c align=1 (i32.const 0)))
+    (local.set 0x09d (i64.load offset=0x09d align=1 (i32.const 0)))
+    (local.set 0x09e (i64.load offset=0x09e align=1 (i32.const 0)))
+    (local.set 0x09f (i64.load offset=0x09f align=1 (i32.const 0)))
+    (local.set 0x0a0 (i64.load offset=0x0a0 align=1 (i32.const 0)))
+    (local.set 0x0a1 (i64.load offset=0x0a1 align=1 (i32.const 0)))
+    (local.set 0x0a2 (i64.load offset=0x0a2 align=1 (i32.const 0)))
+    (local.set 0x0a3 (i64.load offset=0x0a3 align=1 (i32.const 0)))
+    (local.set 0x0a4 (i64.load offset=0x0a4 align=1 (i32.const 0)))
+    (local.set 0x0a5 (i64.load offset=0x0a5 align=1 (i32.const 0)))
+    (local.set 0x0a6 (i64.load offset=0x0a6 align=1 (i32.const 0)))
+    (local.set 0x0a7 (i64.load offset=0x0a7 align=1 (i32.const 0)))
+    (local.set 0x0a8 (i64.load offset=0x0a8 align=1 (i32.const 0)))
+    (local.set 0x0a9 (i64.load offset=0x0a9 align=1 (i32.const 0)))
+    (local.set 0x0aa (i64.load offset=0x0aa align=1 (i32.const 0)))
+    (local.set 0x0ab (i64.load offset=0x0ab align=1 (i32.const 0)))
+    (local.set 0x0ac (i64.load offset=0x0ac align=1 (i32.const 0)))
+    (local.set 0x0ad (i64.load offset=0x0ad align=1 (i32.const 0)))
+    (local.set 0x0ae (i64.load offset=0x0ae align=1 (i32.const 0)))
+    (local.set 0x0af (i64.load offset=0x0af align=1 (i32.const 0)))
+    (local.set 0x0b0 (i64.load offset=0x0b0 align=1 (i32.const 0)))
+    (local.set 0x0b1 (i64.load offset=0x0b1 align=1 (i32.const 0)))
+    (local.set 0x0b2 (i64.load offset=0x0b2 align=1 (i32.const 0)))
+    (local.set 0x0b3 (i64.load offset=0x0b3 align=1 (i32.const 0)))
+    (local.set 0x0b4 (i64.load offset=0x0b4 align=1 (i32.const 0)))
+    (local.set 0x0b5 (i64.load offset=0x0b5 align=1 (i32.const 0)))
+    (local.set 0x0b6 (i64.load offset=0x0b6 align=1 (i32.const 0)))
+    (local.set 0x0b7 (i64.load offset=0x0b7 align=1 (i32.const 0)))
+    (local.set 0x0b8 (i64.load offset=0x0b8 align=1 (i32.const 0)))
+    (local.set 0x0b9 (i64.load offset=0x0b9 align=1 (i32.const 0)))
+    (local.set 0x0ba (i64.load offset=0x0ba align=1 (i32.const 0)))
+    (local.set 0x0bb (i64.load offset=0x0bb align=1 (i32.const 0)))
+    (local.set 0x0bc (i64.load offset=0x0bc align=1 (i32.const 0)))
+    (local.set 0x0bd (i64.load offset=0x0bd align=1 (i32.const 0)))
+    (local.set 0x0be (i64.load offset=0x0be align=1 (i32.const 0)))
+    (local.set 0x0bf (i64.load offset=0x0bf align=1 (i32.const 0)))
+    (local.set 0x0c0 (i64.load offset=0x0c0 align=1 (i32.const 0)))
+    (local.set 0x0c1 (i64.load offset=0x0c1 align=1 (i32.const 0)))
+    (local.set 0x0c2 (i64.load offset=0x0c2 align=1 (i32.const 0)))
+    (local.set 0x0c3 (i64.load offset=0x0c3 align=1 (i32.const 0)))
+    (local.set 0x0c4 (i64.load offset=0x0c4 align=1 (i32.const 0)))
+    (local.set 0x0c5 (i64.load offset=0x0c5 align=1 (i32.const 0)))
+    (local.set 0x0c6 (i64.load offset=0x0c6 align=1 (i32.const 0)))
+    (local.set 0x0c7 (i64.load offset=0x0c7 align=1 (i32.const 0)))
+    (local.set 0x0c8 (i64.load offset=0x0c8 align=1 (i32.const 0)))
+    (local.set 0x0c9 (i64.load offset=0x0c9 align=1 (i32.const 0)))
+    (local.set 0x0ca (i64.load offset=0x0ca align=1 (i32.const 0)))
+    (local.set 0x0cb (i64.load offset=0x0cb align=1 (i32.const 0)))
+    (local.set 0x0cc (i64.load offset=0x0cc align=1 (i32.const 0)))
+    (local.set 0x0cd (i64.load offset=0x0cd align=1 (i32.const 0)))
+    (local.set 0x0ce (i64.load offset=0x0ce align=1 (i32.const 0)))
+    (local.set 0x0cf (i64.load offset=0x0cf align=1 (i32.const 0)))
+    (local.set 0x0d0 (i64.load offset=0x0d0 align=1 (i32.const 0)))
+    (local.set 0x0d1 (i64.load offset=0x0d1 align=1 (i32.const 0)))
+    (local.set 0x0d2 (i64.load offset=0x0d2 align=1 (i32.const 0)))
+    (local.set 0x0d3 (i64.load offset=0x0d3 align=1 (i32.const 0)))
+    (local.set 0x0d4 (i64.load offset=0x0d4 align=1 (i32.const 0)))
+    (local.set 0x0d5 (i64.load offset=0x0d5 align=1 (i32.const 0)))
+    (local.set 0x0d6 (i64.load offset=0x0d6 align=1 (i32.const 0)))
+    (local.set 0x0d7 (i64.load offset=0x0d7 align=1 (i32.const 0)))
+    (local.set 0x0d8 (i64.load offset=0x0d8 align=1 (i32.const 0)))
+    (local.set 0x0d9 (i64.load offset=0x0d9 align=1 (i32.const 0)))
+    (local.set 0x0da (i64.load offset=0x0da align=1 (i32.const 0)))
+    (local.set 0x0db (i64.load offset=0x0db align=1 (i32.const 0)))
+    (local.set 0x0dc (i64.load offset=0x0dc align=1 (i32.const 0)))
+    (local.set 0x0dd (i64.load offset=0x0dd align=1 (i32.const 0)))
+    (local.set 0x0de (i64.load offset=0x0de align=1 (i32.const 0)))
+    (local.set 0x0df (i64.load offset=0x0df align=1 (i32.const 0)))
+    (local.set 0x0e0 (i64.load offset=0x0e0 align=1 (i32.const 0)))
+    (local.set 0x0e1 (i64.load offset=0x0e1 align=1 (i32.const 0)))
+    (local.set 0x0e2 (i64.load offset=0x0e2 align=1 (i32.const 0)))
+    (local.set 0x0e3 (i64.load offset=0x0e3 align=1 (i32.const 0)))
+    (local.set 0x0e4 (i64.load offset=0x0e4 align=1 (i32.const 0)))
+    (local.set 0x0e5 (i64.load offset=0x0e5 align=1 (i32.const 0)))
+    (local.set 0x0e6 (i64.load offset=0x0e6 align=1 (i32.const 0)))
+    (local.set 0x0e7 (i64.load offset=0x0e7 align=1 (i32.const 0)))
+    (local.set 0x0e8 (i64.load offset=0x0e8 align=1 (i32.const 0)))
+    (local.set 0x0e9 (i64.load offset=0x0e9 align=1 (i32.const 0)))
+    (local.set 0x0ea (i64.load offset=0x0ea align=1 (i32.const 0)))
+    (local.set 0x0eb (i64.load offset=0x0eb align=1 (i32.const 0)))
+    (local.set 0x0ec (i64.load offset=0x0ec align=1 (i32.const 0)))
+    (local.set 0x0ed (i64.load offset=0x0ed align=1 (i32.const 0)))
+    (local.set 0x0ee (i64.load offset=0x0ee align=1 (i32.const 0)))
+    (local.set 0x0ef (i64.load offset=0x0ef align=1 (i32.const 0)))
+    (local.set 0x0f0 (i64.load offset=0x0f0 align=1 (i32.const 0)))
+    (local.set 0x0f1 (i64.load offset=0x0f1 align=1 (i32.const 0)))
+    (local.set 0x0f2 (i64.load offset=0x0f2 align=1 (i32.const 0)))
+    (local.set 0x0f3 (i64.load offset=0x0f3 align=1 (i32.const 0)))
+    (local.set 0x0f4 (i64.load offset=0x0f4 align=1 (i32.const 0)))
+    (local.set 0x0f5 (i64.load offset=0x0f5 align=1 (i32.const 0)))
+    (local.set 0x0f6 (i64.load offset=0x0f6 align=1 (i32.const 0)))
+    (local.set 0x0f7 (i64.load offset=0x0f7 align=1 (i32.const 0)))
+    (local.set 0x0f8 (i64.load offset=0x0f8 align=1 (i32.const 0)))
+    (local.set 0x0f9 (i64.load offset=0x0f9 align=1 (i32.const 0)))
+    (local.set 0x0fa (i64.load offset=0x0fa align=1 (i32.const 0)))
+    (local.set 0x0fb (i64.load offset=0x0fb align=1 (i32.const 0)))
+    (local.set 0x0fc (i64.load offset=0x0fc align=1 (i32.const 0)))
+    (local.set 0x0fd (i64.load offset=0x0fd align=1 (i32.const 0)))
+    (local.set 0x0fe (i64.load offset=0x0fe align=1 (i32.const 0)))
+    (local.set 0x0ff (i64.load offset=0x0ff align=1 (i32.const 0)))
+    (local.set 0x100 (i64.load offset=0x100 align=1 (i32.const 0)))
+    (local.set 0x101 (i64.load offset=0x101 align=1 (i32.const 0)))
+    (local.set 0x102 (i64.load offset=0x102 align=1 (i32.const 0)))
+    (local.set 0x103 (i64.load offset=0x103 align=1 (i32.const 0)))
+    (local.set 0x104 (i64.load offset=0x104 align=1 (i32.const 0)))
+    (local.set 0x105 (i64.load offset=0x105 align=1 (i32.const 0)))
+    (local.set 0x106 (i64.load offset=0x106 align=1 (i32.const 0)))
+    (local.set 0x107 (i64.load offset=0x107 align=1 (i32.const 0)))
+    (local.set 0x108 (i64.load offset=0x108 align=1 (i32.const 0)))
+    (local.set 0x109 (i64.load offset=0x109 align=1 (i32.const 0)))
+    (local.set 0x10a (i64.load offset=0x10a align=1 (i32.const 0)))
+    (local.set 0x10b (i64.load offset=0x10b align=1 (i32.const 0)))
+    (local.set 0x10c (i64.load offset=0x10c align=1 (i32.const 0)))
+    (local.set 0x10d (i64.load offset=0x10d align=1 (i32.const 0)))
+    (local.set 0x10e (i64.load offset=0x10e align=1 (i32.const 0)))
+    (local.set 0x10f (i64.load offset=0x10f align=1 (i32.const 0)))
+    (local.set 0x110 (i64.load offset=0x110 align=1 (i32.const 0)))
+    (local.set 0x111 (i64.load offset=0x111 align=1 (i32.const 0)))
+    (local.set 0x112 (i64.load offset=0x112 align=1 (i32.const 0)))
+    (local.set 0x113 (i64.load offset=0x113 align=1 (i32.const 0)))
+    (local.set 0x114 (i64.load offset=0x114 align=1 (i32.const 0)))
+    (local.set 0x115 (i64.load offset=0x115 align=1 (i32.const 0)))
+    (local.set 0x116 (i64.load offset=0x116 align=1 (i32.const 0)))
+    (local.set 0x117 (i64.load offset=0x117 align=1 (i32.const 0)))
+    (local.set 0x118 (i64.load offset=0x118 align=1 (i32.const 0)))
+    (local.set 0x119 (i64.load offset=0x119 align=1 (i32.const 0)))
+    (local.set 0x11a (i64.load offset=0x11a align=1 (i32.const 0)))
+    (local.set 0x11b (i64.load offset=0x11b align=1 (i32.const 0)))
+    (local.set 0x11c (i64.load offset=0x11c align=1 (i32.const 0)))
+    (local.set 0x11d (i64.load offset=0x11d align=1 (i32.const 0)))
+    (local.set 0x11e (i64.load offset=0x11e align=1 (i32.const 0)))
+    (local.set 0x11f (i64.load offset=0x11f align=1 (i32.const 0)))
+    (local.set 0x120 (i64.load offset=0x120 align=1 (i32.const 0)))
+    (local.set 0x121 (i64.load offset=0x121 align=1 (i32.const 0)))
+    (local.set 0x122 (i64.load offset=0x122 align=1 (i32.const 0)))
+    (local.set 0x123 (i64.load offset=0x123 align=1 (i32.const 0)))
+    (local.set 0x124 (i64.load offset=0x124 align=1 (i32.const 0)))
+    (local.set 0x125 (i64.load offset=0x125 align=1 (i32.const 0)))
+    (local.set 0x126 (i64.load offset=0x126 align=1 (i32.const 0)))
+    (local.set 0x127 (i64.load offset=0x127 align=1 (i32.const 0)))
+    (local.set 0x128 (i64.load offset=0x128 align=1 (i32.const 0)))
+    (local.set 0x129 (i64.load offset=0x129 align=1 (i32.const 0)))
+    (local.set 0x12a (i64.load offset=0x12a align=1 (i32.const 0)))
+    (local.set 0x12b (i64.load offset=0x12b align=1 (i32.const 0)))
+    (local.set 0x12c (i64.load offset=0x12c align=1 (i32.const 0)))
+    (local.set 0x12d (i64.load offset=0x12d align=1 (i32.const 0)))
+    (local.set 0x12e (i64.load offset=0x12e align=1 (i32.const 0)))
+    (local.set 0x12f (i64.load offset=0x12f align=1 (i32.const 0)))
+    (local.set 0x130 (i64.load offset=0x130 align=1 (i32.const 0)))
+    (local.set 0x131 (i64.load offset=0x131 align=1 (i32.const 0)))
+    (local.set 0x132 (i64.load offset=0x132 align=1 (i32.const 0)))
+    (local.set 0x133 (i64.load offset=0x133 align=1 (i32.const 0)))
+    (local.set 0x134 (i64.load offset=0x134 align=1 (i32.const 0)))
+    (local.set 0x135 (i64.load offset=0x135 align=1 (i32.const 0)))
+    (local.set 0x136 (i64.load offset=0x136 align=1 (i32.const 0)))
+    (local.set 0x137 (i64.load offset=0x137 align=1 (i32.const 0)))
+    (local.set 0x138 (i64.load offset=0x138 align=1 (i32.const 0)))
+    (local.set 0x139 (i64.load offset=0x139 align=1 (i32.const 0)))
+    (local.set 0x13a (i64.load offset=0x13a align=1 (i32.const 0)))
+    (local.set 0x13b (i64.load offset=0x13b align=1 (i32.const 0)))
+    (local.set 0x13c (i64.load offset=0x13c align=1 (i32.const 0)))
+    (local.set 0x13d (i64.load offset=0x13d align=1 (i32.const 0)))
+    (local.set 0x13e (i64.load offset=0x13e align=1 (i32.const 0)))
+    (local.set 0x13f (i64.load offset=0x13f align=1 (i32.const 0)))
+    (local.set 0x140 (i64.load offset=0x140 align=1 (i32.const 0)))
+    (local.set 0x141 (i64.load offset=0x141 align=1 (i32.const 0)))
+    (local.set 0x142 (i64.load offset=0x142 align=1 (i32.const 0)))
+    (local.set 0x143 (i64.load offset=0x143 align=1 (i32.const 0)))
+    (local.set 0x144 (i64.load offset=0x144 align=1 (i32.const 0)))
+    (local.set 0x145 (i64.load offset=0x145 align=1 (i32.const 0)))
+    (local.set 0x146 (i64.load offset=0x146 align=1 (i32.const 0)))
+    (local.set 0x147 (i64.load offset=0x147 align=1 (i32.const 0)))
+    (local.set 0x148 (i64.load offset=0x148 align=1 (i32.const 0)))
+    (local.set 0x149 (i64.load offset=0x149 align=1 (i32.const 0)))
+    (local.set 0x14a (i64.load offset=0x14a align=1 (i32.const 0)))
+    (local.set 0x14b (i64.load offset=0x14b align=1 (i32.const 0)))
+    (local.set 0x14c (i64.load offset=0x14c align=1 (i32.const 0)))
+    (local.set 0x14d (i64.load offset=0x14d align=1 (i32.const 0)))
+    (local.set 0x14e (i64.load offset=0x14e align=1 (i32.const 0)))
+    (local.set 0x14f (i64.load offset=0x14f align=1 (i32.const 0)))
+    (local.set 0x150 (i64.load offset=0x150 align=1 (i32.const 0)))
+    (local.set 0x151 (i64.load offset=0x151 align=1 (i32.const 0)))
+    (local.set 0x152 (i64.load offset=0x152 align=1 (i32.const 0)))
+    (local.set 0x153 (i64.load offset=0x153 align=1 (i32.const 0)))
+    (local.set 0x154 (i64.load offset=0x154 align=1 (i32.const 0)))
+    (local.set 0x155 (i64.load offset=0x155 align=1 (i32.const 0)))
+    (local.set 0x156 (i64.load offset=0x156 align=1 (i32.const 0)))
+    (local.set 0x157 (i64.load offset=0x157 align=1 (i32.const 0)))
+    (local.set 0x158 (i64.load offset=0x158 align=1 (i32.const 0)))
+    (local.set 0x159 (i64.load offset=0x159 align=1 (i32.const 0)))
+    (local.set 0x15a (i64.load offset=0x15a align=1 (i32.const 0)))
+    (local.set 0x15b (i64.load offset=0x15b align=1 (i32.const 0)))
+    (local.set 0x15c (i64.load offset=0x15c align=1 (i32.const 0)))
+    (local.set 0x15d (i64.load offset=0x15d align=1 (i32.const 0)))
+    (local.set 0x15e (i64.load offset=0x15e align=1 (i32.const 0)))
+    (local.set 0x15f (i64.load offset=0x15f align=1 (i32.const 0)))
+    (local.set 0x160 (i64.load offset=0x160 align=1 (i32.const 0)))
+    (local.set 0x161 (i64.load offset=0x161 align=1 (i32.const 0)))
+    (local.set 0x162 (i64.load offset=0x162 align=1 (i32.const 0)))
+    (local.set 0x163 (i64.load offset=0x163 align=1 (i32.const 0)))
+    (local.set 0x164 (i64.load offset=0x164 align=1 (i32.const 0)))
+    (local.set 0x165 (i64.load offset=0x165 align=1 (i32.const 0)))
+    (local.set 0x166 (i64.load offset=0x166 align=1 (i32.const 0)))
+    (local.set 0x167 (i64.load offset=0x167 align=1 (i32.const 0)))
+    (local.set 0x168 (i64.load offset=0x168 align=1 (i32.const 0)))
+    (local.set 0x169 (i64.load offset=0x169 align=1 (i32.const 0)))
+    (local.set 0x16a (i64.load offset=0x16a align=1 (i32.const 0)))
+    (local.set 0x16b (i64.load offset=0x16b align=1 (i32.const 0)))
+    (local.set 0x16c (i64.load offset=0x16c align=1 (i32.const 0)))
+    (local.set 0x16d (i64.load offset=0x16d align=1 (i32.const 0)))
+    (local.set 0x16e (i64.load offset=0x16e align=1 (i32.const 0)))
+    (local.set 0x16f (i64.load offset=0x16f align=1 (i32.const 0)))
+    (local.set 0x170 (i64.load offset=0x170 align=1 (i32.const 0)))
+    (local.set 0x171 (i64.load offset=0x171 align=1 (i32.const 0)))
+    (local.set 0x172 (i64.load offset=0x172 align=1 (i32.const 0)))
+    (local.set 0x173 (i64.load offset=0x173 align=1 (i32.const 0)))
+    (local.set 0x174 (i64.load offset=0x174 align=1 (i32.const 0)))
+    (local.set 0x175 (i64.load offset=0x175 align=1 (i32.const 0)))
+    (local.set 0x176 (i64.load offset=0x176 align=1 (i32.const 0)))
+    (local.set 0x177 (i64.load offset=0x177 align=1 (i32.const 0)))
+    (local.set 0x178 (i64.load offset=0x178 align=1 (i32.const 0)))
+    (local.set 0x179 (i64.load offset=0x179 align=1 (i32.const 0)))
+    (local.set 0x17a (i64.load offset=0x17a align=1 (i32.const 0)))
+    (local.set 0x17b (i64.load offset=0x17b align=1 (i32.const 0)))
+    (local.set 0x17c (i64.load offset=0x17c align=1 (i32.const 0)))
+    (local.set 0x17d (i64.load offset=0x17d align=1 (i32.const 0)))
+    (local.set 0x17e (i64.load offset=0x17e align=1 (i32.const 0)))
+    (local.set 0x17f (i64.load offset=0x17f align=1 (i32.const 0)))
+    (local.set 0x180 (i64.load offset=0x180 align=1 (i32.const 0)))
+    (local.set 0x181 (i64.load offset=0x181 align=1 (i32.const 0)))
+    (local.set 0x182 (i64.load offset=0x182 align=1 (i32.const 0)))
+    (local.set 0x183 (i64.load offset=0x183 align=1 (i32.const 0)))
+    (local.set 0x184 (i64.load offset=0x184 align=1 (i32.const 0)))
+    (local.set 0x185 (i64.load offset=0x185 align=1 (i32.const 0)))
+    (local.set 0x186 (i64.load offset=0x186 align=1 (i32.const 0)))
+    (local.set 0x187 (i64.load offset=0x187 align=1 (i32.const 0)))
+    (local.set 0x188 (i64.load offset=0x188 align=1 (i32.const 0)))
+    (local.set 0x189 (i64.load offset=0x189 align=1 (i32.const 0)))
+    (local.set 0x18a (i64.load offset=0x18a align=1 (i32.const 0)))
+    (local.set 0x18b (i64.load offset=0x18b align=1 (i32.const 0)))
+    (local.set 0x18c (i64.load offset=0x18c align=1 (i32.const 0)))
+    (local.set 0x18d (i64.load offset=0x18d align=1 (i32.const 0)))
+    (local.set 0x18e (i64.load offset=0x18e align=1 (i32.const 0)))
+    (local.set 0x18f (i64.load offset=0x18f align=1 (i32.const 0)))
+    (local.set 0x190 (i64.load offset=0x190 align=1 (i32.const 0)))
+    (local.set 0x191 (i64.load offset=0x191 align=1 (i32.const 0)))
+    (local.set 0x192 (i64.load offset=0x192 align=1 (i32.const 0)))
+    (local.set 0x193 (i64.load offset=0x193 align=1 (i32.const 0)))
+    (local.set 0x194 (i64.load offset=0x194 align=1 (i32.const 0)))
+    (local.set 0x195 (i64.load offset=0x195 align=1 (i32.const 0)))
+    (local.set 0x196 (i64.load offset=0x196 align=1 (i32.const 0)))
+    (local.set 0x197 (i64.load offset=0x197 align=1 (i32.const 0)))
+    (local.set 0x198 (i64.load offset=0x198 align=1 (i32.const 0)))
+    (local.set 0x199 (i64.load offset=0x199 align=1 (i32.const 0)))
+    (local.set 0x19a (i64.load offset=0x19a align=1 (i32.const 0)))
+    (local.set 0x19b (i64.load offset=0x19b align=1 (i32.const 0)))
+    (local.set 0x19c (i64.load offset=0x19c align=1 (i32.const 0)))
+    (local.set 0x19d (i64.load offset=0x19d align=1 (i32.const 0)))
+    (local.set 0x19e (i64.load offset=0x19e align=1 (i32.const 0)))
+    (local.set 0x19f (i64.load offset=0x19f align=1 (i32.const 0)))
+    (local.set 0x1a0 (i64.load offset=0x1a0 align=1 (i32.const 0)))
+    (local.set 0x1a1 (i64.load offset=0x1a1 align=1 (i32.const 0)))
+    (local.set 0x1a2 (i64.load offset=0x1a2 align=1 (i32.const 0)))
+    (local.set 0x1a3 (i64.load offset=0x1a3 align=1 (i32.const 0)))
+    (local.set 0x1a4 (i64.load offset=0x1a4 align=1 (i32.const 0)))
+    (local.set 0x1a5 (i64.load offset=0x1a5 align=1 (i32.const 0)))
+    (local.set 0x1a6 (i64.load offset=0x1a6 align=1 (i32.const 0)))
+    (local.set 0x1a7 (i64.load offset=0x1a7 align=1 (i32.const 0)))
+    (local.set 0x1a8 (i64.load offset=0x1a8 align=1 (i32.const 0)))
+    (local.set 0x1a9 (i64.load offset=0x1a9 align=1 (i32.const 0)))
+    (local.set 0x1aa (i64.load offset=0x1aa align=1 (i32.const 0)))
+    (local.set 0x1ab (i64.load offset=0x1ab align=1 (i32.const 0)))
+    (local.set 0x1ac (i64.load offset=0x1ac align=1 (i32.const 0)))
+    (local.set 0x1ad (i64.load offset=0x1ad align=1 (i32.const 0)))
+    (local.set 0x1ae (i64.load offset=0x1ae align=1 (i32.const 0)))
+    (local.set 0x1af (i64.load offset=0x1af align=1 (i32.const 0)))
+    (local.set 0x1b0 (i64.load offset=0x1b0 align=1 (i32.const 0)))
+    (local.set 0x1b1 (i64.load offset=0x1b1 align=1 (i32.const 0)))
+    (local.set 0x1b2 (i64.load offset=0x1b2 align=1 (i32.const 0)))
+    (local.set 0x1b3 (i64.load offset=0x1b3 align=1 (i32.const 0)))
+    (local.set 0x1b4 (i64.load offset=0x1b4 align=1 (i32.const 0)))
+    (local.set 0x1b5 (i64.load offset=0x1b5 align=1 (i32.const 0)))
+    (local.set 0x1b6 (i64.load offset=0x1b6 align=1 (i32.const 0)))
+    (local.set 0x1b7 (i64.load offset=0x1b7 align=1 (i32.const 0)))
+    (local.set 0x1b8 (i64.load offset=0x1b8 align=1 (i32.const 0)))
+    (local.set 0x1b9 (i64.load offset=0x1b9 align=1 (i32.const 0)))
+    (local.set 0x1ba (i64.load offset=0x1ba align=1 (i32.const 0)))
+    (local.set 0x1bb (i64.load offset=0x1bb align=1 (i32.const 0)))
+    (local.set 0x1bc (i64.load offset=0x1bc align=1 (i32.const 0)))
+    (local.set 0x1bd (i64.load offset=0x1bd align=1 (i32.const 0)))
+    (local.set 0x1be (i64.load offset=0x1be align=1 (i32.const 0)))
+    (local.set 0x1bf (i64.load offset=0x1bf align=1 (i32.const 0)))
+    (local.set 0x1c0 (i64.load offset=0x1c0 align=1 (i32.const 0)))
+    (local.set 0x1c1 (i64.load offset=0x1c1 align=1 (i32.const 0)))
+    (local.set 0x1c2 (i64.load offset=0x1c2 align=1 (i32.const 0)))
+    (local.set 0x1c3 (i64.load offset=0x1c3 align=1 (i32.const 0)))
+    (local.set 0x1c4 (i64.load offset=0x1c4 align=1 (i32.const 0)))
+    (local.set 0x1c5 (i64.load offset=0x1c5 align=1 (i32.const 0)))
+    (local.set 0x1c6 (i64.load offset=0x1c6 align=1 (i32.const 0)))
+    (local.set 0x1c7 (i64.load offset=0x1c7 align=1 (i32.const 0)))
+    (local.set 0x1c8 (i64.load offset=0x1c8 align=1 (i32.const 0)))
+    (local.set 0x1c9 (i64.load offset=0x1c9 align=1 (i32.const 0)))
+    (local.set 0x1ca (i64.load offset=0x1ca align=1 (i32.const 0)))
+    (local.set 0x1cb (i64.load offset=0x1cb align=1 (i32.const 0)))
+    (local.set 0x1cc (i64.load offset=0x1cc align=1 (i32.const 0)))
+    (local.set 0x1cd (i64.load offset=0x1cd align=1 (i32.const 0)))
+    (local.set 0x1ce (i64.load offset=0x1ce align=1 (i32.const 0)))
+    (local.set 0x1cf (i64.load offset=0x1cf align=1 (i32.const 0)))
+    (local.set 0x1d0 (i64.load offset=0x1d0 align=1 (i32.const 0)))
+    (local.set 0x1d1 (i64.load offset=0x1d1 align=1 (i32.const 0)))
+    (local.set 0x1d2 (i64.load offset=0x1d2 align=1 (i32.const 0)))
+    (local.set 0x1d3 (i64.load offset=0x1d3 align=1 (i32.const 0)))
+    (local.set 0x1d4 (i64.load offset=0x1d4 align=1 (i32.const 0)))
+    (local.set 0x1d5 (i64.load offset=0x1d5 align=1 (i32.const 0)))
+    (local.set 0x1d6 (i64.load offset=0x1d6 align=1 (i32.const 0)))
+    (local.set 0x1d7 (i64.load offset=0x1d7 align=1 (i32.const 0)))
+    (local.set 0x1d8 (i64.load offset=0x1d8 align=1 (i32.const 0)))
+    (local.set 0x1d9 (i64.load offset=0x1d9 align=1 (i32.const 0)))
+    (local.set 0x1da (i64.load offset=0x1da align=1 (i32.const 0)))
+    (local.set 0x1db (i64.load offset=0x1db align=1 (i32.const 0)))
+    (local.set 0x1dc (i64.load offset=0x1dc align=1 (i32.const 0)))
+    (local.set 0x1dd (i64.load offset=0x1dd align=1 (i32.const 0)))
+    (local.set 0x1de (i64.load offset=0x1de align=1 (i32.const 0)))
+    (local.set 0x1df (i64.load offset=0x1df align=1 (i32.const 0)))
+    (local.set 0x1e0 (i64.load offset=0x1e0 align=1 (i32.const 0)))
+    (local.set 0x1e1 (i64.load offset=0x1e1 align=1 (i32.const 0)))
+    (local.set 0x1e2 (i64.load offset=0x1e2 align=1 (i32.const 0)))
+    (local.set 0x1e3 (i64.load offset=0x1e3 align=1 (i32.const 0)))
+    (local.set 0x1e4 (i64.load offset=0x1e4 align=1 (i32.const 0)))
+    (local.set 0x1e5 (i64.load offset=0x1e5 align=1 (i32.const 0)))
+    (local.set 0x1e6 (i64.load offset=0x1e6 align=1 (i32.const 0)))
+    (local.set 0x1e7 (i64.load offset=0x1e7 align=1 (i32.const 0)))
+    (local.set 0x1e8 (i64.load offset=0x1e8 align=1 (i32.const 0)))
+    (local.set 0x1e9 (i64.load offset=0x1e9 align=1 (i32.const 0)))
+    (local.set 0x1ea (i64.load offset=0x1ea align=1 (i32.const 0)))
+    (local.set 0x1eb (i64.load offset=0x1eb align=1 (i32.const 0)))
+    (local.set 0x1ec (i64.load offset=0x1ec align=1 (i32.const 0)))
+    (local.set 0x1ed (i64.load offset=0x1ed align=1 (i32.const 0)))
+    (local.set 0x1ee (i64.load offset=0x1ee align=1 (i32.const 0)))
+    (local.set 0x1ef (i64.load offset=0x1ef align=1 (i32.const 0)))
+    (local.set 0x1f0 (i64.load offset=0x1f0 align=1 (i32.const 0)))
+    (local.set 0x1f1 (i64.load offset=0x1f1 align=1 (i32.const 0)))
+    (local.set 0x1f2 (i64.load offset=0x1f2 align=1 (i32.const 0)))
+    (local.set 0x1f3 (i64.load offset=0x1f3 align=1 (i32.const 0)))
+    (local.set 0x1f4 (i64.load offset=0x1f4 align=1 (i32.const 0)))
+    (local.set 0x1f5 (i64.load offset=0x1f5 align=1 (i32.const 0)))
+    (local.set 0x1f6 (i64.load offset=0x1f6 align=1 (i32.const 0)))
+    (local.set 0x1f7 (i64.load offset=0x1f7 align=1 (i32.const 0)))
+    (local.set 0x1f8 (i64.load offset=0x1f8 align=1 (i32.const 0)))
+    (local.set 0x1f9 (i64.load offset=0x1f9 align=1 (i32.const 0)))
+    (local.set 0x1fa (i64.load offset=0x1fa align=1 (i32.const 0)))
+    (local.set 0x1fb (i64.load offset=0x1fb align=1 (i32.const 0)))
+    (local.set 0x1fc (i64.load offset=0x1fc align=1 (i32.const 0)))
+    (local.set 0x1fd (i64.load offset=0x1fd align=1 (i32.const 0)))
+    (local.set 0x1fe (i64.load offset=0x1fe align=1 (i32.const 0)))
+    (local.set 0x1ff (i64.load offset=0x1ff align=1 (i32.const 0)))
+    (local.set 0x200 (i64.load offset=0x200 align=1 (i32.const 0)))
+    (local.set 0x201 (i64.load offset=0x201 align=1 (i32.const 0)))
+    (local.set 0x202 (i64.load offset=0x202 align=1 (i32.const 0)))
+    (local.set 0x203 (i64.load offset=0x203 align=1 (i32.const 0)))
+    (local.set 0x204 (i64.load offset=0x204 align=1 (i32.const 0)))
+    (local.set 0x205 (i64.load offset=0x205 align=1 (i32.const 0)))
+    (local.set 0x206 (i64.load offset=0x206 align=1 (i32.const 0)))
+    (local.set 0x207 (i64.load offset=0x207 align=1 (i32.const 0)))
+    (local.set 0x208 (i64.load offset=0x208 align=1 (i32.const 0)))
+    (local.set 0x209 (i64.load offset=0x209 align=1 (i32.const 0)))
+    (local.set 0x20a (i64.load offset=0x20a align=1 (i32.const 0)))
+    (local.set 0x20b (i64.load offset=0x20b align=1 (i32.const 0)))
+    (local.set 0x20c (i64.load offset=0x20c align=1 (i32.const 0)))
+    (local.set 0x20d (i64.load offset=0x20d align=1 (i32.const 0)))
+    (local.set 0x20e (i64.load offset=0x20e align=1 (i32.const 0)))
+    (local.set 0x20f (i64.load offset=0x20f align=1 (i32.const 0)))
+    (local.set 0x210 (i64.load offset=0x210 align=1 (i32.const 0)))
+    (local.set 0x211 (i64.load offset=0x211 align=1 (i32.const 0)))
+    (local.set 0x212 (i64.load offset=0x212 align=1 (i32.const 0)))
+    (local.set 0x213 (i64.load offset=0x213 align=1 (i32.const 0)))
+    (local.set 0x214 (i64.load offset=0x214 align=1 (i32.const 0)))
+    (local.set 0x215 (i64.load offset=0x215 align=1 (i32.const 0)))
+    (local.set 0x216 (i64.load offset=0x216 align=1 (i32.const 0)))
+    (local.set 0x217 (i64.load offset=0x217 align=1 (i32.const 0)))
+    (local.set 0x218 (i64.load offset=0x218 align=1 (i32.const 0)))
+    (local.set 0x219 (i64.load offset=0x219 align=1 (i32.const 0)))
+    (local.set 0x21a (i64.load offset=0x21a align=1 (i32.const 0)))
+    (local.set 0x21b (i64.load offset=0x21b align=1 (i32.const 0)))
+    (local.set 0x21c (i64.load offset=0x21c align=1 (i32.const 0)))
+    (local.set 0x21d (i64.load offset=0x21d align=1 (i32.const 0)))
+    (local.set 0x21e (i64.load offset=0x21e align=1 (i32.const 0)))
+    (local.set 0x21f (i64.load offset=0x21f align=1 (i32.const 0)))
+    (local.set 0x220 (i64.load offset=0x220 align=1 (i32.const 0)))
+    (local.set 0x221 (i64.load offset=0x221 align=1 (i32.const 0)))
+    (local.set 0x222 (i64.load offset=0x222 align=1 (i32.const 0)))
+    (local.set 0x223 (i64.load offset=0x223 align=1 (i32.const 0)))
+    (local.set 0x224 (i64.load offset=0x224 align=1 (i32.const 0)))
+    (local.set 0x225 (i64.load offset=0x225 align=1 (i32.const 0)))
+    (local.set 0x226 (i64.load offset=0x226 align=1 (i32.const 0)))
+    (local.set 0x227 (i64.load offset=0x227 align=1 (i32.const 0)))
+    (local.set 0x228 (i64.load offset=0x228 align=1 (i32.const 0)))
+    (local.set 0x229 (i64.load offset=0x229 align=1 (i32.const 0)))
+    (local.set 0x22a (i64.load offset=0x22a align=1 (i32.const 0)))
+    (local.set 0x22b (i64.load offset=0x22b align=1 (i32.const 0)))
+    (local.set 0x22c (i64.load offset=0x22c align=1 (i32.const 0)))
+    (local.set 0x22d (i64.load offset=0x22d align=1 (i32.const 0)))
+    (local.set 0x22e (i64.load offset=0x22e align=1 (i32.const 0)))
+    (local.set 0x22f (i64.load offset=0x22f align=1 (i32.const 0)))
+    (local.set 0x230 (i64.load offset=0x230 align=1 (i32.const 0)))
+    (local.set 0x231 (i64.load offset=0x231 align=1 (i32.const 0)))
+    (local.set 0x232 (i64.load offset=0x232 align=1 (i32.const 0)))
+    (local.set 0x233 (i64.load offset=0x233 align=1 (i32.const 0)))
+    (local.set 0x234 (i64.load offset=0x234 align=1 (i32.const 0)))
+    (local.set 0x235 (i64.load offset=0x235 align=1 (i32.const 0)))
+    (local.set 0x236 (i64.load offset=0x236 align=1 (i32.const 0)))
+    (local.set 0x237 (i64.load offset=0x237 align=1 (i32.const 0)))
+    (local.set 0x238 (i64.load offset=0x238 align=1 (i32.const 0)))
+    (local.set 0x239 (i64.load offset=0x239 align=1 (i32.const 0)))
+    (local.set 0x23a (i64.load offset=0x23a align=1 (i32.const 0)))
+    (local.set 0x23b (i64.load offset=0x23b align=1 (i32.const 0)))
+    (local.set 0x23c (i64.load offset=0x23c align=1 (i32.const 0)))
+    (local.set 0x23d (i64.load offset=0x23d align=1 (i32.const 0)))
+    (local.set 0x23e (i64.load offset=0x23e align=1 (i32.const 0)))
+    (local.set 0x23f (i64.load offset=0x23f align=1 (i32.const 0)))
+    (local.set 0x240 (i64.load offset=0x240 align=1 (i32.const 0)))
+    (local.set 0x241 (i64.load offset=0x241 align=1 (i32.const 0)))
+    (local.set 0x242 (i64.load offset=0x242 align=1 (i32.const 0)))
+    (local.set 0x243 (i64.load offset=0x243 align=1 (i32.const 0)))
+    (local.set 0x244 (i64.load offset=0x244 align=1 (i32.const 0)))
+    (local.set 0x245 (i64.load offset=0x245 align=1 (i32.const 0)))
+    (local.set 0x246 (i64.load offset=0x246 align=1 (i32.const 0)))
+    (local.set 0x247 (i64.load offset=0x247 align=1 (i32.const 0)))
+    (local.set 0x248 (i64.load offset=0x248 align=1 (i32.const 0)))
+    (local.set 0x249 (i64.load offset=0x249 align=1 (i32.const 0)))
+    (local.set 0x24a (i64.load offset=0x24a align=1 (i32.const 0)))
+    (local.set 0x24b (i64.load offset=0x24b align=1 (i32.const 0)))
+    (local.set 0x24c (i64.load offset=0x24c align=1 (i32.const 0)))
+    (local.set 0x24d (i64.load offset=0x24d align=1 (i32.const 0)))
+    (local.set 0x24e (i64.load offset=0x24e align=1 (i32.const 0)))
+    (local.set 0x24f (i64.load offset=0x24f align=1 (i32.const 0)))
+    (local.set 0x250 (i64.load offset=0x250 align=1 (i32.const 0)))
+    (local.set 0x251 (i64.load offset=0x251 align=1 (i32.const 0)))
+    (local.set 0x252 (i64.load offset=0x252 align=1 (i32.const 0)))
+    (local.set 0x253 (i64.load offset=0x253 align=1 (i32.const 0)))
+    (local.set 0x254 (i64.load offset=0x254 align=1 (i32.const 0)))
+    (local.set 0x255 (i64.load offset=0x255 align=1 (i32.const 0)))
+    (local.set 0x256 (i64.load offset=0x256 align=1 (i32.const 0)))
+    (local.set 0x257 (i64.load offset=0x257 align=1 (i32.const 0)))
+    (local.set 0x258 (i64.load offset=0x258 align=1 (i32.const 0)))
+    (local.set 0x259 (i64.load offset=0x259 align=1 (i32.const 0)))
+    (local.set 0x25a (i64.load offset=0x25a align=1 (i32.const 0)))
+    (local.set 0x25b (i64.load offset=0x25b align=1 (i32.const 0)))
+    (local.set 0x25c (i64.load offset=0x25c align=1 (i32.const 0)))
+    (local.set 0x25d (i64.load offset=0x25d align=1 (i32.const 0)))
+    (local.set 0x25e (i64.load offset=0x25e align=1 (i32.const 0)))
+    (local.set 0x25f (i64.load offset=0x25f align=1 (i32.const 0)))
+    (local.set 0x260 (i64.load offset=0x260 align=1 (i32.const 0)))
+    (local.set 0x261 (i64.load offset=0x261 align=1 (i32.const 0)))
+    (local.set 0x262 (i64.load offset=0x262 align=1 (i32.const 0)))
+    (local.set 0x263 (i64.load offset=0x263 align=1 (i32.const 0)))
+    (local.set 0x264 (i64.load offset=0x264 align=1 (i32.const 0)))
+    (local.set 0x265 (i64.load offset=0x265 align=1 (i32.const 0)))
+    (local.set 0x266 (i64.load offset=0x266 align=1 (i32.const 0)))
+    (local.set 0x267 (i64.load offset=0x267 align=1 (i32.const 0)))
+    (local.set 0x268 (i64.load offset=0x268 align=1 (i32.const 0)))
+    (local.set 0x269 (i64.load offset=0x269 align=1 (i32.const 0)))
+    (local.set 0x26a (i64.load offset=0x26a align=1 (i32.const 0)))
+    (local.set 0x26b (i64.load offset=0x26b align=1 (i32.const 0)))
+    (local.set 0x26c (i64.load offset=0x26c align=1 (i32.const 0)))
+    (local.set 0x26d (i64.load offset=0x26d align=1 (i32.const 0)))
+    (local.set 0x26e (i64.load offset=0x26e align=1 (i32.const 0)))
+    (local.set 0x26f (i64.load offset=0x26f align=1 (i32.const 0)))
+    (local.set 0x270 (i64.load offset=0x270 align=1 (i32.const 0)))
+    (local.set 0x271 (i64.load offset=0x271 align=1 (i32.const 0)))
+    (local.set 0x272 (i64.load offset=0x272 align=1 (i32.const 0)))
+    (local.set 0x273 (i64.load offset=0x273 align=1 (i32.const 0)))
+    (local.set 0x274 (i64.load offset=0x274 align=1 (i32.const 0)))
+    (local.set 0x275 (i64.load offset=0x275 align=1 (i32.const 0)))
+    (local.set 0x276 (i64.load offset=0x276 align=1 (i32.const 0)))
+    (local.set 0x277 (i64.load offset=0x277 align=1 (i32.const 0)))
+    (local.set 0x278 (i64.load offset=0x278 align=1 (i32.const 0)))
+    (local.set 0x279 (i64.load offset=0x279 align=1 (i32.const 0)))
+    (local.set 0x27a (i64.load offset=0x27a align=1 (i32.const 0)))
+    (local.set 0x27b (i64.load offset=0x27b align=1 (i32.const 0)))
+    (local.set 0x27c (i64.load offset=0x27c align=1 (i32.const 0)))
+    (local.set 0x27d (i64.load offset=0x27d align=1 (i32.const 0)))
+    (local.set 0x27e (i64.load offset=0x27e align=1 (i32.const 0)))
+    (local.set 0x27f (i64.load offset=0x27f align=1 (i32.const 0)))
+    (local.set 0x280 (i64.load offset=0x280 align=1 (i32.const 0)))
+    (local.set 0x281 (i64.load offset=0x281 align=1 (i32.const 0)))
+    (local.set 0x282 (i64.load offset=0x282 align=1 (i32.const 0)))
+    (local.set 0x283 (i64.load offset=0x283 align=1 (i32.const 0)))
+    (local.set 0x284 (i64.load offset=0x284 align=1 (i32.const 0)))
+    (local.set 0x285 (i64.load offset=0x285 align=1 (i32.const 0)))
+    (local.set 0x286 (i64.load offset=0x286 align=1 (i32.const 0)))
+    (local.set 0x287 (i64.load offset=0x287 align=1 (i32.const 0)))
+    (local.set 0x288 (i64.load offset=0x288 align=1 (i32.const 0)))
+    (local.set 0x289 (i64.load offset=0x289 align=1 (i32.const 0)))
+    (local.set 0x28a (i64.load offset=0x28a align=1 (i32.const 0)))
+    (local.set 0x28b (i64.load offset=0x28b align=1 (i32.const 0)))
+    (local.set 0x28c (i64.load offset=0x28c align=1 (i32.const 0)))
+    (local.set 0x28d (i64.load offset=0x28d align=1 (i32.const 0)))
+    (local.set 0x28e (i64.load offset=0x28e align=1 (i32.const 0)))
+    (local.set 0x28f (i64.load offset=0x28f align=1 (i32.const 0)))
+    (local.set 0x290 (i64.load offset=0x290 align=1 (i32.const 0)))
+    (local.set 0x291 (i64.load offset=0x291 align=1 (i32.const 0)))
+    (local.set 0x292 (i64.load offset=0x292 align=1 (i32.const 0)))
+    (local.set 0x293 (i64.load offset=0x293 align=1 (i32.const 0)))
+    (local.set 0x294 (i64.load offset=0x294 align=1 (i32.const 0)))
+    (local.set 0x295 (i64.load offset=0x295 align=1 (i32.const 0)))
+    (local.set 0x296 (i64.load offset=0x296 align=1 (i32.const 0)))
+    (local.set 0x297 (i64.load offset=0x297 align=1 (i32.const 0)))
+    (local.set 0x298 (i64.load offset=0x298 align=1 (i32.const 0)))
+    (local.set 0x299 (i64.load offset=0x299 align=1 (i32.const 0)))
+    (local.set 0x29a (i64.load offset=0x29a align=1 (i32.const 0)))
+    (local.set 0x29b (i64.load offset=0x29b align=1 (i32.const 0)))
+    (local.set 0x29c (i64.load offset=0x29c align=1 (i32.const 0)))
+    (local.set 0x29d (i64.load offset=0x29d align=1 (i32.const 0)))
+    (local.set 0x29e (i64.load offset=0x29e align=1 (i32.const 0)))
+    (local.set 0x29f (i64.load offset=0x29f align=1 (i32.const 0)))
+    (local.set 0x2a0 (i64.load offset=0x2a0 align=1 (i32.const 0)))
+    (local.set 0x2a1 (i64.load offset=0x2a1 align=1 (i32.const 0)))
+    (local.set 0x2a2 (i64.load offset=0x2a2 align=1 (i32.const 0)))
+    (local.set 0x2a3 (i64.load offset=0x2a3 align=1 (i32.const 0)))
+    (local.set 0x2a4 (i64.load offset=0x2a4 align=1 (i32.const 0)))
+    (local.set 0x2a5 (i64.load offset=0x2a5 align=1 (i32.const 0)))
+    (local.set 0x2a6 (i64.load offset=0x2a6 align=1 (i32.const 0)))
+    (local.set 0x2a7 (i64.load offset=0x2a7 align=1 (i32.const 0)))
+    (local.set 0x2a8 (i64.load offset=0x2a8 align=1 (i32.const 0)))
+    (local.set 0x2a9 (i64.load offset=0x2a9 align=1 (i32.const 0)))
+    (local.set 0x2aa (i64.load offset=0x2aa align=1 (i32.const 0)))
+    (local.set 0x2ab (i64.load offset=0x2ab align=1 (i32.const 0)))
+    (local.set 0x2ac (i64.load offset=0x2ac align=1 (i32.const 0)))
+    (local.set 0x2ad (i64.load offset=0x2ad align=1 (i32.const 0)))
+    (local.set 0x2ae (i64.load offset=0x2ae align=1 (i32.const 0)))
+    (local.set 0x2af (i64.load offset=0x2af align=1 (i32.const 0)))
+    (local.set 0x2b0 (i64.load offset=0x2b0 align=1 (i32.const 0)))
+    (local.set 0x2b1 (i64.load offset=0x2b1 align=1 (i32.const 0)))
+    (local.set 0x2b2 (i64.load offset=0x2b2 align=1 (i32.const 0)))
+    (local.set 0x2b3 (i64.load offset=0x2b3 align=1 (i32.const 0)))
+    (local.set 0x2b4 (i64.load offset=0x2b4 align=1 (i32.const 0)))
+    (local.set 0x2b5 (i64.load offset=0x2b5 align=1 (i32.const 0)))
+    (local.set 0x2b6 (i64.load offset=0x2b6 align=1 (i32.const 0)))
+    (local.set 0x2b7 (i64.load offset=0x2b7 align=1 (i32.const 0)))
+    (local.set 0x2b8 (i64.load offset=0x2b8 align=1 (i32.const 0)))
+    (local.set 0x2b9 (i64.load offset=0x2b9 align=1 (i32.const 0)))
+    (local.set 0x2ba (i64.load offset=0x2ba align=1 (i32.const 0)))
+    (local.set 0x2bb (i64.load offset=0x2bb align=1 (i32.const 0)))
+    (local.set 0x2bc (i64.load offset=0x2bc align=1 (i32.const 0)))
+    (local.set 0x2bd (i64.load offset=0x2bd align=1 (i32.const 0)))
+    (local.set 0x2be (i64.load offset=0x2be align=1 (i32.const 0)))
+    (local.set 0x2bf (i64.load offset=0x2bf align=1 (i32.const 0)))
+    (local.set 0x2c0 (i64.load offset=0x2c0 align=1 (i32.const 0)))
+    (local.set 0x2c1 (i64.load offset=0x2c1 align=1 (i32.const 0)))
+    (local.set 0x2c2 (i64.load offset=0x2c2 align=1 (i32.const 0)))
+    (local.set 0x2c3 (i64.load offset=0x2c3 align=1 (i32.const 0)))
+    (local.set 0x2c4 (i64.load offset=0x2c4 align=1 (i32.const 0)))
+    (local.set 0x2c5 (i64.load offset=0x2c5 align=1 (i32.const 0)))
+    (local.set 0x2c6 (i64.load offset=0x2c6 align=1 (i32.const 0)))
+    (local.set 0x2c7 (i64.load offset=0x2c7 align=1 (i32.const 0)))
+    (local.set 0x2c8 (i64.load offset=0x2c8 align=1 (i32.const 0)))
+    (local.set 0x2c9 (i64.load offset=0x2c9 align=1 (i32.const 0)))
+    (local.set 0x2ca (i64.load offset=0x2ca align=1 (i32.const 0)))
+    (local.set 0x2cb (i64.load offset=0x2cb align=1 (i32.const 0)))
+    (local.set 0x2cc (i64.load offset=0x2cc align=1 (i32.const 0)))
+    (local.set 0x2cd (i64.load offset=0x2cd align=1 (i32.const 0)))
+    (local.set 0x2ce (i64.load offset=0x2ce align=1 (i32.const 0)))
+    (local.set 0x2cf (i64.load offset=0x2cf align=1 (i32.const 0)))
+    (local.set 0x2d0 (i64.load offset=0x2d0 align=1 (i32.const 0)))
+    (local.set 0x2d1 (i64.load offset=0x2d1 align=1 (i32.const 0)))
+    (local.set 0x2d2 (i64.load offset=0x2d2 align=1 (i32.const 0)))
+    (local.set 0x2d3 (i64.load offset=0x2d3 align=1 (i32.const 0)))
+    (local.set 0x2d4 (i64.load offset=0x2d4 align=1 (i32.const 0)))
+    (local.set 0x2d5 (i64.load offset=0x2d5 align=1 (i32.const 0)))
+    (local.set 0x2d6 (i64.load offset=0x2d6 align=1 (i32.const 0)))
+    (local.set 0x2d7 (i64.load offset=0x2d7 align=1 (i32.const 0)))
+    (local.set 0x2d8 (i64.load offset=0x2d8 align=1 (i32.const 0)))
+    (local.set 0x2d9 (i64.load offset=0x2d9 align=1 (i32.const 0)))
+    (local.set 0x2da (i64.load offset=0x2da align=1 (i32.const 0)))
+    (local.set 0x2db (i64.load offset=0x2db align=1 (i32.const 0)))
+    (local.set 0x2dc (i64.load offset=0x2dc align=1 (i32.const 0)))
+    (local.set 0x2dd (i64.load offset=0x2dd align=1 (i32.const 0)))
+    (local.set 0x2de (i64.load offset=0x2de align=1 (i32.const 0)))
+    (local.set 0x2df (i64.load offset=0x2df align=1 (i32.const 0)))
+    (local.set 0x2e0 (i64.load offset=0x2e0 align=1 (i32.const 0)))
+    (local.set 0x2e1 (i64.load offset=0x2e1 align=1 (i32.const 0)))
+    (local.set 0x2e2 (i64.load offset=0x2e2 align=1 (i32.const 0)))
+    (local.set 0x2e3 (i64.load offset=0x2e3 align=1 (i32.const 0)))
+    (local.set 0x2e4 (i64.load offset=0x2e4 align=1 (i32.const 0)))
+    (local.set 0x2e5 (i64.load offset=0x2e5 align=1 (i32.const 0)))
+    (local.set 0x2e6 (i64.load offset=0x2e6 align=1 (i32.const 0)))
+    (local.set 0x2e7 (i64.load offset=0x2e7 align=1 (i32.const 0)))
+    (local.set 0x2e8 (i64.load offset=0x2e8 align=1 (i32.const 0)))
+    (local.set 0x2e9 (i64.load offset=0x2e9 align=1 (i32.const 0)))
+    (local.set 0x2ea (i64.load offset=0x2ea align=1 (i32.const 0)))
+    (local.set 0x2eb (i64.load offset=0x2eb align=1 (i32.const 0)))
+    (local.set 0x2ec (i64.load offset=0x2ec align=1 (i32.const 0)))
+    (local.set 0x2ed (i64.load offset=0x2ed align=1 (i32.const 0)))
+    (local.set 0x2ee (i64.load offset=0x2ee align=1 (i32.const 0)))
+    (local.set 0x2ef (i64.load offset=0x2ef align=1 (i32.const 0)))
+    (local.set 0x2f0 (i64.load offset=0x2f0 align=1 (i32.const 0)))
+    (local.set 0x2f1 (i64.load offset=0x2f1 align=1 (i32.const 0)))
+    (local.set 0x2f2 (i64.load offset=0x2f2 align=1 (i32.const 0)))
+    (local.set 0x2f3 (i64.load offset=0x2f3 align=1 (i32.const 0)))
+    (local.set 0x2f4 (i64.load offset=0x2f4 align=1 (i32.const 0)))
+    (local.set 0x2f5 (i64.load offset=0x2f5 align=1 (i32.const 0)))
+    (local.set 0x2f6 (i64.load offset=0x2f6 align=1 (i32.const 0)))
+    (local.set 0x2f7 (i64.load offset=0x2f7 align=1 (i32.const 0)))
+    (local.set 0x2f8 (i64.load offset=0x2f8 align=1 (i32.const 0)))
+    (local.set 0x2f9 (i64.load offset=0x2f9 align=1 (i32.const 0)))
+    (local.set 0x2fa (i64.load offset=0x2fa align=1 (i32.const 0)))
+    (local.set 0x2fb (i64.load offset=0x2fb align=1 (i32.const 0)))
+    (local.set 0x2fc (i64.load offset=0x2fc align=1 (i32.const 0)))
+    (local.set 0x2fd (i64.load offset=0x2fd align=1 (i32.const 0)))
+    (local.set 0x2fe (i64.load offset=0x2fe align=1 (i32.const 0)))
+    (local.set 0x2ff (i64.load offset=0x2ff align=1 (i32.const 0)))
+    (local.set 0x300 (i64.load offset=0x300 align=1 (i32.const 0)))
+    (local.set 0x301 (i64.load offset=0x301 align=1 (i32.const 0)))
+    (local.set 0x302 (i64.load offset=0x302 align=1 (i32.const 0)))
+    (local.set 0x303 (i64.load offset=0x303 align=1 (i32.const 0)))
+    (local.set 0x304 (i64.load offset=0x304 align=1 (i32.const 0)))
+    (local.set 0x305 (i64.load offset=0x305 align=1 (i32.const 0)))
+    (local.set 0x306 (i64.load offset=0x306 align=1 (i32.const 0)))
+    (local.set 0x307 (i64.load offset=0x307 align=1 (i32.const 0)))
+    (local.set 0x308 (i64.load offset=0x308 align=1 (i32.const 0)))
+    (local.set 0x309 (i64.load offset=0x309 align=1 (i32.const 0)))
+    (local.set 0x30a (i64.load offset=0x30a align=1 (i32.const 0)))
+    (local.set 0x30b (i64.load offset=0x30b align=1 (i32.const 0)))
+    (local.set 0x30c (i64.load offset=0x30c align=1 (i32.const 0)))
+    (local.set 0x30d (i64.load offset=0x30d align=1 (i32.const 0)))
+    (local.set 0x30e (i64.load offset=0x30e align=1 (i32.const 0)))
+    (local.set 0x30f (i64.load offset=0x30f align=1 (i32.const 0)))
+    (local.set 0x310 (i64.load offset=0x310 align=1 (i32.const 0)))
+    (local.set 0x311 (i64.load offset=0x311 align=1 (i32.const 0)))
+    (local.set 0x312 (i64.load offset=0x312 align=1 (i32.const 0)))
+    (local.set 0x313 (i64.load offset=0x313 align=1 (i32.const 0)))
+    (local.set 0x314 (i64.load offset=0x314 align=1 (i32.const 0)))
+    (local.set 0x315 (i64.load offset=0x315 align=1 (i32.const 0)))
+    (local.set 0x316 (i64.load offset=0x316 align=1 (i32.const 0)))
+    (local.set 0x317 (i64.load offset=0x317 align=1 (i32.const 0)))
+    (local.set 0x318 (i64.load offset=0x318 align=1 (i32.const 0)))
+    (local.set 0x319 (i64.load offset=0x319 align=1 (i32.const 0)))
+    (local.set 0x31a (i64.load offset=0x31a align=1 (i32.const 0)))
+    (local.set 0x31b (i64.load offset=0x31b align=1 (i32.const 0)))
+    (local.set 0x31c (i64.load offset=0x31c align=1 (i32.const 0)))
+    (local.set 0x31d (i64.load offset=0x31d align=1 (i32.const 0)))
+    (local.set 0x31e (i64.load offset=0x31e align=1 (i32.const 0)))
+    (local.set 0x31f (i64.load offset=0x31f align=1 (i32.const 0)))
+    (local.set 0x320 (i64.load offset=0x320 align=1 (i32.const 0)))
+    (local.set 0x321 (i64.load offset=0x321 align=1 (i32.const 0)))
+    (local.set 0x322 (i64.load offset=0x322 align=1 (i32.const 0)))
+    (local.set 0x323 (i64.load offset=0x323 align=1 (i32.const 0)))
+    (local.set 0x324 (i64.load offset=0x324 align=1 (i32.const 0)))
+    (local.set 0x325 (i64.load offset=0x325 align=1 (i32.const 0)))
+    (local.set 0x326 (i64.load offset=0x326 align=1 (i32.const 0)))
+    (local.set 0x327 (i64.load offset=0x327 align=1 (i32.const 0)))
+    (local.set 0x328 (i64.load offset=0x328 align=1 (i32.const 0)))
+    (local.set 0x329 (i64.load offset=0x329 align=1 (i32.const 0)))
+    (local.set 0x32a (i64.load offset=0x32a align=1 (i32.const 0)))
+    (local.set 0x32b (i64.load offset=0x32b align=1 (i32.const 0)))
+    (local.set 0x32c (i64.load offset=0x32c align=1 (i32.const 0)))
+    (local.set 0x32d (i64.load offset=0x32d align=1 (i32.const 0)))
+    (local.set 0x32e (i64.load offset=0x32e align=1 (i32.const 0)))
+    (local.set 0x32f (i64.load offset=0x32f align=1 (i32.const 0)))
+    (local.set 0x330 (i64.load offset=0x330 align=1 (i32.const 0)))
+    (local.set 0x331 (i64.load offset=0x331 align=1 (i32.const 0)))
+    (local.set 0x332 (i64.load offset=0x332 align=1 (i32.const 0)))
+    (local.set 0x333 (i64.load offset=0x333 align=1 (i32.const 0)))
+    (local.set 0x334 (i64.load offset=0x334 align=1 (i32.const 0)))
+    (local.set 0x335 (i64.load offset=0x335 align=1 (i32.const 0)))
+    (local.set 0x336 (i64.load offset=0x336 align=1 (i32.const 0)))
+    (local.set 0x337 (i64.load offset=0x337 align=1 (i32.const 0)))
+    (local.set 0x338 (i64.load offset=0x338 align=1 (i32.const 0)))
+    (local.set 0x339 (i64.load offset=0x339 align=1 (i32.const 0)))
+    (local.set 0x33a (i64.load offset=0x33a align=1 (i32.const 0)))
+    (local.set 0x33b (i64.load offset=0x33b align=1 (i32.const 0)))
+    (local.set 0x33c (i64.load offset=0x33c align=1 (i32.const 0)))
+    (local.set 0x33d (i64.load offset=0x33d align=1 (i32.const 0)))
+    (local.set 0x33e (i64.load offset=0x33e align=1 (i32.const 0)))
+    (local.set 0x33f (i64.load offset=0x33f align=1 (i32.const 0)))
+    (local.set 0x340 (i64.load offset=0x340 align=1 (i32.const 0)))
+    (local.set 0x341 (i64.load offset=0x341 align=1 (i32.const 0)))
+    (local.set 0x342 (i64.load offset=0x342 align=1 (i32.const 0)))
+    (local.set 0x343 (i64.load offset=0x343 align=1 (i32.const 0)))
+    (local.set 0x344 (i64.load offset=0x344 align=1 (i32.const 0)))
+    (local.set 0x345 (i64.load offset=0x345 align=1 (i32.const 0)))
+    (local.set 0x346 (i64.load offset=0x346 align=1 (i32.const 0)))
+    (local.set 0x347 (i64.load offset=0x347 align=1 (i32.const 0)))
+    (local.set 0x348 (i64.load offset=0x348 align=1 (i32.const 0)))
+    (local.set 0x349 (i64.load offset=0x349 align=1 (i32.const 0)))
+    (local.set 0x34a (i64.load offset=0x34a align=1 (i32.const 0)))
+    (local.set 0x34b (i64.load offset=0x34b align=1 (i32.const 0)))
+    (local.set 0x34c (i64.load offset=0x34c align=1 (i32.const 0)))
+    (local.set 0x34d (i64.load offset=0x34d align=1 (i32.const 0)))
+    (local.set 0x34e (i64.load offset=0x34e align=1 (i32.const 0)))
+    (local.set 0x34f (i64.load offset=0x34f align=1 (i32.const 0)))
+    (local.set 0x350 (i64.load offset=0x350 align=1 (i32.const 0)))
+    (local.set 0x351 (i64.load offset=0x351 align=1 (i32.const 0)))
+    (local.set 0x352 (i64.load offset=0x352 align=1 (i32.const 0)))
+    (local.set 0x353 (i64.load offset=0x353 align=1 (i32.const 0)))
+    (local.set 0x354 (i64.load offset=0x354 align=1 (i32.const 0)))
+    (local.set 0x355 (i64.load offset=0x355 align=1 (i32.const 0)))
+    (local.set 0x356 (i64.load offset=0x356 align=1 (i32.const 0)))
+    (local.set 0x357 (i64.load offset=0x357 align=1 (i32.const 0)))
+    (local.set 0x358 (i64.load offset=0x358 align=1 (i32.const 0)))
+    (local.set 0x359 (i64.load offset=0x359 align=1 (i32.const 0)))
+    (local.set 0x35a (i64.load offset=0x35a align=1 (i32.const 0)))
+    (local.set 0x35b (i64.load offset=0x35b align=1 (i32.const 0)))
+    (local.set 0x35c (i64.load offset=0x35c align=1 (i32.const 0)))
+    (local.set 0x35d (i64.load offset=0x35d align=1 (i32.const 0)))
+    (local.set 0x35e (i64.load offset=0x35e align=1 (i32.const 0)))
+    (local.set 0x35f (i64.load offset=0x35f align=1 (i32.const 0)))
+    (local.set 0x360 (i64.load offset=0x360 align=1 (i32.const 0)))
+    (local.set 0x361 (i64.load offset=0x361 align=1 (i32.const 0)))
+    (local.set 0x362 (i64.load offset=0x362 align=1 (i32.const 0)))
+    (local.set 0x363 (i64.load offset=0x363 align=1 (i32.const 0)))
+    (local.set 0x364 (i64.load offset=0x364 align=1 (i32.const 0)))
+    (local.set 0x365 (i64.load offset=0x365 align=1 (i32.const 0)))
+    (local.set 0x366 (i64.load offset=0x366 align=1 (i32.const 0)))
+    (local.set 0x367 (i64.load offset=0x367 align=1 (i32.const 0)))
+    (local.set 0x368 (i64.load offset=0x368 align=1 (i32.const 0)))
+    (local.set 0x369 (i64.load offset=0x369 align=1 (i32.const 0)))
+    (local.set 0x36a (i64.load offset=0x36a align=1 (i32.const 0)))
+    (local.set 0x36b (i64.load offset=0x36b align=1 (i32.const 0)))
+    (local.set 0x36c (i64.load offset=0x36c align=1 (i32.const 0)))
+    (local.set 0x36d (i64.load offset=0x36d align=1 (i32.const 0)))
+    (local.set 0x36e (i64.load offset=0x36e align=1 (i32.const 0)))
+    (local.set 0x36f (i64.load offset=0x36f align=1 (i32.const 0)))
+    (local.set 0x370 (i64.load offset=0x370 align=1 (i32.const 0)))
+    (local.set 0x371 (i64.load offset=0x371 align=1 (i32.const 0)))
+    (local.set 0x372 (i64.load offset=0x372 align=1 (i32.const 0)))
+    (local.set 0x373 (i64.load offset=0x373 align=1 (i32.const 0)))
+    (local.set 0x374 (i64.load offset=0x374 align=1 (i32.const 0)))
+    (local.set 0x375 (i64.load offset=0x375 align=1 (i32.const 0)))
+    (local.set 0x376 (i64.load offset=0x376 align=1 (i32.const 0)))
+    (local.set 0x377 (i64.load offset=0x377 align=1 (i32.const 0)))
+    (local.set 0x378 (i64.load offset=0x378 align=1 (i32.const 0)))
+    (local.set 0x379 (i64.load offset=0x379 align=1 (i32.const 0)))
+    (local.set 0x37a (i64.load offset=0x37a align=1 (i32.const 0)))
+    (local.set 0x37b (i64.load offset=0x37b align=1 (i32.const 0)))
+    (local.set 0x37c (i64.load offset=0x37c align=1 (i32.const 0)))
+    (local.set 0x37d (i64.load offset=0x37d align=1 (i32.const 0)))
+    (local.set 0x37e (i64.load offset=0x37e align=1 (i32.const 0)))
+    (local.set 0x37f (i64.load offset=0x37f align=1 (i32.const 0)))
+    (local.set 0x380 (i64.load offset=0x380 align=1 (i32.const 0)))
+    (local.set 0x381 (i64.load offset=0x381 align=1 (i32.const 0)))
+    (local.set 0x382 (i64.load offset=0x382 align=1 (i32.const 0)))
+    (local.set 0x383 (i64.load offset=0x383 align=1 (i32.const 0)))
+    (local.set 0x384 (i64.load offset=0x384 align=1 (i32.const 0)))
+    (local.set 0x385 (i64.load offset=0x385 align=1 (i32.const 0)))
+    (local.set 0x386 (i64.load offset=0x386 align=1 (i32.const 0)))
+    (local.set 0x387 (i64.load offset=0x387 align=1 (i32.const 0)))
+    (local.set 0x388 (i64.load offset=0x388 align=1 (i32.const 0)))
+    (local.set 0x389 (i64.load offset=0x389 align=1 (i32.const 0)))
+    (local.set 0x38a (i64.load offset=0x38a align=1 (i32.const 0)))
+    (local.set 0x38b (i64.load offset=0x38b align=1 (i32.const 0)))
+    (local.set 0x38c (i64.load offset=0x38c align=1 (i32.const 0)))
+    (local.set 0x38d (i64.load offset=0x38d align=1 (i32.const 0)))
+    (local.set 0x38e (i64.load offset=0x38e align=1 (i32.const 0)))
+    (local.set 0x38f (i64.load offset=0x38f align=1 (i32.const 0)))
+    (local.set 0x390 (i64.load offset=0x390 align=1 (i32.const 0)))
+    (local.set 0x391 (i64.load offset=0x391 align=1 (i32.const 0)))
+    (local.set 0x392 (i64.load offset=0x392 align=1 (i32.const 0)))
+    (local.set 0x393 (i64.load offset=0x393 align=1 (i32.const 0)))
+    (local.set 0x394 (i64.load offset=0x394 align=1 (i32.const 0)))
+    (local.set 0x395 (i64.load offset=0x395 align=1 (i32.const 0)))
+    (local.set 0x396 (i64.load offset=0x396 align=1 (i32.const 0)))
+    (local.set 0x397 (i64.load offset=0x397 align=1 (i32.const 0)))
+    (local.set 0x398 (i64.load offset=0x398 align=1 (i32.const 0)))
+    (local.set 0x399 (i64.load offset=0x399 align=1 (i32.const 0)))
+    (local.set 0x39a (i64.load offset=0x39a align=1 (i32.const 0)))
+    (local.set 0x39b (i64.load offset=0x39b align=1 (i32.const 0)))
+    (local.set 0x39c (i64.load offset=0x39c align=1 (i32.const 0)))
+    (local.set 0x39d (i64.load offset=0x39d align=1 (i32.const 0)))
+    (local.set 0x39e (i64.load offset=0x39e align=1 (i32.const 0)))
+    (local.set 0x39f (i64.load offset=0x39f align=1 (i32.const 0)))
+    (local.set 0x3a0 (i64.load offset=0x3a0 align=1 (i32.const 0)))
+    (local.set 0x3a1 (i64.load offset=0x3a1 align=1 (i32.const 0)))
+    (local.set 0x3a2 (i64.load offset=0x3a2 align=1 (i32.const 0)))
+    (local.set 0x3a3 (i64.load offset=0x3a3 align=1 (i32.const 0)))
+    (local.set 0x3a4 (i64.load offset=0x3a4 align=1 (i32.const 0)))
+    (local.set 0x3a5 (i64.load offset=0x3a5 align=1 (i32.const 0)))
+    (local.set 0x3a6 (i64.load offset=0x3a6 align=1 (i32.const 0)))
+    (local.set 0x3a7 (i64.load offset=0x3a7 align=1 (i32.const 0)))
+    (local.set 0x3a8 (i64.load offset=0x3a8 align=1 (i32.const 0)))
+    (local.set 0x3a9 (i64.load offset=0x3a9 align=1 (i32.const 0)))
+    (local.set 0x3aa (i64.load offset=0x3aa align=1 (i32.const 0)))
+    (local.set 0x3ab (i64.load offset=0x3ab align=1 (i32.const 0)))
+    (local.set 0x3ac (i64.load offset=0x3ac align=1 (i32.const 0)))
+    (local.set 0x3ad (i64.load offset=0x3ad align=1 (i32.const 0)))
+    (local.set 0x3ae (i64.load offset=0x3ae align=1 (i32.const 0)))
+    (local.set 0x3af (i64.load offset=0x3af align=1 (i32.const 0)))
+    (local.set 0x3b0 (i64.load offset=0x3b0 align=1 (i32.const 0)))
+    (local.set 0x3b1 (i64.load offset=0x3b1 align=1 (i32.const 0)))
+    (local.set 0x3b2 (i64.load offset=0x3b2 align=1 (i32.const 0)))
+    (local.set 0x3b3 (i64.load offset=0x3b3 align=1 (i32.const 0)))
+    (local.set 0x3b4 (i64.load offset=0x3b4 align=1 (i32.const 0)))
+    (local.set 0x3b5 (i64.load offset=0x3b5 align=1 (i32.const 0)))
+    (local.set 0x3b6 (i64.load offset=0x3b6 align=1 (i32.const 0)))
+    (local.set 0x3b7 (i64.load offset=0x3b7 align=1 (i32.const 0)))
+    (local.set 0x3b8 (i64.load offset=0x3b8 align=1 (i32.const 0)))
+    (local.set 0x3b9 (i64.load offset=0x3b9 align=1 (i32.const 0)))
+    (local.set 0x3ba (i64.load offset=0x3ba align=1 (i32.const 0)))
+    (local.set 0x3bb (i64.load offset=0x3bb align=1 (i32.const 0)))
+    (local.set 0x3bc (i64.load offset=0x3bc align=1 (i32.const 0)))
+    (local.set 0x3bd (i64.load offset=0x3bd align=1 (i32.const 0)))
+    (local.set 0x3be (i64.load offset=0x3be align=1 (i32.const 0)))
+    (local.set 0x3bf (i64.load offset=0x3bf align=1 (i32.const 0)))
+    (local.set 0x3c0 (i64.load offset=0x3c0 align=1 (i32.const 0)))
+    (local.set 0x3c1 (i64.load offset=0x3c1 align=1 (i32.const 0)))
+    (local.set 0x3c2 (i64.load offset=0x3c2 align=1 (i32.const 0)))
+    (local.set 0x3c3 (i64.load offset=0x3c3 align=1 (i32.const 0)))
+    (local.set 0x3c4 (i64.load offset=0x3c4 align=1 (i32.const 0)))
+    (local.set 0x3c5 (i64.load offset=0x3c5 align=1 (i32.const 0)))
+    (local.set 0x3c6 (i64.load offset=0x3c6 align=1 (i32.const 0)))
+    (local.set 0x3c7 (i64.load offset=0x3c7 align=1 (i32.const 0)))
+    (local.set 0x3c8 (i64.load offset=0x3c8 align=1 (i32.const 0)))
+    (local.set 0x3c9 (i64.load offset=0x3c9 align=1 (i32.const 0)))
+    (local.set 0x3ca (i64.load offset=0x3ca align=1 (i32.const 0)))
+    (local.set 0x3cb (i64.load offset=0x3cb align=1 (i32.const 0)))
+    (local.set 0x3cc (i64.load offset=0x3cc align=1 (i32.const 0)))
+    (local.set 0x3cd (i64.load offset=0x3cd align=1 (i32.const 0)))
+    (local.set 0x3ce (i64.load offset=0x3ce align=1 (i32.const 0)))
+    (local.set 0x3cf (i64.load offset=0x3cf align=1 (i32.const 0)))
+    (local.set 0x3d0 (i64.load offset=0x3d0 align=1 (i32.const 0)))
+    (local.set 0x3d1 (i64.load offset=0x3d1 align=1 (i32.const 0)))
+    (local.set 0x3d2 (i64.load offset=0x3d2 align=1 (i32.const 0)))
+    (local.set 0x3d3 (i64.load offset=0x3d3 align=1 (i32.const 0)))
+    (local.set 0x3d4 (i64.load offset=0x3d4 align=1 (i32.const 0)))
+    (local.set 0x3d5 (i64.load offset=0x3d5 align=1 (i32.const 0)))
+    (local.set 0x3d6 (i64.load offset=0x3d6 align=1 (i32.const 0)))
+    (local.set 0x3d7 (i64.load offset=0x3d7 align=1 (i32.const 0)))
+    (local.set 0x3d8 (i64.load offset=0x3d8 align=1 (i32.const 0)))
+    (local.set 0x3d9 (i64.load offset=0x3d9 align=1 (i32.const 0)))
+    (local.set 0x3da (i64.load offset=0x3da align=1 (i32.const 0)))
+    (local.set 0x3db (i64.load offset=0x3db align=1 (i32.const 0)))
+    (local.set 0x3dc (i64.load offset=0x3dc align=1 (i32.const 0)))
+    (local.set 0x3dd (i64.load offset=0x3dd align=1 (i32.const 0)))
+    (local.set 0x3de (i64.load offset=0x3de align=1 (i32.const 0)))
+    (local.set 0x3df (i64.load offset=0x3df align=1 (i32.const 0)))
+    (local.set 0x3e0 (i64.load offset=0x3e0 align=1 (i32.const 0)))
+    (local.set 0x3e1 (i64.load offset=0x3e1 align=1 (i32.const 0)))
+    (local.set 0x3e2 (i64.load offset=0x3e2 align=1 (i32.const 0)))
+    (local.set 0x3e3 (i64.load offset=0x3e3 align=1 (i32.const 0)))
+    (local.set 0x3e4 (i64.load offset=0x3e4 align=1 (i32.const 0)))
+    (local.set 0x3e5 (i64.load offset=0x3e5 align=1 (i32.const 0)))
+    (local.set 0x3e6 (i64.load offset=0x3e6 align=1 (i32.const 0)))
+    (local.set 0x3e7 (i64.load offset=0x3e7 align=1 (i32.const 0)))
+    (local.set 0x3e8 (i64.load offset=0x3e8 align=1 (i32.const 0)))
+    (local.set 0x3e9 (i64.load offset=0x3e9 align=1 (i32.const 0)))
+    (local.set 0x3ea (i64.load offset=0x3ea align=1 (i32.const 0)))
+    (local.set 0x3eb (i64.load offset=0x3eb align=1 (i32.const 0)))
+    (local.set 0x3ec (i64.load offset=0x3ec align=1 (i32.const 0)))
+    (local.set 0x3ed (i64.load offset=0x3ed align=1 (i32.const 0)))
+    (local.set 0x3ee (i64.load offset=0x3ee align=1 (i32.const 0)))
+    (local.set 0x3ef (i64.load offset=0x3ef align=1 (i32.const 0)))
+    (local.set 0x3f0 (i64.load offset=0x3f0 align=1 (i32.const 0)))
+    (local.set 0x3f1 (i64.load offset=0x3f1 align=1 (i32.const 0)))
+    (local.set 0x3f2 (i64.load offset=0x3f2 align=1 (i32.const 0)))
+    (local.set 0x3f3 (i64.load offset=0x3f3 align=1 (i32.const 0)))
+    (local.set 0x3f4 (i64.load offset=0x3f4 align=1 (i32.const 0)))
+    (local.set 0x3f5 (i64.load offset=0x3f5 align=1 (i32.const 0)))
+    (local.set 0x3f6 (i64.load offset=0x3f6 align=1 (i32.const 0)))
+    (local.set 0x3f7 (i64.load offset=0x3f7 align=1 (i32.const 0)))
+    (local.set 0x3f8 (i64.load offset=0x3f8 align=1 (i32.const 0)))
+    (local.set 0x3f9 (i64.load offset=0x3f9 align=1 (i32.const 0)))
+    (local.set 0x3fa (i64.load offset=0x3fa align=1 (i32.const 0)))
+    (local.set 0x3fb (i64.load offset=0x3fb align=1 (i32.const 0)))
+    (local.set 0x3fc (i64.load offset=0x3fc align=1 (i32.const 0)))
+    (local.set 0x3fd (i64.load offset=0x3fd align=1 (i32.const 0)))
+    (local.set 0x3fe (i64.load offset=0x3fe align=1 (i32.const 0)))
+    (local.set 0x3ff (i64.load offset=0x3ff align=1 (i32.const 0)))
+    (local.set 0x400 (i64.load offset=0x400 align=1 (i32.const 0)))
+    (local.set 0x401 (i64.load offset=0x401 align=1 (i32.const 0)))
+    (local.set 0x402 (i64.load offset=0x402 align=1 (i32.const 0)))
+    (local.set 0x403 (i64.load offset=0x403 align=1 (i32.const 0)))
+    (local.set 0x404 (i64.load offset=0x404 align=1 (i32.const 0)))
+    (local.set 0x405 (i64.load offset=0x405 align=1 (i32.const 0)))
+    (local.set 0x406 (i64.load offset=0x406 align=1 (i32.const 0)))
+    (local.set 0x407 (i64.load offset=0x407 align=1 (i32.const 0)))
+    (local.set 0x408 (i64.load offset=0x408 align=1 (i32.const 0)))
+    (local.set 0x409 (i64.load offset=0x409 align=1 (i32.const 0)))
+    (local.set 0x40a (i64.load offset=0x40a align=1 (i32.const 0)))
+    (local.set 0x40b (i64.load offset=0x40b align=1 (i32.const 0)))
+    (local.set 0x40c (i64.load offset=0x40c align=1 (i32.const 0)))
+    (local.set 0x40d (i64.load offset=0x40d align=1 (i32.const 0)))
+    (local.set 0x40e (i64.load offset=0x40e align=1 (i32.const 0)))
+    (local.set 0x40f (i64.load offset=0x40f align=1 (i32.const 0)))
+    (local.set 0x410 (i64.load offset=0x410 align=1 (i32.const 0)))
+    (local.set 0x411 (i64.load offset=0x411 align=1 (i32.const 0)))
+    (local.set 0x412 (i64.load offset=0x412 align=1 (i32.const 0)))
+    (local.set 0x413 (i64.load offset=0x413 align=1 (i32.const 0)))
+    (local.set 0x414 (i64.load offset=0x414 align=1 (i32.const 0)))
+    (local.set 0x415 (i64.load offset=0x415 align=1 (i32.const 0)))
+    (local.set 0x416 (i64.load offset=0x416 align=1 (i32.const 0)))
+    (local.set 0x417 (i64.load offset=0x417 align=1 (i32.const 0)))
+    (local.set 0x418 (i64.load offset=0x418 align=1 (i32.const 0)))
+    (local.set 0x419 (i64.load offset=0x419 align=1 (i32.const 0)))
+    (local.set 0x41a (i64.load offset=0x41a align=1 (i32.const 0)))
+    (local.set 0x41b (i64.load offset=0x41b align=1 (i32.const 0)))
+    (local.set 0x41c (i64.load offset=0x41c align=1 (i32.const 0)))
+    (local.set 0x41d (i64.load offset=0x41d align=1 (i32.const 0)))
+    (local.set 0x41e (i64.load offset=0x41e align=1 (i32.const 0)))
+    (local.set 0x41f (i64.load offset=0x41f align=1 (i32.const 0)))
 
     ;; store the locals back to memory
-    (i64.store offset=0x000 align=1 (i32.const 0) (get_local 0x000))
-    (i64.store offset=0x001 align=1 (i32.const 0) (get_local 0x001))
-    (i64.store offset=0x002 align=1 (i32.const 0) (get_local 0x002))
-    (i64.store offset=0x003 align=1 (i32.const 0) (get_local 0x003))
-    (i64.store offset=0x004 align=1 (i32.const 0) (get_local 0x004))
-    (i64.store offset=0x005 align=1 (i32.const 0) (get_local 0x005))
-    (i64.store offset=0x006 align=1 (i32.const 0) (get_local 0x006))
-    (i64.store offset=0x007 align=1 (i32.const 0) (get_local 0x007))
-    (i64.store offset=0x008 align=1 (i32.const 0) (get_local 0x008))
-    (i64.store offset=0x009 align=1 (i32.const 0) (get_local 0x009))
-    (i64.store offset=0x00a align=1 (i32.const 0) (get_local 0x00a))
-    (i64.store offset=0x00b align=1 (i32.const 0) (get_local 0x00b))
-    (i64.store offset=0x00c align=1 (i32.const 0) (get_local 0x00c))
-    (i64.store offset=0x00d align=1 (i32.const 0) (get_local 0x00d))
-    (i64.store offset=0x00e align=1 (i32.const 0) (get_local 0x00e))
-    (i64.store offset=0x00f align=1 (i32.const 0) (get_local 0x00f))
-    (i64.store offset=0x010 align=1 (i32.const 0) (get_local 0x010))
-    (i64.store offset=0x011 align=1 (i32.const 0) (get_local 0x011))
-    (i64.store offset=0x012 align=1 (i32.const 0) (get_local 0x012))
-    (i64.store offset=0x013 align=1 (i32.const 0) (get_local 0x013))
-    (i64.store offset=0x014 align=1 (i32.const 0) (get_local 0x014))
-    (i64.store offset=0x015 align=1 (i32.const 0) (get_local 0x015))
-    (i64.store offset=0x016 align=1 (i32.const 0) (get_local 0x016))
-    (i64.store offset=0x017 align=1 (i32.const 0) (get_local 0x017))
-    (i64.store offset=0x018 align=1 (i32.const 0) (get_local 0x018))
-    (i64.store offset=0x019 align=1 (i32.const 0) (get_local 0x019))
-    (i64.store offset=0x01a align=1 (i32.const 0) (get_local 0x01a))
-    (i64.store offset=0x01b align=1 (i32.const 0) (get_local 0x01b))
-    (i64.store offset=0x01c align=1 (i32.const 0) (get_local 0x01c))
-    (i64.store offset=0x01d align=1 (i32.const 0) (get_local 0x01d))
-    (i64.store offset=0x01e align=1 (i32.const 0) (get_local 0x01e))
-    (i64.store offset=0x01f align=1 (i32.const 0) (get_local 0x01f))
-    (i64.store offset=0x020 align=1 (i32.const 0) (get_local 0x020))
-    (i64.store offset=0x021 align=1 (i32.const 0) (get_local 0x021))
-    (i64.store offset=0x022 align=1 (i32.const 0) (get_local 0x022))
-    (i64.store offset=0x023 align=1 (i32.const 0) (get_local 0x023))
-    (i64.store offset=0x024 align=1 (i32.const 0) (get_local 0x024))
-    (i64.store offset=0x025 align=1 (i32.const 0) (get_local 0x025))
-    (i64.store offset=0x026 align=1 (i32.const 0) (get_local 0x026))
-    (i64.store offset=0x027 align=1 (i32.const 0) (get_local 0x027))
-    (i64.store offset=0x028 align=1 (i32.const 0) (get_local 0x028))
-    (i64.store offset=0x029 align=1 (i32.const 0) (get_local 0x029))
-    (i64.store offset=0x02a align=1 (i32.const 0) (get_local 0x02a))
-    (i64.store offset=0x02b align=1 (i32.const 0) (get_local 0x02b))
-    (i64.store offset=0x02c align=1 (i32.const 0) (get_local 0x02c))
-    (i64.store offset=0x02d align=1 (i32.const 0) (get_local 0x02d))
-    (i64.store offset=0x02e align=1 (i32.const 0) (get_local 0x02e))
-    (i64.store offset=0x02f align=1 (i32.const 0) (get_local 0x02f))
-    (i64.store offset=0x030 align=1 (i32.const 0) (get_local 0x030))
-    (i64.store offset=0x031 align=1 (i32.const 0) (get_local 0x031))
-    (i64.store offset=0x032 align=1 (i32.const 0) (get_local 0x032))
-    (i64.store offset=0x033 align=1 (i32.const 0) (get_local 0x033))
-    (i64.store offset=0x034 align=1 (i32.const 0) (get_local 0x034))
-    (i64.store offset=0x035 align=1 (i32.const 0) (get_local 0x035))
-    (i64.store offset=0x036 align=1 (i32.const 0) (get_local 0x036))
-    (i64.store offset=0x037 align=1 (i32.const 0) (get_local 0x037))
-    (i64.store offset=0x038 align=1 (i32.const 0) (get_local 0x038))
-    (i64.store offset=0x039 align=1 (i32.const 0) (get_local 0x039))
-    (i64.store offset=0x03a align=1 (i32.const 0) (get_local 0x03a))
-    (i64.store offset=0x03b align=1 (i32.const 0) (get_local 0x03b))
-    (i64.store offset=0x03c align=1 (i32.const 0) (get_local 0x03c))
-    (i64.store offset=0x03d align=1 (i32.const 0) (get_local 0x03d))
-    (i64.store offset=0x03e align=1 (i32.const 0) (get_local 0x03e))
-    (i64.store offset=0x03f align=1 (i32.const 0) (get_local 0x03f))
-    (i64.store offset=0x040 align=1 (i32.const 0) (get_local 0x040))
-    (i64.store offset=0x041 align=1 (i32.const 0) (get_local 0x041))
-    (i64.store offset=0x042 align=1 (i32.const 0) (get_local 0x042))
-    (i64.store offset=0x043 align=1 (i32.const 0) (get_local 0x043))
-    (i64.store offset=0x044 align=1 (i32.const 0) (get_local 0x044))
-    (i64.store offset=0x045 align=1 (i32.const 0) (get_local 0x045))
-    (i64.store offset=0x046 align=1 (i32.const 0) (get_local 0x046))
-    (i64.store offset=0x047 align=1 (i32.const 0) (get_local 0x047))
-    (i64.store offset=0x048 align=1 (i32.const 0) (get_local 0x048))
-    (i64.store offset=0x049 align=1 (i32.const 0) (get_local 0x049))
-    (i64.store offset=0x04a align=1 (i32.const 0) (get_local 0x04a))
-    (i64.store offset=0x04b align=1 (i32.const 0) (get_local 0x04b))
-    (i64.store offset=0x04c align=1 (i32.const 0) (get_local 0x04c))
-    (i64.store offset=0x04d align=1 (i32.const 0) (get_local 0x04d))
-    (i64.store offset=0x04e align=1 (i32.const 0) (get_local 0x04e))
-    (i64.store offset=0x04f align=1 (i32.const 0) (get_local 0x04f))
-    (i64.store offset=0x050 align=1 (i32.const 0) (get_local 0x050))
-    (i64.store offset=0x051 align=1 (i32.const 0) (get_local 0x051))
-    (i64.store offset=0x052 align=1 (i32.const 0) (get_local 0x052))
-    (i64.store offset=0x053 align=1 (i32.const 0) (get_local 0x053))
-    (i64.store offset=0x054 align=1 (i32.const 0) (get_local 0x054))
-    (i64.store offset=0x055 align=1 (i32.const 0) (get_local 0x055))
-    (i64.store offset=0x056 align=1 (i32.const 0) (get_local 0x056))
-    (i64.store offset=0x057 align=1 (i32.const 0) (get_local 0x057))
-    (i64.store offset=0x058 align=1 (i32.const 0) (get_local 0x058))
-    (i64.store offset=0x059 align=1 (i32.const 0) (get_local 0x059))
-    (i64.store offset=0x05a align=1 (i32.const 0) (get_local 0x05a))
-    (i64.store offset=0x05b align=1 (i32.const 0) (get_local 0x05b))
-    (i64.store offset=0x05c align=1 (i32.const 0) (get_local 0x05c))
-    (i64.store offset=0x05d align=1 (i32.const 0) (get_local 0x05d))
-    (i64.store offset=0x05e align=1 (i32.const 0) (get_local 0x05e))
-    (i64.store offset=0x05f align=1 (i32.const 0) (get_local 0x05f))
-    (i64.store offset=0x060 align=1 (i32.const 0) (get_local 0x060))
-    (i64.store offset=0x061 align=1 (i32.const 0) (get_local 0x061))
-    (i64.store offset=0x062 align=1 (i32.const 0) (get_local 0x062))
-    (i64.store offset=0x063 align=1 (i32.const 0) (get_local 0x063))
-    (i64.store offset=0x064 align=1 (i32.const 0) (get_local 0x064))
-    (i64.store offset=0x065 align=1 (i32.const 0) (get_local 0x065))
-    (i64.store offset=0x066 align=1 (i32.const 0) (get_local 0x066))
-    (i64.store offset=0x067 align=1 (i32.const 0) (get_local 0x067))
-    (i64.store offset=0x068 align=1 (i32.const 0) (get_local 0x068))
-    (i64.store offset=0x069 align=1 (i32.const 0) (get_local 0x069))
-    (i64.store offset=0x06a align=1 (i32.const 0) (get_local 0x06a))
-    (i64.store offset=0x06b align=1 (i32.const 0) (get_local 0x06b))
-    (i64.store offset=0x06c align=1 (i32.const 0) (get_local 0x06c))
-    (i64.store offset=0x06d align=1 (i32.const 0) (get_local 0x06d))
-    (i64.store offset=0x06e align=1 (i32.const 0) (get_local 0x06e))
-    (i64.store offset=0x06f align=1 (i32.const 0) (get_local 0x06f))
-    (i64.store offset=0x070 align=1 (i32.const 0) (get_local 0x070))
-    (i64.store offset=0x071 align=1 (i32.const 0) (get_local 0x071))
-    (i64.store offset=0x072 align=1 (i32.const 0) (get_local 0x072))
-    (i64.store offset=0x073 align=1 (i32.const 0) (get_local 0x073))
-    (i64.store offset=0x074 align=1 (i32.const 0) (get_local 0x074))
-    (i64.store offset=0x075 align=1 (i32.const 0) (get_local 0x075))
-    (i64.store offset=0x076 align=1 (i32.const 0) (get_local 0x076))
-    (i64.store offset=0x077 align=1 (i32.const 0) (get_local 0x077))
-    (i64.store offset=0x078 align=1 (i32.const 0) (get_local 0x078))
-    (i64.store offset=0x079 align=1 (i32.const 0) (get_local 0x079))
-    (i64.store offset=0x07a align=1 (i32.const 0) (get_local 0x07a))
-    (i64.store offset=0x07b align=1 (i32.const 0) (get_local 0x07b))
-    (i64.store offset=0x07c align=1 (i32.const 0) (get_local 0x07c))
-    (i64.store offset=0x07d align=1 (i32.const 0) (get_local 0x07d))
-    (i64.store offset=0x07e align=1 (i32.const 0) (get_local 0x07e))
-    (i64.store offset=0x07f align=1 (i32.const 0) (get_local 0x07f))
-    (i64.store offset=0x080 align=1 (i32.const 0) (get_local 0x080))
-    (i64.store offset=0x081 align=1 (i32.const 0) (get_local 0x081))
-    (i64.store offset=0x082 align=1 (i32.const 0) (get_local 0x082))
-    (i64.store offset=0x083 align=1 (i32.const 0) (get_local 0x083))
-    (i64.store offset=0x084 align=1 (i32.const 0) (get_local 0x084))
-    (i64.store offset=0x085 align=1 (i32.const 0) (get_local 0x085))
-    (i64.store offset=0x086 align=1 (i32.const 0) (get_local 0x086))
-    (i64.store offset=0x087 align=1 (i32.const 0) (get_local 0x087))
-    (i64.store offset=0x088 align=1 (i32.const 0) (get_local 0x088))
-    (i64.store offset=0x089 align=1 (i32.const 0) (get_local 0x089))
-    (i64.store offset=0x08a align=1 (i32.const 0) (get_local 0x08a))
-    (i64.store offset=0x08b align=1 (i32.const 0) (get_local 0x08b))
-    (i64.store offset=0x08c align=1 (i32.const 0) (get_local 0x08c))
-    (i64.store offset=0x08d align=1 (i32.const 0) (get_local 0x08d))
-    (i64.store offset=0x08e align=1 (i32.const 0) (get_local 0x08e))
-    (i64.store offset=0x08f align=1 (i32.const 0) (get_local 0x08f))
-    (i64.store offset=0x090 align=1 (i32.const 0) (get_local 0x090))
-    (i64.store offset=0x091 align=1 (i32.const 0) (get_local 0x091))
-    (i64.store offset=0x092 align=1 (i32.const 0) (get_local 0x092))
-    (i64.store offset=0x093 align=1 (i32.const 0) (get_local 0x093))
-    (i64.store offset=0x094 align=1 (i32.const 0) (get_local 0x094))
-    (i64.store offset=0x095 align=1 (i32.const 0) (get_local 0x095))
-    (i64.store offset=0x096 align=1 (i32.const 0) (get_local 0x096))
-    (i64.store offset=0x097 align=1 (i32.const 0) (get_local 0x097))
-    (i64.store offset=0x098 align=1 (i32.const 0) (get_local 0x098))
-    (i64.store offset=0x099 align=1 (i32.const 0) (get_local 0x099))
-    (i64.store offset=0x09a align=1 (i32.const 0) (get_local 0x09a))
-    (i64.store offset=0x09b align=1 (i32.const 0) (get_local 0x09b))
-    (i64.store offset=0x09c align=1 (i32.const 0) (get_local 0x09c))
-    (i64.store offset=0x09d align=1 (i32.const 0) (get_local 0x09d))
-    (i64.store offset=0x09e align=1 (i32.const 0) (get_local 0x09e))
-    (i64.store offset=0x09f align=1 (i32.const 0) (get_local 0x09f))
-    (i64.store offset=0x0a0 align=1 (i32.const 0) (get_local 0x0a0))
-    (i64.store offset=0x0a1 align=1 (i32.const 0) (get_local 0x0a1))
-    (i64.store offset=0x0a2 align=1 (i32.const 0) (get_local 0x0a2))
-    (i64.store offset=0x0a3 align=1 (i32.const 0) (get_local 0x0a3))
-    (i64.store offset=0x0a4 align=1 (i32.const 0) (get_local 0x0a4))
-    (i64.store offset=0x0a5 align=1 (i32.const 0) (get_local 0x0a5))
-    (i64.store offset=0x0a6 align=1 (i32.const 0) (get_local 0x0a6))
-    (i64.store offset=0x0a7 align=1 (i32.const 0) (get_local 0x0a7))
-    (i64.store offset=0x0a8 align=1 (i32.const 0) (get_local 0x0a8))
-    (i64.store offset=0x0a9 align=1 (i32.const 0) (get_local 0x0a9))
-    (i64.store offset=0x0aa align=1 (i32.const 0) (get_local 0x0aa))
-    (i64.store offset=0x0ab align=1 (i32.const 0) (get_local 0x0ab))
-    (i64.store offset=0x0ac align=1 (i32.const 0) (get_local 0x0ac))
-    (i64.store offset=0x0ad align=1 (i32.const 0) (get_local 0x0ad))
-    (i64.store offset=0x0ae align=1 (i32.const 0) (get_local 0x0ae))
-    (i64.store offset=0x0af align=1 (i32.const 0) (get_local 0x0af))
-    (i64.store offset=0x0b0 align=1 (i32.const 0) (get_local 0x0b0))
-    (i64.store offset=0x0b1 align=1 (i32.const 0) (get_local 0x0b1))
-    (i64.store offset=0x0b2 align=1 (i32.const 0) (get_local 0x0b2))
-    (i64.store offset=0x0b3 align=1 (i32.const 0) (get_local 0x0b3))
-    (i64.store offset=0x0b4 align=1 (i32.const 0) (get_local 0x0b4))
-    (i64.store offset=0x0b5 align=1 (i32.const 0) (get_local 0x0b5))
-    (i64.store offset=0x0b6 align=1 (i32.const 0) (get_local 0x0b6))
-    (i64.store offset=0x0b7 align=1 (i32.const 0) (get_local 0x0b7))
-    (i64.store offset=0x0b8 align=1 (i32.const 0) (get_local 0x0b8))
-    (i64.store offset=0x0b9 align=1 (i32.const 0) (get_local 0x0b9))
-    (i64.store offset=0x0ba align=1 (i32.const 0) (get_local 0x0ba))
-    (i64.store offset=0x0bb align=1 (i32.const 0) (get_local 0x0bb))
-    (i64.store offset=0x0bc align=1 (i32.const 0) (get_local 0x0bc))
-    (i64.store offset=0x0bd align=1 (i32.const 0) (get_local 0x0bd))
-    (i64.store offset=0x0be align=1 (i32.const 0) (get_local 0x0be))
-    (i64.store offset=0x0bf align=1 (i32.const 0) (get_local 0x0bf))
-    (i64.store offset=0x0c0 align=1 (i32.const 0) (get_local 0x0c0))
-    (i64.store offset=0x0c1 align=1 (i32.const 0) (get_local 0x0c1))
-    (i64.store offset=0x0c2 align=1 (i32.const 0) (get_local 0x0c2))
-    (i64.store offset=0x0c3 align=1 (i32.const 0) (get_local 0x0c3))
-    (i64.store offset=0x0c4 align=1 (i32.const 0) (get_local 0x0c4))
-    (i64.store offset=0x0c5 align=1 (i32.const 0) (get_local 0x0c5))
-    (i64.store offset=0x0c6 align=1 (i32.const 0) (get_local 0x0c6))
-    (i64.store offset=0x0c7 align=1 (i32.const 0) (get_local 0x0c7))
-    (i64.store offset=0x0c8 align=1 (i32.const 0) (get_local 0x0c8))
-    (i64.store offset=0x0c9 align=1 (i32.const 0) (get_local 0x0c9))
-    (i64.store offset=0x0ca align=1 (i32.const 0) (get_local 0x0ca))
-    (i64.store offset=0x0cb align=1 (i32.const 0) (get_local 0x0cb))
-    (i64.store offset=0x0cc align=1 (i32.const 0) (get_local 0x0cc))
-    (i64.store offset=0x0cd align=1 (i32.const 0) (get_local 0x0cd))
-    (i64.store offset=0x0ce align=1 (i32.const 0) (get_local 0x0ce))
-    (i64.store offset=0x0cf align=1 (i32.const 0) (get_local 0x0cf))
-    (i64.store offset=0x0d0 align=1 (i32.const 0) (get_local 0x0d0))
-    (i64.store offset=0x0d1 align=1 (i32.const 0) (get_local 0x0d1))
-    (i64.store offset=0x0d2 align=1 (i32.const 0) (get_local 0x0d2))
-    (i64.store offset=0x0d3 align=1 (i32.const 0) (get_local 0x0d3))
-    (i64.store offset=0x0d4 align=1 (i32.const 0) (get_local 0x0d4))
-    (i64.store offset=0x0d5 align=1 (i32.const 0) (get_local 0x0d5))
-    (i64.store offset=0x0d6 align=1 (i32.const 0) (get_local 0x0d6))
-    (i64.store offset=0x0d7 align=1 (i32.const 0) (get_local 0x0d7))
-    (i64.store offset=0x0d8 align=1 (i32.const 0) (get_local 0x0d8))
-    (i64.store offset=0x0d9 align=1 (i32.const 0) (get_local 0x0d9))
-    (i64.store offset=0x0da align=1 (i32.const 0) (get_local 0x0da))
-    (i64.store offset=0x0db align=1 (i32.const 0) (get_local 0x0db))
-    (i64.store offset=0x0dc align=1 (i32.const 0) (get_local 0x0dc))
-    (i64.store offset=0x0dd align=1 (i32.const 0) (get_local 0x0dd))
-    (i64.store offset=0x0de align=1 (i32.const 0) (get_local 0x0de))
-    (i64.store offset=0x0df align=1 (i32.const 0) (get_local 0x0df))
-    (i64.store offset=0x0e0 align=1 (i32.const 0) (get_local 0x0e0))
-    (i64.store offset=0x0e1 align=1 (i32.const 0) (get_local 0x0e1))
-    (i64.store offset=0x0e2 align=1 (i32.const 0) (get_local 0x0e2))
-    (i64.store offset=0x0e3 align=1 (i32.const 0) (get_local 0x0e3))
-    (i64.store offset=0x0e4 align=1 (i32.const 0) (get_local 0x0e4))
-    (i64.store offset=0x0e5 align=1 (i32.const 0) (get_local 0x0e5))
-    (i64.store offset=0x0e6 align=1 (i32.const 0) (get_local 0x0e6))
-    (i64.store offset=0x0e7 align=1 (i32.const 0) (get_local 0x0e7))
-    (i64.store offset=0x0e8 align=1 (i32.const 0) (get_local 0x0e8))
-    (i64.store offset=0x0e9 align=1 (i32.const 0) (get_local 0x0e9))
-    (i64.store offset=0x0ea align=1 (i32.const 0) (get_local 0x0ea))
-    (i64.store offset=0x0eb align=1 (i32.const 0) (get_local 0x0eb))
-    (i64.store offset=0x0ec align=1 (i32.const 0) (get_local 0x0ec))
-    (i64.store offset=0x0ed align=1 (i32.const 0) (get_local 0x0ed))
-    (i64.store offset=0x0ee align=1 (i32.const 0) (get_local 0x0ee))
-    (i64.store offset=0x0ef align=1 (i32.const 0) (get_local 0x0ef))
-    (i64.store offset=0x0f0 align=1 (i32.const 0) (get_local 0x0f0))
-    (i64.store offset=0x0f1 align=1 (i32.const 0) (get_local 0x0f1))
-    (i64.store offset=0x0f2 align=1 (i32.const 0) (get_local 0x0f2))
-    (i64.store offset=0x0f3 align=1 (i32.const 0) (get_local 0x0f3))
-    (i64.store offset=0x0f4 align=1 (i32.const 0) (get_local 0x0f4))
-    (i64.store offset=0x0f5 align=1 (i32.const 0) (get_local 0x0f5))
-    (i64.store offset=0x0f6 align=1 (i32.const 0) (get_local 0x0f6))
-    (i64.store offset=0x0f7 align=1 (i32.const 0) (get_local 0x0f7))
-    (i64.store offset=0x0f8 align=1 (i32.const 0) (get_local 0x0f8))
-    (i64.store offset=0x0f9 align=1 (i32.const 0) (get_local 0x0f9))
-    (i64.store offset=0x0fa align=1 (i32.const 0) (get_local 0x0fa))
-    (i64.store offset=0x0fb align=1 (i32.const 0) (get_local 0x0fb))
-    (i64.store offset=0x0fc align=1 (i32.const 0) (get_local 0x0fc))
-    (i64.store offset=0x0fd align=1 (i32.const 0) (get_local 0x0fd))
-    (i64.store offset=0x0fe align=1 (i32.const 0) (get_local 0x0fe))
-    (i64.store offset=0x0ff align=1 (i32.const 0) (get_local 0x0ff))
-    (i64.store offset=0x100 align=1 (i32.const 0) (get_local 0x100))
-    (i64.store offset=0x101 align=1 (i32.const 0) (get_local 0x101))
-    (i64.store offset=0x102 align=1 (i32.const 0) (get_local 0x102))
-    (i64.store offset=0x103 align=1 (i32.const 0) (get_local 0x103))
-    (i64.store offset=0x104 align=1 (i32.const 0) (get_local 0x104))
-    (i64.store offset=0x105 align=1 (i32.const 0) (get_local 0x105))
-    (i64.store offset=0x106 align=1 (i32.const 0) (get_local 0x106))
-    (i64.store offset=0x107 align=1 (i32.const 0) (get_local 0x107))
-    (i64.store offset=0x108 align=1 (i32.const 0) (get_local 0x108))
-    (i64.store offset=0x109 align=1 (i32.const 0) (get_local 0x109))
-    (i64.store offset=0x10a align=1 (i32.const 0) (get_local 0x10a))
-    (i64.store offset=0x10b align=1 (i32.const 0) (get_local 0x10b))
-    (i64.store offset=0x10c align=1 (i32.const 0) (get_local 0x10c))
-    (i64.store offset=0x10d align=1 (i32.const 0) (get_local 0x10d))
-    (i64.store offset=0x10e align=1 (i32.const 0) (get_local 0x10e))
-    (i64.store offset=0x10f align=1 (i32.const 0) (get_local 0x10f))
-    (i64.store offset=0x110 align=1 (i32.const 0) (get_local 0x110))
-    (i64.store offset=0x111 align=1 (i32.const 0) (get_local 0x111))
-    (i64.store offset=0x112 align=1 (i32.const 0) (get_local 0x112))
-    (i64.store offset=0x113 align=1 (i32.const 0) (get_local 0x113))
-    (i64.store offset=0x114 align=1 (i32.const 0) (get_local 0x114))
-    (i64.store offset=0x115 align=1 (i32.const 0) (get_local 0x115))
-    (i64.store offset=0x116 align=1 (i32.const 0) (get_local 0x116))
-    (i64.store offset=0x117 align=1 (i32.const 0) (get_local 0x117))
-    (i64.store offset=0x118 align=1 (i32.const 0) (get_local 0x118))
-    (i64.store offset=0x119 align=1 (i32.const 0) (get_local 0x119))
-    (i64.store offset=0x11a align=1 (i32.const 0) (get_local 0x11a))
-    (i64.store offset=0x11b align=1 (i32.const 0) (get_local 0x11b))
-    (i64.store offset=0x11c align=1 (i32.const 0) (get_local 0x11c))
-    (i64.store offset=0x11d align=1 (i32.const 0) (get_local 0x11d))
-    (i64.store offset=0x11e align=1 (i32.const 0) (get_local 0x11e))
-    (i64.store offset=0x11f align=1 (i32.const 0) (get_local 0x11f))
-    (i64.store offset=0x120 align=1 (i32.const 0) (get_local 0x120))
-    (i64.store offset=0x121 align=1 (i32.const 0) (get_local 0x121))
-    (i64.store offset=0x122 align=1 (i32.const 0) (get_local 0x122))
-    (i64.store offset=0x123 align=1 (i32.const 0) (get_local 0x123))
-    (i64.store offset=0x124 align=1 (i32.const 0) (get_local 0x124))
-    (i64.store offset=0x125 align=1 (i32.const 0) (get_local 0x125))
-    (i64.store offset=0x126 align=1 (i32.const 0) (get_local 0x126))
-    (i64.store offset=0x127 align=1 (i32.const 0) (get_local 0x127))
-    (i64.store offset=0x128 align=1 (i32.const 0) (get_local 0x128))
-    (i64.store offset=0x129 align=1 (i32.const 0) (get_local 0x129))
-    (i64.store offset=0x12a align=1 (i32.const 0) (get_local 0x12a))
-    (i64.store offset=0x12b align=1 (i32.const 0) (get_local 0x12b))
-    (i64.store offset=0x12c align=1 (i32.const 0) (get_local 0x12c))
-    (i64.store offset=0x12d align=1 (i32.const 0) (get_local 0x12d))
-    (i64.store offset=0x12e align=1 (i32.const 0) (get_local 0x12e))
-    (i64.store offset=0x12f align=1 (i32.const 0) (get_local 0x12f))
-    (i64.store offset=0x130 align=1 (i32.const 0) (get_local 0x130))
-    (i64.store offset=0x131 align=1 (i32.const 0) (get_local 0x131))
-    (i64.store offset=0x132 align=1 (i32.const 0) (get_local 0x132))
-    (i64.store offset=0x133 align=1 (i32.const 0) (get_local 0x133))
-    (i64.store offset=0x134 align=1 (i32.const 0) (get_local 0x134))
-    (i64.store offset=0x135 align=1 (i32.const 0) (get_local 0x135))
-    (i64.store offset=0x136 align=1 (i32.const 0) (get_local 0x136))
-    (i64.store offset=0x137 align=1 (i32.const 0) (get_local 0x137))
-    (i64.store offset=0x138 align=1 (i32.const 0) (get_local 0x138))
-    (i64.store offset=0x139 align=1 (i32.const 0) (get_local 0x139))
-    (i64.store offset=0x13a align=1 (i32.const 0) (get_local 0x13a))
-    (i64.store offset=0x13b align=1 (i32.const 0) (get_local 0x13b))
-    (i64.store offset=0x13c align=1 (i32.const 0) (get_local 0x13c))
-    (i64.store offset=0x13d align=1 (i32.const 0) (get_local 0x13d))
-    (i64.store offset=0x13e align=1 (i32.const 0) (get_local 0x13e))
-    (i64.store offset=0x13f align=1 (i32.const 0) (get_local 0x13f))
-    (i64.store offset=0x140 align=1 (i32.const 0) (get_local 0x140))
-    (i64.store offset=0x141 align=1 (i32.const 0) (get_local 0x141))
-    (i64.store offset=0x142 align=1 (i32.const 0) (get_local 0x142))
-    (i64.store offset=0x143 align=1 (i32.const 0) (get_local 0x143))
-    (i64.store offset=0x144 align=1 (i32.const 0) (get_local 0x144))
-    (i64.store offset=0x145 align=1 (i32.const 0) (get_local 0x145))
-    (i64.store offset=0x146 align=1 (i32.const 0) (get_local 0x146))
-    (i64.store offset=0x147 align=1 (i32.const 0) (get_local 0x147))
-    (i64.store offset=0x148 align=1 (i32.const 0) (get_local 0x148))
-    (i64.store offset=0x149 align=1 (i32.const 0) (get_local 0x149))
-    (i64.store offset=0x14a align=1 (i32.const 0) (get_local 0x14a))
-    (i64.store offset=0x14b align=1 (i32.const 0) (get_local 0x14b))
-    (i64.store offset=0x14c align=1 (i32.const 0) (get_local 0x14c))
-    (i64.store offset=0x14d align=1 (i32.const 0) (get_local 0x14d))
-    (i64.store offset=0x14e align=1 (i32.const 0) (get_local 0x14e))
-    (i64.store offset=0x14f align=1 (i32.const 0) (get_local 0x14f))
-    (i64.store offset=0x150 align=1 (i32.const 0) (get_local 0x150))
-    (i64.store offset=0x151 align=1 (i32.const 0) (get_local 0x151))
-    (i64.store offset=0x152 align=1 (i32.const 0) (get_local 0x152))
-    (i64.store offset=0x153 align=1 (i32.const 0) (get_local 0x153))
-    (i64.store offset=0x154 align=1 (i32.const 0) (get_local 0x154))
-    (i64.store offset=0x155 align=1 (i32.const 0) (get_local 0x155))
-    (i64.store offset=0x156 align=1 (i32.const 0) (get_local 0x156))
-    (i64.store offset=0x157 align=1 (i32.const 0) (get_local 0x157))
-    (i64.store offset=0x158 align=1 (i32.const 0) (get_local 0x158))
-    (i64.store offset=0x159 align=1 (i32.const 0) (get_local 0x159))
-    (i64.store offset=0x15a align=1 (i32.const 0) (get_local 0x15a))
-    (i64.store offset=0x15b align=1 (i32.const 0) (get_local 0x15b))
-    (i64.store offset=0x15c align=1 (i32.const 0) (get_local 0x15c))
-    (i64.store offset=0x15d align=1 (i32.const 0) (get_local 0x15d))
-    (i64.store offset=0x15e align=1 (i32.const 0) (get_local 0x15e))
-    (i64.store offset=0x15f align=1 (i32.const 0) (get_local 0x15f))
-    (i64.store offset=0x160 align=1 (i32.const 0) (get_local 0x160))
-    (i64.store offset=0x161 align=1 (i32.const 0) (get_local 0x161))
-    (i64.store offset=0x162 align=1 (i32.const 0) (get_local 0x162))
-    (i64.store offset=0x163 align=1 (i32.const 0) (get_local 0x163))
-    (i64.store offset=0x164 align=1 (i32.const 0) (get_local 0x164))
-    (i64.store offset=0x165 align=1 (i32.const 0) (get_local 0x165))
-    (i64.store offset=0x166 align=1 (i32.const 0) (get_local 0x166))
-    (i64.store offset=0x167 align=1 (i32.const 0) (get_local 0x167))
-    (i64.store offset=0x168 align=1 (i32.const 0) (get_local 0x168))
-    (i64.store offset=0x169 align=1 (i32.const 0) (get_local 0x169))
-    (i64.store offset=0x16a align=1 (i32.const 0) (get_local 0x16a))
-    (i64.store offset=0x16b align=1 (i32.const 0) (get_local 0x16b))
-    (i64.store offset=0x16c align=1 (i32.const 0) (get_local 0x16c))
-    (i64.store offset=0x16d align=1 (i32.const 0) (get_local 0x16d))
-    (i64.store offset=0x16e align=1 (i32.const 0) (get_local 0x16e))
-    (i64.store offset=0x16f align=1 (i32.const 0) (get_local 0x16f))
-    (i64.store offset=0x170 align=1 (i32.const 0) (get_local 0x170))
-    (i64.store offset=0x171 align=1 (i32.const 0) (get_local 0x171))
-    (i64.store offset=0x172 align=1 (i32.const 0) (get_local 0x172))
-    (i64.store offset=0x173 align=1 (i32.const 0) (get_local 0x173))
-    (i64.store offset=0x174 align=1 (i32.const 0) (get_local 0x174))
-    (i64.store offset=0x175 align=1 (i32.const 0) (get_local 0x175))
-    (i64.store offset=0x176 align=1 (i32.const 0) (get_local 0x176))
-    (i64.store offset=0x177 align=1 (i32.const 0) (get_local 0x177))
-    (i64.store offset=0x178 align=1 (i32.const 0) (get_local 0x178))
-    (i64.store offset=0x179 align=1 (i32.const 0) (get_local 0x179))
-    (i64.store offset=0x17a align=1 (i32.const 0) (get_local 0x17a))
-    (i64.store offset=0x17b align=1 (i32.const 0) (get_local 0x17b))
-    (i64.store offset=0x17c align=1 (i32.const 0) (get_local 0x17c))
-    (i64.store offset=0x17d align=1 (i32.const 0) (get_local 0x17d))
-    (i64.store offset=0x17e align=1 (i32.const 0) (get_local 0x17e))
-    (i64.store offset=0x17f align=1 (i32.const 0) (get_local 0x17f))
-    (i64.store offset=0x180 align=1 (i32.const 0) (get_local 0x180))
-    (i64.store offset=0x181 align=1 (i32.const 0) (get_local 0x181))
-    (i64.store offset=0x182 align=1 (i32.const 0) (get_local 0x182))
-    (i64.store offset=0x183 align=1 (i32.const 0) (get_local 0x183))
-    (i64.store offset=0x184 align=1 (i32.const 0) (get_local 0x184))
-    (i64.store offset=0x185 align=1 (i32.const 0) (get_local 0x185))
-    (i64.store offset=0x186 align=1 (i32.const 0) (get_local 0x186))
-    (i64.store offset=0x187 align=1 (i32.const 0) (get_local 0x187))
-    (i64.store offset=0x188 align=1 (i32.const 0) (get_local 0x188))
-    (i64.store offset=0x189 align=1 (i32.const 0) (get_local 0x189))
-    (i64.store offset=0x18a align=1 (i32.const 0) (get_local 0x18a))
-    (i64.store offset=0x18b align=1 (i32.const 0) (get_local 0x18b))
-    (i64.store offset=0x18c align=1 (i32.const 0) (get_local 0x18c))
-    (i64.store offset=0x18d align=1 (i32.const 0) (get_local 0x18d))
-    (i64.store offset=0x18e align=1 (i32.const 0) (get_local 0x18e))
-    (i64.store offset=0x18f align=1 (i32.const 0) (get_local 0x18f))
-    (i64.store offset=0x190 align=1 (i32.const 0) (get_local 0x190))
-    (i64.store offset=0x191 align=1 (i32.const 0) (get_local 0x191))
-    (i64.store offset=0x192 align=1 (i32.const 0) (get_local 0x192))
-    (i64.store offset=0x193 align=1 (i32.const 0) (get_local 0x193))
-    (i64.store offset=0x194 align=1 (i32.const 0) (get_local 0x194))
-    (i64.store offset=0x195 align=1 (i32.const 0) (get_local 0x195))
-    (i64.store offset=0x196 align=1 (i32.const 0) (get_local 0x196))
-    (i64.store offset=0x197 align=1 (i32.const 0) (get_local 0x197))
-    (i64.store offset=0x198 align=1 (i32.const 0) (get_local 0x198))
-    (i64.store offset=0x199 align=1 (i32.const 0) (get_local 0x199))
-    (i64.store offset=0x19a align=1 (i32.const 0) (get_local 0x19a))
-    (i64.store offset=0x19b align=1 (i32.const 0) (get_local 0x19b))
-    (i64.store offset=0x19c align=1 (i32.const 0) (get_local 0x19c))
-    (i64.store offset=0x19d align=1 (i32.const 0) (get_local 0x19d))
-    (i64.store offset=0x19e align=1 (i32.const 0) (get_local 0x19e))
-    (i64.store offset=0x19f align=1 (i32.const 0) (get_local 0x19f))
-    (i64.store offset=0x1a0 align=1 (i32.const 0) (get_local 0x1a0))
-    (i64.store offset=0x1a1 align=1 (i32.const 0) (get_local 0x1a1))
-    (i64.store offset=0x1a2 align=1 (i32.const 0) (get_local 0x1a2))
-    (i64.store offset=0x1a3 align=1 (i32.const 0) (get_local 0x1a3))
-    (i64.store offset=0x1a4 align=1 (i32.const 0) (get_local 0x1a4))
-    (i64.store offset=0x1a5 align=1 (i32.const 0) (get_local 0x1a5))
-    (i64.store offset=0x1a6 align=1 (i32.const 0) (get_local 0x1a6))
-    (i64.store offset=0x1a7 align=1 (i32.const 0) (get_local 0x1a7))
-    (i64.store offset=0x1a8 align=1 (i32.const 0) (get_local 0x1a8))
-    (i64.store offset=0x1a9 align=1 (i32.const 0) (get_local 0x1a9))
-    (i64.store offset=0x1aa align=1 (i32.const 0) (get_local 0x1aa))
-    (i64.store offset=0x1ab align=1 (i32.const 0) (get_local 0x1ab))
-    (i64.store offset=0x1ac align=1 (i32.const 0) (get_local 0x1ac))
-    (i64.store offset=0x1ad align=1 (i32.const 0) (get_local 0x1ad))
-    (i64.store offset=0x1ae align=1 (i32.const 0) (get_local 0x1ae))
-    (i64.store offset=0x1af align=1 (i32.const 0) (get_local 0x1af))
-    (i64.store offset=0x1b0 align=1 (i32.const 0) (get_local 0x1b0))
-    (i64.store offset=0x1b1 align=1 (i32.const 0) (get_local 0x1b1))
-    (i64.store offset=0x1b2 align=1 (i32.const 0) (get_local 0x1b2))
-    (i64.store offset=0x1b3 align=1 (i32.const 0) (get_local 0x1b3))
-    (i64.store offset=0x1b4 align=1 (i32.const 0) (get_local 0x1b4))
-    (i64.store offset=0x1b5 align=1 (i32.const 0) (get_local 0x1b5))
-    (i64.store offset=0x1b6 align=1 (i32.const 0) (get_local 0x1b6))
-    (i64.store offset=0x1b7 align=1 (i32.const 0) (get_local 0x1b7))
-    (i64.store offset=0x1b8 align=1 (i32.const 0) (get_local 0x1b8))
-    (i64.store offset=0x1b9 align=1 (i32.const 0) (get_local 0x1b9))
-    (i64.store offset=0x1ba align=1 (i32.const 0) (get_local 0x1ba))
-    (i64.store offset=0x1bb align=1 (i32.const 0) (get_local 0x1bb))
-    (i64.store offset=0x1bc align=1 (i32.const 0) (get_local 0x1bc))
-    (i64.store offset=0x1bd align=1 (i32.const 0) (get_local 0x1bd))
-    (i64.store offset=0x1be align=1 (i32.const 0) (get_local 0x1be))
-    (i64.store offset=0x1bf align=1 (i32.const 0) (get_local 0x1bf))
-    (i64.store offset=0x1c0 align=1 (i32.const 0) (get_local 0x1c0))
-    (i64.store offset=0x1c1 align=1 (i32.const 0) (get_local 0x1c1))
-    (i64.store offset=0x1c2 align=1 (i32.const 0) (get_local 0x1c2))
-    (i64.store offset=0x1c3 align=1 (i32.const 0) (get_local 0x1c3))
-    (i64.store offset=0x1c4 align=1 (i32.const 0) (get_local 0x1c4))
-    (i64.store offset=0x1c5 align=1 (i32.const 0) (get_local 0x1c5))
-    (i64.store offset=0x1c6 align=1 (i32.const 0) (get_local 0x1c6))
-    (i64.store offset=0x1c7 align=1 (i32.const 0) (get_local 0x1c7))
-    (i64.store offset=0x1c8 align=1 (i32.const 0) (get_local 0x1c8))
-    (i64.store offset=0x1c9 align=1 (i32.const 0) (get_local 0x1c9))
-    (i64.store offset=0x1ca align=1 (i32.const 0) (get_local 0x1ca))
-    (i64.store offset=0x1cb align=1 (i32.const 0) (get_local 0x1cb))
-    (i64.store offset=0x1cc align=1 (i32.const 0) (get_local 0x1cc))
-    (i64.store offset=0x1cd align=1 (i32.const 0) (get_local 0x1cd))
-    (i64.store offset=0x1ce align=1 (i32.const 0) (get_local 0x1ce))
-    (i64.store offset=0x1cf align=1 (i32.const 0) (get_local 0x1cf))
-    (i64.store offset=0x1d0 align=1 (i32.const 0) (get_local 0x1d0))
-    (i64.store offset=0x1d1 align=1 (i32.const 0) (get_local 0x1d1))
-    (i64.store offset=0x1d2 align=1 (i32.const 0) (get_local 0x1d2))
-    (i64.store offset=0x1d3 align=1 (i32.const 0) (get_local 0x1d3))
-    (i64.store offset=0x1d4 align=1 (i32.const 0) (get_local 0x1d4))
-    (i64.store offset=0x1d5 align=1 (i32.const 0) (get_local 0x1d5))
-    (i64.store offset=0x1d6 align=1 (i32.const 0) (get_local 0x1d6))
-    (i64.store offset=0x1d7 align=1 (i32.const 0) (get_local 0x1d7))
-    (i64.store offset=0x1d8 align=1 (i32.const 0) (get_local 0x1d8))
-    (i64.store offset=0x1d9 align=1 (i32.const 0) (get_local 0x1d9))
-    (i64.store offset=0x1da align=1 (i32.const 0) (get_local 0x1da))
-    (i64.store offset=0x1db align=1 (i32.const 0) (get_local 0x1db))
-    (i64.store offset=0x1dc align=1 (i32.const 0) (get_local 0x1dc))
-    (i64.store offset=0x1dd align=1 (i32.const 0) (get_local 0x1dd))
-    (i64.store offset=0x1de align=1 (i32.const 0) (get_local 0x1de))
-    (i64.store offset=0x1df align=1 (i32.const 0) (get_local 0x1df))
-    (i64.store offset=0x1e0 align=1 (i32.const 0) (get_local 0x1e0))
-    (i64.store offset=0x1e1 align=1 (i32.const 0) (get_local 0x1e1))
-    (i64.store offset=0x1e2 align=1 (i32.const 0) (get_local 0x1e2))
-    (i64.store offset=0x1e3 align=1 (i32.const 0) (get_local 0x1e3))
-    (i64.store offset=0x1e4 align=1 (i32.const 0) (get_local 0x1e4))
-    (i64.store offset=0x1e5 align=1 (i32.const 0) (get_local 0x1e5))
-    (i64.store offset=0x1e6 align=1 (i32.const 0) (get_local 0x1e6))
-    (i64.store offset=0x1e7 align=1 (i32.const 0) (get_local 0x1e7))
-    (i64.store offset=0x1e8 align=1 (i32.const 0) (get_local 0x1e8))
-    (i64.store offset=0x1e9 align=1 (i32.const 0) (get_local 0x1e9))
-    (i64.store offset=0x1ea align=1 (i32.const 0) (get_local 0x1ea))
-    (i64.store offset=0x1eb align=1 (i32.const 0) (get_local 0x1eb))
-    (i64.store offset=0x1ec align=1 (i32.const 0) (get_local 0x1ec))
-    (i64.store offset=0x1ed align=1 (i32.const 0) (get_local 0x1ed))
-    (i64.store offset=0x1ee align=1 (i32.const 0) (get_local 0x1ee))
-    (i64.store offset=0x1ef align=1 (i32.const 0) (get_local 0x1ef))
-    (i64.store offset=0x1f0 align=1 (i32.const 0) (get_local 0x1f0))
-    (i64.store offset=0x1f1 align=1 (i32.const 0) (get_local 0x1f1))
-    (i64.store offset=0x1f2 align=1 (i32.const 0) (get_local 0x1f2))
-    (i64.store offset=0x1f3 align=1 (i32.const 0) (get_local 0x1f3))
-    (i64.store offset=0x1f4 align=1 (i32.const 0) (get_local 0x1f4))
-    (i64.store offset=0x1f5 align=1 (i32.const 0) (get_local 0x1f5))
-    (i64.store offset=0x1f6 align=1 (i32.const 0) (get_local 0x1f6))
-    (i64.store offset=0x1f7 align=1 (i32.const 0) (get_local 0x1f7))
-    (i64.store offset=0x1f8 align=1 (i32.const 0) (get_local 0x1f8))
-    (i64.store offset=0x1f9 align=1 (i32.const 0) (get_local 0x1f9))
-    (i64.store offset=0x1fa align=1 (i32.const 0) (get_local 0x1fa))
-    (i64.store offset=0x1fb align=1 (i32.const 0) (get_local 0x1fb))
-    (i64.store offset=0x1fc align=1 (i32.const 0) (get_local 0x1fc))
-    (i64.store offset=0x1fd align=1 (i32.const 0) (get_local 0x1fd))
-    (i64.store offset=0x1fe align=1 (i32.const 0) (get_local 0x1fe))
-    (i64.store offset=0x1ff align=1 (i32.const 0) (get_local 0x1ff))
-    (i64.store offset=0x200 align=1 (i32.const 0) (get_local 0x200))
-    (i64.store offset=0x201 align=1 (i32.const 0) (get_local 0x201))
-    (i64.store offset=0x202 align=1 (i32.const 0) (get_local 0x202))
-    (i64.store offset=0x203 align=1 (i32.const 0) (get_local 0x203))
-    (i64.store offset=0x204 align=1 (i32.const 0) (get_local 0x204))
-    (i64.store offset=0x205 align=1 (i32.const 0) (get_local 0x205))
-    (i64.store offset=0x206 align=1 (i32.const 0) (get_local 0x206))
-    (i64.store offset=0x207 align=1 (i32.const 0) (get_local 0x207))
-    (i64.store offset=0x208 align=1 (i32.const 0) (get_local 0x208))
-    (i64.store offset=0x209 align=1 (i32.const 0) (get_local 0x209))
-    (i64.store offset=0x20a align=1 (i32.const 0) (get_local 0x20a))
-    (i64.store offset=0x20b align=1 (i32.const 0) (get_local 0x20b))
-    (i64.store offset=0x20c align=1 (i32.const 0) (get_local 0x20c))
-    (i64.store offset=0x20d align=1 (i32.const 0) (get_local 0x20d))
-    (i64.store offset=0x20e align=1 (i32.const 0) (get_local 0x20e))
-    (i64.store offset=0x20f align=1 (i32.const 0) (get_local 0x20f))
-    (i64.store offset=0x210 align=1 (i32.const 0) (get_local 0x210))
-    (i64.store offset=0x211 align=1 (i32.const 0) (get_local 0x211))
-    (i64.store offset=0x212 align=1 (i32.const 0) (get_local 0x212))
-    (i64.store offset=0x213 align=1 (i32.const 0) (get_local 0x213))
-    (i64.store offset=0x214 align=1 (i32.const 0) (get_local 0x214))
-    (i64.store offset=0x215 align=1 (i32.const 0) (get_local 0x215))
-    (i64.store offset=0x216 align=1 (i32.const 0) (get_local 0x216))
-    (i64.store offset=0x217 align=1 (i32.const 0) (get_local 0x217))
-    (i64.store offset=0x218 align=1 (i32.const 0) (get_local 0x218))
-    (i64.store offset=0x219 align=1 (i32.const 0) (get_local 0x219))
-    (i64.store offset=0x21a align=1 (i32.const 0) (get_local 0x21a))
-    (i64.store offset=0x21b align=1 (i32.const 0) (get_local 0x21b))
-    (i64.store offset=0x21c align=1 (i32.const 0) (get_local 0x21c))
-    (i64.store offset=0x21d align=1 (i32.const 0) (get_local 0x21d))
-    (i64.store offset=0x21e align=1 (i32.const 0) (get_local 0x21e))
-    (i64.store offset=0x21f align=1 (i32.const 0) (get_local 0x21f))
-    (i64.store offset=0x220 align=1 (i32.const 0) (get_local 0x220))
-    (i64.store offset=0x221 align=1 (i32.const 0) (get_local 0x221))
-    (i64.store offset=0x222 align=1 (i32.const 0) (get_local 0x222))
-    (i64.store offset=0x223 align=1 (i32.const 0) (get_local 0x223))
-    (i64.store offset=0x224 align=1 (i32.const 0) (get_local 0x224))
-    (i64.store offset=0x225 align=1 (i32.const 0) (get_local 0x225))
-    (i64.store offset=0x226 align=1 (i32.const 0) (get_local 0x226))
-    (i64.store offset=0x227 align=1 (i32.const 0) (get_local 0x227))
-    (i64.store offset=0x228 align=1 (i32.const 0) (get_local 0x228))
-    (i64.store offset=0x229 align=1 (i32.const 0) (get_local 0x229))
-    (i64.store offset=0x22a align=1 (i32.const 0) (get_local 0x22a))
-    (i64.store offset=0x22b align=1 (i32.const 0) (get_local 0x22b))
-    (i64.store offset=0x22c align=1 (i32.const 0) (get_local 0x22c))
-    (i64.store offset=0x22d align=1 (i32.const 0) (get_local 0x22d))
-    (i64.store offset=0x22e align=1 (i32.const 0) (get_local 0x22e))
-    (i64.store offset=0x22f align=1 (i32.const 0) (get_local 0x22f))
-    (i64.store offset=0x230 align=1 (i32.const 0) (get_local 0x230))
-    (i64.store offset=0x231 align=1 (i32.const 0) (get_local 0x231))
-    (i64.store offset=0x232 align=1 (i32.const 0) (get_local 0x232))
-    (i64.store offset=0x233 align=1 (i32.const 0) (get_local 0x233))
-    (i64.store offset=0x234 align=1 (i32.const 0) (get_local 0x234))
-    (i64.store offset=0x235 align=1 (i32.const 0) (get_local 0x235))
-    (i64.store offset=0x236 align=1 (i32.const 0) (get_local 0x236))
-    (i64.store offset=0x237 align=1 (i32.const 0) (get_local 0x237))
-    (i64.store offset=0x238 align=1 (i32.const 0) (get_local 0x238))
-    (i64.store offset=0x239 align=1 (i32.const 0) (get_local 0x239))
-    (i64.store offset=0x23a align=1 (i32.const 0) (get_local 0x23a))
-    (i64.store offset=0x23b align=1 (i32.const 0) (get_local 0x23b))
-    (i64.store offset=0x23c align=1 (i32.const 0) (get_local 0x23c))
-    (i64.store offset=0x23d align=1 (i32.const 0) (get_local 0x23d))
-    (i64.store offset=0x23e align=1 (i32.const 0) (get_local 0x23e))
-    (i64.store offset=0x23f align=1 (i32.const 0) (get_local 0x23f))
-    (i64.store offset=0x240 align=1 (i32.const 0) (get_local 0x240))
-    (i64.store offset=0x241 align=1 (i32.const 0) (get_local 0x241))
-    (i64.store offset=0x242 align=1 (i32.const 0) (get_local 0x242))
-    (i64.store offset=0x243 align=1 (i32.const 0) (get_local 0x243))
-    (i64.store offset=0x244 align=1 (i32.const 0) (get_local 0x244))
-    (i64.store offset=0x245 align=1 (i32.const 0) (get_local 0x245))
-    (i64.store offset=0x246 align=1 (i32.const 0) (get_local 0x246))
-    (i64.store offset=0x247 align=1 (i32.const 0) (get_local 0x247))
-    (i64.store offset=0x248 align=1 (i32.const 0) (get_local 0x248))
-    (i64.store offset=0x249 align=1 (i32.const 0) (get_local 0x249))
-    (i64.store offset=0x24a align=1 (i32.const 0) (get_local 0x24a))
-    (i64.store offset=0x24b align=1 (i32.const 0) (get_local 0x24b))
-    (i64.store offset=0x24c align=1 (i32.const 0) (get_local 0x24c))
-    (i64.store offset=0x24d align=1 (i32.const 0) (get_local 0x24d))
-    (i64.store offset=0x24e align=1 (i32.const 0) (get_local 0x24e))
-    (i64.store offset=0x24f align=1 (i32.const 0) (get_local 0x24f))
-    (i64.store offset=0x250 align=1 (i32.const 0) (get_local 0x250))
-    (i64.store offset=0x251 align=1 (i32.const 0) (get_local 0x251))
-    (i64.store offset=0x252 align=1 (i32.const 0) (get_local 0x252))
-    (i64.store offset=0x253 align=1 (i32.const 0) (get_local 0x253))
-    (i64.store offset=0x254 align=1 (i32.const 0) (get_local 0x254))
-    (i64.store offset=0x255 align=1 (i32.const 0) (get_local 0x255))
-    (i64.store offset=0x256 align=1 (i32.const 0) (get_local 0x256))
-    (i64.store offset=0x257 align=1 (i32.const 0) (get_local 0x257))
-    (i64.store offset=0x258 align=1 (i32.const 0) (get_local 0x258))
-    (i64.store offset=0x259 align=1 (i32.const 0) (get_local 0x259))
-    (i64.store offset=0x25a align=1 (i32.const 0) (get_local 0x25a))
-    (i64.store offset=0x25b align=1 (i32.const 0) (get_local 0x25b))
-    (i64.store offset=0x25c align=1 (i32.const 0) (get_local 0x25c))
-    (i64.store offset=0x25d align=1 (i32.const 0) (get_local 0x25d))
-    (i64.store offset=0x25e align=1 (i32.const 0) (get_local 0x25e))
-    (i64.store offset=0x25f align=1 (i32.const 0) (get_local 0x25f))
-    (i64.store offset=0x260 align=1 (i32.const 0) (get_local 0x260))
-    (i64.store offset=0x261 align=1 (i32.const 0) (get_local 0x261))
-    (i64.store offset=0x262 align=1 (i32.const 0) (get_local 0x262))
-    (i64.store offset=0x263 align=1 (i32.const 0) (get_local 0x263))
-    (i64.store offset=0x264 align=1 (i32.const 0) (get_local 0x264))
-    (i64.store offset=0x265 align=1 (i32.const 0) (get_local 0x265))
-    (i64.store offset=0x266 align=1 (i32.const 0) (get_local 0x266))
-    (i64.store offset=0x267 align=1 (i32.const 0) (get_local 0x267))
-    (i64.store offset=0x268 align=1 (i32.const 0) (get_local 0x268))
-    (i64.store offset=0x269 align=1 (i32.const 0) (get_local 0x269))
-    (i64.store offset=0x26a align=1 (i32.const 0) (get_local 0x26a))
-    (i64.store offset=0x26b align=1 (i32.const 0) (get_local 0x26b))
-    (i64.store offset=0x26c align=1 (i32.const 0) (get_local 0x26c))
-    (i64.store offset=0x26d align=1 (i32.const 0) (get_local 0x26d))
-    (i64.store offset=0x26e align=1 (i32.const 0) (get_local 0x26e))
-    (i64.store offset=0x26f align=1 (i32.const 0) (get_local 0x26f))
-    (i64.store offset=0x270 align=1 (i32.const 0) (get_local 0x270))
-    (i64.store offset=0x271 align=1 (i32.const 0) (get_local 0x271))
-    (i64.store offset=0x272 align=1 (i32.const 0) (get_local 0x272))
-    (i64.store offset=0x273 align=1 (i32.const 0) (get_local 0x273))
-    (i64.store offset=0x274 align=1 (i32.const 0) (get_local 0x274))
-    (i64.store offset=0x275 align=1 (i32.const 0) (get_local 0x275))
-    (i64.store offset=0x276 align=1 (i32.const 0) (get_local 0x276))
-    (i64.store offset=0x277 align=1 (i32.const 0) (get_local 0x277))
-    (i64.store offset=0x278 align=1 (i32.const 0) (get_local 0x278))
-    (i64.store offset=0x279 align=1 (i32.const 0) (get_local 0x279))
-    (i64.store offset=0x27a align=1 (i32.const 0) (get_local 0x27a))
-    (i64.store offset=0x27b align=1 (i32.const 0) (get_local 0x27b))
-    (i64.store offset=0x27c align=1 (i32.const 0) (get_local 0x27c))
-    (i64.store offset=0x27d align=1 (i32.const 0) (get_local 0x27d))
-    (i64.store offset=0x27e align=1 (i32.const 0) (get_local 0x27e))
-    (i64.store offset=0x27f align=1 (i32.const 0) (get_local 0x27f))
-    (i64.store offset=0x280 align=1 (i32.const 0) (get_local 0x280))
-    (i64.store offset=0x281 align=1 (i32.const 0) (get_local 0x281))
-    (i64.store offset=0x282 align=1 (i32.const 0) (get_local 0x282))
-    (i64.store offset=0x283 align=1 (i32.const 0) (get_local 0x283))
-    (i64.store offset=0x284 align=1 (i32.const 0) (get_local 0x284))
-    (i64.store offset=0x285 align=1 (i32.const 0) (get_local 0x285))
-    (i64.store offset=0x286 align=1 (i32.const 0) (get_local 0x286))
-    (i64.store offset=0x287 align=1 (i32.const 0) (get_local 0x287))
-    (i64.store offset=0x288 align=1 (i32.const 0) (get_local 0x288))
-    (i64.store offset=0x289 align=1 (i32.const 0) (get_local 0x289))
-    (i64.store offset=0x28a align=1 (i32.const 0) (get_local 0x28a))
-    (i64.store offset=0x28b align=1 (i32.const 0) (get_local 0x28b))
-    (i64.store offset=0x28c align=1 (i32.const 0) (get_local 0x28c))
-    (i64.store offset=0x28d align=1 (i32.const 0) (get_local 0x28d))
-    (i64.store offset=0x28e align=1 (i32.const 0) (get_local 0x28e))
-    (i64.store offset=0x28f align=1 (i32.const 0) (get_local 0x28f))
-    (i64.store offset=0x290 align=1 (i32.const 0) (get_local 0x290))
-    (i64.store offset=0x291 align=1 (i32.const 0) (get_local 0x291))
-    (i64.store offset=0x292 align=1 (i32.const 0) (get_local 0x292))
-    (i64.store offset=0x293 align=1 (i32.const 0) (get_local 0x293))
-    (i64.store offset=0x294 align=1 (i32.const 0) (get_local 0x294))
-    (i64.store offset=0x295 align=1 (i32.const 0) (get_local 0x295))
-    (i64.store offset=0x296 align=1 (i32.const 0) (get_local 0x296))
-    (i64.store offset=0x297 align=1 (i32.const 0) (get_local 0x297))
-    (i64.store offset=0x298 align=1 (i32.const 0) (get_local 0x298))
-    (i64.store offset=0x299 align=1 (i32.const 0) (get_local 0x299))
-    (i64.store offset=0x29a align=1 (i32.const 0) (get_local 0x29a))
-    (i64.store offset=0x29b align=1 (i32.const 0) (get_local 0x29b))
-    (i64.store offset=0x29c align=1 (i32.const 0) (get_local 0x29c))
-    (i64.store offset=0x29d align=1 (i32.const 0) (get_local 0x29d))
-    (i64.store offset=0x29e align=1 (i32.const 0) (get_local 0x29e))
-    (i64.store offset=0x29f align=1 (i32.const 0) (get_local 0x29f))
-    (i64.store offset=0x2a0 align=1 (i32.const 0) (get_local 0x2a0))
-    (i64.store offset=0x2a1 align=1 (i32.const 0) (get_local 0x2a1))
-    (i64.store offset=0x2a2 align=1 (i32.const 0) (get_local 0x2a2))
-    (i64.store offset=0x2a3 align=1 (i32.const 0) (get_local 0x2a3))
-    (i64.store offset=0x2a4 align=1 (i32.const 0) (get_local 0x2a4))
-    (i64.store offset=0x2a5 align=1 (i32.const 0) (get_local 0x2a5))
-    (i64.store offset=0x2a6 align=1 (i32.const 0) (get_local 0x2a6))
-    (i64.store offset=0x2a7 align=1 (i32.const 0) (get_local 0x2a7))
-    (i64.store offset=0x2a8 align=1 (i32.const 0) (get_local 0x2a8))
-    (i64.store offset=0x2a9 align=1 (i32.const 0) (get_local 0x2a9))
-    (i64.store offset=0x2aa align=1 (i32.const 0) (get_local 0x2aa))
-    (i64.store offset=0x2ab align=1 (i32.const 0) (get_local 0x2ab))
-    (i64.store offset=0x2ac align=1 (i32.const 0) (get_local 0x2ac))
-    (i64.store offset=0x2ad align=1 (i32.const 0) (get_local 0x2ad))
-    (i64.store offset=0x2ae align=1 (i32.const 0) (get_local 0x2ae))
-    (i64.store offset=0x2af align=1 (i32.const 0) (get_local 0x2af))
-    (i64.store offset=0x2b0 align=1 (i32.const 0) (get_local 0x2b0))
-    (i64.store offset=0x2b1 align=1 (i32.const 0) (get_local 0x2b1))
-    (i64.store offset=0x2b2 align=1 (i32.const 0) (get_local 0x2b2))
-    (i64.store offset=0x2b3 align=1 (i32.const 0) (get_local 0x2b3))
-    (i64.store offset=0x2b4 align=1 (i32.const 0) (get_local 0x2b4))
-    (i64.store offset=0x2b5 align=1 (i32.const 0) (get_local 0x2b5))
-    (i64.store offset=0x2b6 align=1 (i32.const 0) (get_local 0x2b6))
-    (i64.store offset=0x2b7 align=1 (i32.const 0) (get_local 0x2b7))
-    (i64.store offset=0x2b8 align=1 (i32.const 0) (get_local 0x2b8))
-    (i64.store offset=0x2b9 align=1 (i32.const 0) (get_local 0x2b9))
-    (i64.store offset=0x2ba align=1 (i32.const 0) (get_local 0x2ba))
-    (i64.store offset=0x2bb align=1 (i32.const 0) (get_local 0x2bb))
-    (i64.store offset=0x2bc align=1 (i32.const 0) (get_local 0x2bc))
-    (i64.store offset=0x2bd align=1 (i32.const 0) (get_local 0x2bd))
-    (i64.store offset=0x2be align=1 (i32.const 0) (get_local 0x2be))
-    (i64.store offset=0x2bf align=1 (i32.const 0) (get_local 0x2bf))
-    (i64.store offset=0x2c0 align=1 (i32.const 0) (get_local 0x2c0))
-    (i64.store offset=0x2c1 align=1 (i32.const 0) (get_local 0x2c1))
-    (i64.store offset=0x2c2 align=1 (i32.const 0) (get_local 0x2c2))
-    (i64.store offset=0x2c3 align=1 (i32.const 0) (get_local 0x2c3))
-    (i64.store offset=0x2c4 align=1 (i32.const 0) (get_local 0x2c4))
-    (i64.store offset=0x2c5 align=1 (i32.const 0) (get_local 0x2c5))
-    (i64.store offset=0x2c6 align=1 (i32.const 0) (get_local 0x2c6))
-    (i64.store offset=0x2c7 align=1 (i32.const 0) (get_local 0x2c7))
-    (i64.store offset=0x2c8 align=1 (i32.const 0) (get_local 0x2c8))
-    (i64.store offset=0x2c9 align=1 (i32.const 0) (get_local 0x2c9))
-    (i64.store offset=0x2ca align=1 (i32.const 0) (get_local 0x2ca))
-    (i64.store offset=0x2cb align=1 (i32.const 0) (get_local 0x2cb))
-    (i64.store offset=0x2cc align=1 (i32.const 0) (get_local 0x2cc))
-    (i64.store offset=0x2cd align=1 (i32.const 0) (get_local 0x2cd))
-    (i64.store offset=0x2ce align=1 (i32.const 0) (get_local 0x2ce))
-    (i64.store offset=0x2cf align=1 (i32.const 0) (get_local 0x2cf))
-    (i64.store offset=0x2d0 align=1 (i32.const 0) (get_local 0x2d0))
-    (i64.store offset=0x2d1 align=1 (i32.const 0) (get_local 0x2d1))
-    (i64.store offset=0x2d2 align=1 (i32.const 0) (get_local 0x2d2))
-    (i64.store offset=0x2d3 align=1 (i32.const 0) (get_local 0x2d3))
-    (i64.store offset=0x2d4 align=1 (i32.const 0) (get_local 0x2d4))
-    (i64.store offset=0x2d5 align=1 (i32.const 0) (get_local 0x2d5))
-    (i64.store offset=0x2d6 align=1 (i32.const 0) (get_local 0x2d6))
-    (i64.store offset=0x2d7 align=1 (i32.const 0) (get_local 0x2d7))
-    (i64.store offset=0x2d8 align=1 (i32.const 0) (get_local 0x2d8))
-    (i64.store offset=0x2d9 align=1 (i32.const 0) (get_local 0x2d9))
-    (i64.store offset=0x2da align=1 (i32.const 0) (get_local 0x2da))
-    (i64.store offset=0x2db align=1 (i32.const 0) (get_local 0x2db))
-    (i64.store offset=0x2dc align=1 (i32.const 0) (get_local 0x2dc))
-    (i64.store offset=0x2dd align=1 (i32.const 0) (get_local 0x2dd))
-    (i64.store offset=0x2de align=1 (i32.const 0) (get_local 0x2de))
-    (i64.store offset=0x2df align=1 (i32.const 0) (get_local 0x2df))
-    (i64.store offset=0x2e0 align=1 (i32.const 0) (get_local 0x2e0))
-    (i64.store offset=0x2e1 align=1 (i32.const 0) (get_local 0x2e1))
-    (i64.store offset=0x2e2 align=1 (i32.const 0) (get_local 0x2e2))
-    (i64.store offset=0x2e3 align=1 (i32.const 0) (get_local 0x2e3))
-    (i64.store offset=0x2e4 align=1 (i32.const 0) (get_local 0x2e4))
-    (i64.store offset=0x2e5 align=1 (i32.const 0) (get_local 0x2e5))
-    (i64.store offset=0x2e6 align=1 (i32.const 0) (get_local 0x2e6))
-    (i64.store offset=0x2e7 align=1 (i32.const 0) (get_local 0x2e7))
-    (i64.store offset=0x2e8 align=1 (i32.const 0) (get_local 0x2e8))
-    (i64.store offset=0x2e9 align=1 (i32.const 0) (get_local 0x2e9))
-    (i64.store offset=0x2ea align=1 (i32.const 0) (get_local 0x2ea))
-    (i64.store offset=0x2eb align=1 (i32.const 0) (get_local 0x2eb))
-    (i64.store offset=0x2ec align=1 (i32.const 0) (get_local 0x2ec))
-    (i64.store offset=0x2ed align=1 (i32.const 0) (get_local 0x2ed))
-    (i64.store offset=0x2ee align=1 (i32.const 0) (get_local 0x2ee))
-    (i64.store offset=0x2ef align=1 (i32.const 0) (get_local 0x2ef))
-    (i64.store offset=0x2f0 align=1 (i32.const 0) (get_local 0x2f0))
-    (i64.store offset=0x2f1 align=1 (i32.const 0) (get_local 0x2f1))
-    (i64.store offset=0x2f2 align=1 (i32.const 0) (get_local 0x2f2))
-    (i64.store offset=0x2f3 align=1 (i32.const 0) (get_local 0x2f3))
-    (i64.store offset=0x2f4 align=1 (i32.const 0) (get_local 0x2f4))
-    (i64.store offset=0x2f5 align=1 (i32.const 0) (get_local 0x2f5))
-    (i64.store offset=0x2f6 align=1 (i32.const 0) (get_local 0x2f6))
-    (i64.store offset=0x2f7 align=1 (i32.const 0) (get_local 0x2f7))
-    (i64.store offset=0x2f8 align=1 (i32.const 0) (get_local 0x2f8))
-    (i64.store offset=0x2f9 align=1 (i32.const 0) (get_local 0x2f9))
-    (i64.store offset=0x2fa align=1 (i32.const 0) (get_local 0x2fa))
-    (i64.store offset=0x2fb align=1 (i32.const 0) (get_local 0x2fb))
-    (i64.store offset=0x2fc align=1 (i32.const 0) (get_local 0x2fc))
-    (i64.store offset=0x2fd align=1 (i32.const 0) (get_local 0x2fd))
-    (i64.store offset=0x2fe align=1 (i32.const 0) (get_local 0x2fe))
-    (i64.store offset=0x2ff align=1 (i32.const 0) (get_local 0x2ff))
-    (i64.store offset=0x300 align=1 (i32.const 0) (get_local 0x300))
-    (i64.store offset=0x301 align=1 (i32.const 0) (get_local 0x301))
-    (i64.store offset=0x302 align=1 (i32.const 0) (get_local 0x302))
-    (i64.store offset=0x303 align=1 (i32.const 0) (get_local 0x303))
-    (i64.store offset=0x304 align=1 (i32.const 0) (get_local 0x304))
-    (i64.store offset=0x305 align=1 (i32.const 0) (get_local 0x305))
-    (i64.store offset=0x306 align=1 (i32.const 0) (get_local 0x306))
-    (i64.store offset=0x307 align=1 (i32.const 0) (get_local 0x307))
-    (i64.store offset=0x308 align=1 (i32.const 0) (get_local 0x308))
-    (i64.store offset=0x309 align=1 (i32.const 0) (get_local 0x309))
-    (i64.store offset=0x30a align=1 (i32.const 0) (get_local 0x30a))
-    (i64.store offset=0x30b align=1 (i32.const 0) (get_local 0x30b))
-    (i64.store offset=0x30c align=1 (i32.const 0) (get_local 0x30c))
-    (i64.store offset=0x30d align=1 (i32.const 0) (get_local 0x30d))
-    (i64.store offset=0x30e align=1 (i32.const 0) (get_local 0x30e))
-    (i64.store offset=0x30f align=1 (i32.const 0) (get_local 0x30f))
-    (i64.store offset=0x310 align=1 (i32.const 0) (get_local 0x310))
-    (i64.store offset=0x311 align=1 (i32.const 0) (get_local 0x311))
-    (i64.store offset=0x312 align=1 (i32.const 0) (get_local 0x312))
-    (i64.store offset=0x313 align=1 (i32.const 0) (get_local 0x313))
-    (i64.store offset=0x314 align=1 (i32.const 0) (get_local 0x314))
-    (i64.store offset=0x315 align=1 (i32.const 0) (get_local 0x315))
-    (i64.store offset=0x316 align=1 (i32.const 0) (get_local 0x316))
-    (i64.store offset=0x317 align=1 (i32.const 0) (get_local 0x317))
-    (i64.store offset=0x318 align=1 (i32.const 0) (get_local 0x318))
-    (i64.store offset=0x319 align=1 (i32.const 0) (get_local 0x319))
-    (i64.store offset=0x31a align=1 (i32.const 0) (get_local 0x31a))
-    (i64.store offset=0x31b align=1 (i32.const 0) (get_local 0x31b))
-    (i64.store offset=0x31c align=1 (i32.const 0) (get_local 0x31c))
-    (i64.store offset=0x31d align=1 (i32.const 0) (get_local 0x31d))
-    (i64.store offset=0x31e align=1 (i32.const 0) (get_local 0x31e))
-    (i64.store offset=0x31f align=1 (i32.const 0) (get_local 0x31f))
-    (i64.store offset=0x320 align=1 (i32.const 0) (get_local 0x320))
-    (i64.store offset=0x321 align=1 (i32.const 0) (get_local 0x321))
-    (i64.store offset=0x322 align=1 (i32.const 0) (get_local 0x322))
-    (i64.store offset=0x323 align=1 (i32.const 0) (get_local 0x323))
-    (i64.store offset=0x324 align=1 (i32.const 0) (get_local 0x324))
-    (i64.store offset=0x325 align=1 (i32.const 0) (get_local 0x325))
-    (i64.store offset=0x326 align=1 (i32.const 0) (get_local 0x326))
-    (i64.store offset=0x327 align=1 (i32.const 0) (get_local 0x327))
-    (i64.store offset=0x328 align=1 (i32.const 0) (get_local 0x328))
-    (i64.store offset=0x329 align=1 (i32.const 0) (get_local 0x329))
-    (i64.store offset=0x32a align=1 (i32.const 0) (get_local 0x32a))
-    (i64.store offset=0x32b align=1 (i32.const 0) (get_local 0x32b))
-    (i64.store offset=0x32c align=1 (i32.const 0) (get_local 0x32c))
-    (i64.store offset=0x32d align=1 (i32.const 0) (get_local 0x32d))
-    (i64.store offset=0x32e align=1 (i32.const 0) (get_local 0x32e))
-    (i64.store offset=0x32f align=1 (i32.const 0) (get_local 0x32f))
-    (i64.store offset=0x330 align=1 (i32.const 0) (get_local 0x330))
-    (i64.store offset=0x331 align=1 (i32.const 0) (get_local 0x331))
-    (i64.store offset=0x332 align=1 (i32.const 0) (get_local 0x332))
-    (i64.store offset=0x333 align=1 (i32.const 0) (get_local 0x333))
-    (i64.store offset=0x334 align=1 (i32.const 0) (get_local 0x334))
-    (i64.store offset=0x335 align=1 (i32.const 0) (get_local 0x335))
-    (i64.store offset=0x336 align=1 (i32.const 0) (get_local 0x336))
-    (i64.store offset=0x337 align=1 (i32.const 0) (get_local 0x337))
-    (i64.store offset=0x338 align=1 (i32.const 0) (get_local 0x338))
-    (i64.store offset=0x339 align=1 (i32.const 0) (get_local 0x339))
-    (i64.store offset=0x33a align=1 (i32.const 0) (get_local 0x33a))
-    (i64.store offset=0x33b align=1 (i32.const 0) (get_local 0x33b))
-    (i64.store offset=0x33c align=1 (i32.const 0) (get_local 0x33c))
-    (i64.store offset=0x33d align=1 (i32.const 0) (get_local 0x33d))
-    (i64.store offset=0x33e align=1 (i32.const 0) (get_local 0x33e))
-    (i64.store offset=0x33f align=1 (i32.const 0) (get_local 0x33f))
-    (i64.store offset=0x340 align=1 (i32.const 0) (get_local 0x340))
-    (i64.store offset=0x341 align=1 (i32.const 0) (get_local 0x341))
-    (i64.store offset=0x342 align=1 (i32.const 0) (get_local 0x342))
-    (i64.store offset=0x343 align=1 (i32.const 0) (get_local 0x343))
-    (i64.store offset=0x344 align=1 (i32.const 0) (get_local 0x344))
-    (i64.store offset=0x345 align=1 (i32.const 0) (get_local 0x345))
-    (i64.store offset=0x346 align=1 (i32.const 0) (get_local 0x346))
-    (i64.store offset=0x347 align=1 (i32.const 0) (get_local 0x347))
-    (i64.store offset=0x348 align=1 (i32.const 0) (get_local 0x348))
-    (i64.store offset=0x349 align=1 (i32.const 0) (get_local 0x349))
-    (i64.store offset=0x34a align=1 (i32.const 0) (get_local 0x34a))
-    (i64.store offset=0x34b align=1 (i32.const 0) (get_local 0x34b))
-    (i64.store offset=0x34c align=1 (i32.const 0) (get_local 0x34c))
-    (i64.store offset=0x34d align=1 (i32.const 0) (get_local 0x34d))
-    (i64.store offset=0x34e align=1 (i32.const 0) (get_local 0x34e))
-    (i64.store offset=0x34f align=1 (i32.const 0) (get_local 0x34f))
-    (i64.store offset=0x350 align=1 (i32.const 0) (get_local 0x350))
-    (i64.store offset=0x351 align=1 (i32.const 0) (get_local 0x351))
-    (i64.store offset=0x352 align=1 (i32.const 0) (get_local 0x352))
-    (i64.store offset=0x353 align=1 (i32.const 0) (get_local 0x353))
-    (i64.store offset=0x354 align=1 (i32.const 0) (get_local 0x354))
-    (i64.store offset=0x355 align=1 (i32.const 0) (get_local 0x355))
-    (i64.store offset=0x356 align=1 (i32.const 0) (get_local 0x356))
-    (i64.store offset=0x357 align=1 (i32.const 0) (get_local 0x357))
-    (i64.store offset=0x358 align=1 (i32.const 0) (get_local 0x358))
-    (i64.store offset=0x359 align=1 (i32.const 0) (get_local 0x359))
-    (i64.store offset=0x35a align=1 (i32.const 0) (get_local 0x35a))
-    (i64.store offset=0x35b align=1 (i32.const 0) (get_local 0x35b))
-    (i64.store offset=0x35c align=1 (i32.const 0) (get_local 0x35c))
-    (i64.store offset=0x35d align=1 (i32.const 0) (get_local 0x35d))
-    (i64.store offset=0x35e align=1 (i32.const 0) (get_local 0x35e))
-    (i64.store offset=0x35f align=1 (i32.const 0) (get_local 0x35f))
-    (i64.store offset=0x360 align=1 (i32.const 0) (get_local 0x360))
-    (i64.store offset=0x361 align=1 (i32.const 0) (get_local 0x361))
-    (i64.store offset=0x362 align=1 (i32.const 0) (get_local 0x362))
-    (i64.store offset=0x363 align=1 (i32.const 0) (get_local 0x363))
-    (i64.store offset=0x364 align=1 (i32.const 0) (get_local 0x364))
-    (i64.store offset=0x365 align=1 (i32.const 0) (get_local 0x365))
-    (i64.store offset=0x366 align=1 (i32.const 0) (get_local 0x366))
-    (i64.store offset=0x367 align=1 (i32.const 0) (get_local 0x367))
-    (i64.store offset=0x368 align=1 (i32.const 0) (get_local 0x368))
-    (i64.store offset=0x369 align=1 (i32.const 0) (get_local 0x369))
-    (i64.store offset=0x36a align=1 (i32.const 0) (get_local 0x36a))
-    (i64.store offset=0x36b align=1 (i32.const 0) (get_local 0x36b))
-    (i64.store offset=0x36c align=1 (i32.const 0) (get_local 0x36c))
-    (i64.store offset=0x36d align=1 (i32.const 0) (get_local 0x36d))
-    (i64.store offset=0x36e align=1 (i32.const 0) (get_local 0x36e))
-    (i64.store offset=0x36f align=1 (i32.const 0) (get_local 0x36f))
-    (i64.store offset=0x370 align=1 (i32.const 0) (get_local 0x370))
-    (i64.store offset=0x371 align=1 (i32.const 0) (get_local 0x371))
-    (i64.store offset=0x372 align=1 (i32.const 0) (get_local 0x372))
-    (i64.store offset=0x373 align=1 (i32.const 0) (get_local 0x373))
-    (i64.store offset=0x374 align=1 (i32.const 0) (get_local 0x374))
-    (i64.store offset=0x375 align=1 (i32.const 0) (get_local 0x375))
-    (i64.store offset=0x376 align=1 (i32.const 0) (get_local 0x376))
-    (i64.store offset=0x377 align=1 (i32.const 0) (get_local 0x377))
-    (i64.store offset=0x378 align=1 (i32.const 0) (get_local 0x378))
-    (i64.store offset=0x379 align=1 (i32.const 0) (get_local 0x379))
-    (i64.store offset=0x37a align=1 (i32.const 0) (get_local 0x37a))
-    (i64.store offset=0x37b align=1 (i32.const 0) (get_local 0x37b))
-    (i64.store offset=0x37c align=1 (i32.const 0) (get_local 0x37c))
-    (i64.store offset=0x37d align=1 (i32.const 0) (get_local 0x37d))
-    (i64.store offset=0x37e align=1 (i32.const 0) (get_local 0x37e))
-    (i64.store offset=0x37f align=1 (i32.const 0) (get_local 0x37f))
-    (i64.store offset=0x380 align=1 (i32.const 0) (get_local 0x380))
-    (i64.store offset=0x381 align=1 (i32.const 0) (get_local 0x381))
-    (i64.store offset=0x382 align=1 (i32.const 0) (get_local 0x382))
-    (i64.store offset=0x383 align=1 (i32.const 0) (get_local 0x383))
-    (i64.store offset=0x384 align=1 (i32.const 0) (get_local 0x384))
-    (i64.store offset=0x385 align=1 (i32.const 0) (get_local 0x385))
-    (i64.store offset=0x386 align=1 (i32.const 0) (get_local 0x386))
-    (i64.store offset=0x387 align=1 (i32.const 0) (get_local 0x387))
-    (i64.store offset=0x388 align=1 (i32.const 0) (get_local 0x388))
-    (i64.store offset=0x389 align=1 (i32.const 0) (get_local 0x389))
-    (i64.store offset=0x38a align=1 (i32.const 0) (get_local 0x38a))
-    (i64.store offset=0x38b align=1 (i32.const 0) (get_local 0x38b))
-    (i64.store offset=0x38c align=1 (i32.const 0) (get_local 0x38c))
-    (i64.store offset=0x38d align=1 (i32.const 0) (get_local 0x38d))
-    (i64.store offset=0x38e align=1 (i32.const 0) (get_local 0x38e))
-    (i64.store offset=0x38f align=1 (i32.const 0) (get_local 0x38f))
-    (i64.store offset=0x390 align=1 (i32.const 0) (get_local 0x390))
-    (i64.store offset=0x391 align=1 (i32.const 0) (get_local 0x391))
-    (i64.store offset=0x392 align=1 (i32.const 0) (get_local 0x392))
-    (i64.store offset=0x393 align=1 (i32.const 0) (get_local 0x393))
-    (i64.store offset=0x394 align=1 (i32.const 0) (get_local 0x394))
-    (i64.store offset=0x395 align=1 (i32.const 0) (get_local 0x395))
-    (i64.store offset=0x396 align=1 (i32.const 0) (get_local 0x396))
-    (i64.store offset=0x397 align=1 (i32.const 0) (get_local 0x397))
-    (i64.store offset=0x398 align=1 (i32.const 0) (get_local 0x398))
-    (i64.store offset=0x399 align=1 (i32.const 0) (get_local 0x399))
-    (i64.store offset=0x39a align=1 (i32.const 0) (get_local 0x39a))
-    (i64.store offset=0x39b align=1 (i32.const 0) (get_local 0x39b))
-    (i64.store offset=0x39c align=1 (i32.const 0) (get_local 0x39c))
-    (i64.store offset=0x39d align=1 (i32.const 0) (get_local 0x39d))
-    (i64.store offset=0x39e align=1 (i32.const 0) (get_local 0x39e))
-    (i64.store offset=0x39f align=1 (i32.const 0) (get_local 0x39f))
-    (i64.store offset=0x3a0 align=1 (i32.const 0) (get_local 0x3a0))
-    (i64.store offset=0x3a1 align=1 (i32.const 0) (get_local 0x3a1))
-    (i64.store offset=0x3a2 align=1 (i32.const 0) (get_local 0x3a2))
-    (i64.store offset=0x3a3 align=1 (i32.const 0) (get_local 0x3a3))
-    (i64.store offset=0x3a4 align=1 (i32.const 0) (get_local 0x3a4))
-    (i64.store offset=0x3a5 align=1 (i32.const 0) (get_local 0x3a5))
-    (i64.store offset=0x3a6 align=1 (i32.const 0) (get_local 0x3a6))
-    (i64.store offset=0x3a7 align=1 (i32.const 0) (get_local 0x3a7))
-    (i64.store offset=0x3a8 align=1 (i32.const 0) (get_local 0x3a8))
-    (i64.store offset=0x3a9 align=1 (i32.const 0) (get_local 0x3a9))
-    (i64.store offset=0x3aa align=1 (i32.const 0) (get_local 0x3aa))
-    (i64.store offset=0x3ab align=1 (i32.const 0) (get_local 0x3ab))
-    (i64.store offset=0x3ac align=1 (i32.const 0) (get_local 0x3ac))
-    (i64.store offset=0x3ad align=1 (i32.const 0) (get_local 0x3ad))
-    (i64.store offset=0x3ae align=1 (i32.const 0) (get_local 0x3ae))
-    (i64.store offset=0x3af align=1 (i32.const 0) (get_local 0x3af))
-    (i64.store offset=0x3b0 align=1 (i32.const 0) (get_local 0x3b0))
-    (i64.store offset=0x3b1 align=1 (i32.const 0) (get_local 0x3b1))
-    (i64.store offset=0x3b2 align=1 (i32.const 0) (get_local 0x3b2))
-    (i64.store offset=0x3b3 align=1 (i32.const 0) (get_local 0x3b3))
-    (i64.store offset=0x3b4 align=1 (i32.const 0) (get_local 0x3b4))
-    (i64.store offset=0x3b5 align=1 (i32.const 0) (get_local 0x3b5))
-    (i64.store offset=0x3b6 align=1 (i32.const 0) (get_local 0x3b6))
-    (i64.store offset=0x3b7 align=1 (i32.const 0) (get_local 0x3b7))
-    (i64.store offset=0x3b8 align=1 (i32.const 0) (get_local 0x3b8))
-    (i64.store offset=0x3b9 align=1 (i32.const 0) (get_local 0x3b9))
-    (i64.store offset=0x3ba align=1 (i32.const 0) (get_local 0x3ba))
-    (i64.store offset=0x3bb align=1 (i32.const 0) (get_local 0x3bb))
-    (i64.store offset=0x3bc align=1 (i32.const 0) (get_local 0x3bc))
-    (i64.store offset=0x3bd align=1 (i32.const 0) (get_local 0x3bd))
-    (i64.store offset=0x3be align=1 (i32.const 0) (get_local 0x3be))
-    (i64.store offset=0x3bf align=1 (i32.const 0) (get_local 0x3bf))
-    (i64.store offset=0x3c0 align=1 (i32.const 0) (get_local 0x3c0))
-    (i64.store offset=0x3c1 align=1 (i32.const 0) (get_local 0x3c1))
-    (i64.store offset=0x3c2 align=1 (i32.const 0) (get_local 0x3c2))
-    (i64.store offset=0x3c3 align=1 (i32.const 0) (get_local 0x3c3))
-    (i64.store offset=0x3c4 align=1 (i32.const 0) (get_local 0x3c4))
-    (i64.store offset=0x3c5 align=1 (i32.const 0) (get_local 0x3c5))
-    (i64.store offset=0x3c6 align=1 (i32.const 0) (get_local 0x3c6))
-    (i64.store offset=0x3c7 align=1 (i32.const 0) (get_local 0x3c7))
-    (i64.store offset=0x3c8 align=1 (i32.const 0) (get_local 0x3c8))
-    (i64.store offset=0x3c9 align=1 (i32.const 0) (get_local 0x3c9))
-    (i64.store offset=0x3ca align=1 (i32.const 0) (get_local 0x3ca))
-    (i64.store offset=0x3cb align=1 (i32.const 0) (get_local 0x3cb))
-    (i64.store offset=0x3cc align=1 (i32.const 0) (get_local 0x3cc))
-    (i64.store offset=0x3cd align=1 (i32.const 0) (get_local 0x3cd))
-    (i64.store offset=0x3ce align=1 (i32.const 0) (get_local 0x3ce))
-    (i64.store offset=0x3cf align=1 (i32.const 0) (get_local 0x3cf))
-    (i64.store offset=0x3d0 align=1 (i32.const 0) (get_local 0x3d0))
-    (i64.store offset=0x3d1 align=1 (i32.const 0) (get_local 0x3d1))
-    (i64.store offset=0x3d2 align=1 (i32.const 0) (get_local 0x3d2))
-    (i64.store offset=0x3d3 align=1 (i32.const 0) (get_local 0x3d3))
-    (i64.store offset=0x3d4 align=1 (i32.const 0) (get_local 0x3d4))
-    (i64.store offset=0x3d5 align=1 (i32.const 0) (get_local 0x3d5))
-    (i64.store offset=0x3d6 align=1 (i32.const 0) (get_local 0x3d6))
-    (i64.store offset=0x3d7 align=1 (i32.const 0) (get_local 0x3d7))
-    (i64.store offset=0x3d8 align=1 (i32.const 0) (get_local 0x3d8))
-    (i64.store offset=0x3d9 align=1 (i32.const 0) (get_local 0x3d9))
-    (i64.store offset=0x3da align=1 (i32.const 0) (get_local 0x3da))
-    (i64.store offset=0x3db align=1 (i32.const 0) (get_local 0x3db))
-    (i64.store offset=0x3dc align=1 (i32.const 0) (get_local 0x3dc))
-    (i64.store offset=0x3dd align=1 (i32.const 0) (get_local 0x3dd))
-    (i64.store offset=0x3de align=1 (i32.const 0) (get_local 0x3de))
-    (i64.store offset=0x3df align=1 (i32.const 0) (get_local 0x3df))
-    (i64.store offset=0x3e0 align=1 (i32.const 0) (get_local 0x3e0))
-    (i64.store offset=0x3e1 align=1 (i32.const 0) (get_local 0x3e1))
-    (i64.store offset=0x3e2 align=1 (i32.const 0) (get_local 0x3e2))
-    (i64.store offset=0x3e3 align=1 (i32.const 0) (get_local 0x3e3))
-    (i64.store offset=0x3e4 align=1 (i32.const 0) (get_local 0x3e4))
-    (i64.store offset=0x3e5 align=1 (i32.const 0) (get_local 0x3e5))
-    (i64.store offset=0x3e6 align=1 (i32.const 0) (get_local 0x3e6))
-    (i64.store offset=0x3e7 align=1 (i32.const 0) (get_local 0x3e7))
-    (i64.store offset=0x3e8 align=1 (i32.const 0) (get_local 0x3e8))
-    (i64.store offset=0x3e9 align=1 (i32.const 0) (get_local 0x3e9))
-    (i64.store offset=0x3ea align=1 (i32.const 0) (get_local 0x3ea))
-    (i64.store offset=0x3eb align=1 (i32.const 0) (get_local 0x3eb))
-    (i64.store offset=0x3ec align=1 (i32.const 0) (get_local 0x3ec))
-    (i64.store offset=0x3ed align=1 (i32.const 0) (get_local 0x3ed))
-    (i64.store offset=0x3ee align=1 (i32.const 0) (get_local 0x3ee))
-    (i64.store offset=0x3ef align=1 (i32.const 0) (get_local 0x3ef))
-    (i64.store offset=0x3f0 align=1 (i32.const 0) (get_local 0x3f0))
-    (i64.store offset=0x3f1 align=1 (i32.const 0) (get_local 0x3f1))
-    (i64.store offset=0x3f2 align=1 (i32.const 0) (get_local 0x3f2))
-    (i64.store offset=0x3f3 align=1 (i32.const 0) (get_local 0x3f3))
-    (i64.store offset=0x3f4 align=1 (i32.const 0) (get_local 0x3f4))
-    (i64.store offset=0x3f5 align=1 (i32.const 0) (get_local 0x3f5))
-    (i64.store offset=0x3f6 align=1 (i32.const 0) (get_local 0x3f6))
-    (i64.store offset=0x3f7 align=1 (i32.const 0) (get_local 0x3f7))
-    (i64.store offset=0x3f8 align=1 (i32.const 0) (get_local 0x3f8))
-    (i64.store offset=0x3f9 align=1 (i32.const 0) (get_local 0x3f9))
-    (i64.store offset=0x3fa align=1 (i32.const 0) (get_local 0x3fa))
-    (i64.store offset=0x3fb align=1 (i32.const 0) (get_local 0x3fb))
-    (i64.store offset=0x3fc align=1 (i32.const 0) (get_local 0x3fc))
-    (i64.store offset=0x3fd align=1 (i32.const 0) (get_local 0x3fd))
-    (i64.store offset=0x3fe align=1 (i32.const 0) (get_local 0x3fe))
-    (i64.store offset=0x3ff align=1 (i32.const 0) (get_local 0x3ff))
-    (i64.store offset=0x400 align=1 (i32.const 0) (get_local 0x400))
-    (i64.store offset=0x401 align=1 (i32.const 0) (get_local 0x401))
-    (i64.store offset=0x402 align=1 (i32.const 0) (get_local 0x402))
-    (i64.store offset=0x403 align=1 (i32.const 0) (get_local 0x403))
-    (i64.store offset=0x404 align=1 (i32.const 0) (get_local 0x404))
-    (i64.store offset=0x405 align=1 (i32.const 0) (get_local 0x405))
-    (i64.store offset=0x406 align=1 (i32.const 0) (get_local 0x406))
-    (i64.store offset=0x407 align=1 (i32.const 0) (get_local 0x407))
-    (i64.store offset=0x408 align=1 (i32.const 0) (get_local 0x408))
-    (i64.store offset=0x409 align=1 (i32.const 0) (get_local 0x409))
-    (i64.store offset=0x40a align=1 (i32.const 0) (get_local 0x40a))
-    (i64.store offset=0x40b align=1 (i32.const 0) (get_local 0x40b))
-    (i64.store offset=0x40c align=1 (i32.const 0) (get_local 0x40c))
-    (i64.store offset=0x40d align=1 (i32.const 0) (get_local 0x40d))
-    (i64.store offset=0x40e align=1 (i32.const 0) (get_local 0x40e))
-    (i64.store offset=0x40f align=1 (i32.const 0) (get_local 0x40f))
-    (i64.store offset=0x410 align=1 (i32.const 0) (get_local 0x410))
-    (i64.store offset=0x411 align=1 (i32.const 0) (get_local 0x411))
-    (i64.store offset=0x412 align=1 (i32.const 0) (get_local 0x412))
-    (i64.store offset=0x413 align=1 (i32.const 0) (get_local 0x413))
-    (i64.store offset=0x414 align=1 (i32.const 0) (get_local 0x414))
-    (i64.store offset=0x415 align=1 (i32.const 0) (get_local 0x415))
-    (i64.store offset=0x416 align=1 (i32.const 0) (get_local 0x416))
-    (i64.store offset=0x417 align=1 (i32.const 0) (get_local 0x417))
-    (i64.store offset=0x418 align=1 (i32.const 0) (get_local 0x418))
-    (i64.store offset=0x419 align=1 (i32.const 0) (get_local 0x419))
-    (i64.store offset=0x41a align=1 (i32.const 0) (get_local 0x41a))
-    (i64.store offset=0x41b align=1 (i32.const 0) (get_local 0x41b))
-    (i64.store offset=0x41c align=1 (i32.const 0) (get_local 0x41c))
-    (i64.store offset=0x41d align=1 (i32.const 0) (get_local 0x41d))
-    (i64.store offset=0x41e align=1 (i32.const 0) (get_local 0x41e))
-    (i64.store offset=0x41f align=1 (i32.const 0) (get_local 0x41f))
+    (i64.store offset=0x000 align=1 (i32.const 0) (local.get 0x000))
+    (i64.store offset=0x001 align=1 (i32.const 0) (local.get 0x001))
+    (i64.store offset=0x002 align=1 (i32.const 0) (local.get 0x002))
+    (i64.store offset=0x003 align=1 (i32.const 0) (local.get 0x003))
+    (i64.store offset=0x004 align=1 (i32.const 0) (local.get 0x004))
+    (i64.store offset=0x005 align=1 (i32.const 0) (local.get 0x005))
+    (i64.store offset=0x006 align=1 (i32.const 0) (local.get 0x006))
+    (i64.store offset=0x007 align=1 (i32.const 0) (local.get 0x007))
+    (i64.store offset=0x008 align=1 (i32.const 0) (local.get 0x008))
+    (i64.store offset=0x009 align=1 (i32.const 0) (local.get 0x009))
+    (i64.store offset=0x00a align=1 (i32.const 0) (local.get 0x00a))
+    (i64.store offset=0x00b align=1 (i32.const 0) (local.get 0x00b))
+    (i64.store offset=0x00c align=1 (i32.const 0) (local.get 0x00c))
+    (i64.store offset=0x00d align=1 (i32.const 0) (local.get 0x00d))
+    (i64.store offset=0x00e align=1 (i32.const 0) (local.get 0x00e))
+    (i64.store offset=0x00f align=1 (i32.const 0) (local.get 0x00f))
+    (i64.store offset=0x010 align=1 (i32.const 0) (local.get 0x010))
+    (i64.store offset=0x011 align=1 (i32.const 0) (local.get 0x011))
+    (i64.store offset=0x012 align=1 (i32.const 0) (local.get 0x012))
+    (i64.store offset=0x013 align=1 (i32.const 0) (local.get 0x013))
+    (i64.store offset=0x014 align=1 (i32.const 0) (local.get 0x014))
+    (i64.store offset=0x015 align=1 (i32.const 0) (local.get 0x015))
+    (i64.store offset=0x016 align=1 (i32.const 0) (local.get 0x016))
+    (i64.store offset=0x017 align=1 (i32.const 0) (local.get 0x017))
+    (i64.store offset=0x018 align=1 (i32.const 0) (local.get 0x018))
+    (i64.store offset=0x019 align=1 (i32.const 0) (local.get 0x019))
+    (i64.store offset=0x01a align=1 (i32.const 0) (local.get 0x01a))
+    (i64.store offset=0x01b align=1 (i32.const 0) (local.get 0x01b))
+    (i64.store offset=0x01c align=1 (i32.const 0) (local.get 0x01c))
+    (i64.store offset=0x01d align=1 (i32.const 0) (local.get 0x01d))
+    (i64.store offset=0x01e align=1 (i32.const 0) (local.get 0x01e))
+    (i64.store offset=0x01f align=1 (i32.const 0) (local.get 0x01f))
+    (i64.store offset=0x020 align=1 (i32.const 0) (local.get 0x020))
+    (i64.store offset=0x021 align=1 (i32.const 0) (local.get 0x021))
+    (i64.store offset=0x022 align=1 (i32.const 0) (local.get 0x022))
+    (i64.store offset=0x023 align=1 (i32.const 0) (local.get 0x023))
+    (i64.store offset=0x024 align=1 (i32.const 0) (local.get 0x024))
+    (i64.store offset=0x025 align=1 (i32.const 0) (local.get 0x025))
+    (i64.store offset=0x026 align=1 (i32.const 0) (local.get 0x026))
+    (i64.store offset=0x027 align=1 (i32.const 0) (local.get 0x027))
+    (i64.store offset=0x028 align=1 (i32.const 0) (local.get 0x028))
+    (i64.store offset=0x029 align=1 (i32.const 0) (local.get 0x029))
+    (i64.store offset=0x02a align=1 (i32.const 0) (local.get 0x02a))
+    (i64.store offset=0x02b align=1 (i32.const 0) (local.get 0x02b))
+    (i64.store offset=0x02c align=1 (i32.const 0) (local.get 0x02c))
+    (i64.store offset=0x02d align=1 (i32.const 0) (local.get 0x02d))
+    (i64.store offset=0x02e align=1 (i32.const 0) (local.get 0x02e))
+    (i64.store offset=0x02f align=1 (i32.const 0) (local.get 0x02f))
+    (i64.store offset=0x030 align=1 (i32.const 0) (local.get 0x030))
+    (i64.store offset=0x031 align=1 (i32.const 0) (local.get 0x031))
+    (i64.store offset=0x032 align=1 (i32.const 0) (local.get 0x032))
+    (i64.store offset=0x033 align=1 (i32.const 0) (local.get 0x033))
+    (i64.store offset=0x034 align=1 (i32.const 0) (local.get 0x034))
+    (i64.store offset=0x035 align=1 (i32.const 0) (local.get 0x035))
+    (i64.store offset=0x036 align=1 (i32.const 0) (local.get 0x036))
+    (i64.store offset=0x037 align=1 (i32.const 0) (local.get 0x037))
+    (i64.store offset=0x038 align=1 (i32.const 0) (local.get 0x038))
+    (i64.store offset=0x039 align=1 (i32.const 0) (local.get 0x039))
+    (i64.store offset=0x03a align=1 (i32.const 0) (local.get 0x03a))
+    (i64.store offset=0x03b align=1 (i32.const 0) (local.get 0x03b))
+    (i64.store offset=0x03c align=1 (i32.const 0) (local.get 0x03c))
+    (i64.store offset=0x03d align=1 (i32.const 0) (local.get 0x03d))
+    (i64.store offset=0x03e align=1 (i32.const 0) (local.get 0x03e))
+    (i64.store offset=0x03f align=1 (i32.const 0) (local.get 0x03f))
+    (i64.store offset=0x040 align=1 (i32.const 0) (local.get 0x040))
+    (i64.store offset=0x041 align=1 (i32.const 0) (local.get 0x041))
+    (i64.store offset=0x042 align=1 (i32.const 0) (local.get 0x042))
+    (i64.store offset=0x043 align=1 (i32.const 0) (local.get 0x043))
+    (i64.store offset=0x044 align=1 (i32.const 0) (local.get 0x044))
+    (i64.store offset=0x045 align=1 (i32.const 0) (local.get 0x045))
+    (i64.store offset=0x046 align=1 (i32.const 0) (local.get 0x046))
+    (i64.store offset=0x047 align=1 (i32.const 0) (local.get 0x047))
+    (i64.store offset=0x048 align=1 (i32.const 0) (local.get 0x048))
+    (i64.store offset=0x049 align=1 (i32.const 0) (local.get 0x049))
+    (i64.store offset=0x04a align=1 (i32.const 0) (local.get 0x04a))
+    (i64.store offset=0x04b align=1 (i32.const 0) (local.get 0x04b))
+    (i64.store offset=0x04c align=1 (i32.const 0) (local.get 0x04c))
+    (i64.store offset=0x04d align=1 (i32.const 0) (local.get 0x04d))
+    (i64.store offset=0x04e align=1 (i32.const 0) (local.get 0x04e))
+    (i64.store offset=0x04f align=1 (i32.const 0) (local.get 0x04f))
+    (i64.store offset=0x050 align=1 (i32.const 0) (local.get 0x050))
+    (i64.store offset=0x051 align=1 (i32.const 0) (local.get 0x051))
+    (i64.store offset=0x052 align=1 (i32.const 0) (local.get 0x052))
+    (i64.store offset=0x053 align=1 (i32.const 0) (local.get 0x053))
+    (i64.store offset=0x054 align=1 (i32.const 0) (local.get 0x054))
+    (i64.store offset=0x055 align=1 (i32.const 0) (local.get 0x055))
+    (i64.store offset=0x056 align=1 (i32.const 0) (local.get 0x056))
+    (i64.store offset=0x057 align=1 (i32.const 0) (local.get 0x057))
+    (i64.store offset=0x058 align=1 (i32.const 0) (local.get 0x058))
+    (i64.store offset=0x059 align=1 (i32.const 0) (local.get 0x059))
+    (i64.store offset=0x05a align=1 (i32.const 0) (local.get 0x05a))
+    (i64.store offset=0x05b align=1 (i32.const 0) (local.get 0x05b))
+    (i64.store offset=0x05c align=1 (i32.const 0) (local.get 0x05c))
+    (i64.store offset=0x05d align=1 (i32.const 0) (local.get 0x05d))
+    (i64.store offset=0x05e align=1 (i32.const 0) (local.get 0x05e))
+    (i64.store offset=0x05f align=1 (i32.const 0) (local.get 0x05f))
+    (i64.store offset=0x060 align=1 (i32.const 0) (local.get 0x060))
+    (i64.store offset=0x061 align=1 (i32.const 0) (local.get 0x061))
+    (i64.store offset=0x062 align=1 (i32.const 0) (local.get 0x062))
+    (i64.store offset=0x063 align=1 (i32.const 0) (local.get 0x063))
+    (i64.store offset=0x064 align=1 (i32.const 0) (local.get 0x064))
+    (i64.store offset=0x065 align=1 (i32.const 0) (local.get 0x065))
+    (i64.store offset=0x066 align=1 (i32.const 0) (local.get 0x066))
+    (i64.store offset=0x067 align=1 (i32.const 0) (local.get 0x067))
+    (i64.store offset=0x068 align=1 (i32.const 0) (local.get 0x068))
+    (i64.store offset=0x069 align=1 (i32.const 0) (local.get 0x069))
+    (i64.store offset=0x06a align=1 (i32.const 0) (local.get 0x06a))
+    (i64.store offset=0x06b align=1 (i32.const 0) (local.get 0x06b))
+    (i64.store offset=0x06c align=1 (i32.const 0) (local.get 0x06c))
+    (i64.store offset=0x06d align=1 (i32.const 0) (local.get 0x06d))
+    (i64.store offset=0x06e align=1 (i32.const 0) (local.get 0x06e))
+    (i64.store offset=0x06f align=1 (i32.const 0) (local.get 0x06f))
+    (i64.store offset=0x070 align=1 (i32.const 0) (local.get 0x070))
+    (i64.store offset=0x071 align=1 (i32.const 0) (local.get 0x071))
+    (i64.store offset=0x072 align=1 (i32.const 0) (local.get 0x072))
+    (i64.store offset=0x073 align=1 (i32.const 0) (local.get 0x073))
+    (i64.store offset=0x074 align=1 (i32.const 0) (local.get 0x074))
+    (i64.store offset=0x075 align=1 (i32.const 0) (local.get 0x075))
+    (i64.store offset=0x076 align=1 (i32.const 0) (local.get 0x076))
+    (i64.store offset=0x077 align=1 (i32.const 0) (local.get 0x077))
+    (i64.store offset=0x078 align=1 (i32.const 0) (local.get 0x078))
+    (i64.store offset=0x079 align=1 (i32.const 0) (local.get 0x079))
+    (i64.store offset=0x07a align=1 (i32.const 0) (local.get 0x07a))
+    (i64.store offset=0x07b align=1 (i32.const 0) (local.get 0x07b))
+    (i64.store offset=0x07c align=1 (i32.const 0) (local.get 0x07c))
+    (i64.store offset=0x07d align=1 (i32.const 0) (local.get 0x07d))
+    (i64.store offset=0x07e align=1 (i32.const 0) (local.get 0x07e))
+    (i64.store offset=0x07f align=1 (i32.const 0) (local.get 0x07f))
+    (i64.store offset=0x080 align=1 (i32.const 0) (local.get 0x080))
+    (i64.store offset=0x081 align=1 (i32.const 0) (local.get 0x081))
+    (i64.store offset=0x082 align=1 (i32.const 0) (local.get 0x082))
+    (i64.store offset=0x083 align=1 (i32.const 0) (local.get 0x083))
+    (i64.store offset=0x084 align=1 (i32.const 0) (local.get 0x084))
+    (i64.store offset=0x085 align=1 (i32.const 0) (local.get 0x085))
+    (i64.store offset=0x086 align=1 (i32.const 0) (local.get 0x086))
+    (i64.store offset=0x087 align=1 (i32.const 0) (local.get 0x087))
+    (i64.store offset=0x088 align=1 (i32.const 0) (local.get 0x088))
+    (i64.store offset=0x089 align=1 (i32.const 0) (local.get 0x089))
+    (i64.store offset=0x08a align=1 (i32.const 0) (local.get 0x08a))
+    (i64.store offset=0x08b align=1 (i32.const 0) (local.get 0x08b))
+    (i64.store offset=0x08c align=1 (i32.const 0) (local.get 0x08c))
+    (i64.store offset=0x08d align=1 (i32.const 0) (local.get 0x08d))
+    (i64.store offset=0x08e align=1 (i32.const 0) (local.get 0x08e))
+    (i64.store offset=0x08f align=1 (i32.const 0) (local.get 0x08f))
+    (i64.store offset=0x090 align=1 (i32.const 0) (local.get 0x090))
+    (i64.store offset=0x091 align=1 (i32.const 0) (local.get 0x091))
+    (i64.store offset=0x092 align=1 (i32.const 0) (local.get 0x092))
+    (i64.store offset=0x093 align=1 (i32.const 0) (local.get 0x093))
+    (i64.store offset=0x094 align=1 (i32.const 0) (local.get 0x094))
+    (i64.store offset=0x095 align=1 (i32.const 0) (local.get 0x095))
+    (i64.store offset=0x096 align=1 (i32.const 0) (local.get 0x096))
+    (i64.store offset=0x097 align=1 (i32.const 0) (local.get 0x097))
+    (i64.store offset=0x098 align=1 (i32.const 0) (local.get 0x098))
+    (i64.store offset=0x099 align=1 (i32.const 0) (local.get 0x099))
+    (i64.store offset=0x09a align=1 (i32.const 0) (local.get 0x09a))
+    (i64.store offset=0x09b align=1 (i32.const 0) (local.get 0x09b))
+    (i64.store offset=0x09c align=1 (i32.const 0) (local.get 0x09c))
+    (i64.store offset=0x09d align=1 (i32.const 0) (local.get 0x09d))
+    (i64.store offset=0x09e align=1 (i32.const 0) (local.get 0x09e))
+    (i64.store offset=0x09f align=1 (i32.const 0) (local.get 0x09f))
+    (i64.store offset=0x0a0 align=1 (i32.const 0) (local.get 0x0a0))
+    (i64.store offset=0x0a1 align=1 (i32.const 0) (local.get 0x0a1))
+    (i64.store offset=0x0a2 align=1 (i32.const 0) (local.get 0x0a2))
+    (i64.store offset=0x0a3 align=1 (i32.const 0) (local.get 0x0a3))
+    (i64.store offset=0x0a4 align=1 (i32.const 0) (local.get 0x0a4))
+    (i64.store offset=0x0a5 align=1 (i32.const 0) (local.get 0x0a5))
+    (i64.store offset=0x0a6 align=1 (i32.const 0) (local.get 0x0a6))
+    (i64.store offset=0x0a7 align=1 (i32.const 0) (local.get 0x0a7))
+    (i64.store offset=0x0a8 align=1 (i32.const 0) (local.get 0x0a8))
+    (i64.store offset=0x0a9 align=1 (i32.const 0) (local.get 0x0a9))
+    (i64.store offset=0x0aa align=1 (i32.const 0) (local.get 0x0aa))
+    (i64.store offset=0x0ab align=1 (i32.const 0) (local.get 0x0ab))
+    (i64.store offset=0x0ac align=1 (i32.const 0) (local.get 0x0ac))
+    (i64.store offset=0x0ad align=1 (i32.const 0) (local.get 0x0ad))
+    (i64.store offset=0x0ae align=1 (i32.const 0) (local.get 0x0ae))
+    (i64.store offset=0x0af align=1 (i32.const 0) (local.get 0x0af))
+    (i64.store offset=0x0b0 align=1 (i32.const 0) (local.get 0x0b0))
+    (i64.store offset=0x0b1 align=1 (i32.const 0) (local.get 0x0b1))
+    (i64.store offset=0x0b2 align=1 (i32.const 0) (local.get 0x0b2))
+    (i64.store offset=0x0b3 align=1 (i32.const 0) (local.get 0x0b3))
+    (i64.store offset=0x0b4 align=1 (i32.const 0) (local.get 0x0b4))
+    (i64.store offset=0x0b5 align=1 (i32.const 0) (local.get 0x0b5))
+    (i64.store offset=0x0b6 align=1 (i32.const 0) (local.get 0x0b6))
+    (i64.store offset=0x0b7 align=1 (i32.const 0) (local.get 0x0b7))
+    (i64.store offset=0x0b8 align=1 (i32.const 0) (local.get 0x0b8))
+    (i64.store offset=0x0b9 align=1 (i32.const 0) (local.get 0x0b9))
+    (i64.store offset=0x0ba align=1 (i32.const 0) (local.get 0x0ba))
+    (i64.store offset=0x0bb align=1 (i32.const 0) (local.get 0x0bb))
+    (i64.store offset=0x0bc align=1 (i32.const 0) (local.get 0x0bc))
+    (i64.store offset=0x0bd align=1 (i32.const 0) (local.get 0x0bd))
+    (i64.store offset=0x0be align=1 (i32.const 0) (local.get 0x0be))
+    (i64.store offset=0x0bf align=1 (i32.const 0) (local.get 0x0bf))
+    (i64.store offset=0x0c0 align=1 (i32.const 0) (local.get 0x0c0))
+    (i64.store offset=0x0c1 align=1 (i32.const 0) (local.get 0x0c1))
+    (i64.store offset=0x0c2 align=1 (i32.const 0) (local.get 0x0c2))
+    (i64.store offset=0x0c3 align=1 (i32.const 0) (local.get 0x0c3))
+    (i64.store offset=0x0c4 align=1 (i32.const 0) (local.get 0x0c4))
+    (i64.store offset=0x0c5 align=1 (i32.const 0) (local.get 0x0c5))
+    (i64.store offset=0x0c6 align=1 (i32.const 0) (local.get 0x0c6))
+    (i64.store offset=0x0c7 align=1 (i32.const 0) (local.get 0x0c7))
+    (i64.store offset=0x0c8 align=1 (i32.const 0) (local.get 0x0c8))
+    (i64.store offset=0x0c9 align=1 (i32.const 0) (local.get 0x0c9))
+    (i64.store offset=0x0ca align=1 (i32.const 0) (local.get 0x0ca))
+    (i64.store offset=0x0cb align=1 (i32.const 0) (local.get 0x0cb))
+    (i64.store offset=0x0cc align=1 (i32.const 0) (local.get 0x0cc))
+    (i64.store offset=0x0cd align=1 (i32.const 0) (local.get 0x0cd))
+    (i64.store offset=0x0ce align=1 (i32.const 0) (local.get 0x0ce))
+    (i64.store offset=0x0cf align=1 (i32.const 0) (local.get 0x0cf))
+    (i64.store offset=0x0d0 align=1 (i32.const 0) (local.get 0x0d0))
+    (i64.store offset=0x0d1 align=1 (i32.const 0) (local.get 0x0d1))
+    (i64.store offset=0x0d2 align=1 (i32.const 0) (local.get 0x0d2))
+    (i64.store offset=0x0d3 align=1 (i32.const 0) (local.get 0x0d3))
+    (i64.store offset=0x0d4 align=1 (i32.const 0) (local.get 0x0d4))
+    (i64.store offset=0x0d5 align=1 (i32.const 0) (local.get 0x0d5))
+    (i64.store offset=0x0d6 align=1 (i32.const 0) (local.get 0x0d6))
+    (i64.store offset=0x0d7 align=1 (i32.const 0) (local.get 0x0d7))
+    (i64.store offset=0x0d8 align=1 (i32.const 0) (local.get 0x0d8))
+    (i64.store offset=0x0d9 align=1 (i32.const 0) (local.get 0x0d9))
+    (i64.store offset=0x0da align=1 (i32.const 0) (local.get 0x0da))
+    (i64.store offset=0x0db align=1 (i32.const 0) (local.get 0x0db))
+    (i64.store offset=0x0dc align=1 (i32.const 0) (local.get 0x0dc))
+    (i64.store offset=0x0dd align=1 (i32.const 0) (local.get 0x0dd))
+    (i64.store offset=0x0de align=1 (i32.const 0) (local.get 0x0de))
+    (i64.store offset=0x0df align=1 (i32.const 0) (local.get 0x0df))
+    (i64.store offset=0x0e0 align=1 (i32.const 0) (local.get 0x0e0))
+    (i64.store offset=0x0e1 align=1 (i32.const 0) (local.get 0x0e1))
+    (i64.store offset=0x0e2 align=1 (i32.const 0) (local.get 0x0e2))
+    (i64.store offset=0x0e3 align=1 (i32.const 0) (local.get 0x0e3))
+    (i64.store offset=0x0e4 align=1 (i32.const 0) (local.get 0x0e4))
+    (i64.store offset=0x0e5 align=1 (i32.const 0) (local.get 0x0e5))
+    (i64.store offset=0x0e6 align=1 (i32.const 0) (local.get 0x0e6))
+    (i64.store offset=0x0e7 align=1 (i32.const 0) (local.get 0x0e7))
+    (i64.store offset=0x0e8 align=1 (i32.const 0) (local.get 0x0e8))
+    (i64.store offset=0x0e9 align=1 (i32.const 0) (local.get 0x0e9))
+    (i64.store offset=0x0ea align=1 (i32.const 0) (local.get 0x0ea))
+    (i64.store offset=0x0eb align=1 (i32.const 0) (local.get 0x0eb))
+    (i64.store offset=0x0ec align=1 (i32.const 0) (local.get 0x0ec))
+    (i64.store offset=0x0ed align=1 (i32.const 0) (local.get 0x0ed))
+    (i64.store offset=0x0ee align=1 (i32.const 0) (local.get 0x0ee))
+    (i64.store offset=0x0ef align=1 (i32.const 0) (local.get 0x0ef))
+    (i64.store offset=0x0f0 align=1 (i32.const 0) (local.get 0x0f0))
+    (i64.store offset=0x0f1 align=1 (i32.const 0) (local.get 0x0f1))
+    (i64.store offset=0x0f2 align=1 (i32.const 0) (local.get 0x0f2))
+    (i64.store offset=0x0f3 align=1 (i32.const 0) (local.get 0x0f3))
+    (i64.store offset=0x0f4 align=1 (i32.const 0) (local.get 0x0f4))
+    (i64.store offset=0x0f5 align=1 (i32.const 0) (local.get 0x0f5))
+    (i64.store offset=0x0f6 align=1 (i32.const 0) (local.get 0x0f6))
+    (i64.store offset=0x0f7 align=1 (i32.const 0) (local.get 0x0f7))
+    (i64.store offset=0x0f8 align=1 (i32.const 0) (local.get 0x0f8))
+    (i64.store offset=0x0f9 align=1 (i32.const 0) (local.get 0x0f9))
+    (i64.store offset=0x0fa align=1 (i32.const 0) (local.get 0x0fa))
+    (i64.store offset=0x0fb align=1 (i32.const 0) (local.get 0x0fb))
+    (i64.store offset=0x0fc align=1 (i32.const 0) (local.get 0x0fc))
+    (i64.store offset=0x0fd align=1 (i32.const 0) (local.get 0x0fd))
+    (i64.store offset=0x0fe align=1 (i32.const 0) (local.get 0x0fe))
+    (i64.store offset=0x0ff align=1 (i32.const 0) (local.get 0x0ff))
+    (i64.store offset=0x100 align=1 (i32.const 0) (local.get 0x100))
+    (i64.store offset=0x101 align=1 (i32.const 0) (local.get 0x101))
+    (i64.store offset=0x102 align=1 (i32.const 0) (local.get 0x102))
+    (i64.store offset=0x103 align=1 (i32.const 0) (local.get 0x103))
+    (i64.store offset=0x104 align=1 (i32.const 0) (local.get 0x104))
+    (i64.store offset=0x105 align=1 (i32.const 0) (local.get 0x105))
+    (i64.store offset=0x106 align=1 (i32.const 0) (local.get 0x106))
+    (i64.store offset=0x107 align=1 (i32.const 0) (local.get 0x107))
+    (i64.store offset=0x108 align=1 (i32.const 0) (local.get 0x108))
+    (i64.store offset=0x109 align=1 (i32.const 0) (local.get 0x109))
+    (i64.store offset=0x10a align=1 (i32.const 0) (local.get 0x10a))
+    (i64.store offset=0x10b align=1 (i32.const 0) (local.get 0x10b))
+    (i64.store offset=0x10c align=1 (i32.const 0) (local.get 0x10c))
+    (i64.store offset=0x10d align=1 (i32.const 0) (local.get 0x10d))
+    (i64.store offset=0x10e align=1 (i32.const 0) (local.get 0x10e))
+    (i64.store offset=0x10f align=1 (i32.const 0) (local.get 0x10f))
+    (i64.store offset=0x110 align=1 (i32.const 0) (local.get 0x110))
+    (i64.store offset=0x111 align=1 (i32.const 0) (local.get 0x111))
+    (i64.store offset=0x112 align=1 (i32.const 0) (local.get 0x112))
+    (i64.store offset=0x113 align=1 (i32.const 0) (local.get 0x113))
+    (i64.store offset=0x114 align=1 (i32.const 0) (local.get 0x114))
+    (i64.store offset=0x115 align=1 (i32.const 0) (local.get 0x115))
+    (i64.store offset=0x116 align=1 (i32.const 0) (local.get 0x116))
+    (i64.store offset=0x117 align=1 (i32.const 0) (local.get 0x117))
+    (i64.store offset=0x118 align=1 (i32.const 0) (local.get 0x118))
+    (i64.store offset=0x119 align=1 (i32.const 0) (local.get 0x119))
+    (i64.store offset=0x11a align=1 (i32.const 0) (local.get 0x11a))
+    (i64.store offset=0x11b align=1 (i32.const 0) (local.get 0x11b))
+    (i64.store offset=0x11c align=1 (i32.const 0) (local.get 0x11c))
+    (i64.store offset=0x11d align=1 (i32.const 0) (local.get 0x11d))
+    (i64.store offset=0x11e align=1 (i32.const 0) (local.get 0x11e))
+    (i64.store offset=0x11f align=1 (i32.const 0) (local.get 0x11f))
+    (i64.store offset=0x120 align=1 (i32.const 0) (local.get 0x120))
+    (i64.store offset=0x121 align=1 (i32.const 0) (local.get 0x121))
+    (i64.store offset=0x122 align=1 (i32.const 0) (local.get 0x122))
+    (i64.store offset=0x123 align=1 (i32.const 0) (local.get 0x123))
+    (i64.store offset=0x124 align=1 (i32.const 0) (local.get 0x124))
+    (i64.store offset=0x125 align=1 (i32.const 0) (local.get 0x125))
+    (i64.store offset=0x126 align=1 (i32.const 0) (local.get 0x126))
+    (i64.store offset=0x127 align=1 (i32.const 0) (local.get 0x127))
+    (i64.store offset=0x128 align=1 (i32.const 0) (local.get 0x128))
+    (i64.store offset=0x129 align=1 (i32.const 0) (local.get 0x129))
+    (i64.store offset=0x12a align=1 (i32.const 0) (local.get 0x12a))
+    (i64.store offset=0x12b align=1 (i32.const 0) (local.get 0x12b))
+    (i64.store offset=0x12c align=1 (i32.const 0) (local.get 0x12c))
+    (i64.store offset=0x12d align=1 (i32.const 0) (local.get 0x12d))
+    (i64.store offset=0x12e align=1 (i32.const 0) (local.get 0x12e))
+    (i64.store offset=0x12f align=1 (i32.const 0) (local.get 0x12f))
+    (i64.store offset=0x130 align=1 (i32.const 0) (local.get 0x130))
+    (i64.store offset=0x131 align=1 (i32.const 0) (local.get 0x131))
+    (i64.store offset=0x132 align=1 (i32.const 0) (local.get 0x132))
+    (i64.store offset=0x133 align=1 (i32.const 0) (local.get 0x133))
+    (i64.store offset=0x134 align=1 (i32.const 0) (local.get 0x134))
+    (i64.store offset=0x135 align=1 (i32.const 0) (local.get 0x135))
+    (i64.store offset=0x136 align=1 (i32.const 0) (local.get 0x136))
+    (i64.store offset=0x137 align=1 (i32.const 0) (local.get 0x137))
+    (i64.store offset=0x138 align=1 (i32.const 0) (local.get 0x138))
+    (i64.store offset=0x139 align=1 (i32.const 0) (local.get 0x139))
+    (i64.store offset=0x13a align=1 (i32.const 0) (local.get 0x13a))
+    (i64.store offset=0x13b align=1 (i32.const 0) (local.get 0x13b))
+    (i64.store offset=0x13c align=1 (i32.const 0) (local.get 0x13c))
+    (i64.store offset=0x13d align=1 (i32.const 0) (local.get 0x13d))
+    (i64.store offset=0x13e align=1 (i32.const 0) (local.get 0x13e))
+    (i64.store offset=0x13f align=1 (i32.const 0) (local.get 0x13f))
+    (i64.store offset=0x140 align=1 (i32.const 0) (local.get 0x140))
+    (i64.store offset=0x141 align=1 (i32.const 0) (local.get 0x141))
+    (i64.store offset=0x142 align=1 (i32.const 0) (local.get 0x142))
+    (i64.store offset=0x143 align=1 (i32.const 0) (local.get 0x143))
+    (i64.store offset=0x144 align=1 (i32.const 0) (local.get 0x144))
+    (i64.store offset=0x145 align=1 (i32.const 0) (local.get 0x145))
+    (i64.store offset=0x146 align=1 (i32.const 0) (local.get 0x146))
+    (i64.store offset=0x147 align=1 (i32.const 0) (local.get 0x147))
+    (i64.store offset=0x148 align=1 (i32.const 0) (local.get 0x148))
+    (i64.store offset=0x149 align=1 (i32.const 0) (local.get 0x149))
+    (i64.store offset=0x14a align=1 (i32.const 0) (local.get 0x14a))
+    (i64.store offset=0x14b align=1 (i32.const 0) (local.get 0x14b))
+    (i64.store offset=0x14c align=1 (i32.const 0) (local.get 0x14c))
+    (i64.store offset=0x14d align=1 (i32.const 0) (local.get 0x14d))
+    (i64.store offset=0x14e align=1 (i32.const 0) (local.get 0x14e))
+    (i64.store offset=0x14f align=1 (i32.const 0) (local.get 0x14f))
+    (i64.store offset=0x150 align=1 (i32.const 0) (local.get 0x150))
+    (i64.store offset=0x151 align=1 (i32.const 0) (local.get 0x151))
+    (i64.store offset=0x152 align=1 (i32.const 0) (local.get 0x152))
+    (i64.store offset=0x153 align=1 (i32.const 0) (local.get 0x153))
+    (i64.store offset=0x154 align=1 (i32.const 0) (local.get 0x154))
+    (i64.store offset=0x155 align=1 (i32.const 0) (local.get 0x155))
+    (i64.store offset=0x156 align=1 (i32.const 0) (local.get 0x156))
+    (i64.store offset=0x157 align=1 (i32.const 0) (local.get 0x157))
+    (i64.store offset=0x158 align=1 (i32.const 0) (local.get 0x158))
+    (i64.store offset=0x159 align=1 (i32.const 0) (local.get 0x159))
+    (i64.store offset=0x15a align=1 (i32.const 0) (local.get 0x15a))
+    (i64.store offset=0x15b align=1 (i32.const 0) (local.get 0x15b))
+    (i64.store offset=0x15c align=1 (i32.const 0) (local.get 0x15c))
+    (i64.store offset=0x15d align=1 (i32.const 0) (local.get 0x15d))
+    (i64.store offset=0x15e align=1 (i32.const 0) (local.get 0x15e))
+    (i64.store offset=0x15f align=1 (i32.const 0) (local.get 0x15f))
+    (i64.store offset=0x160 align=1 (i32.const 0) (local.get 0x160))
+    (i64.store offset=0x161 align=1 (i32.const 0) (local.get 0x161))
+    (i64.store offset=0x162 align=1 (i32.const 0) (local.get 0x162))
+    (i64.store offset=0x163 align=1 (i32.const 0) (local.get 0x163))
+    (i64.store offset=0x164 align=1 (i32.const 0) (local.get 0x164))
+    (i64.store offset=0x165 align=1 (i32.const 0) (local.get 0x165))
+    (i64.store offset=0x166 align=1 (i32.const 0) (local.get 0x166))
+    (i64.store offset=0x167 align=1 (i32.const 0) (local.get 0x167))
+    (i64.store offset=0x168 align=1 (i32.const 0) (local.get 0x168))
+    (i64.store offset=0x169 align=1 (i32.const 0) (local.get 0x169))
+    (i64.store offset=0x16a align=1 (i32.const 0) (local.get 0x16a))
+    (i64.store offset=0x16b align=1 (i32.const 0) (local.get 0x16b))
+    (i64.store offset=0x16c align=1 (i32.const 0) (local.get 0x16c))
+    (i64.store offset=0x16d align=1 (i32.const 0) (local.get 0x16d))
+    (i64.store offset=0x16e align=1 (i32.const 0) (local.get 0x16e))
+    (i64.store offset=0x16f align=1 (i32.const 0) (local.get 0x16f))
+    (i64.store offset=0x170 align=1 (i32.const 0) (local.get 0x170))
+    (i64.store offset=0x171 align=1 (i32.const 0) (local.get 0x171))
+    (i64.store offset=0x172 align=1 (i32.const 0) (local.get 0x172))
+    (i64.store offset=0x173 align=1 (i32.const 0) (local.get 0x173))
+    (i64.store offset=0x174 align=1 (i32.const 0) (local.get 0x174))
+    (i64.store offset=0x175 align=1 (i32.const 0) (local.get 0x175))
+    (i64.store offset=0x176 align=1 (i32.const 0) (local.get 0x176))
+    (i64.store offset=0x177 align=1 (i32.const 0) (local.get 0x177))
+    (i64.store offset=0x178 align=1 (i32.const 0) (local.get 0x178))
+    (i64.store offset=0x179 align=1 (i32.const 0) (local.get 0x179))
+    (i64.store offset=0x17a align=1 (i32.const 0) (local.get 0x17a))
+    (i64.store offset=0x17b align=1 (i32.const 0) (local.get 0x17b))
+    (i64.store offset=0x17c align=1 (i32.const 0) (local.get 0x17c))
+    (i64.store offset=0x17d align=1 (i32.const 0) (local.get 0x17d))
+    (i64.store offset=0x17e align=1 (i32.const 0) (local.get 0x17e))
+    (i64.store offset=0x17f align=1 (i32.const 0) (local.get 0x17f))
+    (i64.store offset=0x180 align=1 (i32.const 0) (local.get 0x180))
+    (i64.store offset=0x181 align=1 (i32.const 0) (local.get 0x181))
+    (i64.store offset=0x182 align=1 (i32.const 0) (local.get 0x182))
+    (i64.store offset=0x183 align=1 (i32.const 0) (local.get 0x183))
+    (i64.store offset=0x184 align=1 (i32.const 0) (local.get 0x184))
+    (i64.store offset=0x185 align=1 (i32.const 0) (local.get 0x185))
+    (i64.store offset=0x186 align=1 (i32.const 0) (local.get 0x186))
+    (i64.store offset=0x187 align=1 (i32.const 0) (local.get 0x187))
+    (i64.store offset=0x188 align=1 (i32.const 0) (local.get 0x188))
+    (i64.store offset=0x189 align=1 (i32.const 0) (local.get 0x189))
+    (i64.store offset=0x18a align=1 (i32.const 0) (local.get 0x18a))
+    (i64.store offset=0x18b align=1 (i32.const 0) (local.get 0x18b))
+    (i64.store offset=0x18c align=1 (i32.const 0) (local.get 0x18c))
+    (i64.store offset=0x18d align=1 (i32.const 0) (local.get 0x18d))
+    (i64.store offset=0x18e align=1 (i32.const 0) (local.get 0x18e))
+    (i64.store offset=0x18f align=1 (i32.const 0) (local.get 0x18f))
+    (i64.store offset=0x190 align=1 (i32.const 0) (local.get 0x190))
+    (i64.store offset=0x191 align=1 (i32.const 0) (local.get 0x191))
+    (i64.store offset=0x192 align=1 (i32.const 0) (local.get 0x192))
+    (i64.store offset=0x193 align=1 (i32.const 0) (local.get 0x193))
+    (i64.store offset=0x194 align=1 (i32.const 0) (local.get 0x194))
+    (i64.store offset=0x195 align=1 (i32.const 0) (local.get 0x195))
+    (i64.store offset=0x196 align=1 (i32.const 0) (local.get 0x196))
+    (i64.store offset=0x197 align=1 (i32.const 0) (local.get 0x197))
+    (i64.store offset=0x198 align=1 (i32.const 0) (local.get 0x198))
+    (i64.store offset=0x199 align=1 (i32.const 0) (local.get 0x199))
+    (i64.store offset=0x19a align=1 (i32.const 0) (local.get 0x19a))
+    (i64.store offset=0x19b align=1 (i32.const 0) (local.get 0x19b))
+    (i64.store offset=0x19c align=1 (i32.const 0) (local.get 0x19c))
+    (i64.store offset=0x19d align=1 (i32.const 0) (local.get 0x19d))
+    (i64.store offset=0x19e align=1 (i32.const 0) (local.get 0x19e))
+    (i64.store offset=0x19f align=1 (i32.const 0) (local.get 0x19f))
+    (i64.store offset=0x1a0 align=1 (i32.const 0) (local.get 0x1a0))
+    (i64.store offset=0x1a1 align=1 (i32.const 0) (local.get 0x1a1))
+    (i64.store offset=0x1a2 align=1 (i32.const 0) (local.get 0x1a2))
+    (i64.store offset=0x1a3 align=1 (i32.const 0) (local.get 0x1a3))
+    (i64.store offset=0x1a4 align=1 (i32.const 0) (local.get 0x1a4))
+    (i64.store offset=0x1a5 align=1 (i32.const 0) (local.get 0x1a5))
+    (i64.store offset=0x1a6 align=1 (i32.const 0) (local.get 0x1a6))
+    (i64.store offset=0x1a7 align=1 (i32.const 0) (local.get 0x1a7))
+    (i64.store offset=0x1a8 align=1 (i32.const 0) (local.get 0x1a8))
+    (i64.store offset=0x1a9 align=1 (i32.const 0) (local.get 0x1a9))
+    (i64.store offset=0x1aa align=1 (i32.const 0) (local.get 0x1aa))
+    (i64.store offset=0x1ab align=1 (i32.const 0) (local.get 0x1ab))
+    (i64.store offset=0x1ac align=1 (i32.const 0) (local.get 0x1ac))
+    (i64.store offset=0x1ad align=1 (i32.const 0) (local.get 0x1ad))
+    (i64.store offset=0x1ae align=1 (i32.const 0) (local.get 0x1ae))
+    (i64.store offset=0x1af align=1 (i32.const 0) (local.get 0x1af))
+    (i64.store offset=0x1b0 align=1 (i32.const 0) (local.get 0x1b0))
+    (i64.store offset=0x1b1 align=1 (i32.const 0) (local.get 0x1b1))
+    (i64.store offset=0x1b2 align=1 (i32.const 0) (local.get 0x1b2))
+    (i64.store offset=0x1b3 align=1 (i32.const 0) (local.get 0x1b3))
+    (i64.store offset=0x1b4 align=1 (i32.const 0) (local.get 0x1b4))
+    (i64.store offset=0x1b5 align=1 (i32.const 0) (local.get 0x1b5))
+    (i64.store offset=0x1b6 align=1 (i32.const 0) (local.get 0x1b6))
+    (i64.store offset=0x1b7 align=1 (i32.const 0) (local.get 0x1b7))
+    (i64.store offset=0x1b8 align=1 (i32.const 0) (local.get 0x1b8))
+    (i64.store offset=0x1b9 align=1 (i32.const 0) (local.get 0x1b9))
+    (i64.store offset=0x1ba align=1 (i32.const 0) (local.get 0x1ba))
+    (i64.store offset=0x1bb align=1 (i32.const 0) (local.get 0x1bb))
+    (i64.store offset=0x1bc align=1 (i32.const 0) (local.get 0x1bc))
+    (i64.store offset=0x1bd align=1 (i32.const 0) (local.get 0x1bd))
+    (i64.store offset=0x1be align=1 (i32.const 0) (local.get 0x1be))
+    (i64.store offset=0x1bf align=1 (i32.const 0) (local.get 0x1bf))
+    (i64.store offset=0x1c0 align=1 (i32.const 0) (local.get 0x1c0))
+    (i64.store offset=0x1c1 align=1 (i32.const 0) (local.get 0x1c1))
+    (i64.store offset=0x1c2 align=1 (i32.const 0) (local.get 0x1c2))
+    (i64.store offset=0x1c3 align=1 (i32.const 0) (local.get 0x1c3))
+    (i64.store offset=0x1c4 align=1 (i32.const 0) (local.get 0x1c4))
+    (i64.store offset=0x1c5 align=1 (i32.const 0) (local.get 0x1c5))
+    (i64.store offset=0x1c6 align=1 (i32.const 0) (local.get 0x1c6))
+    (i64.store offset=0x1c7 align=1 (i32.const 0) (local.get 0x1c7))
+    (i64.store offset=0x1c8 align=1 (i32.const 0) (local.get 0x1c8))
+    (i64.store offset=0x1c9 align=1 (i32.const 0) (local.get 0x1c9))
+    (i64.store offset=0x1ca align=1 (i32.const 0) (local.get 0x1ca))
+    (i64.store offset=0x1cb align=1 (i32.const 0) (local.get 0x1cb))
+    (i64.store offset=0x1cc align=1 (i32.const 0) (local.get 0x1cc))
+    (i64.store offset=0x1cd align=1 (i32.const 0) (local.get 0x1cd))
+    (i64.store offset=0x1ce align=1 (i32.const 0) (local.get 0x1ce))
+    (i64.store offset=0x1cf align=1 (i32.const 0) (local.get 0x1cf))
+    (i64.store offset=0x1d0 align=1 (i32.const 0) (local.get 0x1d0))
+    (i64.store offset=0x1d1 align=1 (i32.const 0) (local.get 0x1d1))
+    (i64.store offset=0x1d2 align=1 (i32.const 0) (local.get 0x1d2))
+    (i64.store offset=0x1d3 align=1 (i32.const 0) (local.get 0x1d3))
+    (i64.store offset=0x1d4 align=1 (i32.const 0) (local.get 0x1d4))
+    (i64.store offset=0x1d5 align=1 (i32.const 0) (local.get 0x1d5))
+    (i64.store offset=0x1d6 align=1 (i32.const 0) (local.get 0x1d6))
+    (i64.store offset=0x1d7 align=1 (i32.const 0) (local.get 0x1d7))
+    (i64.store offset=0x1d8 align=1 (i32.const 0) (local.get 0x1d8))
+    (i64.store offset=0x1d9 align=1 (i32.const 0) (local.get 0x1d9))
+    (i64.store offset=0x1da align=1 (i32.const 0) (local.get 0x1da))
+    (i64.store offset=0x1db align=1 (i32.const 0) (local.get 0x1db))
+    (i64.store offset=0x1dc align=1 (i32.const 0) (local.get 0x1dc))
+    (i64.store offset=0x1dd align=1 (i32.const 0) (local.get 0x1dd))
+    (i64.store offset=0x1de align=1 (i32.const 0) (local.get 0x1de))
+    (i64.store offset=0x1df align=1 (i32.const 0) (local.get 0x1df))
+    (i64.store offset=0x1e0 align=1 (i32.const 0) (local.get 0x1e0))
+    (i64.store offset=0x1e1 align=1 (i32.const 0) (local.get 0x1e1))
+    (i64.store offset=0x1e2 align=1 (i32.const 0) (local.get 0x1e2))
+    (i64.store offset=0x1e3 align=1 (i32.const 0) (local.get 0x1e3))
+    (i64.store offset=0x1e4 align=1 (i32.const 0) (local.get 0x1e4))
+    (i64.store offset=0x1e5 align=1 (i32.const 0) (local.get 0x1e5))
+    (i64.store offset=0x1e6 align=1 (i32.const 0) (local.get 0x1e6))
+    (i64.store offset=0x1e7 align=1 (i32.const 0) (local.get 0x1e7))
+    (i64.store offset=0x1e8 align=1 (i32.const 0) (local.get 0x1e8))
+    (i64.store offset=0x1e9 align=1 (i32.const 0) (local.get 0x1e9))
+    (i64.store offset=0x1ea align=1 (i32.const 0) (local.get 0x1ea))
+    (i64.store offset=0x1eb align=1 (i32.const 0) (local.get 0x1eb))
+    (i64.store offset=0x1ec align=1 (i32.const 0) (local.get 0x1ec))
+    (i64.store offset=0x1ed align=1 (i32.const 0) (local.get 0x1ed))
+    (i64.store offset=0x1ee align=1 (i32.const 0) (local.get 0x1ee))
+    (i64.store offset=0x1ef align=1 (i32.const 0) (local.get 0x1ef))
+    (i64.store offset=0x1f0 align=1 (i32.const 0) (local.get 0x1f0))
+    (i64.store offset=0x1f1 align=1 (i32.const 0) (local.get 0x1f1))
+    (i64.store offset=0x1f2 align=1 (i32.const 0) (local.get 0x1f2))
+    (i64.store offset=0x1f3 align=1 (i32.const 0) (local.get 0x1f3))
+    (i64.store offset=0x1f4 align=1 (i32.const 0) (local.get 0x1f4))
+    (i64.store offset=0x1f5 align=1 (i32.const 0) (local.get 0x1f5))
+    (i64.store offset=0x1f6 align=1 (i32.const 0) (local.get 0x1f6))
+    (i64.store offset=0x1f7 align=1 (i32.const 0) (local.get 0x1f7))
+    (i64.store offset=0x1f8 align=1 (i32.const 0) (local.get 0x1f8))
+    (i64.store offset=0x1f9 align=1 (i32.const 0) (local.get 0x1f9))
+    (i64.store offset=0x1fa align=1 (i32.const 0) (local.get 0x1fa))
+    (i64.store offset=0x1fb align=1 (i32.const 0) (local.get 0x1fb))
+    (i64.store offset=0x1fc align=1 (i32.const 0) (local.get 0x1fc))
+    (i64.store offset=0x1fd align=1 (i32.const 0) (local.get 0x1fd))
+    (i64.store offset=0x1fe align=1 (i32.const 0) (local.get 0x1fe))
+    (i64.store offset=0x1ff align=1 (i32.const 0) (local.get 0x1ff))
+    (i64.store offset=0x200 align=1 (i32.const 0) (local.get 0x200))
+    (i64.store offset=0x201 align=1 (i32.const 0) (local.get 0x201))
+    (i64.store offset=0x202 align=1 (i32.const 0) (local.get 0x202))
+    (i64.store offset=0x203 align=1 (i32.const 0) (local.get 0x203))
+    (i64.store offset=0x204 align=1 (i32.const 0) (local.get 0x204))
+    (i64.store offset=0x205 align=1 (i32.const 0) (local.get 0x205))
+    (i64.store offset=0x206 align=1 (i32.const 0) (local.get 0x206))
+    (i64.store offset=0x207 align=1 (i32.const 0) (local.get 0x207))
+    (i64.store offset=0x208 align=1 (i32.const 0) (local.get 0x208))
+    (i64.store offset=0x209 align=1 (i32.const 0) (local.get 0x209))
+    (i64.store offset=0x20a align=1 (i32.const 0) (local.get 0x20a))
+    (i64.store offset=0x20b align=1 (i32.const 0) (local.get 0x20b))
+    (i64.store offset=0x20c align=1 (i32.const 0) (local.get 0x20c))
+    (i64.store offset=0x20d align=1 (i32.const 0) (local.get 0x20d))
+    (i64.store offset=0x20e align=1 (i32.const 0) (local.get 0x20e))
+    (i64.store offset=0x20f align=1 (i32.const 0) (local.get 0x20f))
+    (i64.store offset=0x210 align=1 (i32.const 0) (local.get 0x210))
+    (i64.store offset=0x211 align=1 (i32.const 0) (local.get 0x211))
+    (i64.store offset=0x212 align=1 (i32.const 0) (local.get 0x212))
+    (i64.store offset=0x213 align=1 (i32.const 0) (local.get 0x213))
+    (i64.store offset=0x214 align=1 (i32.const 0) (local.get 0x214))
+    (i64.store offset=0x215 align=1 (i32.const 0) (local.get 0x215))
+    (i64.store offset=0x216 align=1 (i32.const 0) (local.get 0x216))
+    (i64.store offset=0x217 align=1 (i32.const 0) (local.get 0x217))
+    (i64.store offset=0x218 align=1 (i32.const 0) (local.get 0x218))
+    (i64.store offset=0x219 align=1 (i32.const 0) (local.get 0x219))
+    (i64.store offset=0x21a align=1 (i32.const 0) (local.get 0x21a))
+    (i64.store offset=0x21b align=1 (i32.const 0) (local.get 0x21b))
+    (i64.store offset=0x21c align=1 (i32.const 0) (local.get 0x21c))
+    (i64.store offset=0x21d align=1 (i32.const 0) (local.get 0x21d))
+    (i64.store offset=0x21e align=1 (i32.const 0) (local.get 0x21e))
+    (i64.store offset=0x21f align=1 (i32.const 0) (local.get 0x21f))
+    (i64.store offset=0x220 align=1 (i32.const 0) (local.get 0x220))
+    (i64.store offset=0x221 align=1 (i32.const 0) (local.get 0x221))
+    (i64.store offset=0x222 align=1 (i32.const 0) (local.get 0x222))
+    (i64.store offset=0x223 align=1 (i32.const 0) (local.get 0x223))
+    (i64.store offset=0x224 align=1 (i32.const 0) (local.get 0x224))
+    (i64.store offset=0x225 align=1 (i32.const 0) (local.get 0x225))
+    (i64.store offset=0x226 align=1 (i32.const 0) (local.get 0x226))
+    (i64.store offset=0x227 align=1 (i32.const 0) (local.get 0x227))
+    (i64.store offset=0x228 align=1 (i32.const 0) (local.get 0x228))
+    (i64.store offset=0x229 align=1 (i32.const 0) (local.get 0x229))
+    (i64.store offset=0x22a align=1 (i32.const 0) (local.get 0x22a))
+    (i64.store offset=0x22b align=1 (i32.const 0) (local.get 0x22b))
+    (i64.store offset=0x22c align=1 (i32.const 0) (local.get 0x22c))
+    (i64.store offset=0x22d align=1 (i32.const 0) (local.get 0x22d))
+    (i64.store offset=0x22e align=1 (i32.const 0) (local.get 0x22e))
+    (i64.store offset=0x22f align=1 (i32.const 0) (local.get 0x22f))
+    (i64.store offset=0x230 align=1 (i32.const 0) (local.get 0x230))
+    (i64.store offset=0x231 align=1 (i32.const 0) (local.get 0x231))
+    (i64.store offset=0x232 align=1 (i32.const 0) (local.get 0x232))
+    (i64.store offset=0x233 align=1 (i32.const 0) (local.get 0x233))
+    (i64.store offset=0x234 align=1 (i32.const 0) (local.get 0x234))
+    (i64.store offset=0x235 align=1 (i32.const 0) (local.get 0x235))
+    (i64.store offset=0x236 align=1 (i32.const 0) (local.get 0x236))
+    (i64.store offset=0x237 align=1 (i32.const 0) (local.get 0x237))
+    (i64.store offset=0x238 align=1 (i32.const 0) (local.get 0x238))
+    (i64.store offset=0x239 align=1 (i32.const 0) (local.get 0x239))
+    (i64.store offset=0x23a align=1 (i32.const 0) (local.get 0x23a))
+    (i64.store offset=0x23b align=1 (i32.const 0) (local.get 0x23b))
+    (i64.store offset=0x23c align=1 (i32.const 0) (local.get 0x23c))
+    (i64.store offset=0x23d align=1 (i32.const 0) (local.get 0x23d))
+    (i64.store offset=0x23e align=1 (i32.const 0) (local.get 0x23e))
+    (i64.store offset=0x23f align=1 (i32.const 0) (local.get 0x23f))
+    (i64.store offset=0x240 align=1 (i32.const 0) (local.get 0x240))
+    (i64.store offset=0x241 align=1 (i32.const 0) (local.get 0x241))
+    (i64.store offset=0x242 align=1 (i32.const 0) (local.get 0x242))
+    (i64.store offset=0x243 align=1 (i32.const 0) (local.get 0x243))
+    (i64.store offset=0x244 align=1 (i32.const 0) (local.get 0x244))
+    (i64.store offset=0x245 align=1 (i32.const 0) (local.get 0x245))
+    (i64.store offset=0x246 align=1 (i32.const 0) (local.get 0x246))
+    (i64.store offset=0x247 align=1 (i32.const 0) (local.get 0x247))
+    (i64.store offset=0x248 align=1 (i32.const 0) (local.get 0x248))
+    (i64.store offset=0x249 align=1 (i32.const 0) (local.get 0x249))
+    (i64.store offset=0x24a align=1 (i32.const 0) (local.get 0x24a))
+    (i64.store offset=0x24b align=1 (i32.const 0) (local.get 0x24b))
+    (i64.store offset=0x24c align=1 (i32.const 0) (local.get 0x24c))
+    (i64.store offset=0x24d align=1 (i32.const 0) (local.get 0x24d))
+    (i64.store offset=0x24e align=1 (i32.const 0) (local.get 0x24e))
+    (i64.store offset=0x24f align=1 (i32.const 0) (local.get 0x24f))
+    (i64.store offset=0x250 align=1 (i32.const 0) (local.get 0x250))
+    (i64.store offset=0x251 align=1 (i32.const 0) (local.get 0x251))
+    (i64.store offset=0x252 align=1 (i32.const 0) (local.get 0x252))
+    (i64.store offset=0x253 align=1 (i32.const 0) (local.get 0x253))
+    (i64.store offset=0x254 align=1 (i32.const 0) (local.get 0x254))
+    (i64.store offset=0x255 align=1 (i32.const 0) (local.get 0x255))
+    (i64.store offset=0x256 align=1 (i32.const 0) (local.get 0x256))
+    (i64.store offset=0x257 align=1 (i32.const 0) (local.get 0x257))
+    (i64.store offset=0x258 align=1 (i32.const 0) (local.get 0x258))
+    (i64.store offset=0x259 align=1 (i32.const 0) (local.get 0x259))
+    (i64.store offset=0x25a align=1 (i32.const 0) (local.get 0x25a))
+    (i64.store offset=0x25b align=1 (i32.const 0) (local.get 0x25b))
+    (i64.store offset=0x25c align=1 (i32.const 0) (local.get 0x25c))
+    (i64.store offset=0x25d align=1 (i32.const 0) (local.get 0x25d))
+    (i64.store offset=0x25e align=1 (i32.const 0) (local.get 0x25e))
+    (i64.store offset=0x25f align=1 (i32.const 0) (local.get 0x25f))
+    (i64.store offset=0x260 align=1 (i32.const 0) (local.get 0x260))
+    (i64.store offset=0x261 align=1 (i32.const 0) (local.get 0x261))
+    (i64.store offset=0x262 align=1 (i32.const 0) (local.get 0x262))
+    (i64.store offset=0x263 align=1 (i32.const 0) (local.get 0x263))
+    (i64.store offset=0x264 align=1 (i32.const 0) (local.get 0x264))
+    (i64.store offset=0x265 align=1 (i32.const 0) (local.get 0x265))
+    (i64.store offset=0x266 align=1 (i32.const 0) (local.get 0x266))
+    (i64.store offset=0x267 align=1 (i32.const 0) (local.get 0x267))
+    (i64.store offset=0x268 align=1 (i32.const 0) (local.get 0x268))
+    (i64.store offset=0x269 align=1 (i32.const 0) (local.get 0x269))
+    (i64.store offset=0x26a align=1 (i32.const 0) (local.get 0x26a))
+    (i64.store offset=0x26b align=1 (i32.const 0) (local.get 0x26b))
+    (i64.store offset=0x26c align=1 (i32.const 0) (local.get 0x26c))
+    (i64.store offset=0x26d align=1 (i32.const 0) (local.get 0x26d))
+    (i64.store offset=0x26e align=1 (i32.const 0) (local.get 0x26e))
+    (i64.store offset=0x26f align=1 (i32.const 0) (local.get 0x26f))
+    (i64.store offset=0x270 align=1 (i32.const 0) (local.get 0x270))
+    (i64.store offset=0x271 align=1 (i32.const 0) (local.get 0x271))
+    (i64.store offset=0x272 align=1 (i32.const 0) (local.get 0x272))
+    (i64.store offset=0x273 align=1 (i32.const 0) (local.get 0x273))
+    (i64.store offset=0x274 align=1 (i32.const 0) (local.get 0x274))
+    (i64.store offset=0x275 align=1 (i32.const 0) (local.get 0x275))
+    (i64.store offset=0x276 align=1 (i32.const 0) (local.get 0x276))
+    (i64.store offset=0x277 align=1 (i32.const 0) (local.get 0x277))
+    (i64.store offset=0x278 align=1 (i32.const 0) (local.get 0x278))
+    (i64.store offset=0x279 align=1 (i32.const 0) (local.get 0x279))
+    (i64.store offset=0x27a align=1 (i32.const 0) (local.get 0x27a))
+    (i64.store offset=0x27b align=1 (i32.const 0) (local.get 0x27b))
+    (i64.store offset=0x27c align=1 (i32.const 0) (local.get 0x27c))
+    (i64.store offset=0x27d align=1 (i32.const 0) (local.get 0x27d))
+    (i64.store offset=0x27e align=1 (i32.const 0) (local.get 0x27e))
+    (i64.store offset=0x27f align=1 (i32.const 0) (local.get 0x27f))
+    (i64.store offset=0x280 align=1 (i32.const 0) (local.get 0x280))
+    (i64.store offset=0x281 align=1 (i32.const 0) (local.get 0x281))
+    (i64.store offset=0x282 align=1 (i32.const 0) (local.get 0x282))
+    (i64.store offset=0x283 align=1 (i32.const 0) (local.get 0x283))
+    (i64.store offset=0x284 align=1 (i32.const 0) (local.get 0x284))
+    (i64.store offset=0x285 align=1 (i32.const 0) (local.get 0x285))
+    (i64.store offset=0x286 align=1 (i32.const 0) (local.get 0x286))
+    (i64.store offset=0x287 align=1 (i32.const 0) (local.get 0x287))
+    (i64.store offset=0x288 align=1 (i32.const 0) (local.get 0x288))
+    (i64.store offset=0x289 align=1 (i32.const 0) (local.get 0x289))
+    (i64.store offset=0x28a align=1 (i32.const 0) (local.get 0x28a))
+    (i64.store offset=0x28b align=1 (i32.const 0) (local.get 0x28b))
+    (i64.store offset=0x28c align=1 (i32.const 0) (local.get 0x28c))
+    (i64.store offset=0x28d align=1 (i32.const 0) (local.get 0x28d))
+    (i64.store offset=0x28e align=1 (i32.const 0) (local.get 0x28e))
+    (i64.store offset=0x28f align=1 (i32.const 0) (local.get 0x28f))
+    (i64.store offset=0x290 align=1 (i32.const 0) (local.get 0x290))
+    (i64.store offset=0x291 align=1 (i32.const 0) (local.get 0x291))
+    (i64.store offset=0x292 align=1 (i32.const 0) (local.get 0x292))
+    (i64.store offset=0x293 align=1 (i32.const 0) (local.get 0x293))
+    (i64.store offset=0x294 align=1 (i32.const 0) (local.get 0x294))
+    (i64.store offset=0x295 align=1 (i32.const 0) (local.get 0x295))
+    (i64.store offset=0x296 align=1 (i32.const 0) (local.get 0x296))
+    (i64.store offset=0x297 align=1 (i32.const 0) (local.get 0x297))
+    (i64.store offset=0x298 align=1 (i32.const 0) (local.get 0x298))
+    (i64.store offset=0x299 align=1 (i32.const 0) (local.get 0x299))
+    (i64.store offset=0x29a align=1 (i32.const 0) (local.get 0x29a))
+    (i64.store offset=0x29b align=1 (i32.const 0) (local.get 0x29b))
+    (i64.store offset=0x29c align=1 (i32.const 0) (local.get 0x29c))
+    (i64.store offset=0x29d align=1 (i32.const 0) (local.get 0x29d))
+    (i64.store offset=0x29e align=1 (i32.const 0) (local.get 0x29e))
+    (i64.store offset=0x29f align=1 (i32.const 0) (local.get 0x29f))
+    (i64.store offset=0x2a0 align=1 (i32.const 0) (local.get 0x2a0))
+    (i64.store offset=0x2a1 align=1 (i32.const 0) (local.get 0x2a1))
+    (i64.store offset=0x2a2 align=1 (i32.const 0) (local.get 0x2a2))
+    (i64.store offset=0x2a3 align=1 (i32.const 0) (local.get 0x2a3))
+    (i64.store offset=0x2a4 align=1 (i32.const 0) (local.get 0x2a4))
+    (i64.store offset=0x2a5 align=1 (i32.const 0) (local.get 0x2a5))
+    (i64.store offset=0x2a6 align=1 (i32.const 0) (local.get 0x2a6))
+    (i64.store offset=0x2a7 align=1 (i32.const 0) (local.get 0x2a7))
+    (i64.store offset=0x2a8 align=1 (i32.const 0) (local.get 0x2a8))
+    (i64.store offset=0x2a9 align=1 (i32.const 0) (local.get 0x2a9))
+    (i64.store offset=0x2aa align=1 (i32.const 0) (local.get 0x2aa))
+    (i64.store offset=0x2ab align=1 (i32.const 0) (local.get 0x2ab))
+    (i64.store offset=0x2ac align=1 (i32.const 0) (local.get 0x2ac))
+    (i64.store offset=0x2ad align=1 (i32.const 0) (local.get 0x2ad))
+    (i64.store offset=0x2ae align=1 (i32.const 0) (local.get 0x2ae))
+    (i64.store offset=0x2af align=1 (i32.const 0) (local.get 0x2af))
+    (i64.store offset=0x2b0 align=1 (i32.const 0) (local.get 0x2b0))
+    (i64.store offset=0x2b1 align=1 (i32.const 0) (local.get 0x2b1))
+    (i64.store offset=0x2b2 align=1 (i32.const 0) (local.get 0x2b2))
+    (i64.store offset=0x2b3 align=1 (i32.const 0) (local.get 0x2b3))
+    (i64.store offset=0x2b4 align=1 (i32.const 0) (local.get 0x2b4))
+    (i64.store offset=0x2b5 align=1 (i32.const 0) (local.get 0x2b5))
+    (i64.store offset=0x2b6 align=1 (i32.const 0) (local.get 0x2b6))
+    (i64.store offset=0x2b7 align=1 (i32.const 0) (local.get 0x2b7))
+    (i64.store offset=0x2b8 align=1 (i32.const 0) (local.get 0x2b8))
+    (i64.store offset=0x2b9 align=1 (i32.const 0) (local.get 0x2b9))
+    (i64.store offset=0x2ba align=1 (i32.const 0) (local.get 0x2ba))
+    (i64.store offset=0x2bb align=1 (i32.const 0) (local.get 0x2bb))
+    (i64.store offset=0x2bc align=1 (i32.const 0) (local.get 0x2bc))
+    (i64.store offset=0x2bd align=1 (i32.const 0) (local.get 0x2bd))
+    (i64.store offset=0x2be align=1 (i32.const 0) (local.get 0x2be))
+    (i64.store offset=0x2bf align=1 (i32.const 0) (local.get 0x2bf))
+    (i64.store offset=0x2c0 align=1 (i32.const 0) (local.get 0x2c0))
+    (i64.store offset=0x2c1 align=1 (i32.const 0) (local.get 0x2c1))
+    (i64.store offset=0x2c2 align=1 (i32.const 0) (local.get 0x2c2))
+    (i64.store offset=0x2c3 align=1 (i32.const 0) (local.get 0x2c3))
+    (i64.store offset=0x2c4 align=1 (i32.const 0) (local.get 0x2c4))
+    (i64.store offset=0x2c5 align=1 (i32.const 0) (local.get 0x2c5))
+    (i64.store offset=0x2c6 align=1 (i32.const 0) (local.get 0x2c6))
+    (i64.store offset=0x2c7 align=1 (i32.const 0) (local.get 0x2c7))
+    (i64.store offset=0x2c8 align=1 (i32.const 0) (local.get 0x2c8))
+    (i64.store offset=0x2c9 align=1 (i32.const 0) (local.get 0x2c9))
+    (i64.store offset=0x2ca align=1 (i32.const 0) (local.get 0x2ca))
+    (i64.store offset=0x2cb align=1 (i32.const 0) (local.get 0x2cb))
+    (i64.store offset=0x2cc align=1 (i32.const 0) (local.get 0x2cc))
+    (i64.store offset=0x2cd align=1 (i32.const 0) (local.get 0x2cd))
+    (i64.store offset=0x2ce align=1 (i32.const 0) (local.get 0x2ce))
+    (i64.store offset=0x2cf align=1 (i32.const 0) (local.get 0x2cf))
+    (i64.store offset=0x2d0 align=1 (i32.const 0) (local.get 0x2d0))
+    (i64.store offset=0x2d1 align=1 (i32.const 0) (local.get 0x2d1))
+    (i64.store offset=0x2d2 align=1 (i32.const 0) (local.get 0x2d2))
+    (i64.store offset=0x2d3 align=1 (i32.const 0) (local.get 0x2d3))
+    (i64.store offset=0x2d4 align=1 (i32.const 0) (local.get 0x2d4))
+    (i64.store offset=0x2d5 align=1 (i32.const 0) (local.get 0x2d5))
+    (i64.store offset=0x2d6 align=1 (i32.const 0) (local.get 0x2d6))
+    (i64.store offset=0x2d7 align=1 (i32.const 0) (local.get 0x2d7))
+    (i64.store offset=0x2d8 align=1 (i32.const 0) (local.get 0x2d8))
+    (i64.store offset=0x2d9 align=1 (i32.const 0) (local.get 0x2d9))
+    (i64.store offset=0x2da align=1 (i32.const 0) (local.get 0x2da))
+    (i64.store offset=0x2db align=1 (i32.const 0) (local.get 0x2db))
+    (i64.store offset=0x2dc align=1 (i32.const 0) (local.get 0x2dc))
+    (i64.store offset=0x2dd align=1 (i32.const 0) (local.get 0x2dd))
+    (i64.store offset=0x2de align=1 (i32.const 0) (local.get 0x2de))
+    (i64.store offset=0x2df align=1 (i32.const 0) (local.get 0x2df))
+    (i64.store offset=0x2e0 align=1 (i32.const 0) (local.get 0x2e0))
+    (i64.store offset=0x2e1 align=1 (i32.const 0) (local.get 0x2e1))
+    (i64.store offset=0x2e2 align=1 (i32.const 0) (local.get 0x2e2))
+    (i64.store offset=0x2e3 align=1 (i32.const 0) (local.get 0x2e3))
+    (i64.store offset=0x2e4 align=1 (i32.const 0) (local.get 0x2e4))
+    (i64.store offset=0x2e5 align=1 (i32.const 0) (local.get 0x2e5))
+    (i64.store offset=0x2e6 align=1 (i32.const 0) (local.get 0x2e6))
+    (i64.store offset=0x2e7 align=1 (i32.const 0) (local.get 0x2e7))
+    (i64.store offset=0x2e8 align=1 (i32.const 0) (local.get 0x2e8))
+    (i64.store offset=0x2e9 align=1 (i32.const 0) (local.get 0x2e9))
+    (i64.store offset=0x2ea align=1 (i32.const 0) (local.get 0x2ea))
+    (i64.store offset=0x2eb align=1 (i32.const 0) (local.get 0x2eb))
+    (i64.store offset=0x2ec align=1 (i32.const 0) (local.get 0x2ec))
+    (i64.store offset=0x2ed align=1 (i32.const 0) (local.get 0x2ed))
+    (i64.store offset=0x2ee align=1 (i32.const 0) (local.get 0x2ee))
+    (i64.store offset=0x2ef align=1 (i32.const 0) (local.get 0x2ef))
+    (i64.store offset=0x2f0 align=1 (i32.const 0) (local.get 0x2f0))
+    (i64.store offset=0x2f1 align=1 (i32.const 0) (local.get 0x2f1))
+    (i64.store offset=0x2f2 align=1 (i32.const 0) (local.get 0x2f2))
+    (i64.store offset=0x2f3 align=1 (i32.const 0) (local.get 0x2f3))
+    (i64.store offset=0x2f4 align=1 (i32.const 0) (local.get 0x2f4))
+    (i64.store offset=0x2f5 align=1 (i32.const 0) (local.get 0x2f5))
+    (i64.store offset=0x2f6 align=1 (i32.const 0) (local.get 0x2f6))
+    (i64.store offset=0x2f7 align=1 (i32.const 0) (local.get 0x2f7))
+    (i64.store offset=0x2f8 align=1 (i32.const 0) (local.get 0x2f8))
+    (i64.store offset=0x2f9 align=1 (i32.const 0) (local.get 0x2f9))
+    (i64.store offset=0x2fa align=1 (i32.const 0) (local.get 0x2fa))
+    (i64.store offset=0x2fb align=1 (i32.const 0) (local.get 0x2fb))
+    (i64.store offset=0x2fc align=1 (i32.const 0) (local.get 0x2fc))
+    (i64.store offset=0x2fd align=1 (i32.const 0) (local.get 0x2fd))
+    (i64.store offset=0x2fe align=1 (i32.const 0) (local.get 0x2fe))
+    (i64.store offset=0x2ff align=1 (i32.const 0) (local.get 0x2ff))
+    (i64.store offset=0x300 align=1 (i32.const 0) (local.get 0x300))
+    (i64.store offset=0x301 align=1 (i32.const 0) (local.get 0x301))
+    (i64.store offset=0x302 align=1 (i32.const 0) (local.get 0x302))
+    (i64.store offset=0x303 align=1 (i32.const 0) (local.get 0x303))
+    (i64.store offset=0x304 align=1 (i32.const 0) (local.get 0x304))
+    (i64.store offset=0x305 align=1 (i32.const 0) (local.get 0x305))
+    (i64.store offset=0x306 align=1 (i32.const 0) (local.get 0x306))
+    (i64.store offset=0x307 align=1 (i32.const 0) (local.get 0x307))
+    (i64.store offset=0x308 align=1 (i32.const 0) (local.get 0x308))
+    (i64.store offset=0x309 align=1 (i32.const 0) (local.get 0x309))
+    (i64.store offset=0x30a align=1 (i32.const 0) (local.get 0x30a))
+    (i64.store offset=0x30b align=1 (i32.const 0) (local.get 0x30b))
+    (i64.store offset=0x30c align=1 (i32.const 0) (local.get 0x30c))
+    (i64.store offset=0x30d align=1 (i32.const 0) (local.get 0x30d))
+    (i64.store offset=0x30e align=1 (i32.const 0) (local.get 0x30e))
+    (i64.store offset=0x30f align=1 (i32.const 0) (local.get 0x30f))
+    (i64.store offset=0x310 align=1 (i32.const 0) (local.get 0x310))
+    (i64.store offset=0x311 align=1 (i32.const 0) (local.get 0x311))
+    (i64.store offset=0x312 align=1 (i32.const 0) (local.get 0x312))
+    (i64.store offset=0x313 align=1 (i32.const 0) (local.get 0x313))
+    (i64.store offset=0x314 align=1 (i32.const 0) (local.get 0x314))
+    (i64.store offset=0x315 align=1 (i32.const 0) (local.get 0x315))
+    (i64.store offset=0x316 align=1 (i32.const 0) (local.get 0x316))
+    (i64.store offset=0x317 align=1 (i32.const 0) (local.get 0x317))
+    (i64.store offset=0x318 align=1 (i32.const 0) (local.get 0x318))
+    (i64.store offset=0x319 align=1 (i32.const 0) (local.get 0x319))
+    (i64.store offset=0x31a align=1 (i32.const 0) (local.get 0x31a))
+    (i64.store offset=0x31b align=1 (i32.const 0) (local.get 0x31b))
+    (i64.store offset=0x31c align=1 (i32.const 0) (local.get 0x31c))
+    (i64.store offset=0x31d align=1 (i32.const 0) (local.get 0x31d))
+    (i64.store offset=0x31e align=1 (i32.const 0) (local.get 0x31e))
+    (i64.store offset=0x31f align=1 (i32.const 0) (local.get 0x31f))
+    (i64.store offset=0x320 align=1 (i32.const 0) (local.get 0x320))
+    (i64.store offset=0x321 align=1 (i32.const 0) (local.get 0x321))
+    (i64.store offset=0x322 align=1 (i32.const 0) (local.get 0x322))
+    (i64.store offset=0x323 align=1 (i32.const 0) (local.get 0x323))
+    (i64.store offset=0x324 align=1 (i32.const 0) (local.get 0x324))
+    (i64.store offset=0x325 align=1 (i32.const 0) (local.get 0x325))
+    (i64.store offset=0x326 align=1 (i32.const 0) (local.get 0x326))
+    (i64.store offset=0x327 align=1 (i32.const 0) (local.get 0x327))
+    (i64.store offset=0x328 align=1 (i32.const 0) (local.get 0x328))
+    (i64.store offset=0x329 align=1 (i32.const 0) (local.get 0x329))
+    (i64.store offset=0x32a align=1 (i32.const 0) (local.get 0x32a))
+    (i64.store offset=0x32b align=1 (i32.const 0) (local.get 0x32b))
+    (i64.store offset=0x32c align=1 (i32.const 0) (local.get 0x32c))
+    (i64.store offset=0x32d align=1 (i32.const 0) (local.get 0x32d))
+    (i64.store offset=0x32e align=1 (i32.const 0) (local.get 0x32e))
+    (i64.store offset=0x32f align=1 (i32.const 0) (local.get 0x32f))
+    (i64.store offset=0x330 align=1 (i32.const 0) (local.get 0x330))
+    (i64.store offset=0x331 align=1 (i32.const 0) (local.get 0x331))
+    (i64.store offset=0x332 align=1 (i32.const 0) (local.get 0x332))
+    (i64.store offset=0x333 align=1 (i32.const 0) (local.get 0x333))
+    (i64.store offset=0x334 align=1 (i32.const 0) (local.get 0x334))
+    (i64.store offset=0x335 align=1 (i32.const 0) (local.get 0x335))
+    (i64.store offset=0x336 align=1 (i32.const 0) (local.get 0x336))
+    (i64.store offset=0x337 align=1 (i32.const 0) (local.get 0x337))
+    (i64.store offset=0x338 align=1 (i32.const 0) (local.get 0x338))
+    (i64.store offset=0x339 align=1 (i32.const 0) (local.get 0x339))
+    (i64.store offset=0x33a align=1 (i32.const 0) (local.get 0x33a))
+    (i64.store offset=0x33b align=1 (i32.const 0) (local.get 0x33b))
+    (i64.store offset=0x33c align=1 (i32.const 0) (local.get 0x33c))
+    (i64.store offset=0x33d align=1 (i32.const 0) (local.get 0x33d))
+    (i64.store offset=0x33e align=1 (i32.const 0) (local.get 0x33e))
+    (i64.store offset=0x33f align=1 (i32.const 0) (local.get 0x33f))
+    (i64.store offset=0x340 align=1 (i32.const 0) (local.get 0x340))
+    (i64.store offset=0x341 align=1 (i32.const 0) (local.get 0x341))
+    (i64.store offset=0x342 align=1 (i32.const 0) (local.get 0x342))
+    (i64.store offset=0x343 align=1 (i32.const 0) (local.get 0x343))
+    (i64.store offset=0x344 align=1 (i32.const 0) (local.get 0x344))
+    (i64.store offset=0x345 align=1 (i32.const 0) (local.get 0x345))
+    (i64.store offset=0x346 align=1 (i32.const 0) (local.get 0x346))
+    (i64.store offset=0x347 align=1 (i32.const 0) (local.get 0x347))
+    (i64.store offset=0x348 align=1 (i32.const 0) (local.get 0x348))
+    (i64.store offset=0x349 align=1 (i32.const 0) (local.get 0x349))
+    (i64.store offset=0x34a align=1 (i32.const 0) (local.get 0x34a))
+    (i64.store offset=0x34b align=1 (i32.const 0) (local.get 0x34b))
+    (i64.store offset=0x34c align=1 (i32.const 0) (local.get 0x34c))
+    (i64.store offset=0x34d align=1 (i32.const 0) (local.get 0x34d))
+    (i64.store offset=0x34e align=1 (i32.const 0) (local.get 0x34e))
+    (i64.store offset=0x34f align=1 (i32.const 0) (local.get 0x34f))
+    (i64.store offset=0x350 align=1 (i32.const 0) (local.get 0x350))
+    (i64.store offset=0x351 align=1 (i32.const 0) (local.get 0x351))
+    (i64.store offset=0x352 align=1 (i32.const 0) (local.get 0x352))
+    (i64.store offset=0x353 align=1 (i32.const 0) (local.get 0x353))
+    (i64.store offset=0x354 align=1 (i32.const 0) (local.get 0x354))
+    (i64.store offset=0x355 align=1 (i32.const 0) (local.get 0x355))
+    (i64.store offset=0x356 align=1 (i32.const 0) (local.get 0x356))
+    (i64.store offset=0x357 align=1 (i32.const 0) (local.get 0x357))
+    (i64.store offset=0x358 align=1 (i32.const 0) (local.get 0x358))
+    (i64.store offset=0x359 align=1 (i32.const 0) (local.get 0x359))
+    (i64.store offset=0x35a align=1 (i32.const 0) (local.get 0x35a))
+    (i64.store offset=0x35b align=1 (i32.const 0) (local.get 0x35b))
+    (i64.store offset=0x35c align=1 (i32.const 0) (local.get 0x35c))
+    (i64.store offset=0x35d align=1 (i32.const 0) (local.get 0x35d))
+    (i64.store offset=0x35e align=1 (i32.const 0) (local.get 0x35e))
+    (i64.store offset=0x35f align=1 (i32.const 0) (local.get 0x35f))
+    (i64.store offset=0x360 align=1 (i32.const 0) (local.get 0x360))
+    (i64.store offset=0x361 align=1 (i32.const 0) (local.get 0x361))
+    (i64.store offset=0x362 align=1 (i32.const 0) (local.get 0x362))
+    (i64.store offset=0x363 align=1 (i32.const 0) (local.get 0x363))
+    (i64.store offset=0x364 align=1 (i32.const 0) (local.get 0x364))
+    (i64.store offset=0x365 align=1 (i32.const 0) (local.get 0x365))
+    (i64.store offset=0x366 align=1 (i32.const 0) (local.get 0x366))
+    (i64.store offset=0x367 align=1 (i32.const 0) (local.get 0x367))
+    (i64.store offset=0x368 align=1 (i32.const 0) (local.get 0x368))
+    (i64.store offset=0x369 align=1 (i32.const 0) (local.get 0x369))
+    (i64.store offset=0x36a align=1 (i32.const 0) (local.get 0x36a))
+    (i64.store offset=0x36b align=1 (i32.const 0) (local.get 0x36b))
+    (i64.store offset=0x36c align=1 (i32.const 0) (local.get 0x36c))
+    (i64.store offset=0x36d align=1 (i32.const 0) (local.get 0x36d))
+    (i64.store offset=0x36e align=1 (i32.const 0) (local.get 0x36e))
+    (i64.store offset=0x36f align=1 (i32.const 0) (local.get 0x36f))
+    (i64.store offset=0x370 align=1 (i32.const 0) (local.get 0x370))
+    (i64.store offset=0x371 align=1 (i32.const 0) (local.get 0x371))
+    (i64.store offset=0x372 align=1 (i32.const 0) (local.get 0x372))
+    (i64.store offset=0x373 align=1 (i32.const 0) (local.get 0x373))
+    (i64.store offset=0x374 align=1 (i32.const 0) (local.get 0x374))
+    (i64.store offset=0x375 align=1 (i32.const 0) (local.get 0x375))
+    (i64.store offset=0x376 align=1 (i32.const 0) (local.get 0x376))
+    (i64.store offset=0x377 align=1 (i32.const 0) (local.get 0x377))
+    (i64.store offset=0x378 align=1 (i32.const 0) (local.get 0x378))
+    (i64.store offset=0x379 align=1 (i32.const 0) (local.get 0x379))
+    (i64.store offset=0x37a align=1 (i32.const 0) (local.get 0x37a))
+    (i64.store offset=0x37b align=1 (i32.const 0) (local.get 0x37b))
+    (i64.store offset=0x37c align=1 (i32.const 0) (local.get 0x37c))
+    (i64.store offset=0x37d align=1 (i32.const 0) (local.get 0x37d))
+    (i64.store offset=0x37e align=1 (i32.const 0) (local.get 0x37e))
+    (i64.store offset=0x37f align=1 (i32.const 0) (local.get 0x37f))
+    (i64.store offset=0x380 align=1 (i32.const 0) (local.get 0x380))
+    (i64.store offset=0x381 align=1 (i32.const 0) (local.get 0x381))
+    (i64.store offset=0x382 align=1 (i32.const 0) (local.get 0x382))
+    (i64.store offset=0x383 align=1 (i32.const 0) (local.get 0x383))
+    (i64.store offset=0x384 align=1 (i32.const 0) (local.get 0x384))
+    (i64.store offset=0x385 align=1 (i32.const 0) (local.get 0x385))
+    (i64.store offset=0x386 align=1 (i32.const 0) (local.get 0x386))
+    (i64.store offset=0x387 align=1 (i32.const 0) (local.get 0x387))
+    (i64.store offset=0x388 align=1 (i32.const 0) (local.get 0x388))
+    (i64.store offset=0x389 align=1 (i32.const 0) (local.get 0x389))
+    (i64.store offset=0x38a align=1 (i32.const 0) (local.get 0x38a))
+    (i64.store offset=0x38b align=1 (i32.const 0) (local.get 0x38b))
+    (i64.store offset=0x38c align=1 (i32.const 0) (local.get 0x38c))
+    (i64.store offset=0x38d align=1 (i32.const 0) (local.get 0x38d))
+    (i64.store offset=0x38e align=1 (i32.const 0) (local.get 0x38e))
+    (i64.store offset=0x38f align=1 (i32.const 0) (local.get 0x38f))
+    (i64.store offset=0x390 align=1 (i32.const 0) (local.get 0x390))
+    (i64.store offset=0x391 align=1 (i32.const 0) (local.get 0x391))
+    (i64.store offset=0x392 align=1 (i32.const 0) (local.get 0x392))
+    (i64.store offset=0x393 align=1 (i32.const 0) (local.get 0x393))
+    (i64.store offset=0x394 align=1 (i32.const 0) (local.get 0x394))
+    (i64.store offset=0x395 align=1 (i32.const 0) (local.get 0x395))
+    (i64.store offset=0x396 align=1 (i32.const 0) (local.get 0x396))
+    (i64.store offset=0x397 align=1 (i32.const 0) (local.get 0x397))
+    (i64.store offset=0x398 align=1 (i32.const 0) (local.get 0x398))
+    (i64.store offset=0x399 align=1 (i32.const 0) (local.get 0x399))
+    (i64.store offset=0x39a align=1 (i32.const 0) (local.get 0x39a))
+    (i64.store offset=0x39b align=1 (i32.const 0) (local.get 0x39b))
+    (i64.store offset=0x39c align=1 (i32.const 0) (local.get 0x39c))
+    (i64.store offset=0x39d align=1 (i32.const 0) (local.get 0x39d))
+    (i64.store offset=0x39e align=1 (i32.const 0) (local.get 0x39e))
+    (i64.store offset=0x39f align=1 (i32.const 0) (local.get 0x39f))
+    (i64.store offset=0x3a0 align=1 (i32.const 0) (local.get 0x3a0))
+    (i64.store offset=0x3a1 align=1 (i32.const 0) (local.get 0x3a1))
+    (i64.store offset=0x3a2 align=1 (i32.const 0) (local.get 0x3a2))
+    (i64.store offset=0x3a3 align=1 (i32.const 0) (local.get 0x3a3))
+    (i64.store offset=0x3a4 align=1 (i32.const 0) (local.get 0x3a4))
+    (i64.store offset=0x3a5 align=1 (i32.const 0) (local.get 0x3a5))
+    (i64.store offset=0x3a6 align=1 (i32.const 0) (local.get 0x3a6))
+    (i64.store offset=0x3a7 align=1 (i32.const 0) (local.get 0x3a7))
+    (i64.store offset=0x3a8 align=1 (i32.const 0) (local.get 0x3a8))
+    (i64.store offset=0x3a9 align=1 (i32.const 0) (local.get 0x3a9))
+    (i64.store offset=0x3aa align=1 (i32.const 0) (local.get 0x3aa))
+    (i64.store offset=0x3ab align=1 (i32.const 0) (local.get 0x3ab))
+    (i64.store offset=0x3ac align=1 (i32.const 0) (local.get 0x3ac))
+    (i64.store offset=0x3ad align=1 (i32.const 0) (local.get 0x3ad))
+    (i64.store offset=0x3ae align=1 (i32.const 0) (local.get 0x3ae))
+    (i64.store offset=0x3af align=1 (i32.const 0) (local.get 0x3af))
+    (i64.store offset=0x3b0 align=1 (i32.const 0) (local.get 0x3b0))
+    (i64.store offset=0x3b1 align=1 (i32.const 0) (local.get 0x3b1))
+    (i64.store offset=0x3b2 align=1 (i32.const 0) (local.get 0x3b2))
+    (i64.store offset=0x3b3 align=1 (i32.const 0) (local.get 0x3b3))
+    (i64.store offset=0x3b4 align=1 (i32.const 0) (local.get 0x3b4))
+    (i64.store offset=0x3b5 align=1 (i32.const 0) (local.get 0x3b5))
+    (i64.store offset=0x3b6 align=1 (i32.const 0) (local.get 0x3b6))
+    (i64.store offset=0x3b7 align=1 (i32.const 0) (local.get 0x3b7))
+    (i64.store offset=0x3b8 align=1 (i32.const 0) (local.get 0x3b8))
+    (i64.store offset=0x3b9 align=1 (i32.const 0) (local.get 0x3b9))
+    (i64.store offset=0x3ba align=1 (i32.const 0) (local.get 0x3ba))
+    (i64.store offset=0x3bb align=1 (i32.const 0) (local.get 0x3bb))
+    (i64.store offset=0x3bc align=1 (i32.const 0) (local.get 0x3bc))
+    (i64.store offset=0x3bd align=1 (i32.const 0) (local.get 0x3bd))
+    (i64.store offset=0x3be align=1 (i32.const 0) (local.get 0x3be))
+    (i64.store offset=0x3bf align=1 (i32.const 0) (local.get 0x3bf))
+    (i64.store offset=0x3c0 align=1 (i32.const 0) (local.get 0x3c0))
+    (i64.store offset=0x3c1 align=1 (i32.const 0) (local.get 0x3c1))
+    (i64.store offset=0x3c2 align=1 (i32.const 0) (local.get 0x3c2))
+    (i64.store offset=0x3c3 align=1 (i32.const 0) (local.get 0x3c3))
+    (i64.store offset=0x3c4 align=1 (i32.const 0) (local.get 0x3c4))
+    (i64.store offset=0x3c5 align=1 (i32.const 0) (local.get 0x3c5))
+    (i64.store offset=0x3c6 align=1 (i32.const 0) (local.get 0x3c6))
+    (i64.store offset=0x3c7 align=1 (i32.const 0) (local.get 0x3c7))
+    (i64.store offset=0x3c8 align=1 (i32.const 0) (local.get 0x3c8))
+    (i64.store offset=0x3c9 align=1 (i32.const 0) (local.get 0x3c9))
+    (i64.store offset=0x3ca align=1 (i32.const 0) (local.get 0x3ca))
+    (i64.store offset=0x3cb align=1 (i32.const 0) (local.get 0x3cb))
+    (i64.store offset=0x3cc align=1 (i32.const 0) (local.get 0x3cc))
+    (i64.store offset=0x3cd align=1 (i32.const 0) (local.get 0x3cd))
+    (i64.store offset=0x3ce align=1 (i32.const 0) (local.get 0x3ce))
+    (i64.store offset=0x3cf align=1 (i32.const 0) (local.get 0x3cf))
+    (i64.store offset=0x3d0 align=1 (i32.const 0) (local.get 0x3d0))
+    (i64.store offset=0x3d1 align=1 (i32.const 0) (local.get 0x3d1))
+    (i64.store offset=0x3d2 align=1 (i32.const 0) (local.get 0x3d2))
+    (i64.store offset=0x3d3 align=1 (i32.const 0) (local.get 0x3d3))
+    (i64.store offset=0x3d4 align=1 (i32.const 0) (local.get 0x3d4))
+    (i64.store offset=0x3d5 align=1 (i32.const 0) (local.get 0x3d5))
+    (i64.store offset=0x3d6 align=1 (i32.const 0) (local.get 0x3d6))
+    (i64.store offset=0x3d7 align=1 (i32.const 0) (local.get 0x3d7))
+    (i64.store offset=0x3d8 align=1 (i32.const 0) (local.get 0x3d8))
+    (i64.store offset=0x3d9 align=1 (i32.const 0) (local.get 0x3d9))
+    (i64.store offset=0x3da align=1 (i32.const 0) (local.get 0x3da))
+    (i64.store offset=0x3db align=1 (i32.const 0) (local.get 0x3db))
+    (i64.store offset=0x3dc align=1 (i32.const 0) (local.get 0x3dc))
+    (i64.store offset=0x3dd align=1 (i32.const 0) (local.get 0x3dd))
+    (i64.store offset=0x3de align=1 (i32.const 0) (local.get 0x3de))
+    (i64.store offset=0x3df align=1 (i32.const 0) (local.get 0x3df))
+    (i64.store offset=0x3e0 align=1 (i32.const 0) (local.get 0x3e0))
+    (i64.store offset=0x3e1 align=1 (i32.const 0) (local.get 0x3e1))
+    (i64.store offset=0x3e2 align=1 (i32.const 0) (local.get 0x3e2))
+    (i64.store offset=0x3e3 align=1 (i32.const 0) (local.get 0x3e3))
+    (i64.store offset=0x3e4 align=1 (i32.const 0) (local.get 0x3e4))
+    (i64.store offset=0x3e5 align=1 (i32.const 0) (local.get 0x3e5))
+    (i64.store offset=0x3e6 align=1 (i32.const 0) (local.get 0x3e6))
+    (i64.store offset=0x3e7 align=1 (i32.const 0) (local.get 0x3e7))
+    (i64.store offset=0x3e8 align=1 (i32.const 0) (local.get 0x3e8))
+    (i64.store offset=0x3e9 align=1 (i32.const 0) (local.get 0x3e9))
+    (i64.store offset=0x3ea align=1 (i32.const 0) (local.get 0x3ea))
+    (i64.store offset=0x3eb align=1 (i32.const 0) (local.get 0x3eb))
+    (i64.store offset=0x3ec align=1 (i32.const 0) (local.get 0x3ec))
+    (i64.store offset=0x3ed align=1 (i32.const 0) (local.get 0x3ed))
+    (i64.store offset=0x3ee align=1 (i32.const 0) (local.get 0x3ee))
+    (i64.store offset=0x3ef align=1 (i32.const 0) (local.get 0x3ef))
+    (i64.store offset=0x3f0 align=1 (i32.const 0) (local.get 0x3f0))
+    (i64.store offset=0x3f1 align=1 (i32.const 0) (local.get 0x3f1))
+    (i64.store offset=0x3f2 align=1 (i32.const 0) (local.get 0x3f2))
+    (i64.store offset=0x3f3 align=1 (i32.const 0) (local.get 0x3f3))
+    (i64.store offset=0x3f4 align=1 (i32.const 0) (local.get 0x3f4))
+    (i64.store offset=0x3f5 align=1 (i32.const 0) (local.get 0x3f5))
+    (i64.store offset=0x3f6 align=1 (i32.const 0) (local.get 0x3f6))
+    (i64.store offset=0x3f7 align=1 (i32.const 0) (local.get 0x3f7))
+    (i64.store offset=0x3f8 align=1 (i32.const 0) (local.get 0x3f8))
+    (i64.store offset=0x3f9 align=1 (i32.const 0) (local.get 0x3f9))
+    (i64.store offset=0x3fa align=1 (i32.const 0) (local.get 0x3fa))
+    (i64.store offset=0x3fb align=1 (i32.const 0) (local.get 0x3fb))
+    (i64.store offset=0x3fc align=1 (i32.const 0) (local.get 0x3fc))
+    (i64.store offset=0x3fd align=1 (i32.const 0) (local.get 0x3fd))
+    (i64.store offset=0x3fe align=1 (i32.const 0) (local.get 0x3fe))
+    (i64.store offset=0x3ff align=1 (i32.const 0) (local.get 0x3ff))
+    (i64.store offset=0x400 align=1 (i32.const 0) (local.get 0x400))
+    (i64.store offset=0x401 align=1 (i32.const 0) (local.get 0x401))
+    (i64.store offset=0x402 align=1 (i32.const 0) (local.get 0x402))
+    (i64.store offset=0x403 align=1 (i32.const 0) (local.get 0x403))
+    (i64.store offset=0x404 align=1 (i32.const 0) (local.get 0x404))
+    (i64.store offset=0x405 align=1 (i32.const 0) (local.get 0x405))
+    (i64.store offset=0x406 align=1 (i32.const 0) (local.get 0x406))
+    (i64.store offset=0x407 align=1 (i32.const 0) (local.get 0x407))
+    (i64.store offset=0x408 align=1 (i32.const 0) (local.get 0x408))
+    (i64.store offset=0x409 align=1 (i32.const 0) (local.get 0x409))
+    (i64.store offset=0x40a align=1 (i32.const 0) (local.get 0x40a))
+    (i64.store offset=0x40b align=1 (i32.const 0) (local.get 0x40b))
+    (i64.store offset=0x40c align=1 (i32.const 0) (local.get 0x40c))
+    (i64.store offset=0x40d align=1 (i32.const 0) (local.get 0x40d))
+    (i64.store offset=0x40e align=1 (i32.const 0) (local.get 0x40e))
+    (i64.store offset=0x40f align=1 (i32.const 0) (local.get 0x40f))
+    (i64.store offset=0x410 align=1 (i32.const 0) (local.get 0x410))
+    (i64.store offset=0x411 align=1 (i32.const 0) (local.get 0x411))
+    (i64.store offset=0x412 align=1 (i32.const 0) (local.get 0x412))
+    (i64.store offset=0x413 align=1 (i32.const 0) (local.get 0x413))
+    (i64.store offset=0x414 align=1 (i32.const 0) (local.get 0x414))
+    (i64.store offset=0x415 align=1 (i32.const 0) (local.get 0x415))
+    (i64.store offset=0x416 align=1 (i32.const 0) (local.get 0x416))
+    (i64.store offset=0x417 align=1 (i32.const 0) (local.get 0x417))
+    (i64.store offset=0x418 align=1 (i32.const 0) (local.get 0x418))
+    (i64.store offset=0x419 align=1 (i32.const 0) (local.get 0x419))
+    (i64.store offset=0x41a align=1 (i32.const 0) (local.get 0x41a))
+    (i64.store offset=0x41b align=1 (i32.const 0) (local.get 0x41b))
+    (i64.store offset=0x41c align=1 (i32.const 0) (local.get 0x41c))
+    (i64.store offset=0x41d align=1 (i32.const 0) (local.get 0x41d))
+    (i64.store offset=0x41e align=1 (i32.const 0) (local.get 0x41e))
+    (i64.store offset=0x41f align=1 (i32.const 0) (local.get 0x41f))
   )
 )
 
@@ -2281,4 +2281,4 @@
 (assert_exhaustion (invoke "test-guard-page-skip" (i32.const 600)) "call stack exhausted")
 (assert_exhaustion (invoke "test-guard-page-skip" (i32.const 700)) "call stack exhausted")
 (assert_exhaustion (invoke "test-guard-page-skip" (i32.const 800)) "call stack exhausted")
-(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 900)) "call stack exhausted")
\ No newline at end of file
+(assert_exhaustion (invoke "test-guard-page-skip" (i32.const 900)) "call stack exhausted")
diff --git a/test/core/stack.wast b/test/core/stack.wast
index 88147fa3d..d0c46955d 100644
--- a/test/core/stack.wast
+++ b/test/core/stack.wast
@@ -2,128 +2,128 @@
   (func (export "fac-expr") (param $n i64) (result i64)
     (local $i i64)
     (local $res i64)
-    (set_local $i (get_local $n))
-    (set_local $res (i64.const 1))
+    (local.set $i (local.get $n))
+    (local.set $res (i64.const 1))
     (block $done
       (loop $loop
         (if
-          (i64.eq (get_local $i) (i64.const 0))
+          (i64.eq (local.get $i) (i64.const 0))
           (then (br $done))
           (else
-            (set_local $res (i64.mul (get_local $i) (get_local $res)))
-            (set_local $i (i64.sub (get_local $i) (i64.const 1)))
+            (local.set $res (i64.mul (local.get $i) (local.get $res)))
+            (local.set $i (i64.sub (local.get $i) (i64.const 1)))
           )
         )
         (br $loop)
       )
     )
-    (get_local $res)
+    (local.get $res)
   )
 
   (func (export "fac-stack") (param $n i64) (result i64)
     (local $i i64)
     (local $res i64)
-    (get_local $n)
-    (set_local $i)
+    (local.get $n)
+    (local.set $i)
     (i64.const 1)
-    (set_local $res)
+    (local.set $res)
     (block $done
       (loop $loop
-        (get_local $i)
+        (local.get $i)
         (i64.const 0)
         (i64.eq)
         (if
           (then (br $done))
           (else
-            (get_local $i)
-            (get_local $res)
+            (local.get $i)
+            (local.get $res)
             (i64.mul)
-            (set_local $res)
-            (get_local $i)
+            (local.set $res)
+            (local.get $i)
             (i64.const 1)
             (i64.sub)
-            (set_local $i)
+            (local.set $i)
           )
         )
         (br $loop)
       )
     )
-    (get_local $res)
+    (local.get $res)
   )
 
   (func (export "fac-stack-raw") (param $n i64) (result i64)
     (local $i i64)
     (local $res i64)
-    get_local $n
-    set_local $i
+    local.get $n
+    local.set $i
     i64.const 1
-    set_local $res
+    local.set $res
     block $done
       loop $loop
-        get_local $i
+        local.get $i
         i64.const 0
         i64.eq
         if $body
           br $done
         else $body
-          get_local $i
-          get_local $res
+          local.get $i
+          local.get $res
           i64.mul
-          set_local $res
-          get_local $i
+          local.set $res
+          local.get $i
           i64.const 1
           i64.sub
-          set_local $i
+          local.set $i
         end $body
         br $loop
       end $loop
     end $done
-    get_local $res
+    local.get $res
   )
 
   (func (export "fac-mixed") (param $n i64) (result i64)
     (local $i i64)
     (local $res i64)
-    (set_local $i (get_local $n))
-    (set_local $res (i64.const 1))
+    (local.set $i (local.get $n))
+    (local.set $res (i64.const 1))
     (block $done
       (loop $loop
-        (i64.eq (get_local $i) (i64.const 0))
+        (i64.eq (local.get $i) (i64.const 0))
         (if
           (then (br $done))
           (else
-            (i64.mul (get_local $i) (get_local $res))
-            (set_local $res)
-            (i64.sub (get_local $i) (i64.const 1))
-            (set_local $i)
+            (i64.mul (local.get $i) (local.get $res))
+            (local.set $res)
+            (i64.sub (local.get $i) (i64.const 1))
+            (local.set $i)
           )
         )
         (br $loop)
       )
     )
-    (get_local $res)
+    (local.get $res)
   )
 
   (func (export "fac-mixed-raw") (param $n i64) (result i64)
     (local $i i64)
     (local $res i64)
-    (set_local $i (get_local $n))
-    (set_local $res (i64.const 1))
+    (local.set $i (local.get $n))
+    (local.set $res (i64.const 1))
     block $done
       loop $loop
-        (i64.eq (get_local $i) (i64.const 0))
+        (i64.eq (local.get $i) (i64.const 0))
         if
           br $done
         else
-          (i64.mul (get_local $i) (get_local $res))
-          set_local $res
-          (i64.sub (get_local $i) (i64.const 1))
-          set_local $i
+          (i64.mul (local.get $i) (local.get $res))
+          local.set $res
+          (i64.sub (local.get $i) (i64.const 1))
+          local.set $i
         end
         br $loop
       end
     end
-    get_local $res
+    local.get $res
   )
 )
 
@@ -136,7 +136,7 @@
 
 (module
   (type $proc (func))
-  (table 1 anyfunc)
+  (table 1 funcref)
 
   (func
     (block i32.const 0 call_indirect)
diff --git a/test/core/store.wast b/test/core/store.wast
index 8c6c06595..4a1dbb618 100644
--- a/test/core/store.wast
+++ b/test/core/store.wast
@@ -57,14 +57,14 @@
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (i32.store32 (get_local 0) (i32.const 0)))"
+    "(func (param i32) (i32.store32 (local.get 0) (i32.const 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (i32.store64 (get_local 0) (i64.const 0)))"
+    "(func (param i32) (i32.store64 (local.get 0) (i64.const 0)))"
   )
   "unknown operator"
 )
@@ -72,7 +72,7 @@
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (i64.store64 (get_local 0) (i64.const 0)))"
+    "(func (param i32) (i64.store64 (local.get 0) (i64.const 0)))"
   )
   "unknown operator"
 )
@@ -80,14 +80,14 @@
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (f32.store32 (get_local 0) (f32.const 0)))"
+    "(func (param i32) (f32.store32 (local.get 0) (f32.const 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (f32.store64 (get_local 0) (f64.const 0)))"
+    "(func (param i32) (f32.store64 (local.get 0) (f64.const 0)))"
   )
   "unknown operator"
 )
@@ -95,14 +95,14 @@
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (f64.store32 (get_local 0) (f32.const 0)))"
+    "(func (param i32) (f64.store32 (local.get 0) (f32.const 0)))"
   )
   "unknown operator"
 )
 (assert_malformed
   (module quote
     "(memory 1)"
-    "(func (param i32) (f64.store64 (get_local 0) (f64.const 0)))"
+    "(func (param i32) (f64.store64 (local.get 0) (f64.const 0)))"
   )
   "unknown operator"
 )
diff --git a/test/core/switch.wast b/test/core/switch.wast
index 829acc024..e9ae24dc1 100644
--- a/test/core/switch.wast
+++ b/test/core/switch.wast
@@ -2,7 +2,7 @@
   ;; Statement switch
   (func (export "stmt") (param $i i32) (result i32)
     (local $j i32)
-    (set_local $j (i32.const 100))
+    (local.set $j (i32.const 100))
     (block $switch
       (block $7
         (block $default
@@ -14,38 +14,38 @@
                     (block $1
                       (block $0
                         (br_table $0 $1 $2 $3 $4 $5 $6 $7 $default
-                          (get_local $i)
+                          (local.get $i)
                         )
                       ) ;; 0
-                      (return (get_local $i))
+                      (return (local.get $i))
                     ) ;; 1
                     (nop)
                     ;; fallthrough
                   ) ;; 2
                   ;; fallthrough
                 ) ;; 3
-                (set_local $j (i32.sub (i32.const 0) (get_local $i)))
+                (local.set $j (i32.sub (i32.const 0) (local.get $i)))
                 (br $switch)
               ) ;; 4
               (br $switch)
             ) ;; 5
-            (set_local $j (i32.const 101))
+            (local.set $j (i32.const 101))
             (br $switch)
           ) ;; 6
-          (set_local $j (i32.const 101))
+          (local.set $j (i32.const 101))
           ;; fallthrough
         ) ;; default
-        (set_local $j (i32.const 102))
+        (local.set $j (i32.const 102))
       ) ;; 7
       ;; fallthrough
     )
-    (return (get_local $j))
+    (return (local.get $j))
   )
 
   ;; Expression switch
   (func (export "expr") (param $i i64) (result i64)
     (local $j i64)
-    (set_local $j (i64.const 100))
+    (local.set $j (i64.const 100))
     (return
       (block $switch (result i64)
         (block $7
@@ -58,26 +58,26 @@
                       (block $1
                         (block $0
                           (br_table $0 $1 $2 $3 $4 $5 $6 $7 $default
-                            (i32.wrap/i64 (get_local $i))
+                            (i32.wrap_i64 (local.get $i))
                           )
                         ) ;; 0
-                        (return (get_local $i))
+                        (return (local.get $i))
                       ) ;; 1
                       (nop)
                       ;; fallthrough
                     ) ;; 2
                     ;; fallthrough
                   ) ;; 3
-                  (br $switch (i64.sub (i64.const 0) (get_local $i)))
+                  (br $switch (i64.sub (i64.const 0) (local.get $i)))
                 ) ;; 6
-                (set_local $j (i64.const 101))
+                (local.set $j (i64.const 101))
                 ;; fallthrough
               ) ;; 4
               ;; fallthrough
             ) ;; 5
             ;; fallthrough
           ) ;; default
-          (br $switch (get_local $j))
+          (br $switch (local.get $j))
         ) ;; 7
         (i64.const -5)
       )
@@ -95,8 +95,8 @@
                 (i32.add (i32.const 1000)
                   (block $default (result i32)
                     (br_table $0 $1 $2 $default
-                      (i32.mul (i32.const 2) (get_local $i))
-                      (i32.and (i32.const 3) (get_local $i))
+                      (i32.mul (i32.const 2) (local.get $i))
+                      (i32.and (i32.const 3) (local.get $i))
                     )
                   )
                 )
diff --git a/test/core/traps.wast b/test/core/traps.wast
index a9401408e..9ce95be9d 100644
--- a/test/core/traps.wast
+++ b/test/core/traps.wast
@@ -4,13 +4,13 @@
 
 (module
   (func (export "no_dce.i32.div_s") (param $x i32) (param $y i32)
-    (drop (i32.div_s (get_local $x) (get_local $y))))
+    (drop (i32.div_s (local.get $x) (local.get $y))))
   (func (export "no_dce.i32.div_u") (param $x i32) (param $y i32)
-    (drop (i32.div_u (get_local $x) (get_local $y))))
+    (drop (i32.div_u (local.get $x) (local.get $y))))
   (func (export "no_dce.i64.div_s") (param $x i64) (param $y i64)
-    (drop (i64.div_s (get_local $x) (get_local $y))))
+    (drop (i64.div_s (local.get $x) (local.get $y))))
   (func (export "no_dce.i64.div_u") (param $x i64) (param $y i64)
-    (drop (i64.div_u (get_local $x) (get_local $y))))
+    (drop (i64.div_u (local.get $x) (local.get $y))))
 )
 
 (assert_trap (invoke "no_dce.i32.div_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
@@ -22,13 +22,13 @@
 
 (module
   (func (export "no_dce.i32.rem_s") (param $x i32) (param $y i32)
-    (drop (i32.rem_s (get_local $x) (get_local $y))))
+    (drop (i32.rem_s (local.get $x) (local.get $y))))
   (func (export "no_dce.i32.rem_u") (param $x i32) (param $y i32)
-    (drop (i32.rem_u (get_local $x) (get_local $y))))
+    (drop (i32.rem_u (local.get $x) (local.get $y))))
   (func (export "no_dce.i64.rem_s") (param $x i64) (param $y i64)
-    (drop (i64.rem_s (get_local $x) (get_local $y))))
+    (drop (i64.rem_s (local.get $x) (local.get $y))))
   (func (export "no_dce.i64.rem_u") (param $x i64) (param $y i64)
-    (drop (i64.rem_u (get_local $x) (get_local $y))))
+    (drop (i64.rem_u (local.get $x) (local.get $y))))
 )
 
 (assert_trap (invoke "no_dce.i32.rem_s" (i32.const 1) (i32.const 0)) "integer divide by zero")
@@ -37,14 +37,14 @@
 (assert_trap (invoke "no_dce.i64.rem_u" (i64.const 1) (i64.const 0)) "integer divide by zero")
 
 (module
-  (func (export "no_dce.i32.trunc_s_f32") (param $x f32) (drop (i32.trunc_s/f32 (get_local $x))))
-  (func (export "no_dce.i32.trunc_u_f32") (param $x f32) (drop (i32.trunc_u/f32 (get_local $x))))
-  (func (export "no_dce.i32.trunc_s_f64") (param $x f64) (drop (i32.trunc_s/f64 (get_local $x))))
-  (func (export "no_dce.i32.trunc_u_f64") (param $x f64) (drop (i32.trunc_u/f64 (get_local $x))))
-  (func (export "no_dce.i64.trunc_s_f32") (param $x f32) (drop (i64.trunc_s/f32 (get_local $x))))
-  (func (export "no_dce.i64.trunc_u_f32") (param $x f32) (drop (i64.trunc_u/f32 (get_local $x))))
-  (func (export "no_dce.i64.trunc_s_f64") (param $x f64) (drop (i64.trunc_s/f64 (get_local $x))))
-  (func (export "no_dce.i64.trunc_u_f64") (param $x f64) (drop (i64.trunc_u/f64 (get_local $x))))
+  (func (export "no_dce.i32.trunc_s_f32") (param $x f32) (drop (i32.trunc_f32_s (local.get $x))))
+  (func (export "no_dce.i32.trunc_u_f32") (param $x f32) (drop (i32.trunc_f32_u (local.get $x))))
+  (func (export "no_dce.i32.trunc_s_f64") (param $x f64) (drop (i32.trunc_f64_s (local.get $x))))
+  (func (export "no_dce.i32.trunc_u_f64") (param $x f64) (drop (i32.trunc_f64_u (local.get $x))))
+  (func (export "no_dce.i64.trunc_s_f32") (param $x f32) (drop (i64.trunc_f32_s (local.get $x))))
+  (func (export "no_dce.i64.trunc_u_f32") (param $x f32) (drop (i64.trunc_f32_u (local.get $x))))
+  (func (export "no_dce.i64.trunc_s_f64") (param $x f64) (drop (i64.trunc_f64_s (local.get $x))))
+  (func (export "no_dce.i64.trunc_u_f64") (param $x f64) (drop (i64.trunc_f64_u (local.get $x))))
 )
 
 (assert_trap (invoke "no_dce.i32.trunc_s_f32" (f32.const nan)) "invalid conversion to integer")
@@ -59,20 +59,20 @@
 (module
     (memory 1)
 
-    (func (export "no_dce.i32.load") (param $i i32) (drop (i32.load (get_local $i))))
-    (func (export "no_dce.i32.load16_s") (param $i i32) (drop (i32.load16_s (get_local $i))))
-    (func (export "no_dce.i32.load16_u") (param $i i32) (drop (i32.load16_u (get_local $i))))
-    (func (export "no_dce.i32.load8_s") (param $i i32) (drop (i32.load8_s (get_local $i))))
-    (func (export "no_dce.i32.load8_u") (param $i i32) (drop (i32.load8_u (get_local $i))))
-    (func (export "no_dce.i64.load") (param $i i32) (drop (i64.load (get_local $i))))
-    (func (export "no_dce.i64.load32_s") (param $i i32) (drop (i64.load32_s (get_local $i))))
-    (func (export "no_dce.i64.load32_u") (param $i i32) (drop (i64.load32_u (get_local $i))))
-    (func (export "no_dce.i64.load16_s") (param $i i32) (drop (i64.load16_s (get_local $i))))
-    (func (export "no_dce.i64.load16_u") (param $i i32) (drop (i64.load16_u (get_local $i))))
-    (func (export "no_dce.i64.load8_s") (param $i i32) (drop (i64.load8_s (get_local $i))))
-    (func (export "no_dce.i64.load8_u") (param $i i32) (drop (i64.load8_u (get_local $i))))
-    (func (export "no_dce.f32.load") (param $i i32) (drop (f32.load (get_local $i))))
-    (func (export "no_dce.f64.load") (param $i i32) (drop (f64.load (get_local $i))))
+    (func (export "no_dce.i32.load") (param $i i32) (drop (i32.load (local.get $i))))
+    (func (export "no_dce.i32.load16_s") (param $i i32) (drop (i32.load16_s (local.get $i))))
+    (func (export "no_dce.i32.load16_u") (param $i i32) (drop (i32.load16_u (local.get $i))))
+    (func (export "no_dce.i32.load8_s") (param $i i32) (drop (i32.load8_s (local.get $i))))
+    (func (export "no_dce.i32.load8_u") (param $i i32) (drop (i32.load8_u (local.get $i))))
+    (func (export "no_dce.i64.load") (param $i i32) (drop (i64.load (local.get $i))))
+    (func (export "no_dce.i64.load32_s") (param $i i32) (drop (i64.load32_s (local.get $i))))
+    (func (export "no_dce.i64.load32_u") (param $i i32) (drop (i64.load32_u (local.get $i))))
+    (func (export "no_dce.i64.load16_s") (param $i i32) (drop (i64.load16_s (local.get $i))))
+    (func (export "no_dce.i64.load16_u") (param $i i32) (drop (i64.load16_u (local.get $i))))
+    (func (export "no_dce.i64.load8_s") (param $i i32) (drop (i64.load8_s (local.get $i))))
+    (func (export "no_dce.i64.load8_u") (param $i i32) (drop (i64.load8_u (local.get $i))))
+    (func (export "no_dce.f32.load") (param $i i32) (drop (f32.load (local.get $i))))
+    (func (export "no_dce.f64.load") (param $i i32) (drop (f64.load (local.get $i))))
 )
 
 (assert_trap (invoke "no_dce.i32.load" (i32.const 65536)) "out of bounds memory access")
diff --git a/test/core/typecheck.wast b/test/core/typecheck.wast
index 0ac0c75e2..eab512587 100644
--- a/test/core/typecheck.wast
+++ b/test/core/typecheck.wast
@@ -232,7 +232,7 @@
   (module
     (type (func (param i32)))
     (func (type 0))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func
       (call_indirect (type 0) (i32.const 0) (f32.const 0))))
   "type mismatch")
@@ -242,15 +242,15 @@
   (module
     (type (func))
     (func (type 0))
-    (table 0 anyfunc)
+    (table 0 funcref)
     (func (call_indirect (type 0) (f32.const 0))))
   "type mismatch")
 
 ;; return
 (assert_invalid (module (func (result i32) (return (f32.const 0)))) "type mismatch")
 
-;; set_local
-(assert_invalid (module (func (local i32) (set_local 0 (f32.const 0)))) "type mismatch")
+;; local.set
+(assert_invalid (module (func (local i32) (local.set 0 (f32.const 0)))) "type mismatch")
 
 ;; load index
 (assert_invalid (module (memory 1) (func (i32.load (f32.const 0)))) "type mismatch")
@@ -395,31 +395,31 @@
 (assert_invalid (module (func (f64.ne (i64.const 0) (f32.const 0)))) "type mismatch")
 
 ;; convert
-(assert_invalid (module (func (i32.wrap/i64 (f32.const 0)))) "type mismatch")
-(assert_invalid (module (func (i32.trunc_s/f32 (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (i32.trunc_u/f32 (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (i32.trunc_s/f64 (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (i32.trunc_u/f64 (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (i32.reinterpret/f32 (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (i64.extend_s/i32 (f32.const 0)))) "type mismatch")
-(assert_invalid (module (func (i64.extend_u/i32 (f32.const 0)))) "type mismatch")
-(assert_invalid (module (func (i64.trunc_s/f32 (i32.const 0)))) "type mismatch")
-(assert_invalid (module (func (i64.trunc_u/f32 (i32.const 0)))) "type mismatch")
-(assert_invalid (module (func (i64.trunc_s/f64 (i32.const 0)))) "type mismatch")
-(assert_invalid (module (func (i64.trunc_u/f64 (i32.const 0)))) "type mismatch")
-(assert_invalid (module (func (i64.reinterpret/f64 (i32.const 0)))) "type mismatch")
-(assert_invalid (module (func (f32.convert_s/i32 (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (f32.convert_u/i32 (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (f32.convert_s/i64 (i32.const 0)))) "type mismatch")
-(assert_invalid (module (func (f32.convert_u/i64 (i32.const 0)))) "type mismatch")
-(assert_invalid (module (func (f32.demote/f64 (i32.const 0)))) "type mismatch")
-(assert_invalid (module (func (f32.reinterpret/i32 (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (f64.convert_s/i32 (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (f64.convert_u/i32 (i64.const 0)))) "type mismatch")
-(assert_invalid (module (func (f64.convert_s/i64 (i32.const 0)))) "type mismatch")
-(assert_invalid (module (func (f64.convert_u/i64 (i32.const 0)))) "type mismatch")
-(assert_invalid (module (func (f64.promote/f32 (i32.const 0)))) "type mismatch")
-(assert_invalid (module (func (f64.reinterpret/i64 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (i32.wrap_i64 (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (i32.trunc_f32_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (i32.trunc_f32_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (i32.trunc_f64_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (i32.trunc_f64_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (i32.reinterpret_f32 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (i64.extend_i32_s (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (i64.extend_i32_u (f32.const 0)))) "type mismatch")
+(assert_invalid (module (func (i64.trunc_f32_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (i64.trunc_f32_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (i64.trunc_f64_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (i64.trunc_f64_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (i64.reinterpret_f64 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (f32.convert_i32_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (f32.convert_i32_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (f32.convert_i64_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (f32.convert_i64_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (f32.demote_f64 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (f32.reinterpret_i32 (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (f64.convert_i32_s (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (f64.convert_i32_u (i64.const 0)))) "type mismatch")
+(assert_invalid (module (func (f64.convert_i64_s (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (f64.convert_i64_u (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (f64.promote_f32 (i32.const 0)))) "type mismatch")
+(assert_invalid (module (func (f64.reinterpret_i64 (i32.const 0)))) "type mismatch")
 
 ;; memory.grow
 (assert_invalid (module (memory 1) (func (memory.grow (f32.const 0)))) "type mismatch")
diff --git a/test/core/unreachable.wast b/test/core/unreachable.wast
index 791dd8338..f28181f51 100644
--- a/test/core/unreachable.wast
+++ b/test/core/unreachable.wast
@@ -102,17 +102,17 @@
     (if (result i32) (unreachable) (then (i32.const 0)) (else (i32.const 1)))
   )
   (func (export "as-if-then") (param i32 i32) (result i32)
-    (if (result i32) (get_local 0) (then (unreachable)) (else (get_local 1)))
+    (if (result i32) (local.get 0) (then (unreachable)) (else (local.get 1)))
   )
   (func (export "as-if-else") (param i32 i32) (result i32)
-    (if (result i32) (get_local 0) (then (get_local 1)) (else (unreachable)))
+    (if (result i32) (local.get 0) (then (local.get 1)) (else (unreachable)))
   )
 
   (func (export "as-select-first") (param i32 i32) (result i32)
-    (select (unreachable) (get_local 0) (get_local 1))
+    (select (unreachable) (local.get 0) (local.get 1))
   )
   (func (export "as-select-second") (param i32 i32) (result i32)
-    (select (get_local 0) (unreachable) (get_local 1))
+    (select (local.get 0) (unreachable) (local.get 1))
   )
   (func (export "as-select-cond") (result i32)
     (select (i32.const 0) (i32.const 1) (unreachable))
@@ -129,7 +129,7 @@
   )
 
   (type $sig (func (param i32 i32 i32)))
-  (table anyfunc (elem $dummy3))
+  (table funcref (elem $dummy3))
   (func (export "as-call_indirect-func")
     (call_indirect (type $sig)
       (unreachable) (i32.const 1) (i32.const 2) (i32.const 3)
@@ -151,15 +151,15 @@
     )
   )
 
-  (func (export "as-set_local-value") (local f32)
-    (set_local 0 (unreachable))
+  (func (export "as-local.set-value") (local f32)
+    (local.set 0 (unreachable))
   )
-  (func (export "as-tee_local-value") (result f32) (local f32)
-    (tee_local 0 (unreachable))
+  (func (export "as-local.tee-value") (result f32) (local f32)
+    (local.tee 0 (unreachable))
   )
   (global $a (mut f32) (f32.const 0))
-  (func (export "as-set_global-value") (result f32)
-    (set_global $a (unreachable))
+  (func (export "as-global.set-value") (result f32)
+    (global.set $a (unreachable))
   )
 
   (memory 1)
@@ -207,7 +207,7 @@
   )
 
   (func (export "as-convert-operand") (result i32)
-    (i32.wrap/i64 (unreachable))
+    (i32.wrap_i64 (unreachable))
   )
 
   (func (export "as-memory.grow-size") (result i32)
@@ -271,9 +271,9 @@
 (assert_trap (invoke "as-call_indirect-mid") "unreachable")
 (assert_trap (invoke "as-call_indirect-last") "unreachable")
 
-(assert_trap (invoke "as-set_local-value") "unreachable")
-(assert_trap (invoke "as-tee_local-value") "unreachable")
-(assert_trap (invoke "as-set_global-value") "unreachable")
+(assert_trap (invoke "as-local.set-value") "unreachable")
+(assert_trap (invoke "as-local.tee-value") "unreachable")
+(assert_trap (invoke "as-global.set-value") "unreachable")
 
 (assert_trap (invoke "as-load-address") "unreachable")
 (assert_trap (invoke "as-loadN-address") "unreachable")
diff --git a/test/core/unreached-invalid.wast b/test/core/unreached-invalid.wast
index 907049fa3..6ef4ac552 100644
--- a/test/core/unreached-invalid.wast
+++ b/test/core/unreached-invalid.wast
@@ -1,11 +1,11 @@
 ;; Failures in unreachable code.
 
 (assert_invalid
-  (module (func $local-index (unreachable) (drop (get_local 0))))
+  (module (func $local-index (unreachable) (drop (local.get 0))))
   "unknown local"
 )
 (assert_invalid
-  (module (func $global-index (unreachable) (drop (get_global 0))))
+  (module (func $global-index (unreachable) (drop (global.get 0))))
   "unknown global"
 )
 (assert_invalid
@@ -682,7 +682,7 @@
 (assert_invalid
   (module (func $tee-local-unreachable-value
     (local i32)
-    (tee_local 0 (unreachable))
+    (local.tee 0 (unreachable))
   ))
   "type mismatch"
 )
@@ -702,7 +702,7 @@
     (func $type-br_if-after-unreachable (result i64)
       unreachable
       br_if 0
-      i64.extend_u/i32
+      i64.extend_i32_u
     )
   )
  "type mismatch"

From 8ead96427c3ba4e4e868681c009e89cd21ebaf29 Mon Sep 17 00:00:00 2001
From: Sven Sauleau <github@sauleau.com>
Date: Thu, 6 Dec 2018 13:13:21 +0100
Subject: [PATCH 322/329] Update index.bs

---
 document/js-api/index.bs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 80f414c91..f7e721852 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -579,7 +579,6 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 
 <div algorithm>
     The <dfn constructor for="Memory">Memory(|descriptor|)</dfn> constructor, when invoked, performs the following steps:
-    1. If |descriptor|["initial"] is [=present=], let |initial| be |descriptor|["initial"]; otherwise, let |initial| be 0.
     1. If |descriptor|["maximum"] is [=present=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
     1. If |maximum| is not empty and |maximum| &lt; |initial|, throw a {{RangeError}} exception.
     1. Let |memtype| be { min |initial|, max |maximum| }
@@ -674,7 +673,6 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 
 <div algorithm>
     The <dfn constructor for="Table">Table(|descriptor|)</dfn> constructor, when invoked, performs the following steps:
-    1. If |descriptor|["initial"] is [=present=], let |initial| be |descriptor|["initial"]; otherwise, let |initial| be 0.
     1. If |descriptor|["maximum"] is [=present=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
     1. If |maximum| is not empty and |maximum| &lt; |initial|, throw a {{RangeError}} exception.
     1. Let |type| be the [=table type=] {[=table type|𝗆𝗂𝗇=] n, [=table type|𝗆𝖺𝗑=] |maximum|} [=table type|𝖺𝗇𝗒𝖿𝗎𝗇𝖼=].

From 8445cd6516a2c98163e0341f4ff3f91e4ee3dbd9 Mon Sep 17 00:00:00 2001
From: Sven Sauleau <github@sauleau.com>
Date: Thu, 6 Dec 2018 13:16:42 +0100
Subject: [PATCH 323/329] Update index.bs

---
 document/js-api/index.bs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index f7e721852..8c33aed9c 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -579,6 +579,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 
 <div algorithm>
     The <dfn constructor for="Memory">Memory(|descriptor|)</dfn> constructor, when invoked, performs the following steps:
+    1. let |initial| be |descriptor|["initial"]
     1. If |descriptor|["maximum"] is [=present=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
     1. If |maximum| is not empty and |maximum| &lt; |initial|, throw a {{RangeError}} exception.
     1. Let |memtype| be { min |initial|, max |maximum| }
@@ -673,6 +674,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 
 <div algorithm>
     The <dfn constructor for="Table">Table(|descriptor|)</dfn> constructor, when invoked, performs the following steps:
+    1. let |initial| be |descriptor|["initial"]
     1. If |descriptor|["maximum"] is [=present=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
     1. If |maximum| is not empty and |maximum| &lt; |initial|, throw a {{RangeError}} exception.
     1. Let |type| be the [=table type=] {[=table type|𝗆𝗂𝗇=] n, [=table type|𝗆𝖺𝗑=] |maximum|} [=table type|𝖺𝗇𝗒𝖿𝗎𝗇𝖼=].

From a1642af2f0c35e88a6a5f915a7df77514be8e880 Mon Sep 17 00:00:00 2001
From: Sven Sauleau <github@sauleau.com>
Date: Thu, 6 Dec 2018 13:17:23 +0100
Subject: [PATCH 324/329] Update index.bs

---
 document/js-api/index.bs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/document/js-api/index.bs b/document/js-api/index.bs
index 8c33aed9c..691920e34 100644
--- a/document/js-api/index.bs
+++ b/document/js-api/index.bs
@@ -579,7 +579,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 
 <div algorithm>
     The <dfn constructor for="Memory">Memory(|descriptor|)</dfn> constructor, when invoked, performs the following steps:
-    1. let |initial| be |descriptor|["initial"]
+    1. let |initial| be |descriptor|["initial"].
     1. If |descriptor|["maximum"] is [=present=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
     1. If |maximum| is not empty and |maximum| &lt; |initial|, throw a {{RangeError}} exception.
     1. Let |memtype| be { min |initial|, max |maximum| }
@@ -674,7 +674,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
 
 <div algorithm>
     The <dfn constructor for="Table">Table(|descriptor|)</dfn> constructor, when invoked, performs the following steps:
-    1. let |initial| be |descriptor|["initial"]
+    1. let |initial| be |descriptor|["initial"].
     1. If |descriptor|["maximum"] is [=present=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
     1. If |maximum| is not empty and |maximum| &lt; |initial|, throw a {{RangeError}} exception.
     1. Let |type| be the [=table type=] {[=table type|𝗆𝗂𝗇=] n, [=table type|𝗆𝖺𝗑=] |maximum|} [=table type|𝖺𝗇𝗒𝖿𝗎𝗇𝖼=].

From 1c469454e43501640700fd15e9f9340882cf30c8 Mon Sep 17 00:00:00 2001
From: Sven Sauleau <github@sauleau.com>
Date: Thu, 6 Dec 2018 18:15:32 +0100
Subject: [PATCH 325/329] tests: remove invalid property (#916)

Was probably copied from `WebAssembly.Table` tests.
---
 test/js-api/memory/constructor.any.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/js-api/memory/constructor.any.js b/test/js-api/memory/constructor.any.js
index a584a23ec..11e309fe6 100644
--- a/test/js-api/memory/constructor.any.js
+++ b/test/js-api/memory/constructor.any.js
@@ -80,7 +80,7 @@ for (const value of outOfRangeValues) {
 }
 
 test(() => {
-  assert_throws(new RangeError(), () => new WebAssembly.Memory({ "element": "anyfunc", "initial": 10, "maximum": 9 }));
+  assert_throws(new RangeError(), () => new WebAssembly.Memory({ "initial": 10, "maximum": 9 }));
 }, "Initial value exceeds maximum");
 
 test(() => {

From 89ae39ccd81b9d624abde0bd55ee1504acb12e54 Mon Sep 17 00:00:00 2001
From: Andreas Rossberg <rossberg@mpi-sws.org>
Date: Thu, 6 Dec 2018 19:13:15 +0100
Subject: [PATCH 326/329] [spec] Add missing UTF-8 side condition (#928)

---
 document/core/binary/values.rst | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/document/core/binary/values.rst b/document/core/binary/values.rst
index dbb0c21e1..772309f29 100644
--- a/document/core/binary/values.rst
+++ b/document/core/binary/values.rst
@@ -88,7 +88,7 @@ As an additional constraint, the total number of bytes encoding a value of type
 Floating-Point
 ~~~~~~~~~~~~~~
 
-:ref:`Floating-point <syntax-float>` values are encoded directly by their |IEEE754|_ bit pattern in |LittleEndian|_ byte order:
+:ref:`Floating-point <syntax-float>` values are encoded directly by their |IEEE754|_ (Section 3.4) bit pattern in |LittleEndian|_ byte order:
 
 .. math::
    \begin{array}{llclll@{\qquad\qquad}l}
@@ -105,7 +105,7 @@ Floating-Point
 Names
 ~~~~~
 
-:ref:`Names <syntax-name>` are encoded as a :ref:`vector <binary-vec>` of bytes containing the |Unicode|_ UTF-8 encoding of the name's code point sequence.
+:ref:`Names <syntax-name>` are encoded as a :ref:`vector <binary-vec>` of bytes containing the |Unicode|_ (Section 3.9) UTF-8 encoding of the name's code point sequence.
 
 .. math::
    \begin{array}{llclllll}
@@ -117,7 +117,8 @@ Names
 The auxiliary |utf8| function expressing this encoding is defined as follows:
 
 .. math::
-   \begin{array}{@{}lcl@{\qquad}l}
+   \begin{array}{@{}l@{}}
+   \begin{array}{@{}lcl@{\qquad}l@{}}
    \utf8(c^\ast) &=& (\utf8(c))^\ast \\[1ex]
    \utf8(c) &=& b &
      (\begin{array}[t]{@{}c@{~}l@{}}
@@ -139,6 +140,8 @@ The auxiliary |utf8| function expressing this encoding is defined as follows:
       \iff & \unicode{10000} \leq c < \unicode{110000} \\
       \wedge & c = 2^{18}(b_1-\hex{F0})+2^{12}(b_2-\hex{80})+2^6(b_3-\hex{80})+(b_4-\hex{80})) \\
       \end{array} \\
+   \end{array} \\
+   \where b_2, b_3, b_4 < \hex{C0} \\
    \end{array}
 
 .. note::

From 4408f60968e540a3eaf7ab01c2d85ec2de890fed Mon Sep 17 00:00:00 2001
From: zxh0 <zhangxiuhong2013@gmail.com>
Date: Sun, 9 Dec 2018 07:13:46 +0800
Subject: [PATCH 327/329] [interpreter] Fix typo: tyoe -> type (#930)

---
 interpreter/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index c493c46fb..2c65f71ae 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -197,7 +197,7 @@ expr:
   ( block <name>? <block_type> <instr>* )
   ( loop <name>? <block_type> <instr>* )
   ( if <name>? <block_type> ( then <instr>* ) ( else <instr>* )? )
-  ( if <name>? <block_tyoe> <expr>+ ( then <instr>* ) ( else <instr>* )? ) ;; = <expr>+ (if <name>? <block_type> (then <instr>*) (else <instr>*)?)
+  ( if <name>? <block_type> <expr>+ ( then <instr>* ) ( else <instr>* )? ) ;; = <expr>+ (if <name>? <block_type> (then <instr>*) (else <instr>*)?)
 
 instr:
   <expr>

From 118dd51f2f7b61bbdc6e75d6a6b98caac060b73e Mon Sep 17 00:00:00 2001
From: zxh0 <zhangxiuhong2013@gmail.com>
Date: Tue, 11 Dec 2018 13:25:04 +0800
Subject: [PATCH 328/329] [interpreter] Add missing ')' (#931)

---
 interpreter/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/interpreter/README.md b/interpreter/README.md
index 2c65f71ae..6c509fc25 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -253,7 +253,7 @@ elem:    ( elem <var>? (offset <instr>* ) <var>* )
 memory:  ( memory <name>? <memory_type> )
          ( memory <name>? ( export <string> ) <...> )                       ;; = (export <string> (memory <N>))+ (memory <name>? <...>)
          ( memory <name>? ( import <string> <string> ) <memory_type> )      ;; = (import <name>? <string> <string> (memory <memory_type>))
-         ( memory <name>? ( export <string> )* ( data <string>* )           ;; = (memory <name>? ( export <string> )* <size> <size>) (data (i32.const 0) <string>*)
+         ( memory <name>? ( export <string> )* ( data <string>* ) )         ;; = (memory <name>? ( export <string> )* <size> <size>) (data (i32.const 0) <string>*)
 data:    ( data <var>? ( offset <instr>* ) <string>* )
          ( data <var>? <expr> <string>* )                                   ;; = (data <var>? (offset <expr>) <string>*)
 

From 6fdf92b8f2dd5d31cb49d5462bfe006e4d74ca23 Mon Sep 17 00:00:00 2001
From: Ms2ger <Ms2ger@igalia.com>
Date: Tue, 11 Dec 2018 15:16:14 +0100
Subject: [PATCH 329/329] Remove tests/html.

The only test there was for IndexedDB integration, which the specification
doesn't allow.

Future tests for the Web API will land directly in web-platform-tests.
---
 test/build.py          |   4 --
 test/html/indexeddb.js | 114 -----------------------------------------
 2 files changed, 118 deletions(-)
 delete mode 100644 test/html/indexeddb.js

diff --git a/test/build.py b/test/build.py
index c8d7e026c..4d3d800e0 100755
--- a/test/build.py
+++ b/test/build.py
@@ -14,7 +14,6 @@
 
 WAST_TESTS_DIR = os.path.join(SCRIPT_DIR, 'core')
 JS_TESTS_DIR = os.path.join(SCRIPT_DIR, 'js-api')
-HTML_TESTS_DIR = os.path.join(SCRIPT_DIR, 'html')
 HARNESS_DIR = os.path.join(SCRIPT_DIR, 'harness')
 
 HARNESS_FILES = ['testharness.js', 'testharnessreport.js', 'testharness.css']
@@ -140,9 +139,6 @@ def build_html_js(out_dir):
     ensure_empty_dir(out_dir)
     build_js(out_dir, True)
 
-    for js_file in glob.glob(os.path.join(HTML_TESTS_DIR, '*.js')):
-        shutil.copy(js_file, out_dir)
-
     for js_file in glob.glob(os.path.join(out_dir, '*.js')):
         wrap_single_test(js_file)
 
diff --git a/test/html/indexeddb.js b/test/html/indexeddb.js
deleted file mode 100644
index e9e827a94..000000000
--- a/test/html/indexeddb.js
+++ /dev/null
@@ -1,114 +0,0 @@
-/*
- * Copyright 2017 WebAssembly Community Group participants
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
-*/
-
-(function testIndexedDB() {
-    const IDB_NAME = "spec-test";
-    const OBJECT_STORE_NAME = "wasm";
-
-    let db = null;
-
-    function openDB() {
-        console.log('Opening db...');
-        return new Promise((resolve, reject) => {
-            request = indexedDB.open(IDB_NAME, 1);
-            request.onerror = reject;
-            request.onsuccess = () => {
-                db = request.result;
-                console.log('Retrieved db:', db);
-                resolve();
-            };
-            request.onupgradeneeded = () => {
-                console.log('Creating object store...');
-                request.result.createObjectStore(OBJECT_STORE_NAME);
-                request.onerror = reject;
-                request.onupgradeneeded = reject;
-                request.onsuccess = () => {
-                    db = request.result;
-                    console.log('Created db:', db);
-                    resolve();
-                };
-            };
-        });
-    }
-
-    function getObjectStore() {
-        return db.transaction([OBJECT_STORE_NAME], "readwrite").objectStore(OBJECT_STORE_NAME);
-    }
-
-    function clearStore() {
-        console.log('Clearing store...');
-        return new Promise((resolve, reject) => {
-            var request = getObjectStore().clear();
-            request.onerror = reject;
-            request.onupgradeneeded = reject;
-            request.onsuccess = resolve;
-        });
-    }
-
-    function makeModule() {
-        return new Promise(resolve => {
-            let builder = new WasmModuleBuilder();
-            builder.addFunction('run', kSig_i_v)
-                .addBody([
-                    kExprI32Const,
-                    42,
-                    kExprReturn
-                ])
-                .exportFunc();
-            let source = builder.toBuffer();
-
-            let module = new WebAssembly.Module(source);
-            let i = new WebAssembly.Instance(module);
-            assert_equals(i.exports.run(), 42);
-
-            resolve(module);
-        });
-    }
-
-    function storeWasm(module) {
-        console.log('Storing wasm object...', module);
-        return new Promise((resolve, reject) => {
-            request = getObjectStore().add(module, 1);
-            request.onsuccess = resolve;
-            request.onerror = reject;
-            request.onupgradeneeded = reject;
-        });
-    }
-
-    function loadWasm() {
-        console.log('Loading wasm object...');
-        return new Promise((resolve, reject) => {
-            var request = getObjectStore().get(1);
-            request.onsuccess = () => {
-                let i = new WebAssembly.Instance(request.result);
-                assert_equals(i.exports.run(), 42);
-                resolve();
-            }
-            request.onerror = reject;
-            request.onupgradeneeded = reject;
-        });
-    }
-
-    function run() {
-        return openDB()
-        .then(() => clearStore())
-        .then(() => makeModule())
-        .then(wasm => storeWasm(wasm))
-        .then(() => loadWasm());
-    }
-
-    promise_test(run, "store and load from indexeddb");
-})();