diff --git a/.github/workflows/ci-spec.yml b/.github/workflows/ci-spec.yml index 33806f448a..04e47b40d5 100644 --- a/.github/workflows/ci-spec.yml +++ b/.github/workflows/ci-spec.yml @@ -30,8 +30,8 @@ jobs: uses: actions/setup-node@v3 with: node-version: 16 - # - name: Setup Bikeshed - # run: pip install bikeshed && bikeshed update + - name: Setup Bikeshed + run: pip install bikeshed && bikeshed update - name: Setup TexLive run: sudo apt-get update -y && sudo apt-get install -y latexmk texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended - name: Setup Sphinx @@ -40,8 +40,8 @@ jobs: run: cd spectec && opam exec make - name: Build main spec run: cd document/core && opam exec make main - # - name: Run Bikeshed - # run: cd document/core && opam exec make bikeshed + - name: Run Bikeshed + # run: cd document/core && opam exec make bikeshed - name: Upload artifact uses: actions/upload-artifact@v2 with: @@ -56,7 +56,7 @@ jobs: - name: Setup Bikeshed run: pip install bikeshed && bikeshed update - name: Run Bikeshed - run: bikeshed spec "document/js-api/index.bs" "document/js-api/index.html" + # run: bikeshed spec "document/js-api/index.bs" "document/js-api/index.html" - name: Upload artifact uses: actions/upload-artifact@v2 with: @@ -71,16 +71,70 @@ jobs: - name: Setup Bikeshed run: pip install bikeshed && bikeshed update - name: Run Bikeshed - run: bikeshed spec "document/web-api/index.bs" "document/web-api/index.html" + # run: bikeshed spec "document/web-api/index.bs" "document/web-api/index.html" - name: Upload artifact uses: actions/upload-artifact@v2 with: name: web-api-rendered path: document/web-api/index.html + build-code-metadata-spec: + runs-on: ubuntu-latest + needs: [build-core-spec] + steps: + - name: Checkout repo + uses: actions/checkout@v2 + with: + submodules: "recursive" + - name: Setup TexLive + run: sudo apt-get update -y && sudo apt-get install -y latexmk texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended + - name: Setup Sphinx + run: pip install six && pip install sphinx==5.1.0 + - name: Build main spec + run: cd document/metadata/code && make main + - name: Upload artifact + uses: actions/upload-artifact@v2 + with: + name: code-metadata-rendered + path: document/metadata/code/_build/html + + build-legacy-exceptions-core-spec: + runs-on: ubuntu-latest + steps: + - name: Checkout repo + uses: actions/checkout@v2 + with: + submodules: "recursive" + - name: Setup TexLive + run: sudo apt-get update -y && sudo apt-get install -y latexmk texlive-latex-recommended texlive-latex-extra texlive-fonts-recommended + - name: Setup Sphinx + run: pip install six && pip install sphinx==5.1.0 + - name: Build main spec + run: cd document/legacy/exceptions/core && make main + - name: Upload artifact + uses: actions/upload-artifact@v2 + with: + name: legacy-exceptions-core-rendered + path: document/legacy/exceptions/core/_build/html + + build-legacy-exceptions-js-api-spec: + runs-on: ubuntu-latest + steps: + - name: Checkout repo + uses: actions/checkout@v2 + - name: Setup Bikeshed + run: pip install bikeshed && bikeshed update + - name: Run Bikeshed + # run: bikeshed spec "document/legacy/exceptions/js-api/index.bs" "document/legacy/exceptions/js-api/index.html" + - name: Upload artifact + uses: actions/upload-artifact@v2 + with: + name: legacy-exceptions-js-api-rendered + path: document/legacy/exceptions/js-api/index.html + publish-spec: runs-on: ubuntu-latest - needs: [build-core-spec, build-js-api-spec, build-web-api-spec] + needs: [build-core-spec, build-js-api-spec, build-web-api-spec, build-code-metadata-spec, build-legacy-exceptions-core-spec, build-legacy-exceptions-js-api-spec] steps: - name: Checkout repo uses: actions/checkout@v2 @@ -101,6 +155,21 @@ jobs: with: name: web-api-rendered path: _output/web-api + - name: Download code metadata spec artifact + uses: actions/download-artifact@v2 + with: + name: code-metadata-rendered + path: _output/metadata/code + - name: Download legacy exceptions core spec artifact + uses: actions/download-artifact@v2 + with: + name: legacy-exceptions-core-rendered + path: _output/legacy/exceptions/core + - name: Download legacy exceptions JS API spec artifact + uses: actions/download-artifact@v2 + with: + name: legacy-exceptions-js-api-rendered + path: _output/legacy/exceptions/js-api - name: Publish to GitHub Pages if: github.ref == 'refs/heads/main' uses: peaceiris/actions-gh-pages@v3 diff --git a/README.md b/README.md index 641932c211..6617033a25 100644 --- a/README.md +++ b/README.md @@ -18,18 +18,11 @@ Original `README` from upstream repository follows... # 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 specification, +a reference implementation, and the official test suite. -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 diff --git a/deploy_key b/deploy_key deleted file mode 100644 index f4e5b00055..0000000000 --- a/deploy_key +++ /dev/null @@ -1,49 +0,0 @@ ------BEGIN OPENSSH PRIVATE KEY----- -b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAACFwAAAAdzc2gtcn -NhAAAAAwEAAQAAAgEAn9FUrQzWcgEOHsDJ+f7L0g7xIYrdBb3K1dQqFWFidZcL8KYMMR0/ -CEYRXfSn3EcvpYnRoIjWfGQgqOpA90FMaAwqdoK72ByW7q2C4ymjX5xR8XFyG5YJVvjaMe -STXZlynQSOH9lXU5RooeEwRatgQizuwB/Bqahry/8FOfDhVlNO26IbEyJPd23qeyAd+42C -OTE5oWHEJ3TKSWSfwTAhfrIlIg+dWiSx/IUcLc+7Ms5EpQh3ebX49oaW00SWRDnyqoM95m -D+Uc3DuTFJyKdHlLouESdNrE9LeBms5N/bHSgedVyZ5fL9SHC6P1HmgDPFspmO6z1s15/a -5y5hf9zHVoj1ha54LSaPlE5/L5hpY6PCH7fepRXhw84VIQV74IsJow1XUbkmfKkjW3PeBq -CF5cTKF2LK65SraxEfNMLU0ThOH6B6yzePq7JF+05VGMh2G2Wkwy11pezeqW5tPU1M2qwS -RN8jAFKIwuC7B73drz8yMhF8MfTW4iGM4RqhQRCK22xmVtzwYFwRKUM++p2iOggGi42jnV -skv7/yQ6XcaEm+2Jx3C2zy/5OdLql9z8gmKsH4jpQUADmae8KBfJCqHZrtvhRTqH99E3th -pIKcpzY+n5uhNCyrY+hTfB44/EIntWkXDTLwVVRmmOyHSvEA7/Dz1vtA7gY9Nu25xY/SXS -sAAAc4dIF4rHSBeKwAAAAHc3NoLXJzYQAAAgEAn9FUrQzWcgEOHsDJ+f7L0g7xIYrdBb3K -1dQqFWFidZcL8KYMMR0/CEYRXfSn3EcvpYnRoIjWfGQgqOpA90FMaAwqdoK72ByW7q2C4y -mjX5xR8XFyG5YJVvjaMeSTXZlynQSOH9lXU5RooeEwRatgQizuwB/Bqahry/8FOfDhVlNO -26IbEyJPd23qeyAd+42COTE5oWHEJ3TKSWSfwTAhfrIlIg+dWiSx/IUcLc+7Ms5EpQh3eb -X49oaW00SWRDnyqoM95mD+Uc3DuTFJyKdHlLouESdNrE9LeBms5N/bHSgedVyZ5fL9SHC6 -P1HmgDPFspmO6z1s15/a5y5hf9zHVoj1ha54LSaPlE5/L5hpY6PCH7fepRXhw84VIQV74I -sJow1XUbkmfKkjW3PeBqCF5cTKF2LK65SraxEfNMLU0ThOH6B6yzePq7JF+05VGMh2G2Wk -wy11pezeqW5tPU1M2qwSRN8jAFKIwuC7B73drz8yMhF8MfTW4iGM4RqhQRCK22xmVtzwYF -wRKUM++p2iOggGi42jnVskv7/yQ6XcaEm+2Jx3C2zy/5OdLql9z8gmKsH4jpQUADmae8KB -fJCqHZrtvhRTqH99E3thpIKcpzY+n5uhNCyrY+hTfB44/EIntWkXDTLwVVRmmOyHSvEA7/ -Dz1vtA7gY9Nu25xY/SXSsAAAADAQABAAACAFMayDxgY5bOw6fsOlscSqKFkJAPpJUat0Hv -3J5XkJpzHAtcXRShD6jevqMr2Knr/nPHMdGXtmjirDUJ8xRfyTqFsQMFQmbDnxyn71ruyP -yrzdSOWHbN0zd9mgC9yn+ujnHl733SR923W51p+u8PibN/p/sRyGPPp5Zhmzcg8hwwn94H -8qpFeisxZe/2qICpeiEBXuVzcEvQKGx3vbb4r0IxoquOkRVR5ZfZI+kSj1aA+iMTPwV0Qe -z32bAshzMdKvnN2z9UCotBQ1imr6Z+jfNhyRi0ZmiGp0jhmQ0+9rK3rPb8Wy6+50RnEgJh -NUpPIauYvD/JJjMN9genD54skR61JnwRSmMUcuYFvcPKip1FYugYtZY/a9waqcSA73TcuZ -DQzihYs4fdr2aD3pH8QchYwo5vZFzPCVuXF387pYUmj8u3RLDhemSYjwuG/NWdVKnYnZ2B -EVOMi4YZ6Kms7rac8zzgFUonxDWLCigOPI0HPfrDKQ7P6NyiAKEEEfK6g2KvnDJaaCdfpb -70UTFG6YyN+1qa0NWVcU6iEGd/ziT7xPDT3WgJd4SAYkllycQkg5zdFz4T1SqABMrWqjK7 -1Xk//kZxboYZFwBoODiNd2dcLU1XOBhNvoAEajKQNyzAhET6eC02olwUwl7ZwdMxMH8C9H -/j4lAq+v6PYzFHN/uZAAABAQCExWknkwPAu+eDulQTW1T5kIhsD3Ffe+9yg1Ps83NPST9w -7dddykxOzZJ4j8WjpsvwCXuxyxPqt3UI3y2t4nC2aIWq5gPoIfDvtt5J8j6i4RwrI2AU3j -tKdPyLD4qKOCvuqThRCUz3GffU8QNknLYT1jGhO8p//nZq68SVIhtcL8CG1/mQQVApgvd+ -VrBIytptBk0wn4ufMY11CjRTLjASJzBsiT/VmUkQVBQDn6/yvCSxx7nYzMt0XcDqH1/KO7 -iqEN6HfkTNTKBXcRWIS+c7OvAixJTGXRCE2xcQindaHQ3HNK+6r1qAXp65XfsTJUw+FIdc -4OXiRdnAAanVy6tAAAABAQDKduhs+s+AKQWsuwkzWdnLQdMP+98vKBkMH7/dBA73xDd+hR -8sHOhoyxYoNoUhvYWcoip2Mqsn/+F5QLvKxaaccQOtfQpYEeB0koL3QEHUIBMwzgEW112T -ATa8KR6okRAUxn7tqswebAFPmdpGS1YkQAyAQQoPr2NQpPSWN0cKXQZUYLn5r6HSZ7isAm -K/6mrF+TqK80055A+duZggLIKyMAKDTdgtIu4D/wZIqZYcY8uiA2ZhGM3XEQutTjo4xemu -V2X+WSwXhrXiSAWqbCBxCRcCLKktweihb1nOkXIOspKr7Adj/ctmlqO875GHuwlrGaNfe2 -DFo67i4udsdrc9AAABAQDKE5rUxfN6K51jWdgiBVx1XVH0YenLGHECYcxg5AHkDTJUOl9F -SqiP4w128fFjHEO+GGltgkruQ94k+wINub/e7k1NYSpgj03BDs6swpRG7Y3uot1aBFAati -ITJF6p1rmjmBxtDhaVX9nA6GyOmzXO4Tb6niBHO5u7B3dqZI/iXHUmsZOsa1ijuE8YL5P7 -SzxbkiGGsWv5gfs8RcYuOmGhTx2LxOTNh3kovj4xQSoJVH3IikpodQAuXTdL5utuAzgVEL -Xpk1XVyVPkFGitmNqTr3D2gKnPnkQf8KYsRmzt4bPKDrKOBleqYbFSabyHUNJEaW7pmf8+ -fNbVF9dWMmyHAAAAAAEC ------END OPENSSH PRIVATE KEY----- diff --git a/deploy_key.pub b/deploy_key.pub deleted file mode 100644 index 313f1bd8e1..0000000000 --- a/deploy_key.pub +++ /dev/null @@ -1 +0,0 @@ -ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAACAQCf0VStDNZyAQ4ewMn5/svSDvEhit0FvcrV1CoVYWJ1lwvwpgwxHT8IRhFd9KfcRy+lidGgiNZ8ZCCo6kD3QUxoDCp2grvYHJburYLjKaNfnFHxcXIblglW+Nox5JNdmXKdBI4f2VdTlGih4TBFq2BCLO7AH8GpqGvL/wU58OFWU07bohsTIk93bep7IB37jYI5MTmhYcQndMpJZJ/BMCF+siUiD51aJLH8hRwtz7syzkSlCHd5tfj2hpbTRJZEOfKqgz3mYP5RzcO5MUnIp0eUui4RJ02sT0t4Gazk39sdKB51XJnl8v1IcLo/UeaAM8WymY7rPWzXn9rnLmF/3MdWiPWFrngtJo+UTn8vmGljo8Ift96lFeHDzhUhBXvgiwmjDVdRuSZ8qSNbc94GoIXlxMoXYsrrlKtrER80wtTROE4foHrLN4+rskX7TlUYyHYbZaTDLXWl7N6pbm09TUzarBJE3yMAUojC4LsHvd2vPzIyEXwx9NbiIYzhGqFBEIrbbGZW3PBgXBEpQz76naI6CAaLjaOdWyS/v/JDpdxoSb7YnHcLbPL/k50uqX3PyCYqwfiOlBQAOZp7woF8kKodmu2+FFOof30Te2GkgpynNj6fm6E0LKtj6FN8Hjj8Qie1aRcNMvBVVGaY7IdK8QDv8PPW+0DuBj027bnFj9JdKw== diff --git a/document/Makefile b/document/Makefile index 01a6d93423..77a79ee70f 100644 --- a/document/Makefile +++ b/document/Makefile @@ -1,4 +1,4 @@ -DIRS = js-api web-api core +DIRS = core js-api web-api metadata/code legacy/exceptions FILES = index.html BUILDDIR = _build TAR = tar diff --git a/document/core/appendix/algorithm.rst b/document/core/appendix/algorithm.rst index 97988bb381..b8dc8d6944 100644 --- a/document/core/appendix/algorithm.rst +++ b/document/core/appendix/algorithm.rst @@ -32,7 +32,7 @@ Value types are representable as sets of enumerations: type vec_type = V128 type heap_type = Any | Eq | I31 | Struct | Array | None | - Func | Nofunc | Extern | Noextern | Bot | + Func | Nofunc | Exn | Noexn | Extern | Noextern | Bot | Def(def : def_type) type ref_type = Ref(heap : heap_type, null : bool) type val_type = num_type | vec_type | ref_type | Bot @@ -445,6 +445,28 @@ Other instructions are checked in a similar manner. pop_val(Ref(Def(types[x]))) pop_val(unpack_field(st.fields[n])) + case (throw x) + pop_vals(tags[x].type.params) + unreachable() + + case (try_table t1*->t2* handler*) + pop_vals([t1*]) + foreach (handler in handler*) + error_if(ctrls.size() < handler.label) + push_ctrl(catch, [], label_types(ctrls[handler.label])) + switch (handler.clause) + case (catch x) + push_vals(tags[x].type.params) + case (catch_ref x) + push_vals(tags[x].type.params) + push_val(Exnref) + case (catch_all) + skip + case (catch_all_ref) + push_val(Exnref) + pop_ctrl() + push_ctrl(try_table, [t1*], [t2*]) + .. note:: It is an invariant under the current WebAssembly instruction set that an operand of :code:`Bot` type is never duplicated on the stack. This would change if the language were extended with stack instructions like :code:`dup`. diff --git a/document/core/appendix/changes.rst b/document/core/appendix/changes.rst index e60e6fd02d..cc8a445635 100644 --- a/document/core/appendix/changes.rst +++ b/document/core/appendix/changes.rst @@ -12,7 +12,7 @@ Release 2.0 .. index:: instruction, integer -Sign extension instructions +Sign Extension Instructions ........................... Added new numeric instructions for performing sign extension within integer representations. [#proposal-signext]_ @@ -22,7 +22,7 @@ Added new numeric instructions for performing sign extension within integer repr .. index:: instruction, trap, floating-point, integer -Non-trapping float-to-int conversions +Non-trapping Float-to-Int Conversions ..................................... Added new conversion instructions that avoid trapping when converting a floating-point number to an integer. [#proposal-cvtsat]_ @@ -32,7 +32,7 @@ Added new conversion instructions that avoid trapping when converting a floating .. index:: block, function, value type, result type -Multiple values +Multiple Values ............... Generalized the result type of blocks and functions to allow for multiple values; in addition, introduced the ability to have block parameters. [#proposal-multivalue]_ @@ -44,7 +44,7 @@ Generalized the result type of blocks and functions to allow for multiple values .. index:: value type, reference, reference type, instruction, element segment -Reference types +Reference Types ............... Added |FUNCREF| and |EXTERNREF| as new value types and respective instructions. [#proposal-reftype]_ @@ -60,7 +60,7 @@ Added |FUNCREF| and |EXTERNREF| as new value types and respective instructions. .. index:: reference, instruction, table, table type -Table instructions +Table Instructions .................. Added instructions to directly access and modify tables. [#proposal-reftype]_ @@ -72,7 +72,7 @@ Added instructions to directly access and modify tables. [#proposal-reftype]_ .. index:: table, instruction, table index, element segment, import, export -Multiple tables +Multiple Tables ............... Added the ability to use multiple tables per module. [#proposal-reftype]_ @@ -86,7 +86,7 @@ Added the ability to use multiple tables per module. [#proposal-reftype]_ .. index:: instruction, table, memory, data segment, element segment -Bulk memory and table instructions +Bulk Memory and Table Instructions .................................. Added instructions that modify ranges of memory or table entries. [#proposal-reftype]_ [#proposal-bulk]_ @@ -106,7 +106,7 @@ Added instructions that modify ranges of memory or table entries. [#proposal-ref .. index:: instructions, SIMD, value type, vector type -Vector instructions +Vector Instructions ................... Added vector type and instructions that manipulate multiple numeric values in parallel (also known as *SIMD*, single instruction multiple data) [#proposal-vectype]_ @@ -160,9 +160,9 @@ Added vector type and instructions that manipulate multiple numeric values in pa Release 3.0 ~~~~~~~~~~~ -.. index: instruction, expression, constant +.. index:: instruction, expression, constant -Extended constant expressions +Extended Constant Expressions ............................. Allowed basic numeric computations in constant expressions. [#proposal-extconst]_ @@ -173,9 +173,9 @@ Allowed basic numeric computations in constant expressions. [#proposal-extconst] The :ref:`garbage collection ` added further constant instructions. -.. index: instruction, function, call +.. index:: instruction, function, call -Tail calls +Tail Calls .......... Added instructions to perform tail calls. [#proposal-tailcall]_ @@ -183,9 +183,27 @@ Added instructions to perform tail calls. [#proposal-tailcall]_ * New :ref:`control instructions `: |RETURNCALL| and |RETURNCALLINDIRECT| -.. index: instruction, memory, memory index, data segment, import, export +.. index:: instruction, exception, reference type, tag type, tag, handler -Multiple memories +Exception Handling +.................. + +Added tag definitions, imports, and exports, and instructions to throw and catch exceptions [#proposal-exn]_ + +* Modules may :ref:`define `, :ref:`import `, and :ref:`export ` tags. + +* New :ref:`heap types `: |EXN|, |NOEXN| + +* New :ref:`reference type ` short-hands: |EXNREF|, |NULLEXNREF| + +* New :ref:`control instructions `: |THROW|, |THROWREF|, and |TRYTABLE|. + +* New :ref:`tag section ` in binary format. + + +.. index:: instruction, memory, memory index, data segment, import, export + +Multiple Memories ................. Added the ability to use multiple memories per module. [#proposal-multimem]_ @@ -199,7 +217,7 @@ Added the ability to use multiple memories per module. [#proposal-multimem]_ .. index:: reference, reference type, heap type, value type, local, local type, instruction, instruction type, table, function, function type, matching, subtyping -Typeful references +Typeful References .................. Added more precise types for references. [#proposal-typedref]_ @@ -224,7 +242,7 @@ Added more precise types for references. [#proposal-typedref]_ .. index:: reference, reference type, heap type, field type, storage type, structure type, array type, composite type, sub type, recursive type .. _extension-gc: -Garbage collection +Garbage Collection .................. Added managed reference types. [#proposal-gc]_ @@ -250,12 +268,32 @@ Added managed reference types. [#proposal-gc]_ * Extended set of :ref:`constant instructions ` with |REFI31|, |STRUCTNEW|, |STRUCTNEWDEFAULT|, |ARRAYNEW|, |ARRAYNEWDEFAULT|, |ARRAYNEWFIXED|, |ANYCONVERTEXTERN|, |EXTERNCONVERTANY| +.. index:: text format, annotation, custom section, identifier, module, type, function, local, structure field + +Custom Annotations +.................. + +Added generic syntax for custom annotations in the text format, +mirroring the role of custom sections in the binary format. [#proposal-annot]_ + +* :ref:`Annotations ` of the form :math:`\text{(@id~\dots)}` are allowed anywhere in the :ref:`text format ` + +* :ref:`Identifiers ` can be escaped as :math:`\text{@"\dots"}` with arbitrary :ref:`names ` + +* Defined :ref:`name annotations ` :math:`\text{(@name~"\dots")}` for :ref:`module names `, :ref:`type names `, :ref:`function names `, :ref:`local names `, and :ref:`field names ` + +* Defined :ref:`custom annotation ` :math:`\text{(@custom~"\dots")}` to represent arbitrary :ref:`custom sections ` in the text format + + .. [#proposal-extconst] https://github.com/WebAssembly/extended-const/blob/main/proposals/extended-const/ .. [#proposal-tailcall] https://github.com/WebAssembly/spec/tree/main/proposals/tail-call/ +.. [#proposal-exn] + https://github.com/WebAssembly/spec/tree/main/proposals/exception-handling/ + .. [#proposal-multimem] https://github.com/WebAssembly/multi-memory/blob/main/proposals/multi-memory/ @@ -264,3 +302,6 @@ Added managed reference types. [#proposal-gc]_ .. [#proposal-gc] https://github.com/WebAssembly/spec/tree/main/proposals/gc/ + +.. [#proposal-annot] + https://github.com/WebAssembly/annotations/tree/main/proposals/annotations/ diff --git a/document/core/appendix/custom.rst b/document/core/appendix/custom.rst index 106168ec0b..042a9fae44 100644 --- a/document/core/appendix/custom.rst +++ b/document/core/appendix/custom.rst @@ -45,7 +45,8 @@ Each subsection consists of a n{:}\Bname & (\iff n = \text{name}) \\ &&& \Bmodulenamesubsec^? \\ &&& \Bfuncnamesubsec^? \\ &&& - \Blocalnamesubsec^? \\ + \Blocalnamesubsec^? \\ &&& + \Btagnamesubsec^? \\ \production{name subsection} & \Bnamesubsection_N(\B{B}) &::=& N{:}\Bbyte~~\X{size}{:}\Bu32~~\B{B} & (\iff \X{size} = ||\B{B}||) \\ @@ -61,6 +62,7 @@ Id Subsection 2 :ref:`local names ` 4 :ref:`type names ` 10 :ref:`field names ` +11 :ref:`tag names ` == =========================================== Each subsection may occur at most once, and in order of increasing id. @@ -178,6 +180,22 @@ It consists of an :ref:`indirect name map ` assigning fi \end{array} +.. index:: tag, tag index +.. _binary-tagnamesec: + +Tag Names +......... + +The *tag name subsection* has the id 11. +It consists of a :ref:`name map ` assigning tag names to :ref:`tag indices `. + +.. math:: + \begin{array}{llclll} + \production{tag name subsection} & \Btagnamesubsec &::=& + \Bnamesubsection_1(\Bnamemap) \\ + \end{array} + + .. index:: ! name annotation, name, Unicode UTF-8 .. _text-nameannot: @@ -306,6 +324,22 @@ It may only be placed on a declaration that declares exactly one field. \end{array} +.. index:: tag +.. _text-tagnameannot: + +Tag Names +......... + +A *tag name annotation* must be placed on a :ref:`tag declaration ` or tag :ref:`import `, +directly after the :math:`\text{tag}` keyword, or if present, after the following tag :ref:`identifier `. + +.. math:: + \begin{array}{llclll} + \production{tag name annotation} & \Ttagnameannot &::=& + \Tnameannot \\ + \end{array} + + .. index:: ! custom annotation, custom section .. _text-customannot: diff --git a/document/core/appendix/embedding.rst b/document/core/appendix/embedding.rst index 969e2f1310..d643205f53 100644 --- a/document/core/appendix/embedding.rst +++ b/document/core/appendix/embedding.rst @@ -39,23 +39,34 @@ Interface operation that are predicates return Boolean values: .. _embed-error: -Errors -~~~~~~ +Exceptions and Errors +~~~~~~~~~~~~~~~~~~~~~ + +Invoking an exported function may throw or propagate exceptions, expressed by an auxiliary syntactic class: + +.. math:: + \begin{array}{llll} + \production{exception} & \exception &::=& \EXCEPTION~\exnaddr \\ + \end{array} -Failure of an interface operation is indicated by an auxiliary syntactic class: +The exception address :math:`exnaddr` identifies the exception thrown. + +Failure of an interface operation is also 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 ` are reached. +In addition to the error conditions specified explicitly in this section, such as invalid arguments or :ref:`exceptions ` and :ref:`traps ` resulting from :ref:`execution `, implementations may also return errors when specific :ref:`implementation limitations ` are reached. .. note:: Errors are abstract and unspecific with this definition. Implementations can refine it to carry suitable classifications and diagnostic messages. + + Pre- and Post-Conditions ~~~~~~~~~~~~~~~~~~~~~~~~ @@ -63,7 +74,7 @@ Some operations state *pre-conditions* about their arguments or *post-conditions It is the embedder's responsibility to meet the pre-conditions. If it does, the post conditions are guaranteed by the semantics. -In addition to pre- and post-conditions explicitly stated with each operation, the specification adopts the following conventions for :ref:`runtime objects ` (:math:`\store`, :math:`\moduleinst`, :math:`\externval`, :ref:`addresses `): +In addition to pre- and post-conditions explicitly stated with each operation, the specification adopts the following conventions for :ref:`runtime objects ` (:math:`\store`, :math:`\moduleinst`, :ref:`addresses `): * Every runtime object passed as a parameter must be :ref:`valid ` per an implicit pre-condition. @@ -89,7 +100,7 @@ Store .. math:: \begin{array}{lclll} - \F{store\_init}() &=& \{ \SFUNCS~\epsilon,~ \SMEMS~\epsilon,~ \STABLES~\epsilon,~ \SGLOBALS~\epsilon \} \\ + \F{store\_init}() &=& \{ \} \\ \end{array} @@ -153,10 +164,10 @@ Modules .. index:: instantiation, module instance .. _embed-module-instantiate: -:math:`\F{module\_instantiate}(\store, \module, \externval^\ast) : (\store, \moduleinst ~|~ \error)` -.................................................................................................... +:math:`\F{module\_instantiate}(\store, \module, \externaddr^\ast) : (\store, \moduleinst ~|~ \error)` +..................................................................................................... -1. Try :ref:`instantiating ` :math:`\module` in :math:`\store` with :ref:`external values ` :math:`\externval^\ast` as imports: +1. Try :ref:`instantiating ` :math:`\module` in :math:`\store` with :ref:`external addresses ` :math:`\externaddr^\ast` as imports: a. If it succeeds with a :ref:`module instance ` :math:`\moduleinst`, then let :math:`\X{result}` be :math:`\moduleinst`. @@ -167,7 +178,7 @@ Modules .. math:: \begin{array}{lclll} \F{module\_instantiate}(S, m, \X{ev}^\ast) &=& (S', F.\AMODULE) && (\iff \instantiate(S, m, \X{ev}^\ast) \stepto^\ast S'; F; \epsilon) \\ - \F{module\_instantiate}(S, m, \X{ev}^\ast) &=& (S', \ERROR) && (\iff \instantiate(S, m, \X{ev}^\ast) \stepto^\ast S'; F; \TRAP) \\ + \F{module\_instantiate}(S, m, \X{ev}^\ast) &=& (S', \ERROR) && (\otherwise, \iff \instantiate(S, m, \X{ev}^\ast) \stepto^\ast S'; F; \result) \\ \end{array} .. note:: @@ -216,7 +227,7 @@ Modules 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)`. + a. Let :math:`\X{result}_i` be the pair :math:`(\export_i.\XNAME, \externtype'_i)`. 5. Return the concatenation of all :math:`\X{result}_i`, in index order. @@ -225,7 +236,7 @@ Modules .. math:: ~ \\ \begin{array}{lclll} - \F{module\_exports}(m) &=& (\X{ex}.\ENAME, \externtype')^\ast \\ + \F{module\_exports}(m) &=& (\X{ex}.\XNAME, \externtype')^\ast \\ && \qquad (\iff \X{ex}^\ast = m.\MEXPORTS \wedge {} \vdashmodule m : \externtype^\ast \rightarrow {\externtype'}^\ast) \\ \end{array} @@ -240,21 +251,21 @@ Module Instances .. _embed-instance-export: -:math:`\F{instance\_export}(\moduleinst, \name) : \externval ~|~ \error` -........................................................................ +:math:`\F{instance\_export}(\moduleinst, \name) : \externaddr ~|~ \error` +......................................................................... 1. Assert: due to :ref:`validity ` of the :ref:`module instance ` :math:`\moduleinst`, all its :ref:`export names ` are different. -2. If there exists an :math:`\exportinst_i` in :math:`\moduleinst.\MIEXPORTS` such that :ref:`name ` :math:`\exportinst_i.\EINAME` equals :math:`\name`, then: +2. If there exists an :math:`\exportinst_i` in :math:`\moduleinst.\MIEXPORTS` such that :ref:`name ` :math:`\exportinst_i.\XINAME` equals :math:`\name`, then: - a. Return the :ref:`external value ` :math:`\exportinst_i.\EIVALUE`. + a. Return the :ref:`external address ` :math:`\exportinst_i.\XIADDR`. 3. Else, return :math:`\ERROR`. .. math:: ~ \\ \begin{array}{lclll} - \F{instance\_export}(m, \name) &=& m.\MIEXPORTS[i].\EIVALUE && (\iff m.\MEXPORTS[i].\EINAME = \name) \\ + \F{instance\_export}(m, \name) &=& m.\MIEXPORTS[i].\XIADDR && (\iff m.\MEXPORTS[i].\XINAME = \name) \\ \F{instance\_export}(m, \name) &=& \ERROR && (\otherwise) \\ \end{array} @@ -307,14 +318,16 @@ Functions .. index:: invocation, value, result .. _embed-func-invoke: -:math:`\F{func\_invoke}(\store, \funcaddr, \val^\ast) : (\store, \val^\ast ~|~ \error)` -........................................................................................ +:math:`\F{func\_invoke}(\store, \funcaddr, \val^\ast) : (\store, \val^\ast ~|~ \exception ~|~ \error)` +...................................................................................................... 1. Try :ref:`invoking ` the function :math:`\funcaddr` in :math:`\store` with :ref:`values ` :math:`\val^\ast` as arguments: a. If it succeeds with :ref:`values ` :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`. + b. Else if the outcome is an exception with a thrown :ref:`exception ` :math:`\REFEXNADDR~\exnaddr` as the result, then let :math:`\X{result}` be :math:`\EXCEPTION~\exnaddr` + + c. Else it has trapped, hence let :math:`\X{result}` be :math:`\ERROR`. 2. Return the new store paired with :math:`\X{result}`. @@ -322,6 +335,7 @@ Functions ~ \\ \begin{array}{lclll} \F{func\_invoke}(S, a, v^\ast) &=& (S', {v'}^\ast) && (\iff \invoke(S, a, v^\ast) \stepto^\ast S'; F; {v'}^\ast) \\ + \F{func\_invoke}(S, a, v^\ast) &=& (S', \EXCEPTION~a') && (\iff \invoke(S, a, v^\ast) \stepto^\ast S'; F; (\REFEXNADDR~a')~\THROWREF \\ \F{func\_invoke}(S, a, v^\ast) &=& (S', \ERROR) && (\iff \invoke(S, a, v^\ast) \stepto^\ast S'; F; \TRAP) \\ \end{array} @@ -553,6 +567,99 @@ Memories \end{array} +.. index:: tag, tag address, store, tag instance, tag type, function type +.. _embed-tag: + +Tags +~~~~ + +.. _embedd-tag-alloc: + +:math:`\F{tag\_alloc}(\store, \tagtype) : (\store, \tagaddr)` +............................................................. + +1. Pre-condition: :math:`tagtype` is :ref:`valid `. + +2. Let :math:`\tagaddr` be the result of :ref:`allocating a tag ` in :math:`\store` with :ref:`tag type ` :math:`\tagtype`. + +3. Return the new store paired with :math:`\tagaddr`. + +.. math:: + \begin{array}{lclll} + \F{tag\_alloc}(S, \X{tt}) &=& (S', \X{a}) && (\iff \alloctag(S, \X{tt}) = S', \X{a}) \\ + \end{array} + + +.. _embed-tag-type: + +:math:`\F{tag\_type}(\store, \tagaddr) : \tagtype` +.................................................. + +1. Return :math:`S.\STAGS[a].\HITYPE`. + +2. Post-condition: the returned :ref:`tag type ` is :ref:`valid `. + +.. math:: + \begin{array}{lclll} + \F{tag\_type}(S, a) &=& S.\STAGS[a].\HITYPE \\ + \end{array} + + +.. index:: exception, exception address, store, exception instance, exception type +.. _embed-exception: + +Exceptions +~~~~~~~~~~ + +.. _embed-exn-alloc: + +:math:`\F{exn\_alloc}(\store, \tagaddr, \val^\ast) : (\store, \exnaddr)` +........................................................................ + +1. Pre-condition: :math:`\tagaddr` is an allocated :ref:`tag address `. + +2. Let :math:`\exnaddr` be the result of :ref:`allocating an exception instance ` in :math:`\store` with :ref:`tag address ` :math:`\tagaddr` and initialization values :math:`\val^\ast`. + +3. Return the new store paired with :math:`\exnaddr`. + +.. math:: + \begin{array}{lcll} + \F{exn\_alloc}(S, \tagaddr, \val^\ast) &=& (S \compose \{\SEXNS~\exninst\}, |S.\SEXNS|) & + (\iff \exninst = \{\EITAG~\tagaddr, \EIFIELDS~\val^\ast\} \\ + \end{array} + + +.. _embed-exn-tag: + +:math:`\F{exn\_tag}(\store, \exnaddr) : \tagaddr` +................................................. + +1. Let :math:`\exninst` be the :ref:`exception instance ` :math:`\store.\SEXNS[\exnaddr]`. + +2. Return the :ref:`tag address ` :math:`\exninst.\EITAG`. + +.. math:: + \begin{array}{lcll} + \F{exn\_tag}(S, a) &=& \exninst.\EITAG & + (\iff \exninst = S.\SEXNS[a]) \\ + \end{array} + + +.. _embed-exn-read: + +:math:`\F{exn\_read}(\store, \exnaddr) : \val^\ast` +................................................... + +1. Let :math:`\exninst` be the :ref:`exception instance ` :math:`\store.\SEXNS[\exnaddr]`. + +2. Return the :ref:`values ` :math:`\exninst.\EIFIELDS`. + +.. math:: + \begin{array}{lcll} + \F{exn\_read}(S, a) &=& \exninst.\EIFIELDS & + (\iff \exninst = S.\SEXNS[a]) \\ + \end{array} + .. index:: global, global address, store, global instance, global type, value .. _embed-global: diff --git a/document/core/appendix/implementation.rst b/document/core/appendix/implementation.rst index 6de60fb587..15fe69357c 100644 --- a/document/core/appendix/implementation.rst +++ b/document/core/appendix/implementation.rst @@ -24,7 +24,7 @@ However, it is expected that all implementations have "reasonably" large limits Syntactic Limits ~~~~~~~~~~~~~~~~ -.. index:: abstract syntax, module, type, function, table, memory, global, element, data, import, export, parameter, result, local, structured control instruction, instruction, name, Unicode, character +.. index:: abstract syntax, module, type, function, table, memory, global, tag, element, data, import, export, parameter, result, local, structured control instruction, instruction, name, Unicode, character .. _impl-syntax: Structure @@ -37,6 +37,7 @@ An implementation may impose restrictions on the following dimensions of a modul * the number of :ref:`tables ` in a :ref:`module `, including imports * the number of :ref:`memories ` in a :ref:`module `, including imports * the number of :ref:`globals ` in a :ref:`module `, including imports +* the number of :ref:`tags ` in a :ref:`module `, including imports * the number of :ref:`element segments ` in a :ref:`module ` * the number of :ref:`data segments ` in a :ref:`module ` * the number of :ref:`imports ` to a :ref:`module ` @@ -131,8 +132,10 @@ Restrictions on the following dimensions may be imposed during :ref:`execution < * the number of allocated :ref:`table instances ` * the number of allocated :ref:`memory instances ` * the number of allocated :ref:`global instances ` +* the number of allocated :ref:`tag instances ` * the number of allocated :ref:`structure instances ` * the number of allocated :ref:`array instances ` +* the number of allocated :ref:`exception instances ` * the size of a :ref:`table instance ` * the size of a :ref:`memory instance ` * the size of an :ref:`array instance ` diff --git a/document/core/appendix/index-instructions.py b/document/core/appendix/index-instructions.py index 1b86ea3dd2..41c140da1d 100755 --- a/document/core/appendix/index-instructions.py +++ b/document/core/appendix/index-instructions.py @@ -52,17 +52,26 @@ def RefWrap(s, kind): return f':ref:`{kind} <{s}>`' -def Instruction(name, opcode, type=None, validation=None, execution=None, operator=None): +def Instruction(name, opcode, type=None, validation=None, execution=None, operator=None, validation2=None, execution2=None): if operator: execution_str = RefWrap(execution, 'execution') + ' (' + RefWrap(operator, 'operator') + ')' + elif execution2: + execution_str = ', '.join([RefWrap(execution, 'execution'), + RefWrap(execution, 'execution')]) else: execution_str = RefWrap(execution, 'execution') + if validation2: + validation_str = ', '.join([RefWrap(validation, 'validation'), + RefWrap(validation2, 'validation')]) + else: + validation_str = RefWrap(validation, 'validation') + return ( MathWrap(name, '(reserved)'), MathWrap(opcode), MathWrap(type), - RefWrap(validation, 'validation'), + validation_str, execution_str ) @@ -76,9 +85,9 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat Instruction(r'\ELSE', r'\hex{05}'), Instruction(None, r'\hex{06}'), Instruction(None, r'\hex{07}'), - Instruction(None, r'\hex{08}'), + Instruction(r'\THROW~x', r'\hex{08}', r'[t_1^\ast~t_x^\ast] \to [t_2^\ast]', r'valid-throw', r'exec-throw'), Instruction(None, r'\hex{09}'), - Instruction(None, r'\hex{0A}'), + Instruction(r'\THROWREF', r'\hex{0A}', r'[t_1^\ast~\EXNREF] \to [t_2^\ast]', r'valid-throw_ref', r'exec-throw_ref'), Instruction(r'\END', r'\hex{0B}'), Instruction(r'\BR~l', r'\hex{0C}', r'[t_1^\ast~t^\ast] \to [t_2^\ast]', r'valid-br', r'exec-br'), Instruction(r'\BRIF~l', r'\hex{0D}', r'[t^\ast~\I32] \to [t^\ast]', r'valid-br_if', r'exec-br_if'), @@ -99,7 +108,7 @@ def Instruction(name, opcode, type=None, validation=None, execution=None, operat Instruction(r'\SELECT~t', r'\hex{1C}', r'[t~t~\I32] \to [t]', r'valid-select', r'exec-select'), Instruction(None, r'\hex{1D}'), Instruction(None, r'\hex{1E}'), - Instruction(None, r'\hex{1F}'), + Instruction(r'\TRYTABLE~\X{bt}', r'\hex{1F}', r'[t_1^\ast] \to [t_2^\ast]', r'valid-try_table', r'exec-try_table'), Instruction(r'\LOCALGET~x', r'\hex{20}', r'[] \to [t]', r'valid-local.get', r'exec-local.get'), Instruction(r'\LOCALSET~x', r'\hex{21}', r'[t] \to []', r'valid-local.set', r'exec-local.set'), Instruction(r'\LOCALTEE~x', r'\hex{22}', r'[t] \to [t]', r'valid-local.tee', r'exec-local.tee'), diff --git a/document/core/appendix/index-rules.rst b/document/core/appendix/index-rules.rst index 4edbc49527..5c523a2b94 100644 --- a/document/core/appendix/index-rules.rst +++ b/document/core/appendix/index-rules.rst @@ -34,6 +34,7 @@ Construct Judgement :ref:`Table type ` :math:`C \vdashtabletype \tabletype : \OKtabletype` :ref:`Memory type ` :math:`C \vdashmemtype \memtype : \OKmemtype` :ref:`Global type ` :math:`C \vdashglobaltype \globaltype : \OKglobaltype` +:ref:`Tag type ` :math:`C \vdashtagtype \tagtype : \OKtagtype` :ref:`External type ` :math:`C \vdashexterntype \externtype : \OKexterntype` :ref:`Type definitions ` :math:`C \vdashtypes \type^\ast : \OKtypes` =============================================== ================================================================================= @@ -45,8 +46,9 @@ Typing of Static Constructs =============================================== ================================================================================= Construct Judgement =============================================== ================================================================================= -:ref:`Instruction ` :math:`S;C \vdashinstr \instr : \functype` -:ref:`Instruction sequence ` :math:`S;C \vdashinstrs \instr^\ast : \functype` +:ref:`Instruction ` :math:`S;C \vdashinstr \instr : \instrtype` +:ref:`Instruction sequence ` :math:`S;C \vdashinstrs \instr^\ast : \instrtype` +:ref:`Catch clause ` :math:`C \vdashcatch \catch : \OKcatch` :ref:`Expression ` :math:`C \vdashexpr \expr : \resulttype` :ref:`Function ` :math:`C \vdashfunc \func : \functype` :ref:`Local ` :math:`C \vdashlocal \local : \localtype` @@ -54,6 +56,7 @@ Construct Judgement :ref:`Memory ` :math:`C \vdashmem \mem : \memtype` :ref:`Limits ` :math:`C \vdashlimits \limits : k` :ref:`Global ` :math:`C \vdashglobal \global : \globaltype` +:ref:`Tag ` :math:`C \vdashtag \tag : \tagtype` :ref:`Element segment ` :math:`C \vdashelem \elem : \reftype` :ref:`Element mode ` :math:`C \vdashelemmode \elemmode : \reftype` :ref:`Data segment ` :math:`C \vdashdata \data : \OKdata` @@ -79,11 +82,12 @@ Construct Judgement :ref:`Result ` :math:`S \vdashresult \result : \resulttype` :ref:`Packed value ` :math:`S \vdashpackval \packval : \packtype` :ref:`Field value ` :math:`S \vdashfieldval \fieldval : \storagetype` -:ref:`External value ` :math:`S \vdashexternval \externval : \externtype` +:ref:`External address ` :math:`S \vdashexternaddr \externaddr : \externtype` :ref:`Function instance ` :math:`S \vdashfuncinst \funcinst : \functype` :ref:`Table instance ` :math:`S \vdashtableinst \tableinst : \tabletype` :ref:`Memory instance ` :math:`S \vdashmeminst \meminst : \memtype` :ref:`Global instance ` :math:`S \vdashglobalinst \globalinst : \globaltype` +:ref:`Tag instance ` :math:`S \vdashtaginst \taginst : \tagtype` :ref:`Element instance ` :math:`S \vdasheleminst \eleminst : t` :ref:`Data instance ` :math:`S \vdashdatainst \datainst : \OKdatainst` :ref:`Structure instance ` :math:`S \vdashstructinst \structinst : \OKstructinst` @@ -132,6 +136,7 @@ Construct Judgement :ref:`Table type ` :math:`C \vdashtabletypematch \tabletype_1 \subtabletypematch \tabletype_2` :ref:`Memory type ` :math:`C \vdashmemtypematch \memtype_1 \submemtypematch \memtype_2` :ref:`Global type ` :math:`C \vdashglobaltypematch \globaltype_1 \subglobaltypematch \globaltype_2` +:ref:`Tag type ` :math:`C \vdashtagtypematch \tagtype_1 \subtagtypematch \tagtype_2` :ref:`External type ` :math:`C \vdashexterntypematch \externtype_1 \subexterntypematch \externtype_2` :ref:`Limits ` :math:`C \vdashlimitsmatch \limits_1 \sublimitsmatch \limits_2` =============================================== =================================================================================== @@ -147,6 +152,7 @@ Construct Judgement :ref:`Table instance ` :math:`\vdashtableinstextends \tableinst_1 \extendsto \tableinst_2` :ref:`Memory instance ` :math:`\vdashmeminstextends \meminst_1 \extendsto \meminst_2` :ref:`Global instance ` :math:`\vdashglobalinstextends \globalinst_1 \extendsto \globalinst_2` +:ref:`Tag instance ` :math:`\vdashtaginstextends \taginst_1 \extendsto \taginst_2` :ref:`Element instance ` :math:`\vdasheleminstextends \eleminst_1 \extendsto \eleminst_2` :ref:`Data instance ` :math:`\vdashdatainstextends \datainst_1 \extendsto \datainst_2` :ref:`Structure instance ` :math:`\vdashstructinstextends \structinst_1 \extendsto \structinst_2` diff --git a/document/core/appendix/index-types.rst b/document/core/appendix/index-types.rst index 9339bebdd0..6bd849c8ab 100644 --- a/document/core/appendix/index-types.rst +++ b/document/core/appendix/index-types.rst @@ -16,7 +16,8 @@ Category Constructor (reserved) :math:`\hex{7A}` .. :math:`\hex{79}` :ref:`Packed type ` |I8| :math:`\hex{78}` (-8 as |Bs7|) :ref:`Packed type ` |I16| :math:`\hex{77}` (-9 as |Bs7|) -(reserved) :math:`\hex{78}` .. :math:`\hex{74}` +(reserved) :math:`\hex{78}` .. :math:`\hex{75}` +:ref:`Heap type ` |NOEXN| :math:`\hex{74}` (-14 as |Bs7|) :ref:`Heap type ` |NOFUNC| :math:`\hex{73}` (-13 as |Bs7|) :ref:`Heap type ` |NOEXTERN| :math:`\hex{72}` (-14 as |Bs7|) :ref:`Heap type ` |NONE| :math:`\hex{71}` (-15 as |Bs7|) @@ -27,7 +28,8 @@ Category Constructor :ref:`Heap type ` |I31| :math:`\hex{6C}` (-20 as |Bs7|) :ref:`Heap type ` |STRUCT| :math:`\hex{6B}` (-21 as |Bs7|) :ref:`Heap type ` |ARRAY| :math:`\hex{6A}` (-22 as |Bs7|) -(reserved) :math:`\hex{69}` .. :math:`\hex{65}` +:ref:`Heap type ` |EXN| :math:`\hex{69}` (-23 as |Bs7|) +(reserved) :math:`\hex{68}` .. :math:`\hex{65}` :ref:`Reference type ` |REF| :math:`\hex{64}` (-28 as |Bs7|) :ref:`Reference type ` |REF| |NULL| :math:`\hex{63}` (-29 as |Bs7|) (reserved) :math:`\hex{62}` .. :math:`\hex{61}` @@ -43,4 +45,5 @@ Category Constructor :ref:`Table type ` :math:`\limits~\reftype` (none) :ref:`Memory type ` :math:`\limits` (none) :ref:`Global type ` :math:`\mut~\valtype` (none) +:ref:`Tag type ` :math:`\functype` (none) ======================================== ================================================== =============================================================== diff --git a/document/core/appendix/properties.rst b/document/core/appendix/properties.rst index f78541f5ca..6ec9c8c1e1 100644 --- a/document/core/appendix/properties.rst +++ b/document/core/appendix/properties.rst @@ -7,7 +7,7 @@ Type Soundness The :ref:`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 ` or :ref:`global ` variable will only contain type-correct values, every :ref:`instruction ` will only be applied to operands of the expected type, and every :ref:`function ` :ref:`invocation ` always evaluates to a result of the right type (if it does not :ref:`trap ` or diverge). + e.g., every :ref:`local ` or :ref:`global ` variable will only contain type-correct values, every :ref:`instruction ` will only be applied to operands of the expected type, and every :ref:`function ` :ref:`invocation ` always evaluates to a result of the right type (if it does not diverge, throw an exception, or :ref:`trap `). * No memory location will be read or written except those explicitly defined by the program, i.e., as a :ref:`local `, a :ref:`global `, an element in a :ref:`table `, or a location within a linear :ref:`memory `. @@ -219,7 +219,7 @@ In a :ref:`rolled-up ` :ref:`recursive type `, This rule is only invoked when checking :ref:`validity ` of :ref:`rolled-up ` :ref:`recursive types `. -.. index:: value, value type, result, result type, trap +.. index:: value, value type, result, result type, trap, exception, throw .. _valid-result: Results @@ -246,6 +246,23 @@ Results } +:ref:`Results ` :math:`(\REFEXNADDR~a)~\THROWREF` +................................................................ + +* The value :math:`\REFEXNADDR~a` must be :ref:`valid `. + +* Then the result is valid with :ref:`result type ` :math:`[t^\ast]`, for any :ref:`valid ` :ref:`closed ` :ref:`result types `. + +.. math:: + \frac{ + S \vdashval REFEXNADDR~a : REF~EXN + \qquad + \vdashresulttype [t^\ast] : \OKresulttype + }{ + S \vdashresult (\REFEXNADDR~a)~\THROWREF : [{t'}^\ast] + } + + :ref:`Results ` :math:`\TRAP` ............................................ @@ -267,14 +284,37 @@ Store Validity The following typing rules specify when a runtime :ref:`store ` :math:`S` is *valid*. A valid store must consist of -:ref:`function `, :ref:`table `, :ref:`memory `, :ref:`global `, and :ref:`module ` instances that are themselves valid, relative to :math:`S`. - -To that end, each kind of instance is classified by a respective :ref:`function `, :ref:`table `, :ref:`memory `, or :ref:`global ` type. +:ref:`function `, +:ref:`table `, +:ref:`memory `, +:ref:`global `, +:ref:`tag `, +:ref:`element `, +:ref:`data `, +:ref:`structure `, +:ref:`array `, +:ref:`exception `, +and +:ref:`module ` +instances that are themselves valid, relative to :math:`S`. + +To that end, each kind of instance is classified by a respective +:ref:`function `, +:ref:`table `, +:ref:`memory `, +:ref:`global `, +:ref:`tag `, +:ref:`element `, or +:ref:`data ` +type, or just ${:OK} in the case of +:ref:`structures `, +:ref:`arrays `, or +:ref:`exceptions `. Module instances are classified by *module contexts*, which are regular :ref:`contexts ` repurposed as module types describing the :ref:`index spaces ` defined by a module. -.. index:: store, function instance, table instance, memory instance, structure instance, array instance, global instance, function type, table type, memory type, global type, defined type, structure type, array type +.. index:: store, function instance, table instance, memory instance, structure instance, array instance, global instance, tag instance, function type, table type, memory type, global type, tag type, defined type, structure type, array type :ref:`Store ` :math:`S` ..................................... @@ -287,6 +327,8 @@ Module instances are classified by *module contexts*, which are regular :ref:`co * Each :ref:`global instance ` :math:`\globalinst_i` in :math:`S.\SGLOBALS` must be :ref:`valid ` with some :ref:`global type ` :math:`\globaltype_i`. +* Each :ref:`tag instance ` :math:`\taginst_i` in :math:`S.\STAGS` must be :ref:`valid ` with some :ref:`tag type ` :math:`\tagtype_i`. + * Each :ref:`element instance ` :math:`\eleminst_i` in :math:`S.\SELEMS` must be :ref:`valid ` with some :ref:`reference type ` :math:`\reftype_i`. * Each :ref:`data instance ` :math:`\datainst_i` in :math:`S.\SDATAS` must be :ref:`valid `. @@ -295,9 +337,13 @@ Module instances are classified by *module contexts*, which are regular :ref:`co * Each :ref:`array instance ` :math:`\arrayinst_i` in :math:`S.\SARRAYS` must be :ref:`valid `. -* No :ref:`reference ` to a bound :ref:`structure address ` must be reachable from itself through a path consisting only of indirections through immutable structure or array :ref:`fields `. +* Each :ref:`exception instance ` :math:`\exninst_i` in :math:`S.\SEXNS` must be :ref:`valid `. + +* No :ref:`reference ` to a bound :ref:`structure address ` must be reachable from itself through a path consisting only of indirections through immutable structure, or array :ref:`fields ` or fields of :ref:`exception instances `. -* No :ref:`reference ` to a bound :ref:`array address ` must be reachable from itself through a path consisting only of indirections through immutable structure or array :ref:`fields `. +* No :ref:`reference ` to a bound :ref:`array address ` must be reachable from itself through a path consisting only of indirections through immutable structure or array :ref:`fields ` or fields of :ref:`exception instances `. + +* No :ref:`reference ` to a bound :ref:`exception address ` must be reachable from itself through a path consisting only of indirections through immutable structure or array :ref:`fields ` or fields of :ref:`exception instances `. * Then the store is valid. @@ -313,6 +359,8 @@ Module instances are classified by *module contexts*, which are regular :ref:`co \qquad (S \vdashglobalinst \globalinst : \globaltype)^\ast \\ + (S \vdashtaginst \taginst : \tagtype)^\ast + \\ (S \vdasheleminst \eleminst : \reftype)^\ast \qquad (S \vdashdatainst \datainst : \OKdatainst)^\ast @@ -320,17 +368,21 @@ Module instances are classified by *module contexts*, which are regular :ref:`co (S \vdashstructinst \structinst : \OKstructinst)^\ast \qquad (S \vdasharrayinst \arrayinst : \OKarrayinst)^\ast + \qquad + (S \vdashexninst \exninst : \OKexninst)^\ast \\ S = \{ \begin{array}[t]{@{}l@{}} \SFUNCS~\funcinst^\ast, \SGLOBALS~\globalinst^\ast, \STABLES~\tableinst^\ast, - \SMEMS~\meminst^\ast, \\ + \SMEMS~\meminst^\ast, + \STAGS~\taginst^\ast, \\ \SELEMS~\eleminst^\ast, \SDATAS~\datainst^\ast, \SSTRUCTS~\structinst^\ast, - \SARRAYS~\arrayinst^\ast \} + \SARRAYS~\arrayinst^\ast, + \SEXNS~\exninst^\ast \} \end{array} \\ (S.\SSTRUCTS[a_{\F{s}}] = \structinst)^\ast @@ -340,6 +392,10 @@ Module instances are classified by *module contexts*, which are regular :ref:`co (S.\SARRAYS[a_{\F{a}}] = \arrayinst)^\ast \qquad ((\REFARRAYADDR~a_{\F{a}}) \not\gg^+_S (\REFARRAYADDR~a_{\F{a}}))^\ast + \\ + (S.\SEXNS[a_{\F{e}}] = \exninst)^\ast + \qquad + ((\REFEXNADDR~a_{\F{e}}) \not\gg^+_S (\REFEXNADDR~a_{\F{e}}))^\ast \end{array} }{ \vdashstore S : \OKstore @@ -347,7 +403,7 @@ Module instances are classified by *module contexts*, which are regular :ref:`co .. index:: reachability -where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the following *reachability* relation on :ref:`values `: +where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the following *immutable reachability* relation on :ref:`values `: .. math:: \begin{array}{@{}lcll@{}} @@ -355,6 +411,7 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow & \iff \expanddt(S.\SSTRUCTS[a].\SITYPE) = \TSTRUCT~\X{ft}_1^i~(\MCONST~\X{st})~\X{ft}_2^\ast \\ (\REFARRAYADDR~a) &\gg_S& S.\SARRAYS[a].\AIFIELDS[i] & \iff \expanddt(S.\SARRAYS[a].\AITYPE) = \TARRAY~(\MCONST~\X{st}) \\ + (\REFEXNADDR~a) &\gg_S& S.\SEXNS[a].\EIFIELDS[i] \\ (\REFEXTERN~\reff) &\gg_S& \reff \\ \end{array} @@ -532,6 +589,24 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow } +.. index:: tag type, tag instance +.. _valid-taginst: + +:ref:`Tag Instances ` :math:`\{ \HITYPE~\tagtype \}` +.................................................................... + +* The :ref:`tag type ` :math:`\tagtype` must be :ref:`valid ` under the empty :ref:`context `. + +* Then the tag instance is valid with :ref:`tag type ` :math:`\tagtype`. + +.. math:: + \frac{ + \vdashtagtype \tagtype : \OKtagtype + }{ + S \vdashtaginst \{ \HITYPE~\tagtype \} : \tagtype + } + + .. index:: element instance, reference .. _valid-eleminst: @@ -581,7 +656,7 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow :ref:`Structure Instances ` :math:`\{ \SITYPE~\deftype, \SIFIELDS~\fieldval^\ast \}` ....................................................................................................... -* The :ref:`defined type ` :math:`\deftype` must be :ref:`valid `. +* The :ref:`defined type ` :math:`\deftype` must be :ref:`valid ` under the empty :ref:`context `. * The :ref:`expansion ` of :math:`\deftype` must be a :ref:`structure type ` :math:`\TSTRUCT~\fieldtype^\ast`. @@ -613,7 +688,7 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow :ref:`Array Instances ` :math:`\{ \AITYPE~\deftype, \AIFIELDS~\fieldval^\ast \}` .................................................................................................. -* The :ref:`defined type ` :math:`\deftype` must be :ref:`valid `. +* The :ref:`defined type ` :math:`\deftype` must be :ref:`valid ` under the empty :ref:`context `. * The :ref:`expansion ` of :math:`\deftype` must be an :ref:`array type ` :math:`\TARRAY~\fieldtype`. @@ -663,21 +738,49 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow } -.. index:: external type, export instance, name, external value +.. index:: exception instance, tag, tag address +.. _valid-exninst: + +:ref:`Exception Instances ` :math:`\{ \EITAG~a, \EIFIELDS~\val^\ast \}` +....................................................................................... + +* The store entry :math:`S.\STAGS[a]` must exist. + +* Let :math:`[t^\ast] \toF [{t'}^\ast]` be the :ref:`tag type ` :math:`S.\STAGS[a].\HITYPE`. + +* The :ref:`result type ` :math:`[{t'}^\ast]` must be empty. + +* The sequence :math:`\val^ast` of :ref:`values ` must have the same length as the sequence :math:`t^\ast` of :ref:`value types `. + +* For each value :math:`\val_i` in :math:`\val^ast` and corresponding value type :math:`t_i` in :math:`t^\ast`, the value :math:`\val_i` must be valid with type :math:`t_i`. + +* Then the exception instance is valid. + +.. math:: + \frac{ + S.\STAGS[a] = \{\HITYPE = [t^\ast] \toF []\} + \qquad + (S \vdashval \val : t)^\ast + }{ + S \vdashexninst \{ \EITAG~a, \EIFIELDS~\val^\ast \} : \OKexninst + } + + +.. index:: external type, export instance, name, external address .. _valid-exportinst: -:ref:`Export Instances ` :math:`\{ \EINAME~\name, \EIVALUE~\externval \}` -....................................................................................................... +:ref:`Export Instances ` :math:`\{ \XINAME~\name, \XIADDR~\externaddr \}` +............................................................................................ -* The :ref:`external value ` :math:`\externval` must be :ref:`valid ` with some :ref:`external type ` :math:`\externtype`. +* The :ref:`external address ` :math:`\externaddr` must be :ref:`valid ` with some :ref:`external type ` :math:`\externtype`. * Then the export instance is valid. .. math:: \frac{ - S \vdashexternval \externval : \externtype + S \vdashexternaddr \externaddr : \externtype }{ - S \vdashexportinst \{ \EINAME~\name, \EIVALUE~\externval \} : \OKexportinst + S \vdashexportinst \{ \XINAME~\name, \XIADDR~\externaddr \} : \OKexportinst } @@ -689,13 +792,15 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow * Each :ref:`defined type ` :math:`\deftype_i` in :math:`\moduleinst.\MITYPES` must be :ref:`valid ` under the empty :ref:`context `. -* For each :ref:`function address ` :math:`\funcaddr_i` in :math:`\moduleinst.\MIFUNCS`, the :ref:`external value ` :math:`\EVFUNC~\funcaddr_i` must be :ref:`valid ` with some :ref:`external type ` :math:`\ETFUNC~\functype_i`. +* For each :ref:`function address ` :math:`\funcaddr_i` in :math:`\moduleinst.\MIFUNCS`, the :ref:`external address ` :math:`\XAFUNC~\funcaddr_i` must be :ref:`valid ` with some :ref:`external type ` :math:`\XTFUNC~\functype_i`. -* For each :ref:`table address ` :math:`\tableaddr_i` in :math:`\moduleinst.\MITABLES`, the :ref:`external value ` :math:`\EVTABLE~\tableaddr_i` must be :ref:`valid ` with some :ref:`external type ` :math:`\ETTABLE~\tabletype_i`. +* For each :ref:`table address ` :math:`\tableaddr_i` in :math:`\moduleinst.\MITABLES`, the :ref:`external address ` :math:`\XATABLE~\tableaddr_i` must be :ref:`valid ` with some :ref:`external type ` :math:`\XTTABLE~\tabletype_i`. -* For each :ref:`memory address ` :math:`\memaddr_i` in :math:`\moduleinst.\MIMEMS`, the :ref:`external value ` :math:`\EVMEM~\memaddr_i` must be :ref:`valid ` with some :ref:`external type ` :math:`\ETMEM~\memtype_i`. +* For each :ref:`memory address ` :math:`\memaddr_i` in :math:`\moduleinst.\MIMEMS`, the :ref:`external address ` :math:`\XAMEM~\memaddr_i` must be :ref:`valid ` with some :ref:`external type ` :math:`\XTMEM~\memtype_i`. -* For each :ref:`global address ` :math:`\globaladdr_i` in :math:`\moduleinst.\MIGLOBALS`, the :ref:`external value ` :math:`\EVGLOBAL~\globaladdr_i` must be :ref:`valid ` with some :ref:`external type ` :math:`\ETGLOBAL~\globaltype_i`. +* For each :ref:`global address ` :math:`\globaladdr_i` in :math:`\moduleinst.\MIGLOBALS`, the :ref:`external address ` :math:`\XAGLOBAL~\globaladdr_i` must be :ref:`valid ` with some :ref:`external type ` :math:`\XTGLOBAL~\globaltype_i`. + +* For each :ref:`tag address ` :math:`\tagaddr_i` in :math:`\moduleinst.\MITAGS`, the :ref:`external address ` :math:`\XATAG~\tagaddr_i` must be :ref:`valid ` with some :ref:`external type ` :math:`\XTTAG~\tagtype_i`. * For each :ref:`element address ` :math:`\elemaddr_i` in :math:`\moduleinst.\MIELEMS`, the :ref:`element instance ` :math:`S.\SELEMS[\elemaddr_i]` must be :ref:`valid ` with some :ref:`reference type ` :math:`\reftype_i`. @@ -703,7 +808,7 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow * Each :ref:`export instance ` :math:`\exportinst_i` in :math:`\moduleinst.\MIEXPORTS` must be :ref:`valid `. -* For each :ref:`export instance ` :math:`\exportinst_i` in :math:`\moduleinst.\MIEXPORTS`, the :ref:`name ` :math:`\exportinst_i.\EINAME` must be different from any other name occurring in :math:`\moduleinst.\MIEXPORTS`. +* For each :ref:`export instance ` :math:`\exportinst_i` in :math:`\moduleinst.\MIEXPORTS`, the :ref:`name ` :math:`\exportinst_i.\XINAME` must be different from any other name occurring in :math:`\moduleinst.\MIEXPORTS`. * Let :math:`\deftype^\ast` be the concatenation of all :math:`\deftype_i` in order. @@ -715,6 +820,8 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow * Let :math:`\globaltype^\ast` be the concatenation of all :math:`\globaltype_i` in order. +* Let :math:`\tagtype^\ast` be the concatenation of all :math:`\tagtype_i` in order. + * Let :math:`\reftype^\ast` be the concatenation of all :math:`\reftype_i` in order. * Let :math:`\X{ok}^\ast` be the concatenation of all :math:`\X{ok}_i` in order. @@ -724,7 +831,7 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow * Let :math:`x^\ast` be the sequence of :ref:`function indices ` from :math:`0` to :math:`m-1`. * Then the module instance is valid with :ref:`context ` - :math:`\{\CTYPES~\deftype^\ast,` :math:`\CFUNCS~\functype^\ast,` :math:`\CTABLES~\tabletype^\ast,` :math:`\CMEMS~\memtype^\ast,` :math:`\CGLOBALS~\globaltype^\ast,` :math:`\CELEMS~\reftype^\ast,` :math:`\CDATAS~\X{ok}^\ast,` :math:`\CREFS~x^\ast\}`. + :math:`\{\CTYPES~\deftype^\ast,` :math:`\CFUNCS~\functype^\ast,` :math:`\CTABLES~\tabletype^\ast,` :math:`\CMEMS~\memtype^\ast,` :math:`\CGLOBALS~\globaltype^\ast,` \CTAGS~\tagtype^\ast, :math:`\CELEMS~\reftype^\ast,` :math:`\CDATAS~\X{ok}^\ast,` :math:`\CREFS~x^\ast\}`. .. math:: ~\\[-1ex] @@ -732,13 +839,15 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow \begin{array}{@{}c@{}} (\vdashdeftype \deftype : \OKdeftype)^\ast \\ - (S \vdashexternval \EVFUNC~\funcaddr : \ETFUNC~\functype)^\ast + (S \vdashexternaddr \XAFUNC~\funcaddr : \XTFUNC~\functype)^\ast \qquad - (S \vdashexternval \EVTABLE~\tableaddr : \ETTABLE~\tabletype)^\ast + (S \vdashexternaddr \XATABLE~\tableaddr : \XTTABLE~\tabletype)^\ast \\ - (S \vdashexternval \EVMEM~\memaddr : \ETMEM~\memtype)^\ast + (S \vdashexternaddr \XAMEM~\memaddr : \XTMEM~\memtype)^\ast \qquad - (S \vdashexternval \EVGLOBAL~\globaladdr : \ETGLOBAL~\globaltype)^\ast + (S \vdashexternaddr \XAGLOBAL~\globaladdr : \XTGLOBAL~\globaltype)^\ast + \\ + (S \vdashexternaddr \XATAG~\tagaddr : \XTTAG~\tagtype)^\ast \\ (S \vdasheleminst S.\SELEMS[\elemaddr] : \reftype)^\ast \qquad @@ -746,7 +855,7 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow \\ (S \vdashexportinst \exportinst : \OKexportinst)^\ast \qquad - (\exportinst.\EINAME)^\ast ~\mbox{disjoint} + (\exportinst.\XINAME)^\ast ~\mbox{disjoint} \end{array} }{ S \vdashmoduleinst \{ @@ -756,6 +865,7 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow \MITABLES & \tableaddr^\ast, \\ \MIMEMS & \memaddr^\ast, \\ \MIGLOBALS & \globaladdr^\ast, \\ + \MITAGS & \tagaddr^\ast, \\ \MIELEMS & \elemaddr^\ast, \\ \MIDATAS & \dataaddr^\ast, \\ \MIEXPORTS & \exportinst^\ast ~\} : \{ @@ -765,6 +875,7 @@ where :math:`\val_1 \gg^+_S \val_2` denotes the transitive closure of the follow \CTABLES & \tabletype^\ast, \\ \CMEMS & \memtype^\ast, \\ \CGLOBALS & \globaltype^\ast, \\ + \CTAGS & \tagtype^\ast, \\ \CELEMS & \reftype^\ast, \\ \CDATAS & \X{ok}^\ast, \\ \CREFS & 0 \dots (|\funcaddr^\ast|-1) ~\} @@ -959,7 +1070,7 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera :math:`\INVOKE~\funcaddr` ......................... -* The :ref:`external function value ` :math:`\EVFUNC~\funcaddr` must be :ref:`valid ` with :ref:`external function type ` :math:`\ETFUNC \functype'`. +* The :ref:`external function address ` :math:`\XAFUNC~\funcaddr` must be :ref:`valid ` with :ref:`external function type ` :math:`\XTFUNC~\functype'`. * Let :math:`[t_1^\ast] \toF [t_2^\ast])` be the :ref:`function type ` :math:`\functype`. @@ -967,7 +1078,7 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera .. math:: \frac{ - S \vdashexternval \EVFUNC~\funcaddr : \ETFUNC~[t_1^\ast] \toF [t_2^\ast] + S \vdashexternaddr \XAFUNC~\funcaddr : \XTFUNC~[t_1^\ast] \toF [t_2^\ast] }{ S; C \vdashadmininstr \INVOKE~\funcaddr : [t_1^\ast] \to [t_2^\ast] } @@ -1000,7 +1111,7 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera .. index:: frame, instruction, result type :math:`\FRAME_n\{F\}~\instr^\ast~\END` -........................................... +...................................... * Under the :ref:`valid ` return type :math:`[t^n]`, the :ref:`thread ` :math:`F; \instr^\ast` must be :ref:`valid ` with :ref:`result type ` :math:`[t^n]`. @@ -1017,6 +1128,29 @@ To that end, all previous typing judgements :math:`C \vdash \X{prop}` are genera } +.. index:: handler, throw context + +:math:`\HANDLER_n\{\catch^\ast\}~\instr^\ast~\END` +.................................................. + +* For every :ref:`catch clause ` :math:`\catch_i` in :math:`\catch^\ast`, :math:`\catch_i` must be :ref:`valid `. + +* The instruction sequence :math:`\instr^\ast` must be :ref:`valid ` with some type :math:`[t_1^\ast] \to [t_2^\ast]`. + +* Then the compound instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`. + +.. math:: + \frac{ + \begin{array}{c} + (C \vdashcatch \catch : \OKcatch)^\ast + \qquad + S; C \vdashinstrs \instr^\ast : [t_1^\ast] \to [t_2^\ast] \\ + \end{array} + }{ + S; C \vdashadmininstr \HANDLER_n\{\catch^\ast\}~\instr^\ast~\END : [t_1^\ast] \to [t_2^\ast] + } + + .. index:: ! store extension, store .. _extend: @@ -1050,6 +1184,8 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S' * The length of :math:`S.\SGLOBALS` must not shrink. +* The length of :math:`S.\STAGS` must not shrink. + * The length of :math:`S.\SELEMS` must not shrink. * The length of :math:`S.\SDATAS` must not shrink. @@ -1058,6 +1194,8 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S' * The length of :math:`S.\SARRAYS` must not shrink. +* The length of :math:`S.\SEXNS` must not shrink. + * For each :ref:`function instance ` :math:`\funcinst_i` in the original :math:`S.\SFUNCS`, the new function instance must be an :ref:`extension ` of the old. * For each :ref:`table instance ` :math:`\tableinst_i` in the original :math:`S.\STABLES`, the new table instance must be an :ref:`extension ` of the old. @@ -1066,6 +1204,8 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S' * For each :ref:`global instance ` :math:`\globalinst_i` in the original :math:`S.\SGLOBALS`, the new global instance must be an :ref:`extension ` of the old. +* For each :ref:`tag instance ` :math:`\taginst_i` in the original :math:`S.\STAGS`, the new tag instance must be an :ref:`extension ` of the old. + * For each :ref:`element instance ` :math:`\eleminst_i` in the original :math:`S.\SELEMS`, the new element instance must be an :ref:`extension ` of the old. * For each :ref:`data instance ` :math:`\datainst_i` in the original :math:`S.\SDATAS`, the new data instance must be an :ref:`extension ` of the old. @@ -1074,6 +1214,8 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S' * For each :ref:`array instance ` :math:`\arrayinst_i` in the original :math:`S.\SARRAYS`, the new array instance must be an :ref:`extension ` of the old. +* For each :ref:`exception instance ` :math:`\exninst_i` in the original :math:`S.\SEXNS`, the new exception instance must be an :ref:`extension ` of the old. + .. math:: \frac{ \begin{array}{@{}ccc@{}} @@ -1089,6 +1231,9 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S' S_1.\SGLOBALS = \globalinst_1^\ast & S_2.\SGLOBALS = {\globalinst'_1}^\ast~\globalinst_2^\ast & (\vdashglobalinstextends \globalinst_1 \extendsto \globalinst'_1)^\ast \\ + S_1.\STAGS = \taginst_1^\ast & + S_2.\STAGS = {\taginst'_1}^\ast~\taginst_2^\ast & + (\vdashtaginstextends \taginst_1 \extendsto \taginst'_1)^\ast \\ S_1.\SELEMS = \eleminst_1^\ast & S_2.\SELEMS = {\eleminst'_1}^\ast~\eleminst_2^\ast & (\vdasheleminstextends \eleminst_1 \extendsto \eleminst'_1)^\ast \\ @@ -1101,6 +1246,9 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S' S_1.\SARRAYS = \arrayinst_1^\ast & S_2.\SARRAYS = {\arrayinst'_1}^\ast~\arrayinst_2^\ast & (\vdasharrayinstextends \arrayinst_1 \extendsto \arrayinst'_1)^\ast \\ + S_1.\SEXNS = \exninst_1^\ast & + S_2.\SEXNS = {\exninst'_1}^\ast~\exninst_2^\ast & + (\vdashexninstextends \exninst_1 \extendsto \exninst'_1)^\ast \\ \end{array} }{ \vdashstoreextends S_1 \extendsto S_2 @@ -1178,6 +1326,21 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S' } +.. index:: tag instance +.. _extend-taginst: + +:ref:`Tag Instance ` :math:`\taginst` +..................................................... + +* A tag instance must remain unchanged. + +.. math:: + \frac{ + }{ + \vdashtaginstextends \taginst \extendsto \taginst + } + + .. index:: element instance .. _extend-eleminst: @@ -1286,6 +1449,21 @@ a store state :math:`S'` extends state :math:`S`, written :math:`S \extendsto S' } +.. index:: exception instance +.. _extend-exninst: + +:ref:`Exception Instance ` :math:`\exninst` +........................................................... + +* An exception instance must remain unchanged. + +.. math:: + \frac{ + }{ + \vdashexninstextends \exninst \extendsto \exninst + } + + .. index:: ! preservation, ! progress, soundness, configuration, thread, terminal configuration, instantiation, invocation, validity, module .. _soundness-statement: @@ -1317,7 +1495,7 @@ If a :ref:`configuration ` :math:`S;T` is :ref:`valid ` 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. +In other words, every thread in a valid configuration either runs forever, traps, throws an exception, or terminates with a result that has the expected type. Consequently, given a :ref:`valid store `, no computation defined by :ref:`instantiation ` or :ref:`invocation ` of a valid module can "crash" or otherwise (mis)behave in ways not covered by the :ref:`execution ` semantics given in this specification. diff --git a/document/core/binary/instructions.rst b/document/core/binary/instructions.rst index 89a4422811..347565d79e 100644 --- a/document/core/binary/instructions.rst +++ b/document/core/binary/instructions.rst @@ -13,7 +13,7 @@ The only exception are :ref:`structured control instructions ` have varying encodings. For structured instructions, the instruction sequences forming nested blocks are terminated with explicit opcodes for ${:END} and ${:ELSE}. +:ref:`Control instructions ` have varying encodings. For structured instructions, the instruction sequences forming nested blocks are delimited with explicit opcodes for ${:END} and ${:ELSE}. :ref:`Block types ` are encoded in special compressed form, by either the byte ${:0x40} indicating the empty type, as a single :ref:`value type `, or as a :ref:`type index ` encoded as a positive :ref:`signed integer `. @@ -41,8 +41,12 @@ Control Instructions .. _binary-return_call: .. _binary-return_call_ref: .. _binary-return_call_indirect: +.. _binary-throw: +.. _binary-throw_ref: +.. _binary-try_table: +.. _binary-catch: -$${grammar: Bblocktype Binstr/control} +$${grammar: Bblocktype Binstr/control Bcatch} .. note:: The ${:ELSE} opcode ${:0x05} in the encoding of an ${:IF} instruction can be omitted if the following instruction sequence is empty. @@ -100,7 +104,6 @@ Generic :ref:`reference instructions ` are represented by sing $${grammar: {Binstr/ref Binstr/struct Binstr/array Binstr/cast Binstr/extern Binstr/i31} Bcastop} $${syntax-ignore: castop} - .. index:: parametric instruction, value type, polymorphism pair: binary format; instruction .. _binary-instr-parametric: diff --git a/document/core/binary/modules.rst b/document/core/binary/modules.rst index 423c67c673..35631f729a 100644 --- a/document/core/binary/modules.rst +++ b/document/core/binary/modules.rst @@ -9,12 +9,13 @@ except that :ref:`function definitions ` are split into two section This separation enables *parallel* and *streaming* compilation of the functions in a module. -.. index:: index, type index, function index, table index, memory index, global index, element index, data index, local index, label index, field index +.. index:: index, type index, function index, table index, memory index, global index, tag index, element index, data index, local index, label index, field 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; tag index pair: binary format; element index pair: binary format; data index pair: binary format; local index @@ -25,6 +26,7 @@ except that :ref:`function definitions ` are split into two section .. _binary-tableidx: .. _binary-memidx: .. _binary-globalidx: +.. _binary-tagidx: .. _binary-elemidx: .. _binary-dataidx: .. _binary-localidx: @@ -39,7 +41,7 @@ Indices All basic :ref:`indices ` are encoded with their respective value. $${grammar: { - Btypeidx Bfuncidx Btableidx Bmemidx Bglobalidx Belemidx Bdataidx + Btypeidx Bfuncidx Btableidx Bmemidx Bglobalidx Btagidx Belemidx Bdataidx Blocalidx Blabelidx }} @@ -93,6 +95,7 @@ Id Section 10 :ref:`code section ` 11 :ref:`data section ` 12 :ref:`data count section ` +13 :ref:`tag section ` == =============================================== .. note:: @@ -132,7 +135,7 @@ It decodes into the list of :ref:`recursive types ` of a :ref:`m $${grammar: {Btypesec Btype}} -.. index:: ! import section, import, name, function type, table type, memory type, global type +.. index:: ! import section, import, name, function type, table type, memory type, global type, tag type pair: binary format; import pair: section; import .. _binary-import: @@ -157,7 +160,7 @@ Function Section ~~~~~~~~~~~~~~~~ The *function section* has the id 3. -It decodes into a list of :ref:`type indices ` that classify the :ref:`functions ` of a :ref:`module `. +It decodes into a list of :ref:`type indices ` that classify the :ref:`functions ` defined by a :ref:`module `. The bodies of the respective functions are encoded separately in the :ref:`code section `. $${grammar: {Bfuncsec}} @@ -173,7 +176,7 @@ Table Section ~~~~~~~~~~~~~ The *table section* has the id 4. -It decodes into the list of :ref:`tables ` of a :ref:`module `. +It decodes into the list of :ref:`tables ` defined by a :ref:`module `. $${grammar: {Btablesec Btable}} @@ -193,7 +196,7 @@ Memory Section ~~~~~~~~~~~~~~ The *memory section* has the id 5. -It decodes into the list of :ref:`memories ` of a :ref:`module `. +It decodes into the list of :ref:`memories ` defined by a :ref:`module `. $${grammar: {Bmemsec Bmem}} @@ -208,12 +211,12 @@ Global Section ~~~~~~~~~~~~~~ The *global section* has the id 6. -It decodes into the list of :ref:`globals ` of a :ref:`module `. +It decodes into the list of :ref:`globals ` defined by a :ref:`module `. $${grammar: {Bglobalsec Bglobal}} -.. index:: ! export section, export, name, index, function index, table index, memory index, global index +.. index:: ! export section, export, name, index, function index, table index, memory index, tag index, global index pair: binary format; export pair: section; export .. _binary-export: @@ -258,7 +261,7 @@ Element Section ~~~~~~~~~~~~~~~ The *element section* has the id 9. -It decodes into the list of :ref:`element segments ` of a :ref:`module `. +It decodes into the list of :ref:`element segments ` defined by a :ref:`module `. $${grammar: {Belemsec Belemkind Belem}} @@ -285,7 +288,7 @@ Code Section The *code section* has the id 10. It decodes into the list of *code* entries that are pairs of lists of :ref:`locals ` and :ref:`expressions `. -They represent the body of the :ref:`functions ` of a :ref:`module `. +They represent the body of the :ref:`functions ` defined by a :ref:`module `. The types of the respective functions are encoded separately in the :ref:`function section `. The encoding of each code entry consists of @@ -325,7 +328,7 @@ Data Section ~~~~~~~~~~~~ The *data section* has the id 11. -It decodes into the list of :ref:`data segments ` of a :ref:`module `. +It decodes into the list of :ref:`data segments ` defined by a :ref:`module `. $${grammar: {Bdatasec Bdata}} @@ -359,7 +362,22 @@ $${grammar: {Bdatacntsec Bdatacnt}} instead of deferring validation. -.. index:: module, section, type definition, function type, function, table, memory, global, element, data, start function, import, export, context, version +.. index:: ! tag section, tag, tag type, function type index, exception tag + pair: binary format; tag + pair: section; tag +.. _binary-tag: +.. _binary-tagsec: + +Tag Section +~~~~~~~~~~~ + +The *tag section* has the id 13. +It decodes into the list of :ref:`tags ` defined by a :ref:`module `. + +$${grammar: {Btagsec Btag}} + + +.. index:: module, section, type definition, function type, function, table, memory, tag, global, element, data, start function, import, export, context, version pair: binary format; module .. _binary-magic: .. _binary-version: diff --git a/document/core/binary/types.rst b/document/core/binary/types.rst index bf552bc0d5..6763885fae 100644 --- a/document/core/binary/types.rst +++ b/document/core/binary/types.rst @@ -182,6 +182,22 @@ Global Types $${grammar: Bglobaltype} +.. index:: tag type, function type, exception tag + pair: binary format; tag type +.. _binary-tagtype: + +Tag Types +~~~~~~~~~ + +:ref:`Tag types ` are encoded by a :ref:`type index ` denoting a :ref:`function type `. + +$${grammar: Btagtype} + +.. note:: + In future versions of WebAssembly, + the preceding zero byte may encode additional flags. + + .. index:: external type pair: binary format; external type .. _binary-externtype: diff --git a/document/core/exec/conventions.rst b/document/core/exec/conventions.rst index b3701610ac..88e9e0b346 100644 --- a/document/core/exec/conventions.rst +++ b/document/core/exec/conventions.rst @@ -49,7 +49,7 @@ The following conventions are adopted in stating these rules. * Execution can *enter* and *exit* :ref:`instruction sequences ` that form :ref:`blocks `. -* :ref:`Instruction sequences ` are implicitly executed in order, unless a trap or jump occurs. +* :ref:`Instruction sequences ` are implicitly executed in order, unless a trap, jump, or exception occurs. * In various places the rules contain *assertions* expressing crucial invariants about the program state. @@ -103,8 +103,8 @@ The order of reduction is determined by the details of the reduction rules. Usually, the left-most instruction that is not a constant will be the subject of the next reduction *step*. Reduction *terminates* when no more reduction rules are applicable. -:ref:`Soundness ` of the WebAssembly :ref:`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 ` of the resulting operand stack, -or if a :ref:`trap ` occurred. +:ref:`Soundness ` of the WebAssembly :ref:`type system ` guarantees that this is only the case when the original instruction sequence has either been reduced to a sequence of :ref:`value ` instructions, which can be interpreted as the :ref:`values ` of the resulting operand stack, +or if an :ref:`exception ` or :ref:`trap ` occurred. .. note:: For example, the following instruction sequence, diff --git a/document/core/exec/instructions.rst b/document/core/exec/instructions.rst index 4153ac790c..c0cfb0767a 100644 --- a/document/core/exec/instructions.rst +++ b/document/core/exec/instructions.rst @@ -2554,7 +2554,146 @@ $${rule-prose: Step_pure/return_call_indirect} $${rule: {Step_pure/return_call_indirect}} -.. index:: instruction, instruction sequence, block +.. _exec-throw: + +$${rule-prose: exec/throw} + +.. todo:: check prose + +1. Let :math:`F` be the :ref:`current ` :ref:`frame `. + +2. Assert: due to :ref:`validation `, :math:`F.\AMODULE.\MITAGS[x]` exists. + +3. Let :math:`ta` be the :ref:`tag address ` :math:`F.\AMODULE.\MITAGS[x]`. + +4. Assert: due to :ref:`validation `, :math:`S.\STAGS[ta]` exists. + +5. Let :math:`\X{ti}` be the :ref:`tag instance ` :math:`S.\STAGS[ta]`. + +6. Let :math:`[t^n] \toF [{t'}^\ast]` be the :ref:`tag type ` :math:`\X{ti}.\HITYPE`. + +7. Assert: due to :ref:`validation `, there are at least :math:`n` values on the top of the stack. + +8. Pop the :math:`n` values :math:`\val^n` from the stack. + +9. Let :math:`\X{ea}` be the :ref:`exception address ` resulting from :ref:`allocating ` an exception instance with tag address :math:`ta` and initializer values :math:`\val^n`. + +10. Let :math:`\X{exn}` be :math:`S.\SEXNS[ea]` + +11. Push the value :math:`\REFEXNADDR~\X{ea}` to the stack. + +12. Execute the instruction |THROWREF|. + +$${rule: Step/throw} + + +.. _exec-throw_ref: + +$${rule-prose: exec/throw_ref} + +.. todo:: check prose + +1. Let :math:`F` be the :ref:`current ` :ref:`frame `. + +2. Assert: due to :ref:`validation `, a :ref:`reference ` is on the top of the stack. + +3. Pop the reference :math:`\reff` from the stack. + +4. If :math:`\reff` is :math:`\REFNULL~\X{ht}`, then: + + a. Trap. + +5. Assert: due to :ref:`validation `, :math:`\reff` is an :ref:`exception reference `. + +6. Let :math:`\REFEXNADDR~\X{ea}` be :math:`\reff`. + +7. Assert: due to :ref:`validation `, :math:`S.\SEXNS[\X{ea}]` exists. + +8. Let :math:`\X{exn}` be the :ref:`exception instance ` :math:`S.\SEXNS[\X{ea}]`. + +9. Let :math:`a` be the :ref:`tag address ` :math:`\X{exn}.\EITAG`. + +10. While the stack is not empty and the top of the stack is not an :ref:`exception handler `, do: + + a. Pop the top element from the stack. + +11. Assert: the stack is now either empty, or there is an exception handler on the top of the stack. + +12. If the stack is empty, then: + + a. Return the exception :math:`(\REFEXNADDR~a)` as a :ref:`result `. + +13. Assert: there is an :ref:`exception handler ` on the top of the stack. + +14. Pop the exception handler :math:`\HANDLER_n\{\catch^\ast\}` from the stack. + +15. If :math:`\catch^\ast` is empty, then: + + a. Push the exception reference :math:`\REFEXNADDR~\X{ea}` back to the stack. + + b. Execute the instruction |THROWREF| again. + +16. Else: + + a. Let :math:`\catch_1` be the first :ref:`catch clause ` in :math:`\catch^\ast` and :math:`{\catch'}^\ast` the remaining clauses. + + b. If :math:`\catch_1` is of the form :math:`\CATCH~x~l` and the :ref:`tag address ` :math:`a` equals :math:`F.\AMODULE.\MITAGS[x]`, then: + + i. Push the values :math:`\X{exn}.\EIFIELDS` to the stack. + + ii. Execute the instruction :math:`\BR~l`. + + c. Else if :math:`\catch_1` is of the form :math:`\CATCHREF~x~l` and the :ref:`tag address ` :math:`a` equals :math:`F.\AMODULE.\MITAGS[x]`, then: + + i. Push the values :math:`\X{exn}.\EIFIELDS` to the stack. + + ii. Push the exception reference :math:`\REFEXNADDR~\X{ea}` to the stack. + + iii. Execute the instruction :math:`\BR~l`. + + d. Else if :math:`\catch_1` is of the form :math:`\CATCHALL~l`, then: + + i. Execute the instruction :math:`\BR~l`. + + e. Else if :math:`\catch_1` is of the form :math:`\CATCHALLREF~l`, then: + + i. Push the exception reference :math:`\REFEXNADDR~\X{ea}` to the stack. + + ii. Execute the instruction :math:`\BR~l`. + + f. Else: + + 1. Push the modified handler :math:`\HANDLER_n\{{\catch'}^\ast\}` back to the stack. + + 2. Push the exception reference :math:`\REFEXNADDR~\X{ea}` back to the stack. + + 3. Execute the instruction :math:`\THROWREF` again. + +$${rule: Step_read/throw_ref-*} + + +.. _exec-try_table: + +$${rule-prose: exec/try_table} + +.. todo:: check prose + +1. Assert: due to :ref:`validation `, :math:`\fblocktype_{S;F}(\blocktype)` is defined. + +2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`instruction type ` :math:`\fblocktype_{S;F}(\blocktype)`. + +3. Assert: due to :ref:`validation `, there are at least :math:`m` values on the top of the stack. + +4. Pop the values :math:`\val^m` from the stack. + +5. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is the end of the |TRYTABLE| instruction. + +6. :ref:`Enter ` the block :math:`\val^m~\instr_1^\ast` with label :math:`L` and exception handler :math:`\HANDLER_n\{\catch^\ast\}`. + +$${rule: Step_read/try_table} + + +.. index:: instruction, instruction sequence, block, exception, trap .. _exec-instrs: Blocks @@ -2583,7 +2722,7 @@ Entering :math:`\instr^\ast` with label :math:`L` 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. +When the end of a block is reached without a jump, :ref:`exception `, or :ref:`trap ` aborting it, then the following steps are performed. 1. Pop all values :math:`\val^\ast` from the top of the stack. @@ -2598,10 +2737,60 @@ When the end of a block is reached without a jump or trap aborting it, then the $${rule: Step_pure/label-vals} .. note:: - This semantics also applies to the instruction sequence contained in a |LOOP| instruction. + This semantics also applies to the instruction sequence contained in a ${:LOOP} instruction. Therefore, execution of a loop falls off the end, unless a backwards branch is performed explicitly. +.. index:: exception, handler, throw context, tag, exception tag + +.. _exec-handler: + +Exception Handling +~~~~~~~~~~~~~~~~~~ + +The following auxiliary rules define the semantics of entering and exiting ${:TRY_TABLE} blocks. + +.. _exec-handler-enter: + +Entering :math:`\instr^\ast` with label :math:`L` and exception handler :math:`H` +................................................................................. + +1. Push :math:`L` to the stack. + +2. Push :math:`H` onto the stack. + +3. Jump to the start of the instruction sequence :math:`\instr^\ast`. + +.. note:: + No formal reduction rule is needed for entering an exception :ref:`handler ` + because it is an :ref:`administrative instruction ` + that the ${:TRY_TABLE} instruction reduces to directly. + + +.. _exec-handler-exit: + +Exiting an exception handler +............................ + +When the end of a ${:TRY_TABLE} block is reached without a jump, :ref:`exception `, or :ref:`trap `, then the following steps are performed. + +1. Let :math:`m` be the number of values on the top of the stack. + +2. Pop the values :math:`\val^m` from the stack. + +3. Assert: due to :ref:`validation `, a handler and a label are now on the top of the stack. + +4. Pop the label from the stack. + +5. Pop the handler :math:`H` from the stack. + +6. Push :math:`\val^m` back to the stack. + +7. Jump to the position after the |END| of the administrative instruction associated with the handler :math:`H`. + +$${rule: Step_pure/handler-vals} + + .. index:: ! call, function, function instance, label, frame Function Calls @@ -2650,7 +2839,7 @@ $${rule: {Step_read/call_ref-func}} Returning from a function ......................... -When the end of a function 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 (including through |RETURN|), or an :ref:`exception ` or :ref:`trap ` aborting it, then the following steps are performed. 1. Let :math:`F` be the :ref:`current ` :ref:`frame `. @@ -2678,7 +2867,7 @@ Host Functions .............. Invoking a :ref:`host function ` has non-deterministic behavior. -It may either terminate with a :ref:`trap ` or return regularly. +It may either terminate with a :ref:`trap `, an :ref:`exception `, or return regularly. However, in the latter case, it must consume and produce the right number and types of WebAssembly :ref:`values ` on the stack, according to its :ref:`function type `. diff --git a/document/core/exec/modules.rst b/document/core/exec/modules.rst index a34f3a6276..daa361eb60 100644 --- a/document/core/exec/modules.rst +++ b/document/core/exec/modules.rst @@ -10,7 +10,19 @@ For modules, the execution semantics primarily defines :ref:`instantiation `, :ref:`tables `, :ref:`memories `, and :ref:`globals ` are *allocated* in a :ref:`store ` ${:s}, as defined by the following auxiliary functions. +New instances of +:ref:`functions `, +:ref:`tables `, +:ref:`memories `, +:ref:`globals `, +:ref:`tags `, +:ref:`element segments `, and +:ref:`data segments `, +as well as of dynamic data types like +:ref:`structures `, +:ref:`arrays `, or +:ref:`exceptions `, +are *allocated* in a :ref:`store ` ${:s}, as defined by the following auxiliary functions. .. index:: function, function instance, function address, module instance, function type @@ -80,6 +92,58 @@ $${definition: alloctable} $${definition: allocmem} +.. index:: tag, tag instance, tag address, tag type +.. _alloc-tag: + +:ref:`Tags ` +............................ + +1. Let :math:`\tagtype` be the :ref:`tag type ` to allocate. + +2. Let :math:`a` be the first free :ref:`tag address ` in :math:`S`. + +3. Let :math:`\taginst` be the :ref:`tag instance ` :math:`\{ \HITYPE~\tagtype \}`. + +4. Append :math:`\taginst` to the |STAGS| of :math:`S`. + +5. Return :math:`a`. + +.. math:: + \begin{array}{rlll} + \alloctag(S, \tagtype) &=& S', \tagaddr \\[1ex] + \mbox{where:} \hfill \\ + \tagaddr &=& |S.\STAGS| \\ + \taginst &=& \{\HITYPE~\tagtype\} \\ + S' &=& S \compose \{\STAGS~\taginst\} \\ + \end{array} + + +.. index:: exception, exception instance, exception address, tag address +.. _alloc-exception: + +:ref:`Exceptions ` +.................................. + +1. Let :math:`ta` be the :ref:`tag address ` associated with the exception to allocate and :math:`\EIFIELDS~\val^\ast` be the values to initialize the exception with. + +2. Let :math:`a` be the first free :ref:`exception address ` in :math:`S`. + +3. Let :math:`\exninst` be the :ref:`exception instance ` :math:`\{ \EITAG~ta, \EIFIELDS~\val^\ast \}`. + +4. Append :math:`\exninst` to the |SEXNS| of :math:`S`. + +5. Return :math:`a`. + +.. math:: + \begin{array}{rlll} + \allocexn(S, \tagaddr, \val^\ast) &=& S', \exnaddr \\[1ex] + \mbox{where:} \hfill \\ + \exnaddr &=& |S.\SEXNS| \\ + \exninst &=& \{ \EITAG~\tagaddr, \EIFIELDS~\val^\ast \} \\ + S' &=& S \compose \{\SEXNS~\exninst\} \\ + \end{array} + + .. index:: global, global instance, global address, global type, value type, mutability, value .. _alloc-global: @@ -189,7 +253,7 @@ Growing :ref:`memories ` $${definition: growmem} -.. 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 +.. index:: module, module instance, function instance, table instance, memory instance, tag instance, global instance, export instance, function address, table address, memory address, tag address, global address, function index, table index, memory index, tag index, global index, type, function, table, memory, tag, global, import, export, external address, external type, matching .. _alloc-module: :ref:`Modules ` @@ -197,11 +261,11 @@ $${definition: growmem} .. todo:: update prose for types -The allocation function for :ref:`modules ` requires a suitable list of :ref:`external values ` that are assumed to :ref:`match ` the :ref:`import ` list of the module, +The allocation function for :ref:`modules ` requires a suitable list of :ref:`external addresses ` that are assumed to :ref:`match ` the :ref:`import ` list of the module, a list of initialization :ref:`values ` for the module's :ref:`globals `, and list of :ref:`reference ` lists for the module's :ref:`element segments `. -1. Let :math:`\module` be the :ref:`module ` to allocate and :math:`\externval_{\F{im}}^\ast` the list of :ref:`external values ` providing the module's imports, :math:`\val_{\F{g}}^\ast` the initialization :ref:`values ` of the module's :ref:`globals `, :math:`\reff_{\F{t}}^\ast` the initializer :ref:`reference ` of the module's :ref:`tables `, and :math:`(\reff_{\F{e}}^\ast)^\ast` the :ref:`reference ` lists of the module's :ref:`element segments `. +1. Let :math:`\module` be the :ref:`module ` to allocate and :math:`\externaddr_{\F{im}}^\ast` the list of :ref:`external addresses ` providing the module's imports, :math:`\val_{\F{g}}^\ast` the initialization :ref:`values ` of the module's :ref:`globals `, :math:`\reff_{\F{t}}^\ast` the initializer :ref:`reference ` of the module's :ref:`tables `, and :math:`(\reff_{\F{e}}^\ast)^\ast` the :ref:`reference ` lists of the module's :ref:`element segments `. 2. For each :ref:`defined type ` :math:`\deftype'_i` in :math:`\module.\MTYPES`, do: @@ -229,56 +293,68 @@ and list of :ref:`reference ` lists for the module's :ref:`element s b. Let :math:`\globaladdr_i` be the :ref:`global address ` resulting from :ref:`allocating ` :math:`\globaltype_i` with initializer value :math:`\val_{\F{g}}^\ast[i]`. -7. For each :ref:`element segment ` :math:`\elem_i` in :math:`\module.\MELEMS`, do: +7. For each :ref:`tag ` :math:`\tag_i` in :math:`\module.\MTAGS`, do: + + a. Let :math:`\tagtype` be the :ref:`tag type ` :math:`\module.\MTYPES[\tag_i.\TAGTYPE]`. + + b. Let :math:`\tagaddr_i` be the :ref:`tag address ` resulting from :ref:`allocating ` :math:`\tagtype`. + +8. For each :ref:`element segment ` :math:`\elem_i` in :math:`\module.\MELEMS`, do: a. Let :math:`\reftype_i` be the element :ref:`reference type ` obtained by `instantiating ` :math:`\elem_i.\ETYPE` in :math:`\moduleinst` defined below. b. Let :math:`\elemaddr_i` be the :ref:`element address ` resulting from :ref:`allocating ` a :ref:`element instance ` of :ref:`reference type ` :math:`\reftype_i` with contents :math:`(\reff_{\F{e}}^\ast)^\ast[i]`. -8. For each :ref:`data segment ` :math:`\data_i` in :math:`\module.\MDATAS`, do: + +9. For each :ref:`data segment ` :math:`\data_i` in :math:`\module.\MDATAS`, do: a. Let :math:`\dataaddr_i` be the :ref:`data address ` resulting from :ref:`allocating ` a :ref:`data instance ` with contents :math:`\data_i.\DINIT`. -9. Let :math:`\deftype^\ast` be the concatenation of the :ref:`defined types ` :math:`\deftype_i` in index order. +10. Let :math:`\deftype^\ast` be the concatenation of the :ref:`defined types ` :math:`\deftype_i` in index order. + +11. Let :math:`\funcaddr^\ast` be the concatenation of the :ref:`function addresses ` :math:`\funcaddr_i` in index order. + +12. Let :math:`\tableaddr^\ast` be the concatenation of the :ref:`table addresses ` :math:`\tableaddr_i` in index order. -10. Let :math:`\funcaddr^\ast` be the concatenation of the :ref:`function addresses ` :math:`\funcaddr_i` in index order. +13. Let :math:`\memaddr^\ast` be the concatenation of the :ref:`memory addresses ` :math:`\memaddr_i` in index order. -11. Let :math:`\tableaddr^\ast` be the concatenation of the :ref:`table addresses ` :math:`\tableaddr_i` in index order. +14. Let :math:`\globaladdr^\ast` be the concatenation of the :ref:`global addresses ` :math:`\globaladdr_i` in index order. -12. Let :math:`\memaddr^\ast` be the concatenation of the :ref:`memory addresses ` :math:`\memaddr_i` in index order. +15. Let :math:`\tagaddr^\ast` be the concatenation of the :ref:`tag addresses ` :math:`\tagaddr_i` in index order. -13. Let :math:`\globaladdr^\ast` be the concatenation of the :ref:`global addresses ` :math:`\globaladdr_i` in index order. +16. Let :math:`\elemaddr^\ast` be the concatenation of the :ref:`element addresses ` :math:`\elemaddr_i` in index order. -14. Let :math:`\elemaddr^\ast` be the concatenation of the :ref:`element addresses ` :math:`\elemaddr_i` in index order. +17. Let :math:`\dataaddr^\ast` be the concatenation of the :ref:`data addresses ` :math:`\dataaddr_i` in index order. -15. Let :math:`\dataaddr^\ast` be the concatenation of the :ref:`data addresses ` :math:`\dataaddr_i` in index order. +18. Let :math:`\funcaddr_{\F{mod}}^\ast` be the list of :ref:`function addresses ` extracted from :math:`\externaddr_{\F{im}}^\ast`, concatenated with :math:`\funcaddr^\ast`. -16. Let :math:`\funcaddr_{\F{mod}}^\ast` be the list of :ref:`function addresses ` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\funcaddr^\ast`. +19. Let :math:`\tableaddr_{\F{mod}}^\ast` be the list of :ref:`table addresses ` extracted from :math:`\externaddr_{\F{im}}^\ast`, concatenated with :math:`\tableaddr^\ast`. -17. Let :math:`\tableaddr_{\F{mod}}^\ast` be the list of :ref:`table addresses ` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\tableaddr^\ast`. +20. Let :math:`\memaddr_{\F{mod}}^\ast` be the list of :ref:`memory addresses ` extracted from :math:`\externaddr_{\F{im}}^\ast`, concatenated with :math:`\memaddr^\ast`. -18. Let :math:`\memaddr_{\F{mod}}^\ast` be the list of :ref:`memory addresses ` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\memaddr^\ast`. +21. Let :math:`\globaladdr_{\F{mod}}^\ast` be the list of :ref:`global addresses ` extracted from :math:`\externaddr_{\F{im}}^\ast`, concatenated with :math:`\globaladdr^\ast`. -19. Let :math:`\globaladdr_{\F{mod}}^\ast` be the list of :ref:`global addresses ` extracted from :math:`\externval_{\F{im}}^\ast`, concatenated with :math:`\globaladdr^\ast`. +22. Let :math:`\tagaddr_{\F{mod}}^\ast` be the list of :ref:`tag addresses ` extracted from :math:`\externaddr_{\F{im}}^\ast`, concatenated with :math:`\tagaddr^\ast`. -20. For each :ref:`export ` :math:`\export_i` in :math:`\module.\MEXPORTS`, do: +23. For each :ref:`export ` :math:`\export_i` in :math:`\module.\MEXPORTS`, do: - a. If :math:`\export_i` is a function export for :ref:`function index ` :math:`x`, then let :math:`\externval_i` be the :ref:`external value ` :math:`\EVFUNC~(\funcaddr_{\F{mod}}^\ast[x])`. + a. If :math:`\export_i` is a function export for :ref:`function index ` :math:`x`, then let :math:`\externaddr_i` be the :ref:`external address ` :math:`\XAFUNC~(\funcaddr_{\F{mod}}^\ast[x])`. - b. Else, if :math:`\export_i` is a table export for :ref:`table index ` :math:`x`, then let :math:`\externval_i` be the :ref:`external value ` :math:`\EVTABLE~(\tableaddr_{\F{mod}}^\ast[x])`. + b. Else, if :math:`\export_i` is a table export for :ref:`table index ` :math:`x`, then let :math:`\externaddr_i` be the :ref:`external address ` :math:`\XATABLE~(\tableaddr_{\F{mod}}^\ast[x])`. - c. Else, if :math:`\export_i` is a memory export for :ref:`memory index ` :math:`x`, then let :math:`\externval_i` be the :ref:`external value ` :math:`\EVMEM~(\memaddr_{\F{mod}}^\ast[x])`. + c. Else, if :math:`\export_i` is a memory export for :ref:`memory index ` :math:`x`, then let :math:`\externaddr_i` be the :ref:`external address ` :math:`\XAMEM~(\memaddr_{\F{mod}}^\ast[x])`. - d. Else, if :math:`\export_i` is a global export for :ref:`global index ` :math:`x`, then let :math:`\externval_i` be the :ref:`external value ` :math:`\EVGLOBAL~(\globaladdr_{\F{mod}}^\ast[x])`. + d. Else, if :math:`\export_i` is a global export for :ref:`global index ` :math:`x`, then let :math:`\externaddr_i` be the :ref:`external address ` :math:`\XAGLOBAL~(\globaladdr_{\F{mod}}^\ast[x])`. - e. Let :math:`\exportinst_i` be the :ref:`export instance ` :math:`\{\EINAME~(\export_i.\ENAME), \EIVALUE~\externval_i\}`. + e. Else, if :math:`\export_i` is a tag export for :ref:`tag index ` :math:`x`, then let :math:`\externaddr_i` be the :ref:`external address ` :math:`\XATAG~(\tagaddr_{\F{mod}}^\ast[x])`. -21. Let :math:`\exportinst^\ast` be the concatenation of the :ref:`export instances ` :math:`\exportinst_i` in index order. + f. Let :math:`\exportinst_i` be the :ref:`export instance ` :math:`\{\XINAME~(\export_i.\XNAME), \XIADDR~\externaddr_i\}`. -22. Let :math:`\moduleinst` be the :ref:`module instance ` :math:`\{\MITYPES~\deftype^\ast,` :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\}`. +24. Let :math:`\exportinst^\ast` be the concatenation of the :ref:`export instances ` :math:`\exportinst_i` in index order. -23. Return :math:`\moduleinst`. +25. Let :math:`\moduleinst` be the :ref:`module instance ` :math:`\{\MITYPES~\deftype^\ast,` :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:`\MITAGS~\tagaddr_{\F{mod}}^\ast`, :math:`\MIEXPORTS~\exportinst^\ast\}`. +26. Return :math:`\moduleinst`. $${definition: allocmodule} @@ -305,18 +381,18 @@ $${definition: {allocexports allocexport}} -.. index:: ! instantiation, module, instance, store, trap +.. index:: ! instantiation, module, instance, store, trap, exception .. _exec-module: .. _exec-instantiation: Instantiation ~~~~~~~~~~~~~ -Given a :ref:`store ` ${:s}, a ${:module} is instantiated with a list of :ref:`external values ` ${:externval*} supplying the required imports as follows. +Given a :ref:`store ` ${:s}, a ${:module} is instantiated with a list of :ref:`external addresses ` ${:externaddr*} supplying the required imports as follows. Instantiation checks that the module is :ref:`valid ` and the provided imports :ref:`match ` the declared types, and may *fail* with an error otherwise. -Instantiation can also result in a :ref:`trap ` from initializing a table or memory from an active segment or from executing the start function. +Instantiation can also result in an :ref:`exception ` or :ref:`trap ` when initializing a :ref:`table ` or :ref:`memory ` from an :ref:`active segment ` or when executing the :ref:`start ` function. It is up to the :ref:`embedder ` to define how such conditions are reported. 1. If :math:`\module` is not :ref:`valid `, then: @@ -325,13 +401,13 @@ It is up to the :ref:`embedder ` to define how such conditions are rep 2. Assert: :math:`\module` is :ref:`valid ` with :ref:`external types ` :math:`\externtype_{\F{im}}^m` classifying its :ref:`imports `. -3. If the number :math:`m` of :ref:`imports ` is not equal to the number :math:`n` of provided :ref:`external values `, then: +3. If the number :math:`m` of :ref:`imports ` is not equal to the number :math:`n` of provided :ref:`external addresses `, then: a. Fail. -4. For each :ref:`external value ` :math:`\externval_i` in :math:`\externval^n` and :ref:`external type ` :math:`\externtype'_i` in :math:`\externtype_{\F{im}}^n`, do: +4. For each :ref:`external address ` :math:`\externaddr_i` in :math:`\externaddr^n` and :ref:`external type ` :math:`\externtype'_i` in :math:`\externtype_{\F{im}}^n`, do: - a. If :math:`\externval_i` is not :ref:`valid ` with an :ref:`external type ` :math:`\externtype_i` in store :math:`S`, then: + a. If :math:`\externaddr_i` is not :ref:`valid ` with an :ref:`external type ` :math:`\externtype_i` in store :math:`S`, then: i. Fail. @@ -347,7 +423,7 @@ It is up to the :ref:`embedder ` to define how such conditions are rep 7. Push the frame :math:`F` to the stack. -8. Let :math:`\val_{\F{g}}^\ast` be the list of :ref:`global ` initialization :ref:`values ` determined by :math:`\module` and :math:`\externval^n`. These may be calculated as follows. +8. Let :math:`\val_{\F{g}}^\ast` be the list of :ref:`global ` initialization :ref:`values ` determined by :math:`\module` and :math:`\externaddr^n`. These may be calculated as follows. a. For each :ref:`global ` :math:`\global_i` in :math:`\module.\MGLOBALS`, do: @@ -357,7 +433,7 @@ It is up to the :ref:`embedder ` to define how such conditions are rep c. Let :math:`\val_{\F{g}}^\ast` be the concatenation of :math:`\val_{\F{g}i}` in index order. -9. Let :math:`\reff_{\F{t}}^\ast` be the list of :ref:`table ` initialization :ref:`references ` determined by :math:`\module` and :math:`\externval^n`. These may be calculated as follows. +9. Let :math:`\reff_{\F{t}}^\ast` be the list of :ref:`table ` initialization :ref:`references ` determined by :math:`\module` and :math:`\externaddr^n`. These may be calculated as follows. a. For each :ref:`table ` :math:`\table_i` in :math:`\module.\MTABLES`, do: @@ -381,7 +457,7 @@ It is up to the :ref:`embedder ` to define how such conditions are rep c. Let :math:`(\reff_{\F{e}}^\ast)^\ast` be the concatenation of function element lists :math:`\reff^\ast_i` in order of index :math:`i`. -11. Let :math:`\moduleinst` be a new module instance :ref:`allocated ` from :math:`\module` in store :math:`S` with imports :math:`\externval^n`, global initializer values :math:`\val_{\F{g}}^\ast`, table initializer values :math:`\reff_{\F{t}}^\ast`, and element segment contents :math:`(\reff_{\F{e}}^\ast)^\ast`, and let :math:`S'` be the extended store produced by module allocation. +11. Let :math:`\moduleinst` be a new module instance :ref:`allocated ` from :math:`\module` in store :math:`S` with imports :math:`\externaddr^n`, global initializer values :math:`\val_{\F{g}}^\ast`, table initializer values :math:`\reff_{\F{t}}^\ast`, and element segment contents :math:`(\reff_{\F{e}}^\ast)^\ast`, and let :math:`S'` be the extended store produced by module allocation. 12. For each :ref:`element segment ` :math:`\elem_i` in :math:`\module.\MELEMS` whose :ref:`mode ` is of the form :math:`\EACTIVE~\{ \ETABLE~\tableidx_i, \EOFFSET~\X{einstr}^\ast_i~\END \}`, do: @@ -458,7 +534,7 @@ $${definition: runelem_ rundata_} :ref:`Evaluation ` of :ref:`constant expressions ` does not affect the store. -.. index:: ! invocation, module, module instance, function, export, function address, function instance, function type, value, stack, trap, store +.. index:: ! invocation, module, module instance, function, export, function address, function instance, function type, value, stack, trap, exception, store .. _exec-invocation: Invocation @@ -467,11 +543,11 @@ Invocation Once a :ref:`module ` has been :ref:`instantiated `, any exported function can be *invoked* externally via its :ref:`function address ` ${:funcaddr} in the :ref:`store ` ${:s} and an appropriate list ${:val*} of argument :ref:`values `. Invocation may *fail* with an error if the arguments do not fit the :ref:`function type `. -Invocation can also result in a :ref:`trap `. +Invocation can also result in an :ref:`exception ` or :ref:`trap `. It is up to the :ref:`embedder ` to define how such conditions are reported. .. note:: - If the :ref:`embedder ` API performs type checks itself, either statically or dynamically, before performing an invocation, then no failure other than traps can occur. + If the :ref:`embedder ` API performs type checks itself, either statically or dynamically, before performing an invocation, then no failure other than traps or exceptions can occur. The following steps are performed: diff --git a/document/core/exec/runtime.rst b/document/core/exec/runtime.rst index 08fbad90d5..ba97142c0d 100644 --- a/document/core/exec/runtime.rst +++ b/document/core/exec/runtime.rst @@ -16,6 +16,7 @@ Runtime Structure .. _syntax-ref.i31num: .. _syntax-ref.struct: .. _syntax-ref.array: +.. _syntax-ref.exn: .. _syntax-ref.host: .. _syntax-ref.extern: .. _syntax-val: @@ -36,6 +37,7 @@ They either are *scalar references*, containing a 31-bit :ref:`integer `, *array references*, pointing to a specific :ref:`array address `, *function references*, pointing to a specific :ref:`function address `, +*exception references*, pointing to a specific :ref:`exception address `, or *host references* pointing to an uninterpreted form of :ref:`host address ` defined by the :ref:`embedder `. Any of the aformentioned references can furthermore be wrapped up as an *external reference*. @@ -59,7 +61,7 @@ Convention * The meta variable ${ref: r} ranges over reference values where clear from context. -.. index:: ! result, value, trap +.. index:: ! result, value, trap, exception, exception address pair: abstract syntax; result .. _syntax-result: @@ -67,12 +69,12 @@ Results ~~~~~~~ A *result* is the outcome of a computation. -It is either a sequence of :ref:`values ` or a :ref:`trap `. +It is either a sequence of :ref:`values `, an :ref:`exception `, or a :ref:`trap `. $${syntax: result} -.. index:: ! store, type instance, function instance, table instance, memory instance, global instance, module, allocation, structure instance, array instance +.. index:: ! store, type instance, function instance, table instance, memory instance, global instance, tag instance, module, allocation, structure instance, array instance, exception instance pair: abstract syntax; store .. _syntax-store: .. _store: @@ -81,7 +83,19 @@ 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 `, :ref:`tables `, :ref:`memories `, and :ref:`globals `, :ref:`element segments `, :ref:`data segments `, and :ref:`structures ` or :ref:`arrays ` that have been :ref:`allocated ` during the life time of the abstract machine. [#gc]_ +It consists of the runtime representation of all *instances* of +:ref:`functions `, +:ref:`tables `, +:ref:`memories `, +:ref:`globals `, +:ref:`tags `, +:ref:`element segments `, +:ref:`data segments `, +and +:ref:`structures `, +:ref:`arrays ` or +:ref:`exceptions ` +that have been :ref:`allocated ` during the life time of the abstract machine. [#gc]_ It is an invariant of the semantics that no element or data instance is :ref:`addressed ` from anywhere else but the owning module instances. @@ -90,7 +104,7 @@ Syntactically, the store is defined as a :ref:`record ` listing $${syntax: store} .. [#gc] - In practice, implementations may apply techniques like garbage collection to remove objects from the store that are no longer referenced. + In practice, implementations may apply techniques like garbage collection or reference counting 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. @@ -101,32 +115,38 @@ Convention * The meta variable ${store: s} ranges over stores where clear from context. -.. index:: ! address, store, function instance, table instance, memory instance, global instance, element instance, data instance, structure instance, array instance, embedder, host +.. index:: ! address, store, function instance, table instance, memory instance, global instance, tag instance, element instance, data instance, structure instance, array instance, exception instance, embedder, host pair: abstract syntax; function address pair: abstract syntax; table address pair: abstract syntax; memory address pair: abstract syntax; global address + pair: abstract syntax; tag address pair: abstract syntax; element address pair: abstract syntax; data address pair: abstract syntax; structure address pair: abstract syntax; array address + pair: abstract syntax; exception address pair: abstract syntax; host address pair: function; address pair: table; address pair: memory; address pair: global; address + pair: tag; address pair: element; address pair: data; address pair: structure; address pair: array; address + pair: exception; address pair: host; address .. _syntax-funcaddr: .. _syntax-tableaddr: .. _syntax-memaddr: .. _syntax-globaladdr: +.. _syntax-tagaddr: .. _syntax-elemaddr: .. _syntax-dataaddr: .. _syntax-structaddr: +.. _syntax-exnaddr: .. _syntax-arrayaddr: .. _syntax-hostaddr: .. _syntax-addr: @@ -134,11 +154,22 @@ Convention Addresses ~~~~~~~~~ -:ref:`Function instances `, :ref:`table instances `, :ref:`memory instances `, and :ref:`global instances `, :ref:`element instances `, :ref:`data instances ` and :ref:`structure ` or :ref:`array instances ` in the :ref:`store ` are referenced with abstract *addresses*. +:ref:`Function instances `, +:ref:`table instances `, +:ref:`memory instances `, +:ref:`global instances `, +:ref:`tag instances `, +:ref:`element instances `, +:ref:`data instances ` +and +:ref:`structure `, +:ref:`array instances ` or +:ref:`exception instances ` +in the :ref:`store ` are referenced with abstract *addresses*. These are simply indices into the respective store component. In addition, an :ref:`embedder ` may supply an uninterpreted set of *host addresses*. -$${syntax: {addr funcaddr tableaddr memaddr globaladdr elemaddr dataaddr structaddr arrayaddr hostaddr}} +$${syntax: {addr funcaddr tableaddr memaddr globaladdr tagaddr elemaddr dataaddr structaddr arrayaddr hostaddr}} An :ref:`embedder ` may assign identity to :ref:`exported ` store objects corresponding to their addresses, even where this identity is not observable from within WebAssembly code itself @@ -159,6 +190,7 @@ even where this identity is not observable from within WebAssembly code itself .. _free-tableaddr: .. _free-memaddr: .. _free-globaladdr: +.. _free-tagaddr: .. _free-elemaddr: .. _free-dataaddr: .. _free-structaddr: @@ -173,8 +205,28 @@ Conventions * The notation ${:$addr(A)} denotes the set of addresses from address space ${:addr} occurring free in ${:A}. We sometimes reinterpret this set as the :ref:`list ` of its elements. +.. index:: ! external address, function address, table address, memory address, global address, tag address, store, function, table, memory, global, tag, instruction type + pair: abstract syntax; external address + pair: external; address +.. _syntax-externaddr: -.. index:: ! instance, function type, type instance, function instance, table instance, memory instance, global instance, element instance, data instance, export instance, table address, memory address, global address, element address, data address, index, name +External Addresses +~~~~~~~~~~~~~~~~~~ + +An *external address* is the runtime :ref:`address ` of an entity that can be imported or exported. +It is an :ref:`address ` denoting either a +:ref:`function instance `, +:ref:`global instances `, +:ref:`table instance `, +:ref:`memory instance `, or +:ref:`tag instances ` +in the shared :ref:`store `. + +$${syntax: externaddr} + + + +.. index:: ! instance, function type, type instance, function instance, table instance, memory instance, global instance, tag instance, element instance, data instance, export instance, table address, memory address, global address, tag address, element address, data address, index, name pair: abstract syntax; module instance pair: module; instance .. _syntax-moduleinst: @@ -189,7 +241,12 @@ and collects runtime representations of all entities that are imported, defined, $${syntax: moduleinst} 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 `. -:ref:`Function instances `, :ref:`table instances `, :ref:`memory instances `, and :ref:`global instances ` are referenced with an indirection through their respective :ref:`addresses ` in the :ref:`store `. +:ref:`Function instances `, +:ref:`table instances `, +:ref:`memory instances `, +:ref:`global instances `, and +:ref:`tag instances ` +are referenced with an indirection through their respective :ref:`addresses ` in the :ref:`store `. It is an invariant of the semantics that all :ref:`export instances ` in a given module instance have different :ref:`names `. @@ -278,6 +335,20 @@ The value of mutable globals can be mutated through :ref:`variable instructions It is an invariant of the semantics that the value has a type :ref:`matching ` the :ref:`value type ` of ${:globaltype}. +.. index:: ! tag instance, tag, exception tag, tag type + pair: abstract syntax; tag instance + pair: tag; instance +.. _syntax-taginst: + +Tag Instances +~~~~~~~~~~~~~ + +A *tag instance* is the runtime representation of a :ref:`tag ` definition. +It records the :ref:`defined type ` of the tag. + +$${syntax: taginst} + + .. index:: ! element instance, element segment, embedder, element expression pair: abstract syntax; element instance pair: element; instance @@ -306,7 +377,7 @@ It holds a list of :ref:`bytes `. $${syntax: datainst} -.. index:: ! export instance, export, name, external value +.. index:: ! export instance, export, name, external address pair: abstract syntax; export instance pair: export; instance .. _syntax-exportinst: @@ -315,32 +386,18 @@ Export Instances ~~~~~~~~~~~~~~~~ An *export instance* is the runtime representation of an :ref:`export `. -It defines the export's :ref:`name ` and the associated :ref:`external value `. +It defines the export's :ref:`name ` and the associated :ref:`external address `. $${syntax: exportinst} -.. index:: ! external value, function address, table address, memory address, global address, store, function, table, memory, global, instruction type - pair: abstract syntax; external value - pair: external; value -.. _syntax-externval: - -External Values -~~~~~~~~~~~~~~~ - -An *external value* is the runtime representation of an entity that can be imported or exported. -It is an :ref:`address ` denoting either a :ref:`function instance `, :ref:`table instance `, :ref:`memory instance `, or :ref:`global instances ` in the shared :ref:`store `. - -$${syntax: externval} - - Conventions ........... -The following auxiliary notation is defined for sequences of external values. +The following auxiliary notation is defined for sequences of external addresses. It filters out entries of a specific kind in an order-preserving fashion: -$${definition: funcsxv tablesxv memsxv globalsxv} +$${definition: funcsxa tablesxa memsxa globalsxa tagsxa} .. index:: ! structure instance, ! array instance, structure type, array type, defined type, ! field value, ! packed value @@ -381,21 +438,38 @@ Conventions $${definition: unpackfield_} -.. index:: ! stack, ! frame, ! label, instruction, store, activation, function, call, ! call frame, local, module instance +.. index:: ! exception instance, tag, tag address, value + pair: abstract syntax; exception instance + pair: exception; instance +.. _syntax-exninst: + +Exception Instances +~~~~~~~~~~~~~~~~~~~ + +An *exception instance* is the runtime representation of an :ref:`exception ` produced by a ${:THROW} instruction. +It holds the :ref:`address ` of the respective :ref:`tag ` and the argument :ref:`values `. + +$${syntax: exninst} + + +.. index:: ! stack, ! frame, ! label, ! handler, instruction, store, activation, function, call, ! call frame, local, exception, module instance pair: abstract syntax; frame pair: abstract syntax; label + pair: abstract syntax; handler .. _syntax-frame: .. _syntax-callframe: .. _syntax-label: +.. _syntax-handler: .. _frame: .. _label: +.. _handler: .. _stack: Stack ~~~~~ Besides the :ref:`store `, most :ref:`instructions ` interact with an implicit *stack*. -The stack contains three kinds of entries: +The stack contains the following kinds of entries: * *Values*: the *operands* of instructions. @@ -403,6 +477,8 @@ The stack contains three kinds of entries: * *Frames*: the *call frames* of active :ref:`function ` calls. +* *Handlers*: active exception handlers. + 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. @@ -449,6 +525,19 @@ $${syntax: {callframe frame}} Locals may be uninitialized, in which case they are empty. Locals are mutated by respective :ref:`variable instructions `. +Exception Handlers +.................. + +Exception handlers are installed by |TRYTABLE| instructions and record the corresponding list of :ref:`catch clauses `: + +.. math:: + \begin{array}{llllll} + \production{handler} & \handler &::=& + \HANDLER_n\{\catch^\ast\} + \end{array} + +The handlers on the stack are searched when an exception is :ref:`thrown `. + .. _aux-blocktype: @@ -459,12 +548,14 @@ Conventions * The meta variable ${:f} ranges over frame states where clear from context. +* The meta variable :math:`H` ranges over exception handlers where clear from context. + * The following auxiliary definition takes a :ref:`block type ` and looks up the :ref:`instruction type ` that it denotes in the current frame: $${definition: blocktype_} -.. index:: ! administrative instructions, function, function instance, function address, label, frame, instruction, trap, call, memory, memory instance, table, table instance, element, data, segment +.. index:: ! administrative instructions, function, function instance, function address, label, frame, instruction, trap, call, memory, memory instance, table, table instance, element, data, segment, tag, tag instance, tag address, exception, reftype, handler, caught, caught exception pair:: abstract syntax; administrative instruction .. _syntax-trap: .. _syntax-instr-admin: @@ -475,13 +566,13 @@ Administrative Instructions .. note:: This section is only relevant for the :ref:`formal notation `. -In order to express the reduction of :ref:`traps `, :ref:`calls `, and :ref:`control instructions `, the syntax of instructions is extended to include the following *administrative instructions*: +In order to express the reduction of :ref:`traps `, :ref:`calls `, :ref:`exception handling `, and :ref:`control instructions `, the syntax of instructions is extended to include the following *administrative instructions*: $${syntax: {instr/admin}} An :ref:`address reference ` represents an allocated :ref:`reference ` value of respective form :ref:`"on the stack" `. -The ${:LABEL} and ${:FRAME} instructions model :ref:`labels ` and :ref:`frames ` :ref:`"on the stack" `. +The ${:LABEL}, ${:FRAME}, and ${:HANDLER} instructions model :ref:`labels `, :ref:`frames `, and active :ref:`exception handlers `, respectively, :ref:`"on the stack" `. Moreover, the administrative syntax maintains the nesting structure of the original :ref:`structured control instruction ` or :ref:`function body ` and their :ref:`instruction sequences `. The ${:TRAP} instruction represents the occurrence of a trap. @@ -504,7 +595,7 @@ Traps are bubbled up through nested instruction sequences, ultimately reducing t Validation guarantees that ${:n} matches the number ${:|val*|} of resulting values at this point. -.. index:: ! configuration, !state, ! thread, store, frame, instruction, module instruction +.. index:: ! configuration, ! state, ! thread, store, frame, instruction, module instruction .. _syntax-state: .. _syntax-thread: .. _syntax-config: diff --git a/document/core/exec/values.rst b/document/core/exec/values.rst index cdf1a640db..97b35f01be 100644 --- a/document/core/exec/values.rst +++ b/document/core/exec/values.rst @@ -10,7 +10,7 @@ Values Value Typing ~~~~~~~~~~~~ -For the purpose of checking argument :ref:`values ` against the parameter types of exported :ref:`functions `, +For the purpose of checking argument :ref:`values ` against the parameter types of exported :ref:`functions `, values are classified by :ref:`value types `. The following auxiliary typing rules specify this typing relation relative to a :ref:`store ` :math:`S` in which possibly referenced addresses live. @@ -130,6 +130,23 @@ The following auxiliary typing rules specify this typing relation relative to a } +.. _valid-ref.exn: + +:ref:`Exception References ` :math:`\REFEXNADDR~a` +.............................................................. + +* The store entry :math:`S.\SEXNS[a]` must exist. + +* Then the value is valid with :ref:`reference type ` :math:`\EXNREF`. + +.. math:: + \frac{ + S.\SEXNS[a] = \exninst + }{ + S \vdashval \REFEXNADDR : \EXNREF + } + + :ref:`Function References ` :math:`\REFFUNCADDR~a` .............................................................. @@ -207,100 +224,91 @@ Subsumption } -.. index:: external value, external type, validation, import, store -.. _valid-externval: +.. index:: external address, external type, validation, import, store +.. _valid-externaddr: External Typing ~~~~~~~~~~~~~~~ -For the purpose of checking :ref:`external values ` against :ref:`imports `, +For the purpose of checking :ref:`external address ` against :ref:`imports `, such values are classified by :ref:`external types `. The following auxiliary typing rules specify this typing relation relative to a :ref:`store ` :math:`S` in which the referenced instances live. .. index:: function type, function address -.. _valid-externval-func: +.. _valid-externaddr-func: -:math:`\EVFUNC~a` +:math:`\XAFUNC~a` ................. * The store entry :math:`S.\SFUNCS[a]` must exist. -* Then :math:`\EVFUNC~a` is valid with :ref:`external type ` :math:`\ETFUNC~S.\SFUNCS[a].\FITYPE`. +* Then :math:`\XAFUNC~a` is valid with :ref:`external type ` :math:`\XTFUNC~S.\SFUNCS[a].\FITYPE`. -.. math:: - \frac{ - }{ - S \vdashexternval \EVFUNC~a : \ETFUNC~S.\SFUNCS[a].\FITYPE - } +$${rule: Externaddr_type/func} .. index:: table type, table address -.. _valid-externval-table: +.. _valid-externaddr-table: -:math:`\EVTABLE~a` +:math:`\XATABLE~a` .................. * The store entry :math:`S.\STABLES[a]` must exist. -* Then :math:`\EVTABLE~a` is valid with :ref:`external type ` :math:`\ETTABLE~S.\STABLES[a].\TITYPE`. +* Then :math:`\XATABLE~a` is valid with :ref:`external type ` :math:`\XTTABLE~S.\STABLES[a].\TITYPE`. -.. math:: - \frac{ - }{ - S \vdashexternval \EVTABLE~a : \ETTABLE~S.\STABLES[a].\TITYPE - } +$${rule: Externaddr_type/table} .. index:: memory type, memory address -.. _valid-externval-mem: +.. _valid-externaddr-mem: -:math:`\EVMEM~a` +:math:`\XAMEM~a` ................ * The store entry :math:`S.\SMEMS[a]` must exist. -* Then :math:`\EVMEM~a` is valid with :ref:`external type ` :math:`\ETMEM~S.\SMEMS[a].\MITYPE`. +* Then :math:`\XAMEM~a` is valid with :ref:`external type ` :math:`\XTMEM~S.\SMEMS[a].\MITYPE`. -.. math:: - \frac{ - }{ - S \vdashexternval \EVMEM~a : \ETMEM~S.\SMEMS[a].\MITYPE - } +$${rule: Externaddr_type/mem} .. index:: global type, global address, value type, mutability -.. _valid-externval-global: +.. _valid-externaddr-global: -:math:`\EVGLOBAL~a` +:math:`\XAGLOBAL~a` ................... * The store entry :math:`S.\SGLOBALS[a]` must exist. -* Then :math:`\EVGLOBAL~a` is valid with :ref:`external type ` :math:`\ETGLOBAL~S.\SGLOBALS[a].\GITYPE`. +* Then :math:`\XAGLOBAL~a` is valid with :ref:`external type ` :math:`\XTGLOBAL~S.\SGLOBALS[a].\GITYPE`. + +$${rule: Externaddr_type/global} + + +.. index:: tag type, tag address, exception tag, function type +.. _valid-externaddr-tag: + +:math:`\XATAG~a` +................ + +* The store entry :math:`S.\STAGS[a]` must exist. + +* Let :math:`\tagtype` be the function type :math:`S.\STAGS[a].\HITYPE`. + +* Then :math:`\XATAG~a` is valid with :ref:`external type ` :math:`\XTTAG~\tagtype`. + +$${rule: Externaddr_type/tag} -.. math:: - \frac{ - }{ - S \vdashexternval \EVGLOBAL~a : \ETGLOBAL~S.\SGLOBALS[a].\GITYPE - } Subsumption ........... -* The external value must be valid with some external type :math:`\X{et}`. +* The external address must be valid with some external type :math:`\X{et}`. * The external type :math:`\X{et}` :ref:`matches ` another :ref:`valid ` type :math:`\X{et'}`. -* Then the external value is valid with type :math:`\X{et'}`. +* Then the external address is valid with type :math:`\X{et'}`. -.. math:: - \frac{ - S \vdashexternval \externval : \X{et} - \qquad - \vdashexterntype \X{et'} : \OKexterntype - \qquad - \vdashexterntypematch \X{et} \subexterntypematch \X{et'} - }{ - S \vdashexternval \externval : \X{et'} - } +$${rule: Externaddr_type/sub} diff --git a/document/core/syntax/instructions.rst b/document/core/syntax/instructions.rst index 1a5beb9c29..7617d080bd 100644 --- a/document/core/syntax/instructions.rst +++ b/document/core/syntax/instructions.rst @@ -356,7 +356,7 @@ The ${:DATA.DROP} instruction prevents further use of a passive data segment. Th This restriction may be lifted in future versions. -.. index:: ! control instruction, ! structured control, ! label, ! block, ! block type, ! branch, ! unwinding, stack type, label index, function index, type index, list, trap, function, table, function type, value type, type index +.. index:: ! control instruction, ! structured control, ! exception, ! label, ! block, ! block type, ! branch, ! unwinding, stack type, label index, function index, type index, list, trap, function, table, tag, function type, value type, tag type, try block, type index pair: abstract syntax; instruction pair: abstract syntax; block type pair: block; type @@ -378,15 +378,20 @@ The ${:DATA.DROP} instruction prevents further use of a passive data segment. Th .. _syntax-call_indirect: .. _syntax-instrs: .. _syntax-instr-control: +.. _syntax-throw: +.. _syntax-throw_ref: +.. _syntax-try_table: +.. _syntax-catch: +.. _exception: Control Instructions ~~~~~~~~~~~~~~~~~~~~ Instructions in this group affect the flow of control. -$${syntax: blocktype {instr/block instr/br instr/call}} +$${syntax: blocktype {instr/block instr/br instr/call instr/exn} catch} -The ${:BLOCK}, ${:LOOP} and ${:IF} instructions are *structured* instructions. +The ${:BLOCK}, ${:LOOP}, ${:IF} and ${:TRY_TABLE} instructions are *structured* instructions. They bracket nested sequences of instructions, called *blocks*, terminated with, or separated by, ${:END} or ${:ELSE} pseudo-instructions. As the grammar prescribes, they must be well-nested. @@ -434,6 +439,10 @@ The ${:RETURN_CALL}, ${:RETURN_CALL_REF}, and ${:RETURN_CALL_INDIRECT} instructi That is, they first return from the current function before actually performing the respective call. It is guaranteed that no sequence of nested calls using only these instructions can cause resource exhaustion due to hitting an :ref:`implementation's limit ` on the number of active calls. +The instructions ${:THROW}, ${:THROW_REF}, and ${:TRY_TABLE} are concerned with *exceptions*. +The ${:THROW} and ${:THROW_REF} instructions raise and reraise an exception, respectively, and transfers control to the innermost enclosing exception handler that has a matching catch clause. +The ${:TRY_TABLE} instruction installs an exception *handler* that handles exceptions as specified by its catch clauses. + .. index:: ! expression, constant, global, offset, element, data, instruction pair: abstract syntax; expression diff --git a/document/core/syntax/modules.rst b/document/core/syntax/modules.rst index 68b3352122..abdd00b8cf 100644 --- a/document/core/syntax/modules.rst +++ b/document/core/syntax/modules.rst @@ -1,4 +1,4 @@ -.. index:: ! module, type definition, function type, function, table, memory, global, element, data, start function, import, export +.. index:: ! module, type definition, function type, tag type, function, table, memory, tag, global, element, data, start function, import, export pair: abstract syntax; module .. _syntax-module: @@ -7,21 +7,31 @@ Modules WebAssembly programs are organized into *modules*, which are the unit of deployment, loading, and compilation. -A module collects definitions for :ref:`types `, :ref:`functions `, :ref:`tables `, :ref:`memories `, and :ref:`globals `. -In addition, it can declare :ref:`imports ` and :ref:`exports ` -and provide initialization in the form of :ref:`data ` and :ref:`element ` segments, or a :ref:`start function `. +A module collects definitions for +:ref:`types `, +:ref:`functions `, +:ref:`tables `, +:ref:`memories `, +:ref:`tags `, and +:ref:`globals `. +In addition, it can declare +:ref:`imports ` and :ref:`exports ` +and provide initialization in the form of +:ref:`data ` and :ref:`element ` segments, +or a :ref:`start function `. $${syntax: module} Each of the lists --- 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, ! element index, ! data index, ! field index, function, global, table, memory, element, data, local, parameter, import, field +.. index:: ! index, ! index space, ! type index, ! function index, ! table index, ! memory index, ! global index, ! tag index, ! local index, ! label index, ! element index, ! data index, ! field index, function, global, table, memory, tag, element, data, local, parameter, import, field pair: abstract syntax; type index pair: abstract syntax; function index pair: abstract syntax; table index pair: abstract syntax; memory index pair: abstract syntax; global index + pair: abstract syntax; tag index pair: abstract syntax; element index pair: abstract syntax; data index pair: abstract syntax; local index @@ -32,6 +42,7 @@ Each of the lists --- and thus the entire module --- may be empty. pair: table; index pair: memory; index pair: global; index + pair: tag; index pair: element; index pair: data; index pair: local; index @@ -43,6 +54,7 @@ Each of the lists --- and thus the entire module --- may be empty. .. _syntax-tableidx: .. _syntax-memidx: .. _syntax-globalidx: +.. _syntax-tagidx: .. _syntax-elemidx: .. _syntax-dataidx: .. _syntax-localidx: @@ -56,9 +68,15 @@ Indices Definitions are referenced with zero-based *indices*. Each class of definition has its own *index space*, as distinguished by the following classes. -$${syntax: {typeidx funcidx globalidx tableidx memidx elemidx dataidx labelidx localidx fieldidx}} +$${syntax: {typeidx funcidx globalidx tableidx memidx tagidx elemidx dataidx labelidx localidx fieldidx}} -The index space for :ref:`functions `, :ref:`tables `, :ref:`memories ` and :ref:`globals ` includes respective :ref:`imports ` declared in the same module. +The index space for +:ref:`functions `, +:ref:`tables `, +:ref:`memories `, +:ref:`globals `, and +:ref:`tags ` +includes respective :ref:`imports ` declared in the same module. The indices of these imports precede the indices of other definitions in the same index space. Element indices reference :ref:`element segments ` and data indices reference :ref:`data segments `. @@ -82,6 +100,7 @@ Conventions .. _free-tableidx: .. _free-memidx: .. _free-globalidx: +.. _free-tagidx: .. _free-elemidx: .. _free-dataidx: .. _free-localidx: @@ -198,6 +217,23 @@ Globals are referenced through :ref:`global indices `, starting with the smallest index not referencing a global :ref:`import `. +.. index:: ! tag, type index, tag type + pair: abstract syntax; tag +.. _syntax-tag: + +Tags +~~~~ + +The ${:tag} section of a module defines a list of *tags*: + +$${syntax: tag} + +The :ref:`type index ` of a tag must refer to a :ref:`function type ` that declares its :ref:`tag type `. + +Tags are referenced through :ref:`tag indices `, +starting with the smallest index not referencing a tag :ref:`import `. + + .. index:: ! element, ! element mode, ! active, ! passive, ! declarative, element index, table, table index, expression, constant, function index, list pair: abstract syntax; element pair: abstract syntax; element mode @@ -264,13 +300,14 @@ $${syntax: start} The module and its exports are not accessible externally before this initialization has completed. -.. index:: ! export, name, index, external index, function index, table index, memory index, global index, function, table, memory, global, instantiation +.. index:: ! export, name, index, external index, function index, table index, memory index, global index, tag index, function, table, memory, global, tag, instantiation pair: abstract syntax; export pair: abstract syntax; external index single: function; export single: table; export single: memory; export single: global; export + single: tag; export .. _syntax-exportdesc: .. _syntax-export: .. _syntax-externidx: @@ -283,7 +320,12 @@ The ${:export} section of a module defines a set of *exports* that become access $${syntax: export externidx} Each export is labeled by a unique :ref:`name `. -Exportable definitions are :ref:`functions `, :ref:`tables `, :ref:`memories `, and :ref:`globals `, +Exportable definitions are +:ref:`functions `, +:ref:`tables `, +:ref:`memories `, +:ref:`globals `, and +:ref:`tags `, which are referenced through a respective index. @@ -292,15 +334,16 @@ Conventions The following auxiliary notation is defined for sequences of exports, filtering out indices of a specific kind in an order-preserving fashion: -$${definition: funcsxx tablesxx memsxx globalsxx} +$${definition: funcsxx tablesxx memsxx globalsxx tagsxx} -.. 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 +.. index:: ! import, name, function type, table type, memory type, global type, tag type, index, index space, type index, function index, table index, memory index, global index, tag index, function, table, memory, tag, global, instantiation pair: abstract syntax; import single: function; import single: table; import single: memory; import single: global; import + single: tag; import .. _syntax-importdesc: .. _syntax-import: @@ -312,8 +355,13 @@ The ${:import} section of a module defines a set of *imports* that are required $${syntax: import} Each import is labeled by a two-level :ref:`name ` space, consisting of a *module name* and an *item name* for an entity within that module. -Importable definitions are :ref:`functions `, :ref:`tables `, :ref:`memories `, and :ref:`globals `. -Each import is specified by a descriptor with a respective type that a definition provided during instantiation is required to match. +Importable definitions are +:ref:`functions `, +:ref:`tables `, +:ref:`memories `, +:ref:`globals `, and +:ref:`tags `. +Each import is specified by a respective :ref:`external type ` that a definition provided during instantiation is required to match. Every import defines an index in the respective :ref:`index space `. In each index space, the indices of imports go before the first index of any definition contained in the module itself. diff --git a/document/core/syntax/types.rst b/document/core/syntax/types.rst index 4f149586ce..f3c0d7c6b7 100644 --- a/document/core/syntax/types.rst +++ b/document/core/syntax/types.rst @@ -103,6 +103,11 @@ The type ${:FUNC} denotes the common supertype of all :ref:`function types `, regardless of their concrete definition. This type has no values. +The type ${:EXN} denotes the common supertype of all :ref:`exception references `. +This type has no concrete subtypes. +Dually, the type ${:NOEXN} denotes the common subtype of all forms of exception references. +This type has no values. + The type ${:EXTERN} denotes the common supertype of all external references received through the :ref:`embedder `. This type has no concrete subtypes. Dually, the type ${:NOEXTERN} denotes the common subtype of all forms of external references. @@ -125,7 +130,7 @@ Their observable value range is limited to 31 bits. Engines need to perform some form of *pointer tagging* to achieve this, which is why one bit is reserved. - Although the types ${:NONE}, ${:NOFUNC}, and ${:NOEXTERN} are not inhabited by any values, + Although the types ${:NONE}, ${:NOFUNC}, ${:NOEXN}, and ${:NOEXTERN} are not inhabited by any values, they can be used to form the types of all null :ref:`references ` in their respective hierarchy. For example, ${:(REF NULL NOFUNC)} is the generic type of a null reference compatible with all function reference types. @@ -168,12 +173,16 @@ Conventions * The reference type ${:$FUNCREF} is an abbreviation for ${reftype: (REF NULL FUNC)}. +* The reference type ${:$EXNREF} is an abbreviation for ${reftype: (REF NULL EXN)}. + * The reference type ${:$EXTERNREF} is an abbreviation for ${reftype: (REF NULL EXTERN)}. * The reference type ${:$NULLREF} is an abbreviation for ${reftype: (REF NULL NONE)}. * The reference type ${:$NULLFUNCREF} is an abbreviation for ${reftype: (REF NULL NOFUNC)}. +* The reference type ${:$NULLEXNREF} is an abbreviation for ${reftype: (REF NULL NOEXN)}. + * The reference type ${:$NULLEXTERNREF} is an abbreviation for ${reftype: (REF NULL NOEXTERN)}. @@ -394,7 +403,31 @@ Since the contents of a data segment requires no further classification, they me $${syntax: datatype} -.. index:: ! external type, defined type, function type, table type, memory type, global type, import, external value +.. index:: ! tag, tag type, function type, exception tag + pair: abstract syntax; tag + pair: tag; exception tag + single: tag; type; exception +.. _syntax-tagtype: + +Tag Types +~~~~~~~~~ + +*Tag types* classify the signature of :ref:`tags ` with a function type. + +.. math:: + \begin{array}{llll} + \production{tag type} &\tagtype &::=& \functype \\ + \end{array} + +Currently tags are only used for categorizing exceptions. +The parameters of |functype| define the list of values associated with the exception thrown with this tag. +Furthermore, it is an invariant of the semantics that every |functype| in a :ref:`valid ` tag type for an exception has an empty result type. + +.. note:: + Future versions of WebAssembly may have additional uses for tags, and may allow non-empty result types in the function types of tags. + + +.. index:: ! external type, defined type, function type, table type, memory type, global type, tag type, import, external address pair: abstract syntax; external type pair: external; type .. _syntax-externtype: @@ -402,7 +435,7 @@ $${syntax: datatype} External Types ~~~~~~~~~~~~~~ -*External types* classify :ref:`imports ` and :ref:`external values ` with their respective types. +*External types* classify :ref:`imports ` and :ref:`external addresses ` with their respective types. $${syntax: externtype} @@ -413,4 +446,4 @@ 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: -$${definition: funcsxt tablesxt memsxt globalsxt} +$${definition: funcsxt tablesxt memsxt globalsxt tagsxt} diff --git a/document/core/text/conventions.rst b/document/core/text/conventions.rst index 2e8faf915b..4b288b0330 100644 --- a/document/core/text/conventions.rst +++ b/document/core/text/conventions.rst @@ -125,6 +125,7 @@ It is convenient to define identifier contexts as :ref:`records ` can bind an optional symbolic :ref:`label identifier `. -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. +The same label identifier may optionally be repeated after the corresponding :math:`\T{end}` or :math:`\T{else}` keywords, to indicate the matching delimiters. Their :ref:`block type ` is given as a :ref:`type use `, analogous to the type of :ref:`functions `. However, the special case of a type use that is syntactically empty or consists of only a single :ref:`result ` is not regarded as an :ref:`abbreviation ` for an inline :ref:`function type `, but is parsed directly into an optional :ref:`value type `. @@ -88,7 +90,23 @@ However, the special case of a type use that is syntactically empty or consists \text{if}~~(v^?,I'){:}\Tlabel_I~~\X{bt}{:}\Tblocktype_I~~(\X{in}_1{:}\Tinstr_{I'})^\ast~~ \text{else}~~v_1^?{:}\Tid_1^?~~(\X{in}_2{:}\Tinstr_{I'})^\ast~~\text{end}~~v_2^?{:}\Tid_2^? \\ &&&\qquad \Rightarrow\quad \IF~\X{bt}~\X{in}_1^\ast~\ELSE~\X{in}_2^\ast~\END - \qquad (\iff v_1^? = \epsilon \vee v_1^? = v^?, v_2^? = \epsilon \vee v_2^? = v^?) \\ + \qquad (\iff v_1^? = \epsilon \vee v_1^? = v^?, v_2^? = \epsilon \vee v_2^? = v^?) \\ &&|& + \text{try\_table}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype~~(c{:}\Tcatch_I)^\ast~~(\X{in}{:}\Tinstr_{I'})^\ast~~\text{end}~~\Tid^? + \\ &&&\qquad \Rightarrow\quad \TRYTABLE~\X{bt}~c^\ast~\X{in}^\ast~~\END + \qquad\qquad (\iff \Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\ + \production{catch clause} & \Tcatch_I & + \begin{array}[t]{@{}c@{}} ::= \\ | \\ | \\ | \\ \end{array} + & + \begin{array}[t]{@{}lcll@{}} + \text{(}~\text{catch}~~x{:}\Ttagidx_I~~l{:}\Tlabelidx_I~\text{)} + &\Rightarrow& \CATCH~x~l \\ + \text{(}~\text{catch\_ref}~~x{:}\Ttagidx_I~~l{:}\Tlabelidx_I~\text{)} + &\Rightarrow& \CATCHREF~x~l \\ + \text{(}~\text{catch\_all}~~l{:}\Tlabelidx_I~\text{)} + &\Rightarrow& \CATCHALL~l \\ + \text{(}~\text{catch\_all\_ref}~~l{:}\Tlabelidx_I~\text{)} + &\Rightarrow& \CATCHALLREF~l \\ + \end{array} \\ \end{array} .. note:: @@ -110,6 +128,8 @@ However, the special case of a type use that is syntactically empty or consists .. _text-call_indirect: .. _text-return_call: .. _text-return_call_indirect: +.. _text-throw: +.. _text-throw_ref: All other control instruction are represented verbatim. @@ -134,7 +154,9 @@ All other control instruction are represented verbatim. \text{return\_call}~~x{:}\Tfuncidx_I &\Rightarrow& \RETURNCALL~x \\ &&|& \text{return\_call\_ref}~~x{:}\Ttypeidx &\Rightarrow& \RETURNCALLREF~x \\ &&|& \text{return\_call\_indirect}~~x{:}\Ttableidx~~y,I'{:}\Ttypeuse_I &\Rightarrow& \RETURNCALLINDIRECT~x~y - & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\ + & (\iff I' = \{\ILOCALS~(\epsilon)^\ast\}) \\ &&|& + \text{throw}~~x{:}\Ttagidx_I &\Rightarrow& \THROW~x \\ &&|& + \text{throw\_ref} &\Rightarrow& \THROWREF \\ \end{array} .. note:: @@ -1059,9 +1081,14 @@ Such a folded instruction can appear anywhere a regular instruction can. \text{(}~\text{if}~~\Tlabel~~\Tblocktype~~\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~~\Tblocktype &\hspace{-1ex} \Tinstr_1^\ast~~\text{else}~~(\Tinstr_2^\ast)^?~\text{end} \\ + \Tfoldedinstr^\ast~~\text{if}~~\Tlabel + &\hspace{-12ex} \Tblocktype~~\Tinstr_1^\ast~~\text{else}~~(\Tinstr_2^\ast)^?~\text{end} \\ & + \text{(}~\text{try\_table}~~\Tlabel~~\Tblocktype~~\Tcatch^\ast~~\Tinstr^\ast~\text{)} + \quad\equiv \\ &\qquad + \text{try\_table}~~\Tlabel~~\Tblocktype~~\Tcatch^\ast~~\Tinstr^\ast~~\text{end} \\ \end{array} + .. note:: For example, the instruction sequence diff --git a/document/core/text/modules.rst b/document/core/text/modules.rst index ee4c756dfe..d7866b8be6 100644 --- a/document/core/text/modules.rst +++ b/document/core/text/modules.rst @@ -2,12 +2,13 @@ Modules ------- -.. index:: index, type index, function index, table index, memory index, global index, element index, data index, local index, label index +.. index:: index, type index, function index, table index, memory index, global index, tag index, element index, data 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; tag index pair: text format; element index pair: text format; data index pair: text format; local index @@ -16,9 +17,10 @@ Modules .. _text-funcidx: .. _text-tableidx: .. _text-memidx: +.. _text-globalidx: +.. _text-tagidx: .. _text-elemidx: .. _text-dataidx: -.. _text-globalidx: .. _text-localidx: .. _text-labelidx: .. _text-fieldidx: @@ -47,6 +49,9 @@ Such identifiers are looked up in the suitable space of the :ref:`identifier con \production{global index} & \Tglobalidx_I &::=& x{:}\Tu32 &\Rightarrow& x \\&&|& v{:}\Tid &\Rightarrow& x & (\iff I.\IGLOBALS[x] = v) \\ + \production{tag index} & \Ttagidx_I &::=& + x{:}\Tu32 &\Rightarrow& x \\&&|& + v{:}\Tid &\Rightarrow& x & (\iff I.\ITAGS[x] = v) \\ \production{element index} & \Telemidx_I &::=& x{:}\Tu32 &\Rightarrow& x \\&&|& v{:}\Tid &\Rightarrow& x & (\iff I.\IELEM[x] = v) \\ @@ -140,7 +145,7 @@ If no such index exists, then a new :ref:`recursive type ` of the 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 +.. index:: import, name, function type, table type, memory type, global type, tag type pair: text format; import .. _text-importdesc: .. _text-import: @@ -148,7 +153,7 @@ Abbreviations are expanded in the order they appear, such that previously insert Imports ~~~~~~~ -The descriptors in imports can bind a symbolic function, table, memory, or global :ref:`identifier `. +The descriptors in imports can bind a symbolic function, table, memory, tag, or global :ref:`identifier `. .. math:: \begin{array}{llclll} @@ -163,14 +168,22 @@ The descriptors in imports can bind a symbolic function, table, memory, or globa \text{(}~\text{memory}~~\Tid^?~~\X{mt}{:}\Tmemtype_I~\text{)} &\Rightarrow& \IDMEM~~\X{mt} \\ &&|& \text{(}~\text{global}~~\Tid^?~~\X{gt}{:}\Tglobaltype_I~\text{)} - &\Rightarrow& \IDGLOBAL~\X{gt} \\ + &\Rightarrow& \IDGLOBAL~\X{gt} \\ &&|& + \text{(}~\text{tag}~~\Tid^?~~\X{tt}{:}\Ttag~\text{)} + &\Rightarrow& \IDTAG~\X{tt} \\ \end{array} Abbreviations ............. -As an abbreviation, imports may also be specified inline with :ref:`function `, :ref:`table `, :ref:`memory `, or :ref:`global ` definitions; see the respective sections. +As an abbreviation, imports may also be specified inline with +:ref:`function `, +:ref:`table `, +:ref:`memory `, +:ref:`global `, or +:ref:`tag ` +definitions; see the respective sections. @@ -438,7 +451,54 @@ Globals can be defined as :ref:`imports ` or :ref:`exports `. + +.. math:: + \begin{array}{llcl} + \production{tag} & \Ttag_I &::=& + \text{(}~\text{tag}~~\Tid^?~~x,I'{:}\Ttypeuse_I~\text{)} \\ &&& \qquad + \Rightarrow\quad \{ \TAGTYPE~x \} \\ + \end{array} + +.. index:: import, name + pair: text format; import +.. index:: export, name, index, tag index + pair: text format; export +.. index:: tag +.. _text-tag-abbrev: + +Abbreviations +............. + +Tags can be defined as :ref:`imports ` or :ref:`exports ` inline: + +.. math:: + \begin{array}{llclll} + \production{module field} & + \text{(}~\text{tag}~~\Tid^?~~\text{(}~\text{import}~~\Tname_1~~\Tname_2~\text{)}~~\Ttypeuse~\text{)} \quad\equiv \\ & \qquad + \text{(}~\text{import}~~\Tname_1~~\Tname_2~~\text{(}~\text{tag}~~\Tid^?~~\Ttypeuse~\text{)}~\text{)} + \\[1ex] & + \text{(}~\text{tag}~~\Tid^?~~\text{(}~\text{export}~~\Tname~\text{)}~~\dots~\text{)} \quad\equiv \\ & \qquad + \text{(}~\text{export}~~\Tname~~\text{(}~\text{tag}~~\Tid'~\text{)}~\text{)}~~ + \text{(}~\text{tag}~~\Tid'~~\dots~\text{)} + \\ & \qquad\qquad + (\iff \Tid^? \neq \epsilon \wedge \Tid' = \Tid^? \vee \Tid^? = \epsilon \wedge \Tid' \idfresh) \\ + \end{array} + +.. note:: + The latter abbreviation can be applied repeatedly, if ":math:`\dots`" contains additional export clauses. + Consequently, a memory declaration can contain any number of exports, possibly followed by an import. + + + +.. index:: export, name, index, function index, table index, memory index, global index, tag index pair: text format; export .. _text-exportdesc: .. _text-export: @@ -452,23 +512,31 @@ The syntax for exports mirrors their :ref:`abstract syntax ` dire \begin{array}{llclll} \production{export} & \Texport_I &::=& \text{(}~\text{export}~~\X{nm}{:}\Tname~~d{:}\Texportdesc_I~\text{)} - &\Rightarrow& \{ \ENAME~\X{nm}, \EDESC~d \} \\ + &\Rightarrow& \{ \XNAME~\X{nm}, \XDESC~d \} \\ \production{export description} & \Texportdesc_I &::=& \text{(}~\text{func}~~x{:}\Tfuncidx_I~\text{)} - &\Rightarrow& \EDFUNC~x \\ &&|& + &\Rightarrow& \XDFUNC~x \\ &&|& \text{(}~\text{table}~~x{:}\Ttableidx_I~\text{)} - &\Rightarrow& \EDTABLE~x \\ &&|& + &\Rightarrow& \XDTABLE~x \\ &&|& \text{(}~\text{memory}~~x{:}\Tmemidx_I~\text{)} - &\Rightarrow& \EDMEM~x \\ &&|& + &\Rightarrow& \XDMEM~x \\ &&|& \text{(}~\text{global}~~x{:}\Tglobalidx_I~\text{)} - &\Rightarrow& \EDGLOBAL~x \\ + &\Rightarrow& \XDGLOBAL~x \\&&|& + \text{(}~\text{tag}~~x{:}\Ttagidx_I~\text{)} + &\Rightarrow& \XDTAG~x \\ \end{array} Abbreviations ............. -As an abbreviation, exports may also be specified inline with :ref:`function `, :ref:`table `, :ref:`memory `, or :ref:`global ` definitions; see the respective sections. +As an abbreviation, exports may also be specified inline with +:ref:`function `, +:ref:`table `, +:ref:`memory `, +:ref:`global `, or +:ref:`tag ` +definitions; see the respective sections. .. index:: start function, function index @@ -623,7 +691,7 @@ Also, a memory use can be omitted, defaulting to :math:`\T{0}`. As another abbreviation, data segments may also be specified inline with :ref:`memory ` 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 +.. index:: module, type definition, function type, function, table, memory, global, tag, element, data, start function, import, export, identifier context, identifier, name section pair: text format; module single: section; name .. _text-modulefield: @@ -659,10 +727,11 @@ The name serves a documentary role only. \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{tg}{:}\Ttag_I &\Rightarrow& \{\MTAGS~\X{tg}\} \\ |& \X{el}{:}\Telem_I &\Rightarrow& \{\MELEMS~\X{el}\} \\ |& - \X{da}{:}\Tdata_I &\Rightarrow& \{\MDATAS~\X{da}\} \\ + \X{da}{:}\Tdata_I &\Rightarrow& \{\MDATAS~\X{da}\} \\ |& + \X{st}{:}\Tstart_I &\Rightarrow& \{\MSTART~\X{st}\} \\ |& + \X{ex}{:}\Texport_I &\Rightarrow& \{\MEXPORTS~\X{ex}\} \\ \end{array} \end{array} @@ -670,11 +739,16 @@ The following restrictions are imposed on the composition of :ref:`modules ` must occur before any regular definition of a :ref:`function `, :ref:`table `, :ref:`memory `, or :ref:`global `, + The second condition enforces that all :ref:`imports ` must occur before any regular definition of a + :ref:`function `, + :ref:`table `, + :ref:`memory `, + :ref:`global `, or + :ref:`tag `, thereby maintaining the ordering of the respective :ref:`index spaces `. The :ref:`well-formedness ` condition on :math:`I` in the grammar for |Tmodule| ensures that no namespace contains duplicate identifiers. @@ -695,6 +769,8 @@ The definition of the initial :ref:`identifier context ` :math:`I` \{\IMEMS~(v^?)\} \\ \F{idc}(\text{(}~\text{global}~v^?{:}\Tid^?~\dots~\text{)}) &=& \{\IGLOBALS~(v^?)\} \\ + \F{idc}(\text{(}~\text{tag}~v^?{:}\Tid^?~\dots~\text{)}) &=& + \{\ITAGS~(v^?)\} \\ \F{idc}(\text{(}~\text{elem}~v^?{:}\Tid^?~\dots~\text{)}) &=& \{\IELEM~(v^?)\} \\ \F{idc}(\text{(}~\text{data}~v^?{:}\Tid^?~\dots~\text{)}) &=& diff --git a/document/core/text/types.rst b/document/core/text/types.rst index a4c1f3d58b..09b8bb5069 100644 --- a/document/core/text/types.rst +++ b/document/core/text/types.rst @@ -56,6 +56,8 @@ Heap Types \text{func} &\Rightarrow& \FUNC \\ &&|& \text{nofunc} &\Rightarrow& \NOFUNC \\ &&|& \text{extern} &\Rightarrow& \EXTERN \\ &&|& + \text{noexn} &\Rightarrow& \NOEXN \\ &&|& + \text{exn} &\Rightarrow& \EXN \\ &&|& \text{noextern} &\Rightarrow& \NOEXTERN \\ \production{heap type} & \Theaptype_I &::=& t{:}\Tabsheaptype &\Rightarrow& y \\ &&|& @@ -95,6 +97,8 @@ There are shorthands for references to abstract heap types. \text{nullref} &\equiv& \text{(}~\text{ref}~~\text{null}~~\text{none}~\text{)} \\ \text{funcref} &\equiv& \text{(}~\text{ref}~~\text{null}~~\text{func}~\text{)} \\ \text{nullfuncref} &\equiv& \text{(}~\text{ref}~~\text{null}~~\text{nofunc}~\text{)} \\ + \text{exnref} &\equiv& \text{(}~\text{ref}~~\text{null}~~\text{exn}~\text{)} \\ + \text{nullexnref} &\equiv& \text{(}~\text{ref}~~\text{null}~~\text{noexn}~\text{)} \\ \text{externref} &\equiv& \text{(}~\text{ref}~~\text{null}~~\text{extern}~\text{)} \\ \text{nullexternref} &\equiv& \text{(}~\text{ref}~~\text{null}~~\text{noextern}~\text{)} \\ \end{array} diff --git a/document/core/util/macros.def b/document/core/util/macros.def index c3f6ffaf80..934bd53978 100644 --- a/document/core/util/macros.def +++ b/document/core/util/macros.def @@ -211,9 +211,11 @@ .. |STRUCTREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{structref}} .. |ARRAYREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{arrayref}} .. |FUNCREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{funcref}} +.. |EXNREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{exnref}} .. |EXTERNREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{externref}} .. |NULLREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{nullref}} .. |NULLFUNCREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{nullfuncref}} +.. |NULLEXNREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{nullexnref}} .. |NULLEXTERNREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{nullexternref}} .. |REF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{ref}} .. |NULL| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{null}} @@ -224,9 +226,11 @@ .. |STRUCT| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{struct}} .. |ARRAY| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{array}} .. |FUNCT| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{func}} +.. |EXN| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{exn}} .. |EXTERN| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{extern}} .. |NONE| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{none}} .. |NOFUNC| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{nofunc}} +.. |NOEXN| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{noexn}} .. |NOEXTERN| mathdef:: \xref{syntax/types}{syntax-heaptype}{\K{noextern}} .. |I8X16| mathdef:: \xref{syntax/instructions}{syntax-shape}{\K{i{\scriptstyle8}x\scriptstyle16}} @@ -261,10 +265,11 @@ .. |LMAX| mathdef:: \xref{syntax/types}{syntax-limits}{\K{max}} .. |PAGE| mathdef:: \xref{syntax/types}{syntax-memtype}{\K{page}} -.. |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}} +.. |XTFUNC| mathdef:: \xref{syntax/types}{syntax-externtype}{\K{func}} +.. |XTTABLE| mathdef:: \xref{syntax/types}{syntax-externtype}{\K{table}} +.. |XTMEM| mathdef:: \xref{syntax/types}{syntax-externtype}{\K{mem}} +.. |XTGLOBAL| mathdef:: \xref{syntax/types}{syntax-externtype}{\K{global}} +.. |XTTAG| mathdef:: \xref{syntax/types}{syntax-tagtype}{\K{tag}} .. Types, non-terminals @@ -294,6 +299,7 @@ .. |globaltype| mathdef:: \xref{syntax/types}{syntax-globaltype}{\X{globaltype}} .. |tabletype| mathdef:: \xref{syntax/types}{syntax-tabletype}{\X{tabletype}} .. |memtype| mathdef:: \xref{syntax/types}{syntax-memtype}{\X{memtype}} +.. |tagtype| mathdef:: \xref{syntax/types}{syntax-tagtype}{\X{tagtype}} .. |elemtype| mathdef:: \xref{syntax/types}{syntax-elemtype}{\X{elemtype}} .. |datatype| mathdef:: \xref{syntax/types}{syntax-datatype}{\X{datatype}} .. |externtype| mathdef:: \xref{syntax/types}{syntax-externtype}{\X{externtype}} @@ -325,6 +331,7 @@ .. |tablesxt| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{tables}} .. |memsxt| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{mems}} .. |globalsxt| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{globals}} +.. |tagsxt| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{tags}} .. |assignsubst| mathdef:: \xref{valid/conventions}{notation-subst}{\mathrel{:=}} .. |lbracksubst| mathdef:: \xref{valid/conventions}{notation-subst}{{[}} @@ -339,6 +346,7 @@ .. |tableidx| mathdef:: \xref{syntax/modules}{syntax-tableidx}{\X{tableidx}} .. |memidx| mathdef:: \xref{syntax/modules}{syntax-memidx}{\X{memidx}} .. |globalidx| mathdef:: \xref{syntax/modules}{syntax-globalidx}{\X{globalidx}} +.. |tagidx| mathdef:: \xref{syntax/modules}{syntax-tagidx}{\X{tagidx}} .. |elemidx| mathdef:: \xref{syntax/modules}{syntax-elemidx}{\X{elemidx}} .. |dataidx| mathdef:: \xref{syntax/modules}{syntax-dataidx}{\X{dataidx}} .. |localidx| mathdef:: \xref{syntax/modules}{syntax-localidx}{\X{localidx}} @@ -370,6 +378,7 @@ .. |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}} +.. |MTAGS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{tags}} .. |MIMPORTS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{imports}} .. |MEXPORTS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{exports}} .. |MDATAS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{datas}} @@ -396,6 +405,9 @@ .. |GTYPE| mathdef:: \xref{syntax/modules}{syntax-global}{\K{type}} .. |GINIT| mathdef:: \xref{syntax/modules}{syntax-global}{\K{init}} +.. |TAG| mathdef:: \xref{syntax/modules}{syntax-tag}{\K{tag}} +.. |TAGTYPE| mathdef:: \xref{syntax/modules}{syntax-tag}{\K{type}} + .. |ELEM| mathdef:: \xref{syntax/modules}{syntax-elem}{\K{elem}} .. |ETYPE| mathdef:: \xref{syntax/modules}{syntax-elem}{\K{type}} .. |EINIT| mathdef:: \xref{syntax/modules}{syntax-elem}{\K{init}} @@ -418,12 +430,13 @@ .. |SFUNC| mathdef:: \xref{syntax/modules}{syntax-start}{\K{func}} .. |EXPORT| mathdef:: \xref{syntax/modules}{syntax-export}{\K{export}} -.. |ENAME| mathdef:: \xref{syntax/modules}{syntax-export}{\K{name}} +.. |XNAME| mathdef:: \xref{syntax/modules}{syntax-export}{\K{name}} -.. |EXFUNC| mathdef:: \xref{syntax/modules}{syntax-externidx}{\K{func}} -.. |EXTABLE| mathdef:: \xref{syntax/modules}{syntax-externidx}{\K{table}} -.. |EXMEM| mathdef:: \xref{syntax/modules}{syntax-externidx}{\K{memory}} -.. |EXGLOBAL| mathdef:: \xref{syntax/modules}{syntax-externidx}{\K{global}} +.. |XXFUNC| mathdef:: \xref{syntax/modules}{syntax-externidx}{\K{func}} +.. |XXTABLE| mathdef:: \xref{syntax/modules}{syntax-externidx}{\K{table}} +.. |XXMEM| mathdef:: \xref{syntax/modules}{syntax-externidx}{\K{memory}} +.. |XXGLOBAL| mathdef:: \xref{syntax/modules}{syntax-externidx}{\K{global}} +.. |XXTAG| mathdef:: \xref{syntax/modules}{syntax-externidx}{\K{tag}} .. |IMPORT| mathdef:: \xref{syntax/modules}{syntax-import}{\K{import}} .. |IMODULE| mathdef:: \xref{syntax/modules}{syntax-import}{\K{module}} @@ -431,17 +444,19 @@ .. TODO remove below -.. |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}} +.. |XDESC| mathdef:: \xref{syntax/modules}{syntax-export}{\K{desc}} +.. |XDFUNC| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\K{func}} +.. |XDTABLE| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\K{table}} +.. |XDMEM| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\K{mem}} +.. |XDGLOBAL| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\K{global}} +.. |XDTAG| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\K{tag}} .. |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}} +.. |IDTAG| mathdef:: \xref{syntax/modules}{syntax-importdesc}{\K{tag}} .. Modules, non-terminals @@ -453,6 +468,7 @@ .. |table| mathdef:: \xref{syntax/modules}{syntax-table}{\X{table}} .. |mem| mathdef:: \xref{syntax/modules}{syntax-mem}{\X{mem}} .. |global| mathdef:: \xref{syntax/modules}{syntax-global}{\X{global}} +.. |tag| mathdef:: \xref{syntax/modules}{syntax-tag}{\X{tag}} .. |import| mathdef:: \xref{syntax/modules}{syntax-import}{\X{import}} .. |export| mathdef:: \xref{syntax/modules}{syntax-export}{\X{export}} .. |importdesc| mathdef:: \xref{syntax/modules}{syntax-importdesc}{\X{importdesc}} @@ -470,6 +486,7 @@ .. |tablesxx| mathdef:: \xref{syntax/modules}{syntax-externidx}{\F{tables}} .. |memsxx| mathdef:: \xref{syntax/modules}{syntax-externidx}{\F{mems}} .. |globalsxx| mathdef:: \xref{syntax/modules}{syntax-externidx}{\F{globals}} +.. |tagsxx| mathdef:: \xref{syntax/modules}{syntax-externidx}{\F{tags}} .. Instructions, terminals @@ -507,6 +524,14 @@ .. |RETURNCALLREF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{return\_call\_ref}} .. |RETURNCALLINDIRECT| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{return\_call\_indirect}} +.. |THROW| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{throw}} +.. |THROWREF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{throw\_ref}} +.. |TRYTABLE| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{try\_table}} +.. |CATCH| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{catch}} +.. |CATCHREF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{catch\_ref}} +.. |CATCHALL| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{catch\_all}} +.. |CATCHALLREF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{catch\_all\_ref}} + .. |DROP| mathdef:: \xref{syntax/instructions}{syntax-instr-parametric}{\K{drop}} .. |SELECT| mathdef:: \xref{syntax/instructions}{syntax-instr-parametric}{\K{select}} @@ -751,6 +776,7 @@ .. |blocktype| mathdef:: \xref{syntax/instructions}{syntax-blocktype}{\X{blocktype}} .. |instr| mathdef:: \xref{syntax/instructions}{syntax-instr}{\X{instr}} +.. |catch| mathdef:: \xref{syntax/instructions}{syntax-catch}{\X{catch}} .. |expr| mathdef:: \xref{syntax/instructions}{syntax-expr}{\X{expr}} @@ -825,6 +851,7 @@ .. |Bsubtype| mathdef:: \xref{binary/types}{binary-subtype}{\B{subtype}} .. |Brectype| mathdef:: \xref{binary/types}{binary-rectype}{\B{rectype}} .. |Bglobaltype| mathdef:: \xref{binary/types}{binary-globaltype}{\B{globaltype}} +.. |Btagtype| mathdef:: \xref{binary/types}{binary-tagtype}{\B{tagtype}} .. |Btabletype| mathdef:: \xref{binary/types}{binary-tabletype}{\B{tabletype}} .. |Bmemtype| mathdef:: \xref{binary/types}{binary-memtype}{\B{memtype}} .. |Blimits| mathdef:: \xref{binary/types}{binary-limits}{\B{limits}} @@ -840,6 +867,7 @@ .. |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}} +.. |Btagidx| mathdef:: \xref{binary/modules}{binary-tagidx}{\B{tagidx}} .. |Belemidx| mathdef:: \xref{binary/modules}{binary-elemidx}{\B{elemidx}} .. |Bdataidx| mathdef:: \xref{binary/modules}{binary-dataidx}{\B{dataidx}} .. |Blocalidx| mathdef:: \xref{binary/modules}{binary-localidx}{\B{localidx}} @@ -863,6 +891,7 @@ .. |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}} +.. |Btagsec| mathdef:: \xref{binary/modules}{binary-tagsec}{\B{tagsec}} .. |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}} @@ -876,6 +905,7 @@ .. |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}} +.. |Btag| mathdef:: \xref{binary/modules}{binary-tag}{\B{tag}} .. |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}} @@ -897,6 +927,7 @@ .. |Bcastop| mathdef:: \xref{binary/instructions}{binary-castop}{\B{castop}} .. |Binstr| mathdef:: \xref{binary/instructions}{binary-instr}{\B{instr}} +.. |Bcatch| mathdef:: \xref{binary/instructions}{binary-catch}{\B{catch}} .. |Bexpr| mathdef:: \xref{binary/instructions}{binary-expr}{\B{expr}} .. |Blaneidx| mathdef:: \xref{binary/instructions}{binary-laneidx}{\B{laneidx}} @@ -1029,6 +1060,7 @@ .. |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}} +.. |Ttagidx| mathdef:: \xref{text/modules}{text-tagidx}{\T{tagidx}} .. |Telemidx| mathdef:: \xref{text/modules}{text-elemidx}{\T{elemidx}} .. |Tdataidx| mathdef:: \xref{text/modules}{text-dataidx}{\T{dataidx}} .. |Tlocalidx| mathdef:: \xref{text/modules}{text-localidx}{\T{localidx}} @@ -1046,6 +1078,7 @@ .. |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}} +.. |Ttag| mathdef:: \xref{text/modules}{text-tag}{\T{tag}} .. |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}} @@ -1075,6 +1108,7 @@ .. |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}} +.. |Tcatch| mathdef:: \xref{text/instructions}{text-catch}{\T{catch}} .. |Texpr| mathdef:: \xref{text/instructions}{text-expr}{\T{expr}} @@ -1091,6 +1125,7 @@ .. |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}} +.. |ITAGS| mathdef:: \xref{text/conventions}{text-context}{\K{tags}} .. |IELEM| mathdef:: \xref{text/conventions}{text-context}{\K{elem}} .. |IDATA| mathdef:: \xref{text/conventions}{text-context}{\K{data}} .. |ILOCALS| mathdef:: \xref{text/conventions}{text-context}{\K{locals}} @@ -1123,6 +1158,7 @@ .. |CTABLES| mathdef:: \xref{valid/conventions}{context}{\K{tables}} .. |CMEMS| mathdef:: \xref{valid/conventions}{context}{\K{mems}} .. |CGLOBALS| mathdef:: \xref{valid/conventions}{context}{\K{globals}} +.. |CTAGS| mathdef:: \xref{valid/conventions}{context}{\K{tags}} .. |CELEMS| mathdef:: \xref{valid/conventions}{context}{\K{elems}} .. |CDATAS| mathdef:: \xref{valid/conventions}{context}{\K{datas}} .. |CLOCALS| mathdef:: \xref{valid/conventions}{context}{\K{locals}} @@ -1156,6 +1192,7 @@ .. |vdashtabletype| mathdef:: \xref{valid/types}{valid-tabletype}{\vdash} .. |vdashmemtype| mathdef:: \xref{valid/types}{valid-memtype}{\vdash} .. |vdashglobaltype| mathdef:: \xref{valid/types}{valid-globaltype}{\vdash} +.. |vdashtagtype| mathdef:: \xref{valid/types}{valid-tagtype}{\vdash} .. |vdashexterntype| mathdef:: \xref{valid/types}{valid-externtype}{\vdash} .. |vdashdeftype| mathdef:: \xref{valid/types}{valid-deftype}{\vdash} @@ -1182,6 +1219,7 @@ .. |OKtabletype| mathdef:: \xref{valid/types}{valid-tabletype}{\K{ok}} .. |OKmemtype| mathdef:: \xref{valid/types}{valid-memtype}{\K{ok}} .. |OKglobaltype| mathdef:: \xref{valid/types}{valid-globaltype}{\K{ok}} +.. |OKtagtype| mathdef:: \xref{valid/types}{valid-tagtype}{\K{ok}} .. |OKexterntype| mathdef:: \xref{valid/types}{valid-externtype}{\K{ok}} .. |OKlimits| mathdef:: \xref{valid/types}{valid-limits}{\K{ok}} @@ -1205,6 +1243,7 @@ .. |vdashtabletypematch| mathdef:: \xref{valid/matching}{match-tabletype}{\vdash} .. |vdashmemtypematch| mathdef:: \xref{valid/matching}{match-memtype}{\vdash} .. |vdashglobaltypematch| mathdef:: \xref{valid/matching}{match-globaltype}{\vdash} +.. |vdashtagtypematch| mathdef:: \xref{valid/matching}{match-tagtype}{\vdash} .. |vdashexterntypematch| mathdef:: \xref{valid/matching}{match-externtype}{\vdash} .. |vdashlimitsmatch| mathdef:: \xref{valid/matching}{match-limits}{\vdash} @@ -1226,16 +1265,20 @@ .. |subtabletypematch| mathdef:: \xref{valid/matching}{match-tabletype}{\leq} .. |submemtypematch| mathdef:: \xref{valid/matching}{match-memtype}{\leq} .. |subglobaltypematch| mathdef:: \xref{valid/matching}{match-globaltype}{\leq} +.. |subtagtypematch| mathdef:: \xref{valid/matching}{match-tagtype}{\leq} .. |subexterntypematch| mathdef:: \xref{valid/matching}{match-externtype}{\leq} .. |sublimitsmatch| mathdef:: \xref{valid/matching}{match-limits}{\leq} .. |vdashinstr| mathdef:: \xref{valid/instructions}{valid-instr}{\vdash} .. |vdashinstrs| mathdef:: \xref{valid/instructions}{valid-instrs}{\vdash} +.. |vdashcatch| mathdef:: \xref{valid/instructions}{valid-catch}{\vdash} .. |vdashexpr| mathdef:: \xref{valid/instructions}{valid-expr}{\vdash} .. |vdashinstrconst| mathdef:: \xref{valid/instructions}{valid-const}{\vdash} .. |vdashexprconst| mathdef:: \xref{valid/instructions}{valid-const}{\vdash} .. |vdashexprokconst| mathdef:: \xref{valid/instructions}{valid-const}{\vdash} +.. |OKcatch| mathdef:: \xref{valid/instructions}{valid-catch}{\K{ok}} + .. |CONSTinstrconst| mathdef:: \xref{valid/instructions}{valid-const}{\K{const}} .. |CONSTexprconst| mathdef:: \xref{valid/instructions}{valid-const}{\K{const}} .. |CONSTexprokconst| mathdef:: \xref{valid/instructions}{valid-const}{\K{const}} @@ -1249,6 +1292,7 @@ .. |vdashtable| mathdef:: \xref{valid/modules}{valid-table}{\vdash} .. |vdashmem| mathdef:: \xref{valid/modules}{valid-mem}{\vdash} .. |vdashglobal| mathdef:: \xref{valid/modules}{valid-global}{\vdash} +.. |vdashtag| mathdef:: \xref{valid/modules}{valid-tag}{\vdash} .. |vdashglobals| mathdef:: \xref{valid/modules}{valid-globalseq}{\vdash} .. |vdashelem| mathdef:: \xref{valid/modules}{valid-elem}{\vdash} .. |vdashelemmode| mathdef:: \xref{valid/modules}{valid-elemmode}{\vdash} @@ -1292,11 +1336,14 @@ .. |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}} +.. |alloctag| mathdef:: \xref{exec/modules}{alloc-tag}{\F{alloctag}} .. |allocelem| mathdef:: \xref{exec/modules}{alloc-elem}{\F{allocelem}} .. |allocdata| mathdef:: \xref{exec/modules}{alloc-data}{\F{allocdata}} .. |allocexport| mathdef:: \xref{exec/modules}{alloc-export}{\F{allocexport}} .. |allocmodule| mathdef:: \xref{exec/modules}{alloc-module}{\F{allocmodule}} +.. |allocexn| mathdef:: \xref{exec/modules}{alloc-exception}{\F{allocexn}} + .. |evalglobal| mathdef:: \xref{exec/modules}{eval-globals}{\F{evalglobal}} .. |growtable| mathdef:: \xref{exec/modules}{grow-table}{\F{growtable}} @@ -1313,10 +1360,12 @@ .. |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}} +.. |tagaddr| mathdef:: \xref{exec/runtime}{syntax-tagaddr}{\X{tagaddr}} .. |elemaddr| mathdef:: \xref{exec/runtime}{syntax-elemaddr}{\X{elemaddr}} .. |dataaddr| mathdef:: \xref{exec/runtime}{syntax-dataaddr}{\X{dataaddr}} .. |structaddr| mathdef:: \xref{exec/runtime}{syntax-structaddr}{\X{structaddr}} .. |arrayaddr| mathdef:: \xref{exec/runtime}{syntax-arrayaddr}{\X{arrayaddr}} +.. |exnaddr| mathdef:: \xref{exec/runtime}{syntax-exnaddr}{\X{exnaddr}} .. |hostaddr| mathdef:: \xref{exec/runtime}{syntax-hostaddr}{\X{hostaddr}} @@ -1326,6 +1375,7 @@ .. |freetableaddr| mathdef:: \xref{exec/runtime}{syntax-tableaddr}{\F{tableaddr}} .. |freememaddr| mathdef:: \xref{exec/runtime}{syntax-memaddr}{\F{memaddr}} .. |freeglobaladdr| mathdef:: \xref{exec/runtime}{syntax-globaladdr}{\F{globaladdr}} +.. |freetagaddr| mathdef:: \xref{exec/runtime}{syntax-globaladdr}{\F{tagaddr}} .. |freeelemaddr| mathdef:: \xref{exec/runtime}{syntax-elemaddr}{\F{elemaddr}} .. |freedataaddr| mathdef:: \xref{exec/runtime}{syntax-dataaddr}{\F{dataaddr}} @@ -1347,25 +1397,29 @@ .. |GITYPE| mathdef:: \xref{exec/runtime}{syntax-globalinst}{\K{type}} .. |GIVALUE| mathdef:: \xref{exec/runtime}{syntax-globalinst}{\K{value}} +.. |HITYPE| mathdef:: \xref{exec/runtime}{syntax-taginst}{\K{type}} + .. |EITYPE| mathdef:: \xref{exec/runtime}{syntax-eleminst}{\K{type}} .. |EIREFS| mathdef:: \xref{exec/runtime}{syntax-eleminst}{\K{elem}} .. |DITYPE| mathdef:: \xref{exec/runtime}{syntax-datainst}{\K{data}} .. |DIBYTES| mathdef:: \xref{exec/runtime}{syntax-datainst}{\K{bytes}} -.. |EINAME| mathdef:: \xref{exec/runtime}{syntax-exportinst}{\K{name}} -.. |EIVALUE| mathdef:: \xref{exec/runtime}{syntax-exportinst}{\K{value}} +.. |XINAME| mathdef:: \xref{exec/runtime}{syntax-exportinst}{\K{name}} +.. |XIADDR| mathdef:: \xref{exec/runtime}{syntax-exportinst}{\K{addr}} -.. |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}} +.. |XAFUNC| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\K{func}} +.. |XATABLE| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\K{table}} +.. |XAMEM| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\K{mem}} +.. |XAGLOBAL| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\K{global}} +.. |XATAG| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\K{tag}} .. |MITYPES| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{types}} .. |MIFUNCS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{funcs}} .. |MITABLES| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{tables}} .. |MIMEMS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{mems}} .. |MIGLOBALS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{globals}} +.. |MITAGS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{tags}} .. |MIELEMS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{elems}} .. |MIDATAS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{datas}} .. |MIEXPORTS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{exports}} @@ -1376,6 +1430,9 @@ .. |AITYPE| mathdef:: \xref{exec/runtime}{syntax-arrayinst}{\K{type}} .. |AIFIELDS| mathdef:: \xref{exec/runtime}{syntax-arrayinst}{\K{fields}} +.. |EITAG| mathdef:: \xref{exec/runtime}{syntax-exninst}{\K{tag}} +.. |EIFIELDS| mathdef:: \xref{exec/runtime}{syntax-exninst}{\K{fields}} + .. |PACK| mathdef:: \xref{exec/runtime}{syntax-packval}{\K{pack}} .. |I8PACK| mathdef:: \xref{exec/runtime}{syntax-packval}{\K{i8.pack}} .. |I16PACK| mathdef:: \xref{exec/runtime}{syntax-packval}{\K{i16.pack}} @@ -1388,10 +1445,12 @@ .. |ZGLOBALS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{globals}} .. |ZTABLES| mathdef:: \xref{exec/runtime}{syntax-store}{\K{tables}} .. |ZMEMS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{mems}} +.. |ZTAGS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{tags}} .. |ZELEMS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{elems}} .. |ZDATAS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{datas}} .. |ZSTRUCTS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{structs}} .. |ZARRAYS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{arrays}} +.. |ZEXNS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{exns}} .. |ZLOCALS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{locals}} .. |ZGGLOBALS| mathdef:: \ZGLOBALS @@ -1415,7 +1474,7 @@ .. |packval| mathdef:: \xref{exec/runtime}{syntax-packval}{\X{packval}} .. |pack| mathdef:: \xref{exec/runtime}{syntax-pack}{\X{pack}} -.. |externval| mathdef:: \xref{exec/runtime}{syntax-externval}{\X{externval}} +.. |externaddr| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\X{externaddr}} .. |moduleinst| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\X{moduleinst}} .. |funccode| mathdef:: \xref{exec/runtime}{syntax-funcinst}{\X{code}} @@ -1423,21 +1482,24 @@ .. |tableinst| mathdef:: \xref{exec/runtime}{syntax-tableinst}{\X{tableinst}} .. |meminst| mathdef:: \xref{exec/runtime}{syntax-meminst}{\X{meminst}} .. |globalinst| mathdef:: \xref{exec/runtime}{syntax-globalinst}{\X{globalinst}} +.. |taginst| mathdef:: \xref{exec/runtime}{syntax-taginst}{\X{taginst}} .. |eleminst| mathdef:: \xref{exec/runtime}{syntax-eleminst}{\X{eleminst}} .. |datainst| mathdef:: \xref{exec/runtime}{syntax-datainst}{\X{datainst}} .. |structinst| mathdef:: \xref{exec/runtime}{syntax-structinst}{\X{structinst}} .. |arrayinst| mathdef:: \xref{exec/runtime}{syntax-arrayinst}{\X{arrayinst}} .. |exportinst| mathdef:: \xref{exec/runtime}{syntax-exportinst}{\X{exportinst}} +.. |exninst| mathdef:: \xref{exec/runtime}{syntax-exninst}{\X{exninst}} .. |hostfunc| mathdef:: \xref{exec/runtime}{syntax-hostfunc}{\X{hostfunc}} .. Instances, meta functions -.. |funcsxv| mathdef:: \xref{exec/runtime}{syntax-externval}{\F{funcs}} -.. |tablesxv| mathdef:: \xref{exec/runtime}{syntax-externval}{\F{tables}} -.. |memsxv| mathdef:: \xref{exec/runtime}{syntax-externval}{\F{mems}} -.. |globalsxv| mathdef:: \xref{exec/runtime}{syntax-externval}{\F{globals}} +.. |funcsxa| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\F{funcs}} +.. |tablesxa| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\F{tables}} +.. |memsxa| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\F{mems}} +.. |globalsxa| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\F{globals}} +.. |tagsxa| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\F{tags}} .. Store, terminals @@ -1445,11 +1507,13 @@ .. |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}} +.. |STAGS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{tags}} .. |SGLOBALS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{globals}} .. |SELEMS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{elems}} .. |SDATAS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{datas}} .. |SSTRUCTS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{structs}} .. |SARRAYS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{arrays}} +.. |SEXNS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{exns}} .. Store, non-terminals @@ -1461,6 +1525,7 @@ .. |LABEL| mathdef:: \xref{exec/runtime}{syntax-label}{\K{label}} .. |FRAME| mathdef:: \xref{exec/runtime}{syntax-frame}{\K{frame}} +.. |HANDLER| mathdef:: \xref{exec/runtime}{syntax-handler}{\K{handler}} .. |ALOCALS| mathdef:: \xref{exec/runtime}{syntax-frame}{\K{locals}} .. |AMODULE| mathdef:: \xref{exec/runtime}{syntax-frame}{\K{module}} @@ -1469,6 +1534,7 @@ .. Stack, non-terminals .. |label| mathdef:: \xref{exec/runtime}{syntax-label}{\X{label}} +.. |handler| mathdef:: \xref{exec/runtime}{syntax-handler}{\X{handler}} .. |frame| mathdef:: \xref{exec/runtime}{syntax-frame}{\X{frame}} .. |callframe| mathdef:: \xref{exec/runtime}{syntax-callframe}{\X{callframe}} @@ -1484,6 +1550,7 @@ .. |REFFUNCADDR| mathdef:: \xref{exec/runtime}{syntax-ref}{\K{ref{.}func}} .. |REFSTRUCTADDR| mathdef:: \xref{exec/runtime}{syntax-ref}{\K{ref{.}struct}} .. |REFARRAYADDR| mathdef:: \xref{exec/runtime}{syntax-ref}{\K{ref{.}array}} +.. |REFEXNADDR| mathdef:: \xref{exec/runtime}{syntax-ref}{\K{ref{.}exn}} .. |REFHOSTADDR| mathdef:: \xref{exec/runtime}{syntax-ref}{\K{ref{.}host}} .. |REFEXTERN| mathdef:: \xref{exec/runtime}{syntax-ref}{\K{ref{.}extern}} .. |TRAP| mathdef:: \xref{exec/runtime}{syntax-trap}{\K{trap}} @@ -1661,7 +1728,7 @@ .. Judgements -.. |vdashexternval| mathdef:: \xref{exec/values}{valid-externval}{\vdash} +.. |vdashexternaddr| mathdef:: \xref{exec/values}{valid-externaddr}{\vdash} .. Soundness @@ -1680,16 +1747,20 @@ .. |vdashtableinst| mathdef:: \xref{appendix/properties}{valid-tableinst}{\vdash} .. |vdashmeminst| mathdef:: \xref{appendix/properties}{valid-meminst}{\vdash} .. |vdashglobalinst| mathdef:: \xref{appendix/properties}{valid-globalinst}{\vdash} +.. |vdashtaginst| mathdef:: \xref{appendix/properties}{valid-taginst}{\vdash} .. |vdasheleminst| mathdef:: \xref{appendix/properties}{valid-eleminst}{\vdash} .. |vdashdatainst| mathdef:: \xref{appendix/properties}{valid-datainst}{\vdash} .. |vdashstructinst| mathdef:: \xref{appendix/properties}{valid-structinst}{\vdash} .. |vdasharrayinst| mathdef:: \xref{appendix/properties}{valid-arrayinst}{\vdash} +.. |vdashexninst| mathdef:: \xref{appendix/properties}{valid-exninst}{\vdash} .. |vdashexportinst| mathdef:: \xref{appendix/properties}{valid-exportinst}{\vdash} .. |vdashmoduleinst| mathdef:: \xref{appendix/properties}{valid-moduleinst}{\vdash} +.. |OKtaginst| mathdef:: \xref{appendix/properties}{valid-taginst}{\K{ok}} .. |OKdatainst| mathdef:: \xref{appendix/properties}{valid-datainst}{\K{ok}} .. |OKstructinst| mathdef:: \xref{appendix/properties}{valid-structinst}{\K{ok}} .. |OKarrayinst| mathdef:: \xref{appendix/properties}{valid-arrayinst}{\K{ok}} +.. |OKexninst| mathdef:: \xref{appendix/properties}{valid-exninst}{\K{ok}} .. |OKexportinst| mathdef:: \xref{appendix/properties}{valid-exportinst}{\K{ok}} .. |vdashcontext| mathdef:: \xref{appendix/properties}{valid-context}{\vdash} @@ -1704,10 +1775,12 @@ .. |vdashtableinstextends| mathdef:: \xref{appendix/properties}{extend-tableinst}{\vdash} .. |vdashmeminstextends| mathdef:: \xref{appendix/properties}{extend-meminst}{\vdash} .. |vdashglobalinstextends| mathdef:: \xref{appendix/properties}{extend-globalinst}{\vdash} +.. |vdashtaginstextends| mathdef:: \xref{appendix/properties}{extend-taginst}{\vdash} .. |vdasheleminstextends| mathdef:: \xref{appendix/properties}{extend-eleminst}{\vdash} .. |vdashdatainstextends| mathdef:: \xref{appendix/properties}{extend-datainst}{\vdash} .. |vdashstructinstextends| mathdef:: \xref{appendix/properties}{extend-structinst}{\vdash} .. |vdasharrayinstextends| mathdef:: \xref{appendix/properties}{extend-arrayinst}{\vdash} +.. |vdashexninstextends| mathdef:: \xref{appendix/properties}{extend-exninst}{\vdash} .. |vdashstoreextends| mathdef:: \xref{appendix/properties}{extend-store}{\vdash} @@ -1727,6 +1800,7 @@ .. |Bmodulenamesubsec| mathdef:: \xref{appendix/custom}{binary-modulenamesec}{\B{modulenamesubsec}} .. |Bfuncnamesubsec| mathdef:: \xref{appendix/custom}{binary-funcnamesec}{\B{funcnamesubsec}} +.. |Btagnamesubsec| mathdef:: \xref{appendix/custom}{binary-tagnamesec}{\B{tagnamesubsec}} .. |Blocalnamesubsec| mathdef:: \xref{appendix/custom}{binary-localnamesec}{\B{localnamesubsec}} .. |Btypenamesubsec| mathdef:: \xref{appendix/custom}{binary-typenamesec}{\B{typenamesubsec}} .. |Bfieldnamesubsec| mathdef:: \xref{appendix/custom}{binary-fieldnamesec}{\B{fieldnamesubsec}} @@ -1751,6 +1825,7 @@ .. |Tlocalnameannot| mathdef:: \xref{appendix/custom}{text-localnameannot}{\T{localnameannot}} .. |Ttypenameannot| mathdef:: \xref{appendix/custom}{text-typenameannot}{\T{typenameannot}} .. |Tfieldnameannot| mathdef:: \xref{appendix/custom}{text-fieldnameannot}{\T{fieldnameannot}} +.. |Ttagnameannot| mathdef:: \xref{appendix/custom}{text-tagnameannot}{\T{tagnameannot}} .. Embedding @@ -1762,3 +1837,5 @@ .. |error| mathdef:: \xref{appendix/embedding}{embed-error}{\X{error}} .. |ERROR| mathdef:: \xref{appendix/embedding}{embed-error}{\K{error}} +.. |exception| mathdef:: \xref{appendix/embedding}{embed-error}{\X{exception}} +.. |EXCEPTION| mathdef:: \xref{appendix/embedding}{embed-error}{\K{exception}} diff --git a/document/core/valid/conventions.rst b/document/core/valid/conventions.rst index 822ede5174..ebad23bb7b 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, instantiation. module +.. index:: ! validation, ! type system, function type, table type, memory type, global type, tag type, value type, result type, index space, instantiation. module .. _type-system: Conventions @@ -199,7 +199,7 @@ $${syntax: {localtype init}} they do not occur in programs. -.. index:: ! context, local type, function type, table type, memory type, global type, value type, result type, index space, module, function, local type +.. index:: ! context, local type, function type, table type, memory type, global type, tag type, local type, value type, result type, index space, module, function, table, memory, global, tag .. _context: Contexts @@ -214,6 +214,7 @@ which collects relevant information about the surrounding :ref:`module ` declared in the current module, represented by their :ref:`table type `. * *Memories*: the list of :ref:`memories ` declared in the current module, represented by their :ref:`memory type `. * *Globals*: the list of :ref:`globals ` declared in the current module, represented by their :ref:`global type `. +* *Tags*: the list of tags declared in the current module, represented by their :ref:`tag type `. * *Element Segments*: the list of :ref:`element segments ` declared in the current module, represented by the elements' :ref:`reference type `. * *Data Segments*: the list of :ref:`data segments ` declared in the current module, each represented by an ${datatype: OK} entry. * *Locals*: the list of :ref:`locals ` declared in the current :ref:`function ` (including parameters), represented by their :ref:`local type `. diff --git a/document/core/valid/instructions.rst b/document/core/valid/instructions.rst index 721f7db5ab..37b810b20b 100644 --- a/document/core/valid/instructions.rst +++ b/document/core/valid/instructions.rst @@ -1368,7 +1368,7 @@ $${rule: Instr_ok/memory.init} $${rule: Instr_ok/data.drop} -.. index:: control instructions, structured control, label, block, branch, block type, label index, function index, type index, list, polymorphism, context +.. index:: control instructions, structured control, label, block, branch, block type, label index, result type, function index, type index, tag index, list, polymorphism, context pair: validation; instruction single: abstract syntax; instruction .. _valid-label: @@ -1395,6 +1395,7 @@ $${rule: Instr_ok/block} .. note:: The :ref:`notation ` ${context: {LABELS (t*)} ++ C} inserts the new label type at index ${:0}, shifting all others. + The same applies to all other block instructions. .. _valid-loop: @@ -1413,9 +1414,6 @@ $${rule: Instr_ok/block} $${rule: Instr_ok/loop} -.. note:: - The :ref:`notation ` ${context: {LABELS (t*)} ++ C} inserts the new label type at index ${:0}, shifting all others. - .. _valid-if: @@ -1436,8 +1434,86 @@ $${rule: Instr_ok/loop} $${rule: Instr_ok/if} -.. note:: - The :ref:`notation ` ${context: {LABELS (t*)} ++ C} inserts the new label type at index ${:0}, shifting all others. + + +.. _valid-try_table: + +:math:`\TRYTABLE~\blocktype~\catch^\ast~\instr^\ast~\END` +......................................................... + +* The :ref:`block type ` must be :ref:`valid ` as some :ref:`function type ` :math:`[t_1^\ast] \to [t_2^\ast]`. + +* For every :ref:`catch clause ` :math:`\catch_i` in :math:`\catch^\ast`, :math:`\catch_i` must be :ref:`valid `. + +* Let :math:`C'` be the same :ref:`context ` as :math:`C`, but with the :ref:`result type ` :math:`[t_2^\ast]` prepended to the |CLABELS| vector. + +* Under context :math:`C'`, + the instruction sequence :math:`\instr^\ast` must be :ref:`valid ` with type :math:`[t_1^\ast] \to [t_2^\ast]`. + +* Then the compound instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`. + + +.. _valid-catch: + +:math:`\CATCH~x~l` +.................. + +* The tag :math:`C.\CTAGS[x]` must be defined in the context. + +* Let :math:`[t^\ast] \to [{t'}^\ast]` be the :ref:`tag type ` :math:`C.\CTAGS[x]`. + +* The :ref:`result type ` :math:`[{t'}^\ast]` must be empty. + +* The label :math:`C.\CLABELS[l]` must be defined in the context. + +* The :ref:`result type ` :math:`[t^\ast]` must :ref:`match ` :math:`C.\CLABELS[l]`. + +* Then the catch clause is valid. + +$${rule: Catch_ok/catch} + + +:math:`\CATCHREF~x~l` +..................... + +* The tag :math:`C.\CTAGS[x]` must be defined in the context. + +* Let :math:`[t^\ast] \to [{t'}^\ast]` be the :ref:`tag type ` :math:`C.\CTAGS[x]`. + +* The :ref:`result type ` :math:`[{t'}^\ast]` must be empty. + +* The label :math:`C.\CLABELS[l]` must be defined in the context. + +* The :ref:`result type ` :math:`[t^\ast (REF EXN)]` must :ref:`match ` :math:`C.\CLABELS[l]`. + +* Then the catch clause is valid. + +$${rule: Catch_ok/catch_ref} + + +:math:`\CATCHALL~l` +................... + +* The label :math:`C.\CLABELS[l]` must be defined in the context. + +* The :ref:`result type ` :math:`C.\CLABELS[l]` must be empty. + +* Then the catch clause is valid. + +$${rule: Catch_ok/catch_all} + + +:math:`\CATCHALLREF~l` +...................... + +* The label :math:`C.\CLABELS[l]` must be defined in the context. + +* The :ref:`result type ` :math:`[(REF EXN)]` must :ref:`match ` :math:`C.\CLABELS[l]`. + +* Then the catch clause is valid. + +$${rule: Catch_ok/catch_all_ref} + .. _valid-br: @@ -1454,7 +1530,8 @@ $${rule: Instr_ok/if} $${rule: Instr_ok/br} .. note:: - The :ref:`label index ` space in the :ref:`context ` ${:C} contains the most recent label first, so that ${:C.LABEL[l]} performs a relative lookup as expected. + The :ref:`label index ` space in the :ref:`context ` ${:C} contains the most recent label first, so that ${:C.LABELS[l]} performs a relative lookup as expected. + This applies to other branch instructions as well. The ${:BR} instruction is :ref:`stack-polymorphic `. @@ -1472,9 +1549,6 @@ $${rule: Instr_ok/br} $${rule: Instr_ok/br_if} -.. note:: - The :ref:`label index ` space in the :ref:`context ` ${:C} contains the most recent label first, so that ${:C.LABEL[l]} performs a relative lookup as expected. - .. _valid-br_table: @@ -1498,8 +1572,6 @@ $${rule: Instr_ok/br_if} $${rule: Instr_ok/br_table} .. note:: - The :ref:`label index ` space in the :ref:`context ` ${:C} contains the most recent label first, so that ${:C.LABEL[l]} performs a relative lookup as expected. - The ${:BR_TABLE} instruction is :ref:`stack-polymorphic `. Furthermore, the :ref:`result type ` ${:t*} is also chosen non-deterministically in this rule. @@ -1729,6 +1801,38 @@ $${rule: Instr_ok/return_call_indirect} The ${:RETURN_CALL_INDIRECT} instruction is :ref:`stack-polymorphic `. +.. _valid-throw: + +:math:`\THROW~x` +................ + +* The tag :math:`C.\CTAGS[x]` must be defined in the context. + +* Let :math:`[t^\ast] \to [{t'}^\ast]` be the :ref:`tag type ` :math:`C.\CTAGS[x]`. + +* The :ref:`result type ` :math:`[{t'}^\ast]` must be empty. + +* Then the instruction is valid with type :math:`[t_1^\ast t^\ast] \to [t_2^\ast]`, for any sequences of :ref:`value types ` :math:`t_1^\ast` and :math:`t_2^\ast`. + +$${rule: Instr_ok/throw} + +.. note:: + The ${:THROW} instruction is :ref:`stack-polymorphic `. + + +.. _valid-throw_ref: + +:math:`\THROWREF` +................. + +* The instruction is valid with type :math:`[t_1^\ast~\EXNREF] \to [t_2^\ast]`, for any sequences of :ref:`value types ` :math:`t_1^\ast` and :math:`t_2^\ast`. + +$${rule: Instr_ok/throw} + +.. note:: + The ${:THROW_REF} instruction is :ref:`stack-polymorphic `. + + .. index:: instruction, instruction sequence, local type .. _valid-instrs: diff --git a/document/core/valid/matching.rst b/document/core/valid/matching.rst index c9012be26c..0ed9aa2ae5 100644 --- a/document/core/valid/matching.rst +++ b/document/core/valid/matching.rst @@ -324,6 +324,19 @@ A :ref:`global type ` ${globaltype: (mut1 valtype_1)} matches $${rule: {Globaltype_sub/*}} +.. index:: tag type +.. _match-tagtype: + +Tag Types +~~~~~~~~~ + +A :ref:`tag type ` ${tagtype: deftype_1} matches ${tagtype: deftype_2} if and only if: + +* :ref:`Defined type ` :math:`\deftype_1` :ref:`matches ` :math:`\deftype_2` and vice versa. + +$${rule: {Tagtype_sub}} + + .. index:: external type, function type, table type, memory type, global type .. _match-externtype: @@ -368,3 +381,13 @@ An :ref:`external type ` ${externtype: GLOBAL globaltype_1} m * Global type :math:`\globaltype_1` :ref:`matches ` :math:`\globaltype_2`. $${rule: Externtype_sub/global} + + +Tags +.... + +An :ref:`external type ` ${externtype: TAG tagtype_1} matches ${externtype: TAG tagtype_2} if and only if: + +* Tag type :math:`\tagtype_1` :ref:`matches ` :math:`\tagtype_2`. + +$${rule: Externtype_sub/tag} diff --git a/document/core/valid/modules.rst b/document/core/valid/modules.rst index c14ec6e089..a0a479c040 100644 --- a/document/core/valid/modules.rst +++ b/document/core/valid/modules.rst @@ -212,6 +212,29 @@ $${rule: Global_ok} $${rule: {Globals_ok/*}} +.. index:: tag, tag type, function type, exception tag + pair: validation; tag + single: abstract syntax; tag +.. _valid-tag: + +Tags +~~~~ + +Tags :math:`\tag` are classified by their :ref:`tag type `, +each containing an index to a :ref:`function type ` with empty result. + +:math:`\{ \TAGTYPE~x \}` +........................ + +* The type :math:`C.\CTYPES[x]` must be defined in the context. + +* Let :math:`[t_1^\ast] \to [t_2^\ast]` be the :ref:`function type ` :math:`C.\CTYPES[x]`. + +* Then the tag definition is valid with :ref:`tag type ` :math:`[t_1^\ast]\to[t_2^\ast]`. + +$${rule: Tag_ok} + + .. index:: element, table, table index, expression, constant, function index pair: validation; element single: abstract syntax; element @@ -229,7 +252,7 @@ Element segments ${:elem} are classified by the :ref:`reference type ` :math:`t` must be :ref:`valid `. -* For each :math:`e_i` in :math:`e^\ast`, +* For each :math:`e_i` in :math:`e^\ast`: * The expression :math:`e_i` must be :ref:`valid ` with some :ref:`result type ` :math:`[t]`. @@ -345,7 +368,7 @@ Start function declarations ${:start} are not classified by any type. $${rule: Start_ok} -.. index:: export, name, index, function index, table index, memory index, global index +.. index:: export, name, index, function index, table index, memory index, global index, tag index pair: validation; export single: abstract syntax; export .. _valid-exportdesc: @@ -358,7 +381,7 @@ Exports Exports ${:export} are classified by their :ref:`external type `. -:math:`\{ \ENAME~\name, \EDESC~\exportdesc \}` +:math:`\{ \XNAME~\name, \XDESC~\exportdesc \}` .............................................. * The export description :math:`\exportdesc` must be valid with :ref:`external type ` :math:`\externtype`. @@ -368,50 +391,60 @@ Exports ${:export} are classified by their :ref:`external type ` :math:`C.\CFUNCS[x]`. -* Then the export description is valid with :ref:`external type ` :math:`\ETFUNC~\X{dt}`. +* Then the export description is valid with :ref:`external type ` :math:`\XTFUNC~\X{dt}`. $${rule: Externidx_ok/func} -:math:`\EDTABLE~x` +:math:`\XDTABLE~x` .................. * The table :math:`C.\CTABLES[x]` must be defined in the context. -* Then the export description is valid with :ref:`external type ` :math:`\ETTABLE~C.\CTABLES[x]`. +* Then the export description is valid with :ref:`external type ` :math:`\XTTABLE~C.\CTABLES[x]`. $${rule: Externidx_ok/table} -:math:`\EDMEM~x` +:math:`\XDMEM~x` ................ * The memory :math:`C.\CMEMS[x]` must be defined in the context. -* Then the export description is valid with :ref:`external type ` :math:`\ETMEM~C.\CMEMS[x]`. +* Then the export description is valid with :ref:`external type ` :math:`\XTMEM~C.\CMEMS[x]`. $${rule: Externidx_ok/mem} -:math:`\EDGLOBAL~x` +:math:`\XDGLOBAL~x` ................... * The global :math:`C.\CGLOBALS[x]` must be defined in the context. -* Then the export description is valid with :ref:`external type ` :math:`\ETGLOBAL~C.\CGLOBALS[x]`. +* Then the export description is valid with :ref:`external type ` :math:`\XTGLOBAL~C.\CGLOBALS[x]`. $${rule: Externidx_ok/global} -.. index:: import, name, function type, table type, memory type, global type +:math:`\XDTAG~x` +................ + +* The tag :math:`C.\CTAGS[x]` must be defined in the context. + +* Then the export description is valid with :ref:`external type ` :math:`\XTTAG~C.\CTAGS[x]`. + +$${rule: Externidx_ok/tag} + + +.. index:: import, name, function type, table type, memory type, global type, tag type pair: validation; import single: abstract syntax; import .. _valid-importdesc: @@ -433,7 +466,7 @@ Imports ${:import} are classified by :ref:`external types `. $${rule: Import_ok} -.. index:: module, 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, tag, element, data, start function, import, export, context pair: validation; module single: abstract syntax; module .. _valid-module: @@ -472,6 +505,9 @@ The :ref:`external types ` classifying a module may contain f * :math:`C.\CGLOBALS` is :math:`\globalsxt(\X{it}^\ast)` concatenated with :math:`\X{gt}^\ast`, with the import's :ref:`external types ` :math:`\X{it}^\ast` and the internal :ref:`global types ` :math:`\X{gt}^\ast` as determined below, + * :math:`C.\CTAGS` is :math:`\tagsxt(\X{it}^\ast)` concatenated with :math:`\X{ht}^\ast`, + with the import's :ref:`external types ` :math:`\X{it}^\ast` and the internal :ref:`tag types ` :math:`\X{ht}^\ast` as determined below, + * :math:`C.\CELEMS` is :math:`{\X{rt}}^\ast` as determined below, * :math:`C.\CDATAS` is :math:`{\X{ok}}^\ast` as determined below, @@ -515,6 +551,9 @@ The :ref:`external types ` classifying a module may contain f * For each :math:`\func_i` in :math:`\module.\MFUNCS`, the definition :math:`\func_i` must be :ref:`valid ` with a :ref:`defined type ` :math:`\X{dt}_i`. + * For each :math:`\tag_i` in :math:`\module.\MTAGS`, + the definition :math:`\tag_i` must be :ref:`valid ` with a :ref:`tag type ` :math:`\X{ht}_i`. + * For each :math:`\elem_i` in :math:`\module.\MELEMS`, the segment :math:`\elem_i` must be :ref:`valid ` with :ref:`reference type ` :math:`\X{rt}_i`. @@ -536,6 +575,10 @@ The :ref:`external types ` classifying a module may contain f * Let :math:`\X{mt}^\ast` be the concatenation of the internal :ref:`memory types ` :math:`\X{mt}_i`, in index order. +* Let :math:`\X{gt}^\ast` be the concatenation of the internal :ref:`global types ` :math:`\X{gt}_i`, in index order. + +* Let :math:`\X{ht}^\ast` be the concatenation of the internal :ref:`tag types ` :math:`\X{ht}_i`, in index order. + * Let :math:`\X{rt}^\ast` be the concatenation of the :ref:`reference types ` :math:`\X{rt}_i`, in index order. * Let :math:`\X{ok}^\ast` be the concatenation of the :ref:`data types ` :math:`\X{ok}_i`, in index order. @@ -546,7 +589,7 @@ The :ref:`external types ` classifying a module may contain f * The length of :math:`C.\CMEMS` must not be larger than :math:`1`. -* All export names :math:`\export_i.\ENAME` must be different. +* All export names :math:`\export_i.\XNAME` must be different. * Then the module is valid with :ref:`external types ` :math:`\X{it}^\ast \to \X{et}^\ast`. @@ -563,6 +606,3 @@ $${rule: Module_ok} All types needed to construct ${: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 but evaluated sequentially, such that each :ref:`constant expressions ` only has access to imported or previously defined globals. - -.. note:: - The restriction on the number of memories may be lifted in future versions of WebAssembly. diff --git a/document/core/valid/types.rst b/document/core/valid/types.rst index 03f199b026..10bd77f0da 100644 --- a/document/core/valid/types.rst +++ b/document/core/valid/types.rst @@ -410,6 +410,26 @@ Memory Types $${rule: Memtype_ok} +.. index:: tag type, function type, exception tag + pair: validation; tag type + single: abstract syntax; tag type +.. _valid-tagtype: + +Tag Types +~~~~~~~~~ + +:math:`[t_1^n] \to [t_2^m]` +........................... + +* The :ref:`function type ` :math:`[t_1^n] \to [t_2^m]` must be :ref:`valid `. + +* The type sequence :math:`t_2^m` must be empty. + +* Then the tag type is valid. + +$${rule: Tagtype_ok} + + .. index:: global type, value type, mutability pair: validation; global type single: abstract syntax; global type @@ -436,7 +456,7 @@ $${rule: Globaltype_ok} External Types ~~~~~~~~~~~~~~ -:math:`\ETFUNC~\deftype` +:math:`\XTFUNC~\deftype` ........................ * The :ref:`defined type ` :math:`\deftype` must be :ref:`valid `. @@ -448,7 +468,7 @@ External Types $${rule: Externtype_ok/func} -:math:`\ETTABLE~\tabletype` +:math:`\XTTABLE~\tabletype` ........................... * The :ref:`table type ` :math:`\tabletype` must be :ref:`valid `. @@ -458,7 +478,7 @@ $${rule: Externtype_ok/func} $${rule: Externtype_ok/table} -:math:`\ETMEM~\memtype` +:math:`\XTMEM~\memtype` ....................... * The :ref:`memory type ` :math:`\memtype` must be :ref:`valid `. @@ -468,7 +488,17 @@ $${rule: Externtype_ok/table} $${rule: Externtype_ok/mem} -:math:`\ETGLOBAL~\globaltype` +:math:`\XTTAG~\tagtype` +....................... + +* The :ref:`tag type ` :math:`\tagtype` must be :ref:`valid `. + +* Then the external type is valid. + +$${rule: Externtype_ok/tag} + + +:math:`\XTGLOBAL~\globaltype` ............................. * The :ref:`global type ` :math:`\globaltype` must be :ref:`valid `. diff --git a/document/index.html b/document/index.html index 37eed9762e..f7661d8bec 100644 --- a/document/index.html +++ b/document/index.html @@ -49,21 +49,56 @@

Embedder specifications

  • JavaScript Embedding: 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.

  • Web Embedding: 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.

+

Metadata specifications

+ +

Define the format and semantics of extra information attached to a WebAssembly module

+ + + +

Legacy Extensions

+ +

Define extensions that are deprecated, but may still be in use.

+ +
    +

  • Legacy Exception Handling: defines additional instructions for exception handling that may still be available in some engines and tools, specifically web browsers.

    + +
    • +
+

- Source for these documents is available + Source for all documents is available here.

diff --git a/document/js-api/index.bs b/document/js-api/index.bs index bde4698862..dd790f819c 100644 --- a/document/js-api/index.bs +++ b/document/js-api/index.bs @@ -89,6 +89,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df text: ref.func text: ref.host text: ref.extern + text: ref.exn text: function index; url: syntax/modules.html#syntax-funcidx text: function instance; url: exec/runtime.html#function-instances text: store_init; url: appendix/embedding.html#embed-store-init @@ -127,11 +128,19 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df 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 + text: tag address; url: exec/runtime.html#syntax-tagaddr + text: tag type; url: syntax/types.html#syntax-tagtype text: struct address; url: exec/runtime.html#syntax-structaddr text: array address; url: exec/runtime.html#syntax-arrayaddr + text: exception address; url: exec/runtime.html#syntax-exnaddr text: host address; url: exec/runtime.html#syntax-hostaddr text: extern address; url: exec/runtime.html#syntax-externaddr text: page size; url: exec/runtime.html#page-size + text: tag_alloc; url: appendix/embedding.html#embed-tag-alloc + text: tag_type; url: appendix/embedding.html#embed-tag-type + text: exn_alloc; url: appendix/embedding.html#embed-exn-alloc + text: exn_tag; url: appendix/embedding.html#embed-exn-tag + text: exn_read; url: appendix/embedding.html#embed-exn-read url: syntax/types.html#syntax-numtype text: i32 text: i64 @@ -142,6 +151,7 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df url: syntax/types.html#syntax-reftype text: reftype text: funcref + text: exnref text: externref text: ref url: syntax/types.html#heap-types; for: heap-type @@ -157,7 +167,10 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df text: signif 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 + url: exec/runtime.html#syntax-externval + text: external value + for: external value + text: tag text: host function; url: exec/runtime.html#syntax-hostfunc text: the instantiation algorithm; url: exec/modules.html#instantiation text: module; url: syntax/modules.html#syntax-module @@ -169,6 +182,8 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df text: table text: mem text: global + for: externtype + text: tag text: global type; url: syntax/types.html#syntax-globaltype url: syntax/types.html#syntax-mut text: var @@ -177,14 +192,18 @@ urlPrefix: https://webassembly.github.io/spec/core/; spec: WebAssembly; type: df text: signed_31; url: exec/numerics.html#aux-signed text: signed_32; url: exec/numerics.html#aux-signed text: memory.grow; url: exec/instructions.html#exec-memory-grow + text: throw_ref; url: exec/instructions.html#exec-throw-ref text: current frame; url: exec/conventions.html#exec-notation-textual text: module; for: frame; url: exec/runtime.html#syntax-frame text: memaddrs; for: moduleinst; url: exec/runtime.html#syntax-moduleinst text: signed_64; url: exec/numerics.html#aux-signed text: sequence; url: syntax/conventions.html#grammar-notation + text: exception; for: tagtype/attribute; url: syntax/types.html#syntax-tagtype urlPrefix: https://heycam.github.io/webidl/; spec: WebIDL type: dfn text: create a namespace object; url: create-a-namespace-object +urlPrefix: https://webassembly.github.io/js-types/js-api/; spec: WebAssembly JS API (JS Type Reflection) + type: abstract-op; text: FromValueType; url: abstract-opdef-fromvaluetype urlPrefix: https://tc39.es/proposal-resizablearraybuffer/; spec: ResizableArrayBuffer proposal type: dfn text: handled; url: sec-hostresizearraybuffer @@ -272,8 +291,11 @@ Each [=agent=] is associated with the following [=ordered map=]s: * The Exported Function cache, mapping [=function address=]es to [=Exported Function=] objects. * The Exported GC Object cache, mapping [=struct address=]es and [=array address=]es to [=Exported GC Object=] objects. * The Global object cache, mapping [=global address=]es to {{Global}} objects. + * The Tag object cache, mapping [=tag addresses=] to {{Tag}} objects. + * The Exception object cache, mapping [=exception address=]es to {{Exception}} objects. * The Host value cache, mapping [=host address=]es to values. +

The WebAssembly Namespace

@@ -292,6 +314,8 @@ namespace WebAssembly {
 
     Promise<Instance> instantiate(
         Module moduleObject, optional object importObject);
+
+    readonly attribute Tag JSTag;
 };
@@ -396,6 +420,12 @@ A {{Module}} object represents a single WebAssembly module. Each {{Module}} obje 1. Let |tableaddr| be |v|.\[[Table]]. 1. Let |externtable| be the [=external value=] [=external value|table=] |tableaddr|. 1. [=list/Append=] |externtable| to |imports|. + 1. If |externtype| is of the form [=externtype/tag=] |attribute| functype, + 1. Assert: |attribute| is [=tagtype/attribute/exception=]. + 1. If |v| does not [=implement=] {{Tag}}, throw a {{LinkError}} exception. + 1. Let |tagaddr| be |v|.\[[Address]]. + 1. Let |externtag| be the [=external value=] [=external value/tag=] |tagaddr|. + 1. [=list/Append=] |externtag| to |imports|. 1. Return |imports|. Note: This algorithm only verifies the right kind of JavaScript values are passed. @@ -429,6 +459,12 @@ The verification of WebAssembly type requirements is deferred to the 1. Let [=external value|table=] |tableaddr| be |externval|. 1. Let |table| be [=create a Table object|a new Table object=] created from |tableaddr|. 1. Let |value| be |table|. + 1. If |externtype| is of the form [=externtype/tag=] |attribute| functype, + 1. Assert: |attribute| is [=tagtype/attribute/exception=]. + 1. Assert: |externval| is of the form [=external value/tag=] |tagaddr|. + 1. Let [=external value/tag=] |tagaddr| be |externval|. + 1. Let |tag| be [=create a Tag object|a new Tag object=] created from |tagaddr|. + 1. Let |value| be |tag|. 1. Let |status| be [=!=] [$CreateDataProperty$](|exportsObject|, |name|, |value|). 1. Assert: |status| is true. @@ -506,6 +542,11 @@ The verification of WebAssembly type requirements is deferred to the Note: A follow-on streaming API is documented in the WebAssembly Web API. +The getter of the JSTag attribute of the {{WebAssembly}} Namespace, when invoked, performs the following steps: + 1. Let |JSTagAddr| be the result of [=get the JavaScript exception tag|getting the JavaScript exception tag=]. + 1. Let |JSTagObject| be the result of [=create a Tag object|creating a Tag object=] from |JSTagAddr|. + 1. Return |JSTagObject|. +

Modules

@@ -513,7 +554,8 @@ enum ImportExportKind {
   "function",
   "table",
   "memory",
-  "global"
+  "global",
+  "tag"
 };
 
 dictionary ModuleExportDescriptor {
@@ -543,6 +585,7 @@ interface Module {
     * "table" if |type| is of the form [=table=] tabletype
     * "memory" if |type| is of the form [=mem=] memtype
     * "global" if |type| is of the form [=global=] globaltype
+    * "tag" if |type| is of the form [=externtype/tag=] tag
 
 
 

@@ -848,7 +891,7 @@ Each {{Table}} object has a \[[Table]] internal slot, which is a [=table address
     The Table(|descriptor|, |value|) constructor, when invoked, performs the following steps:
     1. Let |elementType| be [=ToValueType=](|descriptor|["element"]).
     1. If |elementType| is not a [=reftype=],
-        1. [=Throw=] a {{TypeError}} exception.
+        1. Throw a {{TypeError}} exception.
     1. Let |initial| be |descriptor|["initial"].
     1. If |descriptor|["maximum"] [=map/exists=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
     1. If |maximum| is not empty and |maximum| < |initial|, throw a {{RangeError}} exception.
@@ -895,6 +938,9 @@ Each {{Table}} object has a \[[Table]] internal slot, which is a [=table address
     The get(|index|) method, when invoked, performs the following steps:
     1. Let |tableaddr| be **this**.\[[Table]].
     1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let (limits, |elementType|) be [=table_type=](|store|, |tableaddr|).
+    1. If |elementType| is [=exnref=],
+        1. Throw a {{TypeError}} exception.
     1. Let |result| be [=table_read=](|store|, |tableaddr|, |index|).
     1. If |result| is [=error=], throw a {{RangeError}} exception.
     1. Return [=ToJSValue=](|result|).
@@ -903,7 +949,10 @@ Each {{Table}} object has a \[[Table]] internal slot, which is a [=table address
 

     The set(|index|, |value|) method, when invoked, performs the following steps:
     1. Let |tableaddr| be **this**.\[[Table]].
-    1. Let (limits, |elementType|) be [=table_type=](|tableaddr|).
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let (limits, |elementType|) be [=table_type=](|store|, |tableaddr|).
+    1. If |elementType| is [=exnref=],
+        1. Throw a {{TypeError}} exception.
     1. If |value| is missing,
         1. Let |ref| be [=DefaultValue=](|elementType|).
         1. If |ref| is [=error=], throw a {{TypeError}} exception.
@@ -991,7 +1040,7 @@ which can be simultaneously referenced by multiple {{Instance}} objects. Each
     The Global(|descriptor|, |v|) constructor, when invoked, performs the following steps:
     1. Let |mutable| be |descriptor|["mutable"].
     1. Let |valuetype| be [=ToValueType=](|descriptor|["value"]).
-    1. If |valuetype| is [=v128=],
+    1. If |valuetype| is [=v128=] or [=exnref=],
         1. Throw a {{TypeError}} exception.
     1. If |v| is missing,
         1. Let |value| be [=DefaultValue=](|valuetype|).
@@ -1010,7 +1059,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 [=global_type=](|store|, |globaladdr|).
-    1. If |globaltype| is of the form mut [=v128=], throw a {{TypeError}}.
+    1. If |globaltype| is of the form mut |valuetype| where |valuetype| is [=v128=] or [=exnref=], throw a {{TypeError}}.
     1. Let |value| be [=global_read=](|store|, |globaladdr|).
     1. Return [=ToJSValue=](|value|).
 

@@ -1023,7 +1072,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 **this**.\[[Global]].
     1. Let |mut| |valuetype| be [=global_type=](|store|, |globaladdr|).
-    1. If |valuetype| is [=v128=], throw a {{TypeError}}.
+    1. If |valuetype| is [=v128=] or [=exnref=], throw a {{TypeError}}.
     1. If |mut| is [=const=], throw a {{TypeError}}.
     1. Let |value| be [=ToWebAssemblyValue=](**the given value**, |valuetype|).
     1. Let |store| be [=global_write=](|store|, |globaladdr|, |value|).
@@ -1082,7 +1131,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 |functype| be [=func_type=](|store|, |funcaddr|).
     1. Let [|parameters|] → [|results|] be |functype|.
-    1. If |parameters| or |results| contain [=v128=], throw a {{TypeError}}.
+    1. If |parameters| or |results| contain [=v128=] or [=exnref=], throw a {{TypeError}}.
 
         Note: the above error is thrown each time the \[[Call]] method is invoked.
     1. Let |args| be « ».
@@ -1095,6 +1144,15 @@ This slot holds a [=function address=] relative to the [=surrounding agent=]'s [
     1. Let (|store|, |ret|) be the result of [=func_invoke=](|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 the WebAssembly error mapping.
+    1. If |ret| is [=THROW=] [=ref.exn=] |exnaddr|, then
+        1. Let |tagaddr| be [=exn_tag=](|store|, |exnaddr|).
+        1. Let |payload| be [=exn_read=](|store|, |exnaddr|).
+        1. Let |jsTagAddr| be the result of [=get the JavaScript exception tag |getting the JavaScript exception tag=].
+        1. If |tagaddr| is equal to |jsTagAddr|,
+            1. Throw the result of [=retrieving an extern value=] from |payload|[0].
+        1. Otherwise,
+            1. Let |exception| be [=create an Exception object|a new Exception=] created from |exnaddr|.
+            1. Throw |exception|.
     1. Let |outArity| be the [=list/size=] of |ret|.
     1. If |outArity| is 0, return undefined.
     1. Otherwise, if |outArity| is 1, return [=ToJSValue=](|ret|[0]).
@@ -1113,7 +1171,7 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
   To run a host function from the JavaScript object |func|, type |functype|, and [=list=] of [=WebAssembly values=] |arguments|, perform the following steps:
 
     1. Let [|parameters|] → [|results|] be |functype|.
-    1. If |parameters| or |results| contain [=v128=], throw a {{TypeError}}.
+    1. If |parameters| or |results| contain [=v128=] or [=exnref=], throw a {{TypeError}}.
     1. Let |jsArguments| be « ».
     1. [=list/iterate|For each=] |arg| of |arguments|,
         1. [=list/Append=] [=!=] [=ToJSValue=](|arg|) to |jsArguments|.
@@ -1146,9 +1204,18 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
         1. [=Clean up after running a callback=] with |stored settings|.
         1. [=Clean up after running script=] with |relevant settings|.
         1. Assert: |result|.\[[Type]] is throw or normal.
-        1. If |result|.\[[Type]] is throw, then trigger a WebAssembly trap, and propagate |result|.\[[Value]] to the enclosing JavaScript.
+        1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+        1. If |result|.\[[Type]] is throw, then:
+            1. Let |v| be |result|.\[[Value]].
+            1. If |v| [=implements=] {{Exception}},
+                1. Let |address| be |v|.\[[Address]].
+            1. Otherwise,
+                1. Let |type| be the result of [=get the JavaScript exception tag |getting the JavaScript exception tag=].
+                1. Let |payload| be [=!=] [=ToWebAssemblyValue=](|v|, [=externref=]).
+                1. Let (|store|, |address|) be [=exn_alloc=](|store|, |type|, « |payload| »).
+                1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
+            1. Execute the WebAssembly instructions ([=ref.exn=] |address|) ([=throw_ref=]).
         1. Otherwise, return |result|.\[[Value]].
-    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
     1. Let (|store|, |funcaddr|) be [=func_alloc=](|store|, |functype|, |hostfunc|).
     1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
     1. Return |funcaddr|.
@@ -1157,7 +1224,8 @@ Note: Exported Functions do not have a \[[Construct]] method and thus it is not
 

 The algorithm ToJSValue(|w|) coerces a [=WebAssembly value=] to a JavaScript value by performing the following steps:
 
-1. Assert: |w| is not of  the form [=v128.const=] v128.
+1. Assert: |w| is not of the form [=v128.const=] v128.
+1. Assert: |w| is not of the form [=ref.exn=] exnaddr.
 1. If |w| is of the form [=i64.const=] |u64|,
     1. Let |i64| be [=signed_64=](|u64|).
     1. Return [=ℤ=](|i64| interpreted as a mathematical value).
@@ -1200,6 +1268,7 @@ For retrieving a host value from an [=host address=] |hostaddr|, perf
 The algorithm ToWebAssemblyValue(|v|, |type|) coerces a JavaScript value to a [=WebAssembly value=] by performing the following steps:
 
 1. Assert: |type| is not [=v128=].
+1. Assert: |type| is not [=exnref=].
 1. If |type| is [=i64=],
     1. Let |i64| be [=?=] [$ToBigInt64$](|v|).
     1. Let |u64| be the unsigned integer such that |i64| is [=signed_64=](|u64|).
@@ -1260,6 +1329,68 @@ The algorithm ToWebAssemblyValue(|v|, |type|) coerces a JavaScript va
 
 

 
+
+
Tags

+
+The tag_alloc(|store|, |parameters|) algorithm creates a new [=tag address=] for |parameters| in |store| and returns the updated store and the [=tag address=].
+
+The tag_parameters(|store|, |tagAddress|) algorithm returns the [=list=] of types for |tagAddress| in |store|.
+
+
Tag types

+
+
+dictionary TagType {
+  required sequence<ValueType> parameters;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+interface Tag {
+  constructor(TagType type);
+};
+

+
+A {{Tag}} value represents an exception tag.
+
+

+
+To initialize a Tag object |tag| from a [=tag address=] |tagAddress|, perform the following steps:
+
+1. Let |map| be the [=surrounding agent=]'s associated [=Tag object cache=].
+1. Assert: |map|[|tagAddress|] doesn't [=map/exist=].
+1. Set |tag|.\[[Address]] to |tagAddress|.
+1. [=map/Set=] |map|[|tagAddress|] to |tag|.
+
+

+
+

+
+To create a Tag object from a [=tag address=] |tagAddress|, perform the following steps:
+
+1. Let |map| be the [=surrounding agent=]'s associated [=Tag object cache=].
+1. If |map|[|tagAddress|] [=map/exists=],
+    1. Return |map|[|tagAddress|].
+1. Let |tag| be a [=new=] {{Tag}}.
+1. [=initialize a Tag object|Initialize=] |tag| from |tagAddress|.
+1. Return |tag|.
+
+

+
+

+
+The new Tag(|type|) constructor steps are:
+
+1. Let |parameters| be |type|["parameters"].
+1. Let |wasmParameters| be «».
+1. [=list/iterate|For each=] |type| of |parameters|,
+    1. [=list/Append=] [=ToValueType=](|type|) to |wasmParameters|.
+1. Let |store| be the current agent's [=associated store=].
+1. Let (|store|, |tagAddress|) be [=tag_alloc=](|store|, |wasmParameters|).
+1. Set the current agent's [=associated store=] to |store|.
+1. [=initialize a Tag object|Initialize=] **this** from |tagAddress|.
+
+

+
+
 
Garbage Collected Objects

 
 A WebAssembly struct or array is made available in JavaScript as an Exported GC Object.
@@ -1363,6 +1494,139 @@ The internal methods of an [=Exported GC Object=] use the following implementati
     1. Set |object|.\[[OwnPropertyKeys]] as specified in [=[[OwnPropertyKeys]] internal method of an Exported GC Object=].
     1. [=map/Set=] |map|[|objectaddr|] to |object|.
     1. Return |object|.
+
+
+
Exceptions

+
+
+dictionary ExceptionOptions {
+  boolean traceStack = false;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+interface Exception {
+  constructor(Tag exceptionTag, sequence<any> payload, optional ExceptionOptions options = {});
+  any getArg([EnforceRange] unsigned long index);
+  boolean is(Tag exceptionTag);
+  readonly attribute (DOMString or undefined) stack;
+};
+

+
+An {{Exception}} value represents an exception.
+
+

+
+To initialize an Exception object |exn| from an [=Exception address=] |exnAddress|, perform the following steps:
+
+1. Let |map| be the [=surrounding agent=]'s associated [=Exception object cache=].
+1. Assert: |map|[|exnAddress|] doesn't [=map/exist=].
+1. Set |exn|.\[[Address]] to |exnAddress|.
+1. [=map/Set=] |map|[|exnAddress|] to |exn|.
+1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+1. Let |tagaddr| be [=exn_tag=](|store|, |exnAddress|).
+1. Let |payload| be [=exn_read=](|store|, |exnAddress|).
+1. Set |exn|.\[[Type]] to |tagaddr|.
+1. Set |exn|.\[[Payload]] to |payload|.
+1. Set |exn|.\[[Stack]] to undefined.
+
+

+
+

+
+To create an Exception object from a [=exception address=] |exnAddress|, perform the following steps:
+
+1. Let |map| be the [=surrounding agent=]'s associated [=Exception object cache=].
+1. If |map|[|exnAddress|] [=map/exists=],
+    1. Return |map|[|exnAddress|].
+1. Let |exn| be a [=new=] {{Exception}}.
+1. [=initialize an Exception object|Initialize=] |exn| from |exnAddress|.
+1. Return |exn|.
+
+
+

+
+

+
+The new Exception(|exceptionTag|, |payload|, |options|)
+constructor steps are:
+
+1. Let |JSTagAddr| be the result of [=get the JavaScript exception tag|getting the JavaScript exception tag=].
+1. If |exceptionTag|.\[[Address]] is equal to |JSTagAddr|,
+    1. Throw a {{TypeError}}.
+1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+1. Let [|types|] → [] be [=tag_type=](|store|, |exceptionTag|.\[[Address]]).
+1. If |types|'s [=list/size=] is not |payload|'s [=list/size=],
+    1. Throw a {{TypeError}}.
+1. Let |wasmPayload| be « ».
+1. [=list/iterate|For each=] |value| and |resultType| of |payload| and |types|, paired linearly,
+    1. If |resultType| is [=v128=] or [=exnref=],
+        1. Throw a {{TypeError}}.
+    1. [=list/Append=] [=?=] [=ToWebAssemblyValue=](|value|, |resultType|) to |wasmPayload|.
+1. Let (|store|, |exceptionAddr|) be [=exn_alloc=](|store|, |exceptionTag|.\[[Address]], |wasmPayload|)
+1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
+1. [=initialize an Exception object|Initialize=] **this** from |exceptionAddr|.
+1. If |options|["traceStack"] is true,
+    1. Set **this**.\[[Stack]] to either a {{DOMString}} representation of the current call stack or undefined.
+
+
+

+
+

+
+The getArg(|index|) method steps are:
+
+1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+1. Let |tagaddr| be [=exn_tag=](|store|, **this**.\[[Address]]).
+1. Let |payload| be [=exn_read=](|store|, **this**.\[[Address]]).
+1. Assert: |tagaddr| is equal to **this**.\[[Type]].
+1. If |index| ≥ |payload|'s [=list/size=],
+    1. Throw a {{RangeError}}.
+1. Let [|types|] → [] be [=tag_type=](|store|, |tagaddr|).
+1. If |types|[|index|] is [=v128=] or [=exnref=],
+    1. Throw a {{TypeError}}.
+1. Return [=ToJSValue=](|payload|[|index|]).
+
+

+
+

+
+The is(|exceptionTag|) method steps are:
+
+1. If **this**.\[[Type]] is not equal to |exceptionTag|.\[[Address]],
+    1. Return false.
+1. Return true.
+
+

+
+

+
+The stack getter steps are:
+
+1. Return **this**.\[[Stack]].
+
+

+
+
JavaScript exceptions

+
+The JavaScript exception tag is a [=tag address=] associated with
+the surrounding agent. It is allocated in the agent's [=associated store=] on
+first use and cached. It always has the [=tag type=] « [=externref=] » → « ».
+
+
+

+
+To get the JavaScript exception tag, perform the following steps:
+
+    1. If the [=surrounding agent=]'s associated [=JavaScript exception tag=] has been initialized,
+        1. return the [=surrounding agent=]'s associated [=JavaScript exception tag=]
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let (|store|, |tagAddress|) be [=tag_alloc=](|store|, « [=externref=] » → « »).
+    1. Set the current agent's [=associated store=] to |store|.
+    1. Set the current agent's associated [=JavaScript exception tag=] to |tagAddress|.
+    1. return |tagAddress|.
+
+
 

 
 
Error Objects

@@ -1445,6 +1709,7 @@ In practice, an implementation may run out of resources for valid modules below
 
  • The maximum number of imports declared in a module is 100,000.
    • 
 
  • The maximum number of exports declared in a module is 100,000.
    • 
 
  • The maximum number of globals defined in a module is 1,000,000.
    • 
+
  • The maximum number of tags defined in a module is 1,000,000.
    • 
 
  • The maximum number of data segments defined in a module is 100,000.
    • 
 
 
  • The maximum number of tables, including declared or imported tables, is 100,000.
    • 
diff --git a/document/legacy/exceptions/.gitignore b/document/legacy/exceptions/.gitignore
new file mode 100644
index 0000000000..b932ec283e
--- /dev/null
+++ b/document/legacy/exceptions/.gitignore
@@ -0,0 +1,3 @@
+_build
+_static
+document/*.pyc
diff --git a/document/legacy/exceptions/core/LICENSE b/document/legacy/exceptions/core/LICENSE
new file mode 100644
index 0000000000..795b406e4e
--- /dev/null
+++ b/document/legacy/exceptions/core/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/document/legacy/exceptions/core/Makefile b/document/legacy/exceptions/core/Makefile
new file mode 100644
index 0000000000..eb2611acd2
--- /dev/null
+++ b/document/legacy/exceptions/core/Makefile
@@ -0,0 +1,358 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         = a4
+BUILDDIR      = _build
+STATICDIR     = _static
+DOWNLOADDIR   = _download
+NAME          = WebAssembly-Legacy-Exceptions
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(SPHINXOPTS) .
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: usage
+usage:
+	@echo "Please use \`make ' where  is one of"
+	@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 "  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"
+
+.PHONY: help
+help:
+	@echo "Usage: \`make ' where  is one of"
+	@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 "  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"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  applehelp  to make an Apple Help Book"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  epub3      to make an epub3"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  texinfo    to make Texinfo files"
+	@echo "  info       to make Texinfo files and run them through makeinfo"
+	@echo "  gettext    to make PO message catalogs"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  xml        to make Docutils-native XML files"
+	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+	@echo "  coverage   to run coverage check of the documentation (if enabled)"
+	@echo "  dummy      to check syntax errors of document sources"
+
+.PHONY: deploy
+deploy:
+	(cd ../..; make dir-core deploy-core)
+
+.PHONY: publish
+publish: clean all deploy
+
+.PHONY: publish-main
+publish-main: clean main bikeshed-keep deploy
+
+.PHONY: all
+all:	pdf html bikeshed
+
+.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.
+
+
+GENERATED = appendix/index-instructions.rst
+.INTERMEDIATE: $(GENERATED)
+
+%.rst: %.py
+	(cd `dirname $@`; ./`basename $^`)
+
+.PHONY: pdf
+pdf:	$(GENERATED) latexpdf
+	mkdir -p $(BUILDDIR)/html/$(DOWNLOADDIR)
+	ln -f $(BUILDDIR)/latex/$(NAME).pdf $(BUILDDIR)/html/$(DOWNLOADDIR)/$(NAME).pdf
+
+
+.PHONY: clean
+clean:
+	rm -rf $(BUILDDIR)
+	rm -rf $(STATICDIR)
+	rm -f $(GENERATED)
+
+.PHONY: html
+html: $(GENERATED)
+	$(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; \
+	done
+	for file in `ls $(BUILDDIR)/html/*/*.html`; \
+	do \
+	  sed s:BASEDIR:..:g <$$file >$$file.out; \
+	  mv -f $$file.out $$file; \
+	done
+	@echo
+	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html/."
+
+.PHONY: dirhtml
+dirhtml: $(GENERATED)
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+.PHONY: singlehtml
+singlehtml: $(GENERATED)
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
+	@echo
+	@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
+
+.PHONY: bikeshed
+bikeshed: $(GENERATED)
+	$(SPHINXBUILD) -b singlehtml -c util/bikeshed \
+		$(ALLSPHINXOPTS) $(BUILDDIR)/bikeshed_singlehtml
+	python3 util/bikeshed_fixup.py $(BUILDDIR)/bikeshed_singlehtml/index.html \
+		>$(BUILDDIR)/bikeshed_singlehtml/index_fixed.html
+	@echo ==== Showing contents of _build/bikeshed_singlehtml/index_fixed.html ====
+	@head -n10 _build/bikeshed_singlehtml/index_fixed.html
+	@echo ... skipping $$(expr `cat _build/bikeshed_singlehtml/index_fixed.html | wc -l` - 20) lines ...
+	@tail -n10 _build/bikeshed_singlehtml/index_fixed.html
+	@echo
+	@echo =========================================================================
+	mkdir -p $(BUILDDIR)/bikeshed_mathjax/
+	bikeshed spec index.bs $(BUILDDIR)/bikeshed_mathjax/index.html
+	mkdir -p $(BUILDDIR)/html/bikeshed/
+	(cd util/katex/ && yarn && yarn build && npm install --only=prod)
+	python3 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
+	cp $(BUILDDIR)/bikeshed_singlehtml/_static/pygments.css \
+		$(BUILDDIR)/html/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..."
+	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
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+.PHONY: json
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+.PHONY: htmlhelp
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+.PHONY: qthelp
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/WebAssembly.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/WebAssembly.qhc"
+
+.PHONY: applehelp
+applehelp:
+	$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
+	@echo
+	@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
+	@echo "N.B. You won't be able to view it unless you put it in" \
+	      "~/Library/Documentation/Help or install it in your application" \
+	      "bundle."
+
+.PHONY: devhelp
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/WebAssembly"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/WebAssembly"
+	@echo "# devhelp"
+
+.PHONY: epub
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+.PHONY: epub3
+epub3:
+	$(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3
+	@echo
+	@echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3."
+
+.PHONY: latex
+latex:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+.PHONY: latexpdf
+latexpdf: $(GENERATED)
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex LATEXMKOPTS=" $(BUILDDIR)/latex/LOG 2>&1 || cat $(BUILDDIR)/latex/LOG
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: latexpdfja
+latexpdfja:
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through platex and dvipdfmx..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: text
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+.PHONY: man
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+.PHONY: texinfo
+texinfo:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+.PHONY: info
+info:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+.PHONY: gettext
+gettext:
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+	@echo
+	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+.PHONY: changes
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+.PHONY: linkcheck
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+.PHONY: doctest
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
+
+.PHONY: coverage
+coverage:
+	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
+	@echo "Testing of coverage in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/coverage/python.txt."
+
+.PHONY: xml
+xml:
+	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
+	@echo
+	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
+
+.PHONY: pseudoxml
+pseudoxml:
+	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
+	@echo
+	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
+
+.PHONY: dummy
+dummy:
+	$(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy
+	@echo
+	@echo "Build finished. Dummy builder generates no files."
diff --git a/document/legacy/exceptions/core/README.md b/document/legacy/exceptions/core/README.md
new file mode 100644
index 0000000000..06d075235c
--- /dev/null
+++ b/document/legacy/exceptions/core/README.md
@@ -0,0 +1,25 @@
+# WebAssembly Core Specification Addendum: Legacy Exception Handling
+
+This is the official WebAssembly "language" specification.
+
+It uses [Sphinx](http://www.sphinx-doc.org/). To install that:
+```
+pip install sphinx
+```
+To make HTML (result in `_build/html`):
+```
+make html
+```
+To make PDF (result in `_build/latex`, requires LaTeX):
+```
+make pdf
+```
+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.
diff --git a/document/legacy/exceptions/core/appendix/index-instructions.py b/document/legacy/exceptions/core/appendix/index-instructions.py
new file mode 100755
index 0000000000..2c8d3407da
--- /dev/null
+++ b/document/legacy/exceptions/core/appendix/index-instructions.py
@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+
+# This script generates the `index-instructions.rst` file. The table in that
+# file is particularly annoying to update by hand, since the Restructured Text
+# format requires the header and columns to line up properly. This is
+# especially tedious when merging changes from the upstream spec, or merging a
+# proposal back to the spec when it is standardized.
+
+import os
+
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+INDEX_INSTRUCTIONS_RST = os.path.join(SCRIPT_DIR, 'index-instructions.rst')
+
+HEADER = """\
+.. DO NOT EDIT: This file is auto-generated by the index-instructions.py script.
+
+.. _appendix:
+.. _index-instr:
+
+Index of Instructions
+=====================
+"""
+
+FOOTER = """\
+"""
+
+COLUMNS = [
+    'Instruction',
+    'Binary Opcode',
+    'Type',
+    'Validation',
+    'Execution',
+]
+
+
+def MathWrap(s, default=''):
+    if s is None:
+        return default
+    else:
+        return f':math:`{s}`'
+
+
+def RefWrap(s, kind):
+    if s is None:
+        return ''
+    else:
+        return f':ref:`{kind} <{s}>`'
+
+
+def Instruction(name, opcode, type=None, validation=None, execution=None, operator=None, validation2=None, execution2=None):
+    if operator:
+        execution_str = ', '.join([RefWrap(execution, 'execution'),
+                                   RefWrap(operator, 'operator')])
+    elif execution2:
+        execution_str = ', '.join([RefWrap(execution, 'execution'),
+                                   RefWrap(execution, 'execution')])
+
+    else:
+        execution_str = RefWrap(execution, 'execution')
+
+    if validation2:
+        validation_str = ', '.join([RefWrap(validation, 'validation'),
+                                    RefWrap(validation2, 'validation')])
+    else:
+        validation_str = RefWrap(validation, 'validation')
+
+    return (
+        MathWrap(name, '(reserved)'),
+        MathWrap(opcode),
+        MathWrap(type),
+        validation_str,
+        execution_str
+    )
+
+
+INSTRUCTIONS = [
+    Instruction(r'\TRY~\X{bt}', r'\hex{06}', r'[t_1^\ast] \to [t_2^\ast]', r'valid-try-catch', r'exec-try-catch', None, r'valid-try-delegate', r'exec-try-delegate'),
+    Instruction(r'\CATCH~x', r'\hex{07}', None, r'valid-try-catch', r'exec-try-catch'),
+    Instruction(r'\RETHROW~n', r'\hex{09}', r'[t_1^\ast] \to [t_2^\ast]', r'valid-rethrow', r'exec-rethrow'),
+    Instruction(r'\DELEGATE~l', r'\hex{18}', None, r'valid-try-delegate', r'exec-try-delegate'),
+    Instruction(r'\CATCHALL', r'\hex{19}', None, r'valid-try-catch', r'exec-try-catch'),
+]
+
+
+def ColumnWidth(n):
+    return max([len(instr[n]) for instr in INSTRUCTIONS])
+
+COLUMN_WIDTHS = [ColumnWidth(i) for i in range(len(COLUMNS))]
+DIVIDER = '  '.join('=' * width for width in COLUMN_WIDTHS)
+
+def Row(columns):
+    return '  '.join(('{:%d}' % COLUMN_WIDTHS[i]).format(column)
+                     for i, column in enumerate(columns))
+
+if __name__ == '__main__':
+    with open(INDEX_INSTRUCTIONS_RST, 'w') as f:
+        print(HEADER, file=f)
+        print(DIVIDER, file=f)
+        print(Row(COLUMNS), file=f)
+        print(DIVIDER, file=f)
+
+        for instr in INSTRUCTIONS:
+          print(Row(instr), file=f)
+
+        print(DIVIDER, file=f)
+        print(FOOTER, file=f)
diff --git a/document/legacy/exceptions/core/binary.rst b/document/legacy/exceptions/core/binary.rst
new file mode 100644
index 0000000000..f5c95be2ff
--- /dev/null
+++ b/document/legacy/exceptions/core/binary.rst
@@ -0,0 +1,32 @@
+.. _binary:
+
+Binary Format
+=============
+
+.. _binary-instr:
+
+Instructions
+------------
+
+.. _binary-instr-control:
+
+Control Instructions
+~~~~~~~~~~~~~~~~~~~~
+
+.. _binary-try:
+.. _binary-rethrow:
+
+.. math::
+   \begin{array}{@{}llcllll}
+   \production{instruction} & \Binstr &::=& \dots \\ &&|&
+     \hex{06}~~\X{bt}{:}\Bblocktype~~
+       (\X{in}_1{:}\Binstr)^\ast~~ \\&&&
+       (\hex{07}~~x{:}\Btagidx~~(\X{in}_2{:}\Binstr)^\ast)^\ast~~ \\&&&
+       (\hex{19}~~(\X{in}_3{:}\Binstr)^\ast)^?~~\hex{0B}
+       &\Rightarrow& \TRY~\X{bt}~\X{in}_1^\ast~(\CATCH~x~\X{in}_2^\ast)^\ast~
+       (\CATCHALL~\X{in}_3^\ast)^?\END \\ &&|&
+     \hex{06}~~\X{bt}{:}\Bblocktype~~(\X{in}{:}\Binstr)^\ast~~ \\&&&
+       \hex{18}~~l{:}\Blabelidx
+       &\Rightarrow& \TRY~\X{bt}~\X{in}^\ast~\DELEGATE~l \\ &&|&
+     \hex{09}~~l{:}\Blabelidx &\Rightarrow& \RETHROW~l \\
+   \end{array}
diff --git a/document/legacy/exceptions/core/conf.py b/document/legacy/exceptions/core/conf.py
new file mode 100644
index 0000000000..39b20491d6
--- /dev/null
+++ b/document/legacy/exceptions/core/conf.py
@@ -0,0 +1,500 @@
+# -*- 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
+from datetime import date
+
+pwd = os.path.abspath('.')
+sys.path.insert(0, pwd)
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+needs_sphinx = '2.3'
+
+# 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',
+  'util.mathdef',
+  'util.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-Legacy-Exceptions'
+project = u'WebAssembly-Legacy-Exceptions'
+title = u'WebAssembly Spec Addendum: Legacy Exception Handling'
+copyright = u'2023, WebAssembly Community Group'
+author = u'WebAssembly Community Group'
+editor = u'Andreas Rossberg (editor)'
+logo = 'static/webassembly.png'
+
+# The name of the GitHub repository this resides in
+repo = 'spec'
+
+# The draft version string (clear out for release cuts)
+draft = ' (Draft ' + date.today().strftime("%Y-%m-%d") + ')'
+
+# 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 = ''
+# 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 = 'en'
+
+# 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 = 'alabaster'
+
+# 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 = {
+  'logo': logo,
+  'logo_name': 'WebAssembly',
+  'description': 'WebAssembly Specification',
+  'fixed_sidebar': True,
+  'sidebar_width': '260px',
+  'sidebar_collapse': True,
+  'show_powered_by': False,
+  'extra_nav_links': {
+    'Download as PDF': 'BASEDIR/_download/' + name + '.pdf'
+  },
+}
+
+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.
+# " v documentation" by default.
+#
+html_title = u'WebAssembly Legacy Exceptions'
+
+# 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/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 = False
+
+# 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 = '%Y-%m-%d'
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a  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.
+   # Don't type-set cross references with emphasis.
+   'preamble': '\\renewcommand\\sphinxcrossref[1]{#1}\n',
+
+   # Latex figure (float) alignment
+  'figure_align': 'htbp',
+
+   # Fancy chapters [Bjarne, Sonny, Lenny, Glenn, Conny, Rejne]
+   'fncychap': '\\usepackage[Sonny]{fncychap}',
+
+   # Allow chapters to start on even pages
+   'extraclassoptions': 'openany'
+}
+
+# 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 + '\\\\ \\hfill\\large ' + editor,
+    'howto'
+  ),
+]
+
+# 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 = 'section'
+
+# 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 = """
+.. |issuelink| replace:: https://github.com/webassembly/""" + repo + """/issues/
+.. |pagelink| replace:: https://webassembly.github.io/""" + repo + """/core/
+.. include:: /""" + pwd + """/util/macros.def
+"""
+
+# https://www.sphinx-doc.org/en/master/usage/extensions/math.html#confval-mathjax3_config
+# https://docs.mathjax.org/en/latest/web/configuration.html#configuration
+# https://docs.mathjax.org/en/latest/options/input/tex.html#tex-maxbuffer
+mathjax3_config = {
+    'tex': { 'maxBuffer': 30*1024 },
+}
diff --git a/document/legacy/exceptions/core/exec.rst b/document/legacy/exceptions/core/exec.rst
new file mode 100644
index 0000000000..15d30b1b6b
--- /dev/null
+++ b/document/legacy/exceptions/core/exec.rst
@@ -0,0 +1,350 @@
+.. _exec:
+
+Execution
+=========
+
+.. _syntax-runtime:
+
+Runtime Structure
+-----------------
+
+.. _handler:
+.. _stack:
+
+Stack
+~~~~~
+
+.. _syntax-handler:
+
+**Exception Handlers**
+
+Legacy exception handlers are installed by |TRY| instructions.
+Instead of branch labels, their catch clauses have instruction blocks associated with them.
+Furthermore, a |DELEGATE| handler is associated with a label index to implicitly rewthrow to:
+
+.. math::
+   \begin{array}{llllll}
+     \production{catch} & \catch &::=& \dots \\ &&|&
+       \CATCH~\tagidx~\instr^\ast \\ &&|&
+       \CATCHALL~\tagidx~\instr^\ast \\ &&|&
+       \DELEGATE~\labelidx \\
+   \end{array}
+
+
+.. _syntax-caught:
+.. _syntax-instr-admin:
+
+Administrative Instructions
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Administrative instructions are extended with the |CAUGHT| instruction that models exceptions caught by legacy exception handlers.
+
+.. math::
+   \begin{array}{llcl}
+   \production{administrative instruction} & \instr &::=& \dots \\ &&|&
+     \CAUGHT_n\{\exnaddr\}~\instr^\ast~\END \\
+   \end{array}
+
+
+.. _syntax-ctxt-block:
+
+Block Contexts
+..............
+
+Block contexts are extended to include |CAUGHT| instructions:
+
+.. math::
+   \begin{array}{llll}
+   \production{block contexts} & \XB^k &::=& \dots \\ &&|&
+     \CAUGHT_n~\{\exnaddr\}~\XB^k~\END \\
+   \end{array}
+
+
+.. _syntax-ctxt-throw:
+
+Throw Contexts
+..............
+
+Throw contexts are also extended to include |CAUGHT| instructions:
+
+.. math::
+   \begin{array}{llll}
+   \production{throw contexts} & \XT &::=& \dots \\ &&|&
+     \CAUGHT_n\{\exnaddr\}~\XT~\END \\
+   \end{array}
+
+
+.. _exec-instr:
+
+Instructions
+------------
+
+.. _exec-instr-control:
+
+Control Instructions
+~~~~~~~~~~~~~~~~~~~~
+
+.. _exec-try-catch:
+
+:math:`\TRY~\blocktype~\instr_1^\ast~(\CATCH~x~\instr_2^\ast)^\ast~(\CATCHALL~\instr_3^\ast)^?~\END`
+....................................................................................................
+
+1. Assert: due to :ref:`validation `, :math:`\expand_F(\blocktype)` is defined.
+
+2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`function type ` :math:`\expand_F(\blocktype)`.
+
+3. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is the end of the |TRY| instruction.
+
+4. Assert: due to :ref:`validation `, there are at least :math:`m` values on the top of the stack.
+
+5. Pop the values :math:`\val^m` from the stack.
+
+6. Let :math:`F` be the :ref:`current ` :ref:`frame `.
+
+7. For each catch clause :math:`(\CATCH~x_i~\instr_{2i}^\ast)` do:
+
+   a. Assert: due to :ref:`validation `, :math:`F.\AMODULE.\MITAGS[x_i]` exists.
+
+   b. Let :math:`a_i` be the tag address :math:`F.\AMODULE.\MITAGS[x_i]`.
+
+   c. Let :math:`\catch_i` be the catch clause :math:`(\CATCH~a_i~\instr_{2i}^\ast)`.
+
+8. If there is a catch-all clause :math:`(\CATCHALL~\instr_3^\ast)`, then:
+
+    a. Let :math:`\catch'^?` be the handler :math:`(\CATCHALL~\instr_3^\ast)`.
+
+9. Else:
+
+    a. Let :math:`\catch'^?` be empty.
+
+10. Let :math:`\catch^\ast` be the concatenation of :math:`\catch_i` and :math:`\catch'^?`.
+
+11. :ref:`Enter ` the block :math:`\val^m~\instr_1^\ast` with label :math:`L` and exception handler :math:`\HANDLER_n\{\catch^\ast\}^\ast`.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{l}
+   F; \val^m~(\TRY~\X{bt}~\instr_1^\ast~(\CATCH~x~\instr_2^\ast)^\ast~(\CATCHALL~\instr_3^\ast)^?~\END
+   \quad \stepto \\
+   \qquad F; \LABEL_n\{\epsilon\}~(\HANDLER_n\{(\CATCH~a_x~\instr_2^\ast)^\ast~(\CATCHALL~\instr_3^\ast)^?\}~\val^m~\instr_1^\ast~\END)~\END \\ \qquad
+   (\iff \expand_F(\X{bt}) = [t_1^m] \to [t_2^n] \land (F.\AMODULE.\MITAGS[x]=a_x)^\ast)
+   \end{array}
+
+
+.. _exec-try-delegate:
+
+:math:`\TRY~\blocktype~\instr^\ast~\DELEGATE~l`
+...............................................
+
+1. Assert: due to :ref:`validation `, :math:`\expand_F(\blocktype)` is defined.
+
+2. Let :math:`[t_1^m] \to [t_2^n]` be the :ref:`function type ` :math:`\expand_F(\blocktype)`.
+
+3. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is the end of the |TRY| instruction.
+
+4. Let :math:`H` be the :ref:`exception handler ` :math:`l`, targeting the :math:`l`-th surrounding block.
+
+5. Assert: due to :ref:`validation `, there are at least :math:`m` values on the top of the stack.
+
+6. Pop the values :math:`\val^m` from the stack.
+
+7. :ref:`Enter ` the block :math:`\val^m~\instr^\ast` with label :math:`L` and  exception handler `\HANDLER_n\{\DELEGATE~l\}`.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{lcl}
+   F; \val^m~(\TRY~\X{bt}~\instr^\ast~\DELEGATE~l) &\stepto&
+   F; \LABEL_n\{\epsilon\}~(\HANDLER_n\{\DELEGATE~l\}~\val^m~\instr^\ast~\END)~\END \\
+   && (\iff \expand_F(\X{bt}) = [t_1^m] \to [t_2^n])
+   \end{array}
+
+
+.. _exec-throw_ref:
+
+:math:`\THROWREF`
+.................
+
+1. Let :math:`F` be the :ref:`current ` :ref:`frame `.
+
+2. Assert: due to :ref:`validation `, a :ref:`reference ` is on the top of the stack.
+
+3. Pop the reference :math:`\reff` from the stack.
+
+4. If :math:`\reff` is :math:`\REFNULL~\X{ht}`, then:
+
+   a. Trap.
+
+5. Assert: due to :ref:`validation `, :math:`\reff` is an :ref:`exception reference `.
+
+6. Let :math:`\REFEXNADDR~\X{ea}` be :math:`\reff`.
+
+7. Assert: due to :ref:`validation `, :math:`S.\SEXNS[\X{ea}]` exists.
+
+8. Let :math:`\X{exn}` be the :ref:`exception instance ` :math:`S.\SEXNS[\X{ea}]`.
+
+9. Let :math:`a` be the :ref:`tag address ` :math:`\X{exn}.\EITAG`.
+
+10. While the stack is not empty and the top of the stack is not an :ref:`exception handler `, do:
+
+   a. Pop the top element from the stack.
+
+11. Assert: the stack is now either empty, or there is an exception handler on the top of the stack.
+
+12. If the stack is empty, then:
+
+   a. Return the exception :math:`(\REFEXNADDR~a)` as a :ref:`result `.
+
+13. Assert: there is an :ref:`exception handler ` on the top of the stack.
+
+14. Pop the exception handler  :math:`\HANDLER_n\{\catch^\ast\}` from the stack.
+
+15. If :math:`\catch^\ast` is empty, then:
+
+    a. Push the exception reference :math:`\REFEXNADDR~\X{ea}` back to the stack.
+
+    b. Execute the instruction |THROWREF| again.
+
+16. Else:
+
+    a. Let :math:`\catch_1` be the first :ref:`catch clause ` in :math:`\catch^\ast` and :math:`{\catch'}^\ast` the remaining clauses.
+
+    b. If :math:`\catch_1` is of the form :math:`\CATCH~x~l` and the :ref:`exception address ` :math:`a` equals :math:`F.\AMODULE.\MITAGS[x]`, then:
+
+       i. Push the values :math:`\X{exn}.\EIFIELDS` to the stack.
+
+       ii. Execute the instruction :math:`\BR~l`.
+
+    c. Else if :math:`\catch_1` is of the form :math:`\CATCHREF~x~l` and the :ref:`exception address ` :math:`a` equals :math:`F.\AMODULE.\MITAGS[x]`, then:
+
+       i. Push the values :math:`\X{exn}.\EIFIELDS` to the stack.
+
+       ii. Push the exception reference :math:`\REFEXNADDR~\X{ea}` to the stack.
+
+       iii. Execute the instruction :math:`\BR~l`.
+
+    d. Else if :math:`\catch_1` is of the form :math:`\CATCHALL~l`, then:
+
+       i. Execute the instruction :math:`\BR~l`.
+
+    e. Else if :math:`\catch_1` is of the form :math:`\CATCHALLREF~l`, then:
+
+       i. Push the exception reference :math:`\REFEXNADDR~\X{ea}` to the stack.
+
+       ii. Execute the instruction :math:`\BR~l`.
+
+    f. Else if :math:`\catch_1` is of the form :math:`\CATCH~x~\instr^\ast` and the :ref:`exception address ` :math:`a` equals :math:`F.\AMODULE.\MITAGS[x]`, then:
+
+       i. Push the caught exception :math:`\CAUGHT_n\{\X{ea}\}` to the stack.
+
+       ii. Push the values :math:`\X{exn}.\EIFIELDS` to the stack.
+
+       iii. :ref:`Enter ` the catch block :math:`\instr^\ast`.
+
+    g. Else if :math:`\catch_1` is of the form :math:`\CATCHALL~\instr^\ast`, then:
+
+       i. Push the caught exception :math:`\CAUGHT_n\{\X{ea}\}` to the stack.
+
+       ii. :ref:`Enter ` the catch block :math:`\instr^\ast`.
+
+    h. Else if :math:`\catch_1` is of the form :math:`\DELEGATE~l`, then:
+
+       i. Assert: due to :ref:`validation `, the stack contains at least :math:`l` labels.
+
+       ii. Repeat :math:`l` times:
+
+           * While the top of the stack is not a label, do:
+
+              - Pop the top element from the stack.
+
+       iii. Assert: due to :ref:`validation `, the top of the stack now is a label.
+
+       iv. Pop the label from the stack.
+
+       v. Push the exception reference :math:`\REFEXNADDR~\X{ea}` back to the stack.
+
+       vi. Execute the instruction :math:`\THROWREF` again.
+
+    i. Else:
+
+       1. Push the modified handler  :math:`\HANDLER_n\{{\catch'}^\ast\}` back to the stack.
+
+       2. Push the exception reference :math:`\REFEXNADDR~\X{ea}` back to the stack.
+
+       3. Execute the instruction :math:`\THROWREF` again.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{rcl}
+   \dots \\
+   \HANDLER_n\{(\CATCH~x~\instr^\ast)~\catch^\ast\}~\XT[(\REFEXNADDR~a)~\THROWREF]~\END &\stepto&
+     \CAUGHT_n\{a\}~\X{exn}.\EIFIELDS~\instr^\ast~\END \\ &&
+     (\begin{array}[t]{@{}r@{~}l@{}}
+      \iff & \X{exn} = S.\SEXNS[a] \\
+      \land & \X{exn}.\EITAG = F.\AMODULE.\MITAGS[x]) \\
+      \end{array} \\
+   \HANDLER_n\{(\CATCHALL~\instr^\ast)~\catch^\ast\}~\XT[(\REFEXNADDR~a)~\THROWREF]~\END &\stepto&
+     \CAUGHT_n\{a\}~\instr^\ast~\END \\
+   \XB^l[\HANDLER_n\{(\DELEGATE~l)~\catch^\ast\}~\XT[(\REFEXNADDR~a)~\THROWREF]~\END] &\stepto&
+     (\REFEXNADDR~a)~\THROWREF \\
+   \end{array}
+
+
+.. _exec-rethrow:
+
+:math:`\RETHROW~l`
+..................
+
+1. Assert: due to :ref:`validation `, 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. Assert: due to :ref:`validation `, :math:`L` is a catch label, i.e., a label of the form :math:`(\LCATCH~[t^\ast])`, which is a label followed by a caught exception in an active catch clause.
+
+4. Let :math:`a` be the caught exception address.
+
+5. Push the value :math:`\REFEXNADDR~a` onto the stack.
+
+6. Execute the instruction |THROWREF|.
+
+.. math::
+   ~\\[-1ex]
+   \begin{array}{lclr@{\qquad}}
+   \CAUGHT_n\{a\}~\XB^l[\RETHROW~l]~\END &\stepto&
+   \CAUGHT_n\{a\}~\XB^l[(\REFEXNADDR~a)~\THROWREF]~\END \\
+   \end{array}
+
+
+.. _exec-caught-enter:
+
+Entering a catch block
+......................
+
+1. Jump to the start of the instruction sequence :math:`\instr^\ast`.
+
+
+.. _exec-caught-exit:
+
+Exiting a catch block
+.....................
+
+When the |END| of a catch block is reached without a jump, thrown exception, or trap, then the following steps are performed.
+
+1. Let :math:`\val^m` be the values on the top of the stack.
+
+2. Pop the values :math:`\val^m` from the stack.
+
+3. Assert: due to :ref:`validation `, a caught exception is now on the top of the stack.
+
+4. Pop the caught exception from the stack.
+
+5. Push :math:`\val^m` back to the stack.
+
+6. Jump to the position after the |END| of the administrative instruction associated with the caught exception.
+
+.. math::
+   \begin{array}{rcl}
+   \CAUGHT_n\{a\}~\val^m~\END  &\stepto& \val^m
+   \end{array}
+
+.. note::
+   A caught exception can only be rethrown from the scope of the administrative instruction associated with it, i.e., from the scope of the |CATCH| or |CATCHALL| block of a legacy |TRY| instruction. Upon exit from that block, the caught exception is discarded.
diff --git a/document/legacy/exceptions/core/index.rst b/document/legacy/exceptions/core/index.rst
new file mode 100644
index 0000000000..a83254bb59
--- /dev/null
+++ b/document/legacy/exceptions/core/index.rst
@@ -0,0 +1,19 @@
+WebAssembly Addendum: Legacy Exception Handling
+===============================================
+
+.. only:: html
+
+   | Editor: Andreas Rossberg
+
+   | Issue Tracker: |WasmIssues|
+
+.. toctree::
+   :maxdepth: 1
+
+   intro
+   syntax
+   valid
+   exec
+   binary
+   text
+   appendix/index-instructions
diff --git a/document/legacy/exceptions/core/intro.rst b/document/legacy/exceptions/core/intro.rst
new file mode 100644
index 0000000000..b8d8c57c3b
--- /dev/null
+++ b/document/legacy/exceptions/core/intro.rst
@@ -0,0 +1,8 @@
+.. _intro:
+
+Introduction
+============
+
+This document describes an extension of the official WebAssembly standard
+developed by its `W3C Community Group `_ with additional instructions for exception handling.
+These instructions were never standardized and are deprecated, but they may still be available in some engines, especially in web browsers.
diff --git a/document/legacy/exceptions/core/static/custom.css b/document/legacy/exceptions/core/static/custom.css
new file mode 100644
index 0000000000..33bb863d42
--- /dev/null
+++ b/document/legacy/exceptions/core/static/custom.css
@@ -0,0 +1,78 @@
+a {
+  color: #004BAB;
+  text-decoration: none;
+}
+
+a.reference {
+  border-bottom: none;
+}
+
+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%; }
+div.body h2 { font-size: 150%; }
+div.body h3 { font-size: 120%; }
+div.body h4 { font-size: 110%; }
+
+div.note {
+  border: 0px;
+  font-size: 90%;
+  background-color: #F6F8FF;
+}
+
+div.admonition {
+  padding: 10px;
+}
+
+div.admonition p.admonition-title {
+  margin: 0px 0px 0px 0px;
+  font-size: 100%;
+  font-weight: bold;
+}
+
+div.math {
+  background-color: #F0F0F0;
+  padding: 3px 0 3px 0;
+  overflow-x: auto;
+  overflow-y: hidden;
+}
+
+div.relations {
+  display: block;
+}
+
+div.sphinxsidebar {
+  z-index: 1;
+  background: #FFF;
+  margin-top: -30px;
+  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;
+}
+
+div.sphinxsidebar a:hover {
+  border-bottom: 1px dotted;
+}
diff --git a/document/legacy/exceptions/core/static/webassembly.png b/document/legacy/exceptions/core/static/webassembly.png
new file mode 100644
index 0000000000..f9edc61098
Binary files /dev/null and b/document/legacy/exceptions/core/static/webassembly.png differ
diff --git a/document/legacy/exceptions/core/syntax.rst b/document/legacy/exceptions/core/syntax.rst
new file mode 100644
index 0000000000..3dc50dfe69
--- /dev/null
+++ b/document/legacy/exceptions/core/syntax.rst
@@ -0,0 +1,38 @@
+.. _syntax:
+
+Structure
+=========
+
+.. _syntax-instr:
+
+Instructions
+------------
+
+.. _syntax-try:
+.. _syntax-try-catch:
+.. _syntax-try-delegate:
+.. _syntax-rethrow:
+.. _syntax-instr-control:
+
+Control Instructions
+~~~~~~~~~~~~~~~~~~~~
+
+The set of recognised instructions is extended with the following:
+
+.. math::
+   \begin{array}{llcl}
+   \production{instruction} & \instr &::=&
+     \dots \\&&|&
+     \TRY~\blocktype~\instr^\ast~(\CATCH~\tagidx~\instr^\ast)^\ast~(\CATCHALL~\instr^\ast)^?~\END \\ &&|&
+     \TRY~\blocktype~\instr^\ast~\DELEGATE~\labelidx \\ &&|&
+     \RETHROW~\labelidx \\
+   \end{array}
+
+The instructions |TRY| and |RETHROW|, are concerned with exceptions.
+The |TRY| instruction installs an exception handler, and may either handle exceptions in the case of |CATCH| and |CATCHALL|,
+or rethrow them in an outer block in the case of |DELEGATE|.
+
+The |RETHROW| instruction is only allowed inside a |CATCH| or |CATCHALL| clause and allows rethrowing the caught exception by lexically referring to a the corresponding |TRY|.
+
+When |TRY|-|DELEGATE| handles an exception, it also behaves similar to a forward jump,
+effectively rethrowing the caught exception right before the matching |END|.
diff --git a/document/legacy/exceptions/core/text.rst b/document/legacy/exceptions/core/text.rst
new file mode 100644
index 0000000000..1968c1120d
--- /dev/null
+++ b/document/legacy/exceptions/core/text.rst
@@ -0,0 +1,38 @@
+.. _text:
+
+Text Format
+===========
+
+.. _text-instr:
+
+Instructions
+------------
+
+.. _text-blockinstr:
+.. _text-plaininstr:
+.. _text-instr-control:
+
+Control Instructions
+~~~~~~~~~~~~~~~~~~~~
+
+.. _text-try:
+
+The label identifier on a structured control instruction may optionally be repeated after the corresponding :math:`\T{end}`, :math:`\T{else}`, :math:`\T{catch}`, :math:`\T{catch\_all}`, and :math:`\T{delegate}`
+pseudo instructions, to indicate the matching delimiters.
+
+.. math::
+   \begin{array}{@{}llclll}
+   \production{block instruction} & \Tblockinstr_I &::=& \dots \\ &&|&
+     \text{try}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype~~(\X{in}_1{:}\Tinstr_{I'})^\ast~~\\&&&
+       (\text{catch}~~\Tid_1^?~~x{:}\Ttagidx_I~~(\X{in}_2{:}\Tinstr_{I'})^\ast)^\ast~~ \\&&&
+       (\text{catch\_all}~~\Tid_1^?~~(\X{in}_3{:}\Tinstr_{I'})^\ast)^?~~ \\&&&
+       \text{end}~~\Tid_2^?
+       \\ &&&\qquad \Rightarrow\quad \TRY~\X{bt}~\X{in}_1^\ast~(\CATCH~x~\X{in}_2^\ast)^\ast~(\CATCHALL~\X{in}_3^\ast)^?~\END
+       \\ &&&\qquad\qquad (\iff \Tid_1^? = \epsilon \vee \Tid_1^? = \Tlabel, \Tid_2^? = \epsilon \vee \Tid_2^? = \Tlabel) \\ &&|&
+     \text{try}~~I'{:}\Tlabel_I~~\X{bt}{:}\Tblocktype~~(\X{in}_1{:}\Tinstr_{I'})^\ast~~ \\&&&
+       \text{delegate}~~l{:}\Tlabelidx_I~~\X{l}{:}\Tlabelidx_I
+       \\ &&&\qquad \Rightarrow\quad \TRY~\X{bt}~\X{in}_1^\ast~\DELEGATE~l
+       \qquad\quad~~ (\iff \Tid^? = \epsilon \vee \Tid^? = \Tlabel) \\
+   \production{plain instruction} & \Tplaininstr_I &::=& \dots \\ &&|&
+     \text{rethrow}~~l{:}\Tlabelidx_I \quad\Rightarrow\quad \RETHROW~l \\
+   \end{array}
diff --git a/document/legacy/exceptions/core/util/macros.def b/document/legacy/exceptions/core/util/macros.def
new file mode 100644
index 0000000000..e1c2891003
--- /dev/null
+++ b/document/legacy/exceptions/core/util/macros.def
@@ -0,0 +1,1342 @@
+.. LINK MACROS
+
+.. External Standards
+.. ------------------
+
+.. |WasmDraft| replace:: |pagelink|
+.. _WasmDraft: |pagelink|
+
+.. |WasmIssues| replace:: |issuelink|
+.. _WasmIssues: |issuelink|
+
+.. |IEEE754| replace:: IEEE 754
+.. _IEEE754: https://ieeexplore.ieee.org/document/8766229
+
+.. |Unicode| replace:: Unicode
+.. _Unicode: https://www.unicode.org/versions/latest/
+
+.. |ASCII| replace:: ASCII
+.. _ASCII: https://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
+
+.. |MediaType| replace:: Media Type
+.. _MediaType: https://www.iana.org/assignments/media-types/media-types.xhtml
+
+
+.. Literature
+.. ----------
+
+.. |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
+
+.. |FM2021| replace:: Two Mechanisations of WebAssembly 1.0
+.. _FM2021: https://link.springer.com/chapter/10.1007/978-3-030-90870-6_4
+
+.. |TAPL| replace:: Types and Programming Languages
+.. _TAPL: https://www.cis.upenn.edu/~bcpierce/tapl/
+
+
+
+.. MATH MACROS
+
+
+.. Generic Stuff
+.. -------------
+
+.. To comment out stuff
+
+.. |void#1| mathdef:: {}
+
+
+.. Type-setting of names
+.. X - (multi-letter) variables / non-terminals
+.. 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
+
+
+.. Notation
+
+.. |mod| mathdef:: \mathbin{\F{mod}}
+
+.. |iff| mathdef:: \mathrel{\mbox{if}}
+.. |otherwise| mathdef:: \mathrel{\mbox{otherwise}}
+.. |where| mathdef:: \mathrel{\mbox{where}}
+
+
+
+.. Grammar & Syntax Notation
+.. -------------------------
+
+.. Notation for grammars
+
+.. |production| mathdef:: \void
+
+
+.. Notation for Sequences & Records
+
+.. |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}
+.. |unicode#1| mathdef:: \mathrm{U{+}#1}
+
+.. |NAN| mathdef:: \xref{syntax/values}{syntax-float}{\K{nan}}
+
+
+.. Values, non-terminals
+
+.. |byte| mathdef:: \xref{syntax/values}{syntax-byte}{\X{byte}}
+
+.. |uX#1| mathdef:: {\X{u#1}}
+.. |sX#1| mathdef:: {\X{s#1}}
+.. |iX#1| mathdef:: {\X{i#1}}
+.. |fX#1| mathdef:: {\X{f#1}}
+.. |vX#1| mathdef:: {\X{v#1}}
+
+.. |uN| mathdef:: \xref{syntax/values}{syntax-int}{\X{u}N}
+.. |uM| mathdef:: \xref{syntax/values}{syntax-int}{\X{u}M}
+.. |u1| mathdef:: \xref{syntax/values}{syntax-int}{\X{u1}}
+.. |u8| mathdef:: \xref{syntax/values}{syntax-int}{\X{u8}}
+.. |u16| mathdef:: \xref{syntax/values}{syntax-int}{\X{u16}}
+.. |u32| mathdef:: \xref{syntax/values}{syntax-int}{\X{u32}}
+.. |u64| mathdef:: \xref{syntax/values}{syntax-int}{\X{u64}}
+
+.. |sN| mathdef:: \xref{syntax/values}{syntax-int}{\X{s}N}
+.. |s8| mathdef:: \xref{syntax/values}{syntax-int}{\X{s8}}
+.. |s16| mathdef:: \xref{syntax/values}{syntax-int}{\X{s16}}
+.. |s32| mathdef:: \xref{syntax/values}{syntax-int}{\X{s32}}
+.. |s64| mathdef:: \xref{syntax/values}{syntax-int}{\X{s64}}
+
+.. |iM| mathdef:: \xref{syntax/values}{syntax-int}{\X{i}M}
+.. |iN| mathdef:: \xref{syntax/values}{syntax-int}{\X{i}N}
+.. |i8| mathdef:: \xref{syntax/values}{syntax-int}{\X{i8}}
+.. |i16| mathdef:: \xref{syntax/values}{syntax-int}{\X{i16}}
+.. |i32| mathdef:: \xref{syntax/values}{syntax-int}{\X{i32}}
+.. |i64| mathdef:: \xref{syntax/values}{syntax-int}{\X{i64}}
+.. |i128| mathdef:: \xref{syntax/values}{syntax-int}{\X{i128}}
+
+.. |fN| mathdef:: \xref{syntax/values}{syntax-float}{\X{f}N}
+.. |fNmag| mathdef:: \xref{syntax/values}{syntax-float}{\X{f}\X{Nmag}}
+.. |f32| mathdef:: \xref{syntax/values}{syntax-float}{\X{f32}}
+.. |f64| mathdef:: \xref{syntax/values}{syntax-float}{\X{f64}}
+
+.. |name| mathdef:: \xref{syntax/values}{syntax-name}{\X{name}}
+.. |char| mathdef:: \xref{syntax/values}{syntax-name}{\X{char}}
+
+
+.. Values, meta functions
+
+.. |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}}
+
+
+.. Types, terminals
+
+.. |to| mathdef:: \xref{syntax/types}{syntax-functype}{\rightarrow}
+.. |toF| 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}}
+.. |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}}
+.. |V128| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{v128}}
+.. |I8X16| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i8x16}}
+.. |I16X8| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i16x8}}
+.. |I32X4| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i32x4}}
+.. |I64X2| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{i64x2}}
+.. |F32X4| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f32x4}}
+.. |F64X2| mathdef:: \xref{syntax/types}{syntax-valtype}{\K{f64x2}}
+.. |I128| mathdef:: \K{i128}
+
+.. |FUNCREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{funcref}}
+.. |EXTERNREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{externref}}
+.. |EXNREF| mathdef:: \xref{syntax/types}{syntax-reftype}{\K{exnref}}
+
+.. |MVAR| mathdef:: \xref{syntax/types}{syntax-mut}{\K{var}}
+.. |MCONST| mathdef:: \xref{syntax/types}{syntax-mut}{\K{const}}
+
+.. |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}}
+.. |ETTAG| mathdef:: \xref{syntax/types}{syntax-tagtype}{\K{tag}}
+
+
+.. Types, non-terminals
+
+.. |numtype| mathdef:: \xref{syntax/types}{syntax-numtype}{\X{numtype}}
+.. |vectype| mathdef:: \xref{syntax/types}{syntax-vectype}{\X{vectype}}
+.. |reftype| mathdef:: \xref{syntax/types}{syntax-reftype}{\X{reftype}}
+.. |valtype| mathdef:: \xref{syntax/types}{syntax-valtype}{\X{valtype}}
+.. |resulttype| mathdef:: \xref{syntax/types}{syntax-resulttype}{\X{resulttype}}
+.. |functype| mathdef:: \xref{syntax/types}{syntax-functype}{\X{functype}}
+.. |tagtype| mathdef:: \xref{syntax/types}{syntax-tagtype}{\X{tagtype}}
+
+.. |globaltype| mathdef:: \xref{syntax/types}{syntax-globaltype}{\X{globaltype}}
+.. |tabletype| mathdef:: \xref{syntax/types}{syntax-tabletype}{\X{tabletype}}
+.. |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}}
+
+.. |externtype| mathdef:: \xref{syntax/types}{syntax-externtype}{\X{externtype}}
+
+.. |stacktype| mathdef:: \xref{syntax/types}{syntax-stacktype}{\X{stacktype}}
+.. |opdtype| mathdef:: \xref{syntax/types}{syntax-opdtype}{\X{opdtype}}
+
+
+.. Types, meta functions
+
+.. |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}}
+.. |ettags| mathdef:: \xref{syntax/types}{syntax-externtype}{\F{tags}}
+
+
+.. Indices, non-terminals
+
+.. |typeidx| mathdef:: \xref{syntax/modules}{syntax-typeidx}{\X{typeidx}}
+.. |funcidx| mathdef:: \xref{syntax/modules}{syntax-funcidx}{\X{funcidx}}
+.. |tableidx| mathdef:: \xref{syntax/modules}{syntax-tableidx}{\X{tableidx}}
+.. |memidx| mathdef:: \xref{syntax/modules}{syntax-memidx}{\X{memidx}}
+.. |globalidx| mathdef:: \xref{syntax/modules}{syntax-globalidx}{\X{globalidx}}
+.. |elemidx| mathdef:: \xref{syntax/modules}{syntax-elemidx}{\X{elemidx}}
+.. |dataidx| mathdef:: \xref{syntax/modules}{syntax-dataidx}{\X{dataidx}}
+.. |localidx| mathdef:: \xref{syntax/modules}{syntax-localidx}{\X{localidx}}
+.. |labelidx| mathdef:: \xref{syntax/modules}{syntax-labelidx}{\X{labelidx}}
+.. |tagidx| mathdef:: \xref{syntax/modules}{syntax-tagidx}{\X{tagidx}}
+
+
+.. Indices, meta functions
+
+.. |freetypeidx| mathdef:: \xref{syntax/modules}{syntax-typeidx}{\F{typeidx}}
+.. |freefuncidx| mathdef:: \xref{syntax/modules}{syntax-funcidx}{\F{funcidx}}
+.. |freetableidx| mathdef:: \xref{syntax/modules}{syntax-tableidx}{\F{tableidx}}
+.. |freememidx| mathdef:: \xref{syntax/modules}{syntax-memidx}{\F{memidx}}
+.. |freeglobalidx| mathdef:: \xref{syntax/modules}{syntax-globalidx}{\F{globalidx}}
+.. |freeelemidx| mathdef:: \xref{syntax/modules}{syntax-elemidx}{\F{elemidx}}
+.. |freedataidx| mathdef:: \xref{syntax/modules}{syntax-dataidx}{\F{dataidx}}
+.. |freelocalidx| mathdef:: \xref{syntax/modules}{syntax-localidx}{\F{localidx}}
+.. |freelabelidx| mathdef:: \xref{syntax/modules}{syntax-labelidx}{\F{labelidx}}
+
+
+.. Modules, terminals
+
+.. |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}}
+.. |MTAGS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{tags}}
+.. |MIMPORTS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{imports}}
+.. |MEXPORTS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{exports}}
+.. |MDATAS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{datas}}
+.. |MELEMS| mathdef:: \xref{syntax/modules}{syntax-module}{\K{elems}}
+.. |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}}
+
+.. |TAGTYPE| mathdef:: \xref{syntax/modules}{syntax-tag}{\K{type}}
+
+.. |GTYPE| mathdef:: \xref{syntax/modules}{syntax-global}{\K{type}}
+.. |GINIT| mathdef:: \xref{syntax/modules}{syntax-global}{\K{init}}
+
+.. |ETYPE| mathdef:: \xref{syntax/modules}{syntax-elem}{\K{type}}
+.. |EINIT| mathdef:: \xref{syntax/modules}{syntax-elem}{\K{init}}
+.. |EMODE| mathdef:: \xref{syntax/modules}{syntax-elem}{\K{mode}}
+.. |EPASSIVE| mathdef:: \xref{syntax/modules}{syntax-elemmode}{\K{passive}}
+.. |EACTIVE| mathdef:: \xref{syntax/modules}{syntax-elemmode}{\K{active}}
+.. |EDECLARATIVE| mathdef:: \xref{syntax/modules}{syntax-elemmode}{\K{declarative}}
+.. |ETABLE| mathdef:: \xref{syntax/modules}{syntax-elem}{\K{table}}
+.. |EOFFSET| mathdef:: \xref{syntax/modules}{syntax-elem}{\K{offset}}
+
+.. |DINIT| mathdef:: \xref{syntax/modules}{syntax-data}{\K{init}}
+.. |DMODE| mathdef:: \xref{syntax/modules}{syntax-data}{\K{mode}}
+.. |DPASSIVE| mathdef:: \xref{syntax/modules}{syntax-datamode}{\K{passive}}
+.. |DACTIVE| mathdef:: \xref{syntax/modules}{syntax-datamode}{\K{active}}
+.. |DMEM| mathdef:: \xref{syntax/modules}{syntax-data}{\K{memory}}
+.. |DOFFSET| mathdef:: \xref{syntax/modules}{syntax-data}{\K{offset}}
+
+.. |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}}
+.. |EDTAG| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\K{tag}}
+
+.. |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}}
+.. |IDTAG| mathdef:: \xref{syntax/modules}{syntax-importdesc}{\K{tag}}
+.. |IDGLOBAL| mathdef:: \xref{syntax/modules}{syntax-importdesc}{\K{global}}
+
+
+.. Modules, non-terminals
+
+.. |module| mathdef:: \xref{syntax/modules}{syntax-module}{\X{module}}
+.. |type| mathdef:: \xref{syntax/types}{syntax-functype}{\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}}
+.. |tag| mathdef:: \xref{syntax/modules}{syntax-tag}{\X{tag}}
+.. |global| mathdef:: \xref{syntax/modules}{syntax-global}{\X{global}}
+.. |import| mathdef:: \xref{syntax/modules}{syntax-import}{\X{import}}
+.. |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-elem}{\X{elem}}
+.. |elemmode| mathdef:: \xref{syntax/modules}{syntax-elemmode}{\X{elemmode}}
+.. |data| mathdef:: \xref{syntax/modules}{syntax-data}{\X{data}}
+.. |datamode| mathdef:: \xref{syntax/modules}{syntax-datamode}{\X{datamode}}
+.. |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}}
+.. |edtags| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\F{tags}}
+.. |edglobals| mathdef:: \xref{syntax/modules}{syntax-exportdesc}{\F{globals}}
+
+
+.. Instructions, terminals
+
+.. |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}}
+.. |BLOCK| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{block}}
+.. |LOOP| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{loop}}
+.. |IF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{if}}
+.. |ELSE| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{else}}
+.. |END| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{end}}
+.. |BR| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br}}
+.. |BRIF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br\_if}}
+.. |BRTABLE| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{br\_table}}
+.. |RETURN| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{return}}
+.. |CALL| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{call}}
+.. |CALLINDIRECT| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{call\_indirect}}
+.. |TRYTABLE| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{try\_table}}
+.. |TRY| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{try}}
+.. |CATCH| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{catch}}
+.. |CATCHREF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{catch\_ref}}
+.. |CATCHALL| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{catch\_all}}
+.. |CATCHALLREF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{catch\_all\_ref}}
+.. |DELEGATE| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{delegate}}
+.. |THROW| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{throw}}
+.. |THROWREF| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{throw\_ref}}
+.. |RETHROW| mathdef:: \xref{syntax/instructions}{syntax-instr-control}{\K{rethrow}}
+
+.. |DROP| mathdef:: \xref{syntax/instructions}{syntax-instr-parametric}{\K{drop}}
+.. |SELECT| mathdef:: \xref{syntax/instructions}{syntax-instr-parametric}{\K{select}}
+
+.. |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}}
+
+.. |TABLEGET| mathdef:: \xref{syntax/instructions}{syntax-instr-table}{\K{table.get}}
+.. |TABLESET| mathdef:: \xref{syntax/instructions}{syntax-instr-table}{\K{table.set}}
+.. |TABLESIZE| mathdef:: \xref{syntax/instructions}{syntax-instr-table}{\K{table.size}}
+.. |TABLEGROW| mathdef:: \xref{syntax/instructions}{syntax-instr-table}{\K{table.grow}}
+.. |TABLEFILL| mathdef:: \xref{syntax/instructions}{syntax-instr-table}{\K{table.fill}}
+.. |TABLECOPY| mathdef:: \xref{syntax/instructions}{syntax-instr-table}{\K{table.copy}}
+.. |TABLEINIT| mathdef:: \xref{syntax/instructions}{syntax-instr-table}{\K{table.init}}
+.. |ELEMDROP| mathdef:: \xref{syntax/instructions}{syntax-instr-table}{\K{elem.drop}}
+
+.. |LOAD| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{load}}
+.. |STORE| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{store}}
+.. |MEMORYSIZE| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{memory.size}}
+.. |MEMORYGROW| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{memory.grow}}
+.. |MEMORYFILL| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{memory.fill}}
+.. |MEMORYCOPY| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{memory.copy}}
+.. |MEMORYINIT| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{memory.init}}
+.. |DATADROP| mathdef:: \xref{syntax/instructions}{syntax-instr-memory}{\K{data.drop}}
+
+.. |REFNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}null}}
+.. |REFISNULL| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}is\_null}}
+.. |REFFUNC| mathdef:: \xref{syntax/instructions}{syntax-instr-ref}{\K{ref{.}func}}
+
+.. |CONST| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{const}}
+.. |EQZ| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{eqz}}
+.. |EQ| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{eq}}
+.. |NE| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{ne}}
+.. |LT| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{lt}}
+.. |GT| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{gt}}
+.. |LE| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{le}}
+.. |GE| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{ge}}
+.. |CLZ| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{clz}}
+.. |CTZ| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{ctz}}
+.. |POPCNT| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{popcnt}}
+.. |ABS| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{abs}}
+.. |NEG| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{neg}}
+.. |CEIL| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{ceil}}
+.. |FLOOR| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{floor}}
+.. |TRUNC| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{trunc}}
+.. |NEAREST| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{nearest}}
+.. |SQRT| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{sqrt}}
+.. |ADD| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{add}}
+.. |SUB| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{sub}}
+.. |MUL| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{mul}}
+.. |DIV| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{div}}
+.. |REM| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{rem}}
+.. |FMIN| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{min}}
+.. |FMAX| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{max}}
+.. |AND| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{and}}
+.. |OR| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{or}}
+.. |XOR| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{xor}}
+.. |SHL| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{shl}}
+.. |SHR| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{shr}}
+.. |ROTL| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{rotl}}
+.. |ROTR| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{rotr}}
+.. |COPYSIGN| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{copysign}}
+
+.. |CONVERT| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{convert}}
+.. |EXTEND| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{extend}}
+.. |WRAP| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{wrap}}
+.. |PROMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{promote}}
+.. |DEMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{demote}}
+.. |REINTERPRET| mathdef:: \xref{syntax/instructions}{syntax-instr-numeric}{\K{reinterpret}}
+
+.. |VCONST| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{const}}
+.. |SHUFFLE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{shuffle}}
+.. |SWIZZLE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{swizzle}}
+.. |SPLAT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{splat}}
+.. |EXTRACTLANE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extract\_lane}}
+.. |REPLACELANE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{replace\_lane}}
+.. |VNOT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{not}}
+.. |VAND| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{and}}
+.. |VANDNOT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{andnot}}
+.. |VOR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{or}}
+.. |VXOR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{xor}}
+.. |BITSELECT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{bitselect}}
+.. |VEQ| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{eq}}
+.. |VNE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{ne}}
+.. |VLT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{lt}}
+.. |VGT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{gt}}
+.. |VLE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{le}}
+.. |VGE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{ge}}
+.. |VABS| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{abs}}
+.. |VNEG| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{neg}}
+.. |VCEIL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{ceil}}
+.. |VFLOOR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{floor}}
+.. |VTRUNC| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{trunc}}
+.. |VNEAREST| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{nearest}}
+.. |VPOPCNT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{popcnt}}
+.. |ANYTRUE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{any\_true}}
+.. |ALLTRUE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{all\_true}}
+.. |BITMASK| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{bitmask}}
+.. |VSHL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{shl}}
+.. |VSHR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{shr}}
+.. |VSQRT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{sqrt}}
+.. |VADD| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{add}}
+.. |VSUB| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{sub}}
+.. |VMUL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{mul}}
+.. |VDIV| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{div}}
+.. |VMIN| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{min}}
+.. |VMAX| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{max}}
+.. |VPMIN| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{pmin}}
+.. |VPMAX| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{pmax}}
+.. |NARROW| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{narrow}}
+.. |VEXTEND| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extend}}
+.. |AVGR| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{avgr}}
+.. |DOT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{dot}}
+.. |EXTMUL| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extmul}}
+.. |VCONVERT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{convert}}
+.. |Q15MULRSAT| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{q15mulr\_sat}}
+.. |EXTADDPAIRWISE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{extadd\_pairwise}}
+.. |VDEMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{demote}}
+.. |VPROMOTE| mathdef:: \xref{syntax/instructions}{syntax-instr-vec}{\K{promote}}
+
+
+.. Instructions, non-terminals
+
+.. |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}}
+
+.. |ishape| mathdef:: \xref{syntax/instructions}{syntax-shape}{\X{ishape}}
+.. |fshape| mathdef:: \xref{syntax/instructions}{syntax-shape}{\X{fshape}}
+.. |shape| mathdef:: \xref{syntax/instructions}{syntax-shape}{\X{shape}}
+
+.. |vunop| mathdef:: \xref{syntax/instructions}{syntax-vunop}{\X{vunop}}
+.. |vbinop| mathdef:: \xref{syntax/instructions}{syntax-vbinop}{\X{vbinop}}
+.. |vrelop| mathdef:: \xref{syntax/instructions}{syntax-vrelop}{\X{vrelop}}
+.. |vternop| mathdef:: \xref{syntax/instructions}{syntax-vternop}{\X{vternop}}
+.. |vcvtop| mathdef:: \xref{syntax/instructions}{syntax-vcvtop}{\X{vcvtop}}
+.. |vextmul| mathdef:: \xref{syntax/instructions}{syntax-vextmul}{\X{vextmul}}
+
+.. |laneidx| mathdef:: \xref{syntax/instructions}{syntax-laneidx}{\X{laneidx}}
+.. |vvunop| mathdef:: \xref{syntax/instructions}{syntax-vvunop}{\X{vvunop}}
+.. |vvbinop| mathdef:: \xref{syntax/instructions}{syntax-vvbinop}{\X{vvbinop}}
+.. |vvternop| mathdef:: \xref{syntax/instructions}{syntax-vvternop}{\X{vvternop}}
+.. |vvtestop| mathdef:: \xref{syntax/instructions}{syntax-vvtestop}{\X{vvtestop}}
+.. |vishiftop| mathdef:: \xref{syntax/instructions}{syntax-vishiftop}{\X{vishiftop}}
+.. |viunop| mathdef:: \xref{syntax/instructions}{syntax-viunop}{\X{viunop}}
+.. |vibinop| mathdef:: \xref{syntax/instructions}{syntax-vibinop}{\X{vibinop}}
+.. |viminmaxop| mathdef:: \xref{syntax/instructions}{syntax-viminmaxop}{\X{viminmaxop}}
+.. |visatbinop| mathdef:: \xref{syntax/instructions}{syntax-visatbinop}{\X{visatbinop}}
+.. |vfunop| mathdef:: \xref{syntax/instructions}{syntax-vfunop}{\X{vfunop}}
+.. |vfbinop| mathdef:: \xref{syntax/instructions}{syntax-vfbinop}{\X{vfbinop}}
+.. |virelop| mathdef:: \xref{syntax/instructions}{syntax-virelop}{\X{virelop}}
+.. |vfrelop| mathdef:: \xref{syntax/instructions}{syntax-vfrelop}{\X{vfrelop}}
+.. |vitestop| mathdef:: \xref{syntax/instructions}{syntax-vitestop}{\X{vitestop}}
+.. |vtestop| mathdef:: \xref{syntax/instructions}{syntax-vtestop}{\X{vtestop}}
+
+.. |sx| mathdef:: \xref{syntax/instructions}{syntax-sx}{\X{sx}}
+.. |half| mathdef:: \xref{syntax/instructions}{syntax-half}{\X{half}}
+.. |memarg| mathdef:: \xref{syntax/instructions}{syntax-memarg}{\X{memarg}}
+
+.. |blocktype| mathdef:: \xref{syntax/instructions}{syntax-blocktype}{\X{blocktype}}
+
+.. |instr| mathdef:: \xref{syntax/instructions}{syntax-instr}{\X{instr}}
+.. |catch| mathdef:: \xref{syntax/instructions}{syntax-catch}{\X{catch}}
+.. |expr| mathdef:: \xref{syntax/instructions}{syntax-expr}{\X{expr}}
+
+
+
+.. 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}}
+
+.. |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}}
+.. |Bs7| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{7}}}
+.. |Bs32| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{32}}}
+.. |Bs33| mathdef:: \xref{binary/values}{binary-int}{\BsX{\B{33}}}
+.. |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}}}
+
+.. |Bname| mathdef:: \xref{binary/values}{binary-name}{\B{name}}
+
+
+.. Values, meta functions
+
+.. |utf8| mathdef:: \xref{binary/values}{binary-utf8}{\F{utf8}}
+
+
+.. Types, non-terminals
+
+.. |Bnumtype| mathdef:: \xref{binary/types}{binary-numtype}{\B{numtype}}
+.. |Bvectype| mathdef:: \xref{binary/types}{binary-vectype}{\B{vectype}}
+.. |Breftype| mathdef:: \xref{binary/types}{binary-reftype}{\B{reftype}}
+.. |Bvaltype| mathdef:: \xref{binary/types}{binary-valtype}{\B{valtype}}
+.. |Bresulttype| mathdef:: \xref{binary/types}{binary-resulttype}{\B{resulttype}}
+.. |Bfunctype| mathdef:: \xref{binary/types}{binary-functype}{\B{functype}}
+.. |Bglobaltype| mathdef:: \xref{binary/types}{binary-globaltype}{\B{globaltype}}
+.. |Btagtype| mathdef:: \xref{binary/types}{binary-tagtype}{\B{tagtype}}
+.. |Btabletype| mathdef:: \xref{binary/types}{binary-tabletype}{\B{tabletype}}
+.. |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
+
+.. |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}}
+.. |Bmemidx| mathdef:: \xref{binary/modules}{binary-memidx}{\B{memidx}}
+.. |Btagidx| mathdef:: \xref{binary/modules}{binary-tagidx}{\B{tagidx}}
+.. |Bglobalidx| mathdef:: \xref{binary/modules}{binary-globalidx}{\B{globalidx}}
+.. |Belemidx| mathdef:: \xref{binary/modules}{binary-elemidx}{\B{elemidx}}
+.. |Bdataidx| mathdef:: \xref{binary/modules}{binary-dataidx}{\B{dataidx}}
+.. |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-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}}
+.. |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}}
+.. |Btagsec| mathdef:: \xref{binary/modules}{binary-tagsec}{\B{tagsec}}
+.. |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}}
+.. |Bdatacountsec| mathdef:: \xref{binary/modules}{binary-datacountsec}{\B{datacountsec}}
+
+.. |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}}
+.. |Btag| mathdef:: \xref{binary/modules}{binary-tag}{\B{tag}}
+.. |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}}
+.. |Belemkind| mathdef:: \xref{binary/modules}{binary-elemkind}{\B{elemkind}}
+.. |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}}
+.. |Bblocktype| mathdef:: \xref{binary/instructions}{binary-blocktype}{\B{blocktype}}
+
+.. |Binstr| mathdef:: \xref{binary/instructions}{binary-instr}{\B{instr}}
+.. |Bcatch| mathdef:: \xref{binary/instructions}{binary-catch}{\B{catch}}
+.. |Bexpr| mathdef:: \xref{binary/instructions}{binary-expr}{\B{expr}}
+
+.. |Blaneidx| mathdef:: \xref{binary/instructions}{binary-laneidx}{\B{laneidx}}
+
+
+.. Text Format
+.. -----------
+
+.. Auxiliary productions
+
+.. |Tvec| mathdef:: \xref{text/conventions}{text-vec}{\T{vec}}
+
+
+.. 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
+
+.. |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}}
+
+.. |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
+
+.. |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}}
+.. |Ti8| mathdef:: \xref{text/values}{text-int}{\TiX{\T{8}}}
+.. |Ti16| mathdef:: \xref{text/values}{text-int}{\TiX{\T{16}}}
+.. |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}}}
+
+.. |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}}
+
+.. |Tid| mathdef:: \xref{text/values}{text-id}{\T{id}}
+.. |Tidchar| mathdef:: \xref{text/values}{text-idchar}{\T{idchar}}
+
+
+.. Types, non-terminals
+
+.. |Tnumtype| mathdef:: \xref{text/types}{text-numtype}{\T{numtype}}
+.. |Tvectype| mathdef:: \xref{text/types}{text-vectype}{\T{vectype}}
+.. |Treftype| mathdef:: \xref{text/types}{text-reftype}{\T{reftype}}
+.. |Theaptype| mathdef:: \xref{text/types}{text-heaptype}{\T{heaptype}}
+.. |Tvaltype| mathdef:: \xref{text/types}{text-valtype}{\T{valtype}}
+.. |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}}
+.. |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}}
+.. |Ttagidx| mathdef:: \xref{text/modules}{text-tagidx}{\T{tagidx}}
+.. |Tglobalidx| mathdef:: \xref{text/modules}{text-globalidx}{\T{globalidx}}
+.. |Telemidx| mathdef:: \xref{text/modules}{text-elemidx}{\T{elemidx}}
+.. |Tdataidx| mathdef:: \xref{text/modules}{text-dataidx}{\T{dataidx}}
+.. |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}}
+.. |Ttag| mathdef:: \xref{text/modules}{text-tag}{\T{tag}}
+.. |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}}
+.. |Telemlist| mathdef:: \xref{text/modules}{text-elemlist}{\T{elemlist}}
+.. |Telemexpr| mathdef:: \xref{text/modules}{text-elemexpr}{\T{elemexpr}}
+.. |Ttableuse| mathdef:: \xref{text/modules}{text-tableuse}{\T{tableuse}}
+.. |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}}
+.. |Tmemuse| mathdef:: \xref{text/modules}{text-memuse}{\T{memuse}}
+.. |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}}
+.. |Toffset| mathdef:: \xref{text/instructions}{text-memarg}{\T{offset}}
+
+.. |Tblocktype| mathdef:: \xref{text/instructions}{text-blocktype}{\T{blocktype}}
+
+.. |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}}
+.. |Tcatch| mathdef:: \xref{text/instructions}{text-catch}{\T{catch}}
+.. |Texpr| mathdef:: \xref{text/instructions}{text-expr}{\T{expr}}
+
+
+
+.. Parsing
+.. -------
+
+.. Contexts
+
+.. |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}}
+.. |ITAGS| mathdef:: \xref{text/conventions}{text-context}{\K{tags}}
+.. |IGLOBALS| mathdef:: \xref{text/conventions}{text-context}{\K{globals}}
+.. |IELEM| mathdef:: \xref{text/conventions}{text-context}{\K{elem}}
+.. |IDATA| mathdef:: \xref{text/conventions}{text-context}{\K{data}}
+.. |ILOCALS| mathdef:: \xref{text/conventions}{text-context}{\K{locals}}
+.. |ILABELS| mathdef:: \xref{text/conventions}{text-context}{\K{labels}}
+
+
+.. Meta Functions
+
+.. |idfresh| mathdef:: ~\xref{text/values}{text-id-fresh}{\mbox{fresh}}
+.. |idcwellformed| mathdef:: ~\xref{text/conventions}{text-context-wf}{\mbox{well-formed}}
+
+
+
+
+.. Validation
+.. ----------
+
+.. Notation
+
+.. |ok| mathdef:: \mathrel{\mbox{ok}}
+.. |const| mathdef:: \xref{valid/instructions}{valid-constant}{\mathrel{\mbox{const}}}
+
+.. Contexts, terminals
+
+.. |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}}
+.. |CTAGS| mathdef:: \xref{valid/conventions}{context}{\K{tags}}
+.. |CGLOBALS| mathdef:: \xref{valid/conventions}{context}{\K{globals}}
+.. |CELEMS| mathdef:: \xref{valid/conventions}{context}{\K{elems}}
+.. |CDATAS| mathdef:: \xref{valid/conventions}{context}{\K{datas}}
+.. |CLOCALS| mathdef:: \xref{valid/conventions}{context}{\K{locals}}
+.. |CLABELS| mathdef:: \xref{valid/conventions}{context}{\K{labels}}
+.. |CRETURN| mathdef:: \xref{valid/conventions}{context}{\K{return}}
+.. |CREFS| mathdef:: \xref{valid/conventions}{context}{\K{refs}}
+.. |LCATCH| mathdef:: \xref{valid/conventions}{context}{\K{catch}}
+
+.. Contexts, non-terminals
+
+.. |labeltype| mathdef:: \xref{valid/conventions}{context}{\X{labeltype}}
+
+
+.. Judgments
+
+.. |vdashlimits| mathdef:: \xref{valid/types}{valid-limits}{\vdash}
+.. |vdashblocktype| mathdef:: \xref{valid/types}{valid-blocktype}{\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}
+.. |vdashtagtype| mathdef:: \xref{valid/types}{valid-tagtype}{\vdash}
+.. |vdashglobaltype| mathdef:: \xref{valid/types}{valid-globaltype}{\vdash}
+.. |vdashexterntype| mathdef:: \xref{valid/types}{valid-externtype}{\vdash}
+
+.. |vdashinstr| mathdef:: \xref{valid/instructions}{valid-instr}{\vdash}
+.. |vdashinstrseq| mathdef:: \xref{valid/instructions}{valid-instr-seq}{\vdash}
+.. |vdashcatch| mathdef:: \xref{valid/instructions}{valid-catch}{\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}
+.. |vdashtag| mathdef:: \xref{valid/modules}{valid-tag}{\vdash}
+.. |vdashglobal| mathdef:: \xref{valid/modules}{valid-global}{\vdash}
+.. |vdashelem| mathdef:: \xref{valid/modules}{valid-elem}{\vdash}
+.. |vdashelemmode| mathdef:: \xref{valid/modules}{valid-elemmode}{\vdash}
+.. |vdashdata| mathdef:: \xref{valid/modules}{valid-data}{\vdash}
+.. |vdashdatamode| mathdef:: \xref{valid/modules}{valid-datamode}{\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}
+
+.. |unpacked| mathdef:: \xref{valid/instructions}{aux-unpacked}{\F{unpacked}}
+.. |dim| mathdef:: \xref{valid/instructions}{aux-dim}{\F{dim}}
+
+
+.. Execution
+.. ---------
+
+.. Notation
+
+.. |stepto| mathdef:: \xref{exec/conventions}{formal-notation}{\hookrightarrow}
+.. |extendsto| mathdef:: \xref{appendix/properties}{extend}{\preceq}
+.. |matchesexterntype| mathdef:: \xref{exec/modules}{match-externtype}{\leq}
+.. |matcheslimits| mathdef:: \xref{exec/modules}{match-limits}{\leq}
+
+
+.. 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}}
+.. |alloctag| mathdef:: \xref{exec/modules}{alloc-tag}{\F{alloctag}}
+.. |allocglobal| mathdef:: \xref{exec/modules}{alloc-global}{\F{allocglobal}}
+.. |allocelem| mathdef:: \xref{exec/modules}{alloc-elem}{\F{allocelem}}
+.. |allocdata| mathdef:: \xref{exec/modules}{alloc-data}{\F{allocdata}}
+.. |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
+
+.. |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}}
+.. |tagaddr| mathdef:: \xref{exec/runtime}{syntax-tagaddr}{\X{tagaddr}}
+.. |globaladdr| mathdef:: \xref{exec/runtime}{syntax-globaladdr}{\X{globaladdr}}
+.. |elemaddr| mathdef:: \xref{exec/runtime}{syntax-elemaddr}{\X{elemaddr}}
+.. |dataaddr| mathdef:: \xref{exec/runtime}{syntax-dataaddr}{\X{dataaddr}}
+.. |exnaddr| mathdef:: \xref{exec/runtime}{syntax-exnaddr}{\X{exnaddr}}
+.. |externaddr| mathdef:: \xref{exec/runtime}{syntax-externaddr}{\X{externaddr}}
+
+.. Instances, terminals
+
+.. |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}}
+
+.. |TITYPE| mathdef:: \xref{exec/runtime}{syntax-tableinst}{\K{type}}
+.. |TIELEM| mathdef:: \xref{exec/runtime}{syntax-tableinst}{\K{elem}}
+
+.. |MITYPE| mathdef:: \xref{exec/runtime}{syntax-meminst}{\K{type}}
+.. |MIDATA| mathdef:: \xref{exec/runtime}{syntax-meminst}{\K{data}}
+
+.. |TAGITYPE| mathdef:: \xref{exec/runtime}{syntax-taginst}{\K{type}}
+
+.. |GITYPE| mathdef:: \xref{exec/runtime}{syntax-globalinst}{\K{type}}
+.. |GIVALUE| mathdef:: \xref{exec/runtime}{syntax-globalinst}{\K{value}}
+
+.. |EITYPE| mathdef:: \xref{exec/runtime}{syntax-eleminst}{\K{type}}
+.. |EIELEM| mathdef:: \xref{exec/runtime}{syntax-eleminst}{\K{elem}}
+
+.. |DIDATA| mathdef:: \xref{exec/runtime}{syntax-datainst}{\K{data}}
+
+.. |EITAG| mathdef:: \xref{exec/runtime}{syntax-exninst}{\K{tag}}
+.. |EIFIELDS| mathdef:: \xref{exec/runtime}{syntax-exninst}{\K{fields}}
+
+.. |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}}
+.. |EVTAG| mathdef:: \xref{exec/runtime}{syntax-externval}{\K{tag}}
+.. |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}}
+.. |MITAGS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{tagaddrs}}
+.. |MIGLOBALS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{globaladdrs}}
+.. |MIELEMS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{elemaddrs}}
+.. |MIDATAS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{dataaddrs}}
+.. |MIEXPORTS| mathdef:: \xref{exec/runtime}{syntax-moduleinst}{\K{exports}}
+
+
+.. 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}}
+.. |meminst| mathdef:: \xref{exec/runtime}{syntax-meminst}{\X{meminst}}
+.. |taginst| mathdef:: \xref{exec/runtime}{syntax-taginst}{\X{taginst}}
+.. |globalinst| mathdef:: \xref{exec/runtime}{syntax-globalinst}{\X{globalinst}}
+.. |eleminst| mathdef:: \xref{exec/runtime}{syntax-eleminst}{\X{eleminst}}
+.. |datainst| mathdef:: \xref{exec/runtime}{syntax-datainst}{\X{datainst}}
+.. |exninst| mathdef:: \xref{exec/runtime}{syntax-exninst}{\X{exninst}}
+.. |exportinst| mathdef:: \xref{exec/runtime}{syntax-exportinst}{\X{exportinst}}
+
+.. |hostfunc| mathdef:: \xref{exec/runtime}{syntax-hostfunc}{\X{hostfunc}}
+
+
+.. 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}}
+.. |evtags| mathdef:: \xref{exec/runtime}{syntax-externval}{\F{tags}}
+.. |evglobals| mathdef:: \xref{exec/runtime}{syntax-externval}{\F{globals}}
+
+
+.. 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}}
+.. |STAGS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{tags}}
+.. |SGLOBALS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{globals}}
+.. |SELEMS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{elems}}
+.. |SDATAS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{datas}}
+.. |SEXNS| mathdef:: \xref{exec/runtime}{syntax-store}{\K{exns}}
+
+.. Store, non-terminals
+
+.. |store| mathdef:: \xref{exec/runtime}{syntax-store}{\X{store}}
+
+
+.. 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}}
+.. |handler| mathdef:: \xref{exec/runtime}{syntax-handler}{\X{handler}}
+
+.. Stack, meta functions
+
+.. |expand| mathdef:: \xref{exec/runtime}{exec-expand}{\F{expand}}
+
+
+.. Administrative Instructions, terminals
+
+.. |REFFUNCADDR| mathdef:: \xref{exec/runtime}{syntax-ref}{\K{ref}}
+.. |REFEXNADDR| mathdef:: \xref{exec/runtime}{syntax-ref.exn-addr}{\K{ref{.}exn}}
+.. |REFEXTERNADDR| mathdef:: \xref{exec/runtime}{syntax-ref.extern-addr}{\K{ref{.}extern}}
+.. |TRAP| mathdef:: \xref{exec/runtime}{syntax-trap}{\K{trap}}
+.. |INVOKE| mathdef:: \xref{exec/runtime}{syntax-invoke}{\K{invoke}}
+.. |HANDLER| mathdef:: \xref{exec/runtime}{syntax-handler}{\K{handler}}
+.. |CAUGHT| mathdef:: \xref{exec/runtime}{syntax-caught}{\K{caught}}
+
+
+.. Values & Results, non-terminals
+
+.. |num| mathdef:: \xref{exec/runtime}{syntax-num}{\X{num}}
+.. |vecc| mathdef:: \xref{exec/runtime}{syntax-vec}{\X{vec}}
+.. |reff| mathdef:: \xref{exec/runtime}{syntax-ref}{\X{ref}}
+.. |val| mathdef:: \xref{exec/runtime}{syntax-val}{\X{val}}
+.. |result| mathdef:: \xref{exec/runtime}{syntax-result}{\X{result}}
+
+
+.. Values, meta-functions
+
+.. |default| mathdef:: \xref{exec/runtime}{default-val}{\F{default}}
+
+
+.. Administrative Instructions, non-terminals
+
+.. |XB| mathdef:: \xref{exec/runtime}{syntax-ctxt-block}{B}
+.. |XC| mathdef:: \xref{exec/runtime}{syntax-ctxt-block}{C}
+.. |XT| mathdef:: \xref{exec/runtime}{syntax-ctxt-throw}{T}
+
+
+.. 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}}
+.. |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}}
+.. |inot| mathdef:: \xref{exec/numerics}{op-inot}{\F{inot}}
+.. |iand| mathdef:: \xref{exec/numerics}{op-iand}{\F{iand}}
+.. |iandnot| mathdef:: \xref{exec/numerics}{op-iandnot}{\F{iandnot}}
+.. |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}}
+.. |iextendMs| mathdef:: \xref{exec/numerics}{op-iextendn_s}{\F{iextend}M\F{\_s}}
+.. |ibitselect| mathdef:: \xref{exec/numerics}{op-ibitselect}{\F{ibitselect}}
+.. |iabs| mathdef:: \xref{exec/numerics}{op-iabs}{\F{iabs}}
+.. |ineg| mathdef:: \xref{exec/numerics}{op-ineg}{\F{ineg}}
+.. |iminu| mathdef:: \xref{exec/numerics}{op-imin_u}{\F{imin\_u}}
+.. |imins| mathdef:: \xref{exec/numerics}{op-imin_s}{\F{imin\_s}}
+.. |imaxu| mathdef:: \xref{exec/numerics}{op-imax_u}{\F{imax\_u}}
+.. |imaxs| mathdef:: \xref{exec/numerics}{op-imax_s}{\F{imax\_s}}
+.. |iaddsatu| mathdef:: \xref{exec/numerics}{op-iaddsat_u}{\F{iaddsat\_u}}
+.. |iaddsats| mathdef:: \xref{exec/numerics}{op-iaddsat_s}{\F{iaddsat\_s}}
+.. |isubsatu| mathdef:: \xref{exec/numerics}{op-isubsat_u}{\F{isubsat\_u}}
+.. |isubsats| mathdef:: \xref{exec/numerics}{op-isubsat_s}{\F{isubsat\_s}}
+.. |iavgru| mathdef:: \xref{exec/numerics}{op-iavgr_u}{\F{iavgr\_u}}
+.. |iq15mulrsats| mathdef:: \xref{exec/numerics}{op-iq15mulrsat_s}{\F{iq15mulrsat\_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}}
+.. |fpmin| mathdef:: \xref{exec/numerics}{op-fpmin}{\F{fpmin}}
+.. |fpmax| mathdef:: \xref{exec/numerics}{op-fpmax}{\F{fpmax}}
+
+.. |extend| mathdef:: \xref{exec/numerics}{op-extend_u}{\F{extend}}
+.. |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}^{\K{u}}}
+.. |truncs| mathdef:: \xref{exec/numerics}{op-trunc_s}{\F{trunc}^{\K{s}}}
+.. |truncsatu| mathdef:: \xref{exec/numerics}{op-trunc_sat_u}{\F{trunc\_sat\_u}}
+.. |truncsats| mathdef:: \xref{exec/numerics}{op-trunc_sat_s}{\F{trunc\_sat\_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}^{\K{u}}}
+.. |converts| mathdef:: \xref{exec/numerics}{op-convert_s}{\F{convert}^{\K{s}}}
+.. |reinterpret| mathdef:: \xref{exec/numerics}{op-reinterpret}{\F{reinterpret}}
+.. |narrow| mathdef:: \xref{exec/numerics}{op-narrow_u}{\F{narrow}}
+.. |narrowu| mathdef:: \xref{exec/numerics}{op-narrow_u}{\F{narrow}^{\K{u}}}
+.. |narrows| mathdef:: \xref{exec/numerics}{op-narrow_s}{\F{narrow}^{\K{s}}}
+
+
+.. 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}}
+.. |satu| mathdef:: \xref{exec/numerics}{aux-sat_u}{\F{sat}^{\K{u}}}
+.. |sats| mathdef:: \xref{exec/numerics}{aux-sat_s}{\F{sat}^{\K{s}}}
+
+.. |lanes| mathdef:: \xref{exec/numerics}{aux-lanes}{\F{lanes}}
+
+
+.. Other meta functions
+
+.. |instantiate| mathdef:: \xref{exec/modules}{exec-instantiation}{\F{instantiate}}
+.. |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}
+
+.. |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}
+.. |vdashtaginst| mathdef:: \xref{appendix/properties}{valid-taginst}{\vdash}
+.. |vdashglobalinst| mathdef:: \xref{appendix/properties}{valid-globalinst}{\vdash}
+.. |vdasheleminst| mathdef:: \xref{appendix/properties}{valid-eleminst}{\vdash}
+.. |vdashdatainst| mathdef:: \xref{appendix/properties}{valid-datainst}{\vdash}
+.. |vdashexninst| mathdef:: \xref{appendix/properties}{valid-exninst}{\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}
+
+.. |vdashfuncinstextends| mathdef:: \xref{appendix/properties}{extend-funcinst}{\vdash}
+.. |vdashtableinstextends| mathdef:: \xref{appendix/properties}{extend-tableinst}{\vdash}
+.. |vdashmeminstextends| mathdef:: \xref{appendix/properties}{extend-meminst}{\vdash}
+.. |vdashtaginstextends| mathdef:: \xref{appendix/properties}{extend-taginst}{\vdash}
+.. |vdashglobalinstextends| mathdef:: \xref{appendix/properties}{extend-globalinst}{\vdash}
+.. |vdasheleminstextends| mathdef:: \xref{appendix/properties}{extend-eleminst}{\vdash}
+.. |vdashdatainstextends| mathdef:: \xref{appendix/properties}{extend-datainst}{\vdash}
+.. |vdashexninstextends| mathdef:: \xref{appendix/properties}{extend-exninst}{\vdash}
+.. |vdashstoreextends| mathdef:: \xref{appendix/properties}{extend-store}{\vdash}
+
+
+.. 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}}
+.. |Btagnamesubsec| mathdef:: \xref{appendix/custom}{binary-tagnamesec}{\B{tagnamesubsec}}
+
+
+.. Embedding
+.. ---------
+
+.. |error| mathdef:: \xref{appendix/embedding}{embed-error}{\X{error}}
+.. |ERROR| mathdef:: \xref{appendix/embedding}{embed-error}{\K{error}}
diff --git a/document/legacy/exceptions/core/util/mathdef.py b/document/legacy/exceptions/core/util/mathdef.py
new file mode 100644
index 0000000000..a10fc458ff
--- /dev/null
+++ b/document/legacy/exceptions/core/util/mathdef.py
@@ -0,0 +1,122 @@
+from sphinx.directives.patches import MathDirective
+from sphinx.util.texescape import tex_replace_map
+from sphinx.writers.html5 import HTML5Translator
+from sphinx.writers.latex import LaTeXTranslator
+from docutils import nodes
+from docutils.nodes import math
+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.html#%s}' % (file, id.replace('_', '-'))
+
+def html_transform_math_xref(node):
+  new_text = xref_re.sub(lambda m: html_hyperlink(m.group(1), m.group(2)), node.astext())
+  node.children[0] = nodes.Text(new_text)
+
+# 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):
+  new_text = xref_re.sub(lambda m: latex_hyperlink(m.group(1), m.group(2)), node.astext())
+  node.children[0] = nodes.Text(new_text)
+
+# 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(raw, text)], []
+
+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().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 = {}
+    # TODO: we don't ever hit the case where len(self.content) > 1
+    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().run()
+
+class WebAssemblyHTML5Translator(HTML5Translator):
+  """
+  Customize HTML5Translator.
+  Convert xref in math and math block nodes to hrefs.
+  """
+  def visit_math(self, node, math_env = ''):
+    html_transform_math_xref(node)
+    super().visit_math(node, math_env)
+
+  def visit_math_block(self, node, math_env  = ''):
+    html_transform_math_xref(node)
+    super().visit_math_block(node, math_env)
+
+class WebAssemblyLaTeXTranslator(LaTeXTranslator):
+  """
+  Customize LaTeXTranslator.
+  Convert xref in math and math block nodes to hyperrefs.
+  """
+  def visit_math(self, node):
+    latex_transform_math_xref(node)
+    super().visit_math(node)
+
+  def visit_math_block(self, node):
+    latex_transform_math_xref(node)
+    super().visit_math_block(node)
+
+# Setup
+
+def setup(app):
+  app.set_translator('html', WebAssemblyHTML5Translator)
+  app.set_translator('latex', WebAssemblyLaTeXTranslator)
+  app.add_role('math', ext_math_role)
+  app.add_directive('math', ExtMathDirective, override = True)
+  app.add_directive('mathdef', MathdefDirective)
diff --git a/document/legacy/exceptions/core/util/pseudo-lexer.py b/document/legacy/exceptions/core/util/pseudo-lexer.py
new file mode 100644
index 0000000000..fd3a251d5e
--- /dev/null
+++ b/document/legacy/exceptions/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"(?` must be :ref:`valid ` as some :ref:`function type ` :math:`[t_1^\ast] \to [t_2^\ast]`.
+
+* Let :math:`C'` be the same :ref:`context ` as :math:`C`, but with the :ref:`label type ` :math:`[t_2^\ast]` prepended to the |CLABELS| vector.
+
+* Under context :math:`C'`,
+  the instruction sequence :math:`\instr_1^\ast` must be :ref:`valid ` with type :math:`[t_1^\ast] \to [t_2^\ast]`.
+
+* Let :math:`C''` be the same :ref:`context ` as :math:`C`, but with the :ref:`label type ` :math:`\LCATCH~[t_2^\ast]` prepended to the |CLABELS| vector.
+
+* For every :math:`x_i` and :math:`\instr_{2i}^\ast` in :math:`(\CATCH~x~\instr_2^\ast)^\ast`:
+
+  * The tag :math:`C.\CTAGS[x_i]` must be defined in the context :math:`C`.
+
+  * Let :math:`[t_{3i}^\ast] \to [t_{4i}^\ast]` be the :ref:`tag type ` :math:`C.\CTAGS[x_i]`.
+
+  * The :ref:`result type ` :math:`[t_{4i}^\ast]` must be empty.
+
+  * Under context :math:`C''`,
+    the instruction sequence :math:`\instr_{2i}^\ast` must be :ref:`valid ` with type :math:`[t_{3i}^\ast] \to [t_2^\ast]`.
+
+* If :math:`(\CATCHALL~\instr_3^\ast)^?` is not empty, then:
+
+  * Under context :math:`C''`,
+    the instruction sequence :math:`\instr_3^\ast` must be :ref:`valid ` with type :math:`[] \to [t_2^\ast]`.
+
+* Then the compound instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
+
+.. math::
+   ~\\
+   \frac{
+   \begin{array}{c}
+     C \vdashblocktype \blocktype : [t_1^\ast] \to [t_2^\ast]
+     \qquad
+     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr_1^\ast : [t_1^\ast] \to [t_2^\ast] \\
+     (C.\CTAGS[x] = [t^\ast] \to [])^\ast \\
+     C,\CLABELS\,(\LCATCH~[t_2^\ast]) \vdashinstrseq \instr_2^\ast : [t^\ast] \to [t_2^\ast])^\ast \\
+     (C,\CLABELS\,(\LCATCH~[t_2^\ast]) \vdashinstrseq \instr_3^\ast : [] \to [t_2^\ast])^?
+   \end{array}
+   }{
+   C \vdashinstr \TRY~\blocktype~\instr_1^\ast~(\CATCH~x~\instr_2^\ast)^\ast~(\CATCHALL~\instr_3^\ast)^?~\END : [t_1^\ast] \to [t_2^\ast]
+   }
+
+
+.. note::
+   The :ref:`notation ` :math:`C,\CLABELS\,(\LCATCH~[t^\ast])` inserts the new label type at index :math:`0`, shifting all others.
+
+
+.. _valid-try-delegate:
+
+:math:`\TRY~\blocktype~\instr^\ast~\DELEGATE~l`
+...............................................
+
+* The label :math:`C.\CLABELS[l]` must be defined in the context.
+
+* The :ref:`block type ` must be :ref:`valid ` as some :ref:`function type ` :math:`[t_1^\ast] \to [t_2^\ast]`.
+
+* Let :math:`C'` be the same :ref:`context ` as :math:`C`, but with the :ref:`result type ` :math:`[t_2^\ast]` prepended to the |CLABELS| vector.
+
+* Under context :math:`C'`,
+  the instruction sequence :math:`\instr^\ast` must be :ref:`valid ` with type :math:`[t_1^\ast] \to [t_2^\ast]`.
+
+* Then the compound instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`.
+
+.. math::
+   ~\\
+   \frac{
+     C \vdashblocktype \blocktype : [t_1^\ast] \to [t_2^\ast]
+     \qquad
+     C,\CLABELS\,[t_2^\ast] \vdashinstrseq \instr^\ast : [t_1^\ast]\to[t_2^\ast]
+     \qquad
+     C.\CLABELS[l] = [t_0^\ast]
+   }{
+   C \vdashinstrseq \TRY~\blocktype~\instr^\ast~\DELEGATE~l : [t_1^\ast]\to[t_2^\ast]
+   }
+
+.. note::
+   The :ref:`label index ` space in the :ref:`context ` :math:`C` contains the most recent label first, so that :math:`C.\CLABELS[l]` performs a relative lookup as expected.
+
+
+.. _valid-rethrow:
+
+:math:`\RETHROW~l`
+..................
+
+* The label :math:`C.\CLABELS[l]` must be defined in the context.
+
+* Let :math:`(\LCATCH^?~[t^\ast])` be the :ref:`label type ` :math:`C.\CLABELS[l]`.
+
+* The |LCATCH| must be present in the :ref:`label type ` :math:`C.\CLABELS[l]`.
+
+* Then the instruction is valid with type :math:`[t_1^\ast] \to [t_2^\ast]`, for any sequences of  :ref:`value types ` :math:`t_1^\ast` and :math:`t_2^\ast`.
+
+
+.. math::
+   ~\\
+   \frac{
+     C.\CLABELS[l] = \LCATCH~[t^\ast]
+   }{
+     C \vdashinstr \RETHROW~l : [t_1^\ast] \to [t_2^\ast]
+   }
+
+
+.. note::
+   The |RETHROW| instruction is stack-polymorphic.
diff --git a/document/legacy/exceptions/js-api/Makefile b/document/legacy/exceptions/js-api/Makefile
new file mode 100644
index 0000000000..84ba5d3abd
--- /dev/null
+++ b/document/legacy/exceptions/js-api/Makefile
@@ -0,0 +1,44 @@
+BUILDDIR      = _build
+STATICDIR     = _static
+DOWNLOADDIR   = _download
+NAME          = WebAssembly
+
+.PHONY: all
+all:
+	mkdir -p $(BUILDDIR)/html
+	bikeshed spec index.bs $(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)
+
+.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"
+
+.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/legacy/exceptions/js-api/index.bs b/document/legacy/exceptions/js-api/index.bs
new file mode 100644
index 0000000000..e7db140740
--- /dev/null
+++ b/document/legacy/exceptions/js-api/index.bs
@@ -0,0 +1,1450 @@
+
    +Title: WebAssembly JavaScript Interface: Exception Handling
+Shortname: wasm-js-api
+Group: wasm
+Status: ED
+Level: 2
+TR: https://www.w3.org/TR/wasm-js-api-2/
+ED: https://webassembly.github.io/exception-handling/js-api/
+Editor: Ms2ger, Igalia
+Repository: WebAssembly/spec
+Markup Shorthands: css no, markdown yes
+Abstract: This document provides an explicit JavaScript API for interacting with WebAssembly.
+Prepare For TR: true
+
    
+
+
    +{
+  "WEBASSEMBLY": {
+    "href": "https://webassembly.github.io/spec/core/",
+    "title": "WebAssembly Core Specification",
+    "publisher": "W3C WebAssembly Community Group",
+    "status": "Draft"
+  }
+}
+
    
+
+
    +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
+        url: sec-returnifabrupt-shorthands
+            text: !
+            text: ?
+        text: Type; url: sec-ecmascript-data-types-and-values
+        text: current Realm; url: current-realm
+        text: Built-in Function Objects; url: sec-built-in-function-objects
+        text: NativeError Object Structure; url: sec-nativeerror-object-structure
+        text: 𝔽; url: #𝔽
+        text: ℤ; url: #ℤ
+urlPrefix: https://webassembly.github.io/exception-handling/core/; spec: WebAssembly; type: dfn
+    url: valid/modules.html#valid-module
+        text: valid
+        text: WebAssembly module validation
+    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
+    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
+        text: i64.const
+        text: i32.const
+        text: f32.const
+        text: f64.const
+        text: v128.const
+        text: ref.null
+        text: ref.func
+        text: ref.extern
+    text: function index; url: syntax/modules.html#syntax-funcidx
+    text: function instance; url: exec/runtime.html#function-instances
+    text: store_init; url: appendix/embedding.html#embed-store-init
+    text: module_decode; url: appendix/embedding.html#embed-module-decode
+    text: module_validate; url: appendix/embedding.html#embed-module-validate
+    text: module_instantiate; url: appendix/embedding.html#embed-module-instantiate
+    text: module_imports; url: appendix/embedding.html#embed-module-imports
+    text: module_exports; url: appendix/embedding.html#embed-module-exports
+    text: instance_export; url: appendix/embedding.html#embed-instance-export
+    text: func_alloc; url: appendix/embedding.html#embed-func-alloc
+    text: func_type; url: appendix/embedding.html#embed-func-type
+    text: func_invoke; url: appendix/embedding.html#embed-func-invoke
+    text: table_alloc; url: appendix/embedding.html#embed-table-alloc
+    text: table_type; url: appendix/embedding.html#embed-table-type
+    text: table_read; url: appendix/embedding.html#embed-table-read
+    text: table_write; url: appendix/embedding.html#embed-table-write
+    text: table_size; url: appendix/embedding.html#embed-table-size
+    text: table_grow; url: appendix/embedding.html#embed-table-grow
+    text: mem_alloc; url: appendix/embedding.html#embed-mem-alloc
+    text: mem_type; url: appendix/embedding.html#embed-mem-type
+    text: mem_read; url: appendix/embedding.html#embed-mem-read
+    text: mem_write; url: appendix/embedding.html#embed-mem-write
+    text: mem_size; url: appendix/embedding.html#embed-mem-size
+    text: mem_grow; url: appendix/embedding.html#embed-mem-grow
+    text: global_alloc; url: appendix/embedding.html#embed-global-alloc
+    text: global_type; url: appendix/embedding.html#embed-global-type
+    text: global_read; url: appendix/embedding.html#embed-global-read
+    text: global_write; url: appendix/embedding.html#embed-global-write
+    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
+    text: global address; url: exec/runtime.html#syntax-globaladdr
+    text: extern address; url: exec/runtime.html#syntax-externaddr
+    text: tag address; url: exec/runtime.html#syntax-tagaddr
+    url: syntax/types.html#syntax-numtype
+        text: i32
+        text: i64
+        text: f32
+        text: f64
+    url: syntax/types.html#vector-types
+        text: v128
+    url: syntax/types.html#syntax-reftype
+        text: reftype
+        text: funcref
+        text: externref
+    url: syntax/values.html#syntax-float
+        text: +∞
+        text: −∞
+        text: nan
+        text: canon
+        text: signif
+    text: function element; url: exec/runtime.html#syntax-funcelem
+    text: import component; url: syntax/modules.html#imports
+    url: exec/runtime.html#syntax-externval
+        text: external value
+        for: external value
+            text: tag
+    text: host function; url: exec/runtime.html#syntax-hostfunc
+    text: the instantiation algorithm; url: exec/modules.html#instantiation
+    text: module; url: syntax/modules.html#syntax-module
+    text: imports; url: syntax/modules.html#syntax-module
+    text: import; url: syntax/modules.html#syntax-import
+    url: syntax/types.html#external-types
+        text: external type
+        text: func
+        text: table
+        text: mem
+        text: global
+        for: externtype
+            text: tag
+    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: memory.grow; url: exec/instructions.html#exec-memory-grow
+    text: current frame; url: exec/conventions.html#exec-notation-textual
+    text: module; for: frame; url: exec/runtime.html#syntax-frame
+    text: memaddrs; for: moduleinst; url: exec/runtime.html#syntax-moduleinst
+    text: signed_64; url: exec/numerics.html#aux-signed
+    text: sequence; url: syntax/conventions.html#grammar-notation
+    text: exception; for: tagtype/attribute; url: syntax/types.html#syntax-tagtype
+urlPrefix: https://heycam.github.io/webidl/; spec: WebIDL
+    type: dfn
+        text: create a namespace object; url: create-a-namespace-object
+urlPrefix: https://webassembly.github.io/js-types/js-api/; spec: WebAssembly JS API (JS Type Reflection)
+    type: abstract-op; text: FromValueType; url: abstract-opdef-fromvaluetype
+
    
+
+
    +spec:infra; type:dfn; text:list
+spec:ecma-262; type:exception; for:ECMAScript; text:Error
+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:webidl; type:dfn; text:resolve
+
    
+
+
+
+This API provides a way to access WebAssembly [[WEBASSEMBLY]] through a bridge to explicitly construct modules from JavaScript [[ECMASCRIPT]].
+
+
    Sample API Usage
    
+
+
    This section is non-normative.
    
+
+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()
+);
+```
+
+
    Notation
    
+
+This specification depends on the Infra Standard. [[INFRA]]
+
+The WebAssembly [=sequence=] type is equivalent to the [=list=] type defined there; values of one
+are treated as values of the other transparently.
+
+
    Internal storage
    
+
+
    Interaction of the WebAssembly Store with JavaScript
    
+
+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 associated store. When a new agent is created, its associated store is set to the result of [=store_init=]().
+
+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 identified with 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.
+
+
    WebAssembly JS Object Caches
    
+
+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. However, this property does not hold for shared objects.
+
+Each [=agent=] is associated with the following [=ordered map=]s:
+    * The Memory object cache, mapping [=memory address=]es to {{Memory}} objects.
+    * The Table object cache, mapping [=table address=]es to {{Table}} objects.
+    * The Exported Function cache, mapping [=function address=]es to [=Exported Function=] objects.
+    * The Global object cache, mapping [=global address=]es to {{Global}} objects.
+    * The Extern value cache, mapping [=extern address=]es to values.
+    * The Tag object cache, mapping [=tag addresses=] to {{Tag}} objects.
+
+
    The WebAssembly Namespace
    
+
+
    +dictionary WebAssemblyInstantiatedSource {
+    required Module module;
+    required Instance instance;
+};
+
+[Exposed=*]
+namespace WebAssembly {
+    boolean validate(BufferSource bytes);
+    Promise<Module> compile(BufferSource bytes);
+
+    Promise<WebAssemblyInstantiatedSource> instantiate(
+        BufferSource bytes, optional object importObject);
+
+    Promise<Instance> instantiate(
+        Module moduleObject, optional object importObject);
+};
+
    
+
+
+
+
    
+  To compile a WebAssembly module from source bytes |bytes|, perform the following steps:
+    1. Let |module| be [=module_decode=](|bytes|). If |module| is [=error=], return [=error=].
+    1. If [=module_validate=](|module|) is [=error=], return [=error=].
+    1. Return |module|.
+
    
+
+
    
+  The validate(|bytes|) 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. [=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.
+
    
+
+A {{Module}} object represents a single WebAssembly module. Each {{Module}} object has the following internal slots:
+
+    * \[[Module]] : a WebAssembly [=/module=]
+    * \[[Bytes]] : the source bytes of \[[Module]].
+
+
    
+  To construct a WebAssembly module object 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|.
+
    
+
+
    
+  To asynchronously compile a WebAssembly module from source bytes |bytes|, using optional [=task source=] |taskSource|, perform the following steps:
+
+    1. Let |promise| be [=a new promise=].
+    1. Run the following steps [=in parallel=]:
+        1. [=compile a WebAssembly module|Compile the WebAssembly module=] |bytes| and store the result as |module|.
+        1. [=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|.
+
    
+
+
    
+    The compile(|bytes|) 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.
+
    
+
+
    
+  To read the imports from a WebAssembly module |module| from imports object |importObject|, perform the following steps:
+    1. If |module|.[=imports=] [=list/is empty|is not empty=], and |importObject| is undefined, throw a {{TypeError}} exception.
+    1. Let |imports| be « ».
+    1. [=list/iterate|For each=] (|moduleName|, |componentName|, |externtype|) of [=module_imports=](|module|),
+        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 [=func=] |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.
+            1. Otherwise,
+                1. [=Create a host function=] from |v| and |functype|, and let |funcaddr| be the result.
+                1. Let |index| be the number of external functions in |imports|. This value |index| is known as the index of the host function |funcaddr|.
+            1. Let |externfunc| be the [=external value=] [=external value|func=] |funcaddr|.
+            1. [=list/Append=] |externfunc| to |imports|.
+        1. If |externtype| is of the form [=global=] mut |valtype|,
+            1. If [=Type=](|v|) is Number or BigInt,
+                1. If |valtype| is [=i64=] and [=Type=](|v|) is Number,
+                    1. Throw a {{LinkError}} exception.
+                1. If |valtype| is not [=i64=] and [=Type=](|v|) is BigInt,
+                    1. Throw a {{LinkError}} exception.
+                1. If |valtype| is [=v128=],
+                    1. 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 [=global_alloc=](|store|, [=const=] |valtype|, |value|).
+                1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
+            1. Otherwise, if |v| [=implements=] {{Global}},
+                1. Let |globaladdr| be |v|.\[[Global]].
+            1. Otherwise,
+                1. Throw a {{LinkError}} exception.
+            1. Let |externglobal| be [=external value|global=] |globaladdr|.
+            1. [=list/Append=] |externglobal| to |imports|.
+        1. If |externtype| is of the form [=mem=] memtype,
+            1. If |v| does not [=implement=] {{Memory}}, throw a {{LinkError}} exception.
+            1. Let |externmem| be the [=external value=] [=external value|mem=] |v|.\[[Memory]].
+            1. [=list/Append=] |externmem| to |imports|.
+        1. If |externtype| is of the form [=table=] tabletype,
+            1. If |v| does not [=implement=] {{Table}}, throw a {{LinkError}} exception.
+            1. Let |tableaddr| be |v|.\[[Table]].
+            1. Let |externtable| be the [=external value=] [=external value|table=] |tableaddr|.
+            1. [=list/Append=] |externtable| to |imports|.
+        1. If |externtype| is of the form [=externtype/tag=] |attribute| functype,
+            1. Assert: |attribute| is [=tagtype/attribute/exception=].
+            1. If |v| does not [=implement=] {{Tag}}, throw a {{LinkError}} exception.
+            1. Let |tagaddr| be |v|.\[[Address]].
+            1. Let |externtag| be the [=external value=] [=external value/tag=] |tagaddr|.
+            1. [=list/Append=] |externtag| to |imports|.
+    1. Return |imports|.
+
+Note: This algorithm only verifies the right kind of JavaScript values are passed.
+The verification of WebAssembly type requirements is deferred to the
+"[=instantiate the core of a WebAssembly module=]" algorithm.
+
    
+
+
    
+  To create an exports object from a WebAssembly module |module| and instance |instance|, perform the following steps:
+    1. Let |exportsObject| be [=!=] [$OrdinaryObjectCreate$](null).
+    1. [=list/iterate|For each=] (|name|, |externtype|) of [=module_exports=](|module|),
+        1. Let |externval| be [=instance_export=](|instance|, |name|).
+        1. Assert: |externval| is not [=error=].
+        1. If |externtype| is of the form [=func=] functype,
+            1. Assert: |externval| is of the form [=external value|func=] |funcaddr|.
+            1. Let [=external value|func=] |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 [=global=] mut globaltype,
+            1. Assert: |externval| is of the form [=external value|global=] |globaladdr|.
+            1. Let [=external value|global=] |globaladdr| be |externval|.
+            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 [=mem=] memtype,
+            1. Assert: |externval| is of the form [=external value|mem=] |memaddr|.
+            1. Let [=external value|mem=] |memaddr| be |externval|.
+            1. Let |memory| be [=create a memory object|a new Memory object=] created from |memaddr|.
+            1. Let |value| be |memory|.
+        1. If |externtype| is of the form [=table=] tabletype,
+            1. Assert: |externval| is of the form [=external value|table=] |tableaddr|.
+            1. Let [=external value|table=] |tableaddr| be |externval|.
+            1. Let |table| be [=create a Table object|a new Table object=] created from |tableaddr|.
+            1. Let |value| be |table|.
+        1. If |externtype| is of the form [=externtype/tag=] |attribute| functype,
+            1. Assert: |attribute| is [=tagtype/attribute/exception=].
+            1. Assert: |externval| is of the form [=external value/tag=] |tagaddr|.
+            1. Let [=external value/tag=] |tagaddr| be |externval|.
+            1. Let |tag| be [=create a Tag object|a new Tag object=] created from |tagaddr|.
+            1. Let |value| be |tag|.
+        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.
+    1. Perform [=!=] [$SetIntegrityLevel$](|exportsObject|, `"frozen"`).
+    1. Return |exportsObject|.
+
    
+
+
    
+  To initialize an instance object |instanceObject| from a WebAssembly module |module| and instance |instance|, perform the following steps:
+
+    1. [=Create an exports object=] from |module| and |instance| and let |exportsObject| be the result.
+    1. Set |instanceObject|.\[[Instance]] to |instance|.
+    1. Set |instanceObject|.\[[Exports]] to |exportsObject|.
+
    
+
+
    
+  To instantiate the core of a WebAssembly module from a module |module| and imports |imports|, perform the following steps:
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let |result| be [=module_instantiate=](|store|, |module|, |imports|).
+    1. If |result| 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 the WebAssembly error mapping.
+    1. Let (|store|, |instance|) be |result|.
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
+    1. Return |instance|.
+
    
+
+
    
+  To asynchronously instantiate a WebAssembly module from a {{Module}} |moduleObject| and imports |importObject|, perform the following steps:
+    1. Let |promise| be [=a new promise=].
+    1. Let |module| be |moduleObject|.\[[Module]].
+    1. [=Read the imports=] of |module| with imports |importObject|, and let |imports| be the result.
+        If this operation throws an exception, catch it, [=reject=] |promise| with the exception, and return |promise|.
+    1. Run the following steps [=in parallel=]:
+        1. [=Queue a task=] to perform the following steps:
+            Note: Implementation-specific work may be performed here.
+            1.  [=Instantiate the core of a WebAssembly module=] |module| with |imports|, and let |instance| be the result.
+                If this throws an exception, catch it, [=reject=] |promise| with the exception, and terminate these substeps.
+            1.  Let |instanceObject| be a [=/new=] {{Instance}}.
+            1.  [=initialize an instance object|Initialize=] |instanceObject| from |module| and |instance|.
+                If this throws an exception, catch it, [=reject=] |promise| with the exception, and terminate these substeps.
+            1. [=Resolve=] |promise| with |instanceObject|.
+    1. Return |promise|.
+
    
+
+
    
+  To synchronously instantiate a WebAssembly module from a {{Module}} |moduleObject| and imports |importObject|, perform the following steps:
+    1. Let |module| be |moduleObject|.\[[Module]].
+    1. [=Read the imports=] of |module| with imports |importObject|, and let |imports| be the result.
+    1. [=Instantiate the core of a WebAssembly module=] |module| with |imports|, and let |instance| be the result.
+    1. Let |instanceObject| be a [=/new=] {{Instance}}.
+    1. [=initialize an instance object|Initialize=] |instanceObject| from |module| and |instance|.
+    1. Return |instanceObject|.
+
    
+
+
    
+  To instantiate a promise of a module |promiseOfModule| with imports |importObject|, perform the following steps:
+
+    1. Let |promise| be [=a new promise=].
+    1. [=Upon fulfillment=] of |promiseOfModule| with value |module|:
+        1. [=asynchronously instantiate a WebAssembly module|Instantiate the WebAssembly module=] |module| importing |importObject|, and let |innerPromise| be the result.
+        1. [=Upon fulfillment=] of |innerPromise| with value |instance|.
+            1. Let |result| be the {{WebAssemblyInstantiatedSource}} value «[ "{{WebAssemblyInstantiatedSource/module}}" → |module|, "{{WebAssemblyInstantiatedSource/instance}}" → |instance| ]».
+            1. [=Resolve=] |promise| with |result|.
+        1. [=Upon rejection=] of |innerPromise| with reason |reason|:
+            1. [=Reject=] |promise| with |reason|.
+    1. [=Upon rejection=] of |promiseOfModule| with reason |reason|:
+        1. [=Reject=] |promise| with |reason|.
+    1. Return |promise|.
+
    
+
+
    
+  The instantiate(|bytes|, |importObject|) 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.
+
    
+
+
    
+  The instantiate(|moduleObject|, |importObject|) method, when invoked, performs the following steps:
+    1. [=asynchronously instantiate a WebAssembly module|Asynchronously instantiate the WebAssembly module=] |moduleObject| importing |importObject|, and return the result.
+
    
+
+Note: A follow-on streaming API is documented in the WebAssembly Web API.
+
+
    Modules
    
+
+
    +enum ImportExportKind {
+  "function",
+  "table",
+  "memory",
+  "global",
+  "tag"
+};
+
+dictionary ModuleExportDescriptor {
+  required USVString name;
+  required ImportExportKind kind;
+  // Note: Other fields such as signature may be added in the future.
+};
+
+dictionary ModuleImportDescriptor {
+  required USVString module;
+  required USVString name;
+  required ImportExportKind kind;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=*]
+interface Module {
+  constructor(BufferSource bytes);
+  static sequence<ModuleExportDescriptor> exports(Module moduleObject);
+  static sequence<ModuleImportDescriptor> imports(Module moduleObject);
+  static sequence<ArrayBuffer> customSections(Module moduleObject, DOMString sectionName);
+};
+
    
+
+
    
+  The string value of the extern type |type| is
+    * "function" if |type| is of the form [=func=] functype
+    * "table" if |type| is of the form [=table=] tabletype
+    * "memory" if |type| is of the form [=mem=] memtype
+    * "global" if |type| is of the form [=global=] globaltype
+    * "tag" if |type| is of the form [=externtype/tag=] tag
+
    
+
+
    
+    The exports(|moduleObject|) method, when invoked, performs the following steps:
+    1. Let |module| be |moduleObject|.\[[Module]].
+    1. Let |exports| be « ».
+    1. [=list/iterate|For each=] (|name|, |type|) of [=module_exports=](|module|),
+        1. Let |kind| be the [=string value of the extern type=] |type|.
+        1. Let |obj| be «[ "{{ModuleExportDescriptor/name}}" → |name|, "{{ModuleExportDescriptor/kind}}" → |kind| ]».
+        1. [=list/Append=] |obj| to |exports|.
+    1. Return |exports|.
+
    
+
+
    
+    The imports(|moduleObject|) method, when invoked, performs the following steps:
+    1. Let |module| be |moduleObject|.\[[Module]].
+    1. Let |imports| be « ».
+    1. [=list/iterate|For each=] (|moduleName|, |name|, |type|) of [=module_imports=](|module|),
+        1. Let |kind| be the [=string value of the extern type=] |type|.
+        1. Let |obj| be «[ "{{ModuleImportDescriptor/module}}" → |moduleName|, "{{ModuleImportDescriptor/name}}" → |name|, "{{ModuleImportDescriptor/kind}}" → |kind| ]».
+        1. [=list/Append=] |obj| to |imports|.
+    1. Return |imports|.
+
    
+
+
    
+    The customSections(|moduleObject|, |sectionName|) method, when invoked, performs the following steps:
+    1. Let |bytes| be |moduleObject|.\[[Bytes]].
+    1. Let |customSections| be « ».
+    1. [=list/iterate|For each=] [=custom section=] |customSection| of |bytes|, interpreted according to the [=module grammar=],
+        1. Let |name| be the name 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. [=list/Append=] a new {{ArrayBuffer}} containing a copy of the bytes in |bytes| for the range matched by this [=customsec=] production to |customSections|.
+    1. Return |customSections|.
+
    
+
+
    
+    The Module(|bytes|) constructor, 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. [=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. Set **this**.\[[Module]] to |module|.
+    1. Set **this**.\[[Bytes]] to |stableBytes|.
+
+Note: Some implementations enforce a size limitation on |bytes|. Use of this API is discouraged, in favor of asynchronous APIs.
+
    
+
+
    Instances
    
+
+
    +[LegacyNamespace=WebAssembly, Exposed=*]
+interface Instance {
+  constructor(Module module, optional object importObject);
+  readonly attribute object exports;
+};
+
    
+
+
    
+  The Instance(|module|, |importObject|) constructor, when invoked, runs the following steps:
+    1. Let |module| be |module|.\[[Module]].
+    1. [=Read the imports=] of |module| with imports |importObject|, and let |imports| be the result.
+    1. [=Instantiate the core of a WebAssembly module=] |module| with |imports|, and let |instance| be the result.
+    1. [=initialize an instance object|Initialize=] **this** from |module| and |instance|.
+
+Note: The use of this synchronous API is discouraged, as some implementations sometimes do long-running compilation work when instantiating.
+
    
+
+
    
+    The getter of the exports attribute of {{Instance}} returns **this**.\[[Exports]].
+
    
+
+
    Memories
    
+
+
    +dictionary MemoryDescriptor {
+  required [EnforceRange] unsigned long initial;
+  [EnforceRange] unsigned long maximum;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=*]
+interface Memory {
+  constructor(MemoryDescriptor descriptor);
+  unsigned long grow([EnforceRange] unsigned long delta);
+  readonly attribute ArrayBuffer buffer;
+};
+
    
+
+A {{Memory}} object represents a single [=memory instance=]
+which can be simultaneously referenced by multiple {{Instance}} objects. Each
+{{Memory}} object has the following internal slots:
+
+    * \[[Memory]] : a [=memory address=]
+    * \[[BufferObject]] : an {{ArrayBuffer}} whose [=Data Block=] is [=identified with=] the above memory address
+
+
    
+    To create a memory buffer 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|.
+
    
+
+
    
+    To initialize a memory object |memory| from a [=memory address=] |memaddr|, perform the following steps:
+    1. Let |map| be the [=surrounding agent=]'s associated [=Memory object cache=].
+    1. Assert: |map|[|memaddr|] doesn't [=map/exist=].
+    1. Let |buffer| be the result of [=create a memory buffer|creating a memory buffer=] from |memaddr|.
+    1. Set |memory|.\[[Memory]] to |memaddr|.
+    1. Set |memory|.\[[BufferObject]] to |buffer|.
+    1. [=map/Set=] |map|[|memaddr|] to |memory|.
+
    
+
+
    
+    To create a memory object 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 |memory| be a [=/new=] {{Memory}}.
+    1. [=initialize a memory object|Initialize=] |memory| from |memaddr|.
+    1. Return |memory|.
+
    
+
+
    
+    The Memory(|descriptor|) constructor, when invoked, performs the following steps:
+    1. Let |initial| be |descriptor|["initial"].
+    1. If |descriptor|["maximum"] [=map/exists=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
+    1. If |maximum| is not empty and |maximum| < |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 [=mem_alloc=](|store|, |memtype|). If allocation fails, throw a {{RangeError}} exception.
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
+    1. [=initialize a memory object|Initialize=] **this** from |memaddr|.
+
    
+
+
    
+    To reset the Memory buffer 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]], "WebAssembly.Memory").
+    1. Let |buffer| be the result of [=create a memory buffer|creating a memory buffer=] from |memaddr|.
+    1. Set |memory|.\[[BufferObject]] to |buffer|.
+
    
+
+
    
+    The grow(|delta|) method, when invoked, performs the following steps:
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let |memaddr| be **this**.\[[Memory]].
+    1. Let |ret| be the [=mem_size=](|store|, |memaddr|).
+    1. Let |store| be [=mem_grow=](|store|, |memaddr|, |delta|).
+    1. If |store| is [=error=], throw a {{RangeError}} exception.
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
+    1. [=Reset the memory buffer=] of |memaddr|.
+    1. Return |ret|.
+
    
+
+Immediately after a WebAssembly [=memory.grow=] instruction executes, perform the following steps:
+
+
    
+    1. If the top of the stack is not [=i32.const=] (−1),
+        1. Let |frame| be the [=current frame=].
+        1. Assert: due to validation, |frame|.[=frame/module=].[=moduleinst/memaddrs=][0] exists.
+        1. Let |memaddr| be the memory address |frame|.[=frame/module=].[=moduleinst/memaddrs=][0].
+        1. [=Reset the memory buffer=] of |memaddr|.
+
    
+
+
    
+    The getter of the buffer attribute of {{Memory}} returns **this**.\[[BufferObject]].
+
    
+
+
    Tables
    
+
+
    +enum TableKind {
+  "externref",
+  "anyfunc",
+  // Note: More values may be added in future iterations,
+  // e.g., typed function references, typed GC references
+};
+
+dictionary TableDescriptor {
+  required TableKind element;
+  required [EnforceRange] unsigned long initial;
+  [EnforceRange] unsigned long maximum;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=*]
+interface Table {
+  constructor(TableDescriptor descriptor, optional any value);
+  unsigned long grow([EnforceRange] unsigned long delta, optional any value);
+  any get([EnforceRange] unsigned long index);
+  undefined set([EnforceRange] unsigned long index, optional any value);
+  readonly attribute unsigned long length;
+};
+
    
+
+A {{Table}} object represents a single [=table instance=] which can be simultaneously referenced by
+multiple {{Instance}} objects.
+Each {{Table}} object has a \[[Table]] internal slot, which is a [=table address=].
+
+
    
+    To initialize a table object |table| from a [=table address=] |tableaddr|, perform the following steps:
+    1. Let |map| be the [=surrounding agent=]'s associated [=Table object cache=].
+    1. Assert: |map|[|tableaddr|] doesn't [=map/exist=].
+    1. Set |table|.\[[Table]] to |tableaddr|.
+    1. [=map/Set=] |map|[|tableaddr|] to |table|.
+
    
+
+
    
+    To create a table object from a [=table address=] |tableaddr|, perform the following steps:
+    1. Let |map| be the [=surrounding agent=]'s associated [=Table object cache=].
+    1. If |map|[|tableaddr|] [=map/exists=],
+        1. Return |map|[|tableaddr|].
+    1. Let |table| be a [=/new=] {{Table}}.
+    1. [=initialize a table object|Initialize=] |table| from |tableaddr|.
+    1. Return |table|.
+
    
+
+
    
+    The Table(|descriptor|, |value|) constructor, when invoked, performs the following steps:
+    1. Let |elementType| be [=ToValueType=](|descriptor|["element"]).
+    1. If |elementType| is not a [=reftype=],
+        1. [=Throw=] a {{TypeError}} exception.
+    1. Let |initial| be |descriptor|["initial"].
+    1. If |descriptor|["maximum"] [=map/exists=], let |maximum| be |descriptor|["maximum"]; otherwise, let |maximum| be empty.
+    1. If |maximum| is not empty and |maximum| < |initial|, throw a {{RangeError}} exception.
+    1. If |value| is missing,
+        1. Let |ref| be [=DefaultValue=](|elementType|).
+    1. Otherwise,
+        1. Let |ref| be [=?=] [=ToWebAssemblyValue=](|value|, |elementType|).
+    1. Let |type| be the [=table type=] {[=table type|min=] |initial|, [=table type|max=] |maximum|} |elementType|.
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let (|store|, |tableaddr|) be [=table_alloc=](|store|, |type|, |ref|). 
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
+    1. [=initialize a table object|Initialize=] **this** from |tableaddr|.
+
    
+
+
    
+    The grow(|delta|, |value|) method, when invoked, performs the following steps:
+    1. Let |tableaddr| be **this**.\[[Table]].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let |initialSize| be [=table_size=](|store|, |tableaddr|).
+    1. Let (limits, |elementType|) be [=table_type=](|tableaddr|).
+    1. If |value| is missing,
+        1. Let |ref| be [=DefaultValue=](|elementType|).
+    1. Otherwise,
+        1. Let |ref| be [=?=] [=ToWebAssemblyValue=](|value|, |elementType|).
+    1. Let |result| be [=table_grow=](|store|, |tableaddr|, |delta|, |ref|).
+    1. If |result| is [=error=], throw a {{RangeError}} exception.
+
+        Note: The above exception can happen due to either insufficient memory or an invalid size parameter.
+
+    1. Set the [=surrounding agent=]'s [=associated store=] to |result|.
+    1. Return |initialSize|.
+
    
+
+
    
+    The getter of the length attribute of {{Table}}, when invoked, performs the following steps:
+    1. Let |tableaddr| be **this**.\[[Table]].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Return [=table_size=](|store|, |tableaddr|).
+
    
+
+
    
+    The get(|index|) method, when invoked, performs the following steps:
+    1. Let |tableaddr| be **this**.\[[Table]].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let |result| be [=table_read=](|store|, |tableaddr|, |index|).
+    1. If |result| is [=error=], throw a {{RangeError}} exception.
+    1. Return [=ToJSValue=](|result|).
+
    
+
+
    
+    The set(|index|, |value|) method, when invoked, performs the following steps:
+    1. Let |tableaddr| be **this**.\[[Table]].
+    1. Let (limits, |elementType|) be [=table_type=](|tableaddr|).
+    1. If |value| is missing,
+        1. Let |ref| be [=DefaultValue=](|elementType|).
+    1. Otherwise,
+        1. Let |ref| be [=?=] [=ToWebAssemblyValue=](|value|, |elementType|).
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let |store| be [=table_write=](|store|, |tableaddr|, |index|, |ref|).
+    1. If |store| is [=error=], throw a {{RangeError}} exception.
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
+
    
+
+
    Globals
    
+
+
    +enum ValueType {
+  "i32",
+  "i64",
+  "f32",
+  "f64",
+  "v128",
+  "externref",
+  "anyfunc",
+};
+
    
+
+Note: this type may be extended with additional cases in future versions of WebAssembly.
+
+
    +dictionary GlobalDescriptor {
+  required ValueType value;
+  boolean mutable = false;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=*]
+interface Global {
+  constructor(GlobalDescriptor descriptor, optional any v);
+  any valueOf();
+  attribute any value;
+};
+
    
+
+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=]
+
+
    
+    To initialize a global object |global| from a [=global address=] |globaladdr|, perform the following steps:
+    1. Let |map| be the [=surrounding agent=]'s associated [=Global object cache=].
+    1. Assert: |map|[|globaladdr|] doesn't [=map/exist=].
+    1. Set |global|.\[[Global]] to |globaladdr|.
+    1. [=map/Set=] |map|[|globaladdr|] to |global|.
+
    
+
+
    
+    To create a global object 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}}.
+    1. [=initialize a global object|Initialize=] |global| from |globaladdr|.
+    1. Return |global|.
+
    
+
+
    
+    The algorithm ToValueType(|s|) performs the following steps:
+    1. If |s| equals "i32", return [=i32=].
+    1. If |s| equals "i64", return [=i64=].
+    1. If |s| equals "f32", return [=f32=].
+    1. If |s| equals "f64", return [=f64=].
+    1. If |s| equals "v128", return [=v128=].
+    1. If |s| equals "anyfunc", return [=funcref=].
+    1. If |s| equals "externref", return [=externref=].
+    1. Assert: This step is not reached.
+
    
+
+
    
+    The algorithm DefaultValue(|valuetype|) performs the following steps:
+    1. If |valuetype| equals [=i32=], return [=i32.const=] 0.
+    1. If |valuetype| equals [=i64=], return [=i64.const=] 0.
+    1. If |valuetype| equals [=f32=], return [=f32.const=] 0.
+    1. If |valuetype| equals [=f64=], return [=f64.const=] 0.
+    1. If |valuetype| equals [=funcref=], return [=ref.null=] [=funcref=].
+    1. If |valuetype| equals [=externref=], return [=ToWebAssemblyValue=](undefined, |valuetype|).
+    1. Assert: This step is not reached.
+
    
+
+
    
+    The Global(|descriptor|, |v|) constructor, when invoked, performs the following steps:
+    1. Let |mutable| be |descriptor|["mutable"].
+    1. Let |valuetype| be [=ToValueType=](|descriptor|["value"]).
+    1. If |valuetype| is [=v128=],
+        1. Throw a {{TypeError}} exception.
+    1. If |v| is missing,
+        1. Let |value| be [=DefaultValue=](|valuetype|).
+    1. Otherwise,
+        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 [=global_alloc=](|store|, |globaltype|, |value|). 
+    1. Set the current agent's [=associated store=] to |store|.
+    1. [=initialize a global object|Initialize=] **this** from |globaladdr|.
+
    
+
+
    
+    The algorithm GetGlobalValue({{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 [=global_type=](|store|, |globaladdr|).
+    1. If |globaltype| is of the form mut [=v128=], throw a {{TypeError}}.
+    1. Let |value| be [=global_read=](|store|, |globaladdr|).
+    1. Return [=ToJSValue=](|value|).
+
    
+
+
    
+    The getter of the value attribute of {{Global}}, when invoked, performs the following steps:
+    1. Return [=GetGlobalValue=](**this**).
+
+    The setter of the value attribute of {{Global}}, when invoked, performs the following steps:
+    1. Let |store| be the current agent's [=associated store=].
+    1. Let |globaladdr| be **this**.\[[Global]].
+    1. Let |mut| |valuetype| be [=global_type=](|store|, |globaladdr|).
+    1. If |valuetype| is [=v128=], throw a {{TypeError}}.
+    1. If |mut| is [=const=], throw a {{TypeError}}.
+    1. Let |value| be [=ToWebAssemblyValue=](**the given value**, |valuetype|).
+    1. Let |store| be [=global_write=](|store|, |globaladdr|, |value|).
+    1. If |store| is [=error=], throw a {{RangeError}} exception.
+    1. Set the current agent's [=associated store=] to |store|.
+
    
+
+
    
+    The valueOf() method, when invoked, performs the following steps:
+    1. Return [=GetGlobalValue=](**this**).
+
    
+
+
    Exported Functions
    
+
+A WebAssembly function is made available in JavaScript as an Exported Function.
+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 [=surrounding agent=]'s [=associated store=].
+
+
    
+  The name of the WebAssembly function |funcaddr| is found by performing the following steps:
+
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let |funcinst| be |store|.funcs[|funcaddr|].
+    1. If |funcinst| is of the form {type functype, hostcode |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,
+        1. Let |moduleinst| be |funcinst|.module.
+        1. Assert: |funcaddr| is contained in |moduleinst|.funcaddrs.
+        1. Let |index| be the index of |moduleinst|.funcaddrs where |funcaddr| is found.
+    1. Return [=!=] [$ToString$](|index|).
+
    
+
+
    
+  To create a new Exported Function from a WebAssembly [=function address=] |funcaddr|, perform the following steps:
+
+    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 |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let |functype| be [=func_type=](|store|, |funcaddr|).
+    1. Let [|paramTypes|] → [resultTypes] be |functype|.
+    1. Let |arity| be |paramTypes|'s [=list/size=].
+    1. Let |name| be the [=name of the WebAssembly function=] |funcaddr|.
+    1. Let |function| be [=!=] [$CreateBuiltinFunction$](|steps|, |arity|, |name|, « \[[FunctionAddress]] », |realm|).
+    1. Set |function|.\[[FunctionAddress]] to |funcaddr|.
+    1. [=map/Set=] |map|[|funcaddr|] to |function|.
+    1. Return |function|.
+
    
+
+
    
+  To call an Exported Function with [=function address=] |funcaddr| and a [=list=] of JavaScript arguments |argValues|, perform the following steps:
+
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let |functype| be [=func_type=](|store|, |funcaddr|).
+    1. Let [|parameters|] → [|results|] be |functype|.
+    1. If |parameters| or |results| contain [=v128=], throw a {{TypeError}}.
+
+        Note: the above error is thrown each time the \[[Call]] method is invoked.
+    1. Let |args| be « ».
+    1. Let |i| be 0.
+    1. [=list/iterate|For each=] |t| of |parameters|,
+        1. If |argValues|'s [=list/size=] > |i|, let |arg| be |argValues|[|i|].
+        1. Otherwise, let |arg| be undefined.
+        1. [=list/Append=] [=ToWebAssemblyValue=](|arg|, |t|) to |args|.
+        1. Set |i| to |i| + 1.
+    1. Let (|store|, |ret|) be the result of [=func_invoke=](|store|, |funcaddr|, |args|).
+    1. Note: The expectation is that [=func_invoke=] will be updated to return (|store|, val* | [=error=] | (exception |exntag| |payload| |opaqueData|)).
+    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 the WebAssembly error mapping.
+    1. If |ret| is exception |exntag| |payload| |opaqueData|, then
+        1. If |opaqueData| is not [=ref.null=] [=externref=],
+            1. Let « [=ref.extern=] |externaddr| » be |opaqueData|.
+            1. Throw the result of [=retrieving an extern value=] from |externaddr|.
+        1. Let |exception| be [=create an Exception object|a new Exception=] for |exntag| and |payload|.
+        1. Throw |exception|.
+    1. Let |outArity| be the [=list/size=] of |ret|.
+    1. If |outArity| is 0, return undefined.
+    1. Otherwise, if |outArity| is 1, return [=ToJSValue=](|ret|[0]).
+    1. Otherwise,
+        1. Let |values| be « ».
+        1. [=list/iterate|For each=] |r| of |ret|,
+            1. [=list/Append=] [=ToJSValue=](|r|) to |values|.
+        1. Return [$CreateArrayFromList$](|values|).
+
    
+
+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.
+
+
    
+  To run a host function from the JavaScript object |func|, type |functype|, and [=list=] of [=WebAssembly values=] |arguments|, perform the following steps:
+
+    1. Let [|parameters|] → [|results|] be |functype|.
+    1. If |parameters| or |results| contain [=v128=], throw a {{TypeError}}.
+    1. Let |jsArguments| be « ».
+    1. [=list/iterate|For each=] |arg| of |arguments|,
+        1. [=list/Append=] [=!=] [=ToJSValue=](|arg|) to |jsArguments|.
+    1. Let |ret| be [=?=] [$Call$](|func|, undefined, |jsArguments|).
+    1. Let |resultsSize| be |results|'s [=list/size=].
+    1. If |resultsSize| is 0, return « ».
+    1. Otherwise, if |resultsSize| is 1, return « [=?=] [=ToWebAssemblyValue=](|ret|, |results|[0]) ».
+    1. Otherwise,
+        1. Let |method| be [=?=] [$GetMethod$](|ret|, {{@@iterator}}).
+        1. If |method| is undefined, [=throw=] a {{TypeError}}.
+        1. Let |values| be [=?=] [$IterableToList$](|ret|, |method|).
+        1. Let |wasmValues| be a new, empty [=list=].
+        1. If |values|'s [=list/size=] is not |resultsSize|, throw a {{TypeError}} exception.
+        1. For each |value| and |resultType| in |values| and |results|, paired linearly,
+            1. [=list/Append=] [=ToWebAssemblyValue=](|value|, |resultType|) to |wasmValues|.
+        1. Return |wasmValues|.
+
    
+
+
    
+  To create a host function from the JavaScript object |func| and type |functype|, perform the following steps:
+
+    1. Assert: [$IsCallable$](|func|).
+    1. Let |stored settings| be the incumbent settings object.
+    1. Let |hostfunc| be a [=host function=] which performs the following steps when called with arguments |arguments|:
+        1. Let |realm| be |func|'s [=associated Realm=].
+        1. Let |relevant settings| be |realm|'s [=realm/settings object=].
+        1. [=Prepare to run script=] with |relevant settings|.
+        1. [=Prepare to run a callback=] with |stored settings|.
+        1. Let |result| be the result of [=run a host function|running a host function=] from |func|, |functype|, and |arguments|.
+        1. [=Clean up after running a callback=] with |stored settings|.
+        1. [=Clean up after running script=] with |relevant settings|.
+        1. Assert: |result|.\[[Type]] is throw or normal.
+        1. If |result|.\[[Type]] is throw, then:
+            1. Let |v| be |result|.\[[Value]].
+            1. If |v| [=implements=] {{Exception}},
+                1. Let |type| be |v|.\[[Type]].
+                1. Let |payload| be |v|.\[[Payload]].
+            1. Otherwise,
+                1. Let |type| be the [=JavaScript exception tag=].
+                1. Let |payload| be « ».
+            1. Let |opaqueData| be [=ToWebAssemblyValue=](|v|, [=externref=])
+            1. [=WebAssembly/Throw=] with |type|, |payload| and |opaqueData|.
+        1. Otherwise, return |result|.\[[Value]].
+    1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+    1. Let (|store|, |funcaddr|) be [=func_alloc=](|store|, |functype|, |hostfunc|).
+    1. Set the [=surrounding agent=]'s [=associated store=] to |store|.
+    1. Return |funcaddr|.
+
    
+
+
    
+The algorithm ToJSValue(|w|) coerces a [=WebAssembly value=] to a JavaScript value by performing the following steps:
+
+1. Assert: |w| is not of  the form [=v128.const=] v128.
+1. If |w| is of the form [=i64.const=] |i64|,
+    1. Let |v| be [=signed_64=](|i64|).
+    1. Return [=ℤ=](|v| interpreted as a mathematical value).
+1. If |w| is of the form [=i32.const=] |i32|, return [=𝔽=]([=signed_32=](|i32| interpreted as a mathematical value)).
+1. If |w| is of the form [=f32.const=] |f32|,
+    1. If |f32| is [=+∞=] or [=−∞=], return **+∞**𝔽 or **-∞**𝔽, respectively.
+    1. If |f32| is [=nan=], return **NaN**.
+    1. Return [=𝔽=](|f32| interpreted as a mathematical value).
+1. If |w| is of the form [=f64.const=] |f64|,
+    1. If |f64| is [=+∞=] or [=−∞=], return **+∞**𝔽 or **-∞**𝔽, respectively.
+    1. If |f64| is [=nan=], return **NaN**.
+    1. Return [=𝔽=](|f64| interpreted as a mathematical value).
+1. If |w| is of the form [=ref.null=] t, return null.
+1. If |w| is of the form [=ref.func=] |funcaddr|, return the result of creating [=a new Exported Function=] from |funcaddr|.
+1. If |w| is of the form [=ref.extern=] |externaddr|, return the result of [=retrieving an extern value=] from |externaddr|.
+
+Note: Number values which are equal to NaN may have various observable NaN payloads; see [$NumericToRawBytes$] for details.
+
    
+
+
    
+
+For retrieving an extern value from an [=extern address=] |externaddr|, perform the following steps:
+
+1. Let |map| be the [=surrounding agent=]'s associated [=extern value cache=].
+1. Assert: |map|[|externaddr|] [=map/exists=].
+1. Return |map|[|externaddr|].
+
+
    
+
+
    
+The algorithm ToWebAssemblyValue(|v|, |type|) coerces a JavaScript value to a [=WebAssembly value=] by performing the following steps:
+
+1. Assert: |type| is not [=v128=].
+1. If |type| is [=i64=],
+    1. Let |i64| be [=?=] [$ToBigInt64$](|v|).
+    1. Return [=i64.const=] |i64|.
+1. If |type| is [=i32=],
+    1. Let |i32| be [=?=] [$ToInt32$](|v|).
+    1. Return [=i32.const=] |i32|.
+1. If |type| is [=f32=],
+    1. Let |number| be [=?=] [$ToNumber$](|v|).
+    1. If |number| is **NaN**,
+        1. Let |n| be an implementation-defined integer such that [=canon=]32 ≤ |n| < 2[=signif=](32).
+        1. Let |f32| be [=nan=](n).
+    1. Otherwise,
+        1. Let |f32| be |number| rounded to the nearest representable value using IEEE 754-2008 round to nearest, ties to even mode. [[IEEE-754]]
+    1. Return [=f32.const=] |f32|.
+1. If |type| is [=f64=],
+    1. Let |number| be [=?=] [$ToNumber$](|v|).
+    1. If |number| is **NaN**,
+        1. Let |n| be an implementation-defined integer such that [=canon=]64 ≤ |n| < 2[=signif=](64).
+        1. Let |f64| be [=nan=](n).
+    1. Otherwise,
+        1. Let |f64| be |number|.
+    1. Return [=f64.const=] |f64|.
+1. If |type| is [=funcref=],
+    1. If |v| is null,
+        1. Return [=ref.null=] [=funcref=].
+    1. If |v| is an [=Exported Function=],
+        1. Let |funcaddr| be the value of |v|'s \[[FunctionAddress]] internal slot.
+        1. Return [=ref.func=] |funcaddr|.
+    1. Throw a {{TypeError}}.
+1. If |type| is [=externref=],
+    1. If |v| is null,
+        1. Return [=ref.null=] [=externref=].
+    1. Let |map| be the [=surrounding agent=]'s associated [=extern value cache=].
+    1. If a [=extern address=] |externaddr| exists such that |map|[|externaddr|] is the same as |v|,
+        1. Return [=ref.extern=] |externaddr|.
+    1. Let [=extern address=] |externaddr| be the smallest address such that |map|[|externaddr|] [=map/exists=] is false.
+    1. [=map/Set=] |map|[|externaddr|] to |v|.
+    1. Return [=ref.extern=] |externaddr|.
+1. Assert: This step is not reached.
+
+
    
+
+
    Tags
    
+
+The tag_alloc(|store|, |parameters|) algorithm creates a new [=tag address=] for |parameters| in |store| and returns the updated store and the [=tag address=].
+
+The tag_parameters(|store|, |tagAddress|) algorithm returns the [=list=] of types for |tagAddress| in |store|.
+
+
    Exception types
    
+
+
    +dictionary TagType {
+  required sequence<ValueType> parameters;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+interface Tag {
+  constructor(TagType type);
+  TagType type();
+};
+
    
+
+A {{Tag}} value represents a type of exception.
+
+
    
+
+To initialize a Tag object |tag| from a [=tag address=] |tagAddress|, perform the following steps:
+
+1. Let |map| be the [=surrounding agent=]'s associated [=Tag object cache=].
+1. Assert: |map|[|tagAddress|] doesn't [=map/exist=].
+1. Set |tag|.\[[Address]] to |tagAddress|.
+1. [=map/Set=] |map|[|tagAddress|] to |tag|.
+
+
    
+
+
    
+
+To create a Tag object from a [=tag address=] |tagAddress|, perform the following steps:
+
+1. Let |map| be the [=surrounding agent=]'s associated [=Tag object cache=].
+1. If |map|[|tagAddress|] [=map/exists=],
+    1. Return |map|[|tagAddress|].
+1. Let |tag| be a [=new=] {{Tag}}.
+1. [=initialize a Tag object|Initialize=] |tag| from |tagAddress|.
+1. Return |tag|.
+
+
    
+
+
    
+
+The new Tag(|type|) constructor steps are:
+
+1. Let |parameters| be |type|["parameters"].
+1. Let |wasmParameters| be «».
+1. [=list/iterate|For each=] |type| of |parameters|,
+    1. [=list/Append=] [=ToValueType=](|type|) to |wasmParameters|.
+1. Let |store| be the current agent's [=associated store=].
+1. Let (|store|, |tagAddress|) be [=tag_alloc=](|store|, |wasmParameters|).
+1. Set the current agent's [=associated store=] to |store|.
+1. [=initialize a Tag object|Initialize=] **this** from |tagAddress|.
+
+
    
+
+
    
+
+The type() method steps are:
+
+1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+1. Let |parameters| be [=tag_parameters=](|store|, **this**.\[[Address]]).
+1. Let |idlParameters| be «».
+1. [=list/iterate|For each=] |type| of |parameters|,
+    1. [=list/Append=] [$FromValueType$](|type|) to |idlParameters|.
+1. Return «[ "{{TagType/parameters}}" → |idlParameters| ]».
+
+Advisement: This method is only expected to be implemented or shipped when both this proposal and the Type Reflection proposal are implemented or shipped (respectively).
+
+
    
+
+
    Runtime exceptions
    
+
+
    +dictionary ExceptionOptions {
+  boolean traceStack = false;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+interface Exception {
+  constructor(Tag exceptionTag, sequence<any> payload, optional ExceptionOptions options = {});
+  any getArg(Tag exceptionTag, [EnforceRange] unsigned long index);
+  boolean is(Tag exceptionTag);
+  readonly attribute (DOMString or undefined) stack;
+};
+
    
+
+An {{Exception}} value represents an exception.
+
+
    
+
+To create an Exception object from a [=tag address=] |tagAddress| and a [=list=] of
+WebAssembly values |payload|, perform the following steps:
+
+1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+1. Let |types| be [=tag_parameters=](|store|, |tagAddress|).
+1. Assert: |types|'s [=list/size=] is |payload|'s [=list/size=].
+1. [=list/iterate|For each=] |value| and |resultType| of |payload| and |types|, paired linearly,
+    1. Assert: |value|'s type matches |resultType|.
+1. Let |exception| be a [=new=] {{Exception}}.
+1. Set |exception|.\[[Type]] to |tagAddress|.
+1. Set |exception|.\[[Payload]] to |payload|.
+1. Set |exception|.\[[Stack]] to undefined.
+1. Return |exception|.
+
+
    
+
+
    
+
+The new Exception(|exceptionTag|, |payload|, |options|)
+constructor steps are:
+
+1. Let |store| be the [=surrounding agent=]'s [=associated store=].
+1. Let |types| be [=tag_parameters=](|store|, |exceptionTag|.\[[Address]]).
+1. If |types|'s [=list/size=] is not |payload|'s [=list/size=],
+    1. Throw a {{TypeError}}.
+1. Let |wasmPayload| be « ».
+1. [=list/iterate|For each=] |value| and |resultType| of |payload| and |types|, paired linearly,
+    1. [=list/Append=] ? [=ToWebAssemblyValue=](|value|, |resultType|) to |wasmPayload|.
+1. Set **this**.\[[Type]] to |exceptionTag|.\[[Address]].
+1. Set **this**.\[[Payload]] to |wasmPayload|.
+1. If |options|["traceStack"] is true,
+    1. Set **this**.\[[Stack]] to either a {{DOMString}} representation of the current call stack or undefined.
+1. Otherwise,
+    1. Set **this**.\[[Stack]] to undefined.
+
+
    
+
+
    
+
+The getArg(|exceptionTag|, |index|) method steps are:
+
+1. If **this**.\[[Type]] is not equal to |exceptionTag|.\[[Address]],
+    1. Throw a {{TypeError}}.
+1. Let |payload| be **this**.\[[Payload]].
+1. If |index| ≥ |payload|'s [=list/size=],
+    1. Throw a {{RangeError}}.
+1. Return [=ToJSValue=](|payload|[|index|]).
+
+
    
+
+
    
+
+The is(|exceptionTag|) method steps are:
+
+1. If **this**.\[[Type]] is not equal to |exceptionTag|.\[[Address]],
+    1. Return false.
+1. Return true.
+
+
    
+
+
    
+
+The stack getter steps are:
+
+1. Return **this**.\[[Stack]].
+
+
    
+
+
    JavaScript exceptions
    
+
+The JavaScript exception tag is a [=tag address=] reserved by this
+specification to distinguish exceptions originating from JavaScript.
+
+For any [=associated store=] |store|, the result of
+[=tag_parameters=](|store|, [=JavaScript exception tag=]) must be « ».
+
+
    
+
+To throw with a [=tag address=] |type|, a matching [=list=] of WebAssembly values |payload|, and an [=externref=] |opaqueData|, perform the following steps:
+
+1. Unwind the stack until reaching the *catching try block* given |type|.
+1. Invoke the catch block with |payload| and |opaqueData|.
+
+Note: This algorithm is expected to be moved into the core specification.
+
+
    
+
+
    Error Objects
    
+
+WebAssembly defines the following Error classes: CompileError, LinkError, and RuntimeError.
+
+
    
+When the [=namespace object=] for the {{WebAssembly}} namespace is [=create a namespace object|created=], the following steps must be run:
+
+1.  Let |namespaceObject| be the [=namespace object=].
+1.  [=list/iterate|For each=] |error| of « "CompileError", "LinkError", "RuntimeError" »,
+    1.  Let |constructor| be a new object, implementing the [=NativeError Object Structure=], with NativeError set to |error|.
+    1.  [=!=] [$CreateMethodProperty$](|namespaceObject|, |error|,  |constructor|).
+
+
    
+
+Note: This defines {{CompileError}}, {{LinkError}}, and {{RuntimeError}} classes on the {{WebAssembly}} namespace, which are produced by the APIs defined in this specification.
+They expose the same interface as native JavaScript errors like {{TypeError}} and {{RangeError}}.
+
+Note: It is not currently possible to define this behavior using Web IDL.
+
+
+
    Error Condition Mappings to JavaScript
    
+
+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.
+
+
    Stack Overflow
    
+
+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.
+
+
    Out of Memory
    
+
+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.
+
+
    
+    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.
+
    
+
+
    Implementation-defined Limits
    
+
+The WebAssembly core specification allows an implementation to define limits on the syntactic structure of the module.
+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 one of the following limits with a {{CompileError}}:
+In practice, an implementation may run out of resources for valid modules below these limits.
+
+
      
+
    • The maximum size of a module is 1,073,741,824 bytes (1 GiB).
      • 
+
    • The maximum number of types defined in the types section is 1,000,000.
      • 
+
    • The maximum number of functions defined in a module is 1,000,000.
      • 
+
    • The maximum number of imports declared in a module is 100,000.
      • 
+
    • The maximum number of exports declared in a module is 100,000.
      • 
+
    • The maximum number of globals defined in a module is 1,000,000.
      • 
+
    • The maximum number of tags defined in a module is 1,000,000.
      • 
+
    • The maximum number of data segments defined in a module is 100,000.
      • 
+
+
    • The maximum number of tables, including declared or imported tables, is 100,000.
      • 
+
    • The maximum size of a table is 10,000,000.
      • 
+
    • The maximum number of table entries in any table initialization is 10,000,000.
      • 
+
    • The maximum number of memories, including declared or imported memories, is 1.
      • 
+
+
    • The maximum number of parameters to any function or block is 1,000.
      • 
+
    • The maximum number of return values for any function or block is 1,000.
      • 
+
    • The maximum size of a function body, including locals declarations, is 7,654,321 bytes.
      • 
+
    • The maximum number of locals declared in a function, including implicitly declared as parameters, is 50,000.
      • 
+
    
+
+An implementation must throw a {{RuntimeError}} if one of the following limits is exceeded during runtime:
+In practice, an implementation may run out of resources for valid modules below these limits.
+
+
      
+
    • The maximum size of a table is 10,000,000.
      • 
+
    • The maximum number of pages of a memory is 65,536.
      • 
+
    
+
+
    Security and Privacy Considerations
    
+
+
    This section is non-normative.
    
+
+This document defines a host environment for WebAssembly. It enables a WebAssembly instance to [=import=] JavaScript objects and functions from an [=read the imports|import object=], but otherwise provides no access to the embedding environment. Thus a WebAssembly instance is bound to the same constraints as JavaScript.
diff --git a/document/metadata/code/.gitignore b/document/metadata/code/.gitignore
new file mode 100644
index 0000000000..b932ec283e
--- /dev/null
+++ b/document/metadata/code/.gitignore
@@ -0,0 +1,3 @@
+_build
+_static
+document/*.pyc
diff --git a/document/metadata/code/LICENSE b/document/metadata/code/LICENSE
new file mode 100644
index 0000000000..795b406e4e
--- /dev/null
+++ b/document/metadata/code/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/document/metadata/code/Makefile b/document/metadata/code/Makefile
new file mode 100644
index 0000000000..e8b975c727
--- /dev/null
+++ b/document/metadata/code/Makefile
@@ -0,0 +1,361 @@
+# Makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+PAPER         = a4
+BUILDDIR      = _build
+STATICDIR     = _static
+DOWNLOADDIR   = _download
+NAME          = WebAssembly-Metadata-Code
+
+# Internal variables.
+PAPEROPT_a4     = -D latex_paper_size=a4
+PAPEROPT_letter = -D latex_paper_size=letter
+ALLSPHINXOPTS   = -d $(BUILDDIR)/doctrees $(SPHINXOPTS) .
+# the i18n builder cannot share the environment and doctrees with the others
+I18NSPHINXOPTS  = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
+
+.PHONY: usage
+usage:
+	@echo "Please use \`make ' where  is one of"
+	@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 "  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"
+
+.PHONY: help
+help:
+	@echo "Usage: \`make ' where  is one of"
+	@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 "  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"
+	@echo "  pickle     to make pickle files"
+	@echo "  json       to make JSON files"
+	@echo "  htmlhelp   to make HTML files and a HTML help project"
+	@echo "  qthelp     to make HTML files and a qthelp project"
+	@echo "  applehelp  to make an Apple Help Book"
+	@echo "  devhelp    to make HTML files and a Devhelp project"
+	@echo "  epub       to make an epub"
+	@echo "  epub3      to make an epub3"
+	@echo "  latex      to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
+	@echo "  latexpdf   to make LaTeX files and run them through pdflatex"
+	@echo "  latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
+	@echo "  text       to make text files"
+	@echo "  man        to make manual pages"
+	@echo "  texinfo    to make Texinfo files"
+	@echo "  info       to make Texinfo files and run them through makeinfo"
+	@echo "  gettext    to make PO message catalogs"
+	@echo "  changes    to make an overview of all changed/added/deprecated items"
+	@echo "  xml        to make Docutils-native XML files"
+	@echo "  pseudoxml  to make pseudoxml-XML files for display purposes"
+	@echo "  linkcheck  to check all external links for integrity"
+	@echo "  doctest    to run all doctests embedded in the documentation (if enabled)"
+	@echo "  coverage   to run coverage check of the documentation (if enabled)"
+	@echo "  dummy      to check syntax errors of document sources"
+
+.PHONY: deploy
+deploy:
+	(cd ../..; make dir-core deploy-core)
+
+.PHONY: publish
+publish: clean all deploy
+
+.PHONY: publish-main
+publish-main: clean main deploy
+
+.PHONY: all
+all:	pdf html
+
+.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.
+
+
+%.rst: %.py
+	(cd `dirname $@`; ./`basename $^`)
+
+.PHONY: pdf
+pdf:	latexpdf
+	mkdir -p $(BUILDDIR)/html/$(DOWNLOADDIR)
+	ln -f $(BUILDDIR)/latex/$(NAME).pdf $(BUILDDIR)/html/$(DOWNLOADDIR)/$(NAME).pdf
+
+
+.PHONY: clean
+clean:
+	rm -rf $(BUILDDIR)
+	rm -rf $(STATICDIR)
+
+.PHONY: html
+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; \
+	done
+	for file in `ls $(BUILDDIR)/html/*/*.html`; \
+	do \
+	  sed s:BASEDIR:..:g <$$file >$$file.out; \
+	  mv -f $$file.out $$file; \
+	done
+	@echo
+	@echo "Build finished. The HTML pages are in `pwd`/$(BUILDDIR)/html/."
+
+.PHONY: dirhtml
+dirhtml:
+	$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
+	@echo
+	@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
+
+.PHONY: singlehtml
+singlehtml:
+	$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/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
+	python3 util/bikeshed_fixup.py $(BUILDDIR)/bikeshed_singlehtml/index.html \
+		>$(BUILDDIR)/bikeshed_singlehtml/index_fixed.html
+	@echo ==== Showing contents of _build/bikeshed_singlehtml/index_fixed.html ====
+	@head -n10 _build/bikeshed_singlehtml/index_fixed.html
+	@echo ... skipping $$(expr `cat _build/bikeshed_singlehtml/index_fixed.html | wc -l` - 20) lines ...
+	@tail -n10 _build/bikeshed_singlehtml/index_fixed.html
+	@echo
+	@echo =========================================================================
+	mkdir -p $(BUILDDIR)/bikeshed_mathjax/
+	bikeshed spec index.bs $(BUILDDIR)/bikeshed_mathjax/index.html
+	mkdir -p $(BUILDDIR)/html/bikeshed/
+	(cd util/katex/ && yarn && yarn build && npm install --only=prod)
+	python3 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
+	cp $(BUILDDIR)/bikeshed_singlehtml/_static/pygments.css \
+		$(BUILDDIR)/html/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..."
+	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
+	@echo
+	@echo "Build finished; now you can process the pickle files."
+
+.PHONY: json
+json:
+	$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
+	@echo
+	@echo "Build finished; now you can process the JSON files."
+
+.PHONY: htmlhelp
+htmlhelp:
+	$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
+	@echo
+	@echo "Build finished; now you can run HTML Help Workshop with the" \
+	      ".hhp project file in $(BUILDDIR)/htmlhelp."
+
+.PHONY: qthelp
+qthelp:
+	$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
+	@echo
+	@echo "Build finished; now you can run "qcollectiongenerator" with the" \
+	      ".qhcp project file in $(BUILDDIR)/qthelp, like this:"
+	@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/WebAssembly.qhcp"
+	@echo "To view the help file:"
+	@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/WebAssembly.qhc"
+
+.PHONY: applehelp
+applehelp:
+	$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
+	@echo
+	@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
+	@echo "N.B. You won't be able to view it unless you put it in" \
+	      "~/Library/Documentation/Help or install it in your application" \
+	      "bundle."
+
+.PHONY: devhelp
+devhelp:
+	$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
+	@echo
+	@echo "Build finished."
+	@echo "To view the help file:"
+	@echo "# mkdir -p $$HOME/.local/share/devhelp/WebAssembly"
+	@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/WebAssembly"
+	@echo "# devhelp"
+
+.PHONY: epub
+epub:
+	$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
+	@echo
+	@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
+
+.PHONY: epub3
+epub3:
+	$(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3
+	@echo
+	@echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3."
+
+
+.PHONY: latex-core-aux
+latex-core-aux:
+	(cd ../../core; make BUILDDIR=$(BUILDDIR) latexpdf)
+	mkdir -p $(BUILDDIR)/latex
+	cp ../../core/$(BUILDDIR)/latex/WebAssembly.aux $(BUILDDIR)/latex/
+
+.PHONY: latex
+latex: latex-core-aux
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo
+	@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
+	@echo "Run \`make' in that directory to run these through (pdf)latex" \
+	      "(use \`make latexpdf' here to do that automatically)."
+
+.PHONY: latexpdf
+latexpdf: latex-core-aux
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through pdflatex..."
+	$(MAKE) -C $(BUILDDIR)/latex LATEXMKOPTS=" $(BUILDDIR)/latex/LOG 2>&1 || cat $(BUILDDIR)/latex/LOG
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: latexpdfja
+latexpdfja: latex-core-aux
+	$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
+	@echo "Running LaTeX files through platex and dvipdfmx..."
+	$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
+	@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
+
+.PHONY: text
+text:
+	$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
+	@echo
+	@echo "Build finished. The text files are in $(BUILDDIR)/text."
+
+.PHONY: man
+man:
+	$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
+	@echo
+	@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
+
+.PHONY: texinfo
+texinfo:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo
+	@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
+	@echo "Run \`make' in that directory to run these through makeinfo" \
+	      "(use \`make info' here to do that automatically)."
+
+.PHONY: info
+info:
+	$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
+	@echo "Running Texinfo files through makeinfo..."
+	make -C $(BUILDDIR)/texinfo info
+	@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
+
+.PHONY: gettext
+gettext:
+	$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
+	@echo
+	@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
+
+.PHONY: changes
+changes:
+	$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
+	@echo
+	@echo "The overview file is in $(BUILDDIR)/changes."
+
+.PHONY: linkcheck
+linkcheck:
+	$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
+	@echo
+	@echo "Link check complete; look for any errors in the above output " \
+	      "or in $(BUILDDIR)/linkcheck/output.txt."
+
+.PHONY: doctest
+doctest:
+	$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
+	@echo "Testing of doctests in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/doctest/output.txt."
+
+.PHONY: coverage
+coverage:
+	$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
+	@echo "Testing of coverage in the sources finished, look at the " \
+	      "results in $(BUILDDIR)/coverage/python.txt."
+
+.PHONY: xml
+xml:
+	$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
+	@echo
+	@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
+
+.PHONY: pseudoxml
+pseudoxml:
+	$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
+	@echo
+	@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
+
+.PHONY: dummy
+dummy:
+	$(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy
+	@echo
+	@echo "Build finished. Dummy builder generates no files."
diff --git a/document/metadata/code/README.md b/document/metadata/code/README.md
new file mode 100644
index 0000000000..d5fe68ce8d
--- /dev/null
+++ b/document/metadata/code/README.md
@@ -0,0 +1,25 @@
+# WebAssembly Code Metadata Specification
+
+This is the official WebAssembly "language" specification.
+
+It uses [Sphinx](http://www.sphinx-doc.org/). To install that:
+```
+pip install sphinx
+```
+To make HTML (result in `_build/html`):
+```
+make html
+```
+To make PDF (result in `_build/latex`, requires LaTeX):
+```
+make pdf
+```
+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.
diff --git a/document/metadata/code/binary.rst b/document/metadata/code/binary.rst
new file mode 100644
index 0000000000..1b17265513
--- /dev/null
+++ b/document/metadata/code/binary.rst
@@ -0,0 +1,69 @@
+.. _binary:
+
+Binary Format
+=============
+
+.. _binary-codemetadata:
+
+Code Metadata
+-------------
+
+A Code Metadata item is a piece of information logically attached to an instruction.
+
+An item is associated with a format, which defines the item's payload.
+
+All code metadata items of a format named *T* are grouped under a custom section
+named *'metadata.code.T'*.
+The following parametrized grammar rules define the generic structure of a code metadata
+section of format *T*.
+
+.. math::
+   \begin{array}{llcll}
+   \production{code metadata section} & \Bcodemetadatasec(\B{T}) &::=&
+     \Bsection_0(\Bcodemetadata(\B{T})) \\
+   \production{code metadata} & \Bcodemetadata(\B{T}) &::=&
+     n{:}\Bname & (\iff n = \text{metadata.code.T}) \\ &&&
+     \Bvec(\Bcodemetadatafunc(\B{T})) \\
+   \production{code metadata function} & \Bcodemetadatafunc(\B{T}) &::=&
+     x{:}\Bfuncidx~\Bvec(\Bcodemetadataitem(\B{T})) \\
+   \production{code metadata item} & \Bcodemetadataitem(\B{T}) &::=&
+     \X{off}{:}\Bu32 ~~ \X{size}{:}\Bu32 & (\iff \X{size} = ||\B{T}||) \\ &&&
+      \X{data}{:}\B{T} \\
+   \end{array}
+.. index:: ! code metadata section
+
+Where :math:`\X{off}` is the byte offset of the attached instruction, relative to the beginning of the |Bfunc| declaration, and :math:`\X{data}` is a further payload, whose content depends on the format :math:`T`.
+
+|Bcodemetadatafunc| entries must appear in order of increasing :math:`x`, and duplicate id values are not allowed. |Bcodemetadata| entries must appear in order of increasing :math:`\X{off}`, and duplicate offset values are not allowed.
+
+.. _binary-branchhints:
+
+Branch Hints
+~~~~~~~~~~~~
+
+A Branch Hint is a code metadata item with format *branch_hint*.
+
+It can only be attached to |BRIF| and |IF| instructions.
+
+Its payload indicates whether the branch is likely or unlikely to be taken.
+
+All branch hints for a module are contained in a single code metadata section
+with name *'metadata.code.branch_hint'*.
+
+.. math::
+   \begin{array}{llcll}
+   \production{branch hint section} & \Bbranchhintsec &::=&
+     \Bcodemetadatasec(\Bbranchhint) \\
+   \production{branch hint} & \Bbranchhint &::=&
+     \Bunlikely \\ &&|&
+     \Blikely \\
+   \production{unlikely} & \Bunlikely &::=&
+     \hex{00} \\
+   \production{likely} & \Blikely &::=&
+     \hex{01} \\
+   \end{array}
+.. index:: ! branch hint section
+
+A value of |Blikely| means that the branch is likely to be taken, while a
+value of |Bunlikely| means the opposite. A branch with no hints is considered
+equally likely to be taken or not.
diff --git a/document/metadata/code/conf.py b/document/metadata/code/conf.py
new file mode 100644
index 0000000000..bff6550b48
--- /dev/null
+++ b/document/metadata/code/conf.py
@@ -0,0 +1,505 @@
+# -*- 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
+from datetime import date
+
+core_dir = os.path.abspath('../../core')
+sys.path.insert(0, core_dir)
+pwd = os.path.abspath('.')
+sys.path.insert(0, pwd)
+
+# -- General configuration ------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+needs_sphinx = '2.3'
+
+# 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',
+  'util.mathdef',
+  'util.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-Metadata-Code'
+project = u'WebAssembly-Metadata-Code'
+title = u'WebAssembly Code Metadata Specification'
+copyright = u'2024, WebAssembly Community Group'
+author = u'WebAssembly Community Group'
+editor = u'Yuri Iozzelli (editor)'
+logo = 'static/webassembly.png'
+
+# The name of the GitHub repository this resides in
+repo = 'spec'
+
+# The draft version string (clear out for release cuts)
+draft = ' (Draft ' + date.today().strftime("%Y-%m-%d") + ')'
+
+# 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 = ''
+# 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 = 'en'
+
+# 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 = 'alabaster'
+
+# 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 = {
+  'logo': logo,
+  'logo_name': 'WebAssembly',
+  'description': 'WebAssembly Specification',
+  'fixed_sidebar': True,
+  'sidebar_width': '260px',
+  'sidebar_collapse': True,
+  'show_powered_by': False,
+  'extra_nav_links': {
+    'Download as PDF': 'BASEDIR/_download/' + name + '.pdf'
+  },
+}
+
+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.
+# " v documentation" by default.
+#
+html_title = u'WebAssembly Custom Sections'
+
+# 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/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 = False
+
+# 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 = '%Y-%m-%d'
+
+# If true, an OpenSearch description file will be output, and all pages will
+# contain a  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.
+   # Don't type-set cross references with emphasis.
+   'preamble': '\\renewcommand\\sphinxcrossref[1]{#1}\n\\externaldocument[Core-]{WebAssembly}[https://webassembly.github.io//'+repo+'/core/_download/WebAssembly.pdf]\n',
+
+   # Latex figure (float) alignment
+  'figure_align': 'htbp',
+
+   # Fancy chapters [Bjarne, Sonny, Lenny, Glenn, Conny, Rejne]
+   'fncychap': '\\usepackage[Sonny]{fncychap}',
+
+   # Allow chapters to start on even pages
+   'extraclassoptions': 'openany',
+
+   'extrapackages': '\\usepackage{xr-hyper}',
+}
+
+# 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 + '\\\\ \\hfill\\large ' + editor,
+    'howto'
+  ),
+]
+
+# 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 = 'section'
+
+# 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 = """
+.. |issuelink| replace:: https://github.com/webassembly/""" + repo + """/issues/
+.. |pagelink| replace:: https://webassembly.github.io/""" + repo + """/core/
+.. include:: /""" + core_dir + """/util/macros.def
+.. include:: /""" + pwd + """/util/macros.def
+"""
+
+# https://www.sphinx-doc.org/en/master/usage/extensions/math.html#confval-mathjax3_config
+# https://docs.mathjax.org/en/latest/web/configuration.html#configuration
+# https://docs.mathjax.org/en/latest/options/input/tex.html#tex-maxbuffer
+mathjax3_config = {
+    'tex': { 'maxBuffer': 30*1024 },
+}
diff --git a/document/metadata/code/index.rst b/document/metadata/code/index.rst
new file mode 100644
index 0000000000..7485244829
--- /dev/null
+++ b/document/metadata/code/index.rst
@@ -0,0 +1,15 @@
+WebAssembly Code Metadata
+=========================
+
+.. only:: html
+
+   | Editor: Yuri Iozzelli
+
+   | Issue Tracker: |WasmIssues|
+
+.. toctree::
+   :maxdepth: 1
+
+   intro
+   binary
+   text
diff --git a/document/metadata/code/intro.rst b/document/metadata/code/intro.rst
new file mode 100644
index 0000000000..59503b413e
--- /dev/null
+++ b/document/metadata/code/intro.rst
@@ -0,0 +1,18 @@
+.. _intro:
+
+Introduction
+============
+
+This document defines a generic mechanism for attaching arbitrary metadata to WebAssembly instructions.
+Additionally, it defines specific metadata formats using this mechanism.
+
+Such metadata does not contribute to, or otherwise affect, the WebAssembly semantics, and may be ignored by an implementation.
+
+However, it can provides useful information that implementations can make use of to improve user experience or take compilation hints.
+
+Dependencies
+~~~~~~~~~~~~
+
+This document is based on the WebAssembly core specification (|WasmDraft|), and makes use of
+terms and definitions described there. These uses always link to the corresponding definition
+in the core specification.
diff --git a/document/metadata/code/static/custom.css b/document/metadata/code/static/custom.css
new file mode 100644
index 0000000000..33bb863d42
--- /dev/null
+++ b/document/metadata/code/static/custom.css
@@ -0,0 +1,78 @@
+a {
+  color: #004BAB;
+  text-decoration: none;
+}
+
+a.reference {
+  border-bottom: none;
+}
+
+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%; }
+div.body h2 { font-size: 150%; }
+div.body h3 { font-size: 120%; }
+div.body h4 { font-size: 110%; }
+
+div.note {
+  border: 0px;
+  font-size: 90%;
+  background-color: #F6F8FF;
+}
+
+div.admonition {
+  padding: 10px;
+}
+
+div.admonition p.admonition-title {
+  margin: 0px 0px 0px 0px;
+  font-size: 100%;
+  font-weight: bold;
+}
+
+div.math {
+  background-color: #F0F0F0;
+  padding: 3px 0 3px 0;
+  overflow-x: auto;
+  overflow-y: hidden;
+}
+
+div.relations {
+  display: block;
+}
+
+div.sphinxsidebar {
+  z-index: 1;
+  background: #FFF;
+  margin-top: -30px;
+  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;
+}
+
+div.sphinxsidebar a:hover {
+  border-bottom: 1px dotted;
+}
diff --git a/document/metadata/code/static/webassembly.png b/document/metadata/code/static/webassembly.png
new file mode 100644
index 0000000000..f9edc61098
Binary files /dev/null and b/document/metadata/code/static/webassembly.png differ
diff --git a/document/metadata/code/text.rst b/document/metadata/code/text.rst
new file mode 100644
index 0000000000..c5ff1fbd04
--- /dev/null
+++ b/document/metadata/code/text.rst
@@ -0,0 +1,24 @@
+.. _text:
+
+Text Format
+===========
+
+.. _text-codemetadata:
+
+Code Metadata
+-------------
+
+Code Metadata items appear in the text format as custom annotations, and are considered
+attached to the first instruction that follows them.
+
+
+.. math::
+   \begin{array}{llclll}
+   \production{code metadata annotation} & \Tcodemetadataannot(\B{T}) &::=&
+     \text{(@metadata.code.T}~\X{data}{:}\B{T}~\text{)} \\
+   \end{array}
+.. index:: ! code metadata annotation
+
+Where `T` is the format name of the item, and `data` is a byte string containing the same
+payload as in the binary format.
+
diff --git a/document/metadata/code/util/macros.def b/document/metadata/code/util/macros.def
new file mode 100644
index 0000000000..fbdd841402
--- /dev/null
+++ b/document/metadata/code/util/macros.def
@@ -0,0 +1,44 @@
+.. LINK MACROS
+
+.. External Standards
+.. ------------------
+
+.. External Definitions
+.. --------------------
+
+
+.. MATH MACROS
+
+.. Abstract Syntax
+.. ---------------
+
+.. Values, non-terminals
+
+
+.. Binary Format
+.. -------------
+
+.. Code Metadata, non-terminals
+
+.. |Bcodemetadatasec| mathdef:: \xref{binary}{binary-codemetadata}{\B{codemetadatasec}}
+.. |Bcodemetadata| mathdef:: \xref{binary}{binary-codemetadata}{\B{codemetadata}}
+.. |Bcodemetadatafunc| mathdef:: \xref{binary}{binary-codemetadata}{\B{codemetadatafunc}}
+.. |Bcodemetadataitem| mathdef:: \xref{binary}{binary-codemetadata}{\B{codemetadataitem}}
+
+.. Branch Hints, non-terminals
+
+.. |Bbranchhintsec| mathdef:: \xref{binary}{binary-branchhints}{\B{branchhintsec}}
+.. |Bbranchhint| mathdef:: \xref{binary}{binary-branchhints}{\B{branchhint}}
+.. |Bunlikely| mathdef:: \xref{binary}{binary-branchhints}{\B{unlikely}}
+.. |Blikely| mathdef:: \xref{binary}{binary-branchhints}{\B{likely}}
+
+
+.. Text Format
+.. -----------
+
+   \production{code metadata annotation} & \Tcodemetadataannot(\B{T}) &::=&
+
+.. Branch Hints, non-terminals
+
+.. |Tcodemetadataannot| mathdef:: \xref{text}{text-codemetadata}{\T{codemetadataannot}}
+
diff --git a/document/metadata/code/util/mathdef.py b/document/metadata/code/util/mathdef.py
new file mode 100644
index 0000000000..57a6cf043d
--- /dev/null
+++ b/document/metadata/code/util/mathdef.py
@@ -0,0 +1,128 @@
+from sphinx.directives.patches import MathDirective
+from sphinx.util.texescape import tex_replace_map
+from sphinx.writers.html5 import HTML5Translator
+from sphinx.writers.latex import LaTeXTranslator
+from docutils import nodes
+from docutils.nodes import math
+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):
+  if "/" in file:
+    return '\\href{../../core/%s.html#%s}' % (file, id.replace('_', '-'))
+  else:
+    return '\\href{%s.html#%s}' % (file, id.replace('_', '-'))
+
+def html_transform_math_xref(node):
+  new_text = xref_re.sub(lambda m: html_hyperlink(m.group(1), m.group(2)), node.astext())
+  node.children[0] = nodes.Text(new_text)
+
+# Mirrors sphinx/writers/latex
+def latex_hyperlink(file, id):
+  id = text_type(id).translate(tex_replace_map).\
+    encode('ascii', 'backslashreplace').decode('ascii').\
+    replace('_', '-').replace('\\', '_')
+  if "/" in file:
+    return '\\hyperref[Core-%s:%s]' % (file, id)
+  else:
+    return '\\hyperref[%s:%s]' % (file, id)
+
+def latex_transform_math_xref(node):
+  new_text = xref_re.sub(lambda m: latex_hyperlink(m.group(1), m.group(2)), node.astext())
+  node.children[0] = nodes.Text(new_text)
+
+# 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(raw, text)], []
+
+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().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 = {}
+    # TODO: we don't ever hit the case where len(self.content) > 1
+    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().run()
+
+class WebAssemblyHTML5Translator(HTML5Translator):
+  """
+  Customize HTML5Translator.
+  Convert xref in math and math block nodes to hrefs.
+  """
+  def visit_math(self, node, math_env = ''):
+    html_transform_math_xref(node)
+    super().visit_math(node, math_env)
+
+  def visit_math_block(self, node, math_env  = ''):
+    html_transform_math_xref(node)
+    super().visit_math_block(node, math_env)
+
+class WebAssemblyLaTeXTranslator(LaTeXTranslator):
+  """
+  Customize LaTeXTranslator.
+  Convert xref in math and math block nodes to hyperrefs.
+  """
+  def visit_math(self, node):
+    latex_transform_math_xref(node)
+    super().visit_math(node)
+
+  def visit_math_block(self, node):
+    latex_transform_math_xref(node)
+    super().visit_math_block(node)
+
+# Setup
+
+def setup(app):
+  app.set_translator('html', WebAssemblyHTML5Translator)
+  app.set_translator('latex', WebAssemblyLaTeXTranslator)
+  app.add_role('math', ext_math_role)
+  app.add_directive('math', ExtMathDirective, override = True)
+  app.add_directive('mathdef', MathdefDirective)
diff --git a/document/web-api/index.bs b/document/web-api/index.bs
index 5bd1dac2c6..efc6a66635 100644
--- a/document/web-api/index.bs
+++ b/document/web-api/index.bs
@@ -1,5 +1,5 @@
 
    -Title: WebAssembly Web API
+Title: WebAssembly Web API: Exception Handling
 Shortname: wasm-web-api
 Group: wasm
 Status: ED
@@ -34,6 +34,12 @@ Date: now
     "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"
   }
 }
 
    
@@ -67,6 +73,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
 
    diff --git a/interpreter/README.md b/interpreter/README.md
index 7d317ae6b2..8aa7e9ae19 100644
--- a/interpreter/README.md
+++ b/interpreter/README.md
@@ -215,6 +215,7 @@ func_type:   ( type  )? * *
 global_type:  | ( mut  )
 table_type:   ? 
 memory_type:  ?
+tag_type: ( type  )? *
 
 num:  | 
 var:  | 
@@ -242,6 +243,7 @@ expr:
   ( loop ?  * )
   ( if ?  ( then * ) ( else * )? )
   ( if ?  + ( then * ) ( else * )? ) ;; = + (if ?  (then *) (else *)?)
+  ( try_table ?   * * )
 
 instr:
   
@@ -250,6 +252,7 @@ instr:
   loop ?  * end ?                     ;; = (loop ?  *)
   if ?  * end ?                       ;; = (if ?  (then *))
   if ?  * else ? * end ? ;; = (if ?  (then *) (else *))
+  try_table ?  * * end ?       ;; = (try_table ?  * *)
 
 op:
   unreachable
@@ -270,6 +273,8 @@ op:
   return_call 
   return_call_ref 
   return_call_indirect ? (type )? 
+  throw 
+  throw_ref
   local.get 
   local.set 
   local.tee 
@@ -334,6 +339,12 @@ op:
   .extract_lane(_)? 
   .replace_lane 
 
+catch:
+  catch  
+  catch_ref  
+  catch_all 
+  catch_all_ref 
+
 func:    ( func ?  * * )
          ( func ? ( export  ) <...> )                         ;; = (export  (func )) (func ? <...>)
          ( func ? ( import   ) )           ;; = (import   (func ? ))
@@ -439,6 +450,7 @@ const:
 
 assertion:
   ( assert_return  * )   ;; assert action has expected results
+  ( assert_exception  )              ;; assert action throws an exception
   ( assert_trap   )         ;; assert action traps with given failure string
   ( assert_exhaustion   )   ;; assert action exhausts system resources
   ( assert_malformed   )    ;; assert module cannot be decoded with given failure string
@@ -532,6 +544,7 @@ action:
 
 assertion:
   ( assert_return  * )   ;; assert action has expected results
+  ( assert_exception  )              ;; assert action throws an exception
   ( assert_trap   )         ;; assert action traps with given failure string
   ( assert_exhaustion   )   ;; assert action exhausts system resources
   ( assert_malformed   )    ;; assert module cannot be decoded with given failure string
diff --git a/interpreter/binary/decode.ml b/interpreter/binary/decode.ml
index 95f699df45..e18dd6ad9e 100644
--- a/interpreter/binary/decode.ml
+++ b/interpreter/binary/decode.ml
@@ -146,6 +146,9 @@ let sized f s =
 
 open Types
 
+let zero s = expect 0x00 s "zero byte expected"
+let var s = u32 s
+
 let mutability s =
   match byte s with
   | 0 -> Cons
@@ -177,6 +180,7 @@ let heap_type s =
     (fun s -> VarHT (var_type s33 s));
     (fun s ->
       match s7 s with
+      | -0x0c -> NoExnHT
       | -0x0d -> NoFuncHT
       | -0x0e -> NoExternHT
       | -0x0f -> NoneHT
@@ -187,6 +191,7 @@ let heap_type s =
       | -0x14 -> I31HT
       | -0x15 -> StructHT
       | -0x16 -> ArrayHT
+      | -0x17 -> ExnHT
       | _ -> error s pos "malformed heap type"
     )
   ] s
@@ -194,6 +199,7 @@ let heap_type s =
 let ref_type s =
   let pos = pos s in
   match s7 s with
+  | -0x0c -> (Null, NoExnHT)
   | -0x0d -> (Null, NoFuncHT)
   | -0x0e -> (Null, NoExternHT)
   | -0x0f -> (Null, NoneHT)
@@ -204,6 +210,7 @@ let ref_type s =
   | -0x14 -> (Null, I31HT)
   | -0x15 -> (Null, StructHT)
   | -0x16 -> (Null, ArrayHT)
+  | -0x17 -> (Null, ExnHT)
   | -0x1c -> (NoNull, heap_type s)
   | -0x1d -> (Null, heap_type s)
   | _ -> error s pos "malformed reference type"
@@ -291,17 +298,17 @@ let global_type s =
   let mut = mutability s in
   GlobalT (mut, t)
 
+let tag_type s =
+  zero s; at var s
+
 
 (* Instructions *)
 
 open Ast
 open Operators
 
-let var s = u32 s
-
 let op s = byte s
 let end_ s = expect 0x0b s "END opcode expected"
-let zero s = expect 0x00 s "zero byte expected"
 
 let memop s =
   let pos = pos s in
@@ -365,7 +372,10 @@ let rec instr s =
     end
 
   | 0x05 -> error s pos "misplaced ELSE opcode"
-  | 0x06| 0x07 | 0x08 | 0x09 | 0x0a as b -> illegal s pos b
+  | 0x06 | 0x07 as b -> illegal s pos b
+  | 0x08 -> throw (at var s)
+  | 0x09 as b -> illegal s pos b
+  | 0x0a -> throw_ref
   | 0x0b -> error s pos "misplaced END opcode"
 
   | 0x0c -> br (at var s)
@@ -396,7 +406,14 @@ let rec instr s =
   | 0x1b -> select None
   | 0x1c -> select (Some (vec val_type s))
 
-  | 0x1d | 0x1e | 0x1f as b -> illegal s pos b
+  | 0x1d | 0x1e as b -> illegal s pos b
+
+  | 0x1f ->
+    let bt = block_type s in
+    let cs = vec (at catch) s in
+    let es = instr_block s in
+    end_ s;
+    try_table bt cs es
 
   | 0x20 -> local_get (at var s)
   | 0x21 -> local_set (at var s)
@@ -961,6 +978,20 @@ and instr_block' s es =
     let e' = instr s in
     instr_block' s ((e' @@ region s pos pos) :: es)
 
+and catch s =
+  match byte s with
+  | 0x00 ->
+    let x1 = at var s in
+    let x2 = at var s in
+    Operators.catch x1 x2
+  | 0x01 ->
+    let x1 = at var s in
+    let x2 = at var s in
+    catch_ref x1 x2
+  | 0x02 -> catch_all (at var s)
+  | 0x03 -> catch_all_ref (at var s)
+  | _ -> error s (pos s - 1) "malformed catch clause"
+
 let const s =
   let c = at instr_block s in
   end_ s;
@@ -986,6 +1017,7 @@ let id s =
     | 10 -> Custom.Code
     | 11 -> Custom.Data
     | 12 -> Custom.DataCount
+    | 13 -> Custom.Tag
     | _ -> error s (pos s) "malformed section id"
     ) bo
 
@@ -1014,6 +1046,7 @@ let import_desc s =
   | 0x01 -> TableImport (table_type s)
   | 0x02 -> MemoryImport (memory_type s)
   | 0x03 -> GlobalImport (global_type s)
+  | 0x04 -> TagImport (tag_type s)
   | _ -> error s (pos s - 1) "malformed import kind"
 
 let import s =
@@ -1064,6 +1097,16 @@ let memory_section s =
   section Custom.Memory (vec (at memory)) [] s
 
 
+(* Tag section *)
+
+let tag s =
+  let tgtype = tag_type s in
+  {tgtype}
+
+let tag_section s =
+  section Custom.Tag (vec (at tag)) [] s
+
+
 (* Global section *)
 
 let global s =
@@ -1083,6 +1126,7 @@ let export_desc s =
   | 0x01 -> TableExport (at var s)
   | 0x02 -> MemoryExport (at var s)
   | 0x03 -> GlobalExport (at var s)
+  | 0x04 -> TagExport (at var s)
   | _ -> error s (pos s - 1) "malformed export kind"
 
 let export s =
@@ -1261,6 +1305,8 @@ let module_ s =
   let customs = customs @ iterate (custom_section (After Table)) s in
   let memories = memory_section s in
   let customs = customs @ iterate (custom_section (After Memory)) s in
+  let tags = tag_section s in
+  let customs = customs @ iterate (custom_section (After Tag)) s in
   let globals = global_section s in
   let customs = customs @ iterate (custom_section (After Global)) s in
   let exports = export_section s in
@@ -1287,7 +1333,8 @@ let module_ s =
     List.map2 Source.(fun t f -> {f.it with ftype = t} @@ f.at)
       func_types func_bodies
   in
-  {types; tables; memories; globals; funcs; imports; exports; elems; datas; start},
+  { types; tables; memories; tags; globals; funcs;
+    imports; exports; elems; datas; start },
   customs
 
 
diff --git a/interpreter/binary/encode.ml b/interpreter/binary/encode.ml
index 81f0482eeb..072c351210 100644
--- a/interpreter/binary/encode.ml
+++ b/interpreter/binary/encode.ml
@@ -79,7 +79,7 @@ struct
   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 opt f xo = Option.iter f xo
   let vec f xs = len (List.length xs); list f xs
 
   let gap32 () = let p = pos s in word32 0l; byte 0; p
@@ -96,6 +96,9 @@ struct
   (* Types *)
 
   open Types
+  open Source
+
+  let var x = u32 x.it
 
   let mutability = function
     | Cons -> byte 0
@@ -123,6 +126,8 @@ struct
     | NoneHT -> s7 (-0x0f)
     | FuncHT -> s7 (-0x10)
     | NoFuncHT -> s7 (-0x0d)
+    | ExnHT -> s7 (-0x17)
+    | NoExnHT -> s7 (-0x0c)
     | ExternHT -> s7 (-0x11)
     | NoExternHT -> s7 (-0x0e)
     | VarHT x -> var_type s33 x
@@ -141,6 +146,8 @@ struct
     | (Null, NoneHT) -> s7 (-0x0f)
     | (Null, FuncHT) -> s7 (-0x10)
     | (Null, NoFuncHT) -> s7 (-0x0d)
+    | (Null, ExnHT) -> s7 (-0x17)
+    | (Null, NoExnHT) -> s7 (-0x0c)
     | (Null, ExternHT) -> s7 (-0x11)
     | (Null, NoExternHT) -> s7 (-0x0e)
     | (Null, t) -> s7 (-0x1d); heap_type t
@@ -199,10 +206,12 @@ struct
   let global_type = function
     | GlobalT (mut, t) -> val_type t; mutability mut
 
+  let tag_type x =
+    u32 0x00l; var x
 
-  (* Instructions *)
 
-  open Source
+  (* Expressions *)
+
   open Ast
   open Value
   open V128
@@ -247,6 +256,8 @@ struct
       op 0x04; block_type bt; list instr es1;
       if es2 <> [] then op 0x05;
       list instr es2; end_ ()
+    | TryTable (bt, cs, es) ->
+      op 0x1f; block_type bt; vec catch cs; list instr es; end_ ()
 
     | Br x -> op 0x0c; var x
     | BrIf x -> op 0x0d; var x
@@ -267,6 +278,9 @@ struct
     | ReturnCallRef x -> op 0x15; var x
     | ReturnCallIndirect (x, y) -> op 0x13; var y; var x
 
+    | Throw x -> op 0x08; var x
+    | ThrowRef -> op 0x0a
+
     | Drop -> op 0x1a
     | Select None -> op 0x1b
     | Select (Some ts) -> op 0x1c; vec val_type ts
@@ -872,6 +886,13 @@ struct
     | VecReplace (V128 (F32x4 (V128Op.Replace i))) -> vecop 0x20l; byte i
     | VecReplace (V128 (F64x2 (V128Op.Replace i))) -> vecop 0x22l; byte i
 
+  and catch c =
+    match c.it with
+    | Catch (x1, x2) -> byte 0x00; var x1; var x2
+    | CatchRef (x1, x2) -> byte 0x01; var x1; var x2
+    | CatchAll x -> byte 0x02; var x
+    | CatchAllRef x -> byte 0x03; var x
+
   let const c =
     list instr c.it; end_ ()
 
@@ -904,6 +925,7 @@ struct
     | TableImport t -> byte 0x01; table_type t
     | MemoryImport t -> byte 0x02; memory_type t
     | GlobalImport t -> byte 0x03; global_type t
+    | TagImport t -> byte 0x04; tag_type t
 
   let import im =
     let {module_name; item_name; idesc} = im.it in
@@ -944,6 +966,14 @@ struct
     section 5 (vec memory) mems (mems <> [])
 
 
+  (* Tag section *)
+
+  let tag (t : tag) = byte 0x00; var t.it.tgtype
+
+  let tag_section ts =
+    section 13 (vec tag) ts (ts <> [])
+
+
   (* Global section *)
 
   let global g =
@@ -962,6 +992,7 @@ struct
     | TableExport x -> byte 1; var x
     | MemoryExport x -> byte 2; var x
     | GlobalExport x -> byte 3; var x
+    | TagExport x -> byte 4; var x
 
   let export ex =
     let {name = n; edesc} = ex.it in
@@ -1100,6 +1131,8 @@ struct
     table_section m.it.tables;
     let cs = iterate (custom_section (Before Memory)) cs in
     memory_section m.it.memories;
+    let cs = iterate (custom_section (Before Tag)) cs in
+    tag_section m.it.tags;
     let cs = iterate (custom_section (Before Global)) cs in
     global_section m.it.globals;
     let cs = iterate (custom_section (Before Export)) cs in
diff --git a/interpreter/custom/custom.ml b/interpreter/custom/custom.ml
index d54e27023b..0b6a058297 100644
--- a/interpreter/custom/custom.ml
+++ b/interpreter/custom/custom.ml
@@ -14,6 +14,7 @@ type section_kind =
   | DataCount
   | Code
   | Data
+  | Tag
 
 type place =
   | Before of section_kind
diff --git a/interpreter/custom/handler_branch_hint.ml b/interpreter/custom/handler_branch_hint.ml
new file mode 100644
index 0000000000..1f46d5de11
--- /dev/null
+++ b/interpreter/custom/handler_branch_hint.ml
@@ -0,0 +1,456 @@
+(* Handler for "metadata.code.branch_hint" section and @metadata.code.branch_hint annotations *)
+
+open Custom
+open Annot
+open Source
+open Ast
+module IdxMap = Map.Make (Int32)
+
+type kind = Likely | Unlikely
+
+type hint = hint' Source.phrase
+and hint' = kind * int
+
+type hints = hint list
+type func_hints = hints IdxMap.t
+
+type format = format' Source.phrase
+and format' = { func_hints : func_hints }
+
+let empty = { func_hints = IdxMap.empty }
+let name = Utf8.decode "metadata.code.branch_hint"
+let place _fmt = Before Code
+let is_contained r1 r2 = r1.left >= r2.left && r1.right <= r2.right
+
+let is_left r1 r2 =
+  r1.right.line < r2.left.line
+  || (r1.right.line == r2.left.line && r1.right.column <= r2.left.column)
+
+let starts_before r1 r2 =
+  r1.left.line < r2.left.line
+  || (r1.left.line == r2.left.line && r1.left.column < r2.left.column)
+
+let get_func m fidx =
+  let nimp = List.length m.it.imports in
+  let fn = Int32.to_int fidx - nimp in
+  List.nth m.it.funcs fn
+
+let flatten_instr_locs is =
+  let rec flatten is =
+    match is with
+    | [] -> []
+    | i :: rest ->
+        let group =
+          match i.it with
+          | Block (_, inner) -> [ i ] @ flatten inner
+          | Loop (_, inner) -> [ i ] @ flatten inner
+          | If (_, inner1, inner2) -> [ i ] @ flatten inner1 @ flatten inner2
+          | _ -> [ i ]
+        in
+        group @ flatten rest
+  in
+  let flat = flatten is in
+  let indexed = List.mapi (fun idx i -> (idx, i)) flat in
+  let sorter (_, i1) (_, i2) = if starts_before i1.at i2.at then -1 else 1 in
+  let sorted = List.sort sorter indexed in
+  sorted
+
+let get_inst_idx locs at =
+  let finder (i, l) = is_left at l.at in
+  let o = List.find_opt finder locs in
+  match o with Some (i, _) -> Some i | None -> None
+
+let get_nth_inst locs idx =
+  match List.find_opt (fun (i_idx, i) -> i_idx == idx) locs with
+  | Some (_, i) -> Some i
+  | None -> None
+
+(* Decoding *)
+
+(* TODO: make Decode module reusable instead of duplicating code *)
+
+type stream = { bytes : string; pos : int ref }
+
+exception EOS
+
+let stream bs = { bytes = bs; pos = ref 0 }
+let len s = String.length s.bytes
+let pos s = !(s.pos)
+let check n s = if pos s + n > len s then raise EOS
+
+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 get s =
+  check 1 s;
+  let b = read s in
+  skip 1 s;
+  b
+
+let position file pos = Source.{ file; line = -1; column = pos }
+
+let region file left right =
+  Source.{ left = position file left; right = position file right }
+
+let decode_error pos msg =
+  raise (Custom.Code (region "@metadata.code.branch_hint section" pos pos, msg))
+
+let require b pos msg = if not b then decode_error pos msg
+let decode_byte s = get s
+
+let rec decode_uN n s =
+  require (n > 0) (pos s) "integer representation too long";
+  let b = decode_byte s in
+  require (n >= 7 || b land 0x7f < 1 lsl n) (pos s - 1) "integer too large";
+  let x = Int32.of_int (b land 0x7f) in
+  if b land 0x80 = 0 then x
+  else Int32.(logor x (shift_left (decode_uN (n - 7) s) 7))
+
+let decode_u32 = decode_uN 32
+
+let decode_vec f s =
+  let n = decode_u32 s in
+  let n = Int32.to_int n in
+  let rec it i s = if i = 0 then [] else [ f s ] @ it (i - 1) s in
+  it n s
+
+let decode_hint locs foff s =
+  let off = decode_u32 s in
+  let one = decode_u32 s in
+  require (one = 1l) (pos s)
+    "@metadata.code.branch_hint section: missing reserved byte";
+  let k = decode_byte s in
+  let hint =
+    match k with
+    | 0x00 -> Unlikely
+    | 0x01 -> Likely
+    | _ ->
+        decode_error (pos s)
+          "@metadata.code.branch_hint section: invalid hint value"
+  in
+  let abs_off = Int32.to_int (Int32.add off foff) in
+  let at = region "" abs_off abs_off in
+  let idx =
+    match get_inst_idx locs at with
+    | Some i -> i
+    | None ->
+        decode_error (pos s)
+          "@metadata.code.branch_hint section: invalid offset"
+  in
+  (hint, idx) @@ at
+
+let decode_func_hints locs foff = decode_vec (decode_hint locs foff)
+
+let decode_func m s =
+  let fidx = decode_u32 s in
+  let f = get_func m fidx in
+  let foff = Int32.of_int f.at.left.column in
+  let locs = flatten_instr_locs f.it.body in
+  let hs = decode_func_hints locs foff s in
+  (fidx, List.rev hs)
+
+let decode_funcs m s =
+  let fs = decode_vec (decode_func m) s in
+  IdxMap.add_seq (List.to_seq fs) IdxMap.empty
+
+let decode m _ custom =
+  let s = stream custom.it.content in
+  try { func_hints = decode_funcs m s } @@ custom.at
+  with EOS -> decode_error (pos s) "unexpected end of name section"
+
+(* Encoding *)
+
+(* TODO: make Encode module reusable *)
+
+let encode_byte buf b = Buffer.add_char buf (Char.chr b)
+
+let rec encode_u32 buf i =
+  let b = Int32.(to_int (logand i 0x7fl)) in
+  if 0l <= i && i < 128l then encode_byte buf b
+  else (
+    encode_byte buf (b lor 0x80);
+    encode_u32 buf (Int32.shift_right_logical i 7))
+
+let encode_size buf n = encode_u32 buf (Int32.of_int n)
+
+let encode_vec buf f v =
+  encode_size buf (List.length v);
+  let rec it v =
+    match v with
+    | [] -> ()
+    | e :: es ->
+        f buf e;
+        it es
+  in
+  it v
+
+let encode_hint locs foff buf h =
+  let kind, idx = h.it in
+  let i =
+    match get_nth_inst locs idx with Some i -> i | None -> assert false
+  in
+  let off = i.at.left.column - foff in
+  encode_size buf off;
+  encode_u32 buf 1l;
+  let b = match kind with Unlikely -> 0l | Likely -> 1l in
+  encode_u32 buf b
+
+let encode_func_hints buf locs foff = encode_vec buf (encode_hint locs foff)
+
+let encode_func m buf t =
+  let fidx, hs = t in
+  encode_u32 buf fidx;
+  let f = get_func m fidx in
+  let foff = f.at.left.column in
+  let locs = flatten_instr_locs f.it.body in
+  encode_func_hints buf locs foff hs
+
+let encode_funcs buf m fhs =
+  encode_vec buf (encode_func m) (List.of_seq (IdxMap.to_seq fhs))
+
+let encode m bs sec =
+  let { func_hints } = sec.it in
+  let m2 = Decode.decode "" bs in
+  let buf = Buffer.create 200 in
+  encode_funcs buf m2 func_hints;
+  let content = Buffer.contents buf in
+  {
+    name = Utf8.decode "metadata.code.branch_hint";
+    content;
+    place = Before Code;
+  }
+  @@ sec.at
+
+(* Parsing *)
+
+open Ast
+
+let parse_error at msg = raise (Custom.Syntax (at, msg))
+
+let merge_func_hints =
+  IdxMap.merge (fun key x y ->
+      match (x, y) with
+      | Some a, None -> Some a
+      | None, Some b -> Some b
+      | Some a, Some [ ({ at = _; it = _, idx } as b) ] ->
+          let _, last_idx = (List.hd (List.rev a)).it in
+          if last_idx >= idx then
+            parse_error b.at
+              "@metadata.code.branch_hint annotation: duplicate annotation"
+          else Some (a @ [ b ])
+      | Some _, Some _ -> assert false
+      | None, None -> None)
+
+let merge s1 s2 =
+  { func_hints = merge_func_hints s1.it.func_hints s2.it.func_hints }
+  @@ { left = s1.at.left; right = s2.at.right }
+
+let find_func_idx m annot =
+  let idx =
+    Lib.List.index_where (fun f -> is_contained annot.at f.at) m.it.funcs
+  in
+  match idx with
+  | Some i -> Int32.of_int (i + List.length m.it.imports)
+  | None ->
+      parse_error annot.at
+        "@metadata.code.branch_hint annotation: not in a function"
+
+let rec parse m _bs annots =
+  let annots' = List.rev annots in
+  let ms = List.map (parse_annot m) annots' in
+  match ms with
+  | [] -> []
+  | m :: ms' -> [ List.fold_left merge (empty @@ m.at) ms ]
+
+and parse_annot m annot =
+  let { name = n; items } = annot.it in
+  assert (n = name);
+  let payload a =
+    match a.it with
+    | String s -> s
+    | _ ->
+        parse_error a.at
+          "@metadata.code.branch_hint annotation: unexpected token"
+  in
+  let fold_payload bs a = bs ^ payload a in
+  let p = List.fold_left fold_payload "" items in
+  let at_last = (List.hd (List.rev items)).at in
+  let fidx = find_func_idx m annot in
+  let f = get_func m fidx in
+  let locs = flatten_instr_locs f.it.body in
+  let hint =
+    match p with
+    | "\x00" -> Unlikely
+    | "\x01" -> Likely
+    | _ ->
+        parse_error annot.at
+          "@metadata.code.branch_hint annotation: invalid hint value"
+  in
+  let at = Source.{ left = annot.at.left; right = at_last.right } in
+  let hidx =
+    match get_inst_idx locs at with
+    | Some i -> i
+    | None ->
+        parse_error annot.at
+          "@metadata.code.branch_hint annotation: invalid placement"
+  in
+  let e =
+    { func_hints = IdxMap.add fidx [ (hint, hidx) @@ at ] IdxMap.empty }
+  in
+  e @@ at
+
+(* Arranging *)
+
+let hint_to_string = function Likely -> "\"\\01\"" | Unlikely -> "\"\\00\""
+
+let collect_one f hat =
+  let h, hidx = hat.it in
+  ( Int32.to_int f,
+    hidx,
+    Sexpr.Node ("@metadata.code.branch_hint ", [ Sexpr.Atom (hint_to_string h) ])
+  )
+
+let collect_func (f, hs) = List.map (collect_one f) hs
+let collect_funcs fhs = List.concat (List.map collect_func fhs)
+
+let string_starts_with s1 s2 =
+  let s2l = String.length s2 in
+  let s1l = String.length s1 in
+  let len = Stdlib.min s2l s1l in
+  let s1sub = String.sub s1 0 len in
+  String.equal s1sub s2
+
+let rec get_instrs n1 n2 =
+  match n2 with
+  | [] -> (n1, [])
+  | Sexpr.Atom s :: rest -> (n1 @ [ Sexpr.Atom s ], rest)
+  | Sexpr.Node (h, els) :: rest ->
+      if
+        string_starts_with h "type "
+        || String.equal h "local"
+        || string_starts_with h "result"
+      then get_instrs (n1 @ [ Sexpr.Node (h, els) ]) rest
+      else (n1, n2)
+
+let get_annot annots fidx idx h =
+  match !annots with
+  | [] -> []
+  | (a_fidx, a_hidx, a_node) :: rest ->
+      if a_fidx = fidx && a_hidx = idx then (
+        annots := rest;
+        [ a_node ])
+      else []
+
+let rec apply_instrs annots fidx curi is =
+  match is with
+  | [] -> []
+  | i :: rest ->
+      let idx = !curi in
+      curi := idx + 1;
+      let newn =
+        match i with
+        | Sexpr.Node (h, ns) ->
+            let annot = get_annot annots fidx idx h in
+            if string_starts_with h "block" || string_starts_with h "loop" then
+              let pre, inner = get_instrs [] ns in
+              annot
+              @ [ Sexpr.Node (h, pre @ apply_instrs annots fidx curi inner) ]
+            else if string_starts_with h "if" then
+              match ns with
+              | [ Sexpr.Node (hif, nif); Sexpr.Node (helse, nelse) ] ->
+                  let newif = apply_instrs annots fidx curi nif in
+                  let newelse = apply_instrs annots fidx curi nelse in
+                  annot
+                  @ [
+                      Sexpr.Node
+                        ( h,
+                          [
+                            Sexpr.Node (hif, newif); Sexpr.Node (helse, newelse);
+                          ] );
+                    ]
+              | [
+               Sexpr.Node ("result", res);
+               Sexpr.Node (hif, nif);
+               Sexpr.Node (helse, nelse);
+              ] ->
+                  let newif = apply_instrs annots fidx curi nif in
+                  let newelse = apply_instrs annots fidx curi nelse in
+                  annot
+                  @ [
+                      Sexpr.Node
+                        ( h,
+                          [
+                            Sexpr.Node ("result", res);
+                            Sexpr.Node (hif, newif);
+                            Sexpr.Node (helse, newelse);
+                          ] );
+                    ]
+              | _ -> assert false
+            else annot @ [ Sexpr.Node (h, ns) ]
+        | Sexpr.Atom s -> [ Sexpr.Atom s ]
+      in
+      newn @ apply_instrs annots fidx curi rest
+
+let apply_func nodes annots fidx =
+  let curi = ref 0 in
+  let pre, instrs = get_instrs [] nodes in
+  let new_instrs = apply_instrs annots fidx curi instrs in
+  pre @ new_instrs
+
+let apply_secs annots curf node =
+  match node with
+  | Sexpr.Atom a -> Sexpr.Atom a
+  | Sexpr.Node (head, rest) ->
+      if string_starts_with head "func" then (
+        let ret = apply_func rest annots !curf in
+        curf := !curf + 1;
+        Sexpr.Node (head, ret))
+      else Sexpr.Node (head, rest)
+
+let apply mnode annots curf =
+  match mnode with
+  | Sexpr.Atom a -> Sexpr.Atom a
+  | Sexpr.Node (h, secs) ->
+      Sexpr.Node (h, List.map (apply_secs annots curf) secs)
+
+let arrange m mnode fmt =
+  let annots =
+    ref (collect_funcs (List.of_seq (IdxMap.to_seq fmt.it.func_hints)))
+  in
+  let curf = ref 0 in
+  let ret = apply mnode annots curf in
+  ret
+
+(* Checking *)
+
+let check_error at msg = raise (Custom.Invalid (at, msg))
+
+let check_one locs prev_hidx h =
+  let kind, idx = h.it in
+  match get_nth_inst locs idx with
+  | None -> assert false
+  | Some i -> (
+      match i.it with
+      | If _ | BrIf _ ->
+          if !prev_hidx >= idx then
+            check_error h.at
+              "@metadata.code.branch_hint annotation: invalid order"
+          else (
+            prev_hidx := idx;
+            ())
+      | _ ->
+          check_error h.at
+            "@metadata.code.branch_hint annotation: invalid target")
+
+let check_fun m fidx hs =
+  let f = get_func m fidx in
+  let locs = flatten_instr_locs f.it.body in
+  let prev_hidx = ref 0 in
+  List.iter (check_one locs prev_hidx) hs
+
+let check (m : module_) (fmt : format) =
+  IdxMap.iter (check_fun m) fmt.it.func_hints;
+  ()
diff --git a/interpreter/custom/handler_custom.ml b/interpreter/custom/handler_custom.ml
index 3a1d8054f8..bcc6457ffa 100644
--- a/interpreter/custom/handler_custom.ml
+++ b/interpreter/custom/handler_custom.ml
@@ -51,13 +51,14 @@ and parse_annot m annot =
   let place, items'' = parse_place_opt items' in
   let content, items''' = parse_content items'' in
   parse_end items''';
-  let Ast.{types; globals; tables; memories; funcs; start;
+  let Ast.{types; tags; globals; tables; memories; funcs; start;
     elems; datas; imports; exports} = m.it in
   let outside x =
     if annot.at.left >= x.at.left && annot.at.right <= x.at.right then
       parse_error annot.at "misplaced @custom annotation"
   in
   List.iter outside types;
+  List.iter outside tags;
   List.iter outside globals;
   List.iter outside tables;
   List.iter outside memories;
@@ -96,6 +97,7 @@ and parse_direction at = function
 
 and parse_section at = function
   | {it = Atom "type"; _} :: items -> Type, items
+  | {it = Atom "tag"; _} :: items -> Tag, items
   | {it = Atom "import"; _} :: items -> Import, items
   | {it = Atom "func"; _} :: items -> Func, items
   | {it = Atom "table"; _} :: items -> Table, items
@@ -144,6 +146,7 @@ and arrange_place = function
 and arrange_sec = function
   | Custom -> assert false
   | Type -> "type"
+  | Tag -> "tag"
   | Import -> "import"
   | Func -> "func"
   | Table -> "table"
diff --git a/interpreter/custom/handler_name.ml b/interpreter/custom/handler_name.ml
index b75486f6db..dde5e28d79 100644
--- a/interpreter/custom/handler_name.ml
+++ b/interpreter/custom/handler_name.ml
@@ -18,6 +18,7 @@ and format' =
   locals : indirect_name_map;
   types : name_map;
   fields : indirect_name_map;
+  tags : name_map;
 }
 
 
@@ -28,6 +29,7 @@ let empty =
   locals = IdxMap.empty;
   types = IdxMap.empty;
   fields = IdxMap.empty;
+  tags = IdxMap.empty;
 }
 
 let name = Utf8.decode "name"
@@ -128,6 +130,7 @@ let decode_funcs s = decode_name_map s
 let decode_locals s = decode_indirect_name_map s
 let decode_types s = decode_name_map s
 let decode_fields s = decode_indirect_name_map s
+let decode_tags s = decode_name_map s
 
 let decode_subsec id f default s =
   match peek s with
@@ -144,13 +147,14 @@ let decode_subsec id f default s =
 let decode _m _bs custom =
   let s = stream custom.it.content in
   try
-    let module_ = decode_subsec 0x00 decode_module None s in
-    let funcs = decode_subsec 0x01 decode_funcs IdxMap.empty s in
-    let locals = decode_subsec 0x02 decode_locals IdxMap.empty s in
-    let types = decode_subsec 0x04 decode_types IdxMap.empty s in
-    let fields = decode_subsec 0x0a decode_fields IdxMap.empty s in
+    let module_ = decode_subsec 0 decode_module None s in
+    let funcs = decode_subsec 1 decode_funcs IdxMap.empty s in
+    let locals = decode_subsec 2 decode_locals IdxMap.empty s in
+    let types = decode_subsec 4 decode_types IdxMap.empty s in
+    let fields = decode_subsec 10 decode_fields IdxMap.empty s in
+    let tags = decode_subsec 11 decode_tags IdxMap.empty s in
     require (eos s) (pos s) "invalid name subsection id";
-    {module_; funcs; locals; types; fields} @@ custom.at
+    {module_; funcs; locals; types; fields; tags} @@ custom.at
   with EOS -> decode_error (pos s) "unexpected end of name section"
 
 
@@ -210,46 +214,54 @@ let encode_module buf name_opt =
   match name_opt with
   | None -> ()
   | Some name ->
-    let subsec = encode_subsec_begin buf 0x00 in
+    let subsec = encode_subsec_begin buf 0 in
     encode_name buf name.it;
     encode_subsec_end buf subsec
 
 let encode_funcs buf name_map =
   if not (IdxMap.is_empty name_map) then begin
-    let subsec = encode_subsec_begin buf 0x01 in
+    let subsec = encode_subsec_begin buf 1 in
     encode_name_map buf name_map;
     encode_subsec_end buf subsec
   end
 
 let encode_locals buf name_map_map =
   if not (IdxMap.is_empty name_map_map) then begin
-    let subsec = encode_subsec_begin buf 0x02 in
+    let subsec = encode_subsec_begin buf 2 in
     encode_indirect_name_map buf name_map_map;
     encode_subsec_end buf subsec
   end
 
 let encode_types buf name_map =
   if not (IdxMap.is_empty name_map) then begin
-    let subsec = encode_subsec_begin buf 0x04 in
+    let subsec = encode_subsec_begin buf 4 in
     encode_name_map buf name_map;
     encode_subsec_end buf subsec
   end
 
 let encode_fields buf name_map_map =
   if not (IdxMap.is_empty name_map_map) then begin
-    let subsec = encode_subsec_begin buf 0x0a in
+    let subsec = encode_subsec_begin buf 10 in
     encode_indirect_name_map buf name_map_map;
     encode_subsec_end buf subsec
   end
 
+let encode_tags buf name_map =
+  if not (IdxMap.is_empty name_map) then begin
+    let subsec = encode_subsec_begin buf 11 in
+    encode_name_map buf name_map;
+    encode_subsec_end buf subsec
+  end
+
 let encode _m _bs sec =
-  let {module_; funcs; locals; types; fields} = sec.it in
+  let {module_; funcs; locals; types; fields; tags} = sec.it in
   let buf = Buffer.create 200 in
   encode_module buf module_;
   encode_funcs buf funcs;
   encode_locals buf locals;
   encode_types buf types;
   encode_fields buf fields;
+  encode_tags buf tags;
   let content = Buffer.contents buf in
   {name = Utf8.decode "name"; content; place = After last} @@ sec.at
 
@@ -290,6 +302,7 @@ let merge s1 s2 =
     locals = merge_indirect_name_map s1.it.locals s2.it.locals;
     types = merge_name_map s1.it.types s2.it.types;
     fields = merge_indirect_name_map s1.it.fields s2.it.fields;
+    tags = merge_name_map s1.it.tags s2.it.tags;
   } @@ {left = s1.at.left; right = s2.at.right}
 
 
@@ -305,6 +318,12 @@ let locate_func bs x name at (f : func) =
   else
     parse_error at "@name annotation: misplaced annotation"
 
+let locate_tag bs x name at (tag : tag) =
+  if is_left at tag.it.tgtype.at then
+    {empty with tags = IdxMap.singleton x name}
+  else
+    parse_error at "@name annotation: misplaced annotation"
+
 let locate_type bs x name at (ty : type_) =
   (* TODO re-parse types from bs *)
   parse_error at "@name annotation: type and field names not yet supported"
@@ -312,10 +331,11 @@ let locate_type bs x name at (ty : type_) =
 let locate_module bs name at (m : module_) =
   if not (is_contained at m.at) then
     parse_error at "misplaced @name annotation";
-  let {types; globals; tables; memories; funcs; start;
+  let {types; tags; globals; tables; memories; funcs; start;
     elems; datas; imports; exports} = m.it in
   let ats =
     List.map (fun p -> p.at) types @
+    List.map (fun p -> p.at) tags @
     List.map (fun p -> p.at) globals @
     List.map (fun p -> p.at) tables @
     List.map (fun p -> p.at) memories @
@@ -330,9 +350,12 @@ let locate_module bs name at (m : module_) =
   | [] -> {empty with module_ = Some name}
   | at1::_ when is_left at at1 -> {empty with module_ = Some name}
   | _ ->
-    match Lib.List.index_where (fun f -> is_contained at f.at) types with
+    match Lib.List.index_where (fun t -> is_contained at t.at) types with
     | Some x -> locate_type bs (Int32.of_int x) name at (List.nth types x)
     | None ->
+    match Lib.List.index_where (fun t -> is_contained at t.at) tags with
+    | Some x -> locate_tag bs (Int32.of_int x) name at (List.nth tags x)
+    | None ->
     match Lib.List.index_where (fun f -> is_contained at f.at) funcs with
     | Some x -> locate_func bs (Int32.of_int x) name at (List.nth funcs x)
     | None -> parse_error at "misplaced @name annotation"
diff --git a/interpreter/exec/eval.ml b/interpreter/exec/eval.ml
index 02e4c348d0..b04cb5db2a 100644
--- a/interpreter/exec/eval.ml
+++ b/interpreter/exec/eval.ml
@@ -9,11 +9,13 @@ open Instance
 (* Errors *)
 
 module Link = Error.Make ()
+module Exception = Error.Make ()
 module Trap = Error.Make ()
 module Crash = Error.Make ()
 module Exhaustion = Error.Make ()
 
 exception Link = Link.Error
+exception Exception = Exception.Error
 exception Trap = Trap.Error
 exception Crash = Crash.Error (* failure that cannot happen in valid code *)
 exception Exhaustion = Exhaustion.Error
@@ -60,12 +62,14 @@ and admin_instr' =
   | Plain of instr'
   | Refer of ref_
   | Invoke of func_inst
-  | Trapping of string
+  | Breaking of int32 * value stack
   | Returning of value stack
   | ReturningInvoke of value stack * func_inst
-  | Breaking of int32 * value stack
+  | Throwing of Tag.t * value stack
+  | Trapping of string
   | Label of int * instr list * code
   | Frame of int * frame * code
+  | Handler of int * catch list * code
 
 type config =
 {
@@ -88,7 +92,8 @@ let admin_instr_of_value (v : value) at : admin_instr' =
 
 let is_jumping e =
   match e.it with
-  | Trapping _ | Returning _ | ReturningInvoke _ | Breaking _ -> true
+  | Returning _ | ReturningInvoke _ | Breaking _
+  | Throwing _ | Trapping _ -> true
   | _ -> false
 
 let lookup category list x =
@@ -99,6 +104,7 @@ 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 tag (inst : module_inst) x = lookup "tag" inst.tags x
 let global (inst : module_inst) x = lookup "global" inst.globals x
 let elem (inst : module_inst) x = lookup "element segment" inst.elems x
 let data (inst : module_inst) x = lookup "data segment" inst.datas x
@@ -171,6 +177,7 @@ let array_oob a i n =
   I64.gt_u (I64.add (I64_convert.extend_i32_u i) (I64_convert.extend_i32_u n))
     (I64_convert.extend_i32_u (Aggr.array_length a))
 
+
 let rec step (c : config) : config =
   let vs, es = c.code in
   let e = List.hd es in
@@ -265,6 +272,12 @@ let rec step (c : config) : config =
             string_of_def_type (type_ c.frame.inst y) ^ " but got " ^
             string_of_def_type (Func.type_of f)) @@ e.at]
 
+      | ReturnCall x, vs ->
+        (match (step {c with code = (vs, [Plain (Call x) @@ e.at])}).code with
+        | vs', [{it = Invoke a; at}] -> vs', [ReturningInvoke (vs', a) @@ at]
+        | _ -> assert false
+        )
+
       | ReturnCallRef _x, Ref (NullRef _) :: vs ->
         vs, [Trapping "null function reference" @@ e.at]
 
@@ -275,12 +288,6 @@ let rec step (c : config) : config =
         | _ -> assert false
         )
 
-      | ReturnCall x, vs ->
-        (match (step {c with code = (vs, [Plain (Call x) @@ e.at])}).code with
-        | vs', [{it = Invoke a; at}] -> vs', [ReturningInvoke (vs', a) @@ at]
-        | _ -> assert false
-        )
-
       | ReturnCallIndirect (x, y), vs ->
         (match
           (step {c with code = (vs, [Plain (CallIndirect (x, y)) @@ e.at])}).code
@@ -290,6 +297,27 @@ let rec step (c : config) : config =
         | _ -> assert false
         )
 
+      | Throw x, vs ->
+        let t = tag c.frame.inst x in
+        let TagT dt = Tag.type_of t in
+        let FuncT (ts, _) = as_func_str_type (expand_def_type dt) in
+        let n = List.length ts in
+        let args, vs' = split n vs e.at in
+        vs', [Throwing (t, args) @@ e.at]
+
+      | ThrowRef, Ref (NullRef _) :: vs ->
+        vs, [Trapping "null exception reference" @@ e.at]
+
+      | ThrowRef, Ref (Exn.(ExnRef (Exn (t, args)))) :: vs ->
+        vs, [Throwing (t, args) @@ e.at]
+
+      | TryTable (bt, cs, es'), vs ->
+        let InstrT (ts1, ts2, _xs) = block_type c.frame.inst bt e.at in
+        let n1 = List.length ts1 in
+        let n2 = List.length ts2 in
+        let args, vs' = split n1 vs e.at in
+        vs', [Handler (n2, cs, ([], [Label (n2, [], (args, List.map plain es')) @@ e.at])) @@ e.at]
+
       | Drop, v :: vs' ->
         vs', []
 
@@ -980,6 +1008,9 @@ let rec step (c : config) : config =
     | Breaking _, vs ->
       Crash.error e.at "undefined label"
 
+    | Throwing _, _ ->
+      assert false
+
     | Label (n, es0, (vs', [])), vs ->
       vs' @ vs, []
 
@@ -999,9 +1030,6 @@ let rec step (c : config) : config =
     | Frame (n, frame', (vs', [])), vs ->
       vs' @ vs, []
 
-    | 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, []
 
@@ -1009,10 +1037,44 @@ let rec step (c : config) : config =
       let FuncT (ts1, _ts2) = as_func_str_type (expand_def_type (Func.type_of f)) in
       take (List.length ts1) vs0 e.at @ vs, [Invoke f @@ at]
 
+    | Frame (n, frame', (vs', e' :: es')), vs when is_jumping e' ->
+      vs, [e']
+
     | Frame (n, frame', code'), vs ->
       let c' = step {frame = frame'; code = code'; budget = c.budget - 1} in
       vs, [Frame (n, frame', c'.code) @@ e.at]
 
+    | Handler (n, cs, (vs', [])), vs ->
+      vs' @ vs, []
+
+    | Handler (n, {it = Catch (x1, x2); _} :: cs, (vs', {it = Throwing (a, vs0); at} :: es')), vs ->
+      if a == tag c.frame.inst x1 then
+        vs0 @ vs, [Plain (Br x2) @@ e.at]
+      else
+        vs, [Handler (n, cs, (vs', {it = Throwing (a, vs0); at} :: es')) @@ e.at]
+
+    | Handler (n, {it = CatchRef (x1, x2); _} :: cs, (vs', {it = Throwing (a, vs0); at} :: es')), vs ->
+      if a == tag c.frame.inst x1 then
+        Ref Exn.(ExnRef (Exn (a, vs0))) :: vs0 @ vs, [Plain (Br x2) @@ e.at]
+      else
+        vs, [Handler (n, cs, (vs', {it = Throwing (a, vs0); at} :: es')) @@ e.at]
+
+    | Handler (n, {it = CatchAll x; _} :: cs, (vs', {it = Throwing (a, vs0); at} :: es')), vs ->
+      vs, [Plain (Br x) @@ e.at]
+
+    | Handler (n, {it = CatchAllRef x; _} :: cs, (vs', {it = Throwing (a, vs0); at} :: es')), vs ->
+      Ref Exn.(ExnRef (Exn (a, vs0))) :: vs, [Plain (Br x) @@ e.at]
+
+    | Handler (n, [], (vs', {it = Throwing (a, vs0); at} :: es')), vs ->
+      vs, [Throwing (a, vs0) @@ at]
+
+    | Handler (n, cs, (vs', e' :: es')), vs when is_jumping e' ->
+      vs, [e']
+
+    | Handler (n, cs, code'), vs ->
+      let c' = step {c with code = code'} in
+      vs, [Handler (n, cs, c'.code) @@ e.at]
+
     | Invoke f, vs when c.budget = 0 ->
       Exhaustion.error e.at "call stack exhausted"
 
@@ -1046,6 +1108,10 @@ let rec eval (c : config) : value stack =
   | vs, {it = Trapping msg; at} :: _ ->
     Trap.error at msg
 
+  | vs, {it = Throwing (a, args); at} :: _ ->
+    let msg = "uncaught exception with args (" ^ string_of_values args ^ ")" in
+    Exception.error at msg
+
   | vs, es ->
     eval (step c)
 
@@ -1089,6 +1155,7 @@ let init_import (inst : module_inst) (ex : extern) (im : import) : module_inst =
     | TableImport tt -> ExternTableT tt
     | MemoryImport mt -> ExternMemoryT mt
     | GlobalImport gt -> ExternGlobalT gt
+    | TagImport x -> ExternTagT (TagT (type_ inst x))
   in
   let et = subst_extern_type (subst_of inst) it in
   let et' = extern_type_of inst.types ex in
@@ -1103,11 +1170,16 @@ let init_import (inst : module_inst) (ex : extern) (im : import) : module_inst =
   | ExternTable tab -> {inst with tables = inst.tables @ [tab]}
   | ExternMemory mem -> {inst with memories = inst.memories @ [mem]}
   | ExternGlobal glob -> {inst with globals = inst.globals @ [glob]}
+  | ExternTag tag -> {inst with tags = inst.tags @ [tag]}
 
 let init_func (inst : module_inst) (f : func) : module_inst =
   let func = Func.alloc (type_ inst f.it.ftype) (Lib.Promise.make ()) f in
   {inst with funcs = inst.funcs @ [func]}
 
+let init_tag (inst : module_inst) (t : tag) : module_inst =
+  let tag = Tag.alloc (TagT (type_ inst t.it.tgtype)) in
+  {inst with tags = inst.tags @ [tag]}
+
 let init_global (inst : module_inst) (glob : global) : module_inst =
   let {gtype; ginit} = glob.it in
   let gt = subst_global_type (subst_of inst) gtype in
@@ -1150,6 +1222,7 @@ let init_export (inst : module_inst) (ex : export) : module_inst =
     | TableExport x -> ExternTable (table inst x)
     | MemoryExport x -> ExternMemory (memory inst x)
     | GlobalExport x -> ExternGlobal (global inst x)
+    | TagExport x -> ExternTag (tag inst x)
   in
   {inst with exports = inst.exports @ [(name, ext)]}
 
@@ -1210,6 +1283,7 @@ let init (m : module_) (exts : extern list) : module_inst =
     |> init_list init_global m.it.globals
     |> init_list init_table m.it.tables
     |> init_list init_memory m.it.memories
+    |> init_list init_tag m.it.tags
     |> init_list init_elem m.it.elems
     |> init_list init_data m.it.datas
     |> init_list init_export m.it.exports
diff --git a/interpreter/exec/eval.mli b/interpreter/exec/eval.mli
index 056fc05fec..196f8997ef 100644
--- a/interpreter/exec/eval.mli
+++ b/interpreter/exec/eval.mli
@@ -3,6 +3,7 @@ open Instance
 
 exception Link of Source.region * string
 exception Trap of Source.region * string
+exception Exception of Source.region * string
 exception Crash of Source.region * string
 exception Exhaustion of Source.region * string
 
diff --git a/interpreter/main/main.ml b/interpreter/main/main.ml
index f35a6735f0..fc8a43f059 100644
--- a/interpreter/main/main.ml
+++ b/interpreter/main/main.ml
@@ -4,6 +4,7 @@ let version = "3.0.0"
 let all_handlers = [
   (module Handler_custom : Custom.Handler);
   (module Handler_name : Custom.Handler);
+  (module Handler_branch_hint : Custom.Handler);
 ]
 
 let configure custom_handlers =
diff --git a/interpreter/runtime/exn.ml b/interpreter/runtime/exn.ml
new file mode 100644
index 0000000000..d4009372e2
--- /dev/null
+++ b/interpreter/runtime/exn.ml
@@ -0,0 +1,38 @@
+open Types
+open Value
+
+type exn_ = Exn of Tag.t * value list
+
+type ref_ += ExnRef of exn_
+
+let alloc_exn tag vs =
+  let TagT dt = Tag.type_of tag in
+  assert Free.((def_type dt).types = Set.empty);
+  let FuncT (ts1, ts2) = as_func_str_type (expand_def_type dt) in
+  assert (List.length vs = List.length ts1);
+  assert (ts2 = []);
+  Exn (tag, vs)
+
+let type_of (Exn (tag, _)) =
+  let TagT dt = Tag.type_of tag in
+  dt
+
+let () =
+  let eq_ref' = !Value.eq_ref' in
+  Value.eq_ref' := fun r1 r2 ->
+    match r1, r2 with
+    | ExnRef _, ExnRef _ -> failwith "eq_ref"
+    | _, _ -> eq_ref' r1 r2
+
+let () =
+  let type_of_ref' = !Value.type_of_ref' in
+  Value.type_of_ref' := function
+    | ExnRef e -> DefHT (type_of e)
+    | r -> type_of_ref' r
+
+let () =
+  let string_of_ref' = !Value.string_of_ref' in
+  Value.string_of_ref' := function
+    | ExnRef (Exn (_tag, vs)) ->
+      "(tag " ^ String.concat " " (List.map string_of_value vs) ^ ")"
+    | r -> string_of_ref' r
diff --git a/interpreter/runtime/exn.mli b/interpreter/runtime/exn.mli
new file mode 100644
index 0000000000..13b0340267
--- /dev/null
+++ b/interpreter/runtime/exn.mli
@@ -0,0 +1,10 @@
+open Types
+open Value
+
+type exn_ = Exn of Tag.t * value list
+
+type ref_ += ExnRef of exn_
+
+val alloc_exn : Tag.t -> value list -> exn_
+
+val type_of : exn_ -> def_type
diff --git a/interpreter/runtime/instance.ml b/interpreter/runtime/instance.ml
index 677f91fcd6..4b211c939f 100644
--- a/interpreter/runtime/instance.ml
+++ b/interpreter/runtime/instance.ml
@@ -7,6 +7,7 @@ type module_inst =
   tables : table_inst list;
   memories : memory_inst list;
   globals : global_inst list;
+  tags : tag_inst list;
   elems : elem_inst list;
   datas : data_inst list;
   exports : export_inst list;
@@ -17,6 +18,7 @@ and func_inst = module_inst Lib.Promise.t Func.t
 and table_inst = Table.t
 and memory_inst = Memory.t
 and global_inst = Global.t
+and tag_inst = Tag.t
 and elem_inst = Elem.t
 and data_inst = Data.t
 and export_inst = Ast.name * extern
@@ -26,6 +28,7 @@ and extern =
   | ExternTable of table_inst
   | ExternMemory of memory_inst
   | ExternGlobal of global_inst
+  | ExternTag of tag_inst
 
 
 (* Reference types *)
@@ -51,33 +54,28 @@ let () =
     | FuncRef _ -> "func"
     | r -> string_of_ref' r
 
-let () =
-  let eq_ref' = !Value.eq_ref' in
-  Value.eq_ref' := fun r1 r2 ->
-    match r1, r2 with
-    | FuncRef f1, FuncRef f2 -> f1 == f2
-    | _, _ -> eq_ref' r1 r2
-
 
 (* Projections *)
 
 let func_inst_of_extern = function ExternFunc f -> f | _ -> failwith "func_inst_of_extern"
-let table_inst_of_extern = function ExternTable f -> f | _ -> failwith "table_inst_of_extern"
-let memory_inst_of_extern = function ExternMemory f -> f | _ -> failwith "memory_inst_of_extern"
-let global_inst_of_extern = function ExternGlobal f -> f | _ -> failwith "global_inst_of_extern"
+let table_inst_of_extern = function ExternTable t -> t | _ -> failwith "table_inst_of_extern"
+let memory_inst_of_extern = function ExternMemory m -> m | _ -> failwith "memory_inst_of_extern"
+let global_inst_of_extern = function ExternGlobal g -> g | _ -> failwith "global_inst_of_extern"
+let tag_inst_of_extern = function ExternTag t -> t | _ -> failwith "tag_inst_of_extern"
 
 
 (* Auxiliary functions *)
 
 let empty_module_inst =
   { types = []; funcs = []; tables = []; memories = []; globals = [];
-    elems = []; datas = []; exports = [] }
+    tags = []; elems = []; datas = []; exports = [] }
 
 let extern_type_of c = function
   | ExternFunc func -> ExternFuncT (Func.type_of func)
   | ExternTable tab -> ExternTableT (Table.type_of tab)
   | ExternMemory mem -> ExternMemoryT (Memory.type_of mem)
   | ExternGlobal glob -> ExternGlobalT (Global.type_of glob)
+  | ExternTag tag -> ExternTagT (Tag.type_of tag)
 
 let export inst name =
   try Some (List.assoc name inst.exports) with Not_found -> None
diff --git a/interpreter/runtime/tag.ml b/interpreter/runtime/tag.ml
new file mode 100644
index 0000000000..3e0b9e499f
--- /dev/null
+++ b/interpreter/runtime/tag.ml
@@ -0,0 +1,10 @@
+open Types
+
+type tag = {ty : tag_type}
+type t = tag
+
+let alloc ty =
+   {ty}
+
+let type_of tg =
+  tg.ty
diff --git a/interpreter/runtime/tag.mli b/interpreter/runtime/tag.mli
new file mode 100644
index 0000000000..c4730e2993
--- /dev/null
+++ b/interpreter/runtime/tag.mli
@@ -0,0 +1,7 @@
+open Types
+
+type tag
+type t = tag
+
+val alloc : tag_type -> tag
+val type_of : tag -> tag_type
diff --git a/interpreter/runtime/value.ml b/interpreter/runtime/value.ml
index a9f162b220..a24fbaf281 100644
--- a/interpreter/runtime/value.ml
+++ b/interpreter/runtime/value.ml
@@ -13,11 +13,12 @@ type num = (I32.t, I64.t, F32.t, F64.t) op
 type vec = (V128.t) vecop
 
 type ref_ = ..
-type ref_ += NullRef of heap_type
 
 type value = Num of num | Vec of vec | Ref of ref_
 type t = value
 
+type ref_ += NullRef of heap_type
+
 
 (* Injection & projection *)
 
@@ -298,8 +299,10 @@ let string_of_vec = function
 let hex_string_of_vec = function
   | V128 v -> V128.to_hex_string v
 
-let string_of_ref' = ref (function NullRef t -> "null" | _ -> "ref")
-let string_of_ref r = !string_of_ref' r
+let string_of_ref' = ref (function _ -> "ref")
+let string_of_ref = function
+  | NullRef _ -> "null"
+  | r -> !string_of_ref' r
 
 let string_of_value = function
   | Num n -> string_of_num n
diff --git a/interpreter/script/js.ml b/interpreter/script/js.ml
index 1a853ed3d3..0a4a605370 100644
--- a/interpreter/script/js.ml
+++ b/interpreter/script/js.ml
@@ -134,6 +134,11 @@ function assert_trap(action) {
   throw new Error("Wasm trap expected");
 }
 
+function assert_exception(action) {
+  try { action() } catch (e) { return; }
+  throw new Error("exception expected");
+}
+
 let StackOverflow;
 try { (function f() { 1 + f() })() } catch (e) { StackOverflow = e.constructor }
 
@@ -398,7 +403,7 @@ let assert_return ress ts at =
         BrIf (0l @@ at) @@ at ]
     | RefResult (RefPat _) ->
       assert false
-    | RefResult (RefTypePat ExternHT) ->
+    | RefResult (RefTypePat (ExnHT | ExternHT)) ->
       [ BrOnNull (0l @@ at) @@ at ]
     | RefResult (RefTypePat t) ->
       [ RefTest (NoNull, t) @@ at;
@@ -458,6 +463,7 @@ let is_js_vec_type = function
   | _ -> false
 
 let is_js_ref_type = function
+  | (_, ExnHT) -> false
   | _ -> true
 
 let is_js_val_type = function
@@ -629,6 +635,8 @@ let of_assertion mods ass =
     of_assertion' mods act "assert_trap" [] None
   | AssertExhaustion (act, _) ->
     of_assertion' mods act "assert_exhaustion" [] None
+  | AssertException act ->
+    of_assertion' mods act "assert_exception" [] None
 
 let of_command mods cmd =
   "\n// " ^ Filename.basename cmd.at.left.file ^
diff --git a/interpreter/script/run.ml b/interpreter/script/run.ml
index d389e0d212..f4b0b80ff0 100644
--- a/interpreter/script/run.ml
+++ b/interpreter/script/run.ml
@@ -115,6 +115,7 @@ let input_from get_script run =
   | Eval.Trap (at, msg) -> error at "runtime trap" msg
   | Eval.Exhaustion (at, msg) -> error at "resource exhaustion" msg
   | Eval.Crash (at, msg) -> error at "runtime crash" msg
+  | Eval.Exception (at, msg) -> error at "uncaught exception" msg
   | Encode.Code (at, msg) -> error at "encoding error" msg
   | Script.Error (at, msg) -> error at "script error" msg
   | IO (at, msg) -> error at "i/o error" msg
@@ -400,6 +401,7 @@ let assert_ref_pat r p =
   | RefTypePat Types.StructHT, Aggr.StructRef _
   | RefTypePat Types.ArrayHT, Aggr.ArrayRef _ -> true
   | RefTypePat Types.FuncHT, Instance.FuncRef _
+  | RefTypePat Types.ExnHT, Exn.ExnRef _
   | RefTypePat Types.ExternHT, _ -> true
   | NullPat, Value.NullRef _ -> true
   | _ -> false
@@ -503,6 +505,13 @@ let run_assertion ass =
     let vs = run_action act in
     assert_result ass.at vs rs
 
+  | AssertException act ->
+    trace ("Asserting exception...");
+    (match run_action act with
+    | exception Eval.Exception (_, msg) -> ()
+    | _ -> Assert.error ass.at "expected exception"
+    )
+
   | AssertTrap (act, re) ->
     trace ("Asserting trap...");
     (match run_action act with
diff --git a/interpreter/script/script.ml b/interpreter/script/script.ml
index 43fa651eb4..df4b74af0d 100644
--- a/interpreter/script/script.ml
+++ b/interpreter/script/script.ml
@@ -47,6 +47,7 @@ and assertion' =
   | AssertUnlinkable of definition * string
   | AssertUninstantiable of definition * string
   | AssertReturn of action * result list
+  | AssertException of action
   | AssertTrap of action * string
   | AssertExhaustion of action * string
 
diff --git a/interpreter/syntax/ast.ml b/interpreter/syntax/ast.ml
index dc7a10acbb..5d5ac6dc6c 100644
--- a/interpreter/syntax/ast.ml
+++ b/interpreter/syntax/ast.ml
@@ -163,6 +163,9 @@ and instr' =
   | ReturnCall of idx                 (* tail-call function *)
   | ReturnCallRef of idx              (* tail call through reference *)
   | ReturnCallIndirect of idx * idx   (* tail-call function through table *)
+  | Throw of idx                      (* throw exception *)
+  | ThrowRef                          (* rethrow exception *)
+  | TryTable of block_type * catch list * instr list  (* handle exceptions *)
   | LocalGet of idx                   (* read local idxiable *)
   | LocalSet of idx                   (* write local idxiable *)
   | LocalTee of idx                   (* write local idxiable and keep value *)
@@ -234,6 +237,13 @@ and instr' =
   | VecExtract of vec_extractop       (* extract lane from vector *)
   | VecReplace of vec_replaceop       (* replace lane in vector *)
 
+and catch = catch' Source.phrase
+and catch' =
+  | Catch of idx * idx
+  | CatchRef of idx * idx
+  | CatchAll of idx
+  | CatchAllRef of idx
+
 
 (* Locals, globals & Functions *)
 
@@ -276,6 +286,13 @@ and memory' =
   mtype : memory_type;
 }
 
+type tag = tag' Source.phrase
+and tag' =
+{
+  tgtype : idx;
+}
+
+
 type segment_mode = segment_mode' Source.phrase
 and segment_mode' =
   | Passive
@@ -308,6 +325,7 @@ and export_desc' =
   | TableExport of idx
   | MemoryExport of idx
   | GlobalExport of idx
+  | TagExport of idx
 
 type export = export' Source.phrase
 and export' =
@@ -322,6 +340,7 @@ and import_desc' =
   | TableImport of table_type
   | MemoryImport of memory_type
   | GlobalImport of global_type
+  | TagImport of idx
 
 type import = import' Source.phrase
 and import' =
@@ -344,6 +363,7 @@ and module_' =
   globals : global list;
   tables : table list;
   memories : memory list;
+  tags : tag list;
   funcs : func list;
   start : start option;
   elems : elem_segment list;
@@ -361,6 +381,7 @@ let empty_module =
   globals = [];
   tables = [];
   memories = [];
+  tags = [];
   funcs = [];
   start = None;
   elems = [];
@@ -387,6 +408,7 @@ let import_type_of (m : module_) (im : import) : import_type =
     | TableImport tt -> ExternTableT tt
     | MemoryImport mt -> ExternMemoryT mt
     | GlobalImport gt -> ExternGlobalT gt
+    | TagImport x -> ExternTagT (TagT (Lib.List32.nth dts x.it))
   in ImportT (subst_extern_type (subst_of dts) et, module_name, item_name)
 
 let export_type_of (m : module_) (ex : export) : export_type =
@@ -409,6 +431,10 @@ let export_type_of (m : module_) (ex : export) : export_type =
     | GlobalExport x ->
       let gts = globals ets @ List.map (fun g -> g.it.gtype) m.it.globals in
       ExternGlobalT (Lib.List32.nth gts x.it)
+    | TagExport x ->
+      let tts = tags ets @ List.map (fun t ->
+        TagT (Lib.List32.nth dts t.it.tgtype.it)) m.it.tags in
+      ExternTagT (Lib.List32.nth tts x.it)
   in ExportT (subst_extern_type (subst_of dts) et, name)
 
 let module_type_of (m : module_) : module_type =
diff --git a/interpreter/syntax/free.ml b/interpreter/syntax/free.ml
index f5cb6e433a..082c9d397e 100644
--- a/interpreter/syntax/free.ml
+++ b/interpreter/syntax/free.ml
@@ -10,6 +10,7 @@ type t =
   globals : Set.t;
   tables : Set.t;
   memories : Set.t;
+  tags : Set.t;
   funcs : Set.t;
   elems : Set.t;
   datas : Set.t;
@@ -23,6 +24,7 @@ let empty : t =
   globals = Set.empty;
   tables = Set.empty;
   memories = Set.empty;
+  tags = Set.empty;
   funcs = Set.empty;
   elems = Set.empty;
   datas = Set.empty;
@@ -36,6 +38,7 @@ let union (s1 : t) (s2 : t) : t =
   globals = Set.union s1.globals s2.globals;
   tables = Set.union s1.tables s2.tables;
   memories = Set.union s1.memories s2.memories;
+  tags = Set.union s1.tags s2.tags;
   funcs = Set.union s1.funcs s2.funcs;
   elems = Set.union s1.elems s2.elems;
   datas = Set.union s1.datas s2.datas;
@@ -47,6 +50,7 @@ let types s = {empty with types = s}
 let globals s = {empty with globals = s}
 let tables s = {empty with tables = s}
 let memories s = {empty with memories = s}
+let tags s = {empty with tags = s}
 let funcs s = {empty with funcs = s}
 let elems s = {empty with elems = s}
 let datas s = {empty with datas = s}
@@ -75,6 +79,7 @@ let heap_type = function
   | AnyHT | NoneHT | EqHT
   | I31HT | StructHT | ArrayHT -> empty
   | FuncHT | NoFuncHT -> empty
+  | ExnHT | NoExnHT -> empty
   | ExternHT | NoExternHT -> empty
   | VarHT x -> var_type x
   | DefHT _ct -> empty  (* assume closed *)
@@ -118,12 +123,14 @@ let def_type = function
 let global_type (GlobalT (_mut, t)) = val_type t
 let table_type (TableT (_lim, t)) = ref_type t
 let memory_type (MemoryT (_lim)) = empty
+let tag_type (TagT dt) = def_type dt
 
 let extern_type = function
   | ExternFuncT dt -> def_type dt
   | ExternTableT tt -> table_type tt
   | ExternMemoryT mt -> memory_type mt
   | ExternGlobalT gt -> global_type gt
+  | ExternTagT tt -> tag_type tt
 
 let block_type = function
   | VarBlockType x -> types (idx x)
@@ -162,6 +169,10 @@ let rec instr (e : instr) =
   | CallRef x | ReturnCallRef x -> types (idx x)
   | CallIndirect (x, y) | ReturnCallIndirect (x, y) ->
     tables (idx x) ++ types (idx y)
+  | Throw x -> tags (idx x)
+  | ThrowRef -> empty
+  | TryTable (bt, cs, es) ->
+    block_type bt ++ list catch cs ++ block es
   | LocalGet x | LocalSet x | LocalTee x -> locals (idx x)
   | GlobalGet x | GlobalSet x -> globals (idx x)
   | TableGet x | TableSet x | TableSize x | TableGrow x | TableFill x ->
@@ -185,6 +196,11 @@ let rec instr (e : instr) =
 and block (es : instr list) =
   let free = list instr es in {free with labels = shift free.labels}
 
+and catch (c : catch) =
+  match c.it with
+  | Catch (x1, x2) | CatchRef (x1, x2) -> tags (idx x1) ++ labels (idx x2)
+  | CatchAll x | CatchAllRef x -> labels (idx x)
+
 let const (c : const) = block c.it
 
 let global (g : global) = global_type g.it.gtype ++ const g.it.ginit
@@ -192,6 +208,7 @@ let func (f : func) =
   {(types (idx f.it.ftype) ++ block f.it.body) with locals = Set.empty}
 let table (t : table) = table_type t.it.ttype ++ const t.it.tinit
 let memory (m : memory) = memory_type m.it.mtype
+let tag (t : tag) = empty
 
 let segment_mode f (m : segment_mode) =
   match m.it with
@@ -212,6 +229,7 @@ let export_desc (d : export_desc) =
   | TableExport x -> tables (idx x)
   | MemoryExport x -> memories (idx x)
   | GlobalExport x -> globals (idx x)
+  | TagExport x -> tags (idx x)
 
 let import_desc (d : import_desc) =
   match d.it with
@@ -219,6 +237,7 @@ let import_desc (d : import_desc) =
   | TableImport tt -> table_type tt
   | MemoryImport mt -> memory_type mt
   | GlobalImport gt -> global_type gt
+  | TagImport x -> types (idx x)
 
 let export (e : export) = export_desc e.it.edesc
 let import (i : import) = import_desc i.it.idesc
diff --git a/interpreter/syntax/free.mli b/interpreter/syntax/free.mli
index 11490dd367..3c18c665c2 100644
--- a/interpreter/syntax/free.mli
+++ b/interpreter/syntax/free.mli
@@ -6,6 +6,7 @@ type t =
   globals : Set.t;
   tables : Set.t;
   memories : Set.t;
+  tags : Set.t;
   funcs : Set.t;
   elems : Set.t;
   datas : Set.t;
@@ -25,6 +26,7 @@ val func_type : Types.func_type -> t
 val global_type : Types.global_type -> t
 val table_type : Types.table_type -> t
 val memory_type : Types.memory_type -> t
+val tag_type : Types.tag_type -> t
 val extern_type : Types.extern_type -> t
 
 val str_type : Types.str_type -> t
@@ -41,6 +43,7 @@ val global : Ast.global -> t
 val func : Ast.func -> t
 val table : Ast.table -> t
 val memory : Ast.memory -> t
+val tag : Ast.tag -> t
 val elem : Ast.elem_segment -> t
 val data : Ast.data_segment -> t
 val export : Ast.export -> t
diff --git a/interpreter/syntax/operators.ml b/interpreter/syntax/operators.ml
index e7fcba278b..9a467b1cb1 100644
--- a/interpreter/syntax/operators.ml
+++ b/interpreter/syntax/operators.ml
@@ -32,6 +32,11 @@ let br_on_non_null x = BrOnNonNull x
 let br_on_cast x t1 t2 = BrOnCast (x, t1, t2)
 let br_on_cast_fail x t1 t2 = BrOnCastFail (x, t1, t2)
 
+let catch x1 x2 = Catch (x1, x2)
+let catch_ref x1 x2 = CatchRef (x1, x2)
+let catch_all x = CatchAll x
+let catch_all_ref x = CatchAllRef x
+
 let return = Return
 let call x = Call x
 let call_ref x = CallRef x
@@ -40,6 +45,10 @@ let return_call x = ReturnCall x
 let return_call_ref x = ReturnCallRef x
 let return_call_indirect x y = ReturnCallIndirect (x, y)
 
+let throw x = Throw x
+let throw_ref = ThrowRef
+let try_table bt cs es = TryTable (bt, cs, es)
+
 let local_get x = LocalGet x
 let local_set x = LocalSet x
 let local_tee x = LocalTee x
diff --git a/interpreter/syntax/types.ml b/interpreter/syntax/types.ml
index 08cf7416df..dd233c9f75 100644
--- a/interpreter/syntax/types.ml
+++ b/interpreter/syntax/types.ml
@@ -17,6 +17,7 @@ type vec_type = V128T
 type heap_type =
   | AnyHT | NoneHT | EqHT | I31HT | StructHT | ArrayHT
   | FuncHT | NoFuncHT
+  | ExnHT | NoExnHT
   | ExternHT | NoExternHT
   | VarHT of var
   | DefHT of def_type
@@ -46,12 +47,14 @@ and def_type = DefT of rec_type * int32
 type table_type = TableT of Int32.t limits * ref_type
 type memory_type = MemoryT of Int32.t limits
 type global_type = GlobalT of mut * val_type
+type tag_type = TagT of def_type
 type local_type = LocalT of init * val_type
 type extern_type =
   | ExternFuncT of def_type
   | ExternTableT of table_type
   | ExternMemoryT of memory_type
   | ExternGlobalT of global_type
+  | ExternTagT of tag_type
 
 type export_type = ExportT of extern_type * name
 type import_type = ImportT of extern_type * name * name
@@ -141,6 +144,7 @@ let funcs = List.filter_map (function ExternFuncT ft -> Some ft | _ -> None)
 let tables = List.filter_map (function ExternTableT tt -> Some tt | _ -> None)
 let memories = List.filter_map (function ExternMemoryT mt -> Some mt | _ -> None)
 let globals = List.filter_map (function ExternGlobalT gt -> Some gt | _ -> None)
+let tags = List.filter_map (function ExternTagT tt -> Some tt | _ -> None)
 
 
 (* Substitution *)
@@ -165,6 +169,8 @@ let subst_heap_type s = function
   | ArrayHT -> ArrayHT
   | FuncHT -> FuncHT
   | NoFuncHT -> NoFuncHT
+  | ExnHT -> ExnHT
+  | NoExnHT -> NoExnHT
   | ExternHT -> ExternHT
   | NoExternHT -> NoExternHT
   | VarHT x -> s x
@@ -225,11 +231,15 @@ let subst_table_type s = function
 let subst_global_type s = function
   | GlobalT (mut, t) ->  GlobalT (mut, subst_val_type s t)
 
+let subst_tag_type s = function
+  | TagT dt -> TagT (subst_def_type s dt)
+
 let subst_extern_type s = function
   | ExternFuncT dt -> ExternFuncT (subst_def_type s dt)
   | ExternTableT tt -> ExternTableT (subst_table_type s tt)
   | ExternMemoryT mt -> ExternMemoryT (subst_memory_type s mt)
   | ExternGlobalT gt -> ExternGlobalT (subst_global_type s gt)
+  | ExternTagT tt -> ExternTagT (subst_tag_type s tt)
 
 
 let subst_export_type s = function
@@ -334,6 +344,8 @@ let rec string_of_heap_type = function
   | ArrayHT -> "array"
   | FuncHT -> "func"
   | NoFuncHT -> "nofunc"
+  | ExnHT -> "exn"
+  | NoExnHT -> "noexn"
   | ExternHT -> "extern"
   | NoExternHT -> "noextern"
   | VarHT x -> string_of_var x
@@ -409,6 +421,9 @@ let string_of_table_type = function
 let string_of_global_type = function
   | GlobalT (mut, t) -> string_of_mut (string_of_val_type t) mut
 
+let string_of_tag_type = function
+  | TagT dt -> string_of_def_type dt
+
 let string_of_local_type = function
   | LocalT (Set, t) -> string_of_val_type t
   | LocalT (Unset, t) -> "(unset " ^ string_of_val_type t ^ ")"
@@ -418,6 +433,7 @@ let string_of_extern_type = function
   | ExternTableT tt -> "table " ^ string_of_table_type tt
   | ExternMemoryT mt -> "memory " ^ string_of_memory_type mt
   | ExternGlobalT gt -> "global " ^ string_of_global_type gt
+  | ExternTagT tt -> "tag " ^ string_of_tag_type tt
 
 
 let string_of_export_type = function
diff --git a/interpreter/text/arrange.ml b/interpreter/text/arrange.ml
index c9ca33691e..dfc9ecd71d 100644
--- a/interpreter/text/arrange.ml
+++ b/interpreter/text/arrange.ml
@@ -71,6 +71,7 @@ let ref_type t =
   | (Null, StructHT) -> "structref"
   | (Null, ArrayHT) -> "arrayref"
   | (Null, FuncHT) -> "funcref"
+  | (Null, ExnHT) -> "exnref"
   | t -> string_of_ref_type t
 
 let heap_type t = string_of_heap_type t
@@ -515,6 +516,10 @@ let rec instr e =
     | ReturnCallRef x -> "return_call_ref " ^ var x, []
     | ReturnCallIndirect (x, y) ->
       "return_call_indirect " ^ var x, [Node ("type " ^ var y, [])]
+    | Throw x -> "throw " ^ var x, []
+    | ThrowRef -> "throw_ref", []
+    | TryTable (bt, cs, es) ->
+      "try_table", block_type bt @ list catch cs @ list instr es
     | LocalGet x -> "local.get " ^ var x, []
     | LocalSet x -> "local.set " ^ var x, []
     | LocalTee x -> "local.tee " ^ var x, []
@@ -588,6 +593,13 @@ let rec instr e =
     | VecReplace op -> vec_replaceop op, []
   in Node (head, inner)
 
+and catch c =
+  match c.it with
+  | Catch (x1, x2) -> Node ("catch " ^ var x1 ^ " " ^ var x2, [])
+  | CatchRef (x1, x2) -> Node ("catch_ref " ^ var x1 ^ " " ^ var x2, [])
+  | CatchAll x -> Node ("catch_all " ^ var x, [])
+  | CatchAllRef x -> Node ("catch_all_ref " ^ var x, [])
+
 let const head c =
   match c.it with
   | [e] -> instr e
@@ -611,7 +623,12 @@ let func f =
   func_with_name "" f
 
 
-(* Tables & memories *)
+(* Tags, tables, memories *)
+
+let tag off i tag =
+  Node ("tag $" ^ nat (off + i),
+    [Node ("type " ^ var (tag.it.tgtype), [])]
+  )
 
 let table off i tab =
   let {ttype = TableT (lim, t); tinit} = tab.it in
@@ -673,7 +690,7 @@ let type_ (ns, i) ty =
   | RecT sts ->
     Node ("rec", List.mapi (rec_type i) sts) :: ns, i + List.length sts
 
-let import_desc fx tx mx gx d =
+let import_desc fx tx mx tgx gx d =
   match d.it with
   | FuncImport x ->
     incr fx; Node ("func $" ^ nat (!fx - 1), [Node ("type", [atom var x])])
@@ -683,11 +700,13 @@ let import_desc fx tx mx gx d =
     incr mx; memory 0 (!mx - 1) ({mtype = t} @@ d.at)
   | GlobalImport t ->
     incr gx; Node ("global $" ^ nat (!gx - 1), [global_type t])
+  | TagImport x ->
+    incr tgx; Node ("tag $" ^ nat (!tgx - 1), [Node ("type", [atom var x])])
 
-let import fx tx mx gx im =
+let import fx tx mx ex gx im =
   let {module_name; item_name; idesc} = im.it in
   Node ("import",
-    [atom name module_name; atom name item_name; import_desc fx tx mx gx idesc]
+    [atom name module_name; atom name item_name; import_desc fx tx mx ex gx idesc]
   )
 
 let export_desc d =
@@ -695,6 +714,7 @@ let export_desc d =
   | FuncExport x -> Node ("func", [atom var x])
   | TableExport x -> Node ("table", [atom var x])
   | MemoryExport x -> Node ("memory", [atom var x])
+  | TagExport x -> Node ("tag", [atom var x])
   | GlobalExport x -> Node ("global", [atom var x])
 
 let export ex =
@@ -711,7 +731,6 @@ let start s =
 let custom m mnode (module S : Custom.Section) =
   S.Handler.arrange m mnode S.it
 
-(* Module *)
 
 let var_opt = function
   | None -> ""
@@ -724,13 +743,15 @@ let module_with_var_opt x_opt (m, cs) =
   let fx = ref 0 in
   let tx = ref 0 in
   let mx = ref 0 in
+  let tgx = ref 0 in
   let gx = ref 0 in
-  let imports = list (import fx tx mx gx) m.it.imports in
+  let imports = list (import fx tx mx tgx gx) m.it.imports in
   let ret = Node ("module" ^ var_opt x_opt,
     List.rev (fst (List.fold_left type_ ([], 0) m.it.types)) @
     imports @
     listi (table !tx) m.it.tables @
     listi (memory !mx) m.it.memories @
+    listi (tag !tgx) m.it.tags @
     listi (global !gx) m.it.globals @
     list export m.it.exports @
     opt start m.it.start @
@@ -871,6 +892,8 @@ let assertion mode ass =
     [Node ("assert_return", action mode act :: List.map (result mode) results)]
   | AssertTrap (act, re) ->
     [Node ("assert_trap", [action mode act; Atom (string re)])]
+  | AssertException act ->
+    [Node ("assert_exception", [action mode act])]
   | AssertExhaustion (act, re) ->
     [Node ("assert_exhaustion", [action mode act; Atom (string re)])]
 
diff --git a/interpreter/text/lexer.mll b/interpreter/text/lexer.mll
index 999e060c7a..f1d7105f95 100644
--- a/interpreter/text/lexer.mll
+++ b/interpreter/text/lexer.mll
@@ -169,6 +169,10 @@ rule token = parse
       | "nofunc" -> NOFUNC
       | "funcref" -> FUNCREF
       | "nullfuncref" -> NULLFUNCREF
+      | "exn" -> EXN
+      | "noexn" -> NOEXN
+      | "exnref" -> EXNREF
+      | "nullexnref" -> NULLEXNREF
       | "extern" -> EXTERN
       | "noextern" -> NOEXTERN
       | "externref" -> EXTERNREF
@@ -208,6 +212,13 @@ rule token = parse
       | "return_call" -> RETURN_CALL
       | "return_call_ref" -> RETURN_CALL_REF
       | "return_call_indirect" -> RETURN_CALL_INDIRECT
+      | "throw" -> THROW
+      | "throw_ref" -> THROW_REF
+      | "try_table" -> TRY_TABLE
+      | "catch" -> CATCH
+      | "catch_ref" -> CATCH_REF
+      | "catch_all" -> CATCH_ALL
+      | "catch_all_ref" -> CATCH_ALL_REF
 
       | "local.get" -> LOCAL_GET
       | "local.set" -> LOCAL_SET
@@ -316,6 +327,7 @@ rule token = parse
       | "ref.func" -> REF_FUNC
       | "ref.struct" -> REF_STRUCT
       | "ref.array" -> REF_ARRAY
+      | "ref.exn" -> REF_EXN
       | "ref.extern" -> REF_EXTERN
       | "ref.host" -> REF_HOST
 
@@ -739,6 +751,7 @@ rule token = parse
       | "global" -> GLOBAL
       | "table" -> TABLE
       | "memory" -> MEMORY
+      | "tag" -> TAG
       | "elem" -> ELEM
       | "data" -> DATA
       | "declare" -> DECLARE
@@ -762,6 +775,7 @@ rule token = parse
       | "assert_unlinkable" -> ASSERT_UNLINKABLE
       | "assert_return" -> ASSERT_RETURN
       | "assert_trap" -> ASSERT_TRAP
+      | "assert_exception" -> ASSERT_EXCEPTION
       | "assert_exhaustion" -> ASSERT_EXHAUSTION
       | "nan:canonical" -> NAN Script.CanonicalNan
       | "nan:arithmetic" -> NAN Script.ArithmeticNan
diff --git a/interpreter/text/parser.mly b/interpreter/text/parser.mly
index 8fd9fb5334..f5167e32a8 100644
--- a/interpreter/text/parser.mly
+++ b/interpreter/text/parser.mly
@@ -124,7 +124,7 @@ type types =
 let empty_types () = {space = empty (); fields = []; list = []; ctx = []}
 
 type context =
-  { types : types; tables : space; memories : space;
+  { types : types; tables : space; memories : space; tags : space;
     funcs : space; locals : space; globals : space;
     datas : space; elems : space; labels : space;
     deferred_locals : (unit -> unit) list ref
@@ -132,7 +132,7 @@ type context =
 
 let empty_context () =
   { types = empty_types (); tables = empty (); memories = empty ();
-    funcs = empty (); locals = empty (); globals = empty ();
+    tags = empty (); funcs = empty (); locals = empty (); globals = empty ();
     datas = empty (); elems = empty (); labels = empty ();
     deferred_locals = ref []
   }
@@ -174,6 +174,7 @@ let local (c : context) x = lookup "local" c.locals x
 let global (c : context) x = lookup "global" c.globals x
 let table (c : context) x = lookup "table" c.tables x
 let memory (c : context) x = lookup "memory" c.memories x
+let tag (c : context) x = lookup "tag" c.tags x
 let elem (c : context) x = lookup "elem segment" c.elems x
 let data (c : context) x = lookup "data segment" c.datas x
 let label (c : context) x = lookup "label " c.labels x
@@ -208,6 +209,7 @@ let bind_local (c : context) x = force_locals c; bind_abs "local" c.locals x
 let bind_global (c : context) x = bind_abs "global" c.globals x
 let bind_table (c : context) x = bind_abs "table" c.tables x
 let bind_memory (c : context) x = bind_abs "memory" c.memories x
+let bind_tag (c : context) x = bind_abs "tag" c.tags x
 let bind_elem (c : context) x = bind_abs "elem segment" c.elems x
 let bind_data (c : context) x = bind_abs "data segment" c.datas x
 let bind_label (c : context) x = bind_rel "label" c.labels x
@@ -228,6 +230,7 @@ let anon_locals (c : context) n loc =
 let anon_global (c : context) loc = bind "global" c.globals 1l (at loc)
 let anon_table (c : context) loc = bind "table" c.tables 1l (at loc)
 let anon_memory (c : context) loc = bind "memory" c.memories 1l (at loc)
+let anon_tag (c : context) loc = bind "tag" c.tags 1l (at loc)
 let anon_elem (c : context) loc = bind "elem segment" c.elems 1l (at loc)
 let anon_data (c : context) loc = bind "data segment" c.datas 1l (at loc)
 let anon_label (c : context) loc = bind "label" c.labels 1l (at loc)
@@ -295,8 +298,8 @@ let parse_annots (m : module_) : Custom.section list =
 %token PACK_TYPE
 %token VEC_SHAPE
 %token ANYREF NULLREF EQREF I31REF STRUCTREF ARRAYREF
-%token FUNCREF NULLFUNCREF EXTERNREF NULLEXTERNREF
-%token ANY NONE EQ I31 REF NOFUNC EXTERN NOEXTERN NULL
+%token FUNCREF NULLFUNCREF EXNREF NULLEXNREF EXTERNREF NULLEXTERNREF
+%token ANY NONE EQ I31 REF NOFUNC EXN NOEXN EXTERN NOEXTERN NULL
 %token MUT FIELD STRUCT ARRAY SUB FINAL REC
 %token UNREACHABLE NOP DROP SELECT
 %token BLOCK END IF THEN ELSE LOOP
@@ -305,6 +308,7 @@ let parse_annots (m : module_) : Custom.section list =
 %token Types.ref_type -> Types.ref_type -> Ast.instr'> BR_ON_CAST
 %token CALL CALL_REF CALL_INDIRECT
 %token RETURN RETURN_CALL RETURN_CALL_REF RETURN_CALL_INDIRECT
+%token THROW THROW_REF TRY_TABLE CATCH CATCH_REF CATCH_ALL CATCH_ALL_REF
 %token LOCAL_GET LOCAL_SET LOCAL_TEE GLOBAL_GET GLOBAL_SET
 %token TABLE_GET TABLE_SET
 %token TABLE_SIZE TABLE_GROW TABLE_FILL TABLE_COPY TABLE_INIT ELEM_DROP
@@ -313,7 +317,7 @@ let parse_annots (m : module_) : Custom.section list =
 %token OFFSET_EQ_NAT ALIGN_EQ_NAT
 %token Ast.instr' * Value.num> CONST
 %token UNARY BINARY TEST COMPARE CONVERT
-%token REF_NULL REF_FUNC REF_I31 REF_STRUCT REF_ARRAY REF_EXTERN REF_HOST
+%token REF_NULL REF_FUNC REF_I31 REF_STRUCT REF_ARRAY REF_EXN REF_EXTERN REF_HOST
 %token REF_EQ REF_IS_NULL REF_AS_NON_NULL REF_TEST REF_CAST
 %token I31_GET
 %token Ast.instr'> STRUCT_NEW ARRAY_NEW ARRAY_GET
@@ -331,12 +335,12 @@ let parse_annots (m : module_) : Custom.section list =
 %token VEC_SHUFFLE
 %token Ast.instr'> VEC_EXTRACT VEC_REPLACE
 %token FUNC START TYPE PARAM RESULT LOCAL GLOBAL
-%token TABLE ELEM MEMORY DATA DECLARE OFFSET ITEM IMPORT EXPORT
+%token TABLE ELEM MEMORY TAG DATA DECLARE OFFSET ITEM IMPORT EXPORT
 %token MODULE BIN QUOTE
 %token SCRIPT REGISTER INVOKE GET
 %token ASSERT_MALFORMED ASSERT_INVALID ASSERT_UNLINKABLE
+%token ASSERT_RETURN ASSERT_TRAP ASSERT_EXCEPTION ASSERT_EXHAUSTION
 %token ASSERT_MALFORMED_CUSTOM ASSERT_INVALID_CUSTOM
-%token ASSERT_RETURN ASSERT_TRAP ASSERT_EXHAUSTION
 %token NAN
 %token INPUT OUTPUT
 %token EOF
@@ -373,6 +377,8 @@ heap_type :
   | ARRAY { fun c -> ArrayHT }
   | FUNC { fun c -> FuncHT }
   | NOFUNC { fun c -> NoFuncHT }
+  | EXN { fun c -> ExnHT }
+  | NOEXN { fun c -> NoExnHT }
   | EXTERN { fun c -> ExternHT }
   | NOEXTERN { fun c -> NoExternHT }
   | var { fun c -> VarHT (StatX ($1 c type_).it) }
@@ -387,6 +393,8 @@ ref_type :
   | ARRAYREF { fun c -> (Null, ArrayHT) }  /* Sugar */
   | FUNCREF { fun c -> (Null, FuncHT) }  /* Sugar */
   | NULLFUNCREF { fun c -> (Null, NoFuncHT) }  /* Sugar */
+  | EXNREF { fun c -> (Null, ExnHT) }  /* Sugar */
+  | NULLEXNREF { fun c -> (Null, NoExnHT) }  /* Sugar */
   | EXTERNREF { fun c -> (Null, ExternHT) }  /* Sugar */
   | NULLEXTERNREF { fun c -> (Null, NoExternHT) }  /* Sugar */
 
@@ -569,6 +577,8 @@ plain_instr :
   | CALL_REF var { fun c -> call_ref ($2 c type_) }
   | RETURN_CALL var { fun c -> return_call ($2 c func) }
   | RETURN_CALL_REF var { fun c -> return_call_ref ($2 c type_) }
+  | THROW var { fun c -> throw ($2 c tag) }
+  | THROW_REF { fun c -> throw_ref }
   | 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) }
@@ -728,6 +738,9 @@ block_instr :
   | IF labeling_opt block ELSE labeling_end_opt instr_list END labeling_end_opt
     { fun c -> let c' = $2 c ($5 @ $8) in
       let ts, es1 = $3 c' in if_ ts es1 ($6 c') }
+  | TRY_TABLE labeling_opt handler_block END labeling_end_opt
+    { fun c -> let c' = $2 c $5 in
+      let bt, (cs, es) = $3 c c' in try_table bt cs es }
 
 block :
   | type_use block_param_body
@@ -756,6 +769,48 @@ block_result_body :
       FuncT (ts1, snd $3 c @ ts2), es }
 
 
+handler_block :
+  | type_use handler_block_param_body
+    { fun c c' -> let ft, esh = $2 c c' in
+      VarBlockType (inline_func_type_explicit c ($1 c) ft $loc($1)), esh }
+  | handler_block_param_body  /* Sugar */
+    { fun c c' -> let ft, esh = $1 c c' in
+      let bt =
+        match ft with
+        | FuncT ([], []) -> ValBlockType None
+        | FuncT ([], [t]) -> ValBlockType (Some t)
+        | ft ->  VarBlockType (inline_func_type c ft $sloc)
+      in bt, esh }
+
+handler_block_param_body :
+  | handler_block_result_body { $1 }
+  | LPAR PARAM val_type_list RPAR handler_block_param_body
+    { fun c c' -> let FuncT (ts1, ts2), esh = $5 c c' in
+      FuncT (snd $3 c @ ts1, ts2), esh }
+
+handler_block_result_body :
+  | handler_block_body { fun c c' -> FuncT ([], []), $1 c c' }
+  | LPAR RESULT val_type_list RPAR handler_block_result_body
+    { fun c c' -> let FuncT (ts1, ts2), esh = $5 c c' in
+      FuncT (ts1, snd $3 c @ ts2), esh }
+
+handler_block_body :
+  | instr_list
+    { fun c c' -> [], $1 c' }
+  | LPAR CATCH var var RPAR handler_block_body
+    { fun c c' -> let cs, es = $6 c c' in
+      (catch ($3 c tag) ($4 c label) @@ $loc($2)) :: cs, es }
+  | LPAR CATCH_REF var var RPAR handler_block_body
+    { fun c c' -> let cs, es = $6 c c' in
+      (catch_ref ($3 c tag) ($4 c label) @@ $loc($2)) :: cs, es }
+  | LPAR CATCH_ALL var RPAR handler_block_body
+    { fun c c' -> let cs, es = $5 c c' in
+      (catch_all ($3 c label) @@ $loc($2)) :: cs, es }
+  | LPAR CATCH_ALL_REF var RPAR handler_block_body
+    { fun c c' -> let cs, es = $5 c c' in
+      (catch_all_ref ($3 c label) @@ $loc($2)) :: cs, es }
+
+
 expr :  /* Sugar */
   | LPAR expr1 RPAR
     { fun c -> let es, e' = $2 c in es @ [e' @@ $sloc] }
@@ -779,6 +834,9 @@ expr1 :  /* Sugar */
   | IF labeling_opt if_block
     { fun c -> let c' = $2 c [] in
       let bt, (es, es1, es2) = $3 c c' in es, if_ bt es1 es2 }
+  | TRY_TABLE labeling_opt try_block
+    { fun c -> let c' = $2 c [] in
+      let bt, (cs, es) = $3 c c' in [], try_table bt cs es }
 
 select_expr_results :
   | LPAR RESULT val_type_list RPAR select_expr_results
@@ -844,6 +902,52 @@ if_ :
   | LPAR THEN instr_list RPAR  /* Sugar */
     { fun c c' -> [], $3 c', [] }
 
+
+try_block :
+  | type_use try_block_param_body
+    { fun c c' ->
+      let ft, esh = $2 c c' in
+      let bt = VarBlockType (inline_func_type_explicit c' ($1 c') ft $sloc) in
+      bt, esh }
+  | try_block_param_body  /* Sugar */
+    { fun c c' ->
+      let ft, esh = $1 c c' in
+      let bt =
+        match ft with
+        | FuncT ([], []) -> ValBlockType None
+        | FuncT ([], [t]) -> ValBlockType (Some t)
+        | _ ->  VarBlockType (inline_func_type c' ft $sloc)
+      in bt, esh }
+
+try_block_param_body :
+  | try_block_result_body { $1 }
+  | LPAR PARAM val_type_list RPAR try_block_param_body
+    { fun c c' -> let FuncT (ts1, ts2), esh = $5 c c' in
+      FuncT (snd $3 c @ ts1, ts2), esh }
+
+try_block_result_body :
+  | try_block_handler_body { fun c c' -> FuncT ([], []), $1 c c' }
+  | LPAR RESULT val_type_list RPAR try_block_result_body
+    { fun c c' -> let FuncT (ts1, ts2), esh = $5 c c' in
+      FuncT (ts1, snd $3 c @ ts2), esh }
+
+try_block_handler_body :
+  | instr_list
+    { fun c c' -> [], $1 c' }
+  | LPAR CATCH var var RPAR try_block_handler_body
+    { fun c c' -> let cs, es = $6 c c' in
+      (catch ($3 c tag) ($4 c label) @@ $loc($2)) :: cs, es }
+  | LPAR CATCH_REF var var RPAR try_block_handler_body
+    { fun c c' -> let cs, es = $6 c c' in
+      (catch_ref ($3 c tag) ($4 c label) @@ $loc($2)) :: cs, es }
+  | LPAR CATCH_ALL var RPAR try_block_handler_body
+    { fun c c' -> let cs, es = $5 c c' in
+      (catch_all ($3 c label) @@ $loc($2)) :: cs, es }
+  | LPAR CATCH_ALL_REF var RPAR try_block_handler_body
+    { fun c c' -> let cs, es = $5 c c' in
+      (catch_all_ref ($3 c label) @@ $loc($2)) :: cs, es }
+
+
 expr_list :
   | /* empty */ { fun c -> [] }
   | expr expr_list { fun c -> $1 c @ $2 c }
@@ -866,7 +970,7 @@ func_fields :
   | type_use func_fields_body
     { fun c x loc ->
       let c' = enter_func c loc in
-      let y = inline_func_type_explicit c' ($1 c') (fst $2 c') loc in
+      let y = inline_func_type_explicit c' ($1 c') (fst $2 c') $loc($1) in
       [{(snd $2 c') with ftype = y} @@ loc], [], [] }
   | func_fields_body  /* Sugar */
     { fun c x loc ->
@@ -875,7 +979,7 @@ func_fields :
       [{(snd $1 c') with ftype = y} @@ loc], [], [] }
   | inline_import type_use func_fields_import  /* Sugar */
     { fun c x loc ->
-      let y = inline_func_type_explicit c ($2 c) ($3 c) loc in
+      let y = inline_func_type_explicit c ($2 c) ($3 c) $loc($2) in
       [],
       [{ module_name = fst $1; item_name = snd $1;
          idesc = FuncImport y @@ loc } @@ loc ], [] }
@@ -1077,6 +1181,36 @@ memory_fields :
       [{dinit = $3; dmode = Active {index = x; offset} @@ loc} @@ loc],
       [], [] }
 
+tag :
+  | LPAR TAG bind_var_opt tag_fields RPAR
+    { fun c -> let x = $3 c anon_tag bind_tag @@ $sloc in fun () -> $4 c x $sloc }
+
+tag_fields :
+  | type_use func_type
+    { fun c x loc ->
+      let tgtype = inline_func_type_explicit c ($1 c) ($2 c) $loc($1) in
+      [{tgtype} @@ loc], [], [] }
+  | func_type  /* Sugar */
+    { fun c x loc ->
+      let tgtype = inline_func_type c ($1 c) $sloc in
+      [{tgtype} @@ loc], [], [] }
+  | inline_import type_use func_type  /* Sugar */
+    { fun c x loc ->
+      let y = inline_func_type_explicit c ($2 c) ($3 c) $loc($2) in
+      [],
+      [{ module_name = fst $1; item_name = snd $1;
+         idesc = TagImport y @@ loc } @@ loc ], [] }
+  | inline_import func_type  /* Sugar */
+    { fun c x loc ->
+      let y = inline_func_type c ($2 c) $loc($2) in
+      [],
+      [{ module_name = fst $1; item_name = snd $1;
+         idesc = TagImport y @@ loc } @@ loc ], [] }
+  | inline_export tag_fields  /* Sugar */
+    { fun c x loc ->
+      let tgs, ims, exs = $2 c x loc in tgs, ims, $1 (TagExport x) c :: exs }
+
+
 global :
   | LPAR GLOBAL bind_var_opt global_fields RPAR
     { fun c -> let x = $3 c anon_global bind_global @@ $sloc in
@@ -1113,6 +1247,12 @@ import_desc :
   | LPAR GLOBAL bind_var_opt global_type RPAR
     { fun c -> ignore ($3 c anon_global bind_global);
       fun () -> GlobalImport ($4 c) }
+  | LPAR TAG bind_var_opt type_use RPAR
+    { fun c -> ignore ($3 c anon_tag bind_tag);
+      fun () -> TagImport ($4 c) }
+  | LPAR TAG bind_var_opt func_type RPAR  /* Sugar */
+    { fun c -> ignore ($3 c anon_tag bind_tag);
+      fun () -> TagImport (inline_func_type c ($4 c) $loc($4)) }
 
 import :
   | LPAR IMPORT name name import_desc RPAR
@@ -1126,6 +1266,7 @@ 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 TAG var RPAR { fun c -> TagExport ($3 c tag) }
   | LPAR GLOBAL var RPAR { fun c -> GlobalExport ($3 c global) }
 
 export :
@@ -1204,6 +1345,14 @@ module_fields1 :
         error (List.hd m.imports).at "import after memory definition";
       { m with memories = mems @ m.memories; datas = data @ m.datas;
         imports = ims @ m.imports; exports = exs @ m.exports } }
+  | tag module_fields
+    { fun c -> let ef = $1 c in let mff = $2 c in
+      fun () -> let mf = mff () in
+      fun () -> let tags, ims, exs = ef () in let m = mf () in
+      if tags <> [] && m.imports <> [] then
+        error (List.hd m.imports).at "import after tag definition";
+      { m with tags = tags @ m.tags;
+        imports = ims @ m.imports; exports = exs @ m.exports } }
   | func module_fields
     { fun c -> let ff = $1 c in let mff = $2 c in
       fun () -> let mf = mff () in
@@ -1298,6 +1447,8 @@ assertion :
   | LPAR ASSERT_TRAP script_module STRING RPAR
     { AssertUninstantiable (snd $3, $4) @@ $sloc }
   | LPAR ASSERT_RETURN action list(result) RPAR { AssertReturn ($3, $4) @@ $sloc }
+  | LPAR ASSERT_EXCEPTION action RPAR
+    { AssertException $3 @@ $sloc }
   | LPAR ASSERT_TRAP action STRING RPAR { AssertTrap ($3, $4) @@ $sloc }
   | LPAR ASSERT_EXHAUSTION action STRING RPAR { AssertExhaustion ($3, $4) @@ $sloc }
 
@@ -1344,6 +1495,7 @@ result :
   | LPAR REF_STRUCT RPAR { RefResult (RefTypePat StructHT) @@ $sloc }
   | LPAR REF_ARRAY RPAR { RefResult (RefTypePat ArrayHT) @@ $sloc }
   | LPAR REF_FUNC RPAR { RefResult (RefTypePat FuncHT) @@ $sloc }
+  | LPAR REF_EXN RPAR { RefResult (RefTypePat ExnHT) @@ $sloc }
   | LPAR REF_EXTERN RPAR { RefResult (RefTypePat ExternHT) @@ $sloc }
   | LPAR REF_NULL RPAR { RefResult NullPat @@ $sloc }
   | LPAR VEC_CONST VEC_SHAPE list(numpat) RPAR
diff --git a/interpreter/valid/match.ml b/interpreter/valid/match.ml
index 128269cde7..70f8136c9a 100644
--- a/interpreter/valid/match.ml
+++ b/interpreter/valid/match.ml
@@ -20,6 +20,7 @@ let rec top_of_str_type c st =
 and top_of_heap_type c = function
   | AnyHT | NoneHT | EqHT | StructHT | ArrayHT | I31HT -> AnyHT
   | FuncHT | NoFuncHT -> FuncHT
+  | ExnHT | NoExnHT -> ExnHT
   | ExternHT | NoExternHT -> ExternHT
   | DefHT dt -> top_of_str_type c (expand_def_type dt)
   | VarHT (StatX x) -> top_of_str_type c (expand_def_type (lookup c x))
@@ -31,6 +32,7 @@ let rec bot_of_str_type c st =
 and bot_of_heap_type c = function
   | AnyHT | NoneHT | EqHT | StructHT | ArrayHT | I31HT -> NoneHT
   | FuncHT | NoFuncHT -> NoFuncHT
+  | ExnHT | NoExnHT -> NoExnHT
   | ExternHT | NoExternHT -> NoExternHT
   | DefHT dt -> bot_of_str_type c (expand_def_type dt)
   | VarHT (StatX x) -> bot_of_str_type c (expand_def_type (lookup c x))
@@ -60,7 +62,6 @@ let match_vec_type _c t1 t2 =
 
 let rec match_heap_type c t1 t2 =
   match t1, t2 with
-  | AnyHT, AnyHT -> true
   | EqHT, AnyHT -> true
   | StructHT, AnyHT -> true
   | ArrayHT, AnyHT -> true
@@ -68,9 +69,9 @@ let rec match_heap_type c t1 t2 =
   | I31HT, EqHT -> true
   | StructHT, EqHT -> true
   | ArrayHT, EqHT -> true
-  | ExternHT, ExternHT -> true
   | NoneHT, t -> match_heap_type c t AnyHT
   | NoFuncHT, t -> match_heap_type c t FuncHT
+  | NoExnHT, t -> match_heap_type c t ExnHT
   | NoExternHT, t -> match_heap_type c t ExternHT
   | VarHT (StatX x1), _ -> match_heap_type c (DefHT (lookup c x1)) t2
   | _, VarHT (StatX x2) -> match_heap_type c t1 (DefHT (lookup c x2))
@@ -160,6 +161,9 @@ let match_table_type c (TableT (lim1, t1)) (TableT (lim2, t2)) =
 let match_memory_type c (MemoryT lim1) (MemoryT lim2) =
   match_limits c lim1 lim2
 
+let match_tag_type c (TagT dt1) (TagT dt2) =
+  match_def_type c dt1 dt2 && match_def_type c dt2 dt1
+
 
 let match_extern_type c et1 et2 =
   match et1, et2 with
@@ -167,4 +171,5 @@ let match_extern_type c et1 et2 =
   | ExternTableT tt1, ExternTableT tt2 -> match_table_type c tt1 tt2
   | ExternMemoryT mt1, ExternMemoryT mt2 -> match_memory_type c mt1 mt2
   | ExternGlobalT gt1, ExternGlobalT gt2 -> match_global_type c gt1 gt2
+  | ExternTagT tt1, ExternTagT tt2 -> match_tag_type c tt1 tt2
   | _, _ -> false
diff --git a/interpreter/valid/valid.ml b/interpreter/valid/valid.ml
index e5b65c9532..6c02ff9243 100644
--- a/interpreter/valid/valid.ml
+++ b/interpreter/valid/valid.ml
@@ -21,6 +21,7 @@ type context =
   funcs : def_type list;
   tables : table_type list;
   memories : memory_type list;
+  tags : tag_type list;
   globals : global_type list;
   elems : ref_type list;
   datas : unit list;
@@ -31,8 +32,8 @@ type context =
 }
 
 let empty_context =
-  { types = []; funcs = []; globals = []; tables = []; memories = [];
-    elems = []; datas = [];
+  { types = []; funcs = []; globals = []; tables = [];
+    memories = []; tags = []; elems = []; datas = [];
     locals = []; results = []; labels = [];
     refs = Free.empty
   }
@@ -45,6 +46,7 @@ let type_ (c : context) x = lookup "type" c.types x
 let func (c : context) x = lookup "function" c.funcs x
 let table (c : context) x = lookup "table" c.tables x
 let memory (c : context) x = lookup "memory" c.memories x
+let tag (c : context) x = lookup "tag" c.tags x
 let global (c : context) x = lookup "global" c.globals x
 let elem (c : context) x = lookup "elem segment" c.elems x
 let data (c : context) x = lookup "data segment" c.datas x
@@ -106,6 +108,7 @@ let check_heap_type (c : context) (t : heap_type) at =
   match t with
   | AnyHT | NoneHT | EqHT | I31HT | StructHT | ArrayHT
   | FuncHT | NoFuncHT
+  | ExnHT | NoExnHT
   | ExternHT | NoExternHT -> ()
   | VarHT (StatX x) -> let _dt = type_ c (x @@ at) in ()
   | VarHT (RecX _) | DefHT _ -> assert false
@@ -225,19 +228,22 @@ let stack ts = (NoEllipses, ts)
 let (-->) ts1 ts2 = {ins = NoEllipses, ts1; outs = NoEllipses, ts2}
 let (-->...) ts1 ts2 = {ins = Ellipses, ts1; outs = Ellipses, ts2}
 
-let check_stack (c : context) ts1 ts2 at =
+let match_resulttype s1 s2 (c : context) ts1 ts2 at =
   require
     ( List.length ts1 = List.length ts2 &&
       List.for_all2 (match_val_type c.types) ts1 ts2 ) at
-    ("type mismatch: instruction requires " ^ string_of_result_type ts2 ^
-     " but stack has " ^ string_of_result_type ts1)
+    ("type mismatch: " ^ s2 ^ " requires " ^ string_of_result_type ts2 ^
+     " but " ^ s1 ^ " has " ^ string_of_result_type ts1)
+
+let match_stack (c : context) ts1 ts2 at =
+  match_resulttype "stack" "instruction" c ts1 ts2 at
 
 let pop c (ell1, ts1) (ell2, ts2) at =
   let n1 = List.length ts1 in
   let n2 = List.length ts2 in
   let n = min n1 n2 in
   let n3 = if ell2 = Ellipses then (n1 - n) else 0 in
-  check_stack c (Lib.List.make n3 (BotT : val_type) @ Lib.List.drop (n2 - n) ts2) ts1 at;
+  match_stack c (Lib.List.make n3 (BotT : val_type) @ Lib.List.drop (n2 - n) ts2) ts1 at;
   (ell2, if ell1 = Ellipses then [] else Lib.List.take (n2 - n) ts2)
 
 let push c (ell1, ts1) (ell2, ts2) =
@@ -433,8 +439,8 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
   | BrTable (xs, x) ->
     let n = List.length (label c x) in
     let ts = List.init n (fun i -> peek (n - i) s) in
-    check_stack c ts (label c x) x.at;
-    List.iter (fun x' -> check_stack c ts (label c x') x'.at) xs;
+    match_stack c ts (label c x) x.at;
+    List.iter (fun x' -> match_stack c ts (label c x') x'.at) xs;
     (ts @ [NumT I32T]) -->... [], []
 
   | BrOnNull x ->
@@ -530,6 +536,21 @@ let rec check_instr (c : context) (e : instr) (s : infer_result_type) : infer_in
        " but callee returns " ^ string_of_result_type ts2);
     (ts1 @ [NumT I32T]) -->... [], []
 
+  | Throw x ->
+    let TagT dt = tag c x in
+    let FuncT (ts1, ts2) = as_func_str_type (expand_def_type dt) in
+    ts1 -->... [], []
+
+  | ThrowRef ->
+    [RefT (Null, ExnHT)] -->... [], []
+
+  | TryTable (bt, cs, es) ->
+    let InstrT (ts1, ts2, xs) as it = check_block_type c bt e.at in
+    let c' = {c with labels = ts2 :: c.labels} in
+    List.iter (fun ct -> check_catch c ct ts2 e.at) cs;
+    check_block c' es it e.at;
+    ts1 --> ts2, List.map (fun x -> x @@ e.at) xs
+
   | LocalGet x ->
     let LocalT (init, t) = local c x in
     require (init = Set) x.at "uninitialized local";
@@ -908,6 +929,22 @@ and check_block (c : context) (es : instr list) (it : instr_type) at =
     ("type mismatch: block requires " ^ string_of_result_type ts2 ^
      " but stack has " ^ string_of_result_type (snd s))
 
+and check_catch (c : context) (cc : catch) (ts : val_type list) at =
+  let match_target = match_resulttype "label" "catch handler" in
+  match cc.it with
+  | Catch (x1, x2) ->
+    let TagT dt = tag c x1 in
+    let FuncT (ts1, ts2) = as_func_str_type (expand_def_type dt) in
+    match_target c ts1 (label c x2) cc.at
+  | CatchRef (x1, x2) ->
+    let TagT dt = tag c x1 in
+    let FuncT (ts1, ts2) = as_func_str_type (expand_def_type dt) in
+    match_target c (ts1 @ [RefT (NoNull, ExnHT)]) (label c x2) cc.at
+  | CatchAll x ->
+    match_target c [] (label c x) cc.at
+  | CatchAllRef x ->
+    match_target c [RefT (NoNull, ExnHT)] (label c x) cc.at
+
 
 (* Functions & Constants *)
 
@@ -945,7 +982,6 @@ let check_func_body (c : context) (f : func) =
     }
   in check_block c' body (InstrT ([], ts2, [])) f.at
 
-
 let is_const (c : context) (e : instr) =
   match e.it with
   | Const _ | VecConst _
@@ -962,7 +998,7 @@ let check_const (c : context) (const : const) (t : val_type) =
   check_block c const.it (InstrT ([], [t], [])) const.at
 
 
-(* Globals, Tables, Memories *)
+(* Globals, Tables, Memories, Tags *)
 
 let check_global (c : context) (glob : global) : context =
   let {gtype; ginit} = glob.it in
@@ -983,6 +1019,11 @@ let check_memory (c : context) (mem : memory) : context =
   check_memory_type c mtype mem.at;
   {c with memories = c.memories @ [mtype]}
 
+let check_tag (c : context) (t : tag) : context =
+  let FuncT (_, ts2) = func_type c t.it.tgtype in
+  require (ts2 = []) t.it.tgtype.at "non-empty tag result type";
+  {c with tags = c.tags @ [TagT (type_ c t.it.tgtype)]}
+
 let check_elem_mode (c : context) (t : ref_type) (mode : segment_mode) =
   match mode.it with
   | Passive -> ()
@@ -1038,6 +1079,9 @@ let check_import (c : context) (im : import) : context =
   | MemoryImport mt ->
     check_memory_type c mt idesc.at;
     {c with memories = c.memories @ [mt]}
+  | TagImport x ->
+    let _ = func_type c x in
+    {c with tags = c.tags @ [TagT (type_ c x)]}
 
 module NameSet = Set.Make(struct type t = Ast.name let compare = compare end)
 
@@ -1048,6 +1092,7 @@ let check_export (c : context) (set : NameSet.t) (ex : export) : NameSet.t =
   | GlobalExport x -> ignore (global c x)
   | TableExport x -> ignore (table c x)
   | MemoryExport x -> ignore (memory c x)
+  | TagExport x -> ignore (tag c x)
   );
   require (not (NameSet.mem name set)) ex.at "duplicate export name";
   NameSet.add name set
@@ -1066,6 +1111,7 @@ let check_module (m : module_) =
     |> check_list check_table m.it.tables
     |> check_list check_memory m.it.memories
     |> check_list check_global m.it.globals
+    |> check_list check_tag m.it.tags
     |> check_list check_elem m.it.elems
     |> check_list check_data m.it.datas
   in
diff --git a/proposals/branch-hinting/Motivation.md b/proposals/branch-hinting/Motivation.md
new file mode 100644
index 0000000000..a8e30d734b
--- /dev/null
+++ b/proposals/branch-hinting/Motivation.md
@@ -0,0 +1,393 @@
+# Proposal motivation
+
+This document has the purpose of explaining better the underlying issues that the proposal
+aim to solve, and why they can't be solved in other ways (for example with better tooling).
+
+# Example code
+
+We will refer to the following example code, which is purposefully simple to make
+the analysis easier. The analysis generalizes for more complex code.
+
+```
+void foo();
+int run(int i) {
+    int ret = 0;
+    int b = 0;
+    while(i) {
+        if(__builtin_expect(b==i-1, 0)) {
+            foo();
+        }
+        b++;
+        ret += b;
+        if(b>=i)
+            break;
+    }
+    return ret;
+}
+```
+
+`__builtin_expect` is a gcc and clang specific builtin that hints the compiler that
+we know that `b==i-1` is very likely to be false.
+
+The compiler can use this information to make better decisions regarding register allocation,
+inlining, code layout, etc...
+
+For example here the compiler may decide that it is not worth it to inline the call to `foo()`,
+and that in the resulting machine code the call should be placed far from the rest of the code.
+
+# Native x86-64 code generation
+
+We can see the effect of `__builtin_expect` when compiling native code by compiling
+first with the expected value `1` and then `0`:
+
+```
+// expected 1
+0000000000000000 :
+   0:	          55                   	push   rbp
+   1:	          41 57                	push   r15
+   3:	          41 56                	push   r14
+   5:	          53                   	push   rbx
+   6:	          50                   	push   rax
+   7:	          41 89 ff             	mov    r15d,edi
+   a:	          85 ff                	test   edi,edi
+   c:	          bb 01 00 00 00       	mov    ebx,0x1
+  11:	          41 be 01 00 00 00    	mov    r14d,0x1
+  17:	          44 0f 4f f7          	cmovg  r14d,edi
+  1b:	          41 f7 de             	neg    r14d
+  1e:	          31 ed                	xor    ebp,ebp
+  20:	   /----> 45 85 ff             	test   r15d,r15d
+  23:	/--|----- 74 21                	je     46 
+  25:	|  |      41 39 df             	cmp    r15d,ebx
+  28:	|  |  /-- 75 05                	jne    2f 
+  2a:	|  |  |   e8 00 00 00 00       	call   2f foo
+  2f:	|  |  \-> 01 dd                	add    ebp,ebx
+  31:	|  |      41 8d 04 1e          	lea    eax,[r14+rbx*1]
+  35:	|  |      83 c0 01             	add    eax,0x1
+  38:	|  |      89 d9                	mov    ecx,ebx
+  3a:	|  |      83 c1 01             	add    ecx,0x1
+  3d:	|  |      89 cb                	mov    ebx,ecx
+  3f:	|  |      83 f8 01             	cmp    eax,0x1
+  42:	|  \----- 75 dc                	jne    20 
+  44:	|     /-- eb 02                	jmp    48 
+  46:	\-----|-> 31 ed                	xor    ebp,ebp
+  48:	      \-> 89 e8                	mov    eax,ebp
+  4a:	          48 83 c4 08          	add    rsp,0x8
+  4e:	          5b                   	pop    rbx
+  4f:	          41 5e                	pop    r14
+  51:	          41 5f                	pop    r15
+  53:	          5d                   	pop    rbp
+  54:	          c3                   	ret
+```
+
+```
+// expected 0
+0000000000000000 :
+   0:	                55                   	push   rbp
+   1:	                41 57                	push   r15
+   3:	                41 56                	push   r14
+   5:	                53                   	push   rbx
+   6:	                50                   	push   rax
+   7:	                41 89 ff             	mov    r15d,edi
+   a:	                85 ff                	test   edi,edi
+   c:	                bb 01 00 00 00       	mov    ebx,0x1
+  11:	                41 be 01 00 00 00    	mov    r14d,0x1
+  17:	                44 0f 4f f7          	cmovg  r14d,edi
+  1b:	                41 f7 de             	neg    r14d
+  1e:	                31 ed                	xor    ebp,ebp
+  20:	            /-> 45 85 ff             	test   r15d,r15d
+  23:	/-----------|-- 74 23                	je     48 
+  25:	|           |   41 39 df             	cmp    r15d,ebx
+  28:	|     /-----|-- 74 17                	je     41 
+  2a:	|  /--|-----|-> 01 dd                	add    ebp,ebx
+  2c:	|  |  |     |   41 8d 04 1e          	lea    eax,[r14+rbx*1]
+  30:	|  |  |     |   83 c0 01             	add    eax,0x1
+  33:	|  |  |     |   89 d9                	mov    ecx,ebx
+  35:	|  |  |     |   83 c1 01             	add    ecx,0x1
+  38:	|  |  |     |   89 cb                	mov    ebx,ecx
+  3a:	|  |  |     |   83 f8 01             	cmp    eax,0x1
+  3d:	|  |  |     \-- 75 e1                	jne    20 
+  3f:	|  |  |  /----- eb 09                	jmp    4a 
+  41:	|  |  \--|----> e8 00 00 00 00       	call   46 foo
+  46:	|  \-----|----- eb e2                	jmp    2a 
+  48:	\--------|----> 31 ed                	xor    ebp,ebp
+  4a:	         \----> 89 e8                	mov    eax,ebp
+  4c:	                48 83 c4 08          	add    rsp,0x8
+  50:	                5b                   	pop    rbx
+  51:	                41 5e                	pop    r14
+  53:	                41 5f                	pop    r15
+  55:	                5d                   	pop    rbp
+  56:	                c3                   	ret
+```
+
+You can see that if the compiler expects the branch to be taken, it puts the call
+with the rest of the loop code, while if it expects it to be not take, it puts it after.
+
+This is to maximise the likelyhood that the most often executed code is in the instruction cache.
+
+# Wasm code generation
+
+When compiling into Wasm, the compiler can still use `__builtin_expect` to make better decisions:
+
+For example it can still decide that inlining the call to `foo()` is not worth it.
+
+But a key difference is that in the case of Wasm, the Wasm code is not the actual machine
+code that the cpu will execute.
+Moreover, Wasm's structured control flow has no 1 to 1 relationship with the final machine code
+that a Wasm engine will generate in tems of code layout.
+
+This means that there is no way that a Wasm compiler can tell a Wasm engine how it would
+like the machine code to be laid out.
+
+The Wasm generated from the above code is the following (regardless of the presence of `__builtin_expect`):
+
+```
+func[2] :
+  local[0..3] type=i32
+  local.get 0
+  i32.const 4294967295
+  i32.add
+  local.set 1
+  local.get 0
+  i32.const 0
+  i32.ne
+  local.set 2
+  i32.const 0
+  local.tee 3
+  local.tee 4
+  loop
+    local.get 2
+    if
+      local.get 4
+      local.get 1
+      i32.eq
+      if
+        call 0 
+      end
+      local.get 4
+      i32.const 1
+      i32.add
+      local.tee 4
+      local.get 3
+      i32.add
+      local.set 3
+      local.get 4
+      local.get 0
+      i32.lt_s
+      br_if 1
+      local.get 3
+      return
+    end
+  end
+  end
+```
+
+And the machine code generated by V8's TurboFan is:
+
+```
+0x3ed39fc0d640     0  55             push rbp
+0x3ed39fc0d641     1  4889e5         REX.W movq rbp,rsp
+0x3ed39fc0d644     4  6a0a           push 0xa
+0x3ed39fc0d646     6  56             push rsi
+0x3ed39fc0d647     7  4883ec20       REX.W subq rsp,0x20
+0x3ed39fc0d64b     b  488b5e23       REX.W movq rbx,[rsi+0x23]
+0x3ed39fc0d64f     f  488945e8       REX.W movq [rbp-0x18],rax
+0x3ed39fc0d653    13  483b23         REX.W cmpq rsp,[rbx]
+0x3ed39fc0d656    16  0f869b000000   jna 0x3ed39fc0d6f7  <+0xb7>
+0x3ed39fc0d65c    1c  83f800         cmpl rax,0x0
+0x3ed39fc0d65f    1f  0f95c3         setnzl bl
+0x3ed39fc0d662    22  0fb6db         movzxbl rbx,rbx
+0x3ed39fc0d665    25  33c9           xorl rcx,rcx
+0x3ed39fc0d667    27  48895dd0       REX.W movq [rbp-0x30],rbx
+0x3ed39fc0d66b    2b  488bd1         REX.W movq rdx,rcx
+0x3ed39fc0d66e    2e  488bf9         REX.W movq rdi,rcx
+0x3ed39fc0d671    31  660f1f840000000000 nop
+0x3ed39fc0d67a    3a  660f1f440000   nop
+0x3ed39fc0d680    40  4c8b4623       REX.W movq r8,[rsi+0x23]
+0x3ed39fc0d684    44  493b20         REX.W cmpq rsp,[r8]
+0x3ed39fc0d687    47  0f867c000000   jna 0x3ed39fc0d709  <+0xc9>
+0x3ed39fc0d68d    4d  837dd000       cmpl [rbp-0x30],0x0
+0x3ed39fc0d691    51  0f8454000000   jz 0x3ed39fc0d6eb  <+0xab>
+0x3ed39fc0d697    57  448d40ff       leal r8,[rax-0x1]
+0x3ed39fc0d69b    5b  443bc7         cmpl r8,rdi
+0x3ed39fc0d69e    5e  0f8539000000   jnz 0x3ed39fc0d6dd  <+0x9d>
+0x3ed39fc0d6a4    64  448b462b       movl r8,[rsi+0x2b]
+0x3ed39fc0d6a8    68  4d03c5         REX.W addq r8,r13
+0x3ed39fc0d6ab    6b  458b4007       movl r8,[r8+0x7]
+0x3ed39fc0d6af    6f  4d03c5         REX.W addq r8,r13
+0x3ed39fc0d6b2    72  4c8b4e2f       REX.W movq r9,[rsi+0x2f]
+0x3ed39fc0d6b6    76  4d8b09         REX.W movq r9,[r9]
+0x3ed39fc0d6b9    79  48894de0       REX.W movq [rbp-0x20],rcx
+0x3ed39fc0d6bd    7d  48897dd8       REX.W movq [rbp-0x28],rdi
+0x3ed39fc0d6c1    81  4c8bd6         REX.W movq r10,rsi
+0x3ed39fc0d6c4    84  498bf0         REX.W movq rsi,r8
+0x3ed39fc0d6c7    87  4d8bc2         REX.W movq r8,r10
+0x3ed39fc0d6ca    8a  41ffd1         call r9
+0x3ed39fc0d6cd    8d  488b45e8       REX.W movq rax,[rbp-0x18]
+0x3ed39fc0d6d1    91  488b4de0       REX.W movq rcx,[rbp-0x20]
+0x3ed39fc0d6d5    95  488b7dd8       REX.W movq rdi,[rbp-0x28]
+0x3ed39fc0d6d9    99  488b75f0       REX.W movq rsi,[rbp-0x10]
+0x3ed39fc0d6dd    9d  83c701         addl rdi,0x1
+0x3ed39fc0d6e0    a0  03cf           addl rcx,rdi
+0x3ed39fc0d6e2    a2  3bf8           cmpl rdi,rax
+0x3ed39fc0d6e4    a4  7c9a           jl 0x3ed39fc0d680  <+0x40>
+0x3ed39fc0d6e6    a6  e907000000     jmp 0x3ed39fc0d6f2  <+0xb2>
+0x3ed39fc0d6eb    ab  33c0           xorl rax,rax
+0x3ed39fc0d6ed    ad  488be5         REX.W movq rsp,rbp
+0x3ed39fc0d6f0    b0  5d             pop rbp
+0x3ed39fc0d6f1    b1  c3             retl
+0x3ed39fc0d6f2    b2  488bc1         REX.W movq rax,rcx
+0x3ed39fc0d6f5    b5  ebf6           jmp 0x3ed39fc0d6ed  <+0xad>
+0x3ed39fc0d6f7    b7  e884fbffff     call 0x3ed39fc0d280     ;; wasm stub: WasmStackGuard
+0x3ed39fc0d6fc    bc  488b45e8       REX.W movq rax,[rbp-0x18]
+0x3ed39fc0d700    c0  488b75f0       REX.W movq rsi,[rbp-0x10]
+0x3ed39fc0d704    c4  e953ffffff     jmp 0x3ed39fc0d65c  <+0x1c>
+0x3ed39fc0d709    c9  48894de0       REX.W movq [rbp-0x20],rcx
+0x3ed39fc0d70d    cd  48897dd8       REX.W movq [rbp-0x28],rdi
+0x3ed39fc0d711    d1  e86afbffff     call 0x3ed39fc0d280     ;; wasm stub: WasmStackGuard
+0x3ed39fc0d716    d6  488b45e8       REX.W movq rax,[rbp-0x18]
+0x3ed39fc0d71a    da  488b4de0       REX.W movq rcx,[rbp-0x20]
+0x3ed39fc0d71e    de  488b7dd8       REX.W movq rdi,[rbp-0x28]
+0x3ed39fc0d722    e2  488b75f0       REX.W movq rsi,[rbp-0x10]
+0x3ed39fc0d726    e6  e962ffffff     jmp 0x3ed39fc0d68d  <+0x4d>
+0x3ed39fc0d72b    eb  90             nop
+```
+
+As you can see the call to `foo()` (`call r9`) is in the middle of the loop code.
+
+Is there a way to produce different Wasm code which will result in the call being after
+the rest of the loop code?
+
+No, because:
+
+- the call is part of the loop
+- Wasm loops can only have one entry point
+
+Therefore it is impossible in Wasm to have some code part of a loop moved after it,
+because it would cause irreducible control flow.
+
+Of course we could introduce irreducible control flow and then turn it into reducible control flow
+again (Wasm compilers already must be able to do this), but there are only two way of
+fixing the irreducible control flow: duplicating the code or introducing a new variable
+to direct the control flow:
+
+- The first alternative is not feasible in the general case because the code duplication
+can incur in exponential blowup
+
+- The second is feasible but introduces so much overhead that it defeats the purpose
+
+# Branch Hinting proposal
+
+The underlying problem is that there is a gap of information between the high level source code
+and the final machine code that the engine runs.
+
+The Branch Hinting proposal aims to close the gap by explicitly passing on the missing information
+to the engine.
+
+As a matter of fact, V8 already has the concept of "branch hinting": It is used internally
+to produce better code in the presence of unlikely conditions.
+
+It is also currently used to implement the experimental `br_on_null` instruction (with the assumption
+that it is unlikely to be null).
+
+These of course are implementation details, but they hint at the fact that this functionality
+is valuable.
+
+Without this proposal, performance sesitive applications that benefits from branch hinting
+may have to rely on internal engine behavior to achieve maximum performance.
+
+For example the CheerpX virtual machine is currently experimenting with using br_on_null to take advantage of internal branch hinting in V8.
+Even though this solution is inefficient the performance gains are nonetheless significant.
+Proper support for branch hinting would improve the performance even more.
+
+# Wasm code generation with branch hinting
+
+The V8 POC with branch hinting support produces the following machine code for our example code:
+
+```
+0xfe77b01d640     0  55             push rbp
+0xfe77b01d641     1  4889e5         REX.W movq rbp,rsp
+0xfe77b01d644     4  6a0a           push 0xa
+0xfe77b01d646     6  56             push rsi
+0xfe77b01d647     7  4883ec20       REX.W subq rsp,0x20
+0xfe77b01d64b     b  488b5e23       REX.W movq rbx,[rsi+0x23]
+0xfe77b01d64f     f  483b23         REX.W cmpq rsp,[rbx]
+0xfe77b01d652    12  0f8656000000   jna 0xfe77b01d6ae  <+0x6e>
+0xfe77b01d658    18  83f800         cmpl rax,0x0
+0xfe77b01d65b    1b  0f95c3         setnzl bl
+0xfe77b01d65e    1e  0fb6db         movzxbl rbx,rbx
+0xfe77b01d661    21  33c9           xorl rcx,rcx
+0xfe77b01d663    23  488bd1         REX.W movq rdx,rcx
+0xfe77b01d666    26  488bf9         REX.W movq rdi,rcx
+0xfe77b01d669    29  0f1f8000000000 nop
+0xfe77b01d670    30  4c8b4623       REX.W movq r8,[rsi+0x23]
+0xfe77b01d674    34  493b20         REX.W cmpq rsp,[r8]
+0xfe77b01d677    37  0f8644000000   jna 0xfe77b01d6c1  <+0x81>
+0xfe77b01d67d    3d  83fb00         cmpl rbx,0x0
+0xfe77b01d680    40  0f841b000000   jz 0xfe77b01d6a1  <+0x61>
+0xfe77b01d686    46  448d40ff       leal r8,[rax-0x1]
+0xfe77b01d68a    4a  443bc7         cmpl r8,rdi
+0xfe77b01d68d    4d  0f845b000000   jz 0xfe77b01d6ee  <+0xae>
+0xfe77b01d693    53  83c701         addl rdi,0x1
+0xfe77b01d696    56  03cf           addl rcx,rdi
+0xfe77b01d698    58  3bf8           cmpl rdi,rax
+0xfe77b01d69a    5a  7cd4           jl 0xfe77b01d670  <+0x30>
+0xfe77b01d69c    5c  e908000000     jmp 0xfe77b01d6a9  <+0x69>
+0xfe77b01d6a1    61  488bc2         REX.W movq rax,rdx
+0xfe77b01d6a4    64  488be5         REX.W movq rsp,rbp
+0xfe77b01d6a7    67  5d             pop rbp
+0xfe77b01d6a8    68  c3             retl
+0xfe77b01d6a9    69  488bc1         REX.W movq rax,rcx
+0xfe77b01d6ac    6c  ebf6           jmp 0xfe77b01d6a4  <+0x64>
+0xfe77b01d6ae    6e  488945e8       REX.W movq [rbp-0x18],rax
+0xfe77b01d6b2    72  e8c9fbffff     call 0xfe77b01d280       ;; wasm stub: WasmStackGuard
+0xfe77b01d6b7    77  488b45e8       REX.W movq rax,[rbp-0x18]
+0xfe77b01d6bb    7b  488b75f0       REX.W movq rsi,[rbp-0x10]
+0xfe77b01d6bf    7f  eb97           jmp 0xfe77b01d658  <+0x18>
+0xfe77b01d6c1    81  488945e8       REX.W movq [rbp-0x18],rax
+0xfe77b01d6c5    85  48894de0       REX.W movq [rbp-0x20],rcx
+0xfe77b01d6c9    89  48897dd8       REX.W movq [rbp-0x28],rdi
+0xfe77b01d6cd    8d  48895dd0       REX.W movq [rbp-0x30],rbx
+0xfe77b01d6d1    91  e8aafbffff     call 0xfe77b01d280       ;; wasm stub: WasmStackGuard
+0xfe77b01d6d6    96  33d2           xorl rdx,rdx
+0xfe77b01d6d8    98  488b45e8       REX.W movq rax,[rbp-0x18]
+0xfe77b01d6dc    9c  488b4de0       REX.W movq rcx,[rbp-0x20]
+0xfe77b01d6e0    a0  488b7dd8       REX.W movq rdi,[rbp-0x28]
+0xfe77b01d6e4    a4  488b75f0       REX.W movq rsi,[rbp-0x10]
+0xfe77b01d6e8    a8  488b5dd0       REX.W movq rbx,[rbp-0x30]
+0xfe77b01d6ec    ac  eb8f           jmp 0xfe77b01d67d  <+0x3d>
+0xfe77b01d6ee    ae  448b462b       movl r8,[rsi+0x2b]
+0xfe77b01d6f2    b2  4d03c5         REX.W addq r8,r13
+0xfe77b01d6f5    b5  458b4007       movl r8,[r8+0x7]
+0xfe77b01d6f9    b9  4d03c5         REX.W addq r8,r13
+0xfe77b01d6fc    bc  4c8b4e2f       REX.W movq r9,[rsi+0x2f]
+0xfe77b01d700    c0  4d8b09         REX.W movq r9,[r9]
+0xfe77b01d703    c3  488945e8       REX.W movq [rbp-0x18],rax
+0xfe77b01d707    c7  48894de0       REX.W movq [rbp-0x20],rcx
+0xfe77b01d70b    cb  48897dd8       REX.W movq [rbp-0x28],rdi
+0xfe77b01d70f    cf  48895dd0       REX.W movq [rbp-0x30],rbx
+0xfe77b01d713    d3  4c8bd6         REX.W movq r10,rsi
+0xfe77b01d716    d6  498bf0         REX.W movq rsi,r8
+0xfe77b01d719    d9  4d8bc2         REX.W movq r8,r10
+0xfe77b01d71c    dc  41ffd1         call r9
+0xfe77b01d71f    df  33d2           xorl rdx,rdx
+0xfe77b01d721    e1  488b45e8       REX.W movq rax,[rbp-0x18]
+0xfe77b01d725    e5  488b4de0       REX.W movq rcx,[rbp-0x20]
+0xfe77b01d729    e9  488b7dd8       REX.W movq rdi,[rbp-0x28]
+0xfe77b01d72d    ed  488b75f0       REX.W movq rsi,[rbp-0x10]
+0xfe77b01d731    f1  488b5dd0       REX.W movq rbx,[rbp-0x30]
+0xfe77b01d735    f5  e959ffffff     jmp 0xfe77b01d693  <+0x53>
+0xfe77b01d73a    fa  90             nop
+0xfe77b01d73b    fb  90             nop
+```
+
+As you can see the call to `foo()` (`call r9`) is laid out after the rest of the loop code.
+
+As a result, the hinted version runs ~25% faster than the non-hinted one.
+
+Of course real world code is more complex and probably doing some real computation
+instead of just adding numbers in a tight loop. The actual performance gain will
+depend heavily on the specific code, and how good the assumptions about the likeness
+of a branch are.
+
+Techniques like Performance Guided Optimization can also make use of this feature
+and provide more precise hints.
diff --git a/proposals/branch-hinting/Overview.md b/proposals/branch-hinting/Overview.md
new file mode 100644
index 0000000000..dedd4b4c8c
--- /dev/null
+++ b/proposals/branch-hinting/Overview.md
@@ -0,0 +1,130 @@
+# Branch hinting
+
+## Introduction
+
+### Motivation
+
+The motivation for this proposal is to improve the performance of the compiled wasm
+code, by informing the engine that a particular branch instruction is very likely to take
+a specific path.
+
+This allows the engine to make better decisions for code layout (improving instruction cache hits)
+and register allocation.
+
+See [Motivation](/proposals/branch-hinting/Motivation.md) for more information.
+
+
+### Background
+
+This proposal has first been presented here:
+
+https://github.com/WebAssembly/design/issues/1363
+
+This topic was preliminarily discussed at the CG-09-29 meeting:
+
+https://github.com/WebAssembly/meetings/blob/master/main/2020/CG-09-29.md
+
+The consensus seemed to be to proceed with the idea, but to present some benchmarks
+to prove the need for the proposal.
+
+A [preliminary benchmark](/benchmarks) showed that the proposal is worth investigating
+
+The proposal was accepted for phase 1 at the CG-11-10 meeting:
+
+https://github.com/WebAssembly/meetings/blob/master/main/2020/CG-11-10.md
+
+Discussion about how to implement the proposal happened in this issue:
+
+https://github.com/WebAssembly/branch-hinting/issues/1
+
+And some more discussion and feedback on the custom section format was done in the CG-01-05:
+
+https://github.com/WebAssembly/meetings/blob/master/main/2021/CG-01-05.md
+
+After that, a tentative spec was written and there was further discussion in CG-02-16:
+
+https://github.com/WebAssembly/meetings/blob/master/main/2021/CG-02-16.md
+
+And in CG-03-02:
+
+https://github.com/WebAssembly/meetings/blob/main/main/2021/CG-03-02.md
+
+Finally after working on the feedback received, a poll for phase 2 was made, and passed, in CG-03-16:
+
+https://github.com/WebAssembly/meetings/blob/main/main/2021/CG-03-16.md
+
+The feature landed in V8 92 under an experimental flag, and the CheerpX virtual machine started using it,
+with measurable performance improvements. The results were shown in CG-06-08, plus the start of
+a discussion about testing requirements for phase 3:
+
+https://github.com/WebAssembly/meetings/blob/main/main/2021/CG-06-08.md
+
+After the Instrument and Tracing Proposal passed to phase 2 in CG-07-20, the CG felt the need to
+have a framework for standardizing proposals that use custom section as a way to hint the code
+without altering the semantics. Ongoing discussion is in a design issue:
+
+https://github.com/WebAssembly/design/issues/1424
+
+The result of that discussion prompted the design of Code Annotations, presented in CG-08-17:
+
+https://github.com/WebAssembly/meetings/blob/main/main/2021/CG-08-17.md
+
+and in CG-09-28:
+
+https://github.com/WebAssembly/meetings/blob/main/main/2021/CG-09-28.md
+
+Branch hinting adpoted the Code Annotation format and an update about the new format
+and the current status of the proposal, as well as a poll for phase 3 (which passed)
+ was held on CG-11-09:
+
+https://github.com/WebAssembly/meetings/blob/main/main/2021/CG-11-09.md
+
+
+
+### Design
+
+The *branch hint section* is a **custom section** whose name string is `metadata.code.branch_hint`.
+The branch hints section should appear only once in a module, and only before the code section.
+
+The purpose of this section is to aid the compilation of conditional branch instructions, by providing a hint that a branch is very likely (or unlikely) to be taken.
+
+The section contains a vector of *function branch hints* each representing the branch hints for a single function.
+
+Each *function branch hints* structure consists of
+
+* the function index of the function the hints are referring to,
+* a vector of *branch hint* for the function.
+
+Elements of the vector of *function branch hints* must appear in increasing function index order,
+and a function index can appear at most once.
+
+Each *branch hint* structure consists of
+
+* the |U32| byte offset of the hinted instruction, relative to the beginning of the function locals declaration,
+* A |U32| with value `1`,
+* a |U32| indicating the meaning of the hint:
+
+| value | meaning           |
+|-------|-------------------|
+| 0     | likely not taken  |
+| 1     | likely  taken     |
+
+Elements of the vector of *branch hint* must appear in increasing byte offset order,
+and a byte offset can appear at most once. A |BRIF| or |IF| instruction must be present
+in the code section at the specified offset.
+
+#### Annotations
+
+*Branch Hint annotations* are the textual analogue to the branch hint section and provide a textual representation for it.
+Consequently, their id is :math:`@metadata.code.branch_hint`.
+
+Branch hint annotations are allowed only on |BRIF| and |IF| instructions,
+and at most one branch hint annotation may be given per instruction.
+
+Branch hint annotations have the following format:
+
+```
+(@metadata.code.branch_hint "\00" | "\01")
+```
+
+See the [the spec](/document/core/appendix/custom.rst) for the formal notation.
diff --git a/proposals/exception-handling/Exceptions.md b/proposals/exception-handling/Exceptions.md
new file mode 100644
index 0000000000..d982592ced
--- /dev/null
+++ b/proposals/exception-handling/Exceptions.md
@@ -0,0 +1,470 @@
+# Exception handling
+
+This explainer reflects the up-to-date version of the exception handling
+proposal agreed on [Oct 2023 CG
+meeting](https://github.com/WebAssembly/meetings/blob/main/main/2023/CG-10.md#exception-handling-vote-on-proposal-to-re-introduce-exnref).
+
+---
+
+## Overview
+
+Exception handling allows code to break control flow when an exception is
+thrown. The exception can be any exception known by the WebAssembly module, or
+it may an unknown exception that was thrown by a called imported function.
+
+One of the problems with exception handling is that both WebAssembly and an
+embedder have different notions of what exceptions are, but both must be aware
+of the other.
+
+It is difficult to define exceptions in WebAssembly because (in general) it
+doesn't have knowledge of any embedder. Further, adding such knowledge to
+WebAssembly would limit the ability for other embedders to support WebAssembly
+exceptions.
+
+One issue is that both sides need to know if an exception was thrown by the
+other, because cleanup may need to be performed.
+
+Another problem is that WebAssembly doesn't have direct access to an embedder's
+memory. As a result, WebAssembly defers the handling of exceptions to the host
+VM.
+
+To access exceptions, WebAssembly provides instructions to check if the
+exception is one that WebAssembly understands. If so, the data of the
+WebAssembly exception is extracted and copied onto the stack, allowing
+succeeding instructions to process the data.
+
+A WebAssembly exception is created when you throw it with the `throw`
+instruction. Thrown exceptions are handled as follows:
+
+1. They can be caught by one of the *catch clauses* in an enclosing try block of
+   a function body.
+
+1. Throws not caught within a function body continue up the call stack, popping
+   call frames, until an enclosing try block is found.
+
+1. If the call stack is exhausted without any enclosing try blocks, the embedder
+   defines how to handle the uncaught exception.
+
+### Exception handling
+
+This proposal adds exception handling to WebAssembly. Part of this proposal is
+to define a new section to declare exceptions. However, rather than limiting
+this new section to just defining exceptions, it defines a more general format
+`tag` that allows the declaration of other forms of typed tags in future.
+
+WebAssembly tags are defined in a new `tag` section of a WebAssembly module. The
+tag section is a list of declared tags that are created fresh each time the
+module is instantiated.
+
+Each tag has an `attribute` and a `type`. Currently, the attribute can only
+specify that the tag is for an exception. In the future, additional attribute
+values may be added when other kinds of tags are added to WebAssembly.
+
+To allow for such a future extension possibility, we reserve a byte in the
+binary format of an exception definition, set to 0 to denote an exception
+attribute.
+
+### Exceptions
+
+An `exception tag` is a value to distinguish different exceptions, while an
+`exception tag index` is a numeric name to refer to an (imported or defined)
+exception tag within a module (see [tag index space](#tag-index-space) for
+details). Exception tags are declared in the tag and import sections of a
+module.
+
+An `exception` is an internal construct in WebAssembly that represents a runtime
+object that can be thrown. A WebAssembly exception consists of an exception tag
+and its runtime arguments.
+
+The type of an exception tag is denoted by an index to a function signature
+defined in the `type` section. The parameters of the function signature define
+the list of argument values associated with the tag. The result type must be
+empty.
+
+Exception tag indices are used by:
+
+1. The `throw` instruction which creates a WebAssembly exception with the
+   corresponding exception tag, and then throws it.
+
+2. Catch clauses use a tag to identify the thrown exception it can catch. If it
+   matches, it pushes the corresponding argument values of the exception onto
+   the stack.
+
+### Exception references
+
+When caught, an exception is reified into an _exception reference_, a value of
+the new type `exnref`. Exception references can be used to rethrow the caught
+exception.
+
+### Try blocks
+
+A _try block_ defines a list of instructions that may need to process exceptions
+and/or clean up state when an exception is thrown. Like other higher-level
+constructs, a try block begins with a `try_table` instruction, and ends with an
+`end` instruction. That is, a try block is sequence of instructions having the
+following form:
+
+```
+try_table blocktype catch*
+  instruction*
+end
+```
+
+A try block contains zero or more _catch clauses_. If there are no catch
+clauses, then the try block does not catch any exceptions.
+
+The _body_ of the try block is the list of instructions after the last catch
+clause, if any.
+
+Each `catch` clause can be in one of 4 forms:
+```
+catch tag label
+catch_ref tag label
+catch_all label
+catch_all_ref label
+```
+All forms have a label which is branched to when an exception is caught (see
+below). The former two forms have an exception tag associated with it that
+identifies what exceptions it will catch. The latter two forms catch any
+exception, so that they can be used to define a _default_ handler.
+
+Try blocks, like control-flow blocks, have a _block type_. The block type of a
+try block defines the values yielded by evaluating the try block when either no
+exception is thrown, or the exception is successfully caught by the catch
+clause. Because `try_table` defines a control-flow block, it can be targets for
+branches (`br` and `br_if`) as well.
+
+### Throwing an exception
+
+The `throw` instruction takes an exception tag index as an immediate argument.
+That index is used to identify the exception tag to use to create and throw the
+corresponding exception.
+
+The values on top of the stack must correspond to the type associated with the
+exception tag. These values are popped off the stack and are used (along with
+the corresponding exception tag) to create the corresponding exception. That
+exception is then thrown.
+
+When an exception is thrown, the embedder searches for the nearest enclosing try
+block body that execution is in. That try block is called the _catching_ try
+block.
+
+If the throw appears within the body of a try block, it is the catching try
+block.
+
+If a throw occurs within a function body, and it doesn't appear inside the body
+of a try block, the throw continues up the call stack until it is in the body of
+an an enclosing try block, or the call stack is flushed. If the call stack is
+flushed, the embedder defines how to handle uncaught exceptions. Otherwise, the
+found enclosing try block is the catching try block.
+
+Once a catching try block is found for the thrown exception, the operand stack
+is popped back to the size the operand stack had when the try block was entered
+after possible block parameters were popped.
+
+Then catch clauses are tried in the order they appear in the catching try block,
+until one matches. If a matching catch clause is found, control is transferred
+to the label of that catch clause. In case of `catch` or `catch_ref`, the
+arguments of the exception are pushed back onto the stack. For `catch_ref` and
+`catch_all_ref`, an exception reference is then pushed to the stack, which
+represents the caught exception.
+
+If no catch clauses were matched, the exception is implicitly rethrown.
+
+Note that a caught exception can be rethrown explicitly using the `exnref` and
+the `throw_ref` instruction.
+
+### Rethrowing an exception
+
+The `throw_ref` takes an operand of type `exnref` and re-throws the
+corresponding caught exception. If the operand is null, a trap occurs.
+
+### JS API
+
+#### Traps
+
+Catch clauses handle exceptions generated by the `throw` instruction, but do not
+catch traps. The rationale for this is that in general traps are not locally
+recoverable and are not needed to be handled in local scopes like try blocks.
+
+The `try_table` instruction catches foreign exceptions generated from calls to
+function imports as well, including JavaScript exceptions, with a few
+exceptions:
+1. In order to be consistent before and after a trap reaches a JavaScript frame,
+   the `try_table` instruction does not catch exceptions generated from traps.
+1. The `try_table` instruction does not catch JavaScript exceptions generated
+   from stack overflow and out of memory.
+
+Filtering these exceptions should be based on a predicate that is not observable
+by JavaScript. Traps currently generate instances of
+[`WebAssembly.RuntimeError`](https://webassembly.github.io/reference-types/js-api/#exceptiondef-runtimeerror),
+but this detail is not used to decide type. Implementations are supposed to
+specially mark non-catchable exceptions.
+([`instanceof`](https://tc39.es/ecma262/#sec-instanceofoperator) predicate can
+be intercepted in JS, and types of exceptions generated from stack overflow and
+out of memory are implementation-defined.)
+
+#### API additions
+
+The following additional classes are added to the JS API in order to allow
+JavaScript to interact with WebAssembly exceptions:
+
+  * `WebAssembly.Tag`
+  * `WebAssembly.Exception`
+
+The `WebAssembly.Tag` class represents a typed tag defined in the tag section
+and exported from a WebAssembly module. It allows querying the type of a tag
+following the [JS type reflection
+proposal](https://github.com/WebAssembly/js-types/blob/master/proposals/js-types/Overview.md).
+Constructing an instance of `Tag` creates a fresh tag, and the new tag can be
+passed to a WebAssembly module as a tag import.
+
+In the future, `WebAssembly.Tag` may be used for other proposals that require a
+typed tag and its constructor may be extended to accept other types and/or a tag
+attribute to differentiate them from tags used for exceptions.
+
+The `WebAssembly.Exception` class represents an exception thrown from
+WebAssembly, or an exception that is constructed in JavaScript and is to be
+thrown to a WebAssembly exception handler. The `Exception` constructor accepts a
+`Tag` argument and a sequence of arguments for the exception's data fields. The
+`Tag` argument determines the exception tag to use. The data field arguments
+must match the types specified by the `Tag`'s type. The `is` method can be used
+to query if the `Exception` matches a given tag. The `getArg` method allows
+access to the data fields of a `Exception` if a matching tag is given. This last
+check ensures that without access to a WebAssembly module's exported exception
+tag, the associated data fields cannot be read.
+
+The `Exception` constructor can take an optional `ExceptionOptions` argument,
+which can optionally contain `traceStack` entry. When `traceStack` is `true`,
+JavaScript VMs are permitted to attach a stack trace string to `Exception.stack`
+field, as in JavaScript's `Error` class. `traceStack` serves as a request to the
+WebAssembly engine to attach a stack trace; it is not necessary to honour if
+`true`, but `trace` may not be populated if `traceStack` is `false`. While
+`Exception` is not a subclass of JavaScript's `Error` and it can be used to
+represent normal control flow constructs, `traceStack` field can be set when we
+use it to represent errors. The format of stack trace strings conform to the
+[WebAssembly stack trace
+conventions](https://webassembly.github.io/spec/web-api/index.html#conventions).
+When `ExceptionOption` is not provided or it does not contain `traceStack`
+entry, `traceStack` is considered `false` by default.
+
+To preserve stack trace info when crossing the JS to Wasm boundary, exceptions
+can internally contain a stack trace, which is propagated when caught by a
+`catch[_all]_ref` clause and rethrown by `throw_ref`.
+
+More formally, the added interfaces look like the following:
+
+```WebIDL
+dictionary TagType {
+  required sequence parameters;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+interface Tag {
+  constructor(TagType type);
+  TagType type();
+};
+
+dictionary ExceptionOptions {
+  boolean traceStack = false;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+interface Exception {
+  constructor(Tag tag, sequence payload, optional ExceptionOptions options);
+  any getArg(Tag tag, unsigned long index);
+  boolean is(Tag tag);
+  readonly attribute (DOMString or undefined) stack;
+};
+```
+
+`TagType` corresponds to a `FunctionType` in [the type reflection
+proposal](https://github.com/WebAssembly/js-types/blob/main/proposals/js-types/Overview.md),
+without a `results` property). `TagType` could be extended in the future for
+other proposals that require a richer type specification.
+
+## Changes to the text format
+
+This section describes change in the [instruction syntax
+document](https://github.com/WebAssembly/spec/blob/master/document/core/text/instructions.rst).
+
+### New instructions
+
+The following rules are added to *instructions*:
+
+```
+  try_table blocktype catch* instruction* end |
+  throw tag_index |
+  throw_ref label |
+```
+
+Like the `block`, `loop`, and `if` instructions, the `try_table` instruction is
+*structured* control flow instruction, and can be labeled. This allows branch
+instructions to exit try blocks.
+
+The `tag_index` of the `throw` and `catch[_ref]` clauses denotes the exception
+tag to use when creating/extract from an exception. See [tag index
+space](#tag-index-space) for further clarification of exception tags.
+
+## Changes to Modules document
+
+This section describes change in the [Modules
+document](https://github.com/WebAssembly/design/blob/master/Modules.md).
+
+### Tag index space
+
+The `tag index space` indexes all imported and internally-defined exception
+tags, assigning monotonically-increasing indices based on the order defined in
+the import and tag sections. Thus, the index space starts at zero with imported
+tags, followed by internally-defined tags in the [tag section](#tag-section).
+
+For tag indices that are not imported/exported, the corresponding exception tag
+is guaranteed to be unique over all loaded modules. Exceptions that are imported
+or exported alias the respective exceptions defined elsewhere, and use the same
+tag.
+
+## Changes to the binary model
+
+This section describes changes in the [binary encoding design
+document](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md).
+
+#### Other Types
+
+##### exnref
+
+The type `exnref` is represented by the type opcode `-0x17`.
+
+When combined with the [GC
+proposal](https://github.com/WebAssembly/gc/blob/main/proposals/gc/MVP.md),
+there also is a value type `nullexnref` with opcode `-0x0c`. Furthermore, these
+opcodes also function as heap type, i.e., `exn` is a new heap type with opcode
+`-0x17`, and `noexn` is a new heap type with opcode `-0x0c`; `exnref` and
+`nullexnref` are shorthands for `(ref null exn)` and `(ref null noexn)`,
+respectively.
+
+The heap type `noexn` is a subtype of `exn`. They are not in a subtype relation
+with any other type (except bottom), such that they form a new disjoint
+hierarchy of heap types.
+
+
+##### tag_type
+
+We reserve a bit to denote the exception attribute:
+
+| Name      | Value |
+|-----------|-------|
+| Exception | 0     |
+
+Each tag type has the fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `attribute` | `uint8` | The attribute of a tag. |
+| `type` | `varuint32` | The type index for its corresponding type signature |
+
+##### external_kind
+
+A single-byte unsigned integer indicating the kind of definition being imported
+or defined:
+
+* `4` indicating a `Tag`
+[import](https://github.com/WebAssembly/design/blob/main/BinaryEncoding.md#import-section) or
+[definition](#tag-section)
+
+### Module structure
+
+#### High-level structure
+
+A new `tag` section is introduced.
+
+##### Tag section
+
+The `tag` section comes after the [memory
+section](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#memory-section)
+and before the [global
+section](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#global-section).
+So the list of all sections will be:
+
+| Section Name | Code | Description |
+| ------------ | ---- | ----------- |
+| Type | `1` | Function signature declarations |
+| Import | `2` | Import declarations |
+| Function | `3` | Function declarations |
+| Table | `4` | Indirect function table and other tables |
+| Memory | `5` | Memory attributes |
+| Tag | `13` | Tag declarations |
+| Global | `6` | Global declarations |
+| Export | `7` | Exports |
+| Start | `8` | Start function declaration |
+| Element | `9` | Elements section |
+| Data count | `12` | Data count section |
+| Code | `10` | Function bodies (code) |
+| Data | `11` | Data segments |
+
+The tag section declares a list of tag types as follows:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| count | `varuint32` | count of the number of tags to follow |
+| type | `tag_type*` | The definitions of the tag types |
+
+##### Import section
+
+The import section is extended to include tag definitions by extending an
+`import_entry` as follows:
+
+If the `kind` is `Tag`:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `type` | `tag_type` | the tag being imported |
+
+##### Export section
+
+The export section is extended to reference tag types by extending an
+`export_entry` as follows:
+
+If the `kind` is `Tag`:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `index` | `varuint32` | the index into the corresponding tag index space |
+
+##### Name section
+
+The set of known values for `name_type` of a name section is extended as
+follows:
+
+| Name Type | Code | Description |
+| --------- | ---- | ----------- |
+| [Function](#function-names) | `1` | Assigns names to functions |
+| [Local](#local-names) | `2` | Assigns names to locals in functions |
+| [Tag](#tag-names) | `11` | Assigns names to tags |
+
+###### Tag names
+
+The tag names subsection is a `name_map` which assigns names to a subset of the
+tag indices (Used for both imports and module-defined).
+
+### Control flow instructions
+
+The control flow instructions are extended to define try blocks and throws as
+follows:
+
+| Name | Opcode | Immediates | Description |
+| ---- | ---- | ---- | ---- |
+| `try_table` | `0x1f` | sig : `blocktype`, n : `varuint32`, catch : `catch^n` | begins a block which can handle thrown exceptions |
+| `throw` | `0x08` | index : `varuint32` | Creates an exception defined by the tag and then throws it |
+| `throw_ref` | `0x0a` | | Pops an `exnref` from the stack and throws it |
+
+The *sig* fields of `block`, `if`, and `try_table` instructions are block types
+which describe their use of the operand stack.
+
+A `catch` handler is a pair of tag and label index:
+
+| Name    | Opcode | Immediates |
+| ------- | ------ | ----------- |
+| `catch` | `0x00` | tag : `varuint32`, label : `varuint32` |
+| `catch_ref` | `0x01` | tag : `varuint32`, label : `varuint32` |
+| `catch_all` | `0x02` | label : `varuint32` |
+| `catch_all_ref` | `0x03` | label : `varuint32` |
diff --git a/proposals/exception-handling/legacy/Exceptions-formal-examples.md b/proposals/exception-handling/legacy/Exceptions-formal-examples.md
new file mode 100644
index 0000000000..5beb6d9aa8
--- /dev/null
+++ b/proposals/exception-handling/legacy/Exceptions-formal-examples.md
@@ -0,0 +1,370 @@
+# 3rd Proposal Formal Spec Examples
+
+This document contains WebAssembly code examples mentioned in comments on this repository, and what they reduce to, according to the ["3rd proposal formal spec overview"](Exceptions-formal-overview.md).
+
+Its purpose is to make sure everyone is happy with the implications of the semantics in the current 3rd proposal, or to aid discussions on these semantics.
+
+The first *example 0* contains all the new instructions, and it is the only one with an almost full reduction displayed. It is meant to easily show how the spec works, even if the reader has not spent much time with the WebAssembly formal spec.
+
+For all other examples just the result of the reduction is given. These examples are taken from comments in this repository, which are linked. Sometimes/often the examples are modified to fit the current syntax.
+
+If anyone would like that I add another reduction trace, or other examples, please let me know, I'd be happy to.
+
+### Notation
+
+If `x` is an exception tag index, then `a_x` denotes its exception tag address, i.e., `a_x := F.tag[x]`, where `F` is the current frame.
+
+Note that the block contexts and throw contexts given for the reductions are the largest possible in each case, so the reduction steps are the only possible ones.
+
+## Example 0
+
+The only example with an almost full reduction trace, and all new instructions. Such explicit reduction steps are only shown in Example 4 and Example 5, to highlight the reduction step of the administrative `delegate`.
+
+In the following reduction, we don't show the first 4 steps, which just reduce the several `try`s and the `throw $x` to their respective administrative instructions. The type of the tag `$x` here is `[]→[]`.
+
+```
+(tag $x)
+(func (result i32) (local i32)
+  try (result i32)
+    try
+      try
+        throw $x
+      catch_all
+        i32.const 27
+        local.set 0
+        rethrow 0
+      end
+    delegate 0
+  catch $x
+    local.get 0
+  end)
+```
+
+We write the body of this function in folded form, because it is easier to parse.
+
+```
+(try (result i32)
+  (do
+    (try
+      (do
+        (try
+          (do
+            (throw $x))
+          (catch_all
+            (local.set 0 (i32.const 27))
+            (rethrow 0))))
+      (delegate 0)))
+  (catch $x
+    (local.get 0)))
+```
+
+Take the frame `F = (locals i32.const 0, module m)`. We have:
+
+```
+↪ ↪ ↪
+↪ F; (label_1{}
+        (handler_1{ (a_x (local.get 0)) }
+          (label_0{}
+            (handler_0{ 0 }
+              (label_0{}
+                (handler_0{ (ε (local.set 0 (i32.const 27)) (rethrow 0)) }
+                  (throw a_x) end) end) end) end) end) end)
+```
+
+For the trivial throw context `T = [_]` the above is the same as
+
+```
+↪ F; (label_1{}
+        (handler_1{ (a_x (local.get 0)) }
+          (label_0{}
+            (handler_0{ 0 }
+              (label_0{}
+                (handler_0{ (ε (local.set 0 (i32.const 27)) (rethrow 0)) }
+                  T[(throw a_x)]) end) end) end) end) end)
+
+↪ F; (label_1{}
+        (handler_1{ (a_x (local.get 0)) }
+          (label_0{}
+            (handler_0{ 0 }
+              (label_0{}
+                (caught_0{ a_x ε }
+                  (local.set 0 (i32.const 27))
+                  (rethrow 0) end) end) end) end) end) end)
+```
+
+Let `F'` be the frame `{locals i32.const 27, module m}`, and let `B^0 = [_]` to reduce `rethrow 0`.
+
+```
+↪ F'; (label_1{}
+         (handler_1{ (a_x (local.get 0)) }
+           (label_0{}
+             (handler_0{ 0 }
+               (label_0{}
+                 (caught_0{ a_x ε }
+                   B^0[ (rethrow 0) ] end) end) end) end) end) end)
+
+↪ F'; (label_1{}
+         (handler_1{ (a_x (local.get 0)) }
+           (label_0{}
+             (handler_0{ 0 }
+               (label_0{}
+                 (caught_0{ a_x ε }
+                   (throw a_x) end) end) end) end) end) end)
+```
+
+Let `T' = (label_0{} (caught_0{ a_x ε } [_] end) end)` and use the same `B^0` as above to reduce the throw with the delegate.
+
+```
+↪ F'; (label_1{}
+         (handler_1{ (a_x (local.get 0)) }
+           (label_0{}
+             B^0[ (handler_0{ 0 } T'[ (throw a_x) ] end) ] end) end) end)
+
+↪ F'; (label_1{}
+         (handler_1{ (a_x (local.get 0)) }
+           (throw a_x) end) end)
+```
+
+Use the trivial throw context `T` again, this time to match the throw to the `handler_1{(...)}`.
+
+```
+↪ F'; (label_1{}
+         (handler_1{ (a_x (local.get 0)) }
+           T[ (throw a_x) ] end) end)
+
+↪ F'; (label_1{}
+         (caught_0{ a_x ε }
+           (local.get 0) end) end)
+
+↪ F'; (label_1{}
+         (caught_0{ a_x ε }
+           (i32.const 27) end) end)
+
+↪ F'; (label_1{}
+         (i32.const 27) end)
+
+↪ F'; (i32.const 27)
+```
+
+## Behavior of `rethrow`
+
+### Example 1
+
+Location of a rethrown exception. Let `x, y, z` be tag indices of tags with type `[t_x]→[]`, `[t_y]→[]`, and `[t_z]→[]` respectively. Let `val_p : t_p` for every `p` among `x, y, z`.
+
+```
+try $label2
+  val_x
+  throw $x
+catch $x
+  try
+    val_y
+    throw y
+  catch_all
+    try
+      val_z
+      throw z
+    catch z
+      rethrow $label2 ;; This is rethrow 2.
+    end
+  end
+end
+```
+
+Folded it looks as follows.
+
+```
+(try
+  (do
+    val_x
+    (throw $x))
+  (catch $x  ;; <--- (rethrow 2) targets this catch.
+    (try
+      (do
+        val_y
+        (throw y))
+      (catch_all
+        (try
+          (do
+            val_z
+            (throw z))
+          (catch z
+            (rethrow 2)))))))
+```
+
+In the above example, all thrown exceptions get caught and the first one gets rethrown from the catching block of the last one. So the above reduces to
+
+```
+(label_0{}
+  (caught_0{ a_x val_x } ;; <---- The exception rethrown by `rethrow 2` below.
+    val_x
+    (label_0{}
+      (caught_0{ a_y val_y }
+        ;; The catch_all does not leave val_y here.
+        (label_0{}
+          (caught_0{ a_z val_z }
+            val_z
+            ;; (rethrow 2) puts val_x and the throw below.
+            val_x
+            (throw a_x) end) end) end) end) end) end)
+```
+
+This reduces to `val_x (throw a_x)`, throwing to the caller.
+
+### Example 2
+
+`rethrow`'s immediate validation error.
+
+@aheejin gave the following
+[example in this comment](https://github.com/WebAssembly/exception-handling/pull/143#discussion_r522673735)
+
+```
+(func
+  try $label0
+    rethrow $label0 ;; cannot be done, because it's not within catch below
+  catch $x
+  end)
+```
+
+This is a validation error (no catch block at given rethrow depth).
+
+## Target of `delegate`'s Immediate (Label Depth)
+
+### Example 3
+
+`delegate 0` target.
+
+```
+(try $l
+  (do
+    (throw $x))
+  (delegate $l))
+```
+
+This is a validation error, a `delegate` always refers to an outer block.
+
+### Example 4
+
+`delegate` correctly targeting a `try-delegate` and a `try-catch`.
+
+```
+try $label1
+  try
+    try $label0
+      try
+        throw $x
+      delegate $label0 ;; delegate 0
+    delegate $label1 ;; delegate 1
+  catch_all
+  end
+catch $x
+  instr*
+end
+```
+
+In folded form and reduced to the point `throw $x` is called, this is:
+
+```
+(label_0{}
+  (handler_0{ (a_x instr*) }
+    (label_0{}
+      (handler_0{ (ε ε) }
+        (label_0{}
+          (handler_0{ 1 }
+            (label_0{}
+              (handler_0{ 0 }
+                (throw a_x) end) end) end) end) end) end) end) end)
+```
+
+The `handler_0{ 0 }` reduces using the trivial throw and block contexts to:
+
+```
+(label_0{}
+  (handler_0{ (a_x instr*) }
+    (label_0{}
+      (handler_0{ (ε ε) }
+        (label_0{}
+          (handler_0{ 1 }
+            (throw a_x) end) end) end) end) end) end)
+```
+
+The `handler_0{ 1 }` reduces using the trivial throw context and the block context `B^1 := (handler_0{ (ε ε) } (label_0{} [_] end) end)` to the following:
+
+```
+(label_0{}
+  (handler_0{ (a_x instr*) }
+    (throw a_x) end) end)
+```
+The thrown exception is (eventually) caught by the outer try's `catch $x`, so the above reduces to the following.
+
+```
+(label_0 {}
+  (caught_0{a_x}
+    instr* end) end)
+```
+
+### Example 5
+
+`delegate 0` targeting a catch inside a try.
+
+```
+try (result i32)
+  try $label0
+    throw $x
+  catch_all
+    try
+      throw y
+    delegate $label0 ;; delegate 0
+  end
+catch_all
+  i32.const 4
+end
+```
+
+In folded form this is:
+
+```
+(try (result i32)
+  (do
+    (try
+      (do
+        (throw $x))
+      (catch_all
+        (try
+          (do
+            (throw y)
+          (delegate 0))))))
+  (catch_all
+    (i32.const 4)))
+```
+
+When it's time to reduce `(throw y)`, the reduction looks as follows.
+
+```
+(label_1{}
+  (handler_1{ (ε (i32.const 4)) }
+    (label_0{}
+      (caught_0{ a_x ε }
+        (label_0{}
+          (handler_0{ 0 }
+            (throw a_y) end) end) end) end) end) end)
+```
+
+For `B^0 := [_] := T`, the above is the same as the following.
+
+```
+(label_1{}
+  (handler_1{ (ε (i32.const 4)) }
+    (label_0{}
+      (caught_0{ a_x ε }
+        (label_0{}
+          B^0 [(handler_0{ 0 } T[ (throw a_y) ] end)] end) end) end) end) end)
+
+↪ (label_1{}
+     (handler_1{ (ε (i32.const 4)) }
+       (label_0{}
+         (caught_0{ a_x ε }
+           (throw a_y) end) end) end) end)
+```
+
+So `throw a_y` gets correctly caught by `handler_1{ (ε (i32.const 4)) }` and this example reduces to `(i32.const 4)`.
diff --git a/proposals/exception-handling/legacy/Exceptions-formal-overview.md b/proposals/exception-handling/legacy/Exceptions-formal-overview.md
new file mode 100644
index 0000000000..d7e1ed518d
--- /dev/null
+++ b/proposals/exception-handling/legacy/Exceptions-formal-overview.md
@@ -0,0 +1,238 @@
+# 3rd Proposal Formal Spec Overview
+
+This is an overview of the 3rd proposal's formal spec additions, to aid in discussions concerning the proposed semantics.
+
+## Abstract Syntax
+
+### Types
+
+#### Tag Types
+
+```
+tagtype ::= [valtype*]→[]
+```
+
+### Instructions
+
+```
+instr ::= ... | 'throw' tagidx | 'rethrow' labelidx
+        | 'try' blocktype instr* ('catch' tagidx instr*)* ('catch_all' instr*)? 'end'
+        | 'try' blocktype instr* 'delegate' labelidx
+```
+
+### Modules
+
+#### Tags
+
+```
+tag ::= export* 'tag' tagtype  | export* 'tag' tagtype import
+```
+
+#### Modules
+
+```
+mod ::= 'module' ... tag*
+```
+
+## Validation (Typing)
+
+### Validation Contexts: Tagtypes and modified Labels
+
+To verify that the `rethrow l` instruction refers to a label surrounding the instructions of a catch block (call this a catch-label), an optional `catch` specifier is introduced to labels in the validation context.
+
+```
+labeltype ::= 'catch'? resulttype
+```
+
+The original notation `labels [t*]` is now an abbreviation for:
+
+```
+'labels' [t*] ::= 'labels' ε [t*]
+```
+
+The `labels` entry of validation contexts is modified to use the above definition of labels.
+Moreover, validation contexts now hold a list of tag types, one for each tag known to them.
+
+```
+C ::= { ..., 'labels' labeltype, 'tags' tagtype*}
+```
+
+### Validation Rules for Instructions
+
+
+```
+C.tags[x] = [t*]→[]
+-----------------------------
+C ⊢ throw x : [t1* t*]→[t2*]
+
+
+C.labels[l] = catch [t*]
+----------------------------
+C ⊢ rethrow l : [t1*]→[t2*]
+
+
+C ⊢ bt : [t1*]→[t2*]
+C, labels [t2*] ⊢ instr1* : [t1*]→[t2*]
+(C.tags[x] = [t*]→[] ∧
+ C, labels (catch [t2*]) ⊢ instr2* : [t*]→[t2*])*
+(C, labels (catch [t2*]) ⊢ instr3* : []→[t2*])?
+-----------------------------------------------------------------------------
+C ⊢ try bt instr1* (catch x instr2*)* (catch_all instr3*)? end : [t1*]→[t2*]
+
+
+C ⊢ bt : [t1*]→[t2*]
+C, labels [t2*] ⊢ instr* : [t1*]→[t2*]
+C.labels[l] = [t0*]
+-------------------------------------------
+C ⊢ try bt instr* delegate l : [t1*]→[t2*]
+```
+
+Note that `try ... delegate 0` may appear without any explicitly surrounding block, in which case the label 0 refers to the label of the frame. Currently it is not allowed to refer to a label higher than the one of the frame.
+
+## Execution (Reduction)
+
+### Runtime Structure
+
+#### Stores
+
+```
+S ::= {..., 'tags' taginst*}
+```
+
+#### Tag Instances
+
+```
+taginst ::= {'type' tagtype}
+```
+
+#### Module Instances
+
+```
+m ::= {..., 'tags' tagaddr*}
+```
+#### Stack
+
+```
+handler ::= (tagaddr? instr*)* | labelidx
+exn ::= tagaddr val*
+```
+
+#### Administrative Instructions
+
+```
+instr ::= ... | 'throw' tagaddr | 'handler'_n{handler} instr* 'end'
+        | 'handler'_n{ labelidx } instr* 'end' | 'caught'_n{exn} instr* 'end'
+```
+
+#### Block Contexts and Label Kinds
+
+So far block contexts are only used in the reduction of `br l` and `return`, and only include labels or values on the stack on the left side of the hole `[_]`. To be able to break jumping over try-catch and try-delegate blocks, the new administrative control instructions must be allowed to appear after labels in block contexts.
+
+```
+B^0 ::= val* '[_]' instr* | val* C^0 instr*
+B^{k+1} ::= val* ('label'_n{instr*} B^k 'end') instr* | val* C^{k+1} instr*
+C^k ::= 'handler'_n{ handler } B^k 'end'
+      | 'caught'_n{ exn } B^k 'end'
+```
+
+Note the `C` in `C^k` above stands for `control`, because the related administrative instructions are in some ways modeling [control frame opcodes](https://webassembly.github.io/spec/core/appendix/algorithm.html?highlight=control#data-structures) "on the stack".
+
+#### Throw Contexts
+
+Throw contexts don't skip over handlers.
+Throw contexts are used to match a thrown exception with the innermost handler.
+
+```
+T ::= '[_]' | val* T instr*
+   | 'label'_n{instr*} T 'end'
+   | 'caught'_n{exn} T 'end'
+   | 'frame'_n{F} T 'end'
+```
+
+Note that because handlers are not included above, popping the throw context stops when the innermost handler is found, if any. Note that this also means that `caught_n{exn} instr* end` is not a potential catching block for exceptions thrown by `instr*`. The instruction sequence `instr*` is inside a `catch` or `catch_all` block.
+
+### Reduction of Instructions
+
+Reduction steps for the new instructions or administrative instructions.
+
+An absent tag address in a handler (i.e., `a? = ε`) represents a `catch_all`.
+
+```
+F; throw x  ↪  F; throw a  (if F.module.tagaddrs[x]=a)
+
+caught_n{a val*} B^l[rethrow l] end
+  ↪ caught_n{a val*} B^l[val* (throw a)] end
+
+caught_n{a val0*} val^n end  ↪  val^n
+
+
+F; val^n (try bt instr1* (catch x instr2*)* (catch_all instr3*)? end)
+  ↪  F; label_m{} (handler_m{(a instr2*)*(ε instr3*)?} val^n instr1* end) end
+  (if expand_F(bt) = [t1^n]→[t2^m] ∧ (F.module.tagaddrs[x]=a)*)
+
+handler_m{(a? instr*)*} val^m end ↪ val^m
+
+S; F; handler_m{(a1? instr1*)(a0? instr0*)*} T[val^n (throw a)] end
+  ↪  S; F; caught_m{a val^n} (val^n)? instr1* end
+  (if (a1? = ε ∨ a1? = a) ∧ S.tags(a).type = [t^n]→[])
+
+handler_m{(a1? instr*)(a0? instr0*)*} T[(throw a)] end
+  ↪ handler_m{(a0? instr0*)*} T[(throw a)] end
+  (if a1? ≠ ε ∧ a1? ≠ a)
+
+handler_m{} T[(throw a)] end ↪  T[(throw a)]
+  (if S.tags(a).type = [t^n]→[])
+
+
+F; val^n (try bt instr* delegate l)
+  ↪ F; label_m{} (handler_m{l} val^n instr* end) end
+  (if expand_F(bt) = [t1^n]→[t2^m])
+
+handler_m{l} val^m end ↪ val^m
+
+label_m{} B^l[ handler_m{l} T[(throw a)] end ] end
+  ↪ T[(throw a)]
+```
+
+Note that the last reduction step above is similar to the reduction of `br l` [1], the entire `handler_m{l}...end` is seen as a `br l` immediately followed by a throw.
+
+There is a subtle difference though. The instruction `br l` searches for the `l+1`th surrounding block and breaks out after that block. Because `handler_m{l}` is always wrapped in its own `label_m{} ... end` [2], with the same lookup as for `br l` the instruction ends up breaking inside the `l+1`th surrounding block, and throwing there. So if that `l+1`th surrounding block is a try, the exception is thrown in the "try code", and thus correctly getting delegated to that try's catches.
+
+- [1] [The execution step for `br l`](https://webassembly.github.io/spec/core/exec/instructions.html#xref-syntax-instructions-syntax-instr-control-mathsf-br-l)
+- [2] The label that always wraps `delegate{l}...end` can be thought of as "level -1" and cannot be referred to by the delegate's label index `l`.
+
+### Typing Rules for Administrative Instructions
+
+
+```
+S ⊢ tag a : tag [t*]→[]
+-------------------------------
+S;C ⊢ throw a : [t1* t*]→[t2*]
+
+((S ⊢ tag a : tag [t1*]→[])?
+ S;C, labels (catch [t2^m]) ⊢ instr2* : [t1*?]→[t2^m])*
+S;C, labels [t2^m] ⊢ instr1* : []→[t2^m]
+-----------------------------------------------------------
+S;C, labels [t2^m] ⊢ handler_m{(a? instr2*)*} instr1* end : []→[t2^m]
+
+S;C ⊢ instr* : []→[t^m]
+C.labels[l+1] = [t0*]
+------------------------------------------------------
+S;C ⊢ handler_m{l} instr* end : []→[t^m]
+
+S ⊢ tag a : tag [t0*]→[]
+(val:t0)*
+S;C, labels (catch [t^n]) ⊢ instr* : []→[t^n]
+------------------------------------------------------------
+S;C, labels [t^n] ⊢ caught_n{a val^*} instr* end : []→[t^n]
+```
+
+## Uncaught Exceptions
+
+A new [result](https://webassembly.github.io/spec/core/exec/runtime.html#syntax-result) value is added to describe uncaught exceptions.
+
+```
+result ::= val* | trap
+         | val* (throw tagaddr)
+```
+
diff --git a/proposals/exception-handling/legacy/Exceptions.md b/proposals/exception-handling/legacy/Exceptions.md
new file mode 100644
index 0000000000..74270f88c0
--- /dev/null
+++ b/proposals/exception-handling/legacy/Exceptions.md
@@ -0,0 +1,711 @@
+# Exception handling
+
+This explainer reflects the third version of the proposal adopted in the [CG
+meeting on
+09-15-2020](https://github.com/WebAssembly/meetings/blob/main/main/2020/CG-09-15.md#proposal-for-changes-in-eh-proposal-for-two-phase-unwinding-support-part-2--discussions-heejin-ahn-30-min),
+which removed `exnref`. The rational then was the old proposal having a
+first-class exception reference type was not easily extensible to a future
+proposal that supports two-phase unwinding.
+
+This proposal was superseded by the [current
+proposal](https://github.com/WebAssembly/exception-handling/blob/main/proposals/exception-handling/Exceptions.md)
+in [Oct 2023 CG
+meeting](https://github.com/WebAssembly/meetings/blob/main/main/2023/CG-10.md#exception-handling-vote-on-proposal-to-re-introduce-exnref),
+recognizing that after all `exnref` provided important functionalities for the
+spec and engine/toolchain implementations.
+
+This proposal is currently also known as the "legacy proposal" and still
+supported in the web, but can be deprecated in future and the use of this
+proposal is discouraged.
+
+---
+
+## Overview
+
+Exception handling allows code to break control flow when an exception is
+thrown. The exception can be any exception known by the WebAssembly module, or
+it may an unknown exception that was thrown by a called imported function.
+
+One of the problems with exception handling is that both WebAssembly and an
+embedder have different notions of what exceptions are, but both must be aware
+of the other.
+
+It is difficult to define exceptions in WebAssembly because (in general) it
+doesn't have knowledge of any embedder. Further, adding such knowledge to
+WebAssembly would limit the ability for other embedders to support WebAssembly
+exceptions.
+
+One issue is that both sides need to know if an exception was thrown by the
+other, because cleanup may need to be performed.
+
+Another problem is that WebAssembly doesn't have direct access to an embedder's
+memory. As a result, WebAssembly defers the handling of exceptions to the host
+VM.
+
+To access exceptions, WebAssembly provides instructions to check if the
+exception is one that WebAssembly understands. If so, the data of the
+WebAssembly exception is extracted and copied onto the stack, allowing
+succeeding instructions to process the data.
+
+A WebAssembly exception is created when you throw it with the `throw`
+instruction. Thrown exceptions are handled as follows:
+
+1. They can be caught by one of `catch`/`catch_all` blocks in an enclosing try
+   block of a function body.
+
+1. Throws not caught within a function body continue up the call stack, popping
+   call frames, until an enclosing try block is found.
+
+1. If the call stack is exhausted without any enclosing try blocks, the embedder
+   defines how to handle the uncaught exception.
+
+### Exception handling
+
+This proposal adds exception handling to WebAssembly. Part of this proposal is
+to define a new section to declare exceptions. However, rather than limiting
+this new section to just defining exceptions, it defines a more general format
+`tag` that allows the declaration of other forms of typed tags in future.
+
+WebAssembly tags are defined in a new `tag` section of a WebAssembly module. The
+tag section is a list of declared tags that are created fresh each time the
+module is instantiated.
+
+Each tag has an `attribute` and a `type`. Currently, the attribute can only
+specify that the tag is for an exception. In the future, additional attribute
+values may be added when other kinds of tags are added to WebAssembly.
+
+To allow for such a future extension possibility, we reserve a byte in the
+binary format of an exception definition, set to 0 to denote an exception
+attribute.
+
+### Exceptions
+
+An `exception tag` is a value to distinguish different exceptions, while an
+`exception tag index` is a numeric name to refer to an (imported or defined)
+exception tag within a module (see [tag index space](#tag-index-space) for
+details). Exception tags are declared in the tag and import sections of a
+module.
+
+An `exception` is an internal construct in WebAssembly that represents a runtime
+object that can be thrown. A WebAssembly exception consists of an exception tag
+and its runtime arguments.
+
+The type of an exception tag is denoted by an index to a function signature
+defined in the `type` section. The parameters of the function signature define
+the list of argument values associated with the tag. The result type must be
+empty.
+
+Exception tag indices are used by:
+
+1. The `throw` instruction which creates a WebAssembly exception with the
+   corresponding exception tag, and then throws it.
+
+2. The `catch` clause uses the tag to identify if the thrown exception is one it
+   can catch. If true it pushes the corresponding argument values of the
+   exception onto the stack.
+
+### Try-catch blocks
+
+A _try block_ defines a list of instructions that may need to process exceptions
+and/or clean up state when an exception is thrown. Like other higher-level
+constructs, a try block begins with a `try` instruction, and ends with an `end`
+instruction. That is, a try-catch block is sequence of instructions having the
+following form:
+
+```
+try blocktype
+  instruction*
+catch i
+  instruction*
+catch j
+  instruction*
+...
+catch_all
+  instruction*
+end
+```
+
+A try-catch block contains zero or more `catch` blocks and zero or one
+`catch_all` block. All `catch` blocks must precede the `catch_all` block, if
+any. The `catch`/`catch_all` instructions (within the try construct) are called
+the _catching_ instructions. There may not be any `catch` or `catch_all` blocks
+after a `try`, in which case the `try` block does not catch any exceptions.
+
+The _body_ of the try block is the list of instructions before the first
+catching instruction. The _body_ of each catch block is the sequence of
+instructions following the corresponding catching instruction before the next
+catching instruction (or the `end` instruction if it is the last catching
+block).
+
+The `catch` instruction has an exception tag associated with it. The tag
+identifies what exceptions it can catch. That is, any exception created with the
+corresponding exception tag. Catch blocks that begin with a `catch` instruction
+are considered _tagged_ catch blocks.
+
+The last catching instruction of a try-catch block can be the `catch_all`
+instruction. If it begins with the `catch_all` instruction, it defines the
+_default_ catch block. The default catch block has no tag index, and is used to
+catch all exceptions not caught by any of the tagged catch blocks. The term
+'catch block' refers to both `catch` and `catch_all` blocks.
+
+When the program runs `br` within `catch` or `catch_all` blocks, the rest of
+the catching blocks will not run and the program control will branch to the
+destination, as in normal blocks.
+
+Try blocks, like control-flow blocks, have a _block type_. The block type of a
+try block defines the values yielded by evaluating the try block when either no
+exception is thrown, or the exception is successfully caught by the catch block.
+Because `try` and `end` instructions define a control-flow block, they can be
+targets for branches (`br` and `br_if`) as well.
+
+### Throwing an exception
+
+The `throw` instruction takes an exception tag index as an immediate argument.
+That index is used to identify the exception tag to use to create and throw the
+corresponding exception.
+
+The values on top of the stack must correspond to the type associated with the
+exception tag. These values are popped off the stack and are used (along with
+the corresponding exception tag) to create the corresponding exception. That
+exception is then thrown.
+
+When an exception is thrown, the embedder searches for the nearest enclosing try
+block body that execution is in. That try block is called the _catching_ try
+block.
+
+If the throw appears within the body of a try block, it is the catching try
+block.
+
+If a throw occurs within a function body, and it doesn't appear inside the body
+of a try block, the throw continues up the call stack until it is in the body of
+an an enclosing try block, or the call stack is flushed. If the call stack is
+flushed, the embedder defines how to handle uncaught exceptions. Otherwise, the
+found enclosing try block is the catching try block.
+
+A throw inside the body of a catch block is never caught by the corresponding
+try block of the catch block, since instructions in the body of the catch block
+are not in the body of the try block.
+
+Once a catching try block is found for the thrown exception, the operand stack
+is popped back to the size the operand stack had when the try block was entered
+after possible block parameters were popped.
+
+Then in case of a try-catch block, tagged catch blocks are tried in the order
+they appear in the catching try block, until one matches. If a matched tagged
+catch block is found, control is transferred to the body of the catch block, and
+the arguments of the exception are pushed back onto the stack.
+
+Otherwise, control is transferred to the body of the `catch_all` block, if any.
+However, unlike tagged catch blocks, the constructor arguments are not copied
+back onto the operand stack.
+
+If no tagged catch blocks were matched, and the catching try block doesn't have
+a `catch_all` block, the exception is rethrown.
+
+If control is transferred to the body of a catch block, and the last instruction
+in the body is executed, control then exits the try block.
+
+If the selected catch block does not throw an exception, it must yield the
+value(s) specified by the type annotation on the corresponding catching try
+block.
+
+Note that a caught exception can be rethrown using the `rethrow` instruction.
+
+### Rethrowing an exception
+
+The `rethrow` instruction can only appear in the body of a catch/catch_all
+block. It always re-throws the exception caught by an enclosing catch block.
+
+Associated with the `rethrow` instruction is a _label_. The label is used to
+disambiguate which exception is to be rethrown, when inside nested catch blocks.
+The label is the relative block depth to the corresponding try block for which
+the catching block appears.
+
+For example consider the following:
+
+```
+try $l1
+  ...
+catch  ;; $l1
+  ...
+  block
+    ...
+    try $l2
+      ...
+    catch  ;; $l2
+      ...
+      try $l3
+        ...
+      catch  ;; $l3
+        ...
+        rethrow N  ;; (or label)
+      end
+    end
+  end
+  ...
+end
+```
+
+In this example, `N` is used to disambiguate which caught exception is being
+rethrown. It could rethrow any of the three caught expceptions. Hence, `rethrow
+0` corresponds to the exception caught by `catch 3`, `rethrow 1` corresponds to
+the exception caught by `catch 2`, and `rethrow 3` corresponds to the exception
+caught by `catch 1`. In wat format, the argument for the `rethrow` instructions
+can also be written as a label, like branches. So `rethrow 0` in the example
+above can also be written as `rethrow $l3`.
+
+Note that `rethrow 2` is not allowed because it does not refer to a `try` label
+from within its catch block. Rather, it references a `block` instruction, so it
+will result in a validation failure.
+
+Note that the example below is a validation failure:
+```
+try $l1
+  try $l2
+    rethrow $l2  ;; (= rethrow 0)
+  catch
+  end
+catch
+end
+```
+The `rethrow` here references `try $l2`, but the `rethrow` is not within its
+`catch` block.
+
+The example below includes all of the cases explained above. The numbers
+within `()` after `rethrow`s are the label operands in immediate values.
+```
+(func $test
+  try $lA
+    ...
+  catch ($lA)
+    ...
+    block $lB
+      ...
+      try $lC
+        ...
+      catch ($lC)
+        ...
+        try $lD
+          ...
+          rethrow $lD (0) ;; refers to 'catch ($lD)', but it is not within 'catch ($lD)', so validation failure
+          rethrow $lC (1) ;; rethrows the exception caught by catch ($lC)
+          rethrow $lB (2) ;; refers to 'block $lB', so validation failure
+          rethrow $lA (3) ;; rethrows the exception caught by catch ($lA)
+          rethrow 4       ;; validation failure
+        catch ($lD)
+          ...
+          rethrow $lD (0) ;; rethrows the exception caught by catch ($lD)
+          rethrow $lC (1) ;; rethrows the exception caught by catch ($lC)
+          rethrow $lB (2) ;; refers to 'block $lB', so validation failure
+          rethrow $lA (3) ;; rethrows the exception caught by catch ($lA)
+          rethrow 4       ;; validation failure
+        end
+      end
+    end
+    ...
+  end
+```
+
+### Try-delegate blocks
+
+Try blocks can also be used with the `delegate` instruction. A try-delegate
+block contains a `delegate` instruction with the following form:
+
+```
+try blocktype
+  instruction*
+delegate label
+```
+
+The `delegate` clause does not have an associated body, so try-delegate blocks
+don't have an `end` instruction at the end. The `delegate` instruction takes a
+try label and delegates exception handling to a `catch`/`catch_all`/`delegate`
+specified by the `try` label. For example, consider this code:
+
+```
+try $l0
+  try
+    call $foo
+  delegate $l0  ;; (= delegate 0)
+catch
+  ...
+catch_all
+  ...
+end
+```
+
+If `call $foo` throws, searching for a catching block first finds `delegate`,
+and because it delegates exception handling to catching instructions associated
+with `$l1`, it will be next checked by the outer `catch` and then `catch_all`
+instructions.
+
+`delegate` can also target `catch`-less `try`s or non-`try` block constructs
+like `block`s or `loop`s, in which case the delegated exception is assumed to
+propagate to the outer scope and will be caught by the next matching
+try-catches, or rethrown to the caller if there is no outer try block. In the
+examples, catches are annotated with `($label_name)` to clarify which `try` it
+belongs to for clarification; it is not the official syntax.
+```
+try $l0
+  block $l1
+    try
+      call $foo
+    delegate $l1  ;; delegates to 'catch ($l0)'
+  end
+catch ($l0)
+end
+```
+
+Like branches, `delegate` can only target outer blocks, and effectively
+rethrows the exception in that block. Consequently, delegating to a specific
+`catch` or `catch_all` handler requires targeting the respective label from
+within the associated `try` block. Delegating to a label from within a `catch`
+block does delegate the exception to the next enclosing handler -- analogous to
+performing a `throw` within a `catch` block, that handler is no longer active
+at that point. Here is another example:
+
+```
+try $l0
+  try $l1
+  catch ($l1)
+    try
+      call $foo
+    delegate $l1  ;; delegates to 'catch ($l0)'
+  catch_all
+    ...
+  end
+catch ($l0)
+```
+
+Here the `delegate` is targeting `catch ($l1)`, which exists before the
+`delegate`. So in case an exception occurs, it propagates out and ends up
+targetting `catch ($l0)`, if the catch has a matching tag. If not, it will
+propagate further out. Even if the `catch_all` is below the `delegate`,
+`delegate` targets catches of a `try` as a whole and does not target an
+individual `catch`/`catch_all`, so it doesn't apply.
+
+If `delegate` targets the implicit function body block, then in effect it
+delegates the exception to the caller of the current function. For example:
+```
+(func $test
+  try
+    try
+      call $foo
+    delegate 1  ;; delegates to the caller
+  catch
+    ...
+  catch_all
+    ...
+  end
+)
+```
+In case `foo` throws, `delegate 1` here delegates the exception handling to the
+caller, i.e., the exception escapes the current function. If the immediate is
+greater than or equal to the number of block nesting including the implicit
+function-level block, it is a validation failure. In this example, any number
+equal to or greater than 2 is not allowed.
+
+The below is an example that includes all the cases explained. The numbers
+within `()` after `delegate`s are the label operands in immediate values.
+```
+(func $test
+  try $lA
+    block $lB
+      try $lC
+        try
+        delegate $lC (0)  ;; delegates to 'catch ($lC)'
+        try
+        delegate $lB (1)  ;; $lB is a block, so delegates to 'catch ($lA)'
+        try
+        delegate $lA (2)  ;; delegates to 'catch ($lA)'
+        try
+        delegate 3        ;; propagates to the caller
+        try
+        delegate 4        ;; validation failure
+      catch ($lC)
+        try
+        delegate $lC (0)  ;; 'catch ($lC)' is above this instruction,
+                          ;; so delegates to 'catch ($lA)'
+        try
+        delegate $lB (1)  ;; $lB is a block, so delegates to 'catch ($lA)'
+        try
+        delegate $lA (2)  ;; delegates to 'catch ($lA)'
+        try
+        delegate 3        ;; propagates to the caller
+        try
+        delegate 4        ;; validation failure
+      end  ;; try $lC
+    end  ;; block $lB
+  catch ($lA)
+  end  ;; try $lA
+)
+```
+
+### JS API
+
+#### Traps
+
+The `catch`/`catch_all` instruction catches exceptions generated by the `throw`
+instruction, but does not catch traps. The rationale for this is that in general
+traps are not locally recoverable and are not needed to be handled in local
+scopes like try-catch.
+
+The `catch` instruction catches foreign exceptions generated from calls to
+function imports as well, including JavaScript exceptions, with a few
+exceptions:
+1. In order to be consistent before and after a trap reaches a JavaScript frame,
+   the `catch` instruction does not catch exceptions generated from traps.
+1. The `catch` instruction does not catch JavaScript exceptions generated from
+   stack overflow and out of memory.
+
+Filtering these exceptions should be based on a predicate that is not observable
+by JavaScript. Traps currently generate instances of
+[`WebAssembly.RuntimeError`](https://webassembly.github.io/reference-types/js-api/#exceptiondef-runtimeerror),
+but this detail is not used to decide type. Implementations are supposed to
+specially mark non-catchable exceptions.
+([`instanceof`](https://tc39.es/ecma262/#sec-instanceofoperator) predicate can
+be intercepted in JS, and types of exceptions generated from stack overflow and
+out of memory are implementation-defined.)
+
+#### API additions
+
+The following additional classes are added to the JS API in order to allow
+JavaScript to interact with WebAssembly exceptions:
+
+  * `WebAssembly.Tag`
+  * `WebAssembly.Exception`
+
+The `WebAssembly.Tag` class represents a typed tag defined in the tag section
+and exported from a WebAssembly module. It allows querying the type of a tag
+following the [JS type reflection
+proposal](https://github.com/WebAssembly/js-types/blob/master/proposals/js-types/Overview.md).
+Constructing an instance of `Tag` creates a fresh tag, and the new tag can be
+passed to a WebAssembly module as a tag import.
+
+In the future, `WebAssembly.Tag` may be used for other proposals that require a
+typed tag and its constructor may be extended to accept other types and/or a tag
+attribute to differentiate them from tags used for exceptions.
+
+The `WebAssembly.Exception` class represents an exception thrown from
+WebAssembly, or an exception that is constructed in JavaScript and is to be
+thrown to a WebAssembly exception handler. The `Exception` constructor accepts a
+`Tag` argument and a sequence of arguments for the exception's data fields. The
+`Tag` argument determines the exception tag to use. The data field arguments
+must match the types specified by the `Tag`'s type. The `is` method can be used
+to query if the `Exception` matches a given tag. The `getArg` method allows
+access to the data fields of a `Exception` if a matching tag is given. This last
+check ensures that without access to a WebAssembly module's exported exception
+tag, the associated data fields cannot be read.
+
+The `Exception` constructor can take an optional `ExceptionOptions` argument,
+which can optionally contain `traceStack` entry. When `traceStack` is
+`true`, JavaScript VMs are permitted to attach a stack trace string to
+`Exception.stack` field, as in JavaScript's `Error` class. `traceStack`
+serves as a request to the WebAssembly engine to attach a stack trace; it
+is not necessary to honour if `true`, but `trace` may not be populated if
+`traceStack` is `false`. While `Exception` is not a subclass of JavaScript's
+`Error` and it can be used to represent normal control flow constructs,
+`traceStack` field can be set when we use it to represent errors. The
+format of stack trace strings conform to the [WebAssembly stack trace
+conventions](https://webassembly.github.io/spec/web-api/index.html#conventions).
+When `ExceptionOption` is not provided or it does not contain `traceStack`
+entry, `traceStack` is considered `false` by default.
+
+To preserve stack trace info when crossing the JS to Wasm boundary, exceptions
+can internally contain a stack trace, which is propagated when caught by `catch`
+and rethrown by `rethrow`.
+
+More formally, the added interfaces look like the following:
+
+```WebIDL
+dictionary TagType {
+  required sequence parameters;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+interface Tag {
+  constructor(TagType type);
+  TagType type();
+};
+
+dictionary ExceptionOptions {
+  boolean traceStack = false;
+};
+
+[LegacyNamespace=WebAssembly, Exposed=(Window,Worker,Worklet)]
+interface Exception {
+  constructor(Tag tag, sequence payload, optional ExceptionOptions options);
+  any getArg(Tag tag, unsigned long index);
+  boolean is(Tag tag);
+  readonly attribute (DOMString or undefined) stack;
+};
+```
+
+`TagType` corresponds to a `FunctionType` in [the type reflection
+proposal](https://github.com/WebAssembly/js-types/blob/main/proposals/js-types/Overview.md),
+without a `results` property). `TagType` could be extended in the future for
+other proposals that require a richer type specification.
+
+## Changes to the text format
+
+This section describes change in the [instruction syntax
+document](https://github.com/WebAssembly/spec/blob/master/document/core/text/instructions.rst).
+
+### New instructions
+
+The following rules are added to *instructions*:
+
+```
+  try blocktype instruction* (catch tag_index instruction*)* (catch_all instruction*)? end |
+  try blocktype instruction* delegate label |
+  throw tag_index argument* |
+  rethrow label |
+```
+
+Like the `block`, `loop`, and `if` instructions, the `try` instruction is
+*structured* control flow instruction, and can be labeled. This allows branch
+instructions to exit try blocks.
+
+The `tag_index` of the `throw` and `catch` instructions denotes the exception
+tag to use when creating/extract from an exception. See [tag index
+space](#tag-index-space) for further clarification of exception tags.
+
+## Changes to Modules document
+
+This section describes change in the [Modules
+document](https://github.com/WebAssembly/design/blob/master/Modules.md).
+
+### Tag index space
+
+The `tag index space` indexes all imported and internally-defined exception
+tags, assigning monotonically-increasing indices based on the order defined in
+the import and tag sections. Thus, the index space starts at zero with imported
+tags, followed by internally-defined tags in the [tag section](#tag-section).
+
+For tag indices that are not imported/exported, the corresponding exception tag
+is guaranteed to be unique over all loaded modules. Exceptions that are imported
+or exported alias the respective exceptions defined elsewhere, and use the same
+tag.
+
+## Changes to the binary model
+
+This section describes changes in the [binary encoding design
+document](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md).
+
+#### Other Types
+
+##### tag_type
+
+We reserve a bit to denote the exception attribute:
+
+| Name      | Value |
+|-----------|-------|
+| Exception | 0     |
+
+Each tag type has the fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `attribute` | `uint8` | The attribute of a tag. |
+| `type` | `varuint32` | The type index for its corresponding type signature |
+
+##### external_kind
+
+A single-byte unsigned integer indicating the kind of definition being imported
+or defined:
+
+* `4` indicating a `Tag`
+[import](https://github.com/WebAssembly/design/blob/main/BinaryEncoding.md#import-section) or
+[definition](#tag-section)
+
+### Module structure
+
+#### High-level structure
+
+A new `tag` section is introduced.
+
+##### Tag section
+
+The `tag` section comes after the [memory
+section](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#memory-section)
+and before the [global
+section](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#global-section).
+So the list of all sections will be:
+
+| Section Name | Code | Description |
+| ------------ | ---- | ----------- |
+| Type | `1` | Function signature declarations |
+| Import | `2` | Import declarations |
+| Function | `3` | Function declarations |
+| Table | `4` | Indirect function table and other tables |
+| Memory | `5` | Memory attributes |
+| Tag | `13` | Tag declarations |
+| Global | `6` | Global declarations |
+| Export | `7` | Exports |
+| Start | `8` | Start function declaration |
+| Element | `9` | Elements section |
+| Data count | `12` | Data count section |
+| Code | `10` | Function bodies (code) |
+| Data | `11` | Data segments |
+
+The tag section declares a list of tag types as follows:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| count | `varuint32` | count of the number of tags to follow |
+| type | `tag_type*` | The definitions of the tag types |
+
+##### Import section
+
+The import section is extended to include tag definitions by extending an
+`import_entry` as follows:
+
+If the `kind` is `Tag`:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `type` | `tag_type` | the tag being imported |
+
+##### Export section
+
+The export section is extended to reference tag types by extending an
+`export_entry` as follows:
+
+If the `kind` is `Tag`:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `index` | `varuint32` | the index into the corresponding tag index space |
+
+##### Name section
+
+The set of known values for `name_type` of a name section is extended as
+follows:
+
+| Name Type | Code | Description |
+| --------- | ---- | ----------- |
+| [Function](#function-names) | `1` | Assigns names to functions |
+| [Local](#local-names) | `2` | Assigns names to locals in functions |
+| [Tag](#tag-names) | `11` | Assigns names to tags |
+
+###### Tag names
+
+The tag names subsection is a `name_map` which assigns names to a subset of
+the tag indices (Used for both imports and module-defined).
+
+### Control flow operators
+
+The control flow operators are extended to define try blocks, catch blocks,
+throws, and rethrows as follows:
+
+| Name | Opcode | Immediates | Description |
+| ---- | ---- | ---- | ---- |
+| `try` | `0x06` | sig : `blocktype` | begins a block which can handle thrown exceptions |
+| `catch` | `0x07` | index : `varint32` | begins the catch block of the try block |
+| `catch_all` | `0x19` | | begins the catch_all block of the try block |
+| `delegate` | `0x18` | relative_depth : `varuint32` | begins the delegate block of the try block |
+| `throw` | `0x08` | index : `varint32` | Creates an exception defined by the tag and then throws it |
+| `rethrow` | `0x09` | relative_depth : `varuint32` | Pops the `exnref` on top of the stack and throws it |
+
+The *sig* fields of `block`, `if`, and `try` operators are block signatures
+which describe their use of the operand stack.
diff --git a/proposals/exception-handling/pre-legacy/Exceptions-v1.md b/proposals/exception-handling/pre-legacy/Exceptions-v1.md
new file mode 100644
index 0000000000..c48fa64ed5
--- /dev/null
+++ b/proposals/exception-handling/pre-legacy/Exceptions-v1.md
@@ -0,0 +1,389 @@
+This is the first version of the exception handling proposal, active from 2017
+to 2018 and superseded by [V2 proposal](Exceptions-v2.md) in [Oct 2018 CG
+meeting](https://github.com/WebAssembly/meetings/blob/main/main/2018/TPAC.md#exception-handling-ben-titzer).
+
+---
+
+# Exception handling
+
+There are four sections to this proposal
+
+1. A overview of the proposed extension to WebAssembly
+   
+1. Changes to the text format document.
+
+1. Changes to the Modules document.
+
+1. Changes of the WebAssembly Binary Design document.
+
+The proposal here is also meant to be a minimal proposal that may be further
+extended sometime in the future.
+
+## Overview
+
+Exception handling allows code to break control flow when an exception is
+thrown. The exception can be an exception known by the WebAssembly module, or it
+may be an unknown exception thrown by an imported call.
+
+Thrown exceptions are handled as follows:
+
+1. They can be caught by a catch block in an enclosing try block of a function
+   body.
+
+1. Throws not caught within a function body continue up the call stack until an
+   enclosing try block is found.
+   
+1. If the call stack is exhausted without any enclosing try blocks, it
+   terminates the application.
+
+This proposal looks at the changes needed to incorporate these concepts into the
+portable binary encoding of WebAssembly modules.
+
+At the specification level, these changes do not infer whether an implementation
+must implement lightweight or heavyweight exceptions. Rather, it defers that
+choice to the runtime implementation.
+
+Exception handling is defined using *exceptions*, *try blocks*, *catch blocks*,
+and the instructions `throw` and `rethrow`.
+
+### Exceptions
+
+An _exception_ is an internal construct in WebAssembly. Exceptions are defined
+by a new _exception_ section of a WebAssembly module. The exception section is a
+list of exceptions. Each exception has a _type signature_. The type signature
+defines the list of values associated with an exception.
+
+Within the module, exceptions are identified by an index into
+the [exception index space](#exception-index-space).  This index is referred to
+as the _exception tag_.
+
+Exceptions can be imported and exported by adding the appropriate entries to the
+import and export sections of the module. All imported/exported exceptions must
+be named to reconcile exception tags between modules.
+
+Exception tags are used by throw and catch instructions. The throw instruction
+uses the tag to allocate the exception with the corresponding data fields
+defined by the exception's type signature. The catch instruction uses the tag to
+identify if the thrown exception is one it can catch.
+
+Exceptions can also be thrown by called, imported functions. If it corresponds
+to an imported exception, it can be caught by an appropriate catch instruction.
+If the exception is not imported, it still can be caught to allow code clean-up,
+but the data of the exception can't be accessed.
+
+### Try and catch blocks.
+
+A _try_ block defines a list of instructions that may need to catch exceptions
+and/or clean up state when an exception is thrown.  Like other higher-level
+constructs, a try block begins with a `try` instruction, and ends with an `end`
+instruction. That is, a try block is sequence of instructions having the
+following form:
+
+```
+try
+  instruction*
+catch i
+  instruction*
+catch j
+  instruction*
+...
+catch n
+  instruction*
+catch_all
+    instruction*
+end
+```
+
+A try block also contains one or more catch blocks, and all but the last catch
+block must begin with a`catch` instruction. The last catch block can begin with
+either a `catch` or `catch_all` instruction. The `catch`/`catch_all`
+instructions (within the try construct) are called the _catching_ instructions.
+
+The _body_ of the try block is the list of instructions before the first
+catching instruction. The _body_ of each catch block is the sequence of
+instructions following the corresponding catching instruction, and the next
+catching instruction (or the `end` instruction if it is the last catching
+block).
+
+The `catch` instruction has an exception tag associated with it. The tag
+identifies what exceptions it can catch. That is, any exception created with the
+corresponding exception tag. Catch blocks that begin with a `catch` instruction
+are considered _tagged_ catch blocks.
+
+The last catch block of an exception can be a tagged catch block. Alternatively,
+it can begin with the `catch_all` instruction. If it begins with the
+`catch_all` instruction, it defines the _default_ catch block. The default
+catch block has no exception type, and is used to catch all exceptions not
+caught by any of the tagged catch blocks.
+
+Try blocks, like control-flow blocks, have a _block type_. The block type of a
+try block defines the values yielded by the evaluation the try block when either
+no exception is thrown, or the exception is successfully caught by one of its
+catch blocks, and the instructions within the catch block can recover from the
+throw.
+
+In the initial implementation, try blocks may only yield 0 or 1 values.
+
+### Throws
+
+The `throw` instruction has a single immediate argument, an exception tag.  The
+exception tag is used to define the data fields of the allocated exception. The
+values for the data fields must be on top of the operand stack, and must
+correspond to the exception type signature for the exception.
+
+When an exception is thrown, the exception is allocated and the values on the
+stack (corresponding to the type signature) are popped off and assigned to the
+allocated exception.  The exception is stored internally for access when the
+exception is caught. The runtime then searches for nearest enclosing try block
+body that execution is in. That try block is called the _catching_ try block.
+
+If the throw appears within the body of a try block, it is the catching try
+block.
+
+If a throw occurs within a function body, and it doesn't appear inside the body
+of a try block, the throw continues up the call stack until it is in the body of
+an an enclosing try block, or the call stack is flushed. If the call stack is
+flushed, execution is terminated. Otherwise, the found enclosing try block is
+the catching try block.
+
+A throw inside a the body of a catch block is never caught by the corresponding
+try block of the catch block, since instructions in the body of the catch block
+are not in the body of the try block.
+
+Once a catching try block is found for the throw, the operand stack is popped back
+to the size the operand stack had when the try block was entered. Then, tagged
+catch blocks are tried in the order they appear in the catching try block, until
+one matches.
+
+If a matched tagged catch block is found, control is transferred to the body of
+the catch block, and the data fields of the exception are pushed back onto the
+stack.
+
+Otherwise, control is transferred to the body of the default catch
+block. However, unlike tagged catch blocks, the constructor arguments are not
+copied back onto the operand stack.
+
+If no tagged catch blocks were matched, and the catching try block doesn't have
+a default catch block, the exception is rethrown to the next enclosing try
+block.
+
+If control is transferred to the body of a catch block, and the last instruction
+in the body is executed, control then exits the try block.
+
+Also note that when the thrown exception is caught by a catch block, it is not
+destroyed until the catch block is exited. This is done so that the catch block
+can rethrow the exception.
+
+If the selected catch block does not rethrow an exception, it must yield the
+value(s) expected by the enclosing try block. For tagged catch blocks, they must
+also be sure to also pop off the caught exception values.
+
+### Rethrows
+
+The `rethrow` instruction can only appear in the body of a catch block.  The
+`rethrow` instruction always re-throws the exception caught by an enclosing
+catch block. This allows the catch block to clean up state before the exception
+is passed back to the next enclosing try block.
+
+Associated with the `rethrow` instruction is a _label_. The label is used to
+disambiguate which exception is to be rethrown, when inside nested catch blocks.
+
+The label is the relative block depth to the corresponding try block for which
+the catching block appears.
+
+For example consider the following:
+
+```
+try
+  ...
+catch 1
+  ...
+  block
+    ...
+    try
+      ...
+    catch 2
+      ...
+      try
+        ...
+      catch 3
+        ...
+        rethrow N
+      end
+    end
+  end
+  ...
+end
+```
+
+In this example, `N` is used to disambiguate which caught exception is being
+rethrown. It could rethrow any of the three caught expceptions. Hence,
+`rethrow 0` corresponds to the exception caught by `catch 3`, `rethrow 1`
+corresponds to the exception caught by `catch 2`, and `rethrow 3` corresponds
+to the exception caught by `catch 1`.
+
+Note that `rethrow 2` is not allowed because it does not reference a `try`
+instruction. Rather, it references a `block` instruction.
+
+### Debugging
+
+Earlier discussion implied that when an exception is thrown, the runtime will
+pop the operand stack across function calls until a corresponding, enclosing try
+block is found. The implementation may actually not do this. Rather, it may
+first search up the call stack to see if there is an enclosing try. If none are
+found, it could terminate the thread at the point of the throw. This would
+allow better debugging capability, since the corresponding call stack is still
+there to query.
+
+## Changes to the text format.
+
+This section describes change in the
+[instruction syntax document](https://github.com/WebAssembly/spec/blob/master/document/text/instructions.rst).
+
+### Control Instructions
+
+The following rule is added to *instructions*:
+
+```
+instructions ::=
+  ...
+  try resulttype instr* catch+ end |
+  throw except_index |
+  rethrow label
+  
+catch ::=
+  catch except_index inst* |
+  catch_all inst*
+```
+
+Like the `block`, `loop`, and `if` instructions, the `try` instruction is a
+*structured* instruction, and is implicitly labeled. This allows branch
+instructions to exit try blocks.
+
+The `except_index` of the `catch` instruction is the exception tag for the caught
+exception. Similarly, the `except_index` of the `throw` instruction is the tag for
+the constructed exception.  See [exception index space](#exception-index-space)
+for further clarification of exception tags.
+
+The `label` of the `rethrow` instruction is the label to the corresponding try
+block, defining the catch to rethrow.
+
+## Changes to Modules document.
+
+This section describes change in the
+[Modules document](https://github.com/WebAssembly/design/blob/master/Modules.md).
+
+#### Exception index space
+
+The _exception index space_ indexes all imported and internally-defined
+exceptions, assigning monotonically-increasing indices based on the order
+defined in the import and exception sections. Thus, the index space starts at
+zero with imported exceptions followed by internally-defined exceptions in
+the [exception section](#exception-section).
+
+## Changes to the binary model
+
+This section describes changes in
+the
+[binary encoding design document](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md).
+
+### except_type
+
+An exception is described by its exception type signature, which corresponds to
+the data fields of the exception.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `count` | `varuint32` | The number of types in the signature |
+| `type` | `value_type*` | The type of each element in the signature |
+
+### External kind
+
+`external_kind`
+
+A single-byte unsigned integer indicating the kind of definition being imported
+or defined:
+
+* `0` indicating a `Function` [import](Modules.md#imports) or [definition](Modules.md#function-and-code-sections)
+* `1` indicating a `Table` [import](Modules.md#imports) or [definition](Modules.md#table-section)
+* `2` indicating a `Memory` [import](Modules.md#imports) or [definition](Modules.md#linear-memory-section)
+* `3` indicating a `Global` [import](Modules.md#imports) or [definition](Modules.md#global-section)
+* `4` indicating an `Exception` [import](#import-section) or [definition](#exception-sectio)
+
+### Exception section
+
+The `exception` section is the named section 'exception'. The exception section
+declares exception types using exception type signatures.
+
+| Field | Type | Description |
+|-------|------|-------------|
+| count | `varuint32` | count of the number of exceptions to follow |
+| sig | `except_type*` | The type signature of the data fields for each exception |
+
+### Import section
+
+The import section is extended to include exception types by extending an
+`import_entry` as follows:
+
+If the `kind` is `Exception`:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `sig`  | `except_type` | the type signature of the exception |
+
+### Export section
+
+The export section is extended to include exception types by extending an
+`export_entry` as follows:
+
+If the `kind` is `Exception`, then the `index` is into the corresponding
+exception in the [exception index space](#exception-index-space).
+
+### Name section
+
+The set of known values for `name_type` of a name section is extended as
+follows:
+
+
+| Name Type | Code | Description |
+| --------- | ---- | ----------- |
+| [Function](#function-names) | `1` | Assigns names to functions |
+| [Local](#local-names) | `2` | Assigns names to locals in functions |
+| [Exception](#exception-names) | `3` | Assigns names to exception types |
+
+### Exception names
+
+The exception names subsection is a `name_map` which assigns names to a subset
+of the _exception_ indices from the exception section. (Used for both imports
+and module-defined).
+
+### Control flow operators
+
+The control flow operators are extended to define try blocks, catch blocks,
+throws, and rethrows as follows:
+
+| Name | Opcode | Immediates | Description |
+| ---- | ---- | ---- | ---- |
+| `unreachable` | `0x00` | | trap immediately |
+| `nop` | `0x01` | | no operation |
+| `block` | `0x02` | sig : `block_type` | begin a sequence of expressions, yielding 0 or 1 values |
+| `loop` | `0x03` |  sig : `block_type` | begin a block which can also form control flow loops |
+| `if` | `0x04` | sig : `block_type` | begin if expression |
+| `else` | `0x05` | | begin else expression of if or try  |
+| `try` | `0x06` | sig : `block_type` | begins a block which can handle thrown exceptions |
+| `catch` | `0x07` | tag : `varuint32` | begins a block when the exception `tag` is thrown |
+| `throw` | `0x08` | tag : `varuint32` | Throws an exception defined by the exception `tag` |
+| `rethrow` | `0x09` | relative_depth : `varuint32` | re-throws the exception caught by the corresponding try block |
+| `end` | `0x0b` | | end a block, loop, if, and try |
+| `br` | `0x0c` | relative_depth : `varuint32` | break that targets an outer nested block |
+| `br_if` | `0x0d` | relative_depth : `varuint32` | conditional break that targets an outer nested block |
+| `br_table` | `0x0e` | see below | branch table control flow construct |
+| `return` | `0x0f` | | return zero or one value from this function |
+
+The *sig* fields of `block`, `if`, and `try` operators are block signatures
+which describe their use of the operand stack.
+
+Note that the textual `catch_all` instruction is implemented using the
+`else` operator. Since the `else` operator is always unambiguous in the binary
+format, there is no need to tie up a separate opcode for the `catch_all`
+instruction.
diff --git a/proposals/exception-handling/pre-legacy/Exceptions-v2-Level-1+N.md b/proposals/exception-handling/pre-legacy/Exceptions-v2-Level-1+N.md
new file mode 100644
index 0000000000..08a1a5e0e3
--- /dev/null
+++ b/proposals/exception-handling/pre-legacy/Exceptions-v2-Level-1+N.md
@@ -0,0 +1,275 @@
+This was written along with [Level 1 Proposal](Exceptions-v2-Level-1.md) in the
+beginning of 2018 for collecting ideas for future work.
+
+---
+
+# Exception Handling Level 1+N Extensions
+
+While the Level 1 Proposal establishes the minimum viable product (MVP) for
+exception handling, there are several extensions that would be nice to have for
+various reasons. These include:
+* More compact WebAssembly code. Compound instructions can capture common
+  sequences and save on code size.
+* More efficient embedder implementation. Some changes to the baseline spec can
+  open up opportunities for embedders to generate better code.
+* General completeness. The baseline proposal has some arbitrary limitations
+  that are only there to reduce implementation effort but do not have any
+  fundamental theoretical reasons.
+
+Many of these extensions are complementary and build upon each other. Thus a
+layered approach works well, where sets of features that are logically related
+can be added at once.
+
+This document captures several feature levels at a high level. The goal is not
+to exhaustively specify them but to carve out the design space in sufficient
+detail that we can ensure the Level 1 proposal is future proof with respect to
+these. Each level will likely become its own WebAssembly proposal after the
+initial exception handling support is accepted, but if there are strong use
+cases and a low enough specification and implementation burden, these may be
+included with the initial exception proposal. The goal is to make sure each set
+of features can be discussed in terms of its own merits independent of the other
+features.
+
+Please note that everything in here should be considered fluid and subject to
+change.
+
+# Level 2
+
+## Specific Catch
+
+The Level 1 proposal only supports `catch_all`, meaning a single catch clause
+that runs for all exceptions. Some languages may only be interested in catching
+certain exceptions. Specific catch allows programs to specify which exceptions
+that will handle with a certain `try` block. This improves performance by not
+running code that is not needed and, more importantly, opens up for efficient
+implementation strategies for the embedder such as being able to go directly to
+the catch clause for the given exception.
+
+This feature extends try blocks as follows:
+
+```
+try resulttype
+  instruction*
+(catch exception_index
+  instruction* )*
+(catch
+  instruction* )?
+end
+```
+
+Note that the `catch exception_index` and `catch` forms of the catch clause should be given different opcodes.
+
+### Alternate Form: Catch Lists
+
+In this version, a catch clause lists which exception indices it handles. An
+empty list is equivalent to `catch_all`. An example is given below.
+
+```
+try resulttype
+  instruction*
+catch exception_index*
+  instrunction*
+end
+```
+
+One downside of this form is that it does not directly support running different
+code for different exception types. This can still be accomplished, however, by
+dynamically inspecting the exception inside the catch block.
+
+# Level 3
+
+## Resumable Exceptions
+
+This proposal allows exception handlers to return a value to the site where the
+exception was thrown. Resumable exceptions enable or are equivalent to a number
+of advanced control flow features such as generators, coroutines, delimited
+continuations and effect handlers.
+
+In high level code, this would enable programs such as:
+
+```
+Exception FileNotFound: string -> string
+
+try {
+  filename = "foo.txt"
+  while(!(file = open(filename))) {
+    filename = throw FileNotFound(filename);
+  }
+} catch (FileNotFound e) {
+  new_file_name = ask_user_for_filename();
+  resume e(new_file_name)
+}
+```
+
+The key changes are that exception types are now allowed to include return
+values, `throw` can return a value (we might want to introduce a different
+opcode for this version, such as `raise` or `throw_resumable`), and there is a
+`resume` instruction that returns values back to where the exception was thrown
+from.
+
+Below are several examples showing how other control flow patterns can be
+expressed in terms of resumable exceptions.
+
+### Example: Algebraic Effect Handlers
+
+Consider the following example, taken from http://www.eff-lang.org/try/:
+
+```
+handle
+    std#print "A";
+    std#print "B";
+    std#print "C";
+    std#print "D"
+with
+| std#print msg k ->
+    std#print ("I see you tried to print " ^ msg ^ ". Okay, you may.\n");
+    k ()
+```
+
+This could be lowered to Wasm resumable exception pseudo-code like this:
+
+```
+Exception StdPrint: string -> ()
+
+import function RealPrint: string -> ()
+
+try:
+  throw StdPrint("A")
+  throw StdPrint("B")
+  throw StdPrint("C")
+  throw StdPrint("D")
+catch e: StdPrint(msg):
+  RealPrint("I see you tried to print " + msg + ". Okay, you may.\n")
+  resume e()
+end
+```
+
+### Example: Coroutines
+
+Consider the example below taken from https://en.wikipedia.org/wiki/Coroutine:
+
+```
+var q := new queue
+
+coroutine produce
+    loop
+        while q is not full
+            create some new items
+            add the items to q
+        yield to consume
+
+coroutine consume
+    loop
+        while q is not empty
+            remove some items from q
+            use the items
+        yield to produce
+```
+
+Using similar high level pseudo code, we can convert this as follows to use
+resumable exceptions:
+
+```
+Exception yield: () -> ()
+
+function produce():
+  loop:
+    while q is not full:
+      create some new items
+      add the items to q
+    throw yield()
+
+function consume():
+  loop:
+    while q is not empty:
+      remove some items from q
+      use the items
+    throw yield()
+
+function run():
+  // Start the producer
+  try:
+    produce()
+  catch e: yield():
+    e
+  end
+
+  // Start the consumer
+  try:
+    consume()
+  catch e: yield():
+    e
+  end
+
+  loop:
+    // Run the producer
+    c1 = resume c1();
+    // Run the consumer
+    c2 = resume c2();
+```
+
+### Example: Generators
+
+Consider the following generator example in JavaScript:
+
+```javascript
+function* simpleIterator() {
+  yield 1;
+  yield 2;
+  yield 3;
+}
+
+for (let i of simpleIterator()) {
+  print(i);
+}
+```
+
+In our WebAssembly pseudo code, this could become:
+
+```
+Exception yield: i32 -> ()
+
+function simpleIterator():
+  throw yield(1)
+  throw yield(2)
+  throw yield(3)
+
+function main():
+  try:
+    simpleIterator()
+  catch e: yield(i):
+    print(i)
+    resume e()
+```
+
+### Example: Delimited Continuations
+
+Consider the following example taken from
+https://en.wikipedia.org/wiki/Delimited_continuation:
+
+```scheme
+(* 2 (reset (+ 1 (shift k (k 5)))))
+```
+
+This can be translated into a resumable exceptions program. We'll start by
+rewriting the program so that it's closer to the high level syntax we've been
+using.
+
+```
+function main():
+  2 * (reset => 1 + (shift k => k(5)))
+```
+
+Now we can convert the program to use resumable exceptions. For convenience, we
+use JavaScript-style lambdas (e.g. `(x, y) => x + y`) and assume a later pass
+will compile this away.
+
+```
+Exception shift_k: (fn (i32) -> i32) -> i32
+
+function main():
+  2 * (try:
+         1 + (throw shift_k((k) => k(5)))
+       catch e: shift_k(f):
+         f((v) => resume e(v)))
+```
diff --git a/proposals/exception-handling/pre-legacy/Exceptions-v2-Level-1.md b/proposals/exception-handling/pre-legacy/Exceptions-v2-Level-1.md
new file mode 100644
index 0000000000..32400e9a91
--- /dev/null
+++ b/proposals/exception-handling/pre-legacy/Exceptions-v2-Level-1.md
@@ -0,0 +1,425 @@
+This is written as an alternative to [V1 Proposal](Exceptions-v1.md) in the
+beginning of 2018 as the need for the first-class exception reference type was
+suggested. This was later slightly modified and became the basis of [V2
+Proposal](Exceptions-v2.md), which replaced the V1 Proposal in [Oct 2018 CG
+meeting](https://github.com/WebAssembly/meetings/blob/main/main/2018/TPAC.md#exception-handling-ben-titzer).
+
+---
+
+# Level 1 exception handling
+
+Level 1 of exception handling is the MVP (minimal viable proposal) for
+implementing exceptions in WebAssembly. As such, it doesn't include higher-level
+concepts and structures. These concept and structures are introduced in later
+levels, and either:
+
+1. Improves readability by combining concepts in Level 1 into higher-level
+   constructs, thereby reducing code size.
+2. Allow performance improvements in the VM.
+3. Introduce additional new functionality not available in Level 1.
+
+## Overview
+
+Exception handling allows code to break control flow when an exception is
+thrown.  The exception can be any exception known by the WebAssembly module, or
+it may an unknown exception that was thrown by a called imported function.
+
+One of the problems with exception handling is that both WebAssembly and an
+embedder have different notions of what exceptions are, but both must be aware
+of the other.
+
+It is difficult to define exceptions in WebAssembly because (in general) it
+doesn't have knowledge of any embedder. Further, adding such knowledge to
+WebAssembly would limit the ability for other embedders to support WebAssembly
+exceptions.
+
+One issue is that both sides need to know if an exception was thrown by the
+other, because cleanup may need to be performed.
+
+Another problem is that WebAssembly doesn't have direct access to an embedder's
+memory.  As a result, WebAssembly defers the handling of exceptions to the host
+VM.
+
+To access exceptions, WebAssembly provides instructions to check if the
+exception is one that WebAssembly understands. If so, the data of the
+WebAssembly exception is extracted and copied onto the stack, allowing
+succeeding instructions to process the data.
+
+Lastly, exception lifetimes may be maintained by the embedder, so that it can
+collect and reuse the memory used by exceptions. This implies that an embedder
+needs to know where exceptions are stored, so that it can determine when an
+exception can be garbage collected.
+
+This also implies that that embedders must provide a garbage collector for
+exceptions.  For embedders that have garbage collection (such as JavaScript),
+this is not a problem.
+
+However, not all embedders may have a garbage collector.  For this reason,
+WebAssembly exceptions are designed to allow other storage management methods,
+such as reference counting, to perform the garbage collection in the embedder.
+
+To do this, WebAssembly exceptions are immutable once created, to avoid cyclic
+data structures that cannot be garbage collected. It also means that exceptions
+can't be stored into linear memory. The rationale for this is twofold:
+
+* For security. Loads and stores do not guarantee that the data read was of the
+  same type as stored. This allows spoofing of exception references that may
+  allow a WebAssembly module to access data it should not know in the host VM.
+  
+* The embedder does not know the layout of data in linear memory, so it can't
+  find places where exception references are stored.
+
+Hence, while an exception reference is a new first class type, this proposal
+disallows their usage in linear memory.
+
+A WebAssembly exception is created when you throw it with the `throw`
+instruction. Thrown exceptions are handled as follows:
+
+1. They can be caught by a catch block in an enclosing try block of a function
+   body. The caught exception is pushed onto the stack.
+
+1. Throws not caught within a function body continue up the call stack, popping
+   call frames, until an enclosing try block is found.
+   
+1. If the call stack is exhausted without any enclosing try blocks, the embedder
+   defines how to handle the uncaught exception.
+   
+### Event handling
+
+This proposal adds exception handling to WebAssembly. Part of this proposal is
+to define a new section to declare exceptions. However, rather than limiting
+this new section to just defining exceptions, it defines a more general format
+that allows the declaration of other forms of events.
+
+In general, an event handler allows one to process an event generated by a block
+of code. Events suspend the current execution and look for a corresponding event
+handler. If found, the corresponding event handler is run.  Some event handlers
+may send values back to the suspended instruction, allowing the originating code
+to resume.
+
+Exceptions are a special case of an event in that they never resume. Similarly,
+a throw instruction is the suspending event of an exception. The catch block
+associated with a try block defines how to handle the throw.
+
+WebAssembly events (i.e. exceptions) are defined by a new `event` section of a
+WebAssembly module. The event section is a list of declared events associated
+with the module.
+
+Each event has an `attribute` and a `type`. Currently, the attribute can only
+specify that the event is an exception. In the future, additional attribute
+values may be added when other events are added to WebAssembly.
+
+The type of an event is denoted by an index to a function signature defined in
+the `type` section. The parameters of the function signature defines the list of
+values associated with the exception event. The result type must be 'void'.
+
+An `event tag` is a value to distinguish different events, while an `event index`
+is a numeric name to refer to an (imported or defined) event tag within a module
+(see [event index space](#event-index-space) for details).
+
+### Exceptions
+
+An `exception` is an internal construct in WebAssembly . WebAssembly exceptions
+are defined in the `event` and import sections of a module. Each event (with an
+exception attribute) defines an `exception`. The event index is also called the
+`exception index`. Similarly, the corresponding event tag is called an
+`exception tag`.
+
+Exception indices are used by:
+
+1. The `throw` instruction which creates a WebAssembly exception
+   with the corresponding exception tag, and then throws it.
+
+2. The `if_except` instruction queries an exception to see if the corresponding
+   exception tag denoted by the exception index.  If true it pushes the
+   corresponding values of the exception onto the stack.
+   
+### The exception reference data type
+
+Data types are extended to have a new `except_ref` type, that refers to an
+exception. The representation of an exception is left to the implementation.
+
+### Try and catch blocks
+
+A _try block_ defines a list of instructions that may need to process exceptions
+and/or clean up state when an exception is thrown. Like other higher-level
+constructs, a try block begins with a `try` instruction, and ends with an `end`
+instruction. That is, a try block is sequence of instructions having the
+following form:
+
+```
+try block_type
+  instruction*
+catch
+  instruction*
+end
+```
+
+A try block ends with a `catch block` that is defined by the list of
+instructions after the `catch` instruction.
+
+Try blocks, like control-flow blocks, have a _block type_. The block type of a
+try block defines the values yielded by the evaluation the try block when either
+no exception is thrown, or the exception is successfully caught by the catch
+block.
+
+In the initial implementation, try blocks may only yield 0 or 1 values.
+
+### Throwing an exception
+
+The `throw` instruction takes an exception index as an immediate argument.  That
+index is used to identify the exception tag to use to create and throw the
+corresponding exception.
+
+The values on top of the stack must correspond to the type associated with the
+exception. These values are popped off the stack and are used (along with the
+corresponding exception tag) to create the corresponding exception. That
+exception is then thrown.
+
+When an exception is thrown, the embedder searches for the nearest enclosing try
+block body that execution is in. That try block is called the _catching_ try
+block.
+
+If the throw appears within the body of a try block, it is the catching try
+block.
+
+If a throw occurs within a function body, and it doesn't appear inside the body
+of a try block, the throw continues up the call stack until it is in the body of
+an an enclosing try block, or the call stack is flushed. If the call stack is
+flushed, the embedder defines how to handle uncaught exceptions.  Otherwise, the
+found enclosing try block is the catching try block.
+
+A throw inside the body of a catch block is never caught by the corresponding
+try block of the catch block, since instructions in the body of the catch block
+are not in the body of the try block.
+
+Once a catching try block is found for the thrown exception, the operand stack
+is popped back to the size the operand stack had when the try block was entered,
+and then an except_ref referring to the caught exception is pushed back onto the
+operand stack.
+
+If control is transferred to the body of a catch block, and the last instruction
+in the body is executed, control then exits the try block.
+
+If the selected catch block does not throw an exception, it must yield the
+value(s) expected by the corresponding catching try block. This includes popping
+the caught exception.
+
+Note that a caught exception can be rethrown using the `rethrow` instruction.
+
+### Rethrowing an exception
+
+The `rethrow` instruction takes the exception associated with the `except_ref`
+on top of the stack, and rethrows the exception. A rethrow has the same effect
+as a throw, other than an exception is not created. Rather, the referenced
+exception on top of the stack is popped and then thrown.
+
+### Exception data extraction
+
+The `if_except` block begins with an `if_except` instruction, and
+has two instruction blocks,
+
+That is, the forms of an if_except block is:
+
+```
+if_except block_type except_index
+  Instruction*
+end
+
+if_except block_type except_index
+  Instruction*
+else
+  Instruction*
+end
+```
+
+In the first form, the instructions between the `if_except` and 'end' define the
+`then block`. In the second form, the instructions between the `if_except` and
+`else` define the `then block`, while the instructions between the `else` and
+the `end` define the `else block`.
+
+The conditional query of an exception checks the exception tag of exception on
+top of the stack. It succeeds only if the exception index of the instruction
+matches the corresponding exception tag. Once the query completes, the exception
+is popped off the stack.
+
+If the query succeeds the values (associated with the popped exception) are
+extracted and pushed onto the stack, and control transfers to the instructions
+in the then block.
+
+If the query fails, it either enters the else block, or transfer control to the
+end of the if_except block if there is no else block.
+
+### Stack traces
+
+When an exception is thrown, the runtime will pop the stack across
+function calls until a corresponding, enclosing try block is found. It may also
+associate a stack trace that can be used to report uncaught exceptions. However,
+the details of this is left to the embedder.
+
+## Changes to the text format.
+
+This section describes change in the
+[instruction syntax document](https://github.com/WebAssembly/spec/blob/master/document/core/instructions.rst).
+
+### New instructions
+
+The following rules are added to *instructions*:
+
+```
+  try resulttype instruction* catch instruction* end |
+  except except_index |
+  throw except_index |
+  rethrow |
+  if_except resulttype except_index then instruction* end |
+  if_except resulttype except_index then instruction* else instruction* end
+```
+
+Like the `block`, `loop`, and `if` instructions, the `try` and `if_except`
+instructions are *structured* control flow instructions, and can be
+labeled. This allows branch instructions to exit try and `if_except` blocks.
+
+The `except_index` of the `throw` and `if_except` instructions defines the
+exception (and hence, exception tag) to create/extract from. See
+[exception index space](#exception-index-space) for further clarification of
+exception tags.
+
+## Changes to Modules document.
+
+This section describes change in the
+[Modules document](https://github.com/WebAssembly/design/blob/master/Modules.md).
+
+### Event index space
+
+The `event index space` indexes all imported and internally-defined events,
+assigning monotonically-increasing indices based on the order defined in the
+import and event sections. Thus, the index space starts at zero with
+imported events, followed by internally-defined events in the [event
+section](#event-section).
+
+The event index space defines the (module) static version of runtine event
+tags. For event indices that are not imported/exported, the corresponding event
+tag is guaranteed to be unique over all loaded modules. Events that are imported
+or exported alias the respective events defined elsewhere, and use the same tag.
+
+## Changes to the binary model
+
+This section describes changes in
+the
+[binary encoding design document](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md).
+
+### Data Types
+
+#### except_ref
+
+An exception reference points to an exception.
+
+### Language Types
+
+| Opcode | Type constructor |
+|--------|------------------|
+| -0x18  |  `except_ref`    |
+
+#### value_type
+
+A `varint7` indicating a `value_type` is extended to include `except_ref` as
+encoded above.
+
+#### Other Types
+
+##### event_type
+
+The set of event attributes are:
+
+| Name      | Value |
+|-----------|-------|
+| Exception | 0     |
+
+Each event type has the fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `attribute` | `varuint32` | The attribute of the event. |
+| `type` | `varuint32` | The type index for its corresponding type signature |
+
+##### external_kind
+
+A single-byte unsigned integer indicating the kind of definition being imported
+or defined:
+
+* `0` indicating a `Function` [import](Modules.md#imports) or [definition](Modules.md#function-and-code-sections)
+* `1` indicating a `Table` [import](Modules.md#imports) or [definition](Modules.md#table-section)
+* `2` indicating a `Memory` [import](Modules.md#imports) or [definition](Modules.md#linear-memory-section)
+* `3` indicating a `Global` [import](Modules.md#imports) or [definition](Modules.md#global-section)
+* `4` indicating an `Event` [import](#import-section) or [definition](#event-section)
+
+### Module structure
+
+#### High-level structure
+
+A new `event` section is introduced and is named `event`. If included, it must
+appear after immediately after the global section.
+
+##### Event section
+
+The `section` section is the named section 'event'. The event section
+declares a list of event types as follows:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| count | `varuint32` | count of the number of events to follow |
+| type | `except_type*` | The definitions of the event types |
+
+##### Import section
+
+The import section is extended to include event definitions by extending an
+`import_entry` as follows:
+
+If the `kind` is `Event`:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `type` | `event_type` | the event being imported |
+
+##### Export section
+
+The export section is extended to reference event types by
+extending an `export_entry` as follows:
+
+If the `kind` is `Event`:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `index` | `varuint32` | the index into the corresponding event index space |
+
+##### Name section
+
+The set of known values for `name_type` of a name section is extended as
+follows:
+
+| Name Type | Code | Description |
+| --------- | ---- | ----------- |
+| [Function](#function-names) | `1` | Assigns names to functions |
+| [Local](#local-names) | `2` | Assigns names to locals in functions |
+| [Event](#event-names) | `3` | Assigns names to event types |
+
+###### Event names
+
+The event names subsection is a `name_map` which assigns names to a subset of
+the event indices (Used for both imports and module-defined).
+
+### Control flow operators
+
+The control flow operators are extended to define try blocks, catch blocks,
+throws, and rethrows as follows:
+
+| Name | Opcode | Immediates | Description |
+| ---- | ---- | ---- | ---- |
+| `try` | `0x06` | sig : `block_type` | begins a block which can handle thrown exceptions |
+| `catch` | `0x07` | | begins the catch block of the try block |
+| `throw` | `0x08` | index : `varint32` | Creates an exception defined by the exception `index`and then throws it |
+| `rethrow` | `0x09` | | Pops the `except_ref` on top of the stack and throws it |
+| `if_except` | `0x0a` |  index : `varuint32`, sig : `block_type` | Begin exception data extraction if exception on stack was created using the corresponding exception `index` |
+
+The *sig* fields of `block`, `if`, `try` and `if_except` operators are block
+signatures which describe their use of the operand stack.
diff --git a/proposals/exception-handling/pre-legacy/Exceptions-v2.md b/proposals/exception-handling/pre-legacy/Exceptions-v2.md
new file mode 100644
index 0000000000..4ab9eb5f66
--- /dev/null
+++ b/proposals/exception-handling/pre-legacy/Exceptions-v2.md
@@ -0,0 +1,510 @@
+This V2 proposal was developed from [Level 1 Proposal](Exceptions-v2-Level-1.md)
+and superseded [V1 proposal](Exceptions-v1.md). We decided to adopt this
+proposal in [Oct 2018 CG
+meeting](https://github.com/WebAssembly/meetings/blob/main/main/2018/TPAC.md#exception-handling-ben-titzer),
+recognizing the need for a first-class exception type, based on the reasoning
+that it is more expressive and also more extendible to other kinds of events.
+
+This proposal was active from Oct 2018 to Sep 2020 and superseded by [V3
+proposal](https://github.com/WebAssembly/exception-handling/blob/main/proposals/exception-handling/legacy/Exceptions.md).
+
+---
+
+# Exception handling
+
+This proposal requires the following proposals as prerequisites.
+
+- The [reference types proposal](https://github.com/WebAssembly/reference-types/blob/master/proposals/reference-types/Overview.md),
+  since the [`exnref`](#the-exception-reference-data-type) type should be
+  represented as a subtype of `anyref`.
+
+- The [multi-value proposal](https://github.com/WebAssembly/multi-value/blob/master/proposals/multi-value/Overview.md),
+  since otherwise the [`br_on_exn`](#exception-data-extraction) instruction
+  would only work with exceptions that contain one value. Moreover, by using
+  [multi-value](https://github.com/WebAssembly/multi-value/blob/master/proposals/multi-value/Overview.md),
+  the [`try` blocks](#try-and-catch-blocks) may use values already in the stack,
+  and also push multiple values onto the stack.
+
+---
+
+## Overview
+
+Exception handling allows code to break control flow when an exception is
+thrown. The exception can be any exception known by the WebAssembly module, or
+it may an unknown exception that was thrown by a called imported function.
+
+One of the problems with exception handling is that both WebAssembly and an
+embedder have different notions of what exceptions are, but both must be aware
+of the other.
+
+It is difficult to define exceptions in WebAssembly because (in general) it
+doesn't have knowledge of any embedder. Further, adding such knowledge to
+WebAssembly would limit the ability for other embedders to support WebAssembly
+exceptions.
+
+One issue is that both sides need to know if an exception was thrown by the
+other, because cleanup may need to be performed.
+
+Another problem is that WebAssembly doesn't have direct access to an embedder's
+memory. As a result, WebAssembly defers the handling of exceptions to the host
+VM.
+
+To access exceptions, WebAssembly provides instructions to check if the
+exception is one that WebAssembly understands. If so, the data of the
+WebAssembly exception is extracted and copied onto the stack, allowing
+succeeding instructions to process the data.
+
+Lastly, exception lifetimes may be maintained by the embedder, so that it can
+collect and reuse the memory used by exceptions. This implies that an embedder
+needs to know where exceptions are stored, so that it can determine when an
+exception can be garbage collected.
+
+This also implies that embedders must provide a garbage collector for
+exceptions. For embedders that have garbage collection (such as JavaScript),
+this is not a problem.
+
+However, not all embedders may have a garbage collector. For this reason,
+WebAssembly exceptions are designed to allow other storage management methods,
+such as reference counting, to perform the garbage collection in the embedder.
+
+To do this, WebAssembly exceptions are immutable once created, to avoid cyclic
+data structures that cannot easily be reference-counted. It also means that
+exceptions can't be stored into linear memory. The rationale for this is
+twofold:
+
+* For security. Loads and stores do not guarantee that the data read was of the
+  same type as stored. This allows spoofing of exception references that may
+  allow a WebAssembly module to access data it should not know in the host VM.
+
+* The embedder does not know the layout of data in linear memory, so it can't
+  find places where exception references are stored.
+
+Hence, while an exception reference is a new first class type, this proposal
+disallows their usage in linear memory. The exception reference type can be
+represented as a subtype of `anyref` type introduced in [WebAssembly reference
+type
+proposal](https://github.com/WebAssembly/reference-types/blob/master/proposals/reference-types/Overview.md).
+
+A WebAssembly exception is created when you throw it with the `throw`
+instruction. Thrown exceptions are handled as follows:
+
+1. They can be caught by a catch block in an enclosing try block of a function
+   body. The caught exception is pushed onto the stack.
+
+1. Throws not caught within a function body continue up the call stack, popping
+   call frames, until an enclosing try block is found.
+
+1. If the call stack is exhausted without any enclosing try blocks, the embedder
+   defines how to handle the uncaught exception.
+
+### Event handling
+
+This proposal adds exception handling to WebAssembly. Part of this proposal is
+to define a new section to declare exceptions. However, rather than limiting
+this new section to just defining exceptions, it defines a more general format
+that allows the declaration of other forms of events.
+
+In general, an event handler allows one to process an event generated by a block
+of code. Events suspend the current execution and look for a corresponding event
+handler. If found, the corresponding event handler is run. Some event handlers
+may send values back to the suspended instruction, allowing the originating code
+to resume.
+
+Exceptions are a special case of an event in that they never resume. Similarly,
+a throw instruction is the suspending event of an exception. The catch block
+associated with a try block defines how to handle the throw.
+
+WebAssembly events (i.e. exceptions) are defined by a new `event` section of a
+WebAssembly module. The event section is a list of declared events associated
+with the module.
+
+Each event has an `attribute` and a `type`. Currently, the attribute can only
+specify that the event is an exception. In the future, additional attribute
+values may be added when other events are added to WebAssembly.
+
+To allow for such a future extension possibility, we reserve a byte in the
+binary format of an exception definition, set to 0 to denote an exception
+attribute, but for the moment we won't use the term event in the formal spec.
+
+### Exceptions
+
+An `exception` is an internal construct in WebAssembly. WebAssembly exceptions
+are defined in the event and import sections of a module.
+
+The type of an exception is denoted by an index to a function signature defined
+in the `type` section. The parameters of the function signature define the list
+of values associated with the exception. The result type must be empty.
+
+An `exception tag` is a value to distinguish different exceptions, while an
+`exception index` is a numeric name to refer to an (imported or defined)
+exception tag within a module (see [exception index
+space](#exception-index-space) for details).
+
+Exception indices are used by:
+
+1. The `throw` instruction which creates a WebAssembly exception with the
+   corresponding exception tag, and then throws it.
+
+2. The `br_on_exn` instruction queries an exception to see if it matches the
+   corresponding exception tag denoted by the exception index. If true it
+   branches to the given label and pushes the corresponding argument values of
+   the exception onto the stack.
+
+### The exception reference data type
+
+Data types are extended to have a new `exnref` type, that refers to an
+exception. The representation of an exception is left to the implementation.
+
+### Try and catch blocks
+
+A _try block_ defines a list of instructions that may need to process exceptions
+and/or clean up state when an exception is thrown. Like other higher-level
+constructs, a try block begins with a `try` instruction, and ends with an `end`
+instruction. That is, a try block is sequence of instructions having the
+following form:
+
+```
+try blocktype
+  instruction*
+catch
+  instruction*
+end
+```
+
+A try block ends with a `catch block` that is defined by the list of
+instructions after the `catch` instruction.
+
+Try blocks, like control-flow blocks, have a _block type_. The block type of a
+try block defines the values yielded by evaluating the try block when either no
+exception is thrown, or the exception is successfully caught by the catch block.
+Because `try` and `end` instructions define a control-flow block, they can be
+targets for branches (`br` and `br_if`) as well.
+
+In the initial implementation, try blocks may only yield 0 or 1 values.
+
+### Throwing an exception
+
+The `throw` instruction takes an exception index as an immediate argument. That
+index is used to identify the exception tag to use to create and throw the
+corresponding exception.
+
+The values on top of the stack must correspond to the type associated with the
+exception. These values are popped off the stack and are used (along with the
+corresponding exception tag) to create the corresponding exception. That
+exception is then thrown.
+
+When an exception is thrown, the embedder searches for the nearest enclosing try
+block body that execution is in. That try block is called the _catching_ try
+block.
+
+If the throw appears within the body of a try block, it is the catching try
+block.
+
+If a throw occurs within a function body, and it doesn't appear inside the body
+of a try block, the throw continues up the call stack until it is in the body of
+an an enclosing try block, or the call stack is flushed. If the call stack is
+flushed, the embedder defines how to handle uncaught exceptions. Otherwise, the
+found enclosing try block is the catching try block.
+
+A throw inside the body of a catch block is never caught by the corresponding
+try block of the catch block, since instructions in the body of the catch block
+are not in the body of the try block.
+
+Once a catching try block is found for the thrown exception, the operand stack
+is popped back to the size the operand stack had when the try block was entered,
+and then an `exnref` referring to the caught exception is pushed back onto the
+operand stack.
+
+If control is transferred to the body of a catch block, and the last instruction
+in the body is executed, control then exits the try block.
+
+If the selected catch block does not throw an exception, it must yield the
+value(s) expected by the corresponding catching try block. This includes popping
+the caught exception.
+
+Note that a caught exception can be rethrown using the `rethrow` instruction.
+
+### Rethrowing an exception
+
+The `rethrow` instruction takes the exception associated with the `exnref` on
+top of the stack, and rethrows the exception. A rethrow has the same effect as a
+throw, other than an exception is not created. Rather, the referenced exception
+on top of the stack is popped and then thrown. The `rethrow` instruction traps
+if the value on the top of the stack is null.
+
+### Exception data extraction
+
+The `br_on_exn` instruction is a conditional branch that checks the exception
+tag of an exception on top of the stack, in the form of:
+
+```
+br_on_exn label except_index
+```
+
+The `br_on_exn` instruction checks the exception tag of an `exnref` on top of
+the stack if it matches the given exception index. If it does, it branches out
+to the label referenced by the instruction (In the binary form, the label will
+be converted to a relative depth immediate, like other branch instructions), and
+while doing that, pops the `exnref` value from the stack and instead pushes the
+exception's argument values on top of the stack. In order to use these popped
+values, the block signature of the branch target has to match the exception
+types - because it receives the exception arguments as branch operands. If the
+exception tag does not match, the `exnref` value remains on the stack. For
+example, when an `exnref` contains an exception of type (i32 i64), the target
+block signature should be (i32 i64) as well, as in the following example:
+
+```
+block $l (result i32 i64)
+  ...
+  ;; exnref $e is on the stack at this point
+  br_on_exn $l ;; branch to $l with $e's arguments
+  ...
+end
+```
+
+This can now be used to construct handler switches in the same way `br_table`
+is used to construct regular switch:
+
+```
+block $end
+  block $l1
+    ...
+      block $lN
+        br_on_exn $l1
+        ...
+        br_on_exn $lN
+        rethrow
+      end $lN
+      ;; handler for $eN here
+      br $end
+    ...
+  end $l1
+  ;; handler for $e1
+end $end
+```
+
+If the query fails, the control flow falls through, and no values are pushed
+onto the stack. The `br_on_exn` instruction traps if the value on the top of the
+stack is null.
+
+### Stack traces
+
+When an exception is thrown, the runtime will pop the stack across function
+calls until a corresponding, enclosing try block is found. It may also associate
+a stack trace that can be used to report uncaught exceptions. However, the
+details of this is left to the embedder.
+
+### Traps and JS API
+
+The `catch` instruction catches exceptions generated by the `throw` instruction,
+but does not catch traps. The rationale for this is that in general traps are
+not locally recoverable and are not needed to be handled in local scopes like
+try-catch.
+
+The `catch` instruction catches foreign exceptions generated from calls to
+function imports as well, including JavaScript exceptions, with a few
+exceptions:
+1. In order to be consistent before and after a trap reaches a JavaScript frame,
+   the `catch` instruction does not catch exceptions generated from traps.
+1. The `catch` instruction does not catch JavaScript exceptions generated from
+   stack overflow and out of memory.
+
+Filtering these exceptions should be based on a predicate that is not observable
+by JavaScript. Traps currently generate instances of
+[`WebAssembly.RuntimeError`](https://webassembly.github.io/reference-types/js-api/#exceptiondef-runtimeerror),
+but this detail is not used to decide type. Implementations are supposed to
+specially mark non-catchable exceptions.
+([`instanceof`](https://tc39.es/ecma262/#sec-instanceofoperator) predicate can
+be intercepted in JS, and types of exceptions generated from stack overflow and
+out of memory are implementation-defined.)
+
+## Changes to the text format
+
+This section describes change in the [instruction syntax
+document](https://github.com/WebAssembly/spec/blob/master/document/core/text/instructions.rst).
+
+### New instructions
+
+The following rules are added to *instructions*:
+
+```
+  try blocktype instruction* catch instruction* end |
+  throw (exception except_index) |
+  rethrow |
+  br_on_exn label (exception except_index)
+```
+
+Like the `block`, `loop`, and `if` instructions, the `try` instruction is
+*structured* control flow instruction, and can be labeled. This allows branch
+instructions to exit try blocks.
+
+The `except_index` of the `throw` and `br_on_exn` instructions defines the
+exception (and hence, exception tag) to create/extract from. See [exception
+index space](#exception-index-space) for further clarification of exception
+tags.
+
+## Changes to Modules document
+
+This section describes change in the [Modules
+document](https://github.com/WebAssembly/design/blob/master/Modules.md).
+
+### Exception index space
+
+The `exception index space` indexes all imported and internally-defined
+exceptions, assigning monotonically-increasing indices based on the order
+defined in the import and exception sections. Thus, the index space starts at
+zero with imported exceptions, followed by internally-defined exceptions in the
+[exception section](#exception-section).
+
+The exception index space defines the (module) static version of runtime
+exception tags. For exception indices that are not imported/exported, the
+corresponding exception tag is guaranteed to be unique over all loaded modules.
+Exceptions that are imported or exported alias the respective exceptions defined
+elsewhere, and use the same tag.
+
+## Changes to the binary model
+
+This section describes changes in the [binary encoding design
+document](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md).
+
+### Data Types
+
+#### exnref
+
+An exception reference points to an exception.
+
+### Language Types
+
+| Opcode | Type constructor |
+|--------|------------------|
+| -0x18  |  `exnref`        |
+
+#### value_type
+
+A `varint7` indicating a `value_type` is extended to include `exnref` as encoded
+above.
+
+#### Other Types
+
+##### exception_type
+
+We reserve a bit to denote the exception attribute:
+
+| Name      | Value |
+|-----------|-------|
+| Exception | 0     |
+
+Each exception type has the fields:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `attribute` | `varuint32` | The attribute of an exception. |
+| `type` | `varuint32` | The type index for its corresponding type signature |
+
+##### external_kind
+
+A single-byte unsigned integer indicating the kind of definition being imported
+or defined:
+
+* `0` indicating a `Function` [import](Modules.md#imports) or
+[definition](Modules.md#function-and-code-sections)
+* `1` indicating a `Table` [import](Modules.md#imports) or
+[definition](Modules.md#table-section)
+* `2` indicating a `Memory` [import](Modules.md#imports) or
+[definition](Modules.md#linear-memory-section)
+* `3` indicating a `Global` [import](Modules.md#imports) or
+[definition](Modules.md#global-section)
+* `4` indicating an `Exception` [import](#import-section) or
+[definition](#exception-section)
+
+### Module structure
+
+#### High-level structure
+
+A new `exception` section is introduced and is named `exception`. If included,
+it must appear immediately after the memory section.
+
+##### Exception section
+
+The `exception` section is the named section 'exception'. For ease of
+validation, this section comes after the [memory
+section](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#memory-section)
+and before the [global
+section](https://github.com/WebAssembly/design/blob/master/BinaryEncoding.md#global-section).
+So the list of all sections will be:
+
+| Section Name | Code | Description |
+| ------------ | ---- | ----------- |
+| Type | `1` | Function signature declarations |
+| Import | `2` | Import declarations |
+| Function | `3` | Function declarations |
+| Table | `4` | Indirect function table and other tables |
+| Memory | `5` | Memory attributes |
+| Exception | `13` | Exception declarations |
+| Global | `6` | Global declarations |
+| Export | `7` | Exports |
+| Start | `8` | Start function declaration |
+| Element | `9` | Elements section |
+| Code | `10` | Function bodies (code) |
+| Data | `11` | Data segments |
+
+The exception section declares a list of exception types as follows:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| count | `varuint32` | count of the number of exceptions to follow |
+| type | `exception_type*` | The definitions of the exception types |
+
+##### Import section
+
+The import section is extended to include exception definitions by extending an
+`import_entry` as follows:
+
+If the `kind` is `Exception`:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `type` | `exception_type` | the exception being imported |
+
+##### Export section
+
+The export section is extended to reference exception types by extending an
+`export_entry` as follows:
+
+If the `kind` is `Exception`:
+
+| Field | Type | Description |
+|-------|------|-------------|
+| `index` | `varuint32` | the index into the corresponding exception index space |
+
+##### Name section
+
+The set of known values for `name_type` of a name section is extended as
+follows:
+
+| Name Type | Code | Description |
+| --------- | ---- | ----------- |
+| [Function](#function-names) | `1` | Assigns names to functions |
+| [Local](#local-names) | `2` | Assigns names to locals in functions |
+| [Exception](#exception-names) | `3` | Assigns names to exception types |
+
+###### Exception names
+
+The exception names subsection is a `name_map` which assigns names to a subset
+of the exception indices (Used for both imports and module-defined).
+
+### Control flow operators
+
+The control flow operators are extended to define try blocks, catch blocks,
+throws, and rethrows as follows:
+
+| Name | Opcode | Immediates | Description |
+| ---- | ---- | ---- | ---- |
+| `try` | `0x06` | sig : `blocktype` | begins a block which can handle thrown exceptions |
+| `catch` | `0x07` | | begins the catch block of the try block |
+| `throw` | `0x08` | index : `varint32` | Creates an exception defined by the exception `index`and then throws it |
+| `rethrow` | `0x09` | | Pops the `exnref` on top of the stack and throws it |
+| `br_on_exn` | `0x0a` |  relative_depth : `varuint32`, index : `varuint32` | Branches to the given label and extracts data within `exnref` on top of stack if it was created using the corresponding exception `index` |
+
+The *sig* fields of `block`, `if`, and `try` operators are block signatures
+which describe their use of the operand stack.
diff --git a/spectec/spec/wasm-1.0/4-runtime.watsup b/spectec/spec/wasm-1.0/4-runtime.watsup
index 268f7e22f2..581de45971 100644
--- a/spectec/spec/wasm-1.0/4-runtime.watsup
+++ b/spectec/spec/wasm-1.0/4-runtime.watsup
@@ -15,6 +15,14 @@ var ta : tableaddr
 var ma : memaddr
 
 
+;; External addresses
+
+syntax externaddr hint(desc "external value") =
+  | FUNC funcaddr | GLOBAL globaladdr | TABLE tableaddr | MEM memaddr
+
+var xa : externaddr
+
+
 ;;
 ;; Values
 ;;
@@ -31,14 +39,6 @@ var v : val
 var res : result
 
 
-;; External values
-
-syntax externval hint(desc "external value") =
-  | FUNC funcaddr | GLOBAL globaladdr | TABLE tableaddr | MEM memaddr
-
-var xv : externval
-
-
 ;;
 ;; Configurations
 ;;
@@ -60,7 +60,7 @@ syntax meminst hint(desc "memory instance") =
     BYTES byte* }
 syntax exportinst hint(desc "export instance") =
   { NAME name,
-    VALUE externval }
+    ADDR externaddr }
 
 syntax moduleinst hint(desc "module instance") =
   { TYPES functype*,
diff --git a/spectec/spec/wasm-1.0/5-runtime-aux.watsup b/spectec/spec/wasm-1.0/5-runtime-aux.watsup
index 705d67de7c..fbc6ce5fcb 100644
--- a/spectec/spec/wasm-1.0/5-runtime-aux.watsup
+++ b/spectec/spec/wasm-1.0/5-runtime-aux.watsup
@@ -14,26 +14,26 @@ def $default_(F64) = (CONST F64 $fzero(64))
 
 ;; Projections
 
-def $funcsxv(externval*) : funcaddr*     hint(show $funcs(%))
-def $globalsxv(externval*) : globaladdr* hint(show $globals(%))
-def $tablesxv(externval*) : tableaddr*   hint(show $tables(%))
-def $memsxv(externval*) : memaddr*       hint(show $mems(%))
-
-def $funcsxv(eps) = eps
-def $funcsxv((FUNC fa) xv*) = fa $funcsxv(xv*)
-def $funcsxv(externval xv*) = $funcsxv(xv*)  -- otherwise
-
-def $globalsxv(eps) = eps
-def $globalsxv((GLOBAL ga) xv*) = ga $globalsxv(xv*)
-def $globalsxv(externval xv*) = $globalsxv(xv*)  -- otherwise
-
-def $tablesxv(eps) = eps
-def $tablesxv((TABLE ta) xv*) = ta $tablesxv(xv*)
-def $tablesxv(externval xv*) = $tablesxv(xv*)  -- otherwise
-
-def $memsxv(eps) = eps
-def $memsxv((MEM ma) xv*) = ma $memsxv(xv*)
-def $memsxv(externval xv*) = $memsxv(xv*)  -- otherwise
+def $funcsxa(externaddr*) : funcaddr*     hint(show $funcs(%))
+def $globalsxa(externaddr*) : globaladdr* hint(show $globals(%))
+def $tablesxa(externaddr*) : tableaddr*   hint(show $tables(%))
+def $memsxa(externaddr*) : memaddr*       hint(show $mems(%))
+
+def $funcsxa(eps) = eps
+def $funcsxa((FUNC fa) xv*) = fa $funcsxa(xv*)
+def $funcsxa(externaddr xv*) = $funcsxa(xv*)  -- otherwise
+
+def $globalsxa(eps) = eps
+def $globalsxa((GLOBAL ga) xv*) = ga $globalsxa(xv*)
+def $globalsxa(externaddr xv*) = $globalsxa(xv*)  -- otherwise
+
+def $tablesxa(eps) = eps
+def $tablesxa((TABLE ta) xv*) = ta $tablesxa(xv*)
+def $tablesxa(externaddr xv*) = $tablesxa(xv*)  -- otherwise
+
+def $memsxa(eps) = eps
+def $memsxa((MEM ma) xv*) = ma $memsxa(xv*)
+def $memsxa(externaddr xv*) = $memsxa(xv*)  -- otherwise
 
 
 
diff --git a/spectec/spec/wasm-1.0/9-module.watsup b/spectec/spec/wasm-1.0/9-module.watsup
index 698493a5d0..aa2e789cb0 100644
--- a/spectec/spec/wasm-1.0/9-module.watsup
+++ b/spectec/spec/wasm-1.0/9-module.watsup
@@ -2,28 +2,28 @@
 ;; Projections
 ;;
 
-def $funcs(externval*) : funcaddr*
+def $funcs(externaddr*) : funcaddr*
 def $funcs(eps) = eps
-def $funcs((FUNC fa) externval'*) = fa $funcs(externval'*)
-def $funcs(externval externval'*) = $funcs(externval'*)
+def $funcs((FUNC fa) externaddr'*) = fa $funcs(externaddr'*)
+def $funcs(externaddr externaddr'*) = $funcs(externaddr'*)
   -- otherwise
 
-def $globals(externval*) : globaladdr*
+def $globals(externaddr*) : globaladdr*
 def $globals(eps) = eps
-def $globals((GLOBAL ga) externval'*) = ga $globals(externval'*)
-def $globals(externval externval'*) = $globals(externval'*)
+def $globals((GLOBAL ga) externaddr'*) = ga $globals(externaddr'*)
+def $globals(externaddr externaddr'*) = $globals(externaddr'*)
   -- otherwise
 
-def $tables(externval*) : tableaddr*
+def $tables(externaddr*) : tableaddr*
 def $tables(eps) = eps
-def $tables((TABLE ta) externval'*) = ta $tables(externval'*)
-def $tables(externval externval'*) = $tables(externval'*)
+def $tables((TABLE ta) externaddr'*) = ta $tables(externaddr'*)
+def $tables(externaddr externaddr'*) = $tables(externaddr'*)
   -- otherwise
 
-def $mems(externval*) : memaddr*
+def $mems(externaddr*) : memaddr*
 def $mems(eps) = eps
-def $mems((MEM ma) externval'*) = ma $mems(externval'*)
-def $mems(externval externval'*) = $mems(externval'*)
+def $mems((MEM ma) externaddr'*) = ma $mems(externaddr'*)
+def $mems(externaddr externaddr'*) = $mems(externaddr'*)
   -- otherwise
 
 
@@ -78,14 +78,14 @@ def $allocmems(s, memtype memtype'*) = (s_2, ma ma'*)
 ;; Modules
 
 def $instexport(funcaddr*, globaladdr*, tableaddr*, memaddr*, export) : exportinst
-def $instexport(fa*, ga*, ta*, ma*, EXPORT name (FUNC x)) = { NAME name, VALUE (FUNC fa*[x]) }
-def $instexport(fa*, ga*, ta*, ma*, EXPORT name (GLOBAL x)) = { NAME name, VALUE (GLOBAL ga*[x]) }
-def $instexport(fa*, ga*, ta*, ma*, EXPORT name (TABLE x)) = { NAME name, VALUE (TABLE ta*[x]) }
-def $instexport(fa*, ga*, ta*, ma*, EXPORT name (MEM x)) = { NAME name, VALUE (MEM ma*[x]) }
+def $instexport(fa*, ga*, ta*, ma*, EXPORT name (FUNC x)) = { NAME name, ADDR (FUNC fa*[x]) }
+def $instexport(fa*, ga*, ta*, ma*, EXPORT name (GLOBAL x)) = { NAME name, ADDR (GLOBAL ga*[x]) }
+def $instexport(fa*, ga*, ta*, ma*, EXPORT name (TABLE x)) = { NAME name, ADDR (TABLE ta*[x]) }
+def $instexport(fa*, ga*, ta*, ma*, EXPORT name (MEM x)) = { NAME name, ADDR (MEM ma*[x]) }
 
 
-def $allocmodule(store, module, externval*, val*) : (store, moduleinst)
-def $allocmodule(s, module, externval*, val*) = (s_4, moduleinst)
+def $allocmodule(store, module, externaddr*, val*) : (store, moduleinst)
+def $allocmodule(s, module, externaddr*, val*) = (s_4, moduleinst)
   -- if module =
     MODULE
       (TYPE ft)*
@@ -98,10 +98,10 @@ def $allocmodule(s, module, externval*, val*) = (s_4, moduleinst)
       data*
       start?
       export*
-  -- if fa_ex* = $funcs(externval*)
-  -- if ga_ex* = $globals(externval*)
-  -- if ta_ex* = $tables(externval*)
-  -- if ma_ex* = $mems(externval*)
+  -- if fa_ex* = $funcs(externaddr*)
+  -- if ga_ex* = $globals(externaddr*)
+  -- if ta_ex* = $tables(externaddr*)
+  -- if ma_ex* = $mems(externaddr*)
   -- if fa* = $(|s.FUNCS|+i_func)^(i_func* z; val)*
   -- (Eval_expr : z; expr_E ~>* z; (CONST I32 i_E))*
   -- (Eval_expr : z; expr_D ~>* z; (CONST I32 i_D))*
-  -- if (s_1, moduleinst) = $allocmodule(s, module, externval*, val*)
+  -- if (s_1, moduleinst) = $allocmodule(s, module, externaddr*, val*)
   -- if s_2 = $initelem(s_1, moduleinst, i_E*, moduleinst.FUNCS[x]**)
   -- if s_3 = $initdata(s_2, moduleinst, i_D*, b**)
   -- if f = { MODULE moduleinst }
diff --git a/spectec/spec/wasm-2.0/4-runtime.watsup b/spectec/spec/wasm-2.0/4-runtime.watsup
index 99d7958cb1..cc82019b4b 100644
--- a/spectec/spec/wasm-2.0/4-runtime.watsup
+++ b/spectec/spec/wasm-2.0/4-runtime.watsup
@@ -20,6 +20,14 @@ var ea : elemaddr
 var da : dataaddr
 
 
+;; External addresses
+
+syntax externaddr hint(desc "external value") =
+  | FUNC funcaddr | GLOBAL globaladdr | TABLE tableaddr | MEM memaddr
+
+var xa : externaddr
+
+
 ;;
 ;; Values
 ;;
@@ -43,14 +51,6 @@ var v : val
 var res : result
 
 
-;; External values
-
-syntax externval hint(desc "external value") =
-  | FUNC funcaddr | GLOBAL globaladdr | TABLE tableaddr | MEM memaddr
-
-var xv : externval
-
-
 ;;
 ;; Configurations
 ;;
@@ -77,7 +77,7 @@ syntax datainst hint(desc "data instance") =
   { BYTES byte* }
 syntax exportinst hint(desc "export instance") =
   { NAME name,
-    VALUE externval }
+    ADDR externaddr }
 
 syntax moduleinst hint(desc "module instance") =
   { TYPES functype*,
diff --git a/spectec/spec/wasm-2.0/5-runtime-aux.watsup b/spectec/spec/wasm-2.0/5-runtime-aux.watsup
index 41d915b315..f73103f0b2 100644
--- a/spectec/spec/wasm-2.0/5-runtime-aux.watsup
+++ b/spectec/spec/wasm-2.0/5-runtime-aux.watsup
@@ -17,26 +17,26 @@ def $default_(EXTERNREF) = (REF.NULL EXTERNREF)
 
 ;; Projections
 
-def $funcsxv(externval*) : funcaddr*     hint(show $funcs(%))
-def $globalsxv(externval*) : globaladdr* hint(show $globals(%))
-def $tablesxv(externval*) : tableaddr*   hint(show $tables(%))
-def $memsxv(externval*) : memaddr*       hint(show $mems(%))
-
-def $funcsxv(eps) = eps
-def $funcsxv((FUNC fa) xv*) = fa $funcsxv(xv*)
-def $funcsxv(externval xv*) = $funcsxv(xv*)  -- otherwise
-
-def $globalsxv(eps) = eps
-def $globalsxv((GLOBAL ga) xv*) = ga $globalsxv(xv*)
-def $globalsxv(externval xv*) = $globalsxv(xv*)  -- otherwise
-
-def $tablesxv(eps) = eps
-def $tablesxv((TABLE ta) xv*) = ta $tablesxv(xv*)
-def $tablesxv(externval xv*) = $tablesxv(xv*)  -- otherwise
-
-def $memsxv(eps) = eps
-def $memsxv((MEM ma) xv*) = ma $memsxv(xv*)
-def $memsxv(externval xv*) = $memsxv(xv*)  -- otherwise
+def $funcsxa(externaddr*) : funcaddr*     hint(show $funcs(%))
+def $globalsxa(externaddr*) : globaladdr* hint(show $globals(%))
+def $tablesxa(externaddr*) : tableaddr*   hint(show $tables(%))
+def $memsxa(externaddr*) : memaddr*       hint(show $mems(%))
+
+def $funcsxa(eps) = eps
+def $funcsxa((FUNC fa) xv*) = fa $funcsxa(xv*)
+def $funcsxa(externaddr xv*) = $funcsxa(xv*)  -- otherwise
+
+def $globalsxa(eps) = eps
+def $globalsxa((GLOBAL ga) xv*) = ga $globalsxa(xv*)
+def $globalsxa(externaddr xv*) = $globalsxa(xv*)  -- otherwise
+
+def $tablesxa(eps) = eps
+def $tablesxa((TABLE ta) xv*) = ta $tablesxa(xv*)
+def $tablesxa(externaddr xv*) = $tablesxa(xv*)  -- otherwise
+
+def $memsxa(eps) = eps
+def $memsxa((MEM ma) xv*) = ma $memsxa(xv*)
+def $memsxa(externaddr xv*) = $memsxa(xv*)  -- otherwise
 
 
 ;;
diff --git a/spectec/spec/wasm-2.0/9-module.watsup b/spectec/spec/wasm-2.0/9-module.watsup
index 03ffedda44..9fbda8e653 100644
--- a/spectec/spec/wasm-2.0/9-module.watsup
+++ b/spectec/spec/wasm-2.0/9-module.watsup
@@ -2,28 +2,28 @@
 ;; Projections
 ;;
 
-def $funcs(externval*) : funcaddr*
+def $funcs(externaddr*) : funcaddr*
 def $funcs(eps) = eps
-def $funcs((FUNC fa) externval'*) = fa $funcs(externval'*)
-def $funcs(externval externval'*) = $funcs(externval'*)
+def $funcs((FUNC fa) externaddr'*) = fa $funcs(externaddr'*)
+def $funcs(externaddr externaddr'*) = $funcs(externaddr'*)
   -- otherwise
 
-def $globals(externval*) : globaladdr*
+def $globals(externaddr*) : globaladdr*
 def $globals(eps) = eps
-def $globals((GLOBAL ga) externval'*) = ga $globals(externval'*)
-def $globals(externval externval'*) = $globals(externval'*)
+def $globals((GLOBAL ga) externaddr'*) = ga $globals(externaddr'*)
+def $globals(externaddr externaddr'*) = $globals(externaddr'*)
   -- otherwise
 
-def $tables(externval*) : tableaddr*
+def $tables(externaddr*) : tableaddr*
 def $tables(eps) = eps
-def $tables((TABLE ta) externval'*) = ta $tables(externval'*)
-def $tables(externval externval'*) = $tables(externval'*)
+def $tables((TABLE ta) externaddr'*) = ta $tables(externaddr'*)
+def $tables(externaddr externaddr'*) = $tables(externaddr'*)
   -- otherwise
 
-def $mems(externval*) : memaddr*
+def $mems(externaddr*) : memaddr*
 def $mems(eps) = eps
-def $mems((MEM ma) externval'*) = ma $mems(externval'*)
-def $mems(externval externval'*) = $mems(externval'*)
+def $mems((MEM ma) externaddr'*) = ma $mems(externaddr'*)
+def $mems(externaddr externaddr'*) = $mems(externaddr'*)
   -- otherwise
 
 
@@ -82,7 +82,7 @@ def $allocelems(store, reftype*, (ref*)*) : (store, elemaddr*)
 def $allocelems(s, eps, eps) = (s, eps)
 def $allocelems(s, rt rt'*, (ref*) (ref'*)*) = (s_2, ea ea'*)
   -- if (s_1, ea) = $allocelem(s, rt, ref*)
-  -- if (s_2, ea'*) = $allocelems(s_2, rt'*, (ref'*)*)
+  -- if (s_2, ea'*) = $allocelems(s_1, rt'*, (ref'*)*)
 
 def $allocdata(store, byte*) : (store, dataaddr)
 def $allocdata(s, byte*) = (s[.DATAS =++ di], |s.DATAS|)
@@ -98,14 +98,14 @@ def $allocdatas(s, (byte*) (byte'*)*) = (s_2, da da'*)
 ;; Modules
 
 def $instexport(funcaddr*, globaladdr*, tableaddr*, memaddr*, export) : exportinst
-def $instexport(fa*, ga*, ta*, ma*, EXPORT name (FUNC x)) = { NAME name, VALUE (FUNC fa*[x]) }
-def $instexport(fa*, ga*, ta*, ma*, EXPORT name (GLOBAL x)) = { NAME name, VALUE (GLOBAL ga*[x]) }
-def $instexport(fa*, ga*, ta*, ma*, EXPORT name (TABLE x)) = { NAME name, VALUE (TABLE ta*[x]) }
-def $instexport(fa*, ga*, ta*, ma*, EXPORT name (MEM x)) = { NAME name, VALUE (MEM ma*[x]) }
+def $instexport(fa*, ga*, ta*, ma*, EXPORT name (FUNC x)) = { NAME name, ADDR (FUNC fa*[x]) }
+def $instexport(fa*, ga*, ta*, ma*, EXPORT name (GLOBAL x)) = { NAME name, ADDR (GLOBAL ga*[x]) }
+def $instexport(fa*, ga*, ta*, ma*, EXPORT name (TABLE x)) = { NAME name, ADDR (TABLE ta*[x]) }
+def $instexport(fa*, ga*, ta*, ma*, EXPORT name (MEM x)) = { NAME name, ADDR (MEM ma*[x]) }
 
 
-def $allocmodule(store, module, externval*, val*, (ref*)*) : (store, moduleinst)
-def $allocmodule(s, module, externval*, val*, (ref*)*) = (s_6, moduleinst)
+def $allocmodule(store, module, externaddr*, val*, (ref*)*) : (store, moduleinst)
+def $allocmodule(s, module, externaddr*, val*, (ref*)*) = (s_6, moduleinst)
   -- if module =
     MODULE
       (TYPE ft)*
@@ -118,10 +118,10 @@ def $allocmodule(s, module, externval*, val*, (ref*)*) = (s_6, moduleinst)
       (DATA byte* datamode)^n_data
       start?
       export*
-  -- if fa_ex* = $funcs(externval*)
-  -- if ga_ex* = $globals(externval*)
-  -- if ta_ex* = $tables(externval*)
-  -- if ma_ex* = $mems(externval*)
+  -- if fa_ex* = $funcs(externaddr*)
+  -- if ga_ex* = $globals(externaddr*)
+  -- if ta_ex* = $tables(externaddr*)
+  -- if ma_ex* = $mems(externaddr*)
   -- if fa* = $(|s.FUNCS|+i_func)^(i_func* z; val)*
   -- (Eval_expr : z; expr_E ~>* z; ref)**
-  -- if (s', moduleinst) = $allocmodule(s, module, externval*, val*, (ref*)*)
+  -- if (s', moduleinst) = $allocmodule(s, module, externaddr*, val*, (ref*)*)
   -- if f = { MODULE moduleinst }
   -- if instr_E* = $concat_(instr, $runelem(elem*[i], i)^(i externtype* hint(macro "toM")
 
@@ -259,9 +263,11 @@ syntax moduletype hint(desc "module type") = externtype* -> externtype* hint(mac
 var lim : limits
 
 var t : valtype
+var at : tagtype
 ;; var bt : blocktype  ;; defined below
 var ct : comptype
 var dt : deftype
+var et : elemtype
 var ft : functype
 var gt : globaltype
 var ht : heaptype
@@ -524,6 +530,19 @@ syntax instr/call hint(desc "function instruction") = ...
   | RETURN_CALL_INDIRECT tableidx typeuse
   | ...
 
+syntax instr/exn hint(desc "exception instructions") = ...
+  | THROW tagidx
+  | THROW_REF
+  | TRY_TABLE blocktype list(catch) instr*
+  | ...
+
+syntax catch hint(desc "catch clause") =
+  | CATCH tagidx labelidx
+  | CATCH_REF tagidx labelidx
+  | CATCH_ALL labelidx
+  | CATCH_ALL_REF labelidx
+
+
 syntax instr/num hint(desc "numeric instruction") = ...
   | CONST numtype num_(numtype)      hint(show %.CONST %)
   | UNOP numtype unop_(numtype)      hint(show %.##%)
@@ -684,6 +703,8 @@ syntax table hint(desc "table") =
   TABLE tabletype expr
 syntax mem hint(desc "memory") =
   MEMORY memtype
+syntax tag hint(desc "tag") =
+  TAG typeidx
 syntax elem hint(desc "table segment") =
   ELEM reftype expr* elemmode
 syntax data hint(desc "memory segment") =
@@ -691,15 +712,15 @@ syntax data hint(desc "memory segment") =
 syntax start hint(desc "start function") =
   START funcidx
 
-syntax externidx hint(desc "external index") hint(macro "%" "EX%") =
-  | FUNC funcidx | GLOBAL globalidx | TABLE tableidx | MEM memidx
+syntax externidx hint(desc "external index") hint(macro "%" "XX%") =
+  | FUNC funcidx | GLOBAL globalidx | TABLE tableidx | MEM memidx | TAG tagidx
 syntax export hint(desc "export") =
   EXPORT name externidx
 syntax import hint(desc "import") =
   IMPORT name name externtype
 
 syntax module hint(desc "module") =
-  MODULE type* import* func* global* table* mem* elem* data* start? export*
+  MODULE type* import* func* global* table* mem* tag* elem* data* start? export*
 
 
 var ty : type
diff --git a/spectec/spec/wasm-3.0/2-syntax-aux.watsup b/spectec/spec/wasm-3.0/2-syntax-aux.watsup
index b9a21bb985..ba884d8b16 100644
--- a/spectec/spec/wasm-3.0/2-syntax-aux.watsup
+++ b/spectec/spec/wasm-3.0/2-syntax-aux.watsup
@@ -477,6 +477,9 @@ def $free_table(TABLE tabletype expr) =
 def $free_mem(mem) : free
 def $free_mem(MEMORY memtype) = $free_memtype(memtype)
 
+def $free_tag(tag) : free
+def $free_tag(TAG typeidx) = $free_typeidx(typeidx)
+
 def $free_elemmode(elemmode) : free
 def $free_elemmode(ACTIVE tableidx expr) =
   $free_tableidx(tableidx) ++ $free_expr(expr)
@@ -506,13 +509,14 @@ def $free_import(IMPORT name_1 name_2 externtype) = $free_externtype(externtype)
 
 
 def $free_module(module) : free
-def $free_module(MODULE type* import* func* global* table* mem* elem* data* start? export*) =
+def $free_module(MODULE type* import* func* global* table* mem* tag* elem* data* start? export*) =
   $free_list($free_type(type)*) ++
   $free_list($free_import(import)*) ++
   $free_list($free_func(func)*) ++
   $free_list($free_global(global)*) ++
   $free_list($free_table(table)*) ++
   $free_list($free_mem(mem)*) ++
+  $free_list($free_tag(tag)*) ++
   $free_list($free_elem(elem)*) ++
   $free_list($free_data(data)*) ++
   $free_opt($free_start(start)?) ++
@@ -655,6 +659,7 @@ def $funcsxx(externidx*) : typeidx*      hint(show $funcs(%))   hint(macro "func
 def $globalsxx(externidx*) : globalidx*  hint(show $globals(%)) hint(macro "globalsxx")
 def $tablesxx(externidx*) : tableidx*    hint(show $tables(%))  hint(macro "tablesxx")
 def $memsxx(externidx*) : memidx*        hint(show $mems(%))    hint(macro "memsxx")
+def $tagsxx(externidx*) : tagidx*        hint(show $tags(%))    hint(macro "tagsxx")
 
 def $funcsxx(eps) = eps
 def $funcsxx((FUNC x) xx*) = x $funcsxx(xx*)
@@ -672,11 +677,16 @@ def $memsxx(eps) = eps
 def $memsxx((MEM x) xx*) = x $memsxx(xx*)
 def $memsxx(externidx xx*) = $memsxx(xx*)  -- otherwise
 
+def $tagsxx(eps) = eps
+def $tagsxx((TAG x) xx*) = x $tagsxx(xx*)
+def $tagsxx(externidx xx*) = $tagsxx(xx*)  -- otherwise
+
 
 def $funcsxt(externtype*) : deftype*       hint(show $funcs(%))   hint(macro "funcsxt")
 def $globalsxt(externtype*) : globaltype*  hint(show $globals(%)) hint(macro "globalsxt")
 def $tablesxt(externtype*) : tabletype*    hint(show $tables(%))  hint(macro "tablesxt")
 def $memsxt(externtype*) : memtype*        hint(show $mems(%))    hint(macro "memsxt")
+def $tagsxt(externtype*) : tagtype*        hint(show $tags(%))    hint(macro "tagsxt")
 
 def $funcsxt(eps) = eps
 def $funcsxt((FUNC dt) xt*) = dt $funcsxt(xt*)
@@ -694,6 +704,10 @@ def $memsxt(eps) = eps
 def $memsxt((MEM mt) xt*) = mt $memsxt(xt*)
 def $memsxt(externtype xt*) = $memsxt(xt*)  -- otherwise
 
+def $tagsxt(eps) = eps
+def $tagsxt((TAG at) xt*) = at $tagsxt(xt*)
+def $tagsxt(externtype xt*) = $tagsxt(xt*)  -- otherwise
+
 
 
 ;;
diff --git a/spectec/spec/wasm-3.0/4-runtime.watsup b/spectec/spec/wasm-3.0/4-runtime.watsup
index b177d35e68..a3b913f545 100644
--- a/spectec/spec/wasm-3.0/4-runtime.watsup
+++ b/spectec/spec/wasm-3.0/4-runtime.watsup
@@ -7,21 +7,19 @@ syntax funcaddr hint(desc "function address") = addr
 syntax globaladdr hint(desc "global address") = addr
 syntax tableaddr hint(desc "table address") = addr
 syntax memaddr hint(desc "memory address") = addr
+syntax tagaddr hint(desc "tag address") = addr
 syntax elemaddr hint(desc "elem address") = addr
 syntax dataaddr hint(desc "data address") = addr
 syntax hostaddr hint(desc "host address") = addr
 syntax structaddr hint(desc "structure address") = addr
 syntax arrayaddr hint(desc "array address") = addr
+syntax exnaddr hint(desc "exception address") = addr
+
+syntax externaddr hint(desc "external address") hint(macro "%" "XA%") =
+  | FUNC funcaddr | GLOBAL globaladdr | TABLE tableaddr | MEM memaddr | TAG tagaddr
 
 var a : addr
-var fa : funcaddr
-var ga : globaladdr
-var ta : tableaddr
-var ma : memaddr
-var ea : elemaddr
-var da : dataaddr
-var sa : structaddr
-var aa : arrayaddr
+var xa : externaddr
 
 
 ;;
@@ -39,6 +37,7 @@ syntax addrref hint(desc "address value") =
   | REF.STRUCT_ADDR structaddr           hint(show REF.STRUCT %%) hint(macro "%ADDR")
   | REF.ARRAY_ADDR arrayaddr             hint(show REF.ARRAY %%)  hint(macro "%ADDR")
   | REF.FUNC_ADDR funcaddr               hint(show REF.FUNC %%)   hint(macro "%ADDR")
+  | REF.EXN_ADDR exnaddr                 hint(show REF.EXN %%)    hint(macro "%ADDR")
   | REF.HOST_ADDR hostaddr               hint(show REF.HOST %%)   hint(macro "%ADDR")
   | REF.EXTERN addrref
 syntax ref hint(desc "reference value")  hint(macro "reff") =
@@ -48,21 +47,13 @@ syntax val hint(desc "value") =
   | num | vec | ref
 
 syntax result hint(desc "result") =
-  | _VALS val* | TRAP
+  | _VALS val* | _EXN (REF.EXN_ADDR exnaddr) THROW_REF | TRAP
 
 var r : ref
 var v : val
 var res : result
 
 
-;; External values
-
-syntax externval hint(desc "external value") hint(macro "%" "EV%") =
-  | FUNC funcaddr | GLOBAL globaladdr | TABLE tableaddr | MEM memaddr
-
-var xv : externval
-
-
 ;;
 ;; Configurations
 ;;
@@ -80,12 +71,14 @@ syntax tableinst hint(desc "table instance") hint(macro "%" "TI%") =
   { TYPE tabletype, REFS ref* }
 syntax meminst hint(desc "memory instance") hint(macro "%" "MI%") =
   { TYPE memtype, BYTES byte* }
+syntax taginst hint(desc "tag instance") hint(macro "%" "HI%") =
+  { TYPE tagtype }
 syntax eleminst hint(desc "element instance") hint(macro "%" "EI%") =
   { TYPE elemtype, REFS ref* }
 syntax datainst hint(desc "data instance") hint(macro "%" "DI%") =
   { BYTES byte* }
-syntax exportinst hint(desc "export instance") hint(macro "%" "EI%") =
-  { NAME name, VALUE externval }
+syntax exportinst hint(desc "export instance") hint(macro "%" "XI%") =
+  { NAME name, ADDR externaddr }
 
 syntax packval hint(desc "packed value") =
   | PACK packtype iN($psizenn(packtype))    hint(show %.PACK %)
@@ -95,6 +88,9 @@ syntax structinst hint(desc "structure instance") hint(macro "%" "SI%") =
   { TYPE deftype, FIELDS fieldval* }
 syntax arrayinst hint(desc "array instance") hint(macro "%" "AI%") =
   { TYPE deftype, FIELDS fieldval* }
+syntax exninst hint(desc "exception instance") hint(macro "%" "EI%") =
+  { TAG tagaddr, FIELDS val* }
+
 
 syntax moduleinst hint(desc "module instance") hint(macro "%" "MI%") =
   { TYPES deftype*,
@@ -102,6 +98,7 @@ syntax moduleinst hint(desc "module instance") hint(macro "%" "MI%") =
     GLOBALS globaladdr*,
     TABLES tableaddr*,
     MEMS memaddr*,
+    TAGS tagaddr*,
     ELEMS elemaddr*,
     DATAS dataaddr*,
     EXPORTS exportinst* }
@@ -111,6 +108,7 @@ var fi : funcinst
 var gi : globalinst
 var ti : tableinst
 var mi : meminst
+var hi : taginst
 var ei : eleminst
 var di : datainst
 var xi : exportinst
@@ -128,10 +126,12 @@ syntax store hint(desc "store") hint(macro "%" "S%") =
     GLOBALS globalinst*,
     TABLES tableinst*,
     MEMS meminst*,
+    TAGS taginst*,
     ELEMS eleminst*,
     DATAS datainst*,
     STRUCTS structinst*,
-    ARRAYS arrayinst* }
+    ARRAYS arrayinst*,
+    EXNS exninst* }
 
 syntax frame hint(desc "frame") hint(macro "%" "A%") =
   { LOCALS (val?)*, MODULE moduleinst }
@@ -151,6 +151,7 @@ var z : state
 syntax instr/admin hint(desc "administrative instruction") =
   | ...
   | addrref
-  | LABEL_ n `{instr*} instr*  hint(show LABEL_%#% %%)
-  | FRAME_ n `{frame} instr*   hint(show FRAME_%#% %%)
+  | LABEL_ n `{instr*} instr*   hint(show LABEL_%#% %%)
+  | FRAME_ n `{frame} instr*    hint(show FRAME_%#% %%)
+  | HANDLER_ n `{catch*} instr* hint(show HANDLER_%#% %%)
   | TRAP
diff --git a/spectec/spec/wasm-3.0/5-runtime-aux.watsup b/spectec/spec/wasm-3.0/5-runtime-aux.watsup
index 37b99c5f2e..3dcf72c802 100644
--- a/spectec/spec/wasm-3.0/5-runtime-aux.watsup
+++ b/spectec/spec/wasm-3.0/5-runtime-aux.watsup
@@ -43,26 +43,31 @@ def $unpackfield_(packtype, sx, PACK packtype i) = CONST I32 $extend__($psize(pa
 
 ;; Projections
 
-def $funcsxv(externval*) : funcaddr*     hint(show $funcs(%))   hint(macro "funcsxv")
-def $globalsxv(externval*) : globaladdr* hint(show $globals(%)) hint(macro "globalsxv")
-def $tablesxv(externval*) : tableaddr*   hint(show $tables(%))  hint(macro "tablesxv")
-def $memsxv(externval*) : memaddr*       hint(show $mems(%))    hint(macro "memsxv")
+def $funcsxa(externaddr*) : funcaddr*     hint(show $funcs(%))   hint(macro "funcsxa")
+def $globalsxa(externaddr*) : globaladdr* hint(show $globals(%)) hint(macro "globalsxa")
+def $tablesxa(externaddr*) : tableaddr*   hint(show $tables(%))  hint(macro "tablesxa")
+def $memsxa(externaddr*) : memaddr*       hint(show $mems(%))    hint(macro "memsxa")
+def $tagsxa(externaddr*) : tagaddr*       hint(show $tags(%))    hint(macro "tagsxa")
 
-def $funcsxv(eps) = eps
-def $funcsxv((FUNC fa) xv*) = fa $funcsxv(xv*)
-def $funcsxv(externval xv*) = $funcsxv(xv*)  -- otherwise
+def $funcsxa(eps) = eps
+def $funcsxa((FUNC fa) xa*) = fa $funcsxa(xa*)
+def $funcsxa(externaddr xa*) = $funcsxa(xa*)  -- otherwise
 
-def $globalsxv(eps) = eps
-def $globalsxv((GLOBAL ga) xv*) = ga $globalsxv(xv*)
-def $globalsxv(externval xv*) = $globalsxv(xv*)  -- otherwise
+def $globalsxa(eps) = eps
+def $globalsxa((GLOBAL ga) xa*) = ga $globalsxa(xa*)
+def $globalsxa(externaddr xa*) = $globalsxa(xa*)  -- otherwise
 
-def $tablesxv(eps) = eps
-def $tablesxv((TABLE ta) xv*) = ta $tablesxv(xv*)
-def $tablesxv(externval xv*) = $tablesxv(xv*)  -- otherwise
+def $tablesxa(eps) = eps
+def $tablesxa((TABLE ta) xa*) = ta $tablesxa(xa*)
+def $tablesxa(externaddr xa*) = $tablesxa(xa*)  -- otherwise
 
-def $memsxv(eps) = eps
-def $memsxv((MEM ma) xv*) = ma $memsxv(xv*)
-def $memsxv(externval xv*) = $memsxv(xv*)  -- otherwise
+def $memsxa(eps) = eps
+def $memsxa((MEM ma) xa*) = ma $memsxa(xa*)
+def $memsxa(externaddr xa*) = $memsxa(xa*)  -- otherwise
+
+def $tagsxa(eps) = eps
+def $tagsxa((TAG ha) xa*) = ha $tagsxa(xa*)
+def $tagsxa(externaddr xa*) = $tagsxa(xa*)  -- otherwise
 
 
 ;;
@@ -77,31 +82,39 @@ def $frame(state) : frame             hint(show %.FRAME) hint(macro "Z%")
 def $store((s; f)) = s
 def $frame((s; f)) = f
 
+def $tagaddr(state) : tagaddr*        hint(show %.TAGS)    hint(macro "Z%")
+def $tagaddr((s; f)) = f.MODULE.TAGS
+
 def $moduleinst(state) : moduleinst   hint(show %.MODULE)  hint(macro "Z%")
 def $funcinst(state) : funcinst*      hint(show %.FUNCS)   hint(macro "Z%")
 def $globalinst(state) : globalinst*  hint(show %.GLOBALS) hint(macro "Z%")
 def $tableinst(state) : tableinst*    hint(show %.TABLES)  hint(macro "Z%")
 def $meminst(state) : meminst*        hint(show %.MEMS)    hint(macro "Z%")
+def $taginst(state) : taginst*        hint(show %.TAGS)    hint(macro "Z%")
 def $eleminst(state) : eleminst*      hint(show %.ELEMS)   hint(macro "Z%")
 def $datainst(state) : datainst*      hint(show %.DATAS)   hint(macro "Z%")
 def $structinst(state) : structinst*  hint(show %.STRUCTS) hint(macro "Z%")
 def $arrayinst(state) : arrayinst*    hint(show %.ARRAYS)  hint(macro "Z%")
+def $exninst(state) : exninst*        hint(show %.EXNS)    hint(macro "Z%")
 
 def $moduleinst((s; f)) = f.MODULE
 def $funcinst((s; f)) = s.FUNCS
 def $globalinst((s; f)) = s.GLOBALS
 def $tableinst((s; f)) = s.TABLES
 def $meminst((s; f)) = s.MEMS
+def $taginst((s; f)) = s.TAGS
 def $eleminst((s; f)) = s.ELEMS
 def $datainst((s; f)) = s.DATAS
 def $structinst((s; f)) = s.STRUCTS
 def $arrayinst((s; f)) = s.ARRAYS
+def $exninst((s; f)) = s.EXNS
 
 def $type(state, typeidx) : deftype         hint(show %.TYPES[%])   hint(macro "Z%")
 def $func(state, funcidx) : funcinst        hint(show %.FUNCS[%])   hint(macro "Z%")
 def $global(state, globalidx) : globalinst  hint(show %.GLOBALS[%]) hint(macro "Z%")
 def $table(state, tableidx) : tableinst     hint(show %.TABLES[%])  hint(macro "Z%")
 def $mem(state, memidx) : meminst           hint(show %.MEMS[%])    hint(macro "Z%")
+def $tag(state, tagidx) : taginst           hint(show %.TAGS[%])    hint(macro "Z%")
 def $elem(state, tableidx) : eleminst       hint(show %.ELEMS[%])   hint(macro "Z%")
 def $data(state, dataidx) : datainst        hint(show %.DATAS[%])   hint(macro "Z%")
 def $local(state, localidx) : val?          hint(show %.LOCALS[%])  hint(macro "Z%")
@@ -111,6 +124,7 @@ def $func((s; f), x) = s.FUNCS[f.MODULE.FUNCS[x]]
 def $global((s; f), x) = s.GLOBALS[f.MODULE.GLOBALS[x]]
 def $table((s; f), x) = s.TABLES[f.MODULE.TABLES[x]]
 def $mem((s; f), x) = s.MEMS[f.MODULE.MEMS[x]]
+def $tag((s; f), x) = s.TAGS[f.MODULE.TAGS[x]]
 def $elem((s; f), x) = s.ELEMS[f.MODULE.ELEMS[x]]
 def $data((s; f), x) = s.DATAS[f.MODULE.DATAS[x]]
 def $local((s; f), x) = f.LOCALS[x]
@@ -142,9 +156,12 @@ def $with_array((s; f), a, i, fv) = s[.ARRAYS[a].FIELDS[i] = fv]; f
 
 def $add_structinst(state, structinst*) : state  hint(show %[.STRUCTS =++ %]) hint(macro "Z%")
 def $add_arrayinst(state, arrayinst*) : state    hint(show %[.ARRAYS =++ %])  hint(macro "Z%")
+def $add_exninst(state, exninst*) : state        hint(show %[.EXNS =++ %])    hint(macro "Z%")
 
 def $add_structinst((s; f), si*) = s[.STRUCTS =++ si*]; f
 def $add_arrayinst((s; f), ai*) = s[.ARRAYS =++ ai*]; f
+;; TODO: variable name for exninst? (ei and xi are both taken)
+def $add_exninst((s; f), exn*) = s[.EXNS =++ exn*]; f
 
 
 ;; Growing
diff --git a/spectec/spec/wasm-3.0/6-typing.watsup b/spectec/spec/wasm-3.0/6-typing.watsup
index 51c4b6c55a..5f5c449e2e 100644
--- a/spectec/spec/wasm-3.0/6-typing.watsup
+++ b/spectec/spec/wasm-3.0/6-typing.watsup
@@ -19,6 +19,7 @@ syntax context hint(desc "context") hint(macro "%" "C%") =
     GLOBALS globaltype*,
     TABLES tabletype*,
     MEMS memtype*,
+    TAGS tagtype*,
     ELEMS elemtype*,
     DATAS datatype*,
     LOCALS localtype*,
@@ -232,6 +233,7 @@ relation Limits_ok: context |- limits : nat         hint(show "K-limits") hint(m
 relation Globaltype_ok: context |- globaltype : OK  hint(show "K-global") hint(macro "%globaltype")
 relation Tabletype_ok: context |- tabletype : OK    hint(show "K-table")  hint(macro "%tabletype")
 relation Memtype_ok: context |- memtype : OK        hint(show "K-mem")    hint(macro "%memtype")
+relation Tagtype_ok: context |- tagtype : OK        hint(show "K-tag")    hint(macro "%tagtype")
 relation Externtype_ok: context |- externtype : OK  hint(show "K-extern") hint(macro "%externtype")
 
 
@@ -257,6 +259,11 @@ rule Memtype_ok:
   C |- limits PAGE : OK
   -- Limits_ok: C |- limits : $(2^16)
 
+rule Tagtype_ok:
+  C |- deftype : OK
+  -- Deftype_ok: C |- deftype : OK
+  -- Expand: deftype ~~ FUNC functype
+
 
 rule Externtype_ok/func:
   C |- FUNC deftype : OK
@@ -275,6 +282,10 @@ rule Externtype_ok/mem:
   C |- MEM memtype : OK
   -- Memtype_ok: C |- memtype : OK
 
+rule Externtype_ok/tag:
+  C |- TAG tagtype : OK
+  -- Tagtype_ok: C |- tagtype : OK
+
 
 
 ;;
@@ -464,6 +475,7 @@ relation Limits_sub: context |- limits <: limits             hint(show "S-limits
 relation Globaltype_sub: context |- globaltype <: globaltype hint(show "S-global") hint(macro "%globaltypematch")
 relation Tabletype_sub: context |- tabletype <: tabletype    hint(show "S-table")  hint(macro "%tabletypematch")
 relation Memtype_sub: context |- memtype <: memtype          hint(show "S-mem")    hint(macro "%memtypematch")
+relation Tagtype_sub: context |- tagtype <: tagtype          hint(show "S-tag")    hint(macro "%tagtypematch")
 relation Externtype_sub: context |- externtype <: externtype hint(show "S-extern") hint(macro "%externtypematch")
 
 
@@ -496,6 +508,11 @@ rule Memtype_sub:
   C |- limits_1 PAGE <: limits_2 PAGE
   -- Limits_sub: C |- limits_1 <: limits_2
 
+rule Tagtype_sub:
+  C |- deftype_1 <: deftype_2
+  -- Deftype_sub: C |- deftype_1 <: deftype_2
+  -- Deftype_sub: C |- deftype_2 <: deftype_1
+
 
 rule Externtype_sub/func:
   C |- FUNC deftype_1 <: FUNC deftype_2
@@ -513,6 +530,10 @@ rule Externtype_sub/mem:
   C |- MEM memtype_1 <: MEM memtype_2
   -- Memtype_sub: C |- memtype_1 <: memtype_2
 
+rule Externtype_sub/tag:
+  C |- TAG tagtype_1 <: TAG tagtype_2
+  -- Tagtype_sub: C |- tagtype_1 <: tagtype_2
+
 
 
 ;;
@@ -703,6 +724,44 @@ rule Instr_ok/return_call_indirect:
   -- Instrtype_ok: C |- t_3* -> t_4* : OK
 
 
+;; Exception instructions
+
+relation Catch_ok: context |- catch : OK hint(show "T") hint(macro "%catch")
+
+rule Instr_ok/throw:
+  C |- THROW x : t_1* t* -> t_2*
+  -- Expand: C.TAGS[x] ~~ FUNC (t* -> eps)
+  -- Instrtype_ok: C |- t_1* -> t_2* : OK
+
+rule Instr_ok/throw_ref:
+  C |- THROW_REF : t_1* (REF NULL EXN) -> t_2*
+  -- Instrtype_ok: C |- t_1* -> t_2* : OK
+
+rule Instr_ok/try_table:
+  C |- TRY_TABLE bt catch* instr* : t_1* -> t_2*
+  -- Blocktype_ok: C |- bt : t_1* -> t_2*
+  -- Instrs_ok: {LABELS (t_2*)} ++ C |- instr* : t_1* ->_(x*) t_2*
+  -- (Catch_ok: C |- catch : OK)*
+
+rule Catch_ok/catch:
+  C |- CATCH x l : OK
+  -- Expand: C.TAGS[x] ~~ FUNC (t* -> eps)
+  -- Resulttype_sub: C |- t* <: C.LABELS[l]
+
+rule Catch_ok/catch_ref:
+  C |- CATCH_REF x l : OK
+  -- Expand: C.TAGS[x] ~~ FUNC (t* -> eps)
+  -- Resulttype_sub: C |- t* (REF EXN) <: C.LABELS[l]
+
+rule Catch_ok/catch_all:
+  C |- CATCH_ALL l : OK
+  -- Resulttype_sub: C |- eps <: C.LABELS[l]
+
+rule Catch_ok/catch_all_ref:
+  C |- CATCH_ALL_REF l : OK
+  -- Resulttype_sub: C |- (REF EXN) <: C.LABELS[l]
+
+
 ;; Numeric instructions
 
 rule Instr_ok/const:
@@ -1172,6 +1231,7 @@ relation Local_ok: context |- local : localtype      hint(show "T-local")    hin
 relation Global_ok: context |- global : globaltype   hint(show "T-global")   hint(macro "%global")
 relation Table_ok: context |- table : tabletype      hint(show "T-table")    hint(macro "%table")
 relation Mem_ok: context |- mem : memtype            hint(show "T-mem")      hint(macro "%mem")
+relation Tag_ok: context |- tag : tagtype            hint(show "T-tag")      hint(macro "%tag")
 relation Elem_ok: context |- elem : elemtype         hint(show "T-elem")     hint(macro "%elem")
 relation Data_ok: context |- data : datatype         hint(show "T-data")     hint(macro "%data")
 relation Elemmode_ok: context |- elemmode : elemtype hint(show "T-elemmode") hint(macro "%elemmode")
@@ -1214,6 +1274,10 @@ rule Mem_ok:
   C |- MEMORY memtype : memtype
   -- Memtype_ok: C |- memtype : OK
 
+rule Tag_ok:
+  C |- TAG x : C.TYPES[x]
+  -- Expand: C.TYPES[x] ~~ FUNC functype
+
 rule Elem_ok:
   C |- ELEM elemtype expr* elemmode : elemtype
   -- Reftype_ok: C |- elemtype : OK
@@ -1280,6 +1344,10 @@ rule Externidx_ok/mem:
   C |- MEM x : MEM mt
   -- if C.MEMS[x] = mt
 
+rule Externidx_ok/tag:
+  C |- TAG x : TAG at
+  -- if C.TAGS[x] = at
+
 
 ;; Modules proper
 
@@ -1290,16 +1358,17 @@ relation Globals_ok: context |- global* : globaltype* hint(show "T-globals") hin
 ;; HACK for notation
 syntax nonfuncs = global* table* mem* elem* data*
 def $funcidx_nonfuncs(nonfuncs) : funcidx*  hint(show $funcidx(%)) hint(macro "freefuncidx")
-def $funcidx_nonfuncs(global* table* mem* elem* data*) = $funcidx_module(MODULE eps eps eps global* table* mem* elem* data* eps eps)
+def $funcidx_nonfuncs(global* table* mem* elem* data*) = $funcidx_module(MODULE eps eps eps global* table* mem* eps elem* data* eps eps)
 
 rule Module_ok:
-  |- MODULE type* import* func* global* table* mem* elem* data* start? export* : $clos_moduletype(C, xt_I* -> xt_E*)
+  |- MODULE type* import* func* global* table* mem* tag* elem* data* start? export* : $clos_moduletype(C, xt_I* -> xt_E*)
   -- Types_ok: {} |- type* : dt'*
   -- (Import_ok: {TYPES dt'*} |- import : xt_I)*
   ----
   -- Globals_ok: C' |- global* : gt*
   -- (Table_ok: C' |- table : tt)*
   -- (Mem_ok: C' |- mem : mt)*
+  -- (Tag_ok: C' |- tag : at)*
   -- (Func_ok: C |- func : dt)*
   ----
   -- (Elem_ok: C |- elem : rt)*
@@ -1308,7 +1377,7 @@ rule Module_ok:
   -- (Export_ok: C |- export : nm xt_E)*
   -- if $disjoint_(name, nm*)
   ----
-  -- if C = {TYPES dt'*, FUNCS dt_I* dt*, GLOBALS gt_I* gt*, TABLES tt_I* tt*, MEMS mt_I* mt*, ELEMS rt*, DATAS ok*, REFS x*}
+  -- if C = {TYPES dt'*, FUNCS dt_I* dt*, GLOBALS gt_I* gt*, TABLES tt_I* tt*, MEMS mt_I* mt*, TAGS at_I* at*, ELEMS rt*, DATAS ok*, REFS x*}
   ----
   -- if C' = {TYPES dt'*, FUNCS dt_I* dt*, GLOBALS gt_I*, REFS x*}
   -- if x* = $funcidx_nonfuncs(global* table* mem* elem* data*)
@@ -1317,6 +1386,7 @@ rule Module_ok:
   -- if gt_I* = $globalsxt(xt_I*)
   -- if tt_I* = $tablesxt(xt_I*)
   -- if mt_I* = $memsxt(xt_I*)
+  -- if at_I* = $tagsxt(xt_I*)
 
 
 rule Types_ok/empty:
diff --git a/spectec/spec/wasm-3.0/7-runtime-typing.watsup b/spectec/spec/wasm-3.0/7-runtime-typing.watsup
index 453b189f6e..cc1c2dd0c6 100644
--- a/spectec/spec/wasm-3.0/7-runtime-typing.watsup
+++ b/spectec/spec/wasm-3.0/7-runtime-typing.watsup
@@ -32,6 +32,9 @@ rule Ref_type/func:
   s |- REF.FUNC_ADDR a : (REF eps dt)
   -- if s.FUNCS[a].TYPE = dt
 
+rule Ref_type/exn:
+  s |- REF.EXN_ADDR a : (REF eps EXN)
+
 rule Ref_type/host:
   s |- REF.HOST_ADDR a : (REF eps ANY)
 
@@ -58,28 +61,32 @@ rule Val_type/ref:
 
 
 ;;
-;; Typing external values
+;; Typing external addresses
 ;;
 
-relation Externval_type: store |- externval : externtype
+relation Externaddr_type: store |- externaddr : externtype
 
-rule Externval_type/func:
+rule Externaddr_type/func:
   s |- FUNC a : FUNC funcinst.TYPE
   -- if s.FUNCS[a] = funcinst
 
-rule Externval_type/global:
+rule Externaddr_type/global:
   s |- GLOBAL a : GLOBAL globalinst.TYPE
   -- if s.GLOBALS[a] = globalinst
 
-rule Externval_type/table:
+rule Externaddr_type/table:
   s |- TABLE a : TABLE tableinst.TYPE
   -- if s.TABLES[a] = tableinst
 
-rule Externval_type/mem:
+rule Externaddr_type/mem:
   s |- MEM a : MEM meminst.TYPE
   -- if s.MEMS[a] = meminst
 
-rule Externval_type/sub:
-  s |- externval : xt
-  -- Externval_type: s |- externval : xt'
+rule Externaddr_type/tag:
+  s |- TAG a : TAG taginst.TYPE
+  -- if s.TAGS[a] = taginst
+
+rule Externaddr_type/sub:
+  s |- externaddr : xt
+  -- Externaddr_type: s |- externaddr : xt'
   -- Externtype_sub: {} |- xt' <: xt
diff --git a/spectec/spec/wasm-3.0/8-reduction.watsup b/spectec/spec/wasm-3.0/8-reduction.watsup
index 5129aacb76..d62f4bae03 100644
--- a/spectec/spec/wasm-3.0/8-reduction.watsup
+++ b/spectec/spec/wasm-3.0/8-reduction.watsup
@@ -88,14 +88,17 @@ rule Step_pure/label-vals:
 ;; Branch instructions
 
 ;; TODO(4, rossberg): may want a label context instead of bubbling up
-rule Step_pure/br-zero:
+rule Step_pure/br-label-zero:
   (LABEL_ n `{instr'*} val'* val^n (BR l) instr*)  ~>  val^n instr'*
   -- if l = 0
 
-rule Step_pure/br-succ:
+rule Step_pure/br-label-succ:
   (LABEL_ n `{instr'*} val* (BR l) instr*)  ~>  val* (BR $(l - 1))
   -- if l > 0
 
+rule Step_pure/br-handler:
+  (HANDLER_ n `{catch*} val* (BR l) instr*)  ~>  val* (BR l)
+
 
 rule Step_pure/br_if-true:
   (CONST I32 c) (BR_IF l)  ~>  (BR l)
@@ -206,6 +209,63 @@ rule Step_pure/return-frame:
 rule Step_pure/return-label:
   (LABEL_ n `{instr'*} val* RETURN instr*)  ~>  val* RETURN
 
+rule Step_pure/return-handler:
+  (HANDLER_ n `{catch*} val* RETURN instr*)  ~>  val* RETURN
+
+
+;; Exceptions
+
+rule Step/throw:
+  ;; TODO: Appropriate variable name for execption instance `exn`
+  z; val^n (THROW x)  ~>  $add_exninst(z, exn); (REF.EXN_ADDR a) THROW_REF
+  -- Expand: $tag(z, x).TYPE ~~ FUNC (t^n -> eps)
+  -- if a = |$exninst(z)|
+  -- if exn = {TAG $tagaddr(z)[x], FIELDS val^n}
+
+rule Step_read/throw_ref-null:
+  z; (REF.NULL ht) THROW_REF  ~>  TRAP
+
+rule Step_read/throw_ref-vals:
+  z; val* (REF.EXN_ADDR a) THROW_REF instr*  ~>  (REF.EXN_ADDR a) THROW_REF
+  -- if val* =/= eps \/ instr* =/= eps
+
+rule Step_read/throw_ref-label:
+  z; (LABEL_ n `{instr'*} (REF.EXN_ADDR a) THROW_REF)  ~>  (REF.EXN_ADDR a) THROW_REF
+
+rule Step_read/throw_ref-frame:
+  z; (FRAME_ n `{f} (REF.EXN_ADDR a) THROW_REF)  ~>  (REF.EXN_ADDR a) THROW_REF
+
+rule Step_read/throw_ref-handler-empty:
+  z; (HANDLER_ n `{eps} (REF.EXN_ADDR a) THROW_REF)  ~>  (REF.EXN_ADDR a) THROW_REF
+
+rule Step_read/throw_ref-handler-catch:
+  z; (HANDLER_ n `{(CATCH x l) catch'*} (REF.EXN_ADDR a) THROW_REF)  ~>  val* (BR l)
+  -- if $exninst(z)[a].TAG = $tagaddr(z)[x]
+  -- if val* = $exninst(z)[a].FIELDS  ;; TODO(rossberg, 3): inline
+
+rule Step_read/throw_ref-handler-catch_ref:
+  z; (HANDLER_ n `{(CATCH_REF x l) catch'*} (REF.EXN_ADDR a) THROW_REF)  ~>  val* (REF.EXN_ADDR a) (BR l)
+  -- if $exninst(z)[a].TAG = $tagaddr(z)[x]
+  -- if val* = $exninst(z)[a].FIELDS  ;; TODO(rossberg, 3): inline
+
+rule Step_read/throw_ref-handler-catch_all:
+  z; (HANDLER_ n `{(CATCH_ALL l) catch'*} (REF.EXN_ADDR a) THROW_REF)  ~>  (BR l)
+
+rule Step_read/throw_ref-handler-catch_all_ref:
+  z; (HANDLER_ n `{(CATCH_ALL_REF l) catch'*} (REF.EXN_ADDR a) THROW_REF)  ~>  (REF.EXN_ADDR a) (BR l)
+
+rule Step_read/throw_ref-handler-next:
+  z; (HANDLER_ n `{catch catch'*} (REF.EXN_ADDR a) THROW_REF)  ~>  (HANDLER_ n `{catch'*} (REF.EXN_ADDR a) THROW_REF)
+  -- otherwise
+
+rule Step_read/try_table:
+  z; val^m (TRY_TABLE bt catch* instr*)  ~>  (HANDLER_ n `{catch*} (LABEL_ n `{eps} val^m instr*))
+  -- if $blocktype_(z, bt) = t_1^m -> t_2^n
+
+
+rule Step_pure/handler-vals:
+  (HANDLER_ n `{catch*} val*)  ~>  val*
+
 
 ;; Traps
 
diff --git a/spectec/spec/wasm-3.0/9-module.watsup b/spectec/spec/wasm-3.0/9-module.watsup
index 0e30c441f7..a72ffa9b91 100644
--- a/spectec/spec/wasm-3.0/9-module.watsup
+++ b/spectec/spec/wasm-3.0/9-module.watsup
@@ -56,6 +56,17 @@ def $allocmems(s, memtype memtype'*) = (s_2, ma ma'*)
   -- if (s_1, ma) = $allocmem(s, memtype)
   -- if (s_2, ma'*) = $allocmems(s_1, memtype'*)
 
+def $alloctag(store, tagtype) : (store, tagaddr)
+def $alloctag(s, at) = (s ++ {TAGS taginst}, |s.TAGS|)
+  ---- ----
+  -- if taginst = { TYPE at }
+
+def $alloctags(store, tagtype*) : (store, tagaddr*) hint(show $alloctag*#((%,%)))
+def $alloctags(s, eps) = (s, eps)
+def $alloctags(s, at at'*) = (s_2, aa aa'*)
+  -- if (s_1, aa) = $alloctag(s, at)
+  -- if (s_2, aa'*) = $alloctags(s_1, at'*)
+
 def $allocelem(store, elemtype, ref*) : (store, elemaddr)
 def $allocelem(s, elemtype, ref*) = (s ++ {ELEMS eleminst}, |s.ELEMS|)
   ---- ----
@@ -65,7 +76,7 @@ def $allocelems(store, elemtype*, (ref*)*) : (store, elemaddr*) hint(show $alloc
 def $allocelems(s, eps, eps) = (s, eps)
 def $allocelems(s, rt rt'*, (ref*) (ref'*)*) = (s_2, ea ea'*)
   -- if (s_1, ea) = $allocelem(s, rt, ref*)
-  -- if (s_2, ea'*) = $allocelems(s_2, rt'*, (ref'*)*)
+  -- if (s_2, ea'*) = $allocelems(s_1, rt'*, (ref'*)*)
 
 def $allocdata(store, datatype, byte*) : (store, dataaddr)
 def $allocdata(s, OK, byte*) = (s ++ {DATAS datainst}, |s.DATAS|)
@@ -79,10 +90,11 @@ def $allocdatas(s, ok ok'*, (b*) (b'*)*) = (s_2, da da'*)
   -- if (s_2, da'*) = $allocdatas(s_1, ok'*, (b'*)*)
 
 def $allocexport(moduleinst, export) : exportinst hint(show $allocexport(moduleinst, %2))  ;; HACK !
-def $allocexport(moduleinst, EXPORT name (FUNC x)) = { NAME name, VALUE (FUNC moduleinst.FUNCS[x]) }
-def $allocexport(moduleinst, EXPORT name (GLOBAL x)) = { NAME name, VALUE (GLOBAL moduleinst.GLOBALS[x]) }
-def $allocexport(moduleinst, EXPORT name (TABLE x)) = { NAME name, VALUE (TABLE moduleinst.TABLES[x]) }
-def $allocexport(moduleinst, EXPORT name (MEM x)) = { NAME name, VALUE (MEM moduleinst.MEMS[x]) }
+def $allocexport(moduleinst, EXPORT name (FUNC x)) = { NAME name, ADDR (FUNC moduleinst.FUNCS[x]) }
+def $allocexport(moduleinst, EXPORT name (GLOBAL x)) = { NAME name, ADDR (GLOBAL moduleinst.GLOBALS[x]) }
+def $allocexport(moduleinst, EXPORT name (TABLE x)) = { NAME name, ADDR (TABLE moduleinst.TABLES[x]) }
+def $allocexport(moduleinst, EXPORT name (MEM x)) = { NAME name, ADDR (MEM moduleinst.MEMS[x]) }
+def $allocexport(moduleinst, EXPORT name (TAG x)) = { NAME name, ADDR (TAG moduleinst.TAGS[x]) }
 
 def $allocexports(moduleinst, export*) : exportinst* hint(show $allocexport*#(%,%))
 def $allocexports(moduleinst, export*) = $allocexport(moduleinst, export)*
@@ -90,25 +102,28 @@ def $allocexports(moduleinst, export*) = $allocexport(moduleinst, export)*
 
 ;; Modules
 
-def $allocmodule(store, module, externval*, val*, ref*, (ref*)*) : (store, moduleinst)
-def $allocmodule(s, module, externval*, val_G*, ref_T*, (ref_E*)*) = (s_6, moduleinst)
+def $allocmodule(store, module, externaddr*, val*, ref*, (ref*)*) : (store, moduleinst)
+def $allocmodule(s, module, externaddr*, val_G*, ref_T*, (ref_E*)*) = (s_7, moduleinst)
   ---- ----
-  -- if module = MODULE type* import* func* global* table* mem* elem* data* start? export*
+  -- if module = MODULE type* import* func* global* table* mem* tag* elem* data* start? export*
   -- if func* = (FUNC x local* expr_F)*
   -- if global* = (GLOBAL globaltype expr_G)*
   -- if table* = (TABLE tabletype expr_T)*
   -- if mem* = (MEMORY memtype)*
+  -- if tag* = (TAG y)*
   -- if elem* = (ELEM elemtype expr_E* elemmode)*
   -- if data* = (DATA byte* datamode)*
   ;; TODO(3, rossberg): inline these
-  -- if fa_I* = $funcsxv(externval*)
-  -- if ga_I* = $globalsxv(externval*)
-  -- if ta_I* = $tablesxv(externval*)
-  -- if ma_I* = $memsxv(externval*)
+  -- if fa_I* = $funcsxa(externaddr*)
+  -- if ga_I* = $globalsxa(externaddr*)
+  -- if ta_I* = $tablesxa(externaddr*)
+  -- if ma_I* = $memsxa(externaddr*)
+  -- if aa_I* = $tagsxa(externaddr*)
   ;; TODO(2, rossberg): get rid of these forward guesses
   -- if fa* = ($(|s.FUNCS|+i_F))^(i_F<|func*|)
   -- if ga* = ($(|s.GLOBALS|+i_G))^(i_G<|global*|)
   -- if ta* = ($(|s.TABLES|+i_T))^(i_T<|table*|)
+  -- if aa* = ($(|s.TAGS|+i_A))^(i_A<|tag*|)
   -- if ma* = ($(|s.MEMS|+i_M))^(i_M<|mem*|)
   -- if ea* = ($(|s.ELEMS|+i_E))^(i_E<|elem*|)
   -- if da* = ($(|s.DATAS|+i_D))^(i_D<|data*|)
@@ -117,16 +132,18 @@ def $allocmodule(s, module, externval*, val_G*, ref_T*, (ref_E*)*) = (s_6, modul
   -- if (s_2, ga*) = $allocglobals(s_1, globaltype*, val_G*)
   -- if (s_3, ta*) = $alloctables(s_2, tabletype*, ref_T*)
   -- if (s_4, ma*) = $allocmems(s_3, memtype*)
-  -- if (s_5, ea*) = $allocelems(s_4, elemtype*, (ref_E*)*)
-  -- if (s_6, da*) = $allocdatas(s_5, OK^(|data*|), (byte*)*)
+  -- if (s_5, aa*) = $alloctags(s_4, dt*[y]*)
+  -- if (s_6, ea*) = $allocelems(s_5, elemtype*, (ref_E*)*)
+  -- if (s_7, da*) = $allocdatas(s_6, OK^(|data*|), (byte*)*)
   ;; TODO(2, rossberg): use moduleinst here and remove hack above
-  -- if xi* = $allocexports({FUNCS fa_I* fa*, GLOBALS ga_I* ga*, TABLES ta_I* ta*, MEMS ma_I* ma*}, export*)
+  -- if xi* = $allocexports({FUNCS fa_I* fa*, GLOBALS ga_I* ga*, TABLES ta_I* ta*, MEMS ma_I* ma*, TAGS aa_I* aa*}, export*)
   -- if moduleinst = {
       TYPES dt*,
       FUNCS fa_I* fa*, \
       GLOBALS ga_I* ga*,
       TABLES ta_I* ta*, \
       MEMS ma_I* ma*,
+      TAGS aa_I* aa*,
       ELEMS ea*, \
       DATAS da*,
       EXPORTS xi*
@@ -158,13 +175,13 @@ def $evalglobals(z, gt gt'*, expr expr'*) = (z', val val'*)
   -- if (s', a) = $allocglobal(s, gt, val)
   -- if (z', val'*) = $evalglobals((s'; f[.MODULE.GLOBALS =++ a]), gt'*, expr'*)
 
-def $instantiate(store, module, externval*) : config
-def $instantiate(s, module, externval*) = s'; f; instr_E* instr_D* instr_S?
+def $instantiate(store, module, externaddr*) : config
+def $instantiate(s, module, externaddr*) = s'; f; instr_E* instr_D* instr_S?
   ---- ----
   -- Module_ok: |- module : xt_I* -> xt_E*
-  -- (Externval_type: s |- externval : xt_I)*
+  -- (Externaddr_type: s |- externaddr : xt_I)*
   ----
-  -- if module = MODULE type* import* func* global* table* mem* elem* data* start? export*
+  -- if module = MODULE type* import* func* global* table* mem* tag* elem* data* start? export*
   -- if global* = (GLOBAL globaltype expr_G)*
   -- if table* = (TABLE tabletype expr_T)*
   -- if elem* = (ELEM reftype expr_E* elemmode)*
@@ -173,14 +190,14 @@ def $instantiate(s, module, externval*) = s'; f; instr_E* instr_D* instr_S?
   ;; TODO(2, rossberg): avoid this HACK and use moduleinst directly, or built it fully incrementally
   -- if moduleinst_0 = {
       TYPES $alloctypes(type*),
-      FUNCS $funcsxv(externval*) ($(|s.FUNCS|+i_F))^(i_F<|func*|),
-      GLOBALS $globalsxv(externval*), \
+      FUNCS $funcsxa(externaddr*) ($(|s.FUNCS|+i_F))^(i_F<|func*|),
+      GLOBALS $globalsxa(externaddr*), \
     }
   -- if z = s; {MODULE moduleinst_0}  ;; TODO(2, rossberg): inline
   -- if (z', val_G*) = $evalglobals(z, globaltype*, expr_G*)
   -- (Eval_expr : z'; expr_T ~>* z'; ref_T)*
   -- (Eval_expr : z'; expr_E ~>* z'; ref_E)**
-  -- if (s', moduleinst) = $allocmodule(s, module, externval*, val_G*, ref_T*, (ref_E*)*)
+  -- if (s', moduleinst) = $allocmodule(s, module, externaddr*, val_G*, ref_T*, (ref_E*)*)
   -- if f = {MODULE moduleinst}  ;; TODO(2, rossberg): inline
   -- if instr_E* = $concat_(instr, $runelem_(i_E, elem*[i_E])^(i_E<|elem*|))
   -- if instr_D* = $concat_(instr, $rundata_(i_D, data*[i_D])^(i_D<|data*|))
diff --git a/spectec/spec/wasm-3.0/A-binary.watsup b/spectec/spec/wasm-3.0/A-binary.watsup
index 96ecca0308..fc276819a1 100644
--- a/spectec/spec/wasm-3.0/A-binary.watsup
+++ b/spectec/spec/wasm-3.0/A-binary.watsup
@@ -75,6 +75,7 @@ grammar Bfuncidx : funcidx = x:Bu32 => x
 grammar Bglobalidx : globalidx = x:Bu32 => x
 grammar Btableidx : tableidx = x:Bu32 => x
 grammar Bmemidx : memidx = x:Bu32 => x
+grammar Btagidx : tagidx = x:Bu32 => x
 grammar Belemidx : elemidx = x:Bu32 => x
 grammar Bdataidx : dataidx = x:Bu32 => x
 grammar Blocalidx : localidx = x:Bu32 => x
@@ -85,6 +86,7 @@ grammar Bexternidx : externidx =
   | 0x01 x:Btableidx => TABLE x
   | 0x02 x:Bmemidx => MEM x
   | 0x03 x:Bglobalidx => GLOBAL x
+  | 0x04 x:Btagidx => TAG x
 
 
 ;;
@@ -103,6 +105,7 @@ grammar Bvectype : vectype =
   | 0x7B => V128
 
 grammar Babsheaptype : heaptype =
+  | 0x69 => EXN
   | 0x6A => ARRAY
   | 0x6B => STRUCT
   | 0x6C => I31
@@ -113,6 +116,7 @@ grammar Babsheaptype : heaptype =
   | 0x71 => NONE
   | 0x72 => NOEXTERN
   | 0x73 => NOFUNC
+  | 0x74 => NOEXN
 
 grammar Bheaptype : heaptype =
   | ht:Babsheaptype => ht
@@ -180,12 +184,16 @@ grammar Btabletype : tabletype =
 grammar Bmemtype : memtype =
   | lim:Blimits => lim PAGE
 
+grammar Btagtype : typeidx =
+  | 0x00 x:Btypeidx => x
+
 
 grammar Bexterntype : externtype =
   | 0x00 x:Btypeidx => FUNC $idx(x)
   | 0x01 tt:Btabletype => TABLE tt
   | 0x02 mt:Bmemtype => MEM mt
   | 0x03 gt:Bglobaltype => GLOBAL gt
+  | 0x04 x:Btagtype => TAG $idx(x)
 
 
 ;;
@@ -213,6 +221,8 @@ grammar Binstr/control : instr =
 
 
     0x05 (in_2:Binstr)* 0x0B => IF bt in_1* ELSE in_2*
+  | 0x08 x:Btagidx => THROW x
+  | 0x0A => THROW_REF
   | 0x0C l:Blabelidx => BR l
   | 0x0D l:Blabelidx => BR_IF l
   | 0x0E l*:Blist(Blabelidx) l_n:Blabelidx => BR_TABLE l* l_n
@@ -221,8 +231,16 @@ grammar Binstr/control : instr =
   | 0x11 y:Btypeidx x:Btableidx => CALL_INDIRECT x $idx(y)
   | 0x12 x:Bfuncidx => RETURN_CALL x
   | 0x13 y:Btypeidx x:Btableidx => RETURN_CALL_INDIRECT x $idx(y)
+  | 0x1F bt:Bblocktype c*:Blist(Bcatch) (in:Binstr)* 0x0B =>
+      TRY_TABLE bt c* in*
   | ...
 
+grammar Bcatch : catch =
+  | 0x00 x:Btagidx l:Blabelidx => CATCH x l
+  | 0x01 x:Btagidx l:Blabelidx => CATCH_REF x l
+  | 0x02 l:Blabelidx => CATCH_ALL l
+  | 0x03 l:Blabelidx => CATCH_ALL_REF l
+
 
 ;; Reference instructions
 
@@ -1141,6 +1159,15 @@ grammar Bdatacntsec : u32? hint(desc "data count section") =
   | nopt:Bsection_(12, Bdatacnt) => $opt_(u32, nopt)
 
 
+;; Tag section
+
+grammar Btag : tag =
+  | x:Btypeidx => TAG x
+
+grammar Btagsec : tag* hint(desc "tag section") =
+  | tag*:Bsection_(13, Blist(Btag)) => tag*
+
+
 ;; Modules
 
 ;; TODO(2, rossberg): avoid double empty lines
@@ -1171,6 +1198,10 @@ grammar Bmodule : module =
     mem*:Bmemsec
 
 
+    Bcustomsec*
+    tag*:Btagsec
+
+
     Bcustomsec*
     global*:Bglobalsec
 
@@ -1200,7 +1231,7 @@ grammar Bmodule : module =
 
 
     Bcustomsec* =>
-      MODULE type* import* func* global* table* mem* elem* data* start? export*
+      MODULE type* import* func* global* table* mem* tag* elem* data* start? export*
     ----
     -- (if n = |data*|)?
     -- if n? =/= eps \/ $dataidx_funcs(func*) = eps
diff --git a/spectec/src/al/al_util.ml b/spectec/src/al/al_util.ml
index fd4c5bece5..03a873fbb1 100644
--- a/spectec/src/al/al_util.ml
+++ b/spectec/src/al/al_util.ml
@@ -69,7 +69,7 @@ let contE ?(at = no) ~note e = ContE e |> mk_expr at note
 let chooseE ?(at = no) ~note e = ChooseE e |> mk_expr at note
 let isCaseOfE ?(at = no) ~note (e, a) = IsCaseOfE (e, a) |> mk_expr at note
 let isValidE ?(at = no) ~note e = IsValidE e |> mk_expr at note
-let contextKindE ?(at = no) ~note (a, e) = ContextKindE (a, e) |> mk_expr at note
+let contextKindE ?(at = no) ~note a = ContextKindE a |> mk_expr at note
 let isDefinedE ?(at = no) ~note e = IsDefinedE e |> mk_expr at note
 let matchE ?(at = no) ~note (e1, e2) = MatchE (e1, e2) |> mk_expr at note
 let hasTypeE ?(at = no) ~note (e, ty) = HasTypeE (e, ty) |> mk_expr at note
@@ -264,6 +264,7 @@ let valT = varT "val" []
 let callframeT = varT "callframe" []
 let frameT = varT "frame" []
 let labelT = varT "label" []
+let handlerT = varT "handler" []
 let stateT = varT "state" []
 let instrT = varT "instr" []
 let admininstrT = varT "admininstr" []
diff --git a/spectec/src/al/ast.ml b/spectec/src/al/ast.ml
index 9ee294c79b..bcdb7c4eb2 100644
--- a/spectec/src/al/ast.ml
+++ b/spectec/src/al/ast.ml
@@ -108,9 +108,9 @@ and expr' =
   | ContE of expr                                 (* "the continuation of" expr *)
   | ChooseE of expr                               (* "an element of" expr *)
   (* Conditions *)
-  | IsCaseOfE of expr * atom                      (* expr is of the case kwd *)
+  | IsCaseOfE of expr * atom                      (* expr is of the case atom *)
   | IsValidE of expr                              (* expr is valid *)
-  | ContextKindE of atom * expr                   (* TODO: desugar using IsCaseOf? *)
+  | ContextKindE of atom                          (* "the top of the stack is a" atom *)
   | IsDefinedE of expr                            (* expr is defined *)
   | MatchE of expr * expr                         (* expr matches expr *)
   (* TODO: use typ *)
diff --git a/spectec/src/al/eq.ml b/spectec/src/al/eq.ml
index 00e5340a57..4e44cd893b 100644
--- a/spectec/src/al/eq.ml
+++ b/spectec/src/al/eq.ml
@@ -44,7 +44,7 @@ let rec eq_expr e1 e2 =
   | ChooseE e1, ChooseE e2 -> eq_expr e1 e2
   | IsCaseOfE (e1, a1), IsCaseOfE (e2, a2) -> eq_expr e1 e2 && El.Atom.eq a1 a2
   | IsValidE e1, IsValidE e2 -> eq_expr e1 e2
-  | ContextKindE (a1, e1), ContextKindE (a2, e2) -> El.Atom.eq a1 a2 && eq_expr e1 e2
+  | ContextKindE a1, ContextKindE a2 -> El.Atom.eq a1 a2
   | IsDefinedE e1, IsDefinedE e2 -> eq_expr e1 e2
   | MatchE (e11, e12), MatchE (e21, e22) -> eq_expr e11 e21 && eq_expr e12 e22
   | HasTypeE (e1, t1), HasTypeE (e2, t2) -> eq_expr e1 e2 && Il.Eq.eq_typ t1 t2
diff --git a/spectec/src/al/free.ml b/spectec/src/al/free.ml
index fac07f6708..f1f6be060d 100644
--- a/spectec/src/al/free.ml
+++ b/spectec/src/al/free.ml
@@ -19,6 +19,7 @@ let rec free_expr expr =
   | GetCurLabelE
   | GetCurContextE
   | GetCurFrameE
+  | ContextKindE _
   | YetE _ -> IdSet.empty
   | VarE id
   | SubE (id, _) -> IdSet.singleton id
@@ -47,7 +48,6 @@ let rec free_expr expr =
   | TopLabelE
   | TopFrameE
   | TopValueE None -> IdSet.empty
-  | ContextKindE (_, e)
   | IsDefinedE e
   | IsCaseOfE (e, _)
   | HasTypeE (e, _)
diff --git a/spectec/src/al/print.ml b/spectec/src/al/print.ml
index a444afc1f2..1820715935 100644
--- a/spectec/src/al/print.ml
+++ b/spectec/src/al/print.ml
@@ -194,7 +194,7 @@ and string_of_expr expr =
     )
   | OptE (Some e) -> "?(" ^ string_of_expr e ^ ")"
   | OptE None -> "?()"
-  | ContextKindE (a, e) -> sprintf "%s == %s" (string_of_expr e) (string_of_atom a)
+  | ContextKindE a -> sprintf "context_kind(%s)" (string_of_atom a)
   | IsDefinedE e -> sprintf "%s != None" (string_of_expr e)
   | IsCaseOfE (e, a) -> sprintf "case(%s) == %s" (string_of_expr e) (string_of_atom a)
   | HasTypeE (e, t) -> sprintf "type(%s) == %s" (string_of_expr e) (string_of_typ t)
@@ -508,7 +508,7 @@ and structured_string_of_expr expr =
     ^ ", [" ^ structured_string_of_exprs el ^ "])"
   | OptE None -> "OptE"
   | OptE (Some e) -> "OptE (" ^ structured_string_of_expr e ^ ")"
-  | ContextKindE (a, e) -> sprintf "ContextKindE (%s, %s)" (string_of_atom a) (structured_string_of_expr e)
+  | ContextKindE a -> sprintf "ContextKindE (%s)" (string_of_atom a)
   | IsDefinedE e -> "DefinedE (" ^ structured_string_of_expr e ^ ")"
   | IsCaseOfE (e, a) -> "CaseOfE (" ^ structured_string_of_expr e ^ ", " ^ string_of_atom a ^ ")"
   | HasTypeE (e, t) ->
diff --git a/spectec/src/al/walk.ml b/spectec/src/al/walk.ml
index 401c143153..32346a2e53 100644
--- a/spectec/src/al/walk.ml
+++ b/spectec/src/al/walk.ml
@@ -35,9 +35,9 @@ let walk_expr (walker: unit_walker) (expr: expr) : unit =
   match expr.it with
   | VarE _ | SubE _ | NumE _ | BoolE _ | GetCurStateE | GetCurLabelE
   | GetCurContextE | GetCurFrameE | YetE _ | TopLabelE | TopFrameE
-  | TopValueE None -> ()
+  | TopValueE None | ContextKindE _ -> ()
 
-  | UnE (_, e) | LenE e | ArityE e | ContE e | ContextKindE (_, e)
+  | UnE (_, e) | LenE e | ArityE e | ContE e
   | IsDefinedE e | IsCaseOfE (e, _) | HasTypeE (e, _) | IsValidE e
   | TopValueE (Some e) | TopValuesE e | ChooseE e -> walker.walk_expr walker e
 
@@ -130,7 +130,7 @@ let walk_expr (walker: walker) (expr: expr) : expr =
   let it =
     match expr.it with
     | NumE _ | BoolE _ | VarE _ | SubE _ | GetCurStateE | GetCurFrameE
-    | GetCurLabelE | GetCurContextE | TopLabelE | TopFrameE | YetE _ -> expr.it
+    | GetCurLabelE | GetCurContextE | ContextKindE _ | TopLabelE | TopFrameE | YetE _ -> expr.it
     | UnE (op, e) -> UnE (op, walk_expr e)
     | BinE (op, e1, e2) -> BinE (op, walk_expr e1, walk_expr e2)
     | CallE (id, al) -> CallE (id, List.map walk_arg al)
@@ -153,7 +153,6 @@ let walk_expr (walker: walker) (expr: expr) : expr =
     | ContE e' -> ContE (walk_expr e')
     | ChooseE e' -> ChooseE (walk_expr e')
     | IterE (e, ids, iter) -> IterE (walk_expr e, ids, walk_iter iter)
-    | ContextKindE (a, e) -> ContextKindE (a, walk_expr e)
     | IsCaseOfE (e, a) -> IsCaseOfE (walk_expr e, a)
     | IsDefinedE e -> IsDefinedE (walk_expr e)
     | HasTypeE (e, t) -> HasTypeE(walk_expr e, t)
@@ -273,7 +272,7 @@ let rec walk_expr f e =
       | VarE id -> VarE id
       | SubE (id, t) -> SubE (id, t)
       | IterE (e, ids, iter) -> IterE (new_ e, ids, iter)
-      | ContextKindE (a, e) -> ContextKindE (a, new_ e)
+      | ContextKindE _ -> e.it
       | IsCaseOfE (e, a) -> IsCaseOfE (new_ e, a)
       | IsDefinedE e -> IsDefinedE (new_ e)
       | HasTypeE (e, t) -> HasTypeE(new_ e, t)
diff --git a/spectec/src/backend-interpreter/builtin.ml b/spectec/src/backend-interpreter/builtin.ml
index dd072c17d7..d641ec3c6e 100644
--- a/spectec/src/backend-interpreter/builtin.ml
+++ b/spectec/src/backend-interpreter/builtin.ml
@@ -81,6 +81,7 @@ let builtin () =
     listV zeros
     |> create_meminst (CaseV ("PAGE", [ TupV [ numV Z.one; numV (Z.of_int 2) ] ]));
   ] in
+  let tags = [] in
 
   let append kind (name, inst) extern =
 
@@ -94,7 +95,7 @@ let builtin () =
       | _ -> assert false
     in
     let new_extern =
-      StrV [ "NAME", ref (TextV name); "VALUE", ref (CaseV (kind, [ numV addr ])) ]
+      StrV [ "NAME", ref (TextV name); "ADDR", ref (CaseV (kind, [ numV addr ])) ]
     in
 
     (* Update Store *)
@@ -110,6 +111,7 @@ let builtin () =
   let global_extern = List.fold_right (append "GLOBAL") globals in
   let table_extern = List.fold_right (append "TABLE") tables in
   let memory_extern = List.fold_right (append "MEM") memories in
+  let tag_extern = List.fold_right (append "TAG") tags in
 
   let extern =
     []
@@ -117,6 +119,7 @@ let builtin () =
     |> global_extern
     |> table_extern
     |> memory_extern
+    |> tag_extern
     |> Array.of_list in
 
   let moduleinst =
@@ -125,6 +128,7 @@ let builtin () =
     |> Record.add "GLOBALS" (listV [||])
     |> Record.add "TABLES" (listV [||])
     |> Record.add "MEMS" (listV [||])
+    |> Record.add "TAGS" (listV [||])
     |> Record.add "ELEMS" (listV [||])
     |> Record.add "DATAS" (listV [||])
     |> Record.add "EXPORTS" (listV extern) in
diff --git a/spectec/src/backend-interpreter/construct.ml b/spectec/src/backend-interpreter/construct.ml
index bab0cd2d9f..595c5197b1 100644
--- a/spectec/src/backend-interpreter/construct.ml
+++ b/spectec/src/backend-interpreter/construct.ml
@@ -160,6 +160,8 @@ and al_to_heap_type: value -> heap_type = function
     | "ARRAY" -> ArrayHT
     | "FUNC" | "FUNCREF" -> FuncHT
     | "NOFUNC" -> NoFuncHT
+    | "EXN" | "EXNREF" -> ExnHT
+    | "NOEXN" -> NoExnHT
     | "EXTERN" | "EXTERNREF" -> ExternHT
     | "NOEXTERN" -> NoExternHT
     | _ -> error_value "abstract heap type" v)
@@ -212,6 +214,9 @@ let al_to_memory_type: value -> memory_type = function
   | CaseV ("PAGE", [ limits ]) -> MemoryT (al_to_limits default_memory_max limits)
   | v -> error_value "memory type" v
 
+let al_to_tag_type: value -> tag_type = function
+  | dt -> TagT (al_to_def_type dt)
+
 
 (* Destruct operator *)
 
@@ -850,6 +855,11 @@ let al_to_memory': value -> memory' = function
   | v -> error_value "memory" v
 let al_to_memory: value -> memory = al_to_phrase al_to_memory'
 
+let al_to_tag': value -> tag' = function
+  | CaseV ("TAG", [ idx ]) -> { tgtype = al_to_idx idx }
+  | v -> error_value "tag" v
+let al_to_tag: value -> tag = al_to_phrase al_to_tag'
+
 let al_to_segment': value -> segment_mode' = function
   | CaseV ("PASSIVE", []) -> Passive
   | CaseV ("ACTIVE", [ idx; const ]) ->
@@ -899,6 +909,7 @@ let al_to_export_desc': value -> export_desc' = function
   | CaseV ("TABLE", [ idx ]) -> TableExport (al_to_idx idx)
   | CaseV ("MEM", [ idx ]) -> MemoryExport (al_to_idx idx)
   | CaseV ("GLOBAL", [ idx ]) -> GlobalExport (al_to_idx idx)
+  | CaseV ("TAG", [ idx ]) -> TagExport (al_to_idx idx)
   | v -> error_value "export desc" v
 let al_to_export_desc: value -> export_desc = al_to_phrase al_to_export_desc'
 
@@ -913,10 +924,16 @@ let al_to_export': value -> export' = function
   | v -> error_value "export" v
 let al_to_export: value -> export = al_to_phrase al_to_export'
 
-let al_to_module': value -> module_' = function
+let rec al_to_module': value -> module_' = function
+  | CaseV ("MODULE", [
+      types; _imports; funcs; globals; tables; memories; elems; datas; start; exports
+    ]) when !version < 3 ->
+    al_to_module' (CaseV ("MODULE", [
+      types; _imports; funcs; globals; tables; memories; listV [||]; elems; datas; start; exports
+    ]))
   | CaseV ("MODULE", [
-    types; _imports; funcs; globals; tables; memories; elems; datas; start; exports
-  ]) ->
+      types; _imports; funcs; globals; tables; memories; tags; elems; datas; start; exports
+    ]) ->
     {
       types = al_to_list al_to_type types;
       (* TODO: imports = al_to_list (al_to_import module_) imports;*)
@@ -925,6 +942,7 @@ let al_to_module': value -> module_' = function
       globals = al_to_list al_to_global globals;
       tables = al_to_list al_to_table tables;
       memories = al_to_list al_to_memory memories;
+      tags = al_to_list al_to_tag tags;
       elems = al_to_list al_to_elem elems;
       datas = al_to_list al_to_data datas;
       start = al_to_opt al_to_start start;
@@ -966,6 +984,21 @@ and al_to_struct: value -> Aggr.struct_ = function
     )
   | v -> error_value "struct" v
 
+and al_to_tag: value -> Tag.t = function
+  | StrV r when Record.mem "TYPE" r ->
+    Tag.alloc (al_to_tag_type (Record.find "TYPE" r))
+  | v -> error_value "tag" v
+
+and al_to_exn: value -> Exn.exn_ = function
+  | StrV r when Record.mem "TAG" r && Record.mem "FIELDS" r ->
+    let tag_insts = Ds.Store.access "TAGS" in
+    let tag = Record.find "TAG" r |> al_to_int |> listv_nth tag_insts |> al_to_tag in
+    Exn.Exn (
+      tag,
+      al_to_list al_to_value (Record.find "FIELDS" r)
+    )
+  | v -> error_value "exn" v
+
 and al_to_funcinst: value -> Instance.func_inst = function
   | StrV r when Record.mem "TYPE" r && Record.mem "MODULE" r && Record.mem "CODE" r ->
     Func.AstFunc (
@@ -1295,8 +1328,8 @@ let al_of_float_relop = function
 let al_of_relop = al_of_op al_of_int_relop al_of_float_relop
 
 let al_of_int_cvtop num_bits = function
-  | IntOp.ExtendSI32 -> "I64", "EXTEND", [ nullary "S" ]
-  | IntOp.ExtendUI32 -> "I64", "EXTEND", [ nullary "U" ]
+  | IntOp.ExtendSI32 -> "I32", "EXTEND", [ nullary "S" ]
+  | IntOp.ExtendUI32 -> "I32", "EXTEND", [ nullary "U" ]
   | IntOp.WrapI64 -> "I64", "WRAP", []
   | IntOp.TruncSF32 -> "F32", "TRUNC", [ nullary "S" ]
   | IntOp.TruncUF32 -> "F32", "TRUNC", [ nullary "U" ]
@@ -1729,6 +1762,13 @@ let al_of_vlaneop idx vlaneop laneidx =
 
 (* Construct instruction *)
 
+let al_of_catch catch =
+  match catch.it with
+  | Catch (idx1, idx2) -> CaseV ("CATCH", [ al_of_idx idx1; al_of_idx idx2 ])
+  | CatchRef (idx1, idx2) -> CaseV ("CATCH_REF", [ al_of_idx idx1; al_of_idx idx2 ])
+  | CatchAll idx -> CaseV ("CATCH_ALL", [ al_of_idx idx ])
+  | CatchAllRef idx -> CaseV ("CATCH_ALL_REF", [ al_of_idx idx ])
+
 let rec al_of_instr instr =
   match instr.it with
   (* wasm values *)
@@ -1805,6 +1845,14 @@ let rec al_of_instr instr =
   | ReturnCallRef idx -> CaseV ("RETURN_CALL_REF", [ optV (Some (al_of_typeuse idx)) ])
   | ReturnCallIndirect (idx1, idx2) ->
     CaseV ("RETURN_CALL_INDIRECT", [ al_of_idx idx1; al_of_typeuse idx2 ])
+  | Throw idx -> CaseV ("THROW", [ al_of_idx idx ])
+  | ThrowRef -> nullary "THROW_REF"
+  | TryTable (bt, catches, instrs) ->
+    CaseV ("TRY_TABLE", [
+      al_of_blocktype bt;
+      al_of_list al_of_catch catches;
+      al_of_list al_of_instr instrs
+    ])
   | Load (idx, loadop) -> CaseV ("LOAD", al_of_loadop idx loadop)
   | Store (idx, storeop) -> CaseV ("STORE", al_of_storeop idx storeop)
   | VecLoad (idx, vloadop) -> CaseV ("VLOAD", al_of_vloadop idx vloadop)
@@ -1907,6 +1955,9 @@ let al_of_memory memory =
   in
   CaseV ("MEMORY", [ arg' ])
 
+let al_of_tag tag =
+  CaseV ("TAG", [ al_of_idx tag.it.tgtype ])
+
 let al_of_segment segment =
   match segment.it with
   | Passive -> nullary "PASSIVE"
@@ -1947,6 +1998,10 @@ let al_of_import_desc module_ idesc =
   | TableImport tt -> CaseV ("TABLE", [ al_of_table_type tt ])
   | MemoryImport mt -> CaseV ("MEM", [ al_of_memory_type mt ])
   | GlobalImport gt -> CaseV ("GLOBAL", [ al_of_global_type gt ])
+  | TagImport x ->
+    let dts = def_types_of module_ in
+    let dt = x.it |> Int32.to_int |> List.nth dts |> al_of_def_type in
+    CaseV ("TAG", [ dt ])
 
 let al_of_import module_ import =
   CaseV ("IMPORT", [
@@ -1960,6 +2015,7 @@ let al_of_export_desc export_desc = match export_desc.it with
   | TableExport idx -> CaseV ("TABLE", [ al_of_idx idx ])
   | MemoryExport idx -> CaseV ("MEM", [ al_of_idx idx ])
   | GlobalExport idx -> CaseV ("GLOBAL", [ al_of_idx idx ])
+  | TagExport idx -> CaseV ("TAG", [ al_of_idx idx ])
 
 let al_of_start start = CaseV ("START", [ al_of_idx start.it.sfunc ])
 
@@ -1974,6 +2030,9 @@ let al_of_module module_ =
     al_of_list al_of_global module_.it.globals;
     al_of_list al_of_table module_.it.tables;
     al_of_list al_of_memory module_.it.memories;
+  ] @
+    (if !version < 3 then [] else [al_of_list al_of_tag module_.it.tags])
+  @ [
     al_of_list al_of_elem module_.it.elems;
     al_of_list al_of_data module_.it.datas;
     al_of_opt al_of_start module_.it.start;
diff --git a/spectec/src/backend-interpreter/ds.ml b/spectec/src/backend-interpreter/ds.ml
index e91cf247f5..f0a73188de 100644
--- a/spectec/src/backend-interpreter/ds.ml
+++ b/spectec/src/backend-interpreter/ds.ml
@@ -55,10 +55,12 @@ module Store = struct
       |> Record.add "GLOBALS" (listV [||])
       |> Record.add "TABLES" (listV [||])
       |> Record.add "MEMS" (listV [||])
+      |> Record.add "TAGS" (listV [||])
       |> Record.add "ELEMS" (listV [||])
       |> Record.add "DATAS" (listV [||])
       |> Record.add "STRUCTS" (listV [||])
       |> Record.add "ARRAYS" (listV [||])
+      |> Record.add "EXNS" (listV [||])
 
   let get () = strV !store
 
diff --git a/spectec/src/backend-interpreter/interpreter.ml b/spectec/src/backend-interpreter/interpreter.ml
index 22b8c17779..8a72c0104d 100644
--- a/spectec/src/backend-interpreter/interpreter.ml
+++ b/spectec/src/backend-interpreter/interpreter.ml
@@ -142,7 +142,7 @@ and check_type ty v expr =
   let vnn_types = [ "V128"; ] in
   let abs_heap_types = [
     "ANY"; "EQ"; "I31"; "STRUCT"; "ARRAY"; "NONE"; "FUNC";
-    "NOFUNC"; "EXTERN"; "NOEXTERN"
+    "NOFUNC"; "EXN"; "NOEXN"; "EXTERN"; "NOEXTERN"
   ] in
   match v with
   (* addrref *)
@@ -308,6 +308,10 @@ and eval_expr env expr =
     let v2 = eval_expr env e2 in
     LabelV (v1, v2)
   | GetCurLabelE -> WasmContext.get_current_label ()
+  | GetCurContextE ->
+    (match WasmContext.get_top_context () with
+    | None -> fail_expr expr "cannot get the current context"
+    | Some ctxt -> ctxt)
   | ContE e ->
     (match eval_expr env e with
     | LabelV (_, vs) -> vs
@@ -353,6 +357,13 @@ and eval_expr env expr =
     (match ctx with
     | Some (LabelV _) -> boolV true
     | _ -> boolV false)
+  | ContextKindE a ->
+    let ctx = WasmContext.get_top_context () in
+    (match a.it, ctx with
+    | Atom "FRAME_", Some (FrameV _) -> boolV true
+    | Atom "LABEL_", Some (LabelV _) -> boolV true
+    | Atom case, Some (CaseV (case', _)) -> boolV (case = case')
+    | _ -> boolV false)
   | IsDefinedE e ->
     e
     |> eval_expr env
@@ -724,7 +735,6 @@ and create_context (name: string) (args: value list) : AlContext.mode =
   let algo = lookup_algo name in
   let params = params_of_algo algo in
   let body = body_of_algo algo in
-
   let params = params |> extract_expargs in
 
   if List.length args <> List.length params then (
diff --git a/spectec/src/backend-interpreter/manual.ml b/spectec/src/backend-interpreter/manual.ml
index fc6392e4b1..d17dc04ffa 100644
--- a/spectec/src/backend-interpreter/manual.ml
+++ b/spectec/src/backend-interpreter/manual.ml
@@ -10,6 +10,7 @@ let ref_type =
   let nonull = caseV ("NULL", [ optV None ]) in
   let none = nullary "NONE" in
   let nofunc = nullary "NOFUNC" in
+  let noexn = nullary "NOEXN" in
   let noextern = nullary "NOEXTERN" in
 
   let match_heap_type v1 v2 =
@@ -26,6 +27,8 @@ let ref_type =
       CaseV ("REF", [ null; none])
     else if match_heap_type nofunc ht then
       CaseV ("REF", [ null; nofunc])
+    else if match_heap_type noexn ht then
+      CaseV ("REF", [ null; noexn])
     else if match_heap_type noextern ht then
       CaseV ("REF", [ null; noextern])
     else
@@ -34,6 +37,8 @@ let ref_type =
   | [CaseV ("REF.I31_NUM", [ _ ])] -> CaseV ("REF", [ nonull; nullary "I31"])
   (* host *)
   | [CaseV ("REF.HOST_ADDR", [ _ ])] -> CaseV ("REF", [ nonull; nullary "ANY"])
+  (* exception *)
+  | [CaseV ("REF.EXN_ADDR", [ _ ])] -> CaseV ("REF", [ nonull; nullary "EXN"])
   (* array/func/struct addr *)
   | [CaseV (name, [ NumV i ])]
   when String.starts_with ~prefix:"REF." name && String.ends_with ~suffix:"_ADDR" name ->
diff --git a/spectec/src/backend-interpreter/runner.ml b/spectec/src/backend-interpreter/runner.ml
index 36bd347751..a555fa10f6 100644
--- a/spectec/src/backend-interpreter/runner.ml
+++ b/spectec/src/backend-interpreter/runner.ml
@@ -85,11 +85,11 @@ let get_export name modulename =
   |> listv_find
     (fun export -> al_to_string (strv_access "NAME" export) = name)
 
-let get_externval import =
+let get_externaddr import =
   import.it.module_name
   |> Utf8.encode
   |> get_export (Utf8.encode import.it.Ast.item_name)
-  |> strv_access "VALUE"
+  |> strv_access "ADDR"
 
 let textual_to_module textual =
   match (snd textual).it with
@@ -100,7 +100,7 @@ let get_export_addr name modulename =
   let vl =
     modulename
     |> get_export name
-    |> strv_access "VALUE"
+    |> strv_access "ADDR"
     |> args_of_casev
   in
   try List.hd vl with Failure _ ->
@@ -130,9 +130,9 @@ let instantiate module_ =
   log "[Instantiating module...]\n";
 
   let al_module = al_of_module module_ in
-  let externvals = List.map get_externval module_.it.imports in
+  let externaddrs = List.map get_externaddr module_.it.imports in
 
-  Interpreter.instantiate [ al_module; listV_of_list externvals ]
+  Interpreter.instantiate [ al_module; listV_of_list externaddrs ]
 
 
 (** Wast runner **)
diff --git a/spectec/src/backend-prose/print.ml b/spectec/src/backend-prose/print.ml
index f55cc336a9..24b59a331d 100644
--- a/spectec/src/backend-prose/print.ml
+++ b/spectec/src/backend-prose/print.ml
@@ -169,7 +169,7 @@ and string_of_expr expr =
     )
   | OptE (Some e) -> "?(" ^ string_of_expr e ^ ")"
   | OptE None -> "?()"
-  | ContextKindE (a, e) -> sprintf "%s is %s" (string_of_expr e) (string_of_atom a)
+  | ContextKindE a -> sprintf "the top of the stack is a %s" (string_of_atom a)
   | IsDefinedE e -> sprintf "%s is defined" (string_of_expr e)
   | IsCaseOfE (e, a) -> sprintf "%s is of the case %s" (string_of_expr e) (string_of_atom a)
   | HasTypeE (e, t) -> sprintf "the type of %s is %s" (string_of_expr e) (string_of_typ t)
@@ -279,39 +279,30 @@ let rec string_of_instr' depth instr =
 
   let open Al.Ast in
   match instr.it with
-  | IfI (e, il, []) ->
-    sprintf "%s If %s, then:%s" (make_index depth) (string_of_expr e)
-      (string_of_instrs' (depth + 1) il)
-  | IfI (e, il1, [ { it = IfI (inner_e, inner_il1, []); _ } ]) ->
-    let if_index = make_index depth in
-    let else_if_index = make_index depth in
-    sprintf "%s If %s, then:%s\n%s Else if %s, then:%s"
-      if_index
-      (string_of_expr e)
-      (string_of_instrs' (depth + 1) il1)
-      (repeat indent depth ^ else_if_index)
-      (string_of_expr inner_e)
-      (string_of_instrs' (depth + 1) inner_il1)
-  | IfI (e, il1, [ { it = IfI (inner_e, inner_il1, inner_il2); _ } ]) ->
-    let if_index = make_index depth in
-    let else_if_index = make_index depth in
-    let else_index = make_index depth in
-    sprintf "%s If %s, then:%s\n%s Else if %s, then:%s\n%s Else:%s"
-      if_index
-      (string_of_expr e)
-      (string_of_instrs' (depth + 1) il1)
-      (repeat indent depth ^ else_if_index)
-      (string_of_expr inner_e)
-      (string_of_instrs' (depth + 1) inner_il1)
-      (repeat indent depth ^ else_index)
-      (string_of_instrs' (depth + 1) inner_il2)
   | IfI (e, il1, il2) ->
     let if_index = make_index depth in
-    let else_index = make_index depth in
-    sprintf "%s If %s, then:%s\n%s Else:%s" if_index (string_of_expr e)
+    let if_prose = sprintf "%s If %s, then:%s" if_index (string_of_expr e)
       (string_of_instrs' (depth + 1) il1)
-      (repeat indent depth ^ else_index)
-      (string_of_instrs' (depth + 1) il2)
+    in
+
+    let rec collect_clause il =
+      match il with
+      | [ {it = IfI (c, il1, il2); _} ] -> (Some c, il1) :: collect_clause il2
+      | _ -> [(None, il)]
+    in
+    let else_clauses = collect_clause il2 |> List.filter (fun (_, x) -> x <> []) in
+    let else_proses = List.map (fun (cond_opt, il)->
+      let else_index = make_index depth in
+      match cond_opt with
+      | None -> sprintf "%s Else:%s"
+        (repeat indent depth ^ else_index)
+        (string_of_instrs' (depth + 1) il)
+      | Some e ->  sprintf "%s Else if %s, then:%s"
+        (repeat indent depth ^ else_index) (string_of_expr e)
+        (string_of_instrs' (depth + 1) il)
+    ) else_clauses in
+
+    String.concat "\n" (if_prose :: else_proses)
   | OtherwiseI il ->
     sprintf "%s Otherwise:%s" (make_index depth)
       (string_of_instrs' (depth + 1) il)
diff --git a/spectec/src/backend-prose/render.ml b/spectec/src/backend-prose/render.ml
index 7d94b7f64b..af609773fe 100644
--- a/spectec/src/backend-prose/render.ml
+++ b/spectec/src/backend-prose/render.ml
@@ -431,10 +431,9 @@ and render_expr' env expr =
     let se1 = render_expr env e1 in
     let se2 = render_expr env e2 in
     sprintf "the label whose arity is %s and whose continuation is %s" se1 se2
-  | Al.Ast.ContextKindE (a, e) ->
+  | Al.Ast.ContextKindE a ->
     let sa = render_atom env a in
-    let se = render_expr env e in
-    sprintf "%s is %s" se sa
+    sprintf "the top of the stack is a %s" sa
   | Al.Ast.IsDefinedE e ->
     let se = render_expr env e in
     sprintf "%s is defined" se
@@ -461,6 +460,8 @@ and render_expr' env expr =
     let se1 = render_expr env e1 in
     let se2 = render_expr env e2 in
     sprintf "%s matches %s" se1 se2
+  | Al.Ast.YetE s ->
+    sprintf "YetE: %s" s
   | _ ->
     let se = "`" ^ (Al.Print.string_of_expr expr) ^ "`" in
     if env.config.panic_on_error then (
diff --git a/spectec/src/il/ast.ml b/spectec/src/il/ast.ml
index ecfe22ca6f..40b59f34ad 100644
--- a/spectec/src/il/ast.ml
+++ b/spectec/src/il/ast.ml
@@ -184,7 +184,7 @@ and prem = prem' phrase
 and prem' =
   | RulePr of id * mixop * exp                        (* premise *)
   | IfPr of exp                                       (* side condition *)
-  | LetPr of exp * exp * id list                      (* assignment *)
+  | LetPr of exp * exp * string list                  (* binding *)
   | ElsePr                                            (* otherwise *)
   | IterPr of prem * iterexp                          (* iteration *)
 
diff --git a/spectec/src/il/eq.ml b/spectec/src/il/eq.ml
index cd924b28b0..fdf7f9c00e 100644
--- a/spectec/src/il/eq.ml
+++ b/spectec/src/il/eq.ml
@@ -138,6 +138,8 @@ and eq_prem prem1 prem2 =
   | IfPr e1, IfPr e2 -> eq_exp e1 e2
   | IterPr (prem1, e1), IterPr (prem2, e2) ->
     eq_prem prem1 prem2 && eq_iterexp e1 e2
+  | LetPr (e1, e1', ids1), LetPr (e2, e2', ids2) ->
+    eq_exp e1 e2 && eq_exp e1' e2' && ids1 = ids2
   | _, _ -> prem1.it = prem2.it
 
 
diff --git a/spectec/src/il/free.ml b/spectec/src/il/free.ml
index 66ae3acf96..772a475bf5 100644
--- a/spectec/src/il/free.ml
+++ b/spectec/src/il/free.ml
@@ -164,7 +164,7 @@ and free_prem prem =
   match prem.it with
   | RulePr (id, _op, e) -> free_relid id + free_exp e
   | IfPr e -> free_exp e
-  | LetPr (e1, e2, ids) -> free_exp e1 + free_exp e2 + free_list free_varid ids
+  | LetPr (e1, e2, _) -> free_exp e1 + free_exp e2
   | ElsePr -> empty
   | IterPr (prem1, iter) -> free_prem prem1 + free_iterexp iter
 
diff --git a/spectec/src/il/iter.ml b/spectec/src/il/iter.ml
index 0e015bf051..b6a50f5ef3 100644
--- a/spectec/src/il/iter.ml
+++ b/spectec/src/il/iter.ml
@@ -175,7 +175,7 @@ and prem pr =
   | IfPr e -> exp e
   | ElsePr -> ()
   | IterPr (pr1, it) -> prem pr1; iterexp it
-  | LetPr (e1, e2, xs) -> exp e1; exp e2; list varid xs
+  | LetPr (e1, e2, _) -> exp e1; exp e2
 
 and prems prs = list prem prs
 
diff --git a/spectec/src/il/print.ml b/spectec/src/il/print.ml
index 069e2455b8..41d2239ad3 100644
--- a/spectec/src/il/print.ml
+++ b/spectec/src/il/print.ml
@@ -202,7 +202,8 @@ and string_of_prem prem =
   | RulePr (id, mixop, e) ->
     id.it ^ ": " ^ string_of_mixop mixop ^ string_of_exp_args e
   | IfPr e -> "if " ^ string_of_exp e
-  | LetPr (e1, e2, _ids) -> "where " ^ string_of_exp e1 ^ " = " ^ string_of_exp e2
+  | LetPr (e1, e2, xs) ->
+    "where " ^ string_of_exp e1 ^ " = " ^ string_of_exp e2 ^ " {" ^ (String.concat ", " xs) ^ "}"
   | ElsePr -> "otherwise"
   | IterPr ({it = IterPr _; _} as prem', iter) ->
     string_of_prem prem' ^ string_of_iterexp iter
diff --git a/spectec/src/il/valid.ml b/spectec/src/il/valid.ml
index cd60df9306..dd1ba0d0ee 100644
--- a/spectec/src/il/valid.ml
+++ b/spectec/src/il/valid.ml
@@ -548,9 +548,9 @@ and valid_prem env prem =
     valid_expmix env mixop e (mixop, t) e.at
   | IfPr e ->
     valid_exp env e (BoolT $ e.at)
-  | LetPr (e1, e2, ids) ->
+  | LetPr (e1, e2, xs) ->
     valid_exp env (CmpE (EqOp, e1, e2) $$ prem.at % (BoolT $ prem.at))  (BoolT $ prem.at);
-    let target_ids = Free.(free_list free_varid ids) in
+    let target_ids = Free.({empty with varid = Set.of_list xs}) in
     let free_ids = Free.(free_exp e1) in
     if not (Free.subset target_ids free_ids) then
       error prem.at ("target identifier(s) " ^
diff --git a/spectec/src/il2al/animate.ml b/spectec/src/il2al/animate.ml
index b1a7668cf3..40ab11bd7b 100644
--- a/spectec/src/il2al/animate.ml
+++ b/spectec/src/il2al/animate.ml
@@ -20,6 +20,8 @@ let list_count pred = list_count' pred 0
 
 let not_ f x = not (f x)
 
+let (--) xs ys = List.filter (fun x -> not (List.mem x ys)) xs
+
 (* Helper for handling free-var set *)
 let subset x y = Set.subset x.varid y.varid
 
@@ -28,6 +30,7 @@ type tag =
   | Assign of string list
 (* type row = tag * prem * int list *)
 let unwrap (_, p, _) = p
+let targets (t, _, _) = match t with Assign targets -> targets | _ -> assert false
 
 (* are all free variables in the premise known? *)
 let is_tight env (tag, prem, _) =
@@ -41,9 +44,35 @@ let is_assign env (tag, prem, _) =
   | Assign frees -> subset (diff (free_prem false prem) {empty with varid = (Set.of_list frees)}) env
   | _ -> false
 
-(* iteratively select condition and assignment premises,
+(* is this assign premise encoded premise for pop? *)
+let is_pop env row =
+  is_assign env row &&
+  match (unwrap row).it with
+  | LetPr (_, rhs, _) -> Il.Print.string_of_typ rhs.note = "stackT"
+  | _ -> false
+
+(* iteratively select pop, condition and assignment premises,
  * effectively sorting the premises as a result. *)
-let rec select_tight prems acc env fb =
+let rec select_pops prems acc env fb =
+  match prems with
+  | [] -> Some acc
+  | _ ->
+    let (pops, non_pops) = List.partition (is_pop env) prems in
+    match pops with
+    | [] ->
+      select_tight prems acc env fb
+    | _ ->
+      let pops' = List.map unwrap pops in
+      let new_env = pops
+        |> List.map targets
+        |> List.concat
+        |> List.fold_left (fun env x ->
+          union env { empty with varid = Set.singleton x }
+        ) env
+      in
+      select_pops non_pops (acc @ pops') new_env fb
+
+and select_tight prems acc env fb =
   match prems with
   | [] -> Some acc
   | _ ->
@@ -54,7 +83,13 @@ and select_assign prems acc env fb =
   match prems with
   | [] -> Some acc
   | _ ->
-    let (assigns, non_assigns) = List.partition (is_assign env) prems in
+    let (pops, non_pops) = List.partition (is_pop env) prems in
+    let (assigns, non_assigns) =
+      if pops = [] then
+        List.partition (is_assign env) prems
+      else
+        pops, non_pops
+    in
     match assigns with
     | [] ->
       let len = List.length acc in
@@ -63,7 +98,13 @@ and select_assign prems acc env fb =
       None
     | _ ->
       let assigns' = List.map unwrap assigns in
-      let new_env = assigns' |> List.map (free_prem false) |> List.fold_left union env in
+      let new_env = assigns
+        |> List.map targets
+        |> List.concat
+        |> List.fold_left (fun env x ->
+          union env { empty with varid = Set.singleton x }
+        ) env
+      in
       select_tight non_assigns (acc @ assigns') new_env fb
 
 let select_target_col rows cols =
@@ -145,13 +186,12 @@ let subset_selector e =
   else large_enough_subsets
 
 let rows_of_eq vars len i l r at =
-  free_exp_list l
+  (free_exp_list l -- free_exp_list r)
   |> subset_selector l
   |> List.filter_map (fun frees ->
     let covering_vars = List.filter_map (index_of len vars) frees in
     if List.length frees = List.length covering_vars then (
-      let ids = List.map (fun x -> x $ no_region) frees in (* TODO: restore source *)
-      Some (Assign frees, LetPr (l, r, ids) $ at, [i] @ covering_vars) )
+      Some (Assign frees, LetPr (l, r, frees) $ at, [i] @ covering_vars) )
     else
       None
   )
@@ -169,8 +209,7 @@ let rec rows_of_prem vars len i p =
         @ rows_of_eq vars len i l { r with it = TheE r } p.at
       | _ -> [ Condition, p, [i] ]
     )
-  | LetPr (_, _, ids) ->
-    let targets = List.map it ids in
+  | LetPr (_, _, targets) ->
     let covering_vars = List.filter_map (index_of len vars) targets in
     [ Assign targets, p, [i] @ covering_vars ]
   | RulePr (_, _, { it = TupE args; _ }) ->
@@ -214,7 +253,7 @@ let animate_prems known_vars prems =
 
   (* 2. Reorder *)
   let best' = ref (-1, []) in
-  match List.find_map (fun cand -> select_tight cand other known_vars best') candidates with
+  match List.find_map (fun cand -> select_pops cand other known_vars best') candidates with
   | None ->
     if (not k_fail) then
       let unhandled_prems = Lib.List.drop (fst !best') (snd !best') in
@@ -229,8 +268,8 @@ let animate_rule r = match r.it with
   | RuleD(id, binds, mixop, args, prems) -> (
     match (mixop, args.it) with
     (* lhs ~> rhs *)
-    | ([ [] ; [{it = SqArrow; _}] ; []] , TupE ([lhs; _rhs])) ->
-      let new_prems = animate_prems (free_exp true lhs) prems in
+    | ([ [] ; [{it = SqArrow; _}] ; []] , TupE ([_lhs; _rhs])) ->
+      let new_prems = animate_prems {empty with varid = Set.of_list Encode.input_vars} prems in
       RuleD(id, binds, mixop, args, new_prems) $ r.at
     | _ -> r
   )
diff --git a/spectec/src/il2al/dune b/spectec/src/il2al/dune
index b30ad49633..d99e07b17a 100644
--- a/spectec/src/il2al/dune
+++ b/spectec/src/il2al/dune
@@ -9,5 +9,6 @@
     transpile
     free
     preprocess
+    encode
   )
 )
diff --git a/spectec/src/il2al/encode.ml b/spectec/src/il2al/encode.ml
new file mode 100644
index 0000000000..4c21466d28
--- /dev/null
+++ b/spectec/src/il2al/encode.ml
@@ -0,0 +1,201 @@
+(**
+Encode lhs of a reduction rule into premises.
+ex)
+  v3* v2^n v1 INSTR ~> eps
+  -->
+  v3* v2^n v1 INSTR ~> eps
+  -- if v1,   _s1 = POP(1), 0
+  -- if v2^n, _s2 = POP(n), _s1
+  -- if v3* , _s3 = POP(-1), _s2
+**)
+
+open Util
+open Source
+
+open Il
+open Ast
+(* open Print *)
+open Free
+
+(* Helpers *)
+let error at msg = Error.error at "prose translation" msg
+
+let mk_id x =
+  x $ no_region
+let mk_varT xt =
+  VarT (mk_id xt, []) $ no_region
+let mk_varE xe xt =
+  VarE (mk_id xe) $$ no_region % (mk_varT xt)
+
+let is_case e =
+  match e.it with
+  | CaseE _ -> true
+  | _ -> false
+let case_of_case e =
+  match e.it with
+  | CaseE (mixop, _) -> mixop
+  | _ -> error e.at "cannot get case of case expression"
+let args_of_case e =
+  match e.it with
+  | CaseE (_, { it = TupE exps; _ }) -> exps
+  | CaseE (_, exp) -> [ exp ]
+  | _ -> error e.at "cannot get arguments of case expression"
+
+let context_names = [
+  "FRAME_";
+  "LABEL_";
+  "HANDLER_";
+]
+
+let is_context e =
+  is_case e &&
+  match case_of_case e with
+  | (atom :: _) :: _ ->
+    (match it atom with
+
+  | Atom a -> List.mem a context_names
+    | _ -> false)
+  | _ -> false
+
+let rec stack_to_list e =
+  match e.it with
+  | CatE (e1, e2) -> stack_to_list e1 @ stack_to_list e2
+  | ListE es -> es
+  (* List.map (fun e -> { e with it = ListE [e] }) es *)
+  | _ -> [ e ]
+
+let rec drop_until' acc f xs =
+  match xs with
+  | [] -> acc, []
+  | hd :: tl -> if f hd then acc, xs else drop_until' (hd :: acc) f tl
+let drop_until = drop_until' []
+
+let free_ids e =
+  (free_exp e)
+  .varid
+  |> Set.elements
+
+let dim e =
+  let t = (NumT NatT $ no_region) in
+  match e.it with
+  | IterE (_, (ListN (e_n, _), _)) -> e_n
+  | IterE _ -> NatE Z.minus_one $$ e.at % t
+  | ListE es -> NatE (List.length es |> Z.of_int) $$ e.at % t
+  | _ -> NatE Z.one $$ e.at % t
+
+let arg e =
+  ExpA e $ e.at
+
+let input_vars = [
+  "input";
+  "stack0";
+  "ctxt";
+  "state";
+  "unused";
+]
+
+(* Encode stack *)
+
+let encode_inner_stack context_opt stack =
+  let dropped, es = stack_to_list stack |> List.rev |> drop_until is_case in
+
+  let unused_prems =
+    if List.length dropped = 0 then
+      []
+    else
+      let unused = TupE dropped $$ no_region % (mk_varT "unusedT") in
+      [LetPr (unused, mk_varE "unused" "unusedT", free_ids unused) $ no_region]
+  in
+
+  match es with
+  | [] ->
+    (* ASSUMPTION: The target instruction was actually the outer context (i.e. LABEL_) *)
+    (
+      match context_opt with
+      | None -> assert false
+      | Some e ->
+        Some (LetPr (e, mk_varE "input" "inputT", free_ids e) $ e.at), unused_prems
+    )
+  | _ ->
+    (* ASSUMPTION: The top of the stack should be now the target instruction *)
+    let winstr, operands = Lib.List.split_hd es in
+
+    let prem = LetPr (winstr, mk_varE "input" "inputT", free_ids winstr) $ winstr.at in
+    let prems = List.mapi (fun i e ->
+      let s0 = ("stack" ^ string_of_int i) in
+      let s1 = ("stack" ^ string_of_int (i+1)) in
+      let t = mk_varT "stackT" in
+
+      let stack1 = mk_varE s1 "stackT" in
+      let lhs = TupE [e; stack1] $$ no_region % t in
+
+      let n = dim e in
+      let stack0 = mk_varE s0 "stackT" in
+      let rhs = CallE (mk_id "pop", [arg n; arg stack0]) $$ no_region % t in
+
+      IfPr (CmpE (EqOp, lhs, rhs) $$ e.at % (BoolT $ no_region)) $ e.at
+    ) operands in
+
+    None, prem :: prems @ unused_prems
+
+let encode_stack stack =
+  match stack.it with
+  | ListE [e] when is_context e ->
+    let mixop = case_of_case e in
+    let args  = args_of_case e in
+
+    (* ASSUMPTION: the inner stack of the ctxt instruction is always the last arg *)
+    let args', inner_stack = Lib.List.split_last args in
+    let mixop', _ = Lib.List.split_last mixop in
+
+    let e1 = { e with it = CaseE (mixop', TupE args' $$ no_region % (mk_varT "")) } in
+    let e2 = (mk_varE "ctxt" "contextT") in
+
+    let pr = LetPr (e1, e2, free_ids e1) $ e2.at in
+
+    let pr_opt, prs = encode_inner_stack (Some e) inner_stack in
+    (
+      match pr_opt with
+      | None -> pr
+      | Some pr -> pr
+    ) :: prs
+  | _ ->
+    encode_inner_stack None stack |> snd
+
+(* Encode lhs *)
+let encode_lhs lhs =
+  match lhs.it with
+  | CaseE ([[]; [{it = Semicolon; _}]; []], {it = TupE [z; stack]; _}) ->
+    let prem = LetPr (z, mk_varE "state" "stateT", free_ids z) $ z.at in
+    prem :: encode_stack stack
+  | _ ->
+    let stack = lhs in
+    encode_stack stack
+
+(* Encode rule *)
+let encode_rule r =
+  match r.it with
+  | RuleD(id, binds, mixop, args, prems) ->
+    match (mixop, args.it) with
+    (* lhs ~> rhs *)
+    | ([ [] ; [{it = SqArrow; _}] ; []] , TupE ([lhs; _rhs])) ->
+      let name = String.split_on_char '-' id.it |> List.hd in
+      if List.mem name ["pure"; "read"; "trap"; "ctxt"] then (* Administrative rules *)
+        r
+      else
+        let new_prems = encode_lhs lhs in
+        RuleD(id, binds, mixop, args, new_prems @ prems) $ r.at
+    | _ -> r
+
+(* Encode defs *)
+let rec encode_def d =
+  match d.it with
+  | RelD (id, mixop, t, rules) ->
+    let rules' = List.map encode_rule rules in
+    RelD (id, mixop, t, rules') $ d.at
+  | RecD ds -> RecD (List.map encode_def ds) $ d.at
+  | DecD _ | TypD _ | GramD _ | HintD _ -> d
+
+(* Main entry *)
+let transform (defs : script) =
+  List.map encode_def defs
diff --git a/spectec/src/il2al/il2il.ml b/spectec/src/il2al/il2il.ml
index ab05a55b42..7ed439667c 100644
--- a/spectec/src/il2al/il2il.ml
+++ b/spectec/src/il2al/il2il.ml
@@ -4,92 +4,13 @@ Functions that transform IL into IL.
 
 open Il.Ast
 open Il.Eq
+open Il.Free
 open Util
 open Util.Source
 
 type rgroup = (exp * exp * (prem list)) phrase list
 
 (* Helpers *)
-(* 
-let take_prefix n str =
-  if String.length str < n then
-    str
-  else
-    String.sub str 0 n
- *)
-
-(* Walker-based transformer *)
-
-let rec transform_expr f e =
-  let new_ = transform_expr f in
-  let it =
-    match (f e).it with
-    | VarE _
-    | BoolE _
-    | NatE _
-    | TextE _ -> e.it
-    | UnE (op, e1) -> UnE (op, new_ e1)
-    | BinE (op, e1, e2) -> BinE (op, new_ e1, new_ e2)
-    | CmpE (op, e1, e2) -> CmpE (op, new_ e1, new_ e2)
-    | IdxE (e1, e2) -> IdxE (new_ e1, new_ e2)
-    | SliceE (e1, e2, e3) -> SliceE (new_ e1, new_ e2, new_ e3)
-    | UpdE (e1, p, e2) -> UpdE (new_ e1, p, new_ e2)
-    | ExtE (e1, p, e2) -> ExtE (new_ e1, p, new_ e2)
-    | StrE efs -> StrE efs (* TODO efs *)
-    | DotE (e1, atom) -> DotE (new_ e1, atom)
-    | CompE (e1, e2) -> CompE (new_ e1, new_ e2)
-    | LenE e1 -> LenE (new_ e1)
-    | TupE es -> TupE ((List.map new_) es)
-    | CallE (id, as1) -> CallE (id, List.map (transform_arg f) as1)
-    | IterE (e1, iter) -> IterE (new_ e1, iter) (* TODO iter *)
-    | ProjE (e1, i) -> ProjE (new_ e1, i)
-    | UncaseE (e1, op) -> UncaseE (new_ e1, op)
-    | OptE eo -> OptE ((Option.map new_) eo)
-    | TheE e1 -> TheE (new_ e1)
-    | ListE es -> ListE ((List.map new_) es)
-    | CatE (e1, e2) -> CatE (new_ e1, new_ e2)
-    | MemE (e1, e2) -> MemE (new_ e1, new_ e2)
-    | CaseE (mixop, e1) -> CaseE (mixop, new_ e1)
-    | SubE (e1, _t1, t2) -> SubE (new_ e1, _t1, t2)
-  in { e with it }
-
-
-and transform_arg f a =
-  { a with it = match a.it with
-    | ExpA e -> ExpA (transform_expr f e)
-    | TypA t -> TypA t
-    | DefA id -> DefA id
-    | GramA id -> GramA id }
-
-(* Change right_assoc cat into left_assoc cat *)
-let to_left_assoc_cat =
-  let rec rotate_ccw e =
-    begin match e.it with
-    | CatE (l, r) ->
-      begin match r.it with
-      | CatE (rl, rr) ->
-        { e with it = CatE (CatE (l, rl) $$ no_region % e.note, rr) } |> rotate_ccw
-      | _ -> e
-      end
-    | _ -> e
-    end in
-  transform_expr rotate_ccw
-
-
-(* Change left_assoc cat into right_assoc cat *)
-let to_right_assoc_cat =
-  let rec rotate_cw e =
-    begin match e.it with
-    | CatE (l, r) ->
-      begin match l.it with
-      | CatE (ll, lr) ->
-        { e with it = CatE (ll, CatE (lr, r) $$ no_region % e.note) } |> rotate_cw
-      | _ -> e
-      end
-    | _ -> e
-    end in
-  transform_expr rotate_cw
-
 
 (* Unifying lhs *)
 
@@ -97,11 +18,17 @@ let to_right_assoc_cat =
 
 let unified_prefix = "u"
 let _unified_idx = ref 0
-let init_unified_idx () = _unified_idx := 0
+let _unified_idx_cache = ref None
+let init_unified_idx () = _unified_idx := 0; _unified_idx_cache := None
+let soft_init_unified_idx () =
+  match !_unified_idx_cache with
+  | None -> _unified_idx_cache := Some (!_unified_idx)
+  | Some n -> _unified_idx := n
 let get_unified_idx () = let i = !_unified_idx in _unified_idx := (i+1); i
 let gen_new_unified ty = (Al.Al_util.typ_to_var_name ty) ^ "_" ^ unified_prefix ^ (string_of_int (get_unified_idx())) $ no_region
 let is_unified_id id = String.split_on_char '_' id |> Util.Lib.List.last |> String.starts_with ~prefix:unified_prefix
 
+
 let rec overlap e1 e2 = if eq_exp e1 e2 then e1 else
   let replace_it it = { e1 with it = it } in
   match e1.it, e2.it with
@@ -199,8 +126,8 @@ let rec collect_unified template e = if eq_exp template e then [], [] else
     | VarE id, _
     | IterE ({ it = VarE id; _}, _) , _
       when is_unified_id id.it ->
-      [ IfPr (CmpE (EqOp, template, e) $$ e.at % (BoolT $ e.at)) $ e.at ],
-      [ ExpB (id, template.note, []) $ e.at ]
+      [IfPr (CmpE (EqOp, template, e) $$ e.at % (BoolT $ e.at)) $ e.at],
+      [ExpB (id, template.note, []) $ e.at]
     | UnE (_, e1), UnE (_, e2)
     | DotE (e1, _), DotE (e2, _)
     | LenE e1, LenE e2
@@ -229,7 +156,8 @@ let rec collect_unified template e = if eq_exp template e then [], [] else
     | CallE (_, as1), CallE (_, as2) -> collect_unified_args as1 as2
     (* HARDCODE: Unifying CatE with non-CatE *)
     | CatE (_, e1), _ -> collect_unified e1 e
-    | _ -> Util.Error.error e.at "prose transformation" "cannot unify the expression with previous rule for the same instruction"
+    | _ ->
+      Util.Error.error e.at "prose transformation" "cannot unify the expression with previous rule for the same instruction"
 
 and collect_unified_arg template a = if eq_arg template a then [], [] else match template.it, a.it with
   | ExpA template', ExpA e -> collect_unified template' e
@@ -246,6 +174,27 @@ let prioritize_else prems =
   let other, non_others = List.partition (fun p -> p.it = ElsePr) prems in
   other @ non_others
 
+let lhs_of_prem pr =
+  match pr.it with
+  | LetPr (lhs, _, _) -> lhs
+  | _ -> Error.error pr.at "prose translation" "expected a LetPr"
+let rhs_of_prem pr =
+  match pr.it with
+  | LetPr (_, rhs, _) -> rhs
+  | _ -> Error.error pr.at "prose translation" "expected a LetPr"
+let replace_lhs lhs pr =
+  match pr.it with
+  | LetPr (lhs', rhs, _) ->
+    if eq_exp lhs lhs' then
+      pr
+    else
+      { pr with it = LetPr (lhs, rhs, (free_exp lhs).varid |> Set.elements) }
+  | _ -> Error.error pr.at "prose translation" "expected a LetPr"
+
+(* x list list -> x list list list *)
+let lift = List.map (fun xs -> List.map (fun x -> [x]) xs)
+(* x list list list -> x list list *)
+let unlift = List.map List.concat
 
 (** 1. Validation rules **)
 
@@ -257,6 +206,7 @@ let apply_template_to_rule template rule =
 
 let unify_rules rules =
   init_unified_idx();
+
   let concls = List.map (fun x -> let RuleD(_, _, _, e, _) = x.it in e) rules in
   let hd = List.hd concls in
   let tl = List.tl concls in
@@ -265,27 +215,102 @@ let unify_rules rules =
 
 
 (** 2. Reduction rules **)
-let apply_template_to_rgroup template (lhs, rhs, prems) =
-  let new_prems, _ = collect_unified template lhs in
-  (* TODO: Remove this depedency on animation. Perhaps this should be moved as a middle end before animation path *)
-  let animated_prems = Animate.animate_prems (Il.Free.free_exp template) new_prems in
-  template, rhs, prioritize_else (animated_prems @ prems)
 
-let unify_lhs' rgroup =
-  init_unified_idx();
-  let fst = fun (x, _, _) -> x in
-  let lhs_group = List.map (fun r -> fst r.it) rgroup in
-  let hd = List.hd lhs_group in
-  let tl = List.tl lhs_group in
-  let template = List.fold_left overlap hd tl in
-  List.map (Source.map (apply_template_to_rgroup template)) rgroup
+let apply_template_to_prems template prems idx =
+  List.mapi (fun i prem ->
+    if i <> idx then
+      prem
+    else (
+      assert (List.length prem = 1);
+      let prem = List.hd prem in
+      let new_prem = replace_lhs template prem in
+      let new_prems, _ = collect_unified template (lhs_of_prem prem) in
+      new_prem :: new_prems)
+  ) prems
 
-let unify_lhs (rname, rel_id, rgroup) =
-  let to_left_assoc (lhs, rhs, prems) = to_left_assoc_cat lhs, rhs, prems in
-  let to_right_assoc (lhs, rhs, prems) = to_right_assoc_cat lhs, rhs, prems in
-  (* typical f^-1 ∘ g ∘ f *)
-  rname, rel_id, (rgroup |> List.map (Source.map to_left_assoc) |> unify_lhs' |> List.map (Source.map to_right_assoc))
+let unify_enc premss encs =
+  let idxs = List.map fst encs in
+  let ps = List.map snd encs in
 
+  let es = List.map lhs_of_prem ps in
+
+  let hd = List.hd es in
+  let tl = List.tl es in
+
+  let template = List.fold_left overlap hd tl in
+
+  List.map2 (apply_template_to_prems template) premss idxs
+
+let is_encoded_ctxt pr =
+  match pr.it with
+  | LetPr (_, e, _) ->
+    (match e.note.it with
+    | VarT (id, []) -> List.mem id.it ["inputT"; "stackT"; "contextT"]
+    | _ -> false)
+  | _ -> false
+let is_encoded_pop_or_winstr pr =
+  match pr.it with
+  | LetPr (_, e, _) ->
+    (match e.note.it with
+    | VarT (id, []) -> List.mem id.it ["inputT"; "stackT"]
+    | _ -> false)
+  | _ -> false
+
+let rec extract_encs' pred cnt =
+  function
+  | [] -> []
+  | hd :: tl ->
+    if pred hd then
+      (cnt, hd) :: extract_encs' pred (cnt + 1) tl
+    else
+      extract_encs' pred (cnt + 1) tl
+let extract_encs pred = extract_encs' pred 0
+
+let has_identical_rhs iprem1 iprem2 =
+  let rhs1 = iprem1 |> snd |> rhs_of_prem in
+  let rhs2 = iprem2 |> snd |> rhs_of_prem in
+
+  eq_exp rhs1 rhs2
+
+let rec filter_unifiable encss =
+  match encss with
+  | [] -> assert false
+  | encs :: encss' ->
+    if encs = [] then
+      []
+    else
+      let hd = List.hd encs in
+      let tl = List.tl encs in
+      let pairs = List.map (fun encs -> List.partition (has_identical_rhs hd) encs) encss' in
+      let fsts = List.map fst pairs in
+      let snds = List.map snd pairs in
+
+      assert (List.for_all (fun xs -> List.length xs <= 1) fsts);
+
+      if List.for_all (fun xs -> List.length xs = 1) fsts then
+        (hd :: List.map List.hd fsts) :: filter_unifiable (tl :: snds)
+      else
+        filter_unifiable (tl :: snds)
+
+let replace_prems r prems =
+  let (lhs, rhs, _prems) = r.it in
+  { r with it = (lhs, rhs, prems) }
+
+let unify_rgroup pred input_vars rgroup =
+  let premss = List.map (fun g -> let (_, _, prems) = g.it in prems) rgroup in
+  let encss = List.map (extract_encs pred) premss in
+  let unifiable_encss = filter_unifiable encss in
+  let new_premss = List.fold_left unify_enc (lift premss) unifiable_encss |> unlift in
+  let animated_premss = List.map (Animate.animate_prems {empty with varid = Set.of_list (input_vars @ Encode.input_vars)}) new_premss in
+
+  List.map2 replace_prems rgroup animated_premss
+
+let unify_ctxt input_vars rgroup =
+  soft_init_unified_idx();
+  unify_rgroup is_encoded_ctxt input_vars rgroup
+let unify_pop_and_winstr rgroup =
+  init_unified_idx();
+  unify_rgroup is_encoded_pop_or_winstr [] rgroup
 
 (** 3. Functions **)
 
@@ -293,11 +318,12 @@ let apply_template_to_def template def =
   match def.it with
   | DefD (binds, lhs, rhs, prems) ->
     let new_prems, new_binds = collect_unified_args template lhs in
-    let animated_prems = Animate.animate_prems Il.Free.(free_list free_arg template) new_prems in
+    let animated_prems = Animate.animate_prems (free_list free_arg template) new_prems in
     DefD (binds @ new_binds, template, rhs, (animated_prems @ prems) |> prioritize_else) $ def.at
 
 let unify_defs defs =
   init_unified_idx();
+
   let lhs_s = List.map (fun x -> let DefD(_, lhs, _, _) = x.it in lhs) defs in
   let hd = List.hd lhs_s in
   let tl = List.tl lhs_s in
diff --git a/spectec/src/il2al/il2il.mli b/spectec/src/il2al/il2il.mli
index 597463a1ef..5e9011ef15 100644
--- a/spectec/src/il2al/il2il.mli
+++ b/spectec/src/il2al/il2il.mli
@@ -2,9 +2,7 @@ open Il.Ast
 
 type rgroup = (exp * exp * (prem list)) Util.Source.phrase list
 
-val transform_expr : (exp -> exp) -> exp -> exp
-val is_unified_id : string -> bool
-
 val unify_rules : rule list -> rule list
-val unify_lhs : string * id * rgroup -> string * id * rgroup
+val unify_pop_and_winstr : rgroup -> rgroup
+val unify_ctxt : string list -> rgroup -> rgroup
 val unify_defs : clause list -> clause list
diff --git a/spectec/src/il2al/preprocess.ml b/spectec/src/il2al/preprocess.ml
index b90915fb30..733291279f 100644
--- a/spectec/src/il2al/preprocess.ml
+++ b/spectec/src/il2al/preprocess.ml
@@ -60,6 +60,35 @@ let remove_or def =
     DecD (id, params, typ, List.concat_map remove_or_clause clauses) $ def.at
   | _ -> def
 
+(* HARDCODE: Remove a reduction rule for the block context, specifically, for THROW_REF *)
+let is_block_context_exp e =
+  match e.it with
+  (* instr* =/= [] *)
+  | CmpE (NeOp, e1, e2) ->
+    begin match e1.it, e2.it with
+    | IterE (var, (List, _)), ListE []
+    | ListE [], IterE (var, (List, _)) ->
+      begin match var.it with
+      | VarE id -> id.it = "instr"
+      | _ -> false
+      end
+    | _ -> false
+    end
+  | _ -> false
+let is_block_context_prem prem =
+  match prem.it with
+  | IfPr e -> is_block_context_exp e
+  | _ -> false
+let is_block_context_rule rule =
+  match rule.it with
+  | RuleD (_, _, _, _, [prem]) -> is_block_context_prem prem
+  | _ -> false
+let remove_block_context def =
+  match def.it with
+  | RelD (id, mixop, typ, rules) ->
+    RelD (id, mixop, typ, Util.Lib.List.filter_not is_block_context_rule rules) $ def.at
+  | _ -> def
+
 
 (* Pre-process a premise *)
 let rec preprocess_prem prem =
@@ -128,7 +157,13 @@ let preprocess_clause (clause: clause) : clause =
   DefD (binds, args, exp, List.concat_map preprocess_prem prems) $ clause.at
 
 let rec preprocess_def (def: def) : def =
-  match (remove_or def).it with
+  let def' =
+    def
+    |> remove_or
+    |> remove_block_context
+  in
+
+  match def'.it with
   | RelD (id, mixop, typ, rules) ->
     RelD (id, mixop, typ, List.map preprocess_rule rules) $ def.at
   | DecD (id, params, typ, clauses) ->
diff --git a/spectec/src/il2al/translate.ml b/spectec/src/il2al/translate.ml
index 8a2fc6e3a5..6d44044a6f 100644
--- a/spectec/src/il2al/translate.ml
+++ b/spectec/src/il2al/translate.ml
@@ -48,33 +48,54 @@ let split_state (exp: Il.exp): Il.exp * Il.exp =
   when is_store e1 && is_frame e2 -> e1, e2
   | _ -> assert(false)
 
-let is_list expr =
-  match expr.it with
-  | Il.CatE _ | Il.ListE _ -> true
-  | _ -> false
-
-let rec to_exp_list' (exp: Il.exp): Il.exp list =
-  match exp.it with
-  | Il.CatE (exp1, exp2) -> to_exp_list' exp1 @ to_exp_list' exp2
-  | Il.ListE exps -> List.map (fun e -> { e with it = Il.ListE [e] }) exps
-  | _ -> [ exp ]
-let to_exp_list (exp: Il.exp): Il.exp list = to_exp_list' exp |> List.rev
-
 let flatten_rec def =
   match def.it with
   | Il.RecD defs -> defs
   | _ -> [ def ]
 
-let get_params winstr =
-  match winstr.it with
+let args_of_call e =
+  match e.it with
+  | CallE (_, args) -> args
+  | _ -> error e.at
+    (sprintf "cannot get arguments of call expression `%s`" (Print.string_of_expr e))
+
+let expr2arg e = ExpA e $ e.at
+let arg2expr a =
+  match a.it with
+  | ExpA e -> e
+  | TypA _ -> error a.at "Argument is not an expression"
+
+(* Utils for IL *)
+let is_case e =
+  match e.it with
+  | Il.CaseE _ -> true
+  | _ -> false
+let case_of_case e =
+  match e.it with
+  | Il.CaseE (mixop, _) -> mixop
+  | _ -> error e.at
+    (sprintf "cannot get case of case expression `%s`" (Il.Print.string_of_exp e))
+let args_of_case e =
+  match e.it with
   | Il.CaseE (_, { it = Il.TupE exps; _ }) -> exps
   | Il.CaseE (_, exp) -> [ exp ]
-  | _ -> error winstr.at
-    (sprintf "cannot get params of wasm instruction `%s`" (Il.Print.string_of_exp winstr))
-
-let lhs_of_rgroup rgroup =
-  let (lhs, _, _) = (List.hd rgroup).it in
-  lhs
+  | _ -> error e.at
+    (sprintf "cannot get arguments of case expression `%s`" (Il.Print.string_of_exp e))
+
+let context_names = [
+  "FRAME_";
+  "LABEL_";
+  "HANDLER_";
+]
+
+let is_context exp =
+  is_case exp &&
+  match case_of_case exp with
+  | (atom :: _) :: _ ->
+    (match it atom with
+    | Atom a -> List.mem a context_names
+    | _ -> false)
+  | _ -> false
 
 let name_of_rule rule =
   match rule.it with
@@ -85,27 +106,50 @@ let args_of_clause clause =
   match clause.it with
   | Il.DefD (_, args, _, _) -> args
 
-let upper = String.uppercase_ascii
-let wrap typ e = e $$ no_region % typ
-
-let hole = Il.TextE "_" |> wrap topT
-
 let contains_ids ids expr =
   ids
   |> IdSet.of_list
   |> IdSet.disjoint (free_expr expr)
   |> not
 
-let insert_nop instrs = match instrs with [] -> [ nopI () ] | _ -> instrs
-
 (* Insert `target` at the innermost if instruction *)
 let rec insert_instrs target il =
   match Util.Lib.List.split_last_opt il with
-  | Some ([], { it = OtherwiseI il'; _ }) -> [ otherwiseI (il' @ insert_nop target) ]
+  | Some ([], { it = OtherwiseI il'; _ }) -> [ otherwiseI (il' @ Transpile.insert_nop target) ]
   | Some (h, { it = IfI (cond, il', []); _ }) ->
-    h @ [ ifI (cond, insert_instrs (insert_nop target) il' , []) ]
+    h @ [ ifI (cond, insert_instrs (Transpile.insert_nop target) il' , []) ]
+  | _ -> il @ target
+
+(* Insert `target` at the else-branch of innermost if instruction *)
+let rec insert_instrs_to_else target il =
+  match Util.Lib.List.split_last_opt il with
+  | Some (h, { it = IfI (cond, il1, il2); _ }) ->
+    h @ [ ifI (cond, il1, insert_instrs_to_else target il2) ]
   | _ -> il @ target
 
+let has_branch = List.exists (fun i ->
+  match i.it with
+  | IfI _
+  | OtherwiseI _ -> true
+  | _ -> false
+)
+
+let is_let_prem_with_rhs_type t prem =
+  match prem.it with
+  | Il.LetPr (_, e, _) ->
+    (match e.note.it with
+    | Il.VarT (id, []) -> id.it = t
+    | _ -> false)
+  | _ -> false
+let is_pop = is_let_prem_with_rhs_type "stackT"
+let is_ctxt_prem = is_let_prem_with_rhs_type "contextT"
+let is_winstr_prem = is_let_prem_with_rhs_type "inputT"
+
+let lhs_of_prem pr =
+  match pr.it with
+  | Il.LetPr (lhs, _, _) -> lhs
+  | _ -> Error.error pr.at "prose translation" "expected a LetPr"
+
 (** Translation *)
 
 (* `Il.iter` -> `iter` *)
@@ -307,12 +351,14 @@ let insert_assert exp =
     assertI (topValuesE (translate_exp e) ~at:at ~note:boolT) ~at:at
   | Il.CaseE ([{it = Il.Atom "LABEL_"; _}]::_, { it = Il.TupE [ _n; _instrs; _vals ]; _ }) ->
     assertI (topLabelE () ~at:at ~note:boolT) ~at:at
+  | Il.CaseE ([{it = Il.Atom "HANDLER_"; _}]::_, _) ->
+    assertI (yetE "a handler is now on the top of the stack" ~at:at ~note:boolT) ~at:at
   | Il.CaseE ([{it = Il.Atom "CONST"; _}]::_, { it = Il.TupE (ty' :: _); _ }) ->
     assertI (topValueE (Some (translate_exp ty')) ~note:boolT) ~at:at
   | _ ->
     assertI (topValueE None ~note:boolT) ~at:at
 
-let assert_cond_of_pop_value e =
+let cond_of_pop_value e =
   let at = e.at in
   let bt = boolT in
   match e.it with
@@ -332,39 +378,16 @@ let assert_cond_of_pop_value e =
   | _ ->
     topValueE None ~note:bt
 
-let assert_of_pop i =
+let post_process_of_pop i =
   let at = i.at in
-  (* let bt = boolT () in *)
 
   match i.it with
-  | PopI e -> [ assertI (assert_cond_of_pop_value e) ~at:at ]
-  (* | PopsI (_, e') -> [ assertI (topValuesE e' ~at:at ~note:bt) ~at:at ] *)
-  | _ -> []
+  | PopI e -> assertI (cond_of_pop_value e) ~at:at :: [i]
+  | PopAllI _ -> [i]
+  | _ -> error at "not PopI nor PopallI"
 
-let post_process_of_pop i =
-  (* HARDCODE : Change ($lunpack(t).CONST c) into (nt.CONST c) *)
-  let prefix, pi =
-    (match i.it with
-    | PopI const ->
-      (match const.it with
-      | CaseE (op, [ { it = CallE _; _ } as t; c]) ->
-        (match (get_atom op) with
-        | Some a ->
-          let name = Il.Atom.name a in
-          let var = if name = "CONST" then "nt_0" else "vt_0" in
-          let t' = { t with it = VarE var } in
-          let const' = { const with it = CaseE (op, [t'; c]) } in
-          let i' = { i with it = PopI const' } in
-          [ letI (t', t) ], i'
-        | None -> [], i)
-      | _ -> [], i)
-    | _ -> [], i)
-  in
-  (* End of HARDCODE *)
-
-  prefix @ assert_of_pop pi @ [pi]
-
-let insert_pop e =
+(* TODO: remove this *)
+let insert_pop' e =
   let valsT = listT valT in
   let pop =
     match e.it with
@@ -379,73 +402,38 @@ let insert_pop e =
   in
   post_process_of_pop pop
 
-(* Assume that only the iter variable is unbound *)
-let is_unbound vars e =
-  match e.it with
-  | Il.IterE (_, (ListN (e', _), _))
-    when not (Il.Free.subset (Il.Free.free_exp e') vars) -> true
-  | _ -> false
-
-let get_unbound e =
-  match e.it with
-  | Il.IterE (_, (ListN ({ it = VarE id; _ }, _), _)) -> id.it
-  | _ -> error e.at
-    (sprintf "cannot get_unbound: not an iter expression `%s`" (Il.Print.string_of_exp e))
-
+let insert_pop e e_n =
+  let valsT = listT valT in
+  let pop =
+    match e.it, e_n.it with
+    | ListE [e'], _ ->
+      popI { e' with note = valT } ~at:e'.at
+    | _, NumE z when z = Z.minus_one ->
+      popallI { e with note = valsT } ~at:e.at
+    | _ ->
+      popsI { e with note = valsT } (Some e_n) ~at:e.at
+  in
+  post_process_of_pop pop
 
 let rec translate_rhs exp =
   let at = exp.at in
-  let note = exp.note in
   match exp.it with
   (* Trap *)
   | Il.CaseE ([{it = Atom "TRAP"; _}]::_, _) -> [ trapI () ~at:at ]
   (* Context *)
-  | Il.CaseE (
-      [ { it = Il.Atom "FRAME_"; _ } as atom ] :: _,
-      { it =
-        Il.TupE [
-          { it = Il.VarE arity; note = n1; _ };
-          { it = Il.VarE fid; note = n2; _ };
-          { it = Il.ListE [ le ]; _ };
-        ];
-        _;
-      }
-    ) ->
-      let exp1 = varE arity.it ~note:n1 in
-      let exp2 = varE fid.it ~note:n2 in
-      let exp3 = caseE ([[atom]], []) ~note:note in
-      let note' = listT note in
-    [
-      letI (varE "F" ~note:callframeT, frameE (Some (exp1), exp2) ~note:callframeT) ~at:at;
-      enterI (varE "F" ~note:callframeT, listE ([exp3]) ~note:note', translate_rhs le) ~at:at;
-    ]
-  | Il.CaseE (
-      [ { it = Atom "LABEL_"; _ } as atom ] :: _,
-      { it = Il.TupE [ arity; e1; e2 ]; _ }
-    ) ->
-    (
-    let at' = e2.at in
-    let note' = e2.note in
-    let exp' = labelE (translate_exp arity, translate_exp e1) ~at:at ~note:labelT in
-    let exp'' = listE ([caseE ([[atom]], []) ~note:note]) ~at:at' ~note:note' in
-    match e2.it with
-    | Il.CatE (ve, ie) ->
-      [
-        letI (varE "L" ~note:labelT, exp') ~at:at;
-        enterI (varE "L" ~note:labelT, catE (translate_exp ie, exp'') ~note:note', [pushI (translate_exp ve)]) ~at:at';
-      ]
-    | _ ->
-      [
-        letI (varE "L" ~note:labelT, exp') ~at:at;
-        enterI (varE "L" ~note:labelT, catE(translate_exp e2, exp'') ~note:note', []) ~at:at';
-      ]
-    )
+  | _ when is_context exp -> translate_context_rhs exp
   (* Config *)
   | _ when is_config exp ->
     let state, rhs = split_config exp in
     (match state.it with
     | Il.CallE (f, ae) ->
-      translate_rhs rhs @ [ performI (f.it, translate_args ae) ~at:state.at ]
+      let perform_instr       = performI (f.it, translate_args ae) ~at:state.at in
+      let push_or_exec_instrs = translate_rhs rhs in
+      (match Lib.List.last_opt push_or_exec_instrs with
+      | Some { it = ExecuteI _; _ } ->
+        [ perform_instr ] @ push_or_exec_instrs
+      | _ -> (* HARDCODE: TABLE.GROW *)
+        push_or_exec_instrs @ [ perform_instr ])
     | _ -> translate_rhs rhs
     )
   (* Recursive case *)
@@ -480,6 +468,7 @@ let rec translate_rhs exp =
       "REF.I31_NUM";
       "REF.STRUCT_ADDR";
       "REF.ARRAY_ADDR";
+      "REF.EXN_ADDR";
       "REF.FUNC_ADDR";
       "REF.HOST_ADDR";
       "REF.EXTERN";
@@ -494,6 +483,98 @@ let rec translate_rhs exp =
     [ executeI (translate_exp exp) ]
   | _ -> error_exp exp "expression on rhs of reduction"
 
+and translate_context_rhs exp =
+  let at = exp.at in
+  let note = exp.note in
+  let notes = listT note in
+
+  let case = case_of_case exp in
+  let atom = case |> List.hd |> List.hd in
+  let args = args_of_case exp in
+  let case' = case |> Lib.List.split_last |> fst in
+
+  match atom.it, args with
+  | Il.Atom "FRAME_", [exp1; exp2; exp3] ->
+    let e1 = translate_exp exp1 in (* arity *)
+    let e2 = translate_exp exp2 in (* frame *)
+    let e3 = translate_rhs exp3 in (* label *)
+
+    let eF = varE "F"             ~at:at ~note:callframeT in (* frame id *)
+    let ef = frameE (Some e1, e2) ~at:at ~note:callframeT in (* frame *)
+
+    let e' = caseE ([[atom]], []) ~note:note in
+    [
+      letI (eF, ef) ~at:at;
+      enterI (eF, listE [e'] ~note:notes, e3) ~at:at;
+    ]
+  | Il.Atom "LABEL_", [exp1; exp2; exp3] ->
+    let e1 = translate_exp exp1 in (* arity *)
+    let e2 = translate_exp exp2 in (* cont *)
+    let e3 = translate_exp exp3 in (* instrs *)
+
+    let eL = varE "L"        ~at:at ~note:labelT in (* label id *)
+    let el = labelE (e1, e2) ~at:at ~note:labelT in (* label *)
+
+    let at' = exp3.at in
+    let note' = exp3.note in
+    let exp'' = listE ([caseE ([[atom]], []) ~note:note]) ~at:at' ~note:note' in
+    (match exp3.it with
+    | Il.CatE (ve, ie) ->
+      [
+        letI (eL, el) ~at:at;
+        enterI (eL, catE (translate_exp ie, exp'') ~note:note', [pushI (translate_exp ve)]) ~at:at';
+      ]
+    | _ ->
+      [
+        letI (eL, el) ~at:at;
+        enterI (eL, catE(e3, exp'') ~note:note', []) ~at:at';
+      ]
+    )
+  | Il.Atom "HANDLER_", [exp1; exp2; exp3] ->
+    (match exp3.it with
+    | ListE [ctxt] when is_context ctxt ->
+      (* TODO: This case is very similar to Frame. Perhaps it can be generalized? *)
+      let e1 = translate_exp exp1 in (* arity *)
+      let e2 = translate_exp exp2 in (* catch *)
+      let e3 = translate_rhs exp3 in (* label *)
+
+      let eH = varE "H"                ~at:at ~note:handlerT in (* handler id *)
+      let eh = caseE (case', [e1; e2]) ~at:at ~note:handlerT in (* handler *)
+
+      let e' = caseE ([[atom]], []) ~note:note in
+      [
+        letI (eH, eh) ~at:at;
+        enterI (eH, listE [e'] ~note:notes, e3) ~at:at;
+      ]
+    | _ ->
+      (* TODO: This case is very similar to Label. Perhaps it can be generalized? *)
+      let e1 = translate_exp exp1 in (* arity *)
+      let e2 = translate_exp exp2 in (* catch *)
+      let e3 = translate_exp exp3 in (* instrs *)
+
+      let eH = varE "H"                ~at:at ~note:handlerT in (* handler id *)
+      let eh = caseE (case', [e1; e2]) ~at:at ~note:handlerT in (* handler *)
+
+      let at' = exp3.at in
+      let note' = exp3.note in
+      let exp' = caseE ([[atom]], []) ~note:note in
+      let exp'' = listE ([exp']) ~at:at' ~note:note' in
+
+      (match exp3.it with
+      | Il.ListE [ve; ie] -> (* HARDCODE *)
+        [
+          letI (eH, eh) ~at:at;
+          enterI (eH, listE [translate_exp ie; exp'] ~note:note', [pushI (translate_exp ve)]) ~at:at';
+        ]
+      | _ ->
+        [
+          letI (eH, eh) ~at:at;
+          enterI (eH, catE(e3, exp'') ~note:note', []) ~at:at';
+        ]
+      )
+    )
+  | _ -> error at ("unrecognized context: " ^ (Il.Print.string_of_atom atom))
+
 
 (* Handle pattern matching *)
 
@@ -565,12 +646,6 @@ and call_lhs_to_inverse_call_rhs lhs rhs free_ids =
   in
 
   (* Helper functions *)
-  let expr2arg e = ExpA e $ e.at in
-  let arg2expr a =
-    match a.it with
-    | ExpA e -> e
-    | TypA _ -> error a.at "Cannot translate to inverse function for type argument"
-  in
   let contains_free a =
     match a.it with
     | ExpA e -> contains_ids free_ids e
@@ -733,6 +808,15 @@ and handle_iter_lhs lhs rhs free_ids =
 and handle_special_lhs lhs rhs free_ids =
   let at = over_region [ lhs.at; rhs.at ] in
   match lhs.it with
+  (* Handle encoded premises generated by `encode.ml` *)
+  | _ when (Il.Print.string_of_typ rhs.note) = "inputT" -> []
+  | _ when (Il.Print.string_of_typ rhs.note) = "stateT" -> []
+  | _ when (Il.Print.string_of_typ rhs.note) = "unusedT" -> []
+  | _ when (Il.Print.string_of_typ rhs.note) = "contextT" -> []
+  | TupE [e; _stack] when (Il.Print.string_of_typ rhs.note) = "stackT" ->
+    let args = args_of_call rhs in
+    let pop_num = List.hd args |> arg2expr in
+    insert_pop e pop_num
   (* Handle inverse function call *)
   | CallE _ -> handle_call_lhs lhs rhs free_ids
   (* Handle iterator *)
@@ -839,16 +923,15 @@ and handle_special_lhs lhs rhs free_ids =
     ]
   | _ -> [letI (lhs, rhs) ~at:at]
 
-let translate_letpr lhs rhs free_ids =
+let translate_letpr lhs rhs ids =
   (* Translate *)
   let al_lhs, al_rhs = translate_exp lhs, translate_exp rhs in
-  let al_ids = List.map it free_ids in
 
   (* Handle partial bindings *)
-  let al_lhs', al_rhs', cond_instrs = handle_partial_bindings al_lhs al_rhs al_ids in
+  let al_lhs', al_rhs', cond_instrs = handle_partial_bindings al_lhs al_rhs ids in
 
   (* Construct binding instructions *)
-  let instrs = handle_special_lhs al_lhs' al_rhs' al_ids in
+  let instrs = handle_special_lhs al_lhs' al_rhs' ids in
 
   (* Insert conditions *)
   if List.length cond_instrs = 0 then instrs
@@ -1001,287 +1084,239 @@ let translate_helpers il =
 
   List.filter_map (translate_helper partial_funcs) il
 
+let rec add eq k v = function (* add a (k,v) to an assoc list *)
+  | [] -> [(k, [v])]
+  | (k', vs) :: tl ->
+    if eq k k' then
+      (k', vs @ [v]) :: tl
+    else
+      (k', vs) :: add eq k v tl
 
-let rec kind_of_context e =
-  match e.it with
-  | Il.CaseE ([{it = Il.Atom "FRAME_"; _} as atom]::_, _) -> atom
-  | Il.CaseE ([{it = Il.Atom "LABEL_"; _} as atom]::_, _) -> atom
-  | Il.CaseE ([[]; [{it = Il.Semicolon; _}]; []], e')
-  | Il.ListE [ e' ]
-  | Il.TupE [_ (* z *); e'] -> kind_of_context e'
-  | _ -> error e.at "cannot get a frame or label from lhs of the reduction rule"
-
-let in_same_context (lhs1, _, _) (lhs2, _, _) =
-  kind_of_context lhs1 = kind_of_context lhs2
-
-let group_contexts xs =
-  List.fold_left (fun acc x ->
-    let g1, g2 = List.partition (fun g -> in_same_context (List.hd g).it x.it) acc in
-    match g1 with
-    | [] -> [ x ] :: acc
-    | [ g ] -> (x :: g) :: g2
-    | _ -> failwith "group_contexts: duplicate groups"
-    ) [] xs |> List.rev
-
-let un_unify (lhs, rhs, prems) =
-  let new_lhs, new_prems = List.fold_left (fun (lhs, ps) p ->
-    match p.it with
-    | Il.LetPr (e1, ({ it = Il.VarE uvar; _} as u), _) when Il2il.is_unified_id uvar.it ->
-      let new_lhs = Il2il.transform_expr (fun e2 -> if Il.Eq.eq_exp e2 u then e1 else e2) lhs in
-      new_lhs, ps
-    | _ -> lhs, ps @ [ p ]
-  ) (lhs, []) prems in
-  new_lhs, rhs, new_prems
-
-let insert_deferred = function
-  | None -> Fun.id
-  | Some exp ->
-    (* Translate deferred lhs *)
-    let deferred_instrs = insert_pop exp in
-
-    (* Find unbound variable *)
-    let unbound_variable = get_unbound exp in
-
-    (* Insert the translated instructions right after the binding *)
-    let f instr =
-      match instr.it with
-      | LetI (lhs, _) when free_expr lhs |> IdSet.mem unbound_variable ->
-        instr :: deferred_instrs
-      | _ -> [ instr ] in
-
-    let walk_config = { Al.Walk.default_config with post_instr = f } in
-    Al.Walk.walk_instrs walk_config
+let extract_winstr r =
+  let (_, _, prems) = r.it in
+  match List.find_opt is_winstr_prem prems with
+  | Some p -> lhs_of_prem p (* TODO: Collect helper functions into one place *)
+  | None -> error r.at "Failed to extract the target wasm instruction"
+
+let extract_context r =
+  let (_, _, prems) = r.it in
+  List.find_opt is_ctxt_prem prems
+  |> Option.map lhs_of_prem (* TODO: Collect helper functions into one place *)
+
+let group_by_context rs =
+  let eq_context = Option.equal (fun c1 c2 -> Il.Mixop.eq (case_of_case c1) (case_of_case c2)) in
+  List.fold_left (fun acc r -> acc |> add eq_context (extract_context r) r) [] rs
+
+let exit_context context_opt instrs =
+  match context_opt with
+  | None -> instrs
+  | Some instr -> instr :: instrs
 
 (* `reduction` -> `instr list` *)
-let translate_reduction deferred reduction =
+let translate_reduction ?(context_opt=None) reduction =
   let _, rhs, prems = reduction.it in
 
   (* Translate rhs *)
   translate_rhs rhs
-  |> insert_nop
+  (* Exit context *)
+  |> exit_context context_opt
+  |> Transpile.insert_nop
   (* Translate premises *)
   |> translate_prems prems
-  (* Translate and insert deferred pop instructions *)
-  |> insert_deferred deferred
 
 
-let insert_pop_winstr vars es = match es with
-  | [] -> [], None
-  | _ ->
-    (* ASSUMPTION: The deferred pop is only possible at the bottom of the stack *)
-    let (hs, t) = Util.Lib.List.split_last es in
-    if is_unbound vars t then
-      List.concat_map insert_pop hs, Some t
-    else
-      List.concat_map insert_pop es, None
-
 let translate_context_winstr winstr =
+  if not (is_context winstr) then [] else
+
   let at = winstr.at in
-  match winstr.it with
+  let kind = case_of_case winstr |> List.hd |> List.hd in
+  let args = args_of_case winstr in
+
+  match kind.it with
   (* Frame *)
-  | Il.CaseE ([{it = Il.Atom "FRAME_"; _} as atom]::_, args) ->
-    (match args.it with
-    | Il.TupE [arity; name; inner_exp] ->
+  | Il.Atom "FRAME_" ->
+    (match args with
+    | [arity; name; inner_exp] ->
       [
         letI (translate_exp name, getCurFrameE () ~note:name.note) ~at:at;
         letI (translate_exp arity, arityE (translate_exp name) ~note:arity.note) ~at:at;
         insert_assert inner_exp;
       ]
-      @ insert_pop (inner_exp) @
+      @ insert_pop' (inner_exp) @
       [
         insert_assert winstr;
-        exitI atom ~at:at
+        exitI kind ~at:at
       ]
-    | _ -> error_exp args "argument of frame"
+    | _ -> error_exp winstr "wrong argument of frame"
     )
-  (* Label *)
-  | Il.CaseE ([{it = Il.Atom "LABEL_"; _} as atom]::_, { it = Il.TupE [ _n; _instrs; vals ]; _ }) ->
+  (* Label, Handler *)
+  | _ ->
+    (* ASSUMPTION: the last arg is the inner stack of this context *)
+    let vals = Lib.List.last args in
     [
       (* TODO: append Jump instr *)
-      popallI ({ (translate_exp vals) with note=(listT valT)}) ~at:at;
+      popallI ({ (translate_exp vals) with note=(listT valT)}) ~at:vals.at;
       insert_assert winstr;
-      exitI atom ~at:at
+      exitI kind ~at:at
     ]
-  | _ -> []
 
-let translate_context ctx vs =
+let translate_context ctx =
   let at = ctx.at in
-  let ty = listT valT in
-  let e_vals = iterE (subE ("val", valT) ~note:valT, [ "val" ], List) ~note:ty in
-  let vs = List.rev vs in
-  let instr_popall = popallI e_vals in
-  let instr_pop_context =
-    match ctx.it with
-    | Il.CaseE ([{it = Il.Atom "LABEL_"; at=at'; _} as atom]::_, { it = Il.TupE [ n; instrs; _hole ]; _ }) ->
-      let label = VarE "L" $$ at' % labelT in
-      [
-        letI (label, getCurLabelE () ~note:labelT) ~at:at;
-        letI (translate_exp n, arityE label ~note:n.note) ~at:at;
-        letI (translate_exp instrs, contE label ~note:instrs.note) ~at:at;
-        exitI atom ~at:at
-      ]
-    | Il.CaseE ([{it = Il.Atom "FRAME_"; _} as atom]::_, { it = Il.TupE [ n; f; _hole ]; _ }) ->
-      let frame = translate_exp f in
-      [
-        letI (frame, getCurFrameE () ~note:frameT) ~at:at;
-        letI (translate_exp n, arityE frame ~note:n.note) ~at:at;
-        exitI atom ~at:at
-      ]
-    | _ -> [ yetI "TODO: translate_context" ~at:at ]
+
+  match ctx.it with
+  | Il.CaseE ([{it = Il.Atom "LABEL_"; at=at'; _} as atom]::_, { it = Il.TupE [ n; instrs ]; _ }) ->
+    let label = VarE "L" $$ at' % labelT in
+    [
+      letI (label, getCurLabelE () ~note:labelT) ~at:at;
+      letI (translate_exp n, arityE label ~note:n.note) ~at:at;
+      letI (translate_exp instrs, contE label ~note:instrs.note) ~at:at;
+    ],
+    exitI atom ~at:at
+  | Il.CaseE ([{it = Il.Atom "FRAME_"; _} as atom]::_, { it = Il.TupE [ n; f ]; _ }) ->
+    let frame = translate_exp f in
+    [
+      letI (frame, getCurFrameE () ~note:frameT) ~at:at;
+      letI (translate_exp n, arityE frame ~note:n.note) ~at:at;
+    ],
+    exitI atom ~at:at
+  | Il.CaseE ([atom]::_, _) ->
+    [
+      letI (translate_exp ctx, getCurContextE () ~note:ctx.note) ~at:at;
+    ],
+    exitI atom ~at:at
+  | _ -> [ yetI "TODO: translate_context" ~at:at ], yetI "TODO: translate_context"
+
+let extract_pops rgroup =
+  (* Helpers *)
+  let rec extract_pops' acc prems premss =
+    match prems with
+    | hd :: tl when is_pop hd ->
+      let partitions = List.map (List.partition (Il.Eq.eq_prem hd)) premss in
+      let fsts = List.map fst partitions in
+      let snds = List.map snd partitions in
+
+      if List.for_all (fun l -> List.length l = 1) fsts then
+        extract_pops' (hd :: acc) tl snds
+      else
+        List.rev acc, prems :: premss
+    | _ -> List.rev acc, prems :: premss
   in
-  let instr_let =
-    match vs with
-    | v1 :: v2 :: vs ->
-        let e1 = translate_exp v1 in
-        let e2 = translate_exp v2 in
-        let e_vs = catE (e1, e2) ~note:e1.note in
-        let e =
-          List.fold_left
-            (fun e_vs v -> catE (e_vs, translate_exp v) ~note:e_vs.note)
-            e_vs vs
-        in
-        [ letI (e, e_vals) ~at:at ]
-    | v :: [] ->
-        let e = translate_exp v in
-        if Eq.eq_expr e e_vals then []
-        else [ letI (e, e_vals) ~at:at ]
-    | _ -> []
+
+  let get_prems r =
+    let (_, _, prems) = r.it in
+    prems
   in
-  instr_popall :: instr_pop_context @ instr_let
-
-let translate_context_rgroup lhss sub_algos inner_params =
-  let ty = listT valT in
-  let e_vals = iterE (varE "val" ~note:valT, [ "val" ], List) ~note:ty in
-  let instr_popall = popallI e_vals in
-  let instrs_context =
-    List.fold_right2 (fun lhs algo acc ->
-      match algo.it with
-      | RuleA (_, _, params, body) ->
-        (* Assume that each sub-algorithms are produced by translate_context,
-           i.e., they will always contain instr_popall as their first instruction. *)
-        assert(Eq.eq_instr (List.hd body) instr_popall);
-        if Option.is_none !inner_params then inner_params := Some params;
-        let e_cond =
-          match it (kind_of_context lhs) with
-          | Il.Atom.Atom "FRAME_" -> topFrameE () ~note:boolT
-          | Il.Atom.Atom "LABEL_" -> topLabelE () ~note:boolT
-          | _ -> error lhs.at "the context is neither a frame nor a label"
-        in
-        [ ifI (e_cond, List.tl body, acc) ]
-      | _ -> assert false)
-    lhss sub_algos []
+  let set_prems r prems =
+    let (lhs, rhs, _) = r.it in
+    { r with it = (lhs, rhs, prems) }
   in
-  instr_popall :: instrs_context
-
-let rec split_lhs_stack' ?(note : Il.typ option) name stack ctxs instrs =
-  let target = upper name in
-  match stack with
-  | [] ->
-    let typ = Option.get note in
-    let tag = [[Il.Atom target $$ typ.at % Il.Atom.info "instr"]] in
-    let winstr = Il.CaseE (tag, Il.TupE [] |> wrap topT) |> wrap typ in
-    ctxs @ [ ([], instrs), None ], winstr
-  | hd :: tl ->
-    match hd.it with
-    | Il.ListE [hd'] ->
-      (match hd'.it with
-      (* Top of the stack is the target instruction *)
-      | Il.CaseE (({it = Il.Atom name'; _}::_)::_, _) when name' = target || name' = target ^ "_"
-        -> ctxs @ [ (tl, instrs), None ], hd'
-      (* Top of the stack is a context (label, frame, ...) *)
-      | Il.CaseE (tag, ({it = Il.TupE args; _} as e)) ->
-        let list_arg = List.find is_list args in
-        let inner_stack = to_exp_list list_arg in
-        let holed_args = List.map (fun x -> if x = list_arg then hole else x) args in
-        let ctx = { hd' with it = Il.CaseE (tag, { e with it = Il.TupE holed_args }) } in
-
-        split_lhs_stack' name inner_stack (ctxs @ [ ((tl, instrs), Some ctx) ]) []
-      (* Should be unreachable? *)
-      | _ ->
-        split_lhs_stack' ~note:(hd.note) name tl ctxs (hd :: instrs))
-    | _ ->
-      split_lhs_stack' ~note:(hd.note) name tl ctxs (hd :: instrs)
+  (* End of helpers *)
 
-let split_lhs_stack name stack = split_lhs_stack' name stack [] []
+  let hd = List.hd rgroup in
+  let tl = List.tl rgroup in
 
+  let extracted, new_premss = extract_pops' [] (get_prems hd) (List.map get_prems tl) in
+  extracted, List.map2 set_prems rgroup new_premss
 
-let rec translate_rgroup' context winstr instr_name rel_id rgroup =
-  let inner_params = ref None in
-  let instrs =
-    match context with
-    | [ (vs, []), None ] ->
-      let pop_instrs, defer_opt = vs |> insert_pop_winstr (Il.Free.free_exp winstr) in
-      let inner_pop_instrs = translate_context_winstr winstr in
 
-      let instrs' =
-        match rgroup |> Util.Lib.List.split_last with
-        (* Either case: No premise for the last reduction rule *)
-        | hds, { it = (_, rhs, []); _ } when List.length hds > 0 ->
-          assert (defer_opt = None);
-          let blocks = List.map (translate_reduction None) hds in
-          let body1 = Transpile.merge_blocks blocks in
-          let body2 = translate_rhs rhs |> insert_nop in
-          eitherI (body1, body2) |> Transpile.push_either
-        (* Normal case *)
-        | _ ->
-          let blocks = List.map (translate_reduction defer_opt) rgroup in
-          Transpile.merge_blocks blocks
+let rec translate_rgroup' rgroup =
+  let pops, rgroup' = extract_pops rgroup in
+  let subgroups = group_by_context rgroup' in
+
+  let blocks = List.map (fun (k, subgroup) ->
+    match k with
+    (* Normal case *)
+    | None ->
+      let winstr = extract_winstr (List.hd subgroup) in
+      let inner_pop_instrs = translate_context_winstr winstr in
+      let blocks = List.map translate_reduction subgroup in
+      let instrs =
+        match blocks with
+        | [b1; b2] when not (has_branch b1 || has_branch b2) -> [ eitherI (b1, b2) ] (* Either case *)
+        | _ -> Transpile.merge_blocks blocks
       in
+      k, inner_pop_instrs @ instrs
+    (* Context case *)
+    | Some _ ->
+      let popped_vars = List.concat_map (fun p ->
+        match p.it with
+        | Il.LetPr (_, _, ids) -> ids
+        | _ -> assert false
+      ) pops in
+      let u_group = Il2il.unify_ctxt popped_vars subgroup in
+      let ctxt = extract_context (List.hd u_group) |> Option.get in
+      let atom = case_of_case ctxt |> List.hd |> List.hd in
+      let cond = ContextKindE atom $$ atom.at % boolT in
+      let head_instrs, middle_instr = translate_context ctxt in
+      let is_otherwise = function [{it = OtherwiseI _; _}] -> true | _ -> false in
+      let body_instrs =
+        List.map (translate_reduction ~context_opt:(Some middle_instr)) u_group
+        (* TODO: Consider inserting otherwise to normal case also *)
+        |> List.mapi (fun i instrs -> if i = 0 || is_otherwise instrs then instrs else [otherwiseI instrs])
+        |> Transpile.merge_blocks in
+      k, [
+        ifI (
+          cond,
+          head_instrs @ body_instrs,
+          []
+        )
+      ]
+  ) subgroups in
 
-      pop_instrs @ inner_pop_instrs @ instrs'
-    (* The target instruction is inside a context *)
-    | [ ([], []), Some context ; (vs, _is), None ] ->
-      let head_instrs = translate_context context vs in
-      let body_instrs = List.map (translate_reduction None) rgroup |> List.concat in
-      head_instrs @ body_instrs
-    (* The target instruction is inside different contexts (i.e. return in both label and frame) *)
-    | [ ([], [ _ ]), None ] ->
-      (try
-      let unified_sub_groups =
-        rgroup
-        |> List.map (Source.map un_unify)
-        |> group_contexts
-        |> List.map (fun g -> Il2il.unify_lhs (instr_name, rel_id, g)) in
-      if List.length unified_sub_groups = 1 then [ yetI "Translation fail: Infinite recursion" ] else
-      let lhss = List.map (fun (_, _, g) -> lhs_of_rgroup g) unified_sub_groups in
-      let sub_algos = List.map translate_rgroup unified_sub_groups in
-      translate_context_rgroup lhss sub_algos inner_params
-      with _ ->
-        [ yetI "TODO: It is likely that the value stack of two rules are different" ])
-    | _ -> [ yetI "TODO: translate_rgroup" ] in
-  !inner_params, instrs
+  let normal_block_opt, ctxt_blocks =
+    match List.hd blocks with
+    | (Some _, _) -> None, blocks
+    | (None, b) -> Some b, List.tl blocks
+  in
 
+  let ctxt_block = match ctxt_blocks with
+  | [] -> []
+  | _ ->
+    let valTs = listT valT in
+    let e_vals = iterE (subE ("val", valT) ~note:valT, [ "val" ], List) ~note:valTs in
+    let instr_popall = popallI e_vals in
+    let instr_push = pushI e_vals in
+
+    instr_popall ::
+    List.fold_right (fun instrs acc ->
+      assert (List.length instrs = 1);
+      let if_instr = List.hd instrs in
+      match if_instr.it with
+      | IfI (c, instrs1, []) -> [{if_instr with it = IfI (c, instr_push :: instrs1, acc)}]
+      | _ -> assert false
+    ) (List.map snd ctxt_blocks) []
+  in
 
-(* Main translation for reduction rules
- * `rgroup` -> `Backend-prose.Algo` *)
+  let body_instrs =
+    match normal_block_opt, ctxt_block with
+    | None, b -> b
+    | Some b1, b2 ->
+      (* Assert: b1 must have the else-less IfI as inner most instruction *)
+      insert_instrs_to_else b2 b1
+  in
 
-and get_lhs_stack (exp: Il.exp): Il.exp list =
-  if is_config exp then
-    split_config exp |> snd |> to_exp_list
-  else to_exp_list exp
+  translate_prems pops body_instrs
+
+(* Main translation for reduction rules
+ * `rgroup` -> `Al.Algo` *)
 
 and translate_rgroup (instr_name, rel_id, rgroup) =
-  let lhs, _, _ = (List.hd rgroup).it in
-  (* TODO: Generalize getting current frame *)
-  let lhs_stack = get_lhs_stack lhs in
-  let context, winstr = split_lhs_stack instr_name lhs_stack in
+  let unified_rgroup = Il2il.unify_pop_and_winstr rgroup in
 
-  let inner_params, instrs = translate_rgroup' context winstr instr_name rel_id rgroup in
+  let winstr = extract_winstr (List.hd unified_rgroup) in
+  let instrs = translate_rgroup' unified_rgroup in
 
   let name =
-    match winstr.it with
-    | Il.CaseE ((({it = Il.Atom _; _} as atom)::_)::_, _) -> atom
+    match case_of_case winstr with
+    | (atom :: _) :: _ -> atom
     | _ -> assert false
   in
   let anchor = rel_id.it ^ "/" ^ instr_name in
   let al_params =
-    match inner_params with
-    | None ->
-      if instr_name = "frame" || instr_name = "label" then [] else
-      get_params winstr
-      |> List.map translate_exp
-      |> List.map (fun e -> ExpA e $ e.at)
-    | Some params -> params
+    if List.mem instr_name ["frame"; "label"; "handler"] then [] else
+    args_of_case winstr
+    |> List.map translate_exp
+    |> List.map (fun e -> ExpA e $ e.at)
   in
   (* TODO: refactor transpiles *)
   let al_params' =
@@ -1292,7 +1327,7 @@ and translate_rgroup (instr_name, rel_id, rgroup) =
   let body =
     instrs
     |> Transpile.insert_frame_binding
-    |> insert_nop
+    |> Transpile.insert_nop
     |> Walk.(walk_instrs { default_config with pre_expr = Transpile.remove_sub })
     |> Transpile.enhance_readability
     |> Transpile.infer_assert
@@ -1323,8 +1358,7 @@ let rec group_rules = function
       List.partition (fun (_, rule) -> name_of_rule rule = name) t in
     let rules = rule :: List.map (fun (rel_id', rule') ->
       if rel_id = rel_id' then rule' else
-        Util.Error.error rule'.at
-        "prose transformation"
+        error rule'.at
         "this reduction rule uses a different relation compared to the previous rules"
     ) t1 in
     let tups = List.map rule_to_tup rules in
@@ -1335,10 +1369,11 @@ let extract_rules def =
   match def.it with
   | Il.RelD (id, _, _, rules) when List.mem id.it [ "Step"; "Step_read"; "Step_pure" ] ->
     List.filter_map (fun rule ->
-      match rule.it with
-      | Il.RuleD (id', _, _, _, _) when List.mem id'.it [ "pure"; "read" ] ->
+      (* HARDCODE: Exclude administrative rules *)
+      if List.mem (name_of_rule rule) ["pure"; "read"; "trap"; "ctxt"] then
         None
-      | _ -> Some (id, rule)
+      else
+        Some (id, rule)
     ) rules
   | _ -> []
 
@@ -1349,8 +1384,6 @@ let translate_rules il =
   |> List.concat_map extract_rules
   (* Group rules that have the same names *)
   |> group_rules
-  (* Unify lhs *)
-  |> List.map Il2il.unify_lhs
   (* Translate reduction group into algorithm *)
   |> List.map translate_rgroup
 
@@ -1383,6 +1416,7 @@ let translate il =
   let il' =
     il
     |> Preprocess.preprocess
+    |> Encode.transform
     |> List.concat_map flatten_rec
     |> List.filter is_al_target
     |> Animate.transform
diff --git a/spectec/src/il2al/translate.mli b/spectec/src/il2al/translate.mli
index a4ce508001..67f76c9e10 100644
--- a/spectec/src/il2al/translate.mli
+++ b/spectec/src/il2al/translate.mli
@@ -1,5 +1,4 @@
 val name_of_rule : Il.Ast.rule -> string
-val get_params : Il.Ast.exp -> Il.Ast.exp list
 val translate_exp : Il.Ast.exp -> Al.Ast.expr
 val translate_argexp : Il.Ast.exp -> Al.Ast.expr list
 val translate : Il.Ast.script -> Al.Ast.algorithm list
diff --git a/spectec/src/il2al/transpile.ml b/spectec/src/il2al/transpile.ml
index 3b6a0e1e8b..4992906f2c 100644
--- a/spectec/src/il2al/transpile.ml
+++ b/spectec/src/il2al/transpile.ml
@@ -99,6 +99,9 @@ let unify_tail l1 l2 =
 
 (* AL -> AL transpilers *)
 
+(* Explictly insert nop into empty instr list to prevent the optimization *)
+let insert_nop instrs = match instrs with [] -> [ nopI () ] | _ -> instrs
+
 (* Recursively append else block to every empty if *)
 let rec insert_otherwise else_body instrs =
   let walk = insert_otherwise else_body in
@@ -200,6 +203,7 @@ let swap_if instr =
   match instr.it with
   | IfI (c, il, []) -> ifI (c, il, []) ~at:at
   | IfI (c, [], il) -> ifI (neg c, il, []) ~at:at
+  | IfI (_, _, il2) when (match il2 with | [{it = IfI _; _}] -> true | _ -> false) -> instr
   | IfI (c, il1, il2) when count_instrs il1 > count_instrs il2 -> ifI (neg c, il2, il1) ~at:at
   | _ -> instr
 
@@ -216,13 +220,31 @@ let early_return instr =
   | IfI (c, il1, il2) when return_at_last il1 -> ifI (c, il1, []) ~at:at :: il2
   | _ -> [ instr ]
 
+(* If c then (A; B) else (A; C) --> A; If c then B else C *)
+let unify_if_head instr =
+  let at = instr.at in
+  match instr.it with
+  | IfI (_, [], []) -> []
+  | IfI (_, _, [])
+  | IfI (_, [], _) -> [ instr ]
+  | IfI (c, il1, il2) ->
+    let h, il1', il2' = unify_head il1 il2 in
+    h @ [ ifI (c, insert_nop il1', insert_nop il2') ~at:at ]
+  | EitherI (il1, il2) ->
+    let h, il1', il2' = unify_head il1 il2 in
+    h @ [ eitherI (insert_nop il1', insert_nop il2') ~at:at ]
+  | _ -> [ instr ]
+
+(* If c then (A; C) else (B; C) --> If c then A else B; C *)
 let unify_if_tail instr =
   let at = instr.at in
   match instr.it with
   | IfI (_, [], []) -> []
+  | IfI (_, _, [])
+  | IfI (_, [], _) -> [ instr ]
   | IfI (c, il1, il2) ->
     let t, il1', il2' = unify_tail il1 il2 in
-    ifI (c, il1', il2') ~at:at :: t
+    ifI (c, insert_nop il1', insert_nop il2') ~at:at :: t
   | _ -> [ instr ]
 
 let remove_unnecessary_branch =
@@ -409,7 +431,7 @@ let rec enhance_readability instrs =
       Walk.default_config with
       pre_expr = simplify_record_concat |> composite if_not_defined;
       post_instr =
-        unify_if_tail @@ (lift swap_if) @@ early_return @@ (lift merge_three_branches);
+        unify_if_head @@ unify_if_tail @@ (lift swap_if) @@ early_return @@ (lift merge_three_branches);
     } in
 
   let instrs' =
diff --git a/spectec/src/il2al/transpile.mli b/spectec/src/il2al/transpile.mli
index 181dce71dd..57d49ba6f6 100644
--- a/spectec/src/il2al/transpile.mli
+++ b/spectec/src/il2al/transpile.mli
@@ -1,5 +1,6 @@
 open Al.Ast
 
+val insert_nop : instr list -> instr list
 val merge_blocks : instr list list -> instr list
 val push_either :instr -> instr list
 val simplify_record_concat : expr -> expr
diff --git a/spectec/src/util/lib.ml b/spectec/src/util/lib.ml
index f5a33fde59..d9d15d067b 100644
--- a/spectec/src/util/lib.ml
+++ b/spectec/src/util/lib.ml
@@ -41,6 +41,7 @@ struct
 
   let filter_not pred = List.filter (fun x -> not (pred x))
 
+  let assoc_map f = List.map (fun (k, v) -> (k, f v))
 end
 
 module Char =
diff --git a/spectec/src/util/lib.mli b/spectec/src/util/lib.mli
index bd319b4414..e034e56b21 100644
--- a/spectec/src/util/lib.mli
+++ b/spectec/src/util/lib.mli
@@ -12,6 +12,7 @@ sig
   val last : 'a list -> 'a (* raises Failure *)
   val nub : ('a -> 'a -> bool) -> 'a list -> 'a list
   val filter_not : ('a -> bool) -> 'a list -> 'a list
+  val assoc_map : ('a -> 'b) -> ('k * 'a) list -> ('k * 'b) list
 end
 
 module Char :
diff --git a/spectec/test-frontend/TEST.md b/spectec/test-frontend/TEST.md
index b3033e5a30..a8cd922ca9 100644
--- a/spectec/test-frontend/TEST.md
+++ b/spectec/test-frontend/TEST.md
@@ -339,6 +339,9 @@ syntax tableidx = idx
 ;; 1-syntax.watsup
 syntax memidx = idx
 
+;; 1-syntax.watsup
+syntax tagidx = idx
+
 ;; 1-syntax.watsup
 syntax elemidx = idx
 
@@ -395,6 +398,8 @@ syntax absheaptype =
   | NONE
   | FUNC
   | NOFUNC
+  | EXN
+  | NOEXN
   | EXTERN
   | NOEXTERN
   | BOT
@@ -410,13 +415,13 @@ syntax fin =
 ;; 1-syntax.watsup
 rec {
 
-;; 1-syntax.watsup:153.1-154.26
+;; 1-syntax.watsup:155.1-156.26
 syntax typeuse =
   | _IDX{typeidx : typeidx}(typeidx : typeidx)
   | DEF{rectype : rectype, n : n}(rectype : rectype, n : n)
   | REC{n : n}(n : n)
 
-;; 1-syntax.watsup:156.1-157.26
+;; 1-syntax.watsup:158.1-159.26
 syntax heaptype =
   | ANY
   | EQ
@@ -426,6 +431,8 @@ syntax heaptype =
   | NONE
   | FUNC
   | NOFUNC
+  | EXN
+  | NOEXN
   | EXTERN
   | NOEXTERN
   | BOT
@@ -433,7 +440,7 @@ syntax heaptype =
   | REC{n : n}(n : n)
   | DEF{rectype : rectype, n : n}(rectype : rectype, n : n)
 
-;; 1-syntax.watsup:164.1-165.14
+;; 1-syntax.watsup:166.1-167.14
 syntax valtype =
   | I32
   | I64
@@ -443,10 +450,10 @@ syntax valtype =
   | REF{nul : nul, heaptype : heaptype}(nul : nul, heaptype : heaptype)
   | BOT
 
-;; 1-syntax.watsup:194.1-195.16
+;; 1-syntax.watsup:196.1-197.16
 syntax resulttype = list(syntax valtype)
 
-;; 1-syntax.watsup:202.1-202.66
+;; 1-syntax.watsup:204.1-204.66
 syntax storagetype =
   | BOT
   | I32
@@ -458,31 +465,31 @@ syntax storagetype =
   | I8
   | I16
 
-;; 1-syntax.watsup:218.1-218.60
+;; 1-syntax.watsup:220.1-220.60
 syntax fieldtype =
   | `%%`{mut : mut, storagetype : storagetype}(mut : mut, storagetype : storagetype)
 
-;; 1-syntax.watsup:220.1-220.90
+;; 1-syntax.watsup:222.1-222.90
 syntax functype =
   | `%->%`{resulttype : resulttype}(resulttype : resulttype, resulttype)
 
-;; 1-syntax.watsup:221.1-221.64
+;; 1-syntax.watsup:223.1-223.64
 syntax structtype = list(syntax fieldtype)
 
-;; 1-syntax.watsup:222.1-222.54
+;; 1-syntax.watsup:224.1-224.54
 syntax arraytype = fieldtype
 
-;; 1-syntax.watsup:224.1-227.18
+;; 1-syntax.watsup:226.1-229.18
 syntax comptype =
   | STRUCT{structtype : structtype}(structtype : structtype)
   | ARRAY{arraytype : arraytype}(arraytype : arraytype)
   | FUNC{functype : functype}(functype : functype)
 
-;; 1-syntax.watsup:229.1-230.30
+;; 1-syntax.watsup:231.1-232.30
 syntax subtype =
   | SUB{fin : fin, typeuse* : typeuse*, comptype : comptype}(fin : fin, typeuse*{typeuse : typeuse} : typeuse*, comptype : comptype)
 
-;; 1-syntax.watsup:232.1-233.22
+;; 1-syntax.watsup:234.1-235.22
 syntax rectype =
   | REC{list : list(syntax subtype)}(list : list(syntax subtype))
 }
@@ -626,6 +633,9 @@ syntax tabletype =
 syntax memtype =
   | `%PAGE`{limits : limits}(limits : limits)
 
+;; 1-syntax.watsup
+syntax tagtype = deftype
+
 ;; 1-syntax.watsup
 syntax elemtype = reftype
 
@@ -639,6 +649,7 @@ syntax externtype =
   | GLOBAL{globaltype : globaltype}(globaltype : globaltype)
   | TABLE{tabletype : tabletype}(tabletype : tabletype)
   | MEM{memtype : memtype}(memtype : memtype)
+  | TAG{typeuse : typeuse}(typeuse : typeuse)
 
 ;; 1-syntax.watsup
 syntax moduletype =
@@ -1128,6 +1139,9 @@ syntax addr = nat
 ;; 4-runtime.watsup
 syntax arrayaddr = addr
 
+;; 4-runtime.watsup
+syntax exnaddr = addr
+
 ;; 4-runtime.watsup
 syntax funcaddr = addr
 
@@ -1140,16 +1154,24 @@ syntax structaddr = addr
 ;; 4-runtime.watsup
 rec {
 
-;; 4-runtime.watsup:37.1-43.23
+;; 4-runtime.watsup:35.1-42.23
 syntax addrref =
   | REF.I31_NUM{u31 : u31}(u31 : u31)
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
 }
 
+;; 1-syntax.watsup
+syntax catch =
+  | CATCH{tagidx : tagidx, labelidx : labelidx}(tagidx : tagidx, labelidx : labelidx)
+  | CATCH_REF{tagidx : tagidx, labelidx : labelidx}(tagidx : tagidx, labelidx : labelidx)
+  | CATCH_ALL{labelidx : labelidx}(labelidx : labelidx)
+  | CATCH_ALL_REF{labelidx : labelidx}(labelidx : labelidx)
+
 ;; 4-runtime.watsup
 syntax dataaddr = addr
 
@@ -1166,17 +1188,21 @@ syntax memaddr = addr
 syntax tableaddr = addr
 
 ;; 4-runtime.watsup
-syntax externval =
+syntax tagaddr = addr
+
+;; 4-runtime.watsup
+syntax externaddr =
   | FUNC{funcaddr : funcaddr}(funcaddr : funcaddr)
   | GLOBAL{globaladdr : globaladdr}(globaladdr : globaladdr)
   | TABLE{tableaddr : tableaddr}(tableaddr : tableaddr)
   | MEM{memaddr : memaddr}(memaddr : memaddr)
+  | TAG{tagaddr : tagaddr}(tagaddr : tagaddr)
 
 ;; 4-runtime.watsup
 syntax exportinst =
 {
   NAME{name : name} name,
-  VALUE{externval : externval} externval
+  ADDR{externaddr : externaddr} externaddr
 }
 
 ;; 4-runtime.watsup
@@ -1187,6 +1213,7 @@ syntax moduleinst =
   GLOBALS{globaladdr* : globaladdr*} globaladdr*,
   TABLES{tableaddr* : tableaddr*} tableaddr*,
   MEMS{memaddr* : memaddr*} memaddr*,
+  TAGS{tagaddr* : tagaddr*} tagaddr*,
   ELEMS{elemaddr* : elemaddr*} elemaddr*,
   DATAS{dataaddr* : dataaddr*} dataaddr*,
   EXPORTS{exportinst* : exportinst*} exportinst*
@@ -1201,6 +1228,7 @@ syntax val =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
 
@@ -1214,7 +1242,7 @@ syntax frame =
 ;; 4-runtime.watsup
 rec {
 
-;; 4-runtime.watsup:151.1-156.9
+;; 4-runtime.watsup:151.1-157.9
 syntax instr =
   | NOP
   | UNREACHABLE
@@ -1237,6 +1265,9 @@ syntax instr =
   | RETURN_CALL{funcidx : funcidx}(funcidx : funcidx)
   | RETURN_CALL_REF{typeuse : typeuse}(typeuse : typeuse)
   | RETURN_CALL_INDIRECT{tableidx : tableidx, typeuse : typeuse}(tableidx : tableidx, typeuse : typeuse)
+  | THROW{tagidx : tagidx}(tagidx : tagidx)
+  | THROW_REF
+  | TRY_TABLE{blocktype : blocktype, list : list(syntax catch), instr* : instr*}(blocktype : blocktype, list : list(syntax catch), instr*{instr : instr} : instr*)
   | CONST{numtype : numtype, num_ : num_(numtype)}(numtype : numtype, num_ : num_(numtype))
   | UNOP{numtype : numtype, unop_ : unop_(numtype)}(numtype : numtype, unop_ : unop_(numtype))
   | BINOP{numtype : numtype, binop_ : binop_(numtype)}(numtype : numtype, binop_ : binop_(numtype))
@@ -1324,10 +1355,12 @@ syntax instr =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | `LABEL_%{%}%`{n : n, instr* : instr*}(n : n, instr*{instr : instr} : instr*, instr*)
   | `FRAME_%{%}%`{n : n, frame : frame, instr* : instr*}(n : n, frame : frame, instr*{instr : instr} : instr*)
+  | `HANDLER_%{%}%`{n : n, catch* : catch*, instr* : instr*}(n : n, catch*{catch : catch} : catch*, instr*{instr : instr} : instr*)
   | TRAP
 }
 
@@ -1369,6 +1402,10 @@ syntax table =
 syntax mem =
   | MEMORY{memtype : memtype}(memtype : memtype)
 
+;; 1-syntax.watsup
+syntax tag =
+  | TAG{typeidx : typeidx}(typeidx : typeidx)
+
 ;; 1-syntax.watsup
 syntax elem =
   | ELEM{reftype : reftype, expr* : expr*, elemmode : elemmode}(reftype : reftype, expr*{expr : expr} : expr*, elemmode : elemmode)
@@ -1387,6 +1424,7 @@ syntax externidx =
   | GLOBAL{globalidx : globalidx}(globalidx : globalidx)
   | TABLE{tableidx : tableidx}(tableidx : tableidx)
   | MEM{memidx : memidx}(memidx : memidx)
+  | TAG{tagidx : tagidx}(tagidx : tagidx)
 
 ;; 1-syntax.watsup
 syntax export =
@@ -1398,7 +1436,7 @@ syntax import =
 
 ;; 1-syntax.watsup
 syntax module =
-  | MODULE{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*}(type*{type : type} : type*, import*{import : import} : import*, func*{func : func} : func*, global*{global : global} : global*, table*{table : table} : table*, mem*{mem : mem} : mem*, elem*{elem : elem} : elem*, data*{data : data} : data*, start?{start : start} : start?, export*{export : export} : export*)
+  | MODULE{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*}(type*{type : type} : type*, import*{import : import} : import*, func*{func : func} : func*, global*{global : global} : global*, table*{table : table} : table*, mem*{mem : mem} : mem*, tag*{tag : tag} : tag*, elem*{elem : elem} : elem*, data*{data : data} : data*, start?{start : start} : start?, export*{export : export} : export*)
 
 ;; 2-syntax-aux.watsup
 def $IN(N : N) : Inn
@@ -2022,6 +2060,11 @@ def $free_mem(mem : mem) : free
   ;; 2-syntax-aux.watsup
   def $free_mem{memtype : memtype}(MEMORY_mem(memtype)) = $free_memtype(memtype)
 
+;; 2-syntax-aux.watsup
+def $free_tag(tag : tag) : free
+  ;; 2-syntax-aux.watsup
+  def $free_tag{typeidx : typeidx}(TAG_tag(typeidx)) = $free_typeidx(typeidx)
+
 ;; 2-syntax-aux.watsup
 def $free_elemmode(elemmode : elemmode) : free
   ;; 2-syntax-aux.watsup
@@ -2066,7 +2109,7 @@ def $free_import(import : import) : free
 ;; 2-syntax-aux.watsup
 def $free_module(module : module) : free
   ;; 2-syntax-aux.watsup
-  def $free_module{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*}(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})) = $free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})
+  def $free_module{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*}(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})) = $free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_tag(tag)*{tag : tag}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})
 
 ;; 2-syntax-aux.watsup
 def $funcidx_module(module : module) : funcidx*
@@ -2081,14 +2124,14 @@ def $dataidx_funcs(func*) : dataidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:531.1-531.112
+;; 2-syntax-aux.watsup:535.1-535.112
 def $subst_typevar(typevar : typevar, typevar*, typeuse*) : typeuse
-  ;; 2-syntax-aux.watsup:558.1-558.38
+  ;; 2-syntax-aux.watsup:562.1-562.38
   def $subst_typevar{tv : typevar}(tv, [], []) = (tv : typevar <: typeuse)
-  ;; 2-syntax-aux.watsup:559.1-559.95
+  ;; 2-syntax-aux.watsup:563.1-563.95
   def $subst_typevar{tv : typevar, tv_1 : typevar, tv'* : typevar*, tu_1 : typeuse, tu'* : typeuse*}(tv, [tv_1] :: tv'*{tv' : typevar}, [tu_1] :: tu'*{tu' : typeuse}) = tu_1
     -- if (tv = tv_1)
-  ;; 2-syntax-aux.watsup:560.1-560.92
+  ;; 2-syntax-aux.watsup:564.1-564.92
   def $subst_typevar{tv : typevar, tv_1 : typevar, tv'* : typevar*, tu_1 : typeuse, tu'* : typeuse*}(tv, [tv_1] :: tv'*{tv' : typevar}, [tu_1] :: tu'*{tu' : typeuse}) = $subst_typevar(tv, tv'*{tv' : typevar}, tu'*{tu' : typeuse})
     -- otherwise
 }
@@ -2111,78 +2154,78 @@ def $subst_vectype(vectype : vectype, typevar*, typeuse*) : vectype
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:532.1-532.112
+;; 2-syntax-aux.watsup:536.1-536.112
 def $subst_typeuse(typeuse : typeuse, typevar*, typeuse*) : typeuse
-  ;; 2-syntax-aux.watsup:562.1-562.66
+  ;; 2-syntax-aux.watsup:566.1-566.66
   def $subst_typeuse{tv' : typevar, tv* : typevar*, tu* : typeuse*}((tv' : typevar <: typeuse), tv*{tv : typevar}, tu*{tu : typeuse}) = $subst_typevar(tv', tv*{tv : typevar}, tu*{tu : typeuse})
-  ;; 2-syntax-aux.watsup:563.1-563.64
+  ;; 2-syntax-aux.watsup:567.1-567.64
   def $subst_typeuse{dt : deftype, tv* : typevar*, tu* : typeuse*}((dt : deftype <: typeuse), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_deftype(dt, tv*{tv : typevar}, tu*{tu : typeuse}) : deftype <: typeuse)
 
-;; 2-syntax-aux.watsup:536.1-536.112
+;; 2-syntax-aux.watsup:540.1-540.112
 def $subst_heaptype(heaptype : heaptype, typevar*, typeuse*) : heaptype
-  ;; 2-syntax-aux.watsup:568.1-568.67
+  ;; 2-syntax-aux.watsup:572.1-572.67
   def $subst_heaptype{tv' : typevar, tv* : typevar*, tu* : typeuse*}((tv' : typevar <: heaptype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_typevar(tv', tv*{tv : typevar}, tu*{tu : typeuse}) : typeuse <: heaptype)
-  ;; 2-syntax-aux.watsup:569.1-569.65
+  ;; 2-syntax-aux.watsup:573.1-573.65
   def $subst_heaptype{dt : deftype, tv* : typevar*, tu* : typeuse*}((dt : deftype <: heaptype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_deftype(dt, tv*{tv : typevar}, tu*{tu : typeuse}) : deftype <: heaptype)
-  ;; 2-syntax-aux.watsup:570.1-570.53
+  ;; 2-syntax-aux.watsup:574.1-574.53
   def $subst_heaptype{ht : heaptype, tv* : typevar*, tu* : typeuse*}(ht, tv*{tv : typevar}, tu*{tu : typeuse}) = ht
     -- otherwise
 
-;; 2-syntax-aux.watsup:537.1-537.112
+;; 2-syntax-aux.watsup:541.1-541.112
 def $subst_reftype(reftype : reftype, typevar*, typeuse*) : reftype
-  ;; 2-syntax-aux.watsup:572.1-572.83
+  ;; 2-syntax-aux.watsup:576.1-576.83
   def $subst_reftype{nul : nul, ht : heaptype, tv* : typevar*, tu* : typeuse*}(REF_reftype(nul, ht), tv*{tv : typevar}, tu*{tu : typeuse}) = REF_reftype(nul, $subst_heaptype(ht, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:538.1-538.112
+;; 2-syntax-aux.watsup:542.1-542.112
 def $subst_valtype(valtype : valtype, typevar*, typeuse*) : valtype
-  ;; 2-syntax-aux.watsup:574.1-574.64
+  ;; 2-syntax-aux.watsup:578.1-578.64
   def $subst_valtype{nt : numtype, tv* : typevar*, tu* : typeuse*}((nt : numtype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_numtype(nt, tv*{tv : typevar}, tu*{tu : typeuse}) : numtype <: valtype)
-  ;; 2-syntax-aux.watsup:575.1-575.64
+  ;; 2-syntax-aux.watsup:579.1-579.64
   def $subst_valtype{vt : vectype, tv* : typevar*, tu* : typeuse*}((vt : vectype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_vectype(vt, tv*{tv : typevar}, tu*{tu : typeuse}) : vectype <: valtype)
-  ;; 2-syntax-aux.watsup:576.1-576.64
+  ;; 2-syntax-aux.watsup:580.1-580.64
   def $subst_valtype{rt : reftype, tv* : typevar*, tu* : typeuse*}((rt : reftype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_reftype(rt, tv*{tv : typevar}, tu*{tu : typeuse}) : reftype <: valtype)
-  ;; 2-syntax-aux.watsup:577.1-577.40
+  ;; 2-syntax-aux.watsup:581.1-581.40
   def $subst_valtype{tv* : typevar*, tu* : typeuse*}(BOT_valtype, tv*{tv : typevar}, tu*{tu : typeuse}) = BOT_valtype
 
-;; 2-syntax-aux.watsup:541.1-541.112
+;; 2-syntax-aux.watsup:545.1-545.112
 def $subst_storagetype(storagetype : storagetype, typevar*, typeuse*) : storagetype
-  ;; 2-syntax-aux.watsup:581.1-581.66
+  ;; 2-syntax-aux.watsup:585.1-585.66
   def $subst_storagetype{t : valtype, tv* : typevar*, tu* : typeuse*}((t : valtype <: storagetype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_valtype(t, tv*{tv : typevar}, tu*{tu : typeuse}) : valtype <: storagetype)
-  ;; 2-syntax-aux.watsup:582.1-582.69
+  ;; 2-syntax-aux.watsup:586.1-586.69
   def $subst_storagetype{pt : packtype, tv* : typevar*, tu* : typeuse*}((pt : packtype <: storagetype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_packtype(pt, tv*{tv : typevar}, tu*{tu : typeuse}) : packtype <: storagetype)
 
-;; 2-syntax-aux.watsup:542.1-542.112
+;; 2-syntax-aux.watsup:546.1-546.112
 def $subst_fieldtype(fieldtype : fieldtype, typevar*, typeuse*) : fieldtype
-  ;; 2-syntax-aux.watsup:584.1-584.80
+  ;; 2-syntax-aux.watsup:588.1-588.80
   def $subst_fieldtype{mut : mut, zt : storagetype, tv* : typevar*, tu* : typeuse*}(`%%`_fieldtype(mut, zt), tv*{tv : typevar}, tu*{tu : typeuse}) = `%%`_fieldtype(mut, $subst_storagetype(zt, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:544.1-544.112
+;; 2-syntax-aux.watsup:548.1-548.112
 def $subst_comptype(comptype : comptype, typevar*, typeuse*) : comptype
-  ;; 2-syntax-aux.watsup:586.1-586.85
+  ;; 2-syntax-aux.watsup:590.1-590.85
   def $subst_comptype{yt* : fieldtype*, tv* : typevar*, tu* : typeuse*}(STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = STRUCT_comptype(`%`_structtype($subst_fieldtype(yt, tv*{tv : typevar}, tu*{tu : typeuse})*{yt : fieldtype}))
-  ;; 2-syntax-aux.watsup:587.1-587.81
+  ;; 2-syntax-aux.watsup:591.1-591.81
   def $subst_comptype{yt : fieldtype, tv* : typevar*, tu* : typeuse*}(ARRAY_comptype(yt), tv*{tv : typevar}, tu*{tu : typeuse}) = ARRAY_comptype($subst_fieldtype(yt, tv*{tv : typevar}, tu*{tu : typeuse}))
-  ;; 2-syntax-aux.watsup:588.1-588.78
+  ;; 2-syntax-aux.watsup:592.1-592.78
   def $subst_comptype{ft : functype, tv* : typevar*, tu* : typeuse*}(FUNC_comptype(ft), tv*{tv : typevar}, tu*{tu : typeuse}) = FUNC_comptype($subst_functype(ft, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:545.1-545.112
+;; 2-syntax-aux.watsup:549.1-549.112
 def $subst_subtype(subtype : subtype, typevar*, typeuse*) : subtype
-  ;; 2-syntax-aux.watsup:590.1-591.71
+  ;; 2-syntax-aux.watsup:594.1-595.71
   def $subst_subtype{fin : fin, tu'* : typeuse*, ct : comptype, tv* : typevar*, tu* : typeuse*}(SUB_subtype(fin, tu'*{tu' : typeuse}, ct), tv*{tv : typevar}, tu*{tu : typeuse}) = SUB_subtype(fin, $subst_typeuse(tu', tv*{tv : typevar}, tu*{tu : typeuse})*{tu' : typeuse}, $subst_comptype(ct, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:546.1-546.112
+;; 2-syntax-aux.watsup:550.1-550.112
 def $subst_rectype(rectype : rectype, typevar*, typeuse*) : rectype
-  ;; 2-syntax-aux.watsup:593.1-593.76
+  ;; 2-syntax-aux.watsup:597.1-597.76
   def $subst_rectype{st* : subtype*, tv* : typevar*, tu* : typeuse*}(REC_rectype(`%`_list(st*{st : subtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = REC_rectype(`%`_list($subst_subtype(st, tv*{tv : typevar}, tu*{tu : typeuse})*{st : subtype}))
 
-;; 2-syntax-aux.watsup:547.1-547.112
+;; 2-syntax-aux.watsup:551.1-551.112
 def $subst_deftype(deftype : deftype, typevar*, typeuse*) : deftype
-  ;; 2-syntax-aux.watsup:595.1-595.78
+  ;; 2-syntax-aux.watsup:599.1-599.78
   def $subst_deftype{qt : rectype, i : nat, tv* : typevar*, tu* : typeuse*}(DEF_deftype(qt, i), tv*{tv : typevar}, tu*{tu : typeuse}) = DEF_deftype($subst_rectype(qt, tv*{tv : typevar}, tu*{tu : typeuse}), i)
 
-;; 2-syntax-aux.watsup:550.1-550.112
+;; 2-syntax-aux.watsup:554.1-554.112
 def $subst_functype(functype : functype, typevar*, typeuse*) : functype
-  ;; 2-syntax-aux.watsup:598.1-598.113
+  ;; 2-syntax-aux.watsup:602.1-602.113
   def $subst_functype{t_1* : valtype*, t_2* : valtype*, tv* : typevar*, tu* : typeuse*}(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = `%->%`_functype(`%`_resulttype($subst_valtype(t_1, tv*{tv : typevar}, tu*{tu : typeuse})*{t_1 : valtype}), `%`_resulttype($subst_valtype(t_2, tv*{tv : typevar}, tu*{tu : typeuse})*{t_2 : valtype}))
 }
 
@@ -2240,11 +2283,11 @@ def $subst_all_moduletype(moduletype : moduletype, heaptype*) : moduletype
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:620.1-620.98
+;; 2-syntax-aux.watsup:624.1-624.98
 def $subst_all_deftypes(deftype*, heaptype*) : deftype*
-  ;; 2-syntax-aux.watsup:621.1-621.40
+  ;; 2-syntax-aux.watsup:625.1-625.40
   def $subst_all_deftypes{tu* : typeuse*}([], (tu : typeuse <: heaptype)*{tu : typeuse}) = []
-  ;; 2-syntax-aux.watsup:622.1-622.101
+  ;; 2-syntax-aux.watsup:626.1-626.101
   def $subst_all_deftypes{dt_1 : deftype, dt* : deftype*, tu* : typeuse*}([dt_1] :: dt*{dt : deftype}, (tu : typeuse <: heaptype)*{tu : typeuse}) = [$subst_all_deftype(dt_1, (tu : typeuse <: heaptype)*{tu : typeuse})] :: $subst_all_deftypes(dt*{dt : deftype}, (tu : typeuse <: heaptype)*{tu : typeuse})
 }
 
@@ -2288,13 +2331,13 @@ relation Expand: `%~~%`(deftype, comptype)
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:654.1-654.86
+;; 2-syntax-aux.watsup:658.1-658.86
 def $funcsxx(externidx*) : typeidx*
-  ;; 2-syntax-aux.watsup:659.1-659.24
+  ;; 2-syntax-aux.watsup:664.1-664.24
   def $funcsxx([]) = []
-  ;; 2-syntax-aux.watsup:660.1-660.45
+  ;; 2-syntax-aux.watsup:665.1-665.45
   def $funcsxx{x : idx, xx* : externidx*}([FUNC_externidx(x)] :: xx*{xx : externidx}) = [x] :: $funcsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:661.1-661.58
+  ;; 2-syntax-aux.watsup:666.1-666.58
   def $funcsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $funcsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -2302,13 +2345,13 @@ def $funcsxx(externidx*) : typeidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:655.1-655.88
+;; 2-syntax-aux.watsup:659.1-659.88
 def $globalsxx(externidx*) : globalidx*
-  ;; 2-syntax-aux.watsup:663.1-663.26
+  ;; 2-syntax-aux.watsup:668.1-668.26
   def $globalsxx([]) = []
-  ;; 2-syntax-aux.watsup:664.1-664.51
+  ;; 2-syntax-aux.watsup:669.1-669.51
   def $globalsxx{x : idx, xx* : externidx*}([GLOBAL_externidx(x)] :: xx*{xx : externidx}) = [x] :: $globalsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:665.1-665.62
+  ;; 2-syntax-aux.watsup:670.1-670.62
   def $globalsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $globalsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -2316,13 +2359,13 @@ def $globalsxx(externidx*) : globalidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:656.1-656.87
+;; 2-syntax-aux.watsup:660.1-660.87
 def $tablesxx(externidx*) : tableidx*
-  ;; 2-syntax-aux.watsup:667.1-667.25
+  ;; 2-syntax-aux.watsup:672.1-672.25
   def $tablesxx([]) = []
-  ;; 2-syntax-aux.watsup:668.1-668.48
+  ;; 2-syntax-aux.watsup:673.1-673.48
   def $tablesxx{x : idx, xx* : externidx*}([TABLE_externidx(x)] :: xx*{xx : externidx}) = [x] :: $tablesxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:669.1-669.60
+  ;; 2-syntax-aux.watsup:674.1-674.60
   def $tablesxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $tablesxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -2330,13 +2373,13 @@ def $tablesxx(externidx*) : tableidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:657.1-657.85
+;; 2-syntax-aux.watsup:661.1-661.85
 def $memsxx(externidx*) : memidx*
-  ;; 2-syntax-aux.watsup:671.1-671.23
+  ;; 2-syntax-aux.watsup:676.1-676.23
   def $memsxx([]) = []
-  ;; 2-syntax-aux.watsup:672.1-672.42
+  ;; 2-syntax-aux.watsup:677.1-677.42
   def $memsxx{x : idx, xx* : externidx*}([MEM_externidx(x)] :: xx*{xx : externidx}) = [x] :: $memsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:673.1-673.56
+  ;; 2-syntax-aux.watsup:678.1-678.56
   def $memsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $memsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -2344,13 +2387,27 @@ def $memsxx(externidx*) : memidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:676.1-676.88
+;; 2-syntax-aux.watsup:662.1-662.85
+def $tagsxx(externidx*) : tagidx*
+  ;; 2-syntax-aux.watsup:680.1-680.23
+  def $tagsxx([]) = []
+  ;; 2-syntax-aux.watsup:681.1-681.42
+  def $tagsxx{x : idx, xx* : externidx*}([TAG_externidx(x)] :: xx*{xx : externidx}) = [x] :: $tagsxx(xx*{xx : externidx})
+  ;; 2-syntax-aux.watsup:682.1-682.56
+  def $tagsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $tagsxx(xx*{xx : externidx})
+    -- otherwise
+}
+
+;; 2-syntax-aux.watsup
+rec {
+
+;; 2-syntax-aux.watsup:685.1-685.88
 def $funcsxt(externtype*) : deftype*
-  ;; 2-syntax-aux.watsup:681.1-681.24
+  ;; 2-syntax-aux.watsup:691.1-691.24
   def $funcsxt([]) = []
-  ;; 2-syntax-aux.watsup:682.1-682.47
+  ;; 2-syntax-aux.watsup:692.1-692.47
   def $funcsxt{dt : deftype, xt* : externtype*}([FUNC_externtype((dt : deftype <: typeuse))] :: xt*{xt : externtype}) = [dt] :: $funcsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:683.1-683.59
+  ;; 2-syntax-aux.watsup:693.1-693.59
   def $funcsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $funcsxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -2358,13 +2415,13 @@ def $funcsxt(externtype*) : deftype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:677.1-677.90
+;; 2-syntax-aux.watsup:686.1-686.90
 def $globalsxt(externtype*) : globaltype*
-  ;; 2-syntax-aux.watsup:685.1-685.26
+  ;; 2-syntax-aux.watsup:695.1-695.26
   def $globalsxt([]) = []
-  ;; 2-syntax-aux.watsup:686.1-686.53
+  ;; 2-syntax-aux.watsup:696.1-696.53
   def $globalsxt{gt : globaltype, xt* : externtype*}([GLOBAL_externtype(gt)] :: xt*{xt : externtype}) = [gt] :: $globalsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:687.1-687.63
+  ;; 2-syntax-aux.watsup:697.1-697.63
   def $globalsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $globalsxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -2372,13 +2429,13 @@ def $globalsxt(externtype*) : globaltype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:678.1-678.89
+;; 2-syntax-aux.watsup:687.1-687.89
 def $tablesxt(externtype*) : tabletype*
-  ;; 2-syntax-aux.watsup:689.1-689.25
+  ;; 2-syntax-aux.watsup:699.1-699.25
   def $tablesxt([]) = []
-  ;; 2-syntax-aux.watsup:690.1-690.50
+  ;; 2-syntax-aux.watsup:700.1-700.50
   def $tablesxt{tt : tabletype, xt* : externtype*}([TABLE_externtype(tt)] :: xt*{xt : externtype}) = [tt] :: $tablesxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:691.1-691.61
+  ;; 2-syntax-aux.watsup:701.1-701.61
   def $tablesxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $tablesxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -2386,17 +2443,31 @@ def $tablesxt(externtype*) : tabletype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:679.1-679.87
+;; 2-syntax-aux.watsup:688.1-688.87
 def $memsxt(externtype*) : memtype*
-  ;; 2-syntax-aux.watsup:693.1-693.23
+  ;; 2-syntax-aux.watsup:703.1-703.23
   def $memsxt([]) = []
-  ;; 2-syntax-aux.watsup:694.1-694.44
+  ;; 2-syntax-aux.watsup:704.1-704.44
   def $memsxt{mt : memtype, xt* : externtype*}([MEM_externtype(mt)] :: xt*{xt : externtype}) = [mt] :: $memsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:695.1-695.57
+  ;; 2-syntax-aux.watsup:705.1-705.57
   def $memsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $memsxt(xt*{xt : externtype})
     -- otherwise
 }
 
+;; 2-syntax-aux.watsup
+rec {
+
+;; 2-syntax-aux.watsup:689.1-689.87
+def $tagsxt(externtype*) : tagtype*
+  ;; 2-syntax-aux.watsup:707.1-707.23
+  def $tagsxt([]) = []
+  ;; 2-syntax-aux.watsup:708.1-708.44
+  def $tagsxt{at : tagtype, xt* : externtype*}([TAG_externtype((at : deftype <: typeuse))] :: xt*{xt : externtype}) = [at] :: $tagsxt(xt*{xt : externtype})
+  ;; 2-syntax-aux.watsup:709.1-709.57
+  def $tagsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $tagsxt(xt*{xt : externtype})
+    -- otherwise
+}
+
 ;; 2-syntax-aux.watsup
 def $memarg0 : memarg
   ;; 2-syntax-aux.watsup
@@ -3124,6 +3195,7 @@ syntax ref =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | REF.NULL{heaptype : heaptype}(heaptype : heaptype)
@@ -3131,6 +3203,7 @@ syntax ref =
 ;; 4-runtime.watsup
 syntax result =
   | _VALS{val* : val*}(val*{val : val} : val*)
+  | `_EXN(REF.EXN_ADDR%)THROW_REF`{exnaddr : exnaddr}(exnaddr : exnaddr)
   | TRAP
 
 ;; 4-runtime.watsup
@@ -3171,6 +3244,12 @@ syntax meminst =
   BYTES{byte* : byte*} byte*
 }
 
+;; 4-runtime.watsup
+syntax taginst =
+{
+  TYPE{tagtype : tagtype} tagtype
+}
+
 ;; 4-runtime.watsup
 syntax eleminst =
 {
@@ -3197,6 +3276,7 @@ syntax fieldval =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | PACK{packtype : packtype, iN : iN($psizenn(packtype))}(packtype : packtype, iN : iN($psizenn(packtype)))
@@ -3215,6 +3295,13 @@ syntax arrayinst =
   FIELDS{fieldval* : fieldval*} fieldval*
 }
 
+;; 4-runtime.watsup
+syntax exninst =
+{
+  TAG{tagaddr : tagaddr} tagaddr,
+  FIELDS{val* : val*} val*
+}
+
 ;; 4-runtime.watsup
 syntax store =
 {
@@ -3222,10 +3309,12 @@ syntax store =
   GLOBALS{globalinst* : globalinst*} globalinst*,
   TABLES{tableinst* : tableinst*} tableinst*,
   MEMS{meminst* : meminst*} meminst*,
+  TAGS{taginst* : taginst*} taginst*,
   ELEMS{eleminst* : eleminst*} eleminst*,
   DATAS{datainst* : datainst*} datainst*,
   STRUCTS{structinst* : structinst*} structinst*,
-  ARRAYS{arrayinst* : arrayinst*} arrayinst*
+  ARRAYS{arrayinst* : arrayinst*} arrayinst*,
+  EXNS{exninst* : exninst*} exninst*
 }
 
 ;; 4-runtime.watsup
@@ -3278,56 +3367,70 @@ def $unpackfield_(storagetype : storagetype, sx?, fieldval : fieldval) : val
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:46.1-46.86
-def $funcsxv(externval*) : funcaddr*
-  ;; 5-runtime-aux.watsup:51.1-51.24
-  def $funcsxv([]) = []
-  ;; 5-runtime-aux.watsup:52.1-52.47
-  def $funcsxv{fa : funcaddr, xv* : externval*}([FUNC_externval(fa)] :: xv*{xv : externval}) = [fa] :: $funcsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:53.1-53.58
-  def $funcsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $funcsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:46.1-46.87
+def $funcsxa(externaddr*) : funcaddr*
+  ;; 5-runtime-aux.watsup:52.1-52.24
+  def $funcsxa([]) = []
+  ;; 5-runtime-aux.watsup:53.1-53.47
+  def $funcsxa{fa : funcaddr, xa* : externaddr*}([FUNC_externaddr(fa)] :: xa*{xa : externaddr}) = [fa] :: $funcsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:54.1-54.59
+  def $funcsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $funcsxa(xa*{xa : externaddr})
+    -- otherwise
+}
+
+;; 5-runtime-aux.watsup
+rec {
+
+;; 5-runtime-aux.watsup:47.1-47.89
+def $globalsxa(externaddr*) : globaladdr*
+  ;; 5-runtime-aux.watsup:56.1-56.26
+  def $globalsxa([]) = []
+  ;; 5-runtime-aux.watsup:57.1-57.53
+  def $globalsxa{ga : globaladdr, xa* : externaddr*}([GLOBAL_externaddr(ga)] :: xa*{xa : externaddr}) = [ga] :: $globalsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:58.1-58.63
+  def $globalsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $globalsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:47.1-47.88
-def $globalsxv(externval*) : globaladdr*
-  ;; 5-runtime-aux.watsup:55.1-55.26
-  def $globalsxv([]) = []
-  ;; 5-runtime-aux.watsup:56.1-56.53
-  def $globalsxv{ga : globaladdr, xv* : externval*}([GLOBAL_externval(ga)] :: xv*{xv : externval}) = [ga] :: $globalsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:57.1-57.62
-  def $globalsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $globalsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:48.1-48.88
+def $tablesxa(externaddr*) : tableaddr*
+  ;; 5-runtime-aux.watsup:60.1-60.25
+  def $tablesxa([]) = []
+  ;; 5-runtime-aux.watsup:61.1-61.50
+  def $tablesxa{ta : tableaddr, xa* : externaddr*}([TABLE_externaddr(ta)] :: xa*{xa : externaddr}) = [ta] :: $tablesxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:62.1-62.61
+  def $tablesxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $tablesxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:48.1-48.87
-def $tablesxv(externval*) : tableaddr*
-  ;; 5-runtime-aux.watsup:59.1-59.25
-  def $tablesxv([]) = []
-  ;; 5-runtime-aux.watsup:60.1-60.50
-  def $tablesxv{ta : tableaddr, xv* : externval*}([TABLE_externval(ta)] :: xv*{xv : externval}) = [ta] :: $tablesxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:61.1-61.60
-  def $tablesxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $tablesxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:49.1-49.86
+def $memsxa(externaddr*) : memaddr*
+  ;; 5-runtime-aux.watsup:64.1-64.23
+  def $memsxa([]) = []
+  ;; 5-runtime-aux.watsup:65.1-65.44
+  def $memsxa{ma : memaddr, xa* : externaddr*}([MEM_externaddr(ma)] :: xa*{xa : externaddr}) = [ma] :: $memsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:66.1-66.57
+  def $memsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $memsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:49.1-49.85
-def $memsxv(externval*) : memaddr*
-  ;; 5-runtime-aux.watsup:63.1-63.23
-  def $memsxv([]) = []
-  ;; 5-runtime-aux.watsup:64.1-64.44
-  def $memsxv{ma : memaddr, xv* : externval*}([MEM_externval(ma)] :: xv*{xv : externval}) = [ma] :: $memsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:65.1-65.56
-  def $memsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $memsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:50.1-50.86
+def $tagsxa(externaddr*) : tagaddr*
+  ;; 5-runtime-aux.watsup:68.1-68.23
+  def $tagsxa([]) = []
+  ;; 5-runtime-aux.watsup:69.1-69.44
+  def $tagsxa{ha : tagaddr, xa* : externaddr*}([TAG_externaddr(ha)] :: xa*{xa : externaddr}) = [ha] :: $tagsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:70.1-70.57
+  def $tagsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $tagsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
@@ -3341,6 +3444,11 @@ def $frame(state : state) : frame
   ;; 5-runtime-aux.watsup
   def $frame{s : store, f : frame}(`%;%`_state(s, f)) = f
 
+;; 5-runtime-aux.watsup
+def $tagaddr(state : state) : tagaddr*
+  ;; 5-runtime-aux.watsup
+  def $tagaddr{s : store, f : frame}(`%;%`_state(s, f)) = f.MODULE_frame.TAGS_moduleinst
+
 ;; 5-runtime-aux.watsup
 def $moduleinst(state : state) : moduleinst
   ;; 5-runtime-aux.watsup
@@ -3366,6 +3474,11 @@ def $meminst(state : state) : meminst*
   ;; 5-runtime-aux.watsup
   def $meminst{s : store, f : frame}(`%;%`_state(s, f)) = s.MEMS_store
 
+;; 5-runtime-aux.watsup
+def $taginst(state : state) : taginst*
+  ;; 5-runtime-aux.watsup
+  def $taginst{s : store, f : frame}(`%;%`_state(s, f)) = s.TAGS_store
+
 ;; 5-runtime-aux.watsup
 def $eleminst(state : state) : eleminst*
   ;; 5-runtime-aux.watsup
@@ -3386,6 +3499,11 @@ def $arrayinst(state : state) : arrayinst*
   ;; 5-runtime-aux.watsup
   def $arrayinst{s : store, f : frame}(`%;%`_state(s, f)) = s.ARRAYS_store
 
+;; 5-runtime-aux.watsup
+def $exninst(state : state) : exninst*
+  ;; 5-runtime-aux.watsup
+  def $exninst{s : store, f : frame}(`%;%`_state(s, f)) = s.EXNS_store
+
 ;; 5-runtime-aux.watsup
 def $type(state : state, typeidx : typeidx) : deftype
   ;; 5-runtime-aux.watsup
@@ -3411,6 +3529,11 @@ def $mem(state : state, memidx : memidx) : meminst
   ;; 5-runtime-aux.watsup
   def $mem{s : store, f : frame, x : idx}(`%;%`_state(s, f), x) = s.MEMS_store[f.MODULE_frame.MEMS_moduleinst[x!`%`_idx.0]]
 
+;; 5-runtime-aux.watsup
+def $tag(state : state, tagidx : tagidx) : taginst
+  ;; 5-runtime-aux.watsup
+  def $tag{s : store, f : frame, x : idx}(`%;%`_state(s, f), x) = s.TAGS_store[f.MODULE_frame.TAGS_moduleinst[x!`%`_idx.0]]
+
 ;; 5-runtime-aux.watsup
 def $elem(state : state, tableidx : tableidx) : eleminst
   ;; 5-runtime-aux.watsup
@@ -3486,6 +3609,11 @@ def $add_arrayinst(state : state, arrayinst*) : state
   ;; 5-runtime-aux.watsup
   def $add_arrayinst{s : store, f : frame, ai* : arrayinst*}(`%;%`_state(s, f), ai*{ai : arrayinst}) = `%;%`_state(s[ARRAYS_store =++ ai*{ai : arrayinst}], f)
 
+;; 5-runtime-aux.watsup
+def $add_exninst(state : state, exninst*) : state
+  ;; 5-runtime-aux.watsup
+  def $add_exninst{s : store, f : frame, exn* : exninst*}(`%;%`_state(s, f), exn*{exn : exninst}) = `%;%`_state(s[EXNS_store =++ exn*{exn : exninst}], f)
+
 ;; 5-runtime-aux.watsup
 def $growtable(tableinst : tableinst, nat : nat, ref : ref) : tableinst
   ;; 5-runtime-aux.watsup
@@ -3524,6 +3652,7 @@ syntax context =
   GLOBALS{globaltype* : globaltype*} globaltype*,
   TABLES{tabletype* : tabletype*} tabletype*,
   MEMS{memtype* : memtype*} memtype*,
+  TAGS{tagtype* : tagtype*} tagtype*,
   ELEMS{elemtype* : elemtype*} elemtype*,
   DATAS{datatype* : datatype*} datatype*,
   LOCALS{localtype* : localtype*} localtype*,
@@ -3535,22 +3664,22 @@ syntax context =
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:36.1-36.86
+;; 6-typing.watsup:37.1-37.86
 def $with_locals(context : context, localidx*, localtype*) : context
-  ;; 6-typing.watsup:38.1-38.34
+  ;; 6-typing.watsup:39.1-39.34
   def $with_locals{C : context}(C, [], []) = C
-  ;; 6-typing.watsup:39.1-39.90
+  ;; 6-typing.watsup:40.1-40.90
   def $with_locals{C : context, x_1 : idx, x* : idx*, lct_1 : localtype, lct* : localtype*}(C, [x_1] :: x*{x : localidx}, [lct_1] :: lct*{lct : localtype}) = $with_locals(C[LOCALS_context[x_1!`%`_idx.0] = lct_1], x*{x : localidx}, lct*{lct : localtype})
 }
 
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:45.1-45.94
+;; 6-typing.watsup:46.1-46.94
 def $clos_deftypes(deftype*) : deftype*
-  ;; 6-typing.watsup:52.1-52.30
+  ;; 6-typing.watsup:53.1-53.30
   def $clos_deftypes([]) = []
-  ;; 6-typing.watsup:53.1-53.101
+  ;; 6-typing.watsup:54.1-54.101
   def $clos_deftypes{dt* : deftype*, dt_n : deftype, dt'* : deftype*}(dt*{dt : deftype} :: [dt_n]) = dt'*{dt' : deftype} :: [$subst_all_deftype(dt_n, (dt' : deftype <: heaptype)*{dt' : deftype})]
     -- if (dt'*{dt' : deftype} = $clos_deftypes(dt*{dt : deftype}))
 }
@@ -3718,99 +3847,99 @@ relation Numtype_sub: `%|-%<:%`(context, numtype, numtype)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:140.1-140.107
+;; 6-typing.watsup:141.1-141.107
 relation Deftype_sub: `%|-%<:%`(context, deftype, deftype)
-  ;; 6-typing.watsup:451.1-453.66
+  ;; 6-typing.watsup:462.1-464.66
   rule refl{C : context, deftype_1 : deftype, deftype_2 : deftype}:
     `%|-%<:%`(C, deftype_1, deftype_2)
     -- if ($clos_deftype(C, deftype_1) = $clos_deftype(C, deftype_2))
 
-  ;; 6-typing.watsup:455.1-458.49
+  ;; 6-typing.watsup:466.1-469.49
   rule super{C : context, deftype_1 : deftype, deftype_2 : deftype, fin : fin, typeuse* : typeuse*, ct : comptype, i : nat}:
     `%|-%<:%`(C, deftype_1, deftype_2)
     -- if ($unrolldt(deftype_1) = SUB_subtype(fin, typeuse*{typeuse : typeuse}, ct))
     -- Heaptype_sub: `%|-%<:%`(C, (typeuse*{typeuse : typeuse}[i] : typeuse <: heaptype), (deftype_2 : deftype <: heaptype))
 
-;; 6-typing.watsup:288.1-288.104
+;; 6-typing.watsup:299.1-299.104
 relation Heaptype_sub: `%|-%<:%`(context, heaptype, heaptype)
-  ;; 6-typing.watsup:299.1-300.28
+  ;; 6-typing.watsup:310.1-311.28
   rule refl{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, heaptype, heaptype)
 
-  ;; 6-typing.watsup:302.1-306.48
+  ;; 6-typing.watsup:313.1-317.48
   rule trans{C : context, heaptype_1 : heaptype, heaptype_2 : heaptype, heaptype' : heaptype}:
     `%|-%<:%`(C, heaptype_1, heaptype_2)
     -- Heaptype_ok: `%|-%:OK`(C, heaptype')
     -- Heaptype_sub: `%|-%<:%`(C, heaptype_1, heaptype')
     -- Heaptype_sub: `%|-%<:%`(C, heaptype', heaptype_2)
 
-  ;; 6-typing.watsup:308.1-309.17
+  ;; 6-typing.watsup:319.1-320.17
   rule eq-any{C : context}:
     `%|-%<:%`(C, EQ_heaptype, ANY_heaptype)
 
-  ;; 6-typing.watsup:311.1-312.17
+  ;; 6-typing.watsup:322.1-323.17
   rule i31-eq{C : context}:
     `%|-%<:%`(C, I31_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:314.1-315.20
+  ;; 6-typing.watsup:325.1-326.20
   rule struct-eq{C : context}:
     `%|-%<:%`(C, STRUCT_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:317.1-318.19
+  ;; 6-typing.watsup:328.1-329.19
   rule array-eq{C : context}:
     `%|-%<:%`(C, ARRAY_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:320.1-322.42
+  ;; 6-typing.watsup:331.1-333.42
   rule struct{C : context, deftype : deftype, fieldtype* : fieldtype*}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), STRUCT_heaptype)
     -- Expand: `%~~%`(deftype, STRUCT_comptype(`%`_structtype(fieldtype*{fieldtype : fieldtype})))
 
-  ;; 6-typing.watsup:324.1-326.40
+  ;; 6-typing.watsup:335.1-337.40
   rule array{C : context, deftype : deftype, fieldtype : fieldtype}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), ARRAY_heaptype)
     -- Expand: `%~~%`(deftype, ARRAY_comptype(fieldtype))
 
-  ;; 6-typing.watsup:328.1-330.38
+  ;; 6-typing.watsup:339.1-341.38
   rule func{C : context, deftype : deftype, functype : functype}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), FUNC_heaptype)
     -- Expand: `%~~%`(deftype, FUNC_comptype(functype))
 
-  ;; 6-typing.watsup:332.1-334.46
+  ;; 6-typing.watsup:343.1-345.46
   rule def{C : context, deftype_1 : deftype, deftype_2 : deftype}:
     `%|-%<:%`(C, (deftype_1 : deftype <: heaptype), (deftype_2 : deftype <: heaptype))
     -- Deftype_sub: `%|-%<:%`(C, deftype_1, deftype_2)
 
-  ;; 6-typing.watsup:336.1-338.53
+  ;; 6-typing.watsup:347.1-349.53
   rule typeidx-l{C : context, typeidx : typeidx, heaptype : heaptype}:
     `%|-%<:%`(C, _IDX_heaptype(typeidx), heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, (C.TYPES_context[typeidx!`%`_typeidx.0] : deftype <: heaptype), heaptype)
 
-  ;; 6-typing.watsup:340.1-342.53
+  ;; 6-typing.watsup:351.1-353.53
   rule typeidx-r{C : context, heaptype : heaptype, typeidx : typeidx}:
     `%|-%<:%`(C, heaptype, _IDX_heaptype(typeidx))
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, (C.TYPES_context[typeidx!`%`_typeidx.0] : deftype <: heaptype))
 
-  ;; 6-typing.watsup:344.1-346.40
+  ;; 6-typing.watsup:355.1-357.40
   rule rec{C : context, i : nat, typeuse* : typeuse*, j : nat, fin : fin, ct : comptype}:
     `%|-%<:%`(C, REC_heaptype(i), (typeuse*{typeuse : typeuse}[j] : typeuse <: heaptype))
     -- if (C.RECS_context[i] = SUB_subtype(fin, typeuse*{typeuse : typeuse}, ct))
 
-  ;; 6-typing.watsup:348.1-350.40
+  ;; 6-typing.watsup:359.1-361.40
   rule none{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NONE_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, ANY_heaptype)
 
-  ;; 6-typing.watsup:352.1-354.41
+  ;; 6-typing.watsup:363.1-365.41
   rule nofunc{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NOFUNC_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, FUNC_heaptype)
 
-  ;; 6-typing.watsup:356.1-358.43
+  ;; 6-typing.watsup:367.1-369.43
   rule noextern{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NOEXTERN_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, EXTERN_heaptype)
 
-  ;; 6-typing.watsup:360.1-361.23
+  ;; 6-typing.watsup:371.1-372.23
   rule bot{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, BOT_heaptype, heaptype)
 }
@@ -3954,13 +4083,13 @@ relation Subtype_ok2: `%|-%:%`(context, subtype, oktypeidxnat)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:135.1-135.105
+;; 6-typing.watsup:136.1-136.105
 relation Rectype_ok2: `%|-%:%`(context, rectype, oktypeidxnat)
-  ;; 6-typing.watsup:213.1-214.24
+  ;; 6-typing.watsup:214.1-215.24
   rule empty{C : context, x : idx, i : nat}:
     `%|-%:%`(C, REC_rectype(`%`_list([])), OK_oktypeidxnat(x, i))
 
-  ;; 6-typing.watsup:216.1-219.55
+  ;; 6-typing.watsup:217.1-220.55
   rule cons{C : context, subtype_1 : subtype, subtype* : subtype*, x : idx, i : nat}:
     `%|-%:%`(C, REC_rectype(`%`_list([subtype_1] :: subtype*{subtype : subtype})), OK_oktypeidxnat(x, i))
     -- Subtype_ok2: `%|-%:%`(C, subtype_1, OK_oktypeidxnat(x, i))
@@ -3970,22 +4099,22 @@ relation Rectype_ok2: `%|-%:%`(context, rectype, oktypeidxnat)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:133.1-133.102
+;; 6-typing.watsup:134.1-134.102
 relation Rectype_ok: `%|-%:%`(context, rectype, oktypeidx)
-  ;; 6-typing.watsup:201.1-202.23
+  ;; 6-typing.watsup:202.1-203.23
   rule empty{C : context, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list([])), OK_oktypeidx(x))
 
-  ;; 6-typing.watsup:204.1-207.48
+  ;; 6-typing.watsup:205.1-208.48
   rule cons{C : context, subtype_1 : subtype, subtype* : subtype*, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list([subtype_1] :: subtype*{subtype : subtype})), OK_oktypeidx(x))
     -- Subtype_ok: `%|-%:%`(C, subtype_1, OK_oktypeidx(x))
     -- Rectype_ok: `%|-%:%`(C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidx(`%`_typeidx((x!`%`_idx.0 + 1))))
 
-  ;; 6-typing.watsup:209.1-211.60
+  ;; 6-typing.watsup:210.1-212.60
   rule rec2{C : context, subtype* : subtype*, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidx(x))
-    -- Rectype_ok2: `%|-%:%`({TYPES [], RECS subtype*{subtype : subtype}, FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []} ++ C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidxnat(x, 0))
+    -- Rectype_ok2: `%|-%:%`({TYPES [], RECS subtype*{subtype : subtype}, FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []} ++ C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidxnat(x, 0))
 }
 
 ;; 6-typing.watsup
@@ -4026,6 +4155,14 @@ relation Memtype_ok: `%|-%:OK`(context, memtype)
     `%|-%:OK`(C, `%PAGE`_memtype(limits))
     -- Limits_ok: `%|-%:%`(C, limits, (2 ^ 16))
 
+;; 6-typing.watsup
+relation Tagtype_ok: `%|-%:OK`(context, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, deftype : deftype, functype : functype}:
+    `%|-%:OK`(C, deftype)
+    -- Deftype_ok: `%|-%:OK`(C, deftype)
+    -- Expand: `%~~%`(deftype, FUNC_comptype(functype))
+
 ;; 6-typing.watsup
 relation Externtype_ok: `%|-%:OK`(context, externtype)
   ;; 6-typing.watsup
@@ -4049,6 +4186,11 @@ relation Externtype_ok: `%|-%:OK`(context, externtype)
     `%|-%:OK`(C, MEM_externtype(memtype))
     -- Memtype_ok: `%|-%:OK`(C, memtype)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, tagtype : tagtype}:
+    `%|-%:OK`(C, TAG_externtype((tagtype : deftype <: typeuse)))
+    -- Tagtype_ok: `%|-%:OK`(C, tagtype)
+
 ;; 6-typing.watsup
 relation Instrtype_sub: `%|-%<:%`(context, instrtype, instrtype)
   ;; 6-typing.watsup
@@ -4096,6 +4238,14 @@ relation Memtype_sub: `%|-%<:%`(context, memtype, memtype)
     `%|-%<:%`(C, `%PAGE`_memtype(limits_1), `%PAGE`_memtype(limits_2))
     -- Limits_sub: `%|-%<:%`(C, limits_1, limits_2)
 
+;; 6-typing.watsup
+relation Tagtype_sub: `%|-%<:%`(context, tagtype, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, deftype_1 : deftype, deftype_2 : deftype}:
+    `%|-%<:%`(C, deftype_1, deftype_2)
+    -- Deftype_sub: `%|-%<:%`(C, deftype_1, deftype_2)
+    -- Deftype_sub: `%|-%<:%`(C, deftype_2, deftype_1)
+
 ;; 6-typing.watsup
 relation Externtype_sub: `%|-%<:%`(context, externtype, externtype)
   ;; 6-typing.watsup
@@ -4118,6 +4268,11 @@ relation Externtype_sub: `%|-%<:%`(context, externtype, externtype)
     `%|-%<:%`(C, MEM_externtype(memtype_1), MEM_externtype(memtype_2))
     -- Memtype_sub: `%|-%<:%`(C, memtype_1, memtype_2)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, tagtype_1 : tagtype, tagtype_2 : tagtype}:
+    `%|-%<:%`(C, TAG_externtype((tagtype_1 : deftype <: typeuse)), TAG_externtype((tagtype_2 : deftype <: typeuse)))
+    -- Tagtype_sub: `%|-%<:%`(C, tagtype_1, tagtype_2)
+
 ;; 6-typing.watsup
 relation Blocktype_ok: `%|-%:%`(context, blocktype, instrtype)
   ;; 6-typing.watsup
@@ -4130,86 +4285,110 @@ relation Blocktype_ok: `%|-%:%`(context, blocktype, instrtype)
     `%|-%:%`(C, _IDX_blocktype(typeidx), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[typeidx!`%`_typeidx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
+;; 6-typing.watsup
+relation Catch_ok: `%|-%:OK`(context, catch)
+  ;; 6-typing.watsup
+  rule catch{C : context, x : idx, l : labelidx, t* : valtype*}:
+    `%|-%:OK`(C, CATCH_catch(x, l))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_ref{C : context, x : idx, l : labelidx, t* : valtype*}:
+    `%|-%:OK`(C, CATCH_REF_catch(x, l))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), EXN_heaptype)], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_all{C : context, l : labelidx}:
+    `%|-%:OK`(C, CATCH_ALL_catch(l))
+    -- Resulttype_sub: `%|-%<:%`(C, [], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_all_ref{C : context, l : labelidx}:
+    `%|-%:OK`(C, CATCH_ALL_REF_catch(l))
+    -- Resulttype_sub: `%|-%<:%`(C, [REF_valtype(`NULL%?`_nul(?()), EXN_heaptype)], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:522.1-522.95
+;; 6-typing.watsup:543.1-543.95
 relation Instr_ok: `%|-%:%`(context, instr, instrtype)
-  ;; 6-typing.watsup:561.1-562.24
+  ;; 6-typing.watsup:582.1-583.24
   rule nop{C : context}:
     `%|-%:%`(C, NOP_instr, `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
 
-  ;; 6-typing.watsup:564.1-566.42
+  ;; 6-typing.watsup:585.1-587.42
   rule unreachable{C : context, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, UNREACHABLE_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:568.1-570.29
+  ;; 6-typing.watsup:589.1-591.29
   rule drop{C : context, t : valtype}:
     `%|-%:%`(C, DROP_instr, `%->_%%`_instrtype(`%`_resulttype([t]), [], `%`_resulttype([])))
     -- Valtype_ok: `%|-%:OK`(C, t)
 
-  ;; 6-typing.watsup:573.1-575.29
+  ;; 6-typing.watsup:594.1-596.29
   rule select-expl{C : context, t : valtype}:
     `%|-%:%`(C, `SELECT()%?`_instr(?([t])), `%->_%%`_instrtype(`%`_resulttype([t t I32_valtype]), [], `%`_resulttype([t])))
     -- Valtype_ok: `%|-%:OK`(C, t)
 
-  ;; 6-typing.watsup:577.1-581.37
+  ;; 6-typing.watsup:598.1-602.37
   rule select-impl{C : context, t : valtype, t' : valtype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, `SELECT()%?`_instr(?()), `%->_%%`_instrtype(`%`_resulttype([t t I32_valtype]), [], `%`_resulttype([t])))
     -- Valtype_ok: `%|-%:OK`(C, t)
     -- Valtype_sub: `%|-%<:%`(C, t, t')
     -- if ((t' = (numtype : numtype <: valtype)) \/ (t' = (vectype : vectype <: valtype)))
 
-  ;; 6-typing.watsup:597.1-600.67
+  ;; 6-typing.watsup:618.1-621.67
   rule block{C : context, bt : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
     `%|-%:%`(C, BLOCK_instr(bt, instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:602.1-605.67
+  ;; 6-typing.watsup:623.1-626.67
   rule loop{C : context, bt : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
     `%|-%:%`(C, LOOP_instr(bt, instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_1*{t_1 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_1*{t_1 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:607.1-611.71
+  ;; 6-typing.watsup:628.1-632.71
   rule if{C : context, bt : blocktype, instr_1* : instr*, instr_2* : instr*, t_1* : valtype*, t_2* : valtype*, x_1* : idx*, x_2* : idx*}:
     `%|-%:%`(C, `IF%%ELSE%`_instr(bt, instr_1*{instr_1 : instr}, instr_2*{instr_2 : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_1*{instr_1 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_1*{instr_1 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:616.1-619.42
+  ;; 6-typing.watsup:637.1-640.42
   rule br{C : context, l : labelidx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, BR_instr(l), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:621.1-623.25
+  ;; 6-typing.watsup:642.1-644.25
   rule br_if{C : context, l : labelidx, t* : valtype*}:
     `%|-%:%`(C, BR_IF_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [I32_valtype]), [], `%`_resulttype(t*{t : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
 
-  ;; 6-typing.watsup:625.1-629.42
+  ;; 6-typing.watsup:646.1-650.42
   rule br_table{C : context, l* : labelidx*, l' : labelidx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, BR_TABLE_instr(l*{l : labelidx}, l'), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- (Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0))*{l : labelidx}
     -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l'!`%`_labelidx.0]!`%`_resulttype.0)
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:631.1-634.31
+  ;; 6-typing.watsup:652.1-655.31
   rule br_on_null{C : context, l : labelidx, t* : valtype*, ht : heaptype}:
     `%|-%:%`(C, BR_ON_NULL_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), ht)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:636.1-638.34
+  ;; 6-typing.watsup:657.1-659.34
   rule br_on_non_null{C : context, l : labelidx, t* : valtype*, ht : heaptype}:
     `%|-%:%`(C, BR_ON_NON_NULL_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype(t*{t : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), ht)]))
 
-  ;; 6-typing.watsup:640.1-646.34
+  ;; 6-typing.watsup:661.1-667.34
   rule br_on_cast{C : context, l : labelidx, rt_1 : reftype, rt_2 : reftype, t* : valtype*, rt : reftype}:
     `%|-%:%`(C, BR_ON_CAST_instr(l, rt_1, rt_2), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [(rt_1 : reftype <: valtype)]), [], `%`_resulttype(t*{t : valtype} :: [($diffrt(rt_1, rt_2) : reftype <: valtype)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [(rt : reftype <: valtype)]))
@@ -4218,7 +4397,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt)
 
-  ;; 6-typing.watsup:648.1-654.49
+  ;; 6-typing.watsup:669.1-675.49
   rule br_on_cast_fail{C : context, l : labelidx, rt_1 : reftype, rt_2 : reftype, t* : valtype*, rt : reftype}:
     `%|-%:%`(C, BR_ON_CAST_FAIL_instr(l, rt_1, rt_2), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [(rt_1 : reftype <: valtype)]), [], `%`_resulttype(t*{t : valtype} :: [(rt_2 : reftype <: valtype)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [(rt : reftype <: valtype)]))
@@ -4227,30 +4406,30 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
     -- Reftype_sub: `%|-%<:%`(C, $diffrt(rt_1, rt_2), rt)
 
-  ;; 6-typing.watsup:659.1-661.47
+  ;; 6-typing.watsup:680.1-682.47
   rule call{C : context, x : idx, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, CALL_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.FUNCS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:663.1-665.47
+  ;; 6-typing.watsup:684.1-686.47
   rule call_ref{C : context, x : idx, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, CALL_REF_instr(($idx(x) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:667.1-671.47
+  ;; 6-typing.watsup:688.1-692.47
   rule call_indirect{C : context, x : idx, y : idx, t_1* : valtype*, t_2* : valtype*, lim : limits, rt : reftype}:
     `%|-%:%`(C, CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
     -- Reftype_sub: `%|-%<:%`(C, rt, REF_reftype(`NULL%?`_nul(?(())), FUNC_heaptype))
     -- Expand: `%~~%`(C.TYPES_context[y!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:673.1-676.42
+  ;; 6-typing.watsup:694.1-697.42
   rule return{C : context, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, RETURN_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.RETURN_context = ?(`%`_list(t*{t : valtype})))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:679.1-684.42
+  ;; 6-typing.watsup:700.1-705.42
   rule return_call{C : context, x : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- Expand: `%~~%`(C.FUNCS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
@@ -4258,7 +4437,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:687.1-692.42
+  ;; 6-typing.watsup:708.1-713.42
   rule return_call_ref{C : context, x : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_REF_instr(($idx(x) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
@@ -4266,7 +4445,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:695.1-703.42
+  ;; 6-typing.watsup:716.1-724.42
   rule return_call_indirect{C : context, x : idx, y : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, lim : limits, rt : reftype, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
@@ -4276,452 +4455,470 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:708.1-709.33
+  ;; 6-typing.watsup:731.1-734.42
+  rule throw{C : context, x : idx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
+    `%|-%:%`(C, THROW_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+
+  ;; 6-typing.watsup:736.1-738.42
+  rule throw_ref{C : context, t_1* : valtype*, t_2* : valtype*}:
+    `%|-%:%`(C, THROW_REF_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), EXN_heaptype)]), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+
+  ;; 6-typing.watsup:740.1-744.34
+  rule try_table{C : context, bt : blocktype, catch* : catch*, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
+    `%|-%:%`(C, TRY_TABLE_instr(bt, `%`_list(catch*{catch : catch}), instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- (Catch_ok: `%|-%:OK`(C, catch))*{catch : catch}
+
+  ;; 6-typing.watsup:767.1-768.33
   rule const{C : context, nt : numtype, c_nt : num_(nt)}:
     `%|-%:%`(C, CONST_instr(nt, c_nt), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:711.1-712.34
+  ;; 6-typing.watsup:770.1-771.34
   rule unop{C : context, nt : numtype, unop_nt : unop_(nt)}:
     `%|-%:%`(C, UNOP_instr(nt, unop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype)]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:714.1-715.39
+  ;; 6-typing.watsup:773.1-774.39
   rule binop{C : context, nt : numtype, binop_nt : binop_(nt)}:
     `%|-%:%`(C, BINOP_instr(nt, binop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype) (nt : numtype <: valtype)]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:717.1-718.39
+  ;; 6-typing.watsup:776.1-777.39
   rule testop{C : context, nt : numtype, testop_nt : testop_(nt)}:
     `%|-%:%`(C, TESTOP_instr(nt, testop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:720.1-721.40
+  ;; 6-typing.watsup:779.1-780.40
   rule relop{C : context, nt : numtype, relop_nt : relop_(nt)}:
     `%|-%:%`(C, RELOP_instr(nt, relop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype) (nt : numtype <: valtype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:723.1-724.44
+  ;; 6-typing.watsup:782.1-783.44
   rule cvtop{C : context, nt_1 : numtype, nt_2 : numtype, cvtop : cvtop__(nt_2, nt_1)}:
     `%|-%:%`(C, CVTOP_instr(nt_1, nt_2, cvtop), `%->_%%`_instrtype(`%`_resulttype([(nt_2 : numtype <: valtype)]), [], `%`_resulttype([(nt_1 : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:729.1-731.31
+  ;; 6-typing.watsup:788.1-790.31
   rule ref.null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.NULL_instr(ht), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:733.1-736.20
+  ;; 6-typing.watsup:792.1-795.20
   rule ref.func{C : context, x : idx, dt : deftype}:
     `%|-%:%`(C, REF.FUNC_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), (dt : deftype <: heaptype))])))
     -- if (C.FUNCS_context[x!`%`_idx.0] = dt)
     -- if x <- C.REFS_context
 
-  ;; 6-typing.watsup:738.1-739.34
+  ;; 6-typing.watsup:797.1-798.34
   rule ref.i31{C : context}:
     `%|-%:%`(C, REF.I31_instr, `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), I31_heaptype)])))
 
-  ;; 6-typing.watsup:741.1-743.31
+  ;; 6-typing.watsup:800.1-802.31
   rule ref.is_null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.IS_NULL_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype([I32_valtype])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:745.1-747.31
+  ;; 6-typing.watsup:804.1-806.31
   rule ref.as_non_null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.AS_NON_NULL_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ht)])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:749.1-750.51
+  ;; 6-typing.watsup:808.1-809.51
   rule ref.eq{C : context}:
     `%|-%:%`(C, REF.EQ_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), EQ_heaptype) REF_valtype(`NULL%?`_nul(?(())), EQ_heaptype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:752.1-756.33
+  ;; 6-typing.watsup:811.1-815.33
   rule ref.test{C : context, rt : reftype, rt' : reftype}:
     `%|-%:%`(C, REF.TEST_instr(rt), `%->_%%`_instrtype(`%`_resulttype([(rt' : reftype <: valtype)]), [], `%`_resulttype([I32_valtype])))
     -- Reftype_ok: `%|-%:OK`(C, rt)
     -- Reftype_ok: `%|-%:OK`(C, rt')
     -- Reftype_sub: `%|-%<:%`(C, rt, rt')
 
-  ;; 6-typing.watsup:758.1-762.33
+  ;; 6-typing.watsup:817.1-821.33
   rule ref.cast{C : context, rt : reftype, rt' : reftype}:
     `%|-%:%`(C, REF.CAST_instr(rt), `%->_%%`_instrtype(`%`_resulttype([(rt' : reftype <: valtype)]), [], `%`_resulttype([(rt : reftype <: valtype)])))
     -- Reftype_ok: `%|-%:OK`(C, rt)
     -- Reftype_ok: `%|-%:OK`(C, rt')
     -- Reftype_sub: `%|-%<:%`(C, rt, rt')
 
-  ;; 6-typing.watsup:767.1-768.42
+  ;; 6-typing.watsup:826.1-827.42
   rule i31.get{C : context, sx : sx}:
     `%|-%:%`(C, I31.GET_instr(sx), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), I31_heaptype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:773.1-775.44
+  ;; 6-typing.watsup:832.1-834.44
   rule struct.new{C : context, x : idx, zt* : storagetype*, mut* : mut*}:
     `%|-%:%`(C, STRUCT.NEW_instr(x), `%->_%%`_instrtype(`%`_resulttype($unpack(zt)*{zt : storagetype}), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
 
-  ;; 6-typing.watsup:777.1-780.40
+  ;; 6-typing.watsup:836.1-839.40
   rule struct.new_default{C : context, x : idx, mut* : mut*, zt* : storagetype*, val* : val*}:
     `%|-%:%`(C, STRUCT.NEW_DEFAULT_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
     -- (if ($default_($unpack(zt)) = ?(val)))*{val : val, zt : storagetype}
 
-  ;; 6-typing.watsup:782.1-786.39
+  ;; 6-typing.watsup:841.1-845.39
   rule struct.get{C : context, sx? : sx?, x : idx, i : nat, zt : storagetype, yt* : fieldtype*, mut : mut}:
     `%|-%:%`(C, STRUCT.GET_instr(sx?{sx : sx}, x, `%`_u32(i)), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype([$unpack(zt)])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})))
     -- if (yt*{yt : fieldtype}[i] = `%%`_fieldtype(mut, zt))
     -- if ((sx?{sx : sx} = ?()) <=> (zt = ($unpack(zt) : valtype <: storagetype)))
 
-  ;; 6-typing.watsup:788.1-791.24
+  ;; 6-typing.watsup:847.1-850.24
   rule struct.set{C : context, x : idx, i : nat, zt : storagetype, yt* : fieldtype*}:
     `%|-%:%`(C, STRUCT.SET_instr(x, `%`_u32(i)), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) $unpack(zt)]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})))
     -- if (yt*{yt : fieldtype}[i] = `%%`_fieldtype(`MUT%?`_mut(?(())), zt))
 
-  ;; 6-typing.watsup:796.1-798.42
+  ;; 6-typing.watsup:855.1-857.42
   rule array.new{C : context, x : idx, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.NEW_instr(x), `%->_%%`_instrtype(`%`_resulttype([$unpack(zt) I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 6-typing.watsup:800.1-803.37
+  ;; 6-typing.watsup:859.1-862.37
   rule array.new_default{C : context, x : idx, mut : mut, zt : storagetype, val : val}:
     `%|-%:%`(C, ARRAY.NEW_DEFAULT_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ($default_($unpack(zt)) = ?(val))
 
-  ;; 6-typing.watsup:805.1-807.42
+  ;; 6-typing.watsup:864.1-866.42
   rule array.new_fixed{C : context, x : idx, n : n, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.NEW_FIXED_instr(x, `%`_u32(n)), `%->_%%`_instrtype(`%`_resulttype($unpack(zt)^n{}), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 6-typing.watsup:809.1-812.40
+  ;; 6-typing.watsup:868.1-871.40
   rule array.new_elem{C : context, x : idx, y : idx, mut : mut, rt : reftype}:
     `%|-%:%`(C, ARRAY.NEW_ELEM_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, (rt : reftype <: storagetype))))
     -- Reftype_sub: `%|-%<:%`(C, C.ELEMS_context[y!`%`_idx.0], rt)
 
-  ;; 6-typing.watsup:814.1-818.24
+  ;; 6-typing.watsup:873.1-877.24
   rule array.new_data{C : context, x : idx, y : idx, mut : mut, zt : storagetype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, ARRAY.NEW_DATA_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if (($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:820.1-823.39
+  ;; 6-typing.watsup:879.1-882.39
   rule array.get{C : context, sx? : sx?, x : idx, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.GET_instr(sx?{sx : sx}, x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype]), [], `%`_resulttype([$unpack(zt)])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ((sx?{sx : sx} = ?()) <=> (zt = ($unpack(zt) : valtype <: storagetype)))
 
-  ;; 6-typing.watsup:825.1-827.42
+  ;; 6-typing.watsup:884.1-886.42
   rule array.set{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype $unpack(zt)]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:829.1-831.42
+  ;; 6-typing.watsup:888.1-890.42
   rule array.len{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.LEN_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ARRAY_heaptype)]), [], `%`_resulttype([I32_valtype])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:833.1-835.42
+  ;; 6-typing.watsup:892.1-894.42
   rule array.fill{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype $unpack(zt) I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:837.1-841.40
+  ;; 6-typing.watsup:896.1-900.40
   rule array.copy{C : context, x_1 : idx, x_2 : idx, zt_1 : storagetype, mut : mut, zt_2 : storagetype}:
     `%|-%:%`(C, ARRAY.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x_1) : typevar <: heaptype)) I32_valtype REF_valtype(`NULL%?`_nul(?(())), ($idx(x_2) : typevar <: heaptype)) I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x_1!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt_1)))
     -- Expand: `%~~%`(C.TYPES_context[x_2!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt_2)))
     -- Storagetype_sub: `%|-%<:%`(C, zt_2, zt_1)
 
-  ;; 6-typing.watsup:843.1-846.44
+  ;; 6-typing.watsup:902.1-905.44
   rule array.init_elem{C : context, x : idx, y : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.INIT_ELEM_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
     -- Storagetype_sub: `%|-%<:%`(C, (C.ELEMS_context[y!`%`_idx.0] : reftype <: storagetype), zt)
 
-  ;; 6-typing.watsup:848.1-852.24
+  ;; 6-typing.watsup:907.1-911.24
   rule array.init_data{C : context, x : idx, y : idx, zt : storagetype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, ARRAY.INIT_DATA_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
     -- if (($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:857.1-858.62
+  ;; 6-typing.watsup:916.1-917.62
   rule extern.convert_any{C : context, nul : nul}:
     `%|-%:%`(C, EXTERN.CONVERT_ANY_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(nul, ANY_heaptype)]), [], `%`_resulttype([REF_valtype(nul, EXTERN_heaptype)])))
 
-  ;; 6-typing.watsup:860.1-861.62
+  ;; 6-typing.watsup:919.1-920.62
   rule any.convert_extern{C : context, nul : nul}:
     `%|-%:%`(C, ANY.CONVERT_EXTERN_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(nul, EXTERN_heaptype)]), [], `%`_resulttype([REF_valtype(nul, ANY_heaptype)])))
 
-  ;; 6-typing.watsup:866.1-867.35
+  ;; 6-typing.watsup:925.1-926.35
   rule vconst{C : context, c : vec_(V128_Vnn)}:
     `%|-%:%`(C, VCONST_instr(V128_vectype, c), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:869.1-870.41
+  ;; 6-typing.watsup:928.1-929.41
   rule vvunop{C : context, vvunop : vvunop}:
     `%|-%:%`(C, VVUNOP_instr(V128_vectype, vvunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:872.1-873.48
+  ;; 6-typing.watsup:931.1-932.48
   rule vvbinop{C : context, vvbinop : vvbinop}:
     `%|-%:%`(C, VVBINOP_instr(V128_vectype, vvbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:875.1-876.55
+  ;; 6-typing.watsup:934.1-935.55
   rule vvternop{C : context, vvternop : vvternop}:
     `%|-%:%`(C, VVTERNOP_instr(V128_vectype, vvternop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:878.1-879.44
+  ;; 6-typing.watsup:937.1-938.44
   rule vvtestop{C : context, vvtestop : vvtestop}:
     `%|-%:%`(C, VVTESTOP_instr(V128_vectype, vvtestop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:881.1-882.37
+  ;; 6-typing.watsup:940.1-941.37
   rule vunop{C : context, sh : shape, vunop : vunop_(sh)}:
     `%|-%:%`(C, VUNOP_instr(sh, vunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:884.1-885.44
+  ;; 6-typing.watsup:943.1-944.44
   rule vbinop{C : context, sh : shape, vbinop : vbinop_(sh)}:
     `%|-%:%`(C, VBINOP_instr(sh, vbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:887.1-888.40
+  ;; 6-typing.watsup:946.1-947.40
   rule vtestop{C : context, sh : shape, vtestop : vtestop_(sh)}:
     `%|-%:%`(C, VTESTOP_instr(sh, vtestop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:890.1-891.44
+  ;; 6-typing.watsup:949.1-950.44
   rule vrelop{C : context, sh : shape, vrelop : vrelop_(sh)}:
     `%|-%:%`(C, VRELOP_instr(sh, vrelop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:893.1-894.47
+  ;; 6-typing.watsup:952.1-953.47
   rule vshiftop{C : context, sh : ishape, vshiftop : vshiftop_(sh)}:
     `%|-%:%`(C, VSHIFTOP_instr(sh, vshiftop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype I32_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:896.1-897.33
+  ;; 6-typing.watsup:955.1-956.33
   rule vbitmask{C : context, sh : ishape}:
     `%|-%:%`(C, VBITMASK_instr(sh), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:899.1-900.39
+  ;; 6-typing.watsup:958.1-959.39
   rule vswizzle{C : context, sh : ishape}:
     `%|-%:%`(C, VSWIZZLE_instr(sh), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:902.1-904.29
+  ;; 6-typing.watsup:961.1-963.29
   rule vshuffle{C : context, sh : ishape, i* : nat*}:
     `%|-%:%`(C, VSHUFFLE_instr(sh, `%`_laneidx(i)*{i : nat}), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
     -- (if (i < (2 * $dim((sh : ishape <: shape))!`%`_dim.0)))*{i : nat}
 
-  ;; 6-typing.watsup:906.1-907.44
+  ;; 6-typing.watsup:965.1-966.44
   rule vsplat{C : context, sh : shape}:
     `%|-%:%`(C, VSPLAT_instr(sh), `%->_%%`_instrtype(`%`_resulttype([($unpackshape(sh) : numtype <: valtype)]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:909.1-911.21
+  ;; 6-typing.watsup:968.1-970.21
   rule vextract_lane{C : context, sh : shape, sx? : sx?, i : nat}:
     `%|-%:%`(C, VEXTRACT_LANE_instr(sh, sx?{sx : sx}, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([($unpackshape(sh) : numtype <: valtype)])))
     -- if (i < $dim(sh)!`%`_dim.0)
 
-  ;; 6-typing.watsup:913.1-915.21
+  ;; 6-typing.watsup:972.1-974.21
   rule vreplace_lane{C : context, sh : shape, i : nat}:
     `%|-%:%`(C, VREPLACE_LANE_instr(sh, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([V128_valtype ($unpackshape(sh) : numtype <: valtype)]), [], `%`_resulttype([V128_valtype])))
     -- if (i < $dim(sh)!`%`_dim.0)
 
-  ;; 6-typing.watsup:917.1-918.50
+  ;; 6-typing.watsup:976.1-977.50
   rule vextunop{C : context, sh_1 : ishape, sh_2 : ishape, vextunop : vextunop__(sh_2, sh_1)}:
     `%|-%:%`(C, VEXTUNOP_instr(sh_1, sh_2, vextunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:920.1-921.57
+  ;; 6-typing.watsup:979.1-980.57
   rule vextbinop{C : context, sh_1 : ishape, sh_2 : ishape, vextbinop : vextbinop__(sh_2, sh_1)}:
     `%|-%:%`(C, VEXTBINOP_instr(sh_1, sh_2, vextbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:923.1-924.48
+  ;; 6-typing.watsup:982.1-983.48
   rule vnarrow{C : context, sh_1 : ishape, sh_2 : ishape, sx : sx}:
     `%|-%:%`(C, VNARROW_instr(sh_1, sh_2, sx), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:926.1-927.58
+  ;; 6-typing.watsup:985.1-986.58
   rule vcvtop{C : context, sh_1 : shape, sh_2 : shape, vcvtop : vcvtop__(sh_2, sh_1), half? : half__(sh_2, sh_1)?, zero? : zero__(sh_2, sh_1)?}:
     `%|-%:%`(C, VCVTOP_instr(sh_1, sh_2, vcvtop, half?{half : half__(sh_2, sh_1)}, zero?{zero : zero__(sh_2, sh_1)}), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:932.1-934.28
+  ;; 6-typing.watsup:991.1-993.28
   rule local.get{C : context, x : idx, t : valtype}:
     `%|-%:%`(C, LOCAL.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([t])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(SET_init, t))
 
-  ;; 6-typing.watsup:936.1-938.29
+  ;; 6-typing.watsup:995.1-997.29
   rule local.set{C : context, x : idx, t : valtype, init : init}:
     `%|-%:%`(C, LOCAL.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [x], `%`_resulttype([])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(init, t))
 
-  ;; 6-typing.watsup:940.1-942.29
+  ;; 6-typing.watsup:999.1-1001.29
   rule local.tee{C : context, x : idx, t : valtype, init : init}:
     `%|-%:%`(C, LOCAL.TEE_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [x], `%`_resulttype([t])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(init, t))
 
-  ;; 6-typing.watsup:947.1-949.29
+  ;; 6-typing.watsup:1006.1-1008.29
   rule global.get{C : context, x : idx, t : valtype, mut : mut}:
     `%|-%:%`(C, GLOBAL.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([t])))
     -- if (C.GLOBALS_context[x!`%`_idx.0] = `%%`_globaltype(mut, t))
 
-  ;; 6-typing.watsup:951.1-953.29
+  ;; 6-typing.watsup:1010.1-1012.29
   rule global.set{C : context, x : idx, t : valtype}:
     `%|-%:%`(C, GLOBAL.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [], `%`_resulttype([])))
     -- if (C.GLOBALS_context[x!`%`_idx.0] = `%%`_globaltype(`MUT%?`_mut(?(())), t))
 
-  ;; 6-typing.watsup:958.1-960.29
+  ;; 6-typing.watsup:1017.1-1019.29
   rule table.get{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(rt : reftype <: valtype)])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:962.1-964.29
+  ;; 6-typing.watsup:1021.1-1023.29
   rule table.set{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (rt : reftype <: valtype)]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:966.1-968.29
+  ;; 6-typing.watsup:1025.1-1027.29
   rule table.size{C : context, x : idx, lim : limits, rt : reftype}:
     `%|-%:%`(C, TABLE.SIZE_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([I32_valtype])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:970.1-972.29
+  ;; 6-typing.watsup:1029.1-1031.29
   rule table.grow{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.GROW_instr(x), `%->_%%`_instrtype(`%`_resulttype([(rt : reftype <: valtype) I32_valtype]), [], `%`_resulttype([I32_valtype])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:974.1-976.29
+  ;; 6-typing.watsup:1033.1-1035.29
   rule table.fill{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (rt : reftype <: valtype) I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:978.1-982.36
+  ;; 6-typing.watsup:1037.1-1041.36
   rule table.copy{C : context, x_1 : idx, x_2 : idx, lim_1 : limits, rt_1 : reftype, lim_2 : limits, rt_2 : reftype}:
     `%|-%:%`(C, TABLE.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x_1!`%`_idx.0] = `%%`_tabletype(lim_1, rt_1))
     -- if (C.TABLES_context[x_2!`%`_idx.0] = `%%`_tabletype(lim_2, rt_2))
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
 
-  ;; 6-typing.watsup:984.1-988.36
+  ;; 6-typing.watsup:1043.1-1047.36
   rule table.init{C : context, x : idx, y : idx, lim : limits, rt_1 : reftype, rt_2 : reftype}:
     `%|-%:%`(C, TABLE.INIT_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt_1))
     -- if (C.ELEMS_context[y!`%`_idx.0] = rt_2)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
 
-  ;; 6-typing.watsup:990.1-992.24
+  ;; 6-typing.watsup:1049.1-1051.24
   rule elem.drop{C : context, x : idx, rt : reftype}:
     `%|-%:%`(C, ELEM.DROP_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
     -- if (C.ELEMS_context[x!`%`_idx.0] = rt)
 
-  ;; 6-typing.watsup:997.1-999.23
+  ;; 6-typing.watsup:1056.1-1058.23
   rule memory.size{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.SIZE_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([I32_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1001.1-1003.23
+  ;; 6-typing.watsup:1060.1-1062.23
   rule memory.grow{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.GROW_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([I32_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1005.1-1007.23
+  ;; 6-typing.watsup:1064.1-1066.23
   rule memory.fill{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1009.1-1012.27
+  ;; 6-typing.watsup:1068.1-1071.27
   rule memory.copy{C : context, x_1 : idx, x_2 : idx, mt_1 : memtype, mt_2 : memtype}:
     `%|-%:%`(C, MEMORY.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x_1!`%`_idx.0] = mt_1)
     -- if (C.MEMS_context[x_2!`%`_idx.0] = mt_2)
 
-  ;; 6-typing.watsup:1014.1-1017.24
+  ;; 6-typing.watsup:1073.1-1076.24
   rule memory.init{C : context, x : idx, y : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.INIT_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:1019.1-1021.24
+  ;; 6-typing.watsup:1078.1-1080.24
   rule data.drop{C : context, x : idx}:
     `%|-%:%`(C, DATA.DROP_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
     -- if (C.DATAS_context[x!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:1032.1-1035.43
+  ;; 6-typing.watsup:1091.1-1094.43
   rule load-val{C : context, nt : numtype, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, LOAD_instr(nt, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(nt : numtype <: valtype)])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($size(nt) / 8))
 
-  ;; 6-typing.watsup:1037.1-1040.35
+  ;; 6-typing.watsup:1096.1-1099.35
   rule load-pack{C : context, Inn : Inn, M : M, sx : sx, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, LOAD_instr((Inn : Inn <: numtype), ?(`%%`_loadop_(`%`_sz(M), sx)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(Inn : Inn <: valtype)])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (M / 8))
 
-  ;; 6-typing.watsup:1051.1-1054.43
+  ;; 6-typing.watsup:1110.1-1113.43
   rule store-val{C : context, nt : numtype, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, STORE_instr(nt, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (nt : numtype <: valtype)]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($size(nt) / 8))
 
-  ;; 6-typing.watsup:1056.1-1059.35
+  ;; 6-typing.watsup:1115.1-1118.35
   rule store-pack{C : context, Inn : Inn, M : M, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, STORE_instr((Inn : Inn <: numtype), ?(`%`_sz(M)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (Inn : Inn <: valtype)]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (M / 8))
 
-  ;; 6-typing.watsup:1061.1-1064.46
+  ;; 6-typing.watsup:1120.1-1123.46
   rule vload-val{C : context, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($vsize(V128_vectype) / 8))
 
-  ;; 6-typing.watsup:1066.1-1069.39
+  ;; 6-typing.watsup:1125.1-1128.39
   rule vload-pack{C : context, M : M, N : N, sx : sx, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(M), N, sx)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ((M / 8) * N))
 
-  ;; 6-typing.watsup:1071.1-1074.35
+  ;; 6-typing.watsup:1130.1-1133.35
   rule vload-splat{C : context, N : N, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(N))), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
 
-  ;; 6-typing.watsup:1076.1-1079.35
+  ;; 6-typing.watsup:1135.1-1138.35
   rule vload-zero{C : context, N : N, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(N))), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
 
-  ;; 6-typing.watsup:1081.1-1085.21
+  ;; 6-typing.watsup:1140.1-1144.21
   rule vload_lane{C : context, N : N, x : idx, memarg : memarg, i : nat, mt : memtype}:
     `%|-%:%`(C, VLOAD_LANE_instr(V128_vectype, `%`_sz(N), x, memarg, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
     -- if (i < (128 / N))
 
-  ;; 6-typing.watsup:1087.1-1090.46
+  ;; 6-typing.watsup:1146.1-1149.46
   rule vstore{C : context, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VSTORE_instr(V128_vectype, x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($vsize(V128_vectype) / 8))
 
-  ;; 6-typing.watsup:1092.1-1096.21
+  ;; 6-typing.watsup:1151.1-1155.21
   rule vstore_lane{C : context, N : N, x : idx, memarg : memarg, i : nat, mt : memtype}:
     `%|-%:%`(C, VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, memarg, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
     -- if (i < (128 / N))
 
-;; 6-typing.watsup:523.1-523.96
+;; 6-typing.watsup:544.1-544.96
 relation Instrs_ok: `%|-%:%`(context, instr*, instrtype)
-  ;; 6-typing.watsup:536.1-537.24
+  ;; 6-typing.watsup:557.1-558.24
   rule empty{C : context}:
     `%|-%:%`(C, [], `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
 
-  ;; 6-typing.watsup:540.1-544.82
+  ;; 6-typing.watsup:561.1-565.82
   rule seq{C : context, instr_1 : instr, instr_2* : instr*, t_1* : valtype*, x_1* : idx*, x_2* : idx*, t_3* : valtype*, t_2* : valtype*, init* : init*, t* : valtype*}:
     `%|-%:%`(C, [instr_1] :: instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx} :: x_2*{x_2 : localidx}, `%`_resulttype(t_3*{t_3 : valtype})))
     -- Instr_ok: `%|-%:%`(C, instr_1, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
     -- (if (C.LOCALS_context[x_1!`%`_idx.0] = `%%`_localtype(init, t)))*{init : init, t : valtype, x_1 : idx}
     -- Instrs_ok: `%|-%:%`($with_locals(C, x_1*{x_1 : localidx}, `%%`_localtype(SET_init, t)*{t : valtype}), instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_2*{t_2 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_3*{t_3 : valtype})))
 
-  ;; 6-typing.watsup:546.1-550.33
+  ;; 6-typing.watsup:567.1-571.33
   rule sub{C : context, instr* : instr*, it' : instrtype, it : instrtype}:
     `%|-%:%`(C, instr*{instr : instr}, it')
     -- Instrs_ok: `%|-%:%`(C, instr*{instr : instr}, it)
     -- Instrtype_sub: `%|-%<:%`(C, it, it')
     -- Instrtype_ok: `%|-%:OK`(C, it')
 
-  ;; 6-typing.watsup:553.1-556.33
+  ;; 6-typing.watsup:574.1-577.33
   rule frame{C : context, instr* : instr*, t* : valtype*, t_1* : valtype*, x* : idx*, t_2* : valtype*}:
     `%|-%:%`(C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t*{t : valtype} :: t_2*{t_2 : valtype})))
     -- Instrs_ok: `%|-%:%`(C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
@@ -4818,7 +5015,7 @@ relation Type_ok: `%|-%:%`(context, type, deftype*)
     `%|-%:%`(C, TYPE_type(rectype), dt*{dt : deftype})
     -- if (x = `%`_idx(|C.TYPES_context|))
     -- if (dt*{dt : deftype} = $rolldt(x, rectype))
-    -- Rectype_ok: `%|-%:%`(C ++ {TYPES dt*{dt : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rectype, OK_oktypeidx(x))
+    -- Rectype_ok: `%|-%:%`(C ++ {TYPES dt*{dt : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rectype, OK_oktypeidx(x))
 
 ;; 6-typing.watsup
 relation Local_ok: `%|-%:%`(context, local, localtype)
@@ -4839,7 +5036,7 @@ relation Func_ok: `%|-%:%`(context, func, deftype)
     `%|-%:%`(C, FUNC_func(x, local*{local : local}, expr), C.TYPES_context[x!`%`_idx.0])
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
     -- (Local_ok: `%|-%:%`(C, local, lct))*{lct : localtype, local : local}
-    -- Expr_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS `%%`_localtype(SET_init, t_1)*{t_1 : valtype} :: lct*{lct : localtype}, LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(`%`_resulttype(t_2*{t_2 : valtype})), REFS []}, expr, `%`_resulttype(t_2*{t_2 : valtype}))
+    -- Expr_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS `%%`_localtype(SET_init, t_1)*{t_1 : valtype} :: lct*{lct : localtype}, LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(`%`_resulttype(t_2*{t_2 : valtype})), REFS []}, expr, `%`_resulttype(t_2*{t_2 : valtype}))
 
 ;; 6-typing.watsup
 relation Global_ok: `%|-%:%`(context, global, globaltype)
@@ -4866,6 +5063,13 @@ relation Mem_ok: `%|-%:%`(context, mem, memtype)
     `%|-%:%`(C, MEMORY_mem(memtype), memtype)
     -- Memtype_ok: `%|-%:OK`(C, memtype)
 
+;; 6-typing.watsup
+relation Tag_ok: `%|-%:%`(context, tag, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, x : idx, functype : functype}:
+    `%|-%:%`(C, TAG_tag(x), C.TYPES_context[x!`%`_idx.0])
+    -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(functype))
+
 ;; 6-typing.watsup
 relation Elemmode_ok: `%|-%:%`(context, elemmode, elemtype)
   ;; 6-typing.watsup
@@ -4947,6 +5151,11 @@ relation Externidx_ok: `%|-%:%`(context, externidx, externtype)
     `%|-%:%`(C, MEM_externidx(x), MEM_externtype(mt))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, x : idx, at : tagtype}:
+    `%|-%:%`(C, TAG_externidx(x), TAG_externtype((at : deftype <: typeuse)))
+    -- if (C.TAGS_context[x!`%`_idx.0] = at)
+
 ;; 6-typing.watsup
 relation Export_ok: `%|-%:%%`(context, export, name, externtype)
   ;; 6-typing.watsup
@@ -4957,33 +5166,33 @@ relation Export_ok: `%|-%:%%`(context, export, name, externtype)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:1288.1-1288.100
+;; 6-typing.watsup:1356.1-1356.100
 relation Globals_ok: `%|-%:%`(context, global*, globaltype*)
-  ;; 6-typing.watsup:1330.1-1331.17
+  ;; 6-typing.watsup:1400.1-1401.17
   rule empty{C : context}:
     `%|-%:%`(C, [], [])
 
-  ;; 6-typing.watsup:1333.1-1336.54
+  ;; 6-typing.watsup:1403.1-1406.54
   rule cons{C : context, global_1 : global, global : global, gt_1 : globaltype, gt* : globaltype*}:
     `%|-%:%`(C, [global_1] :: global*{}, [gt_1] :: gt*{gt : globaltype})
     -- Global_ok: `%|-%:%`(C, global, gt_1)
-    -- Globals_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [gt_1], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, global*{}, gt*{gt : globaltype})
+    -- Globals_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [gt_1], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, global*{}, gt*{gt : globaltype})
 }
 
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:1287.1-1287.98
+;; 6-typing.watsup:1355.1-1355.98
 relation Types_ok: `%|-%:%`(context, type*, deftype*)
-  ;; 6-typing.watsup:1322.1-1323.17
+  ;; 6-typing.watsup:1392.1-1393.17
   rule empty{C : context}:
     `%|-%:%`(C, [], [])
 
-  ;; 6-typing.watsup:1325.1-1328.49
+  ;; 6-typing.watsup:1395.1-1398.49
   rule cons{C : context, type_1 : type, type* : type*, dt_1* : deftype*, dt* : deftype*}:
     `%|-%:%`(C, [type_1] :: type*{type : type}, dt_1*{dt_1 : deftype} :: dt*{dt : deftype})
     -- Type_ok: `%|-%:%`(C, type_1, dt_1*{dt_1 : deftype})
-    -- Types_ok: `%|-%:%`(C ++ {TYPES dt_1*{dt_1 : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt*{dt : deftype})
+    -- Types_ok: `%|-%:%`(C ++ {TYPES dt_1*{dt_1 : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt*{dt : deftype})
 }
 
 ;; 6-typing.watsup
@@ -4993,31 +5202,33 @@ syntax nonfuncs =
 ;; 6-typing.watsup
 def $funcidx_nonfuncs(nonfuncs : nonfuncs) : funcidx*
   ;; 6-typing.watsup
-  def $funcidx_nonfuncs{global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*}(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})) = $funcidx_module(MODULE_module([], [], [], global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, ?(), []))
+  def $funcidx_nonfuncs{global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*}(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})) = $funcidx_module(MODULE_module([], [], [], global*{global : global}, table*{table : table}, mem*{mem : mem}, [], elem*{elem : elem}, data*{data : data}, ?(), []))
 
 ;; 6-typing.watsup
 relation Module_ok: `|-%:%`(module, moduletype)
   ;; 6-typing.watsup
-  rule _{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, C : context, xt_I* : externtype*, xt_E* : externtype*, dt'* : deftype*, C' : context, gt* : globaltype*, tt* : tabletype*, mt* : memtype*, dt* : deftype*, rt* : reftype*, ok* : datatype*, nm* : name*, dt_I* : deftype*, gt_I* : globaltype*, tt_I* : tabletype*, mt_I* : memtype*, x* : idx*}:
-    `|-%:%`(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}), $clos_moduletype(C, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype})))
-    -- Types_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt'*{dt' : deftype})
-    -- (Import_ok: `%|-%:%`({TYPES dt'*{dt' : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, import, xt_I))*{import : import, xt_I : externtype}
+  rule _{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, C : context, xt_I* : externtype*, xt_E* : externtype*, dt'* : deftype*, C' : context, gt* : globaltype*, tt* : tabletype*, mt* : memtype*, at* : tagtype*, dt* : deftype*, rt* : reftype*, ok* : datatype*, nm* : name*, dt_I* : deftype*, gt_I* : globaltype*, tt_I* : tabletype*, mt_I* : memtype*, at_I* : tagtype*, x* : idx*}:
+    `|-%:%`(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}), $clos_moduletype(C, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype})))
+    -- Types_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt'*{dt' : deftype})
+    -- (Import_ok: `%|-%:%`({TYPES dt'*{dt' : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, import, xt_I))*{import : import, xt_I : externtype}
     -- Globals_ok: `%|-%:%`(C', global*{global : global}, gt*{gt : globaltype})
     -- (Table_ok: `%|-%:%`(C', table, tt))*{table : table, tt : tabletype}
     -- (Mem_ok: `%|-%:%`(C', mem, mt))*{mem : mem, mt : memtype}
+    -- (Tag_ok: `%|-%:%`(C', tag, at))*{at : tagtype, tag : tag}
     -- (Func_ok: `%|-%:%`(C, func, dt))*{dt : deftype, func : func}
     -- (Elem_ok: `%|-%:%`(C, elem, rt))*{elem : elem, rt : elemtype}
     -- (Data_ok: `%|-%:%`(C, data, ok))*{data : data, ok : datatype}
     -- (Start_ok: `%|-%:OK`(C, start))?{start : start}
     -- (Export_ok: `%|-%:%%`(C, export, nm, xt_E))*{export : export, nm : name, xt_E : externtype}
     -- if $disjoint_(syntax name, nm*{nm : name})
-    -- if (C = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype} :: gt*{gt : globaltype}, TABLES tt_I*{tt_I : tabletype} :: tt*{tt : tabletype}, MEMS mt_I*{mt_I : memtype} :: mt*{mt : memtype}, ELEMS rt*{rt : elemtype}, DATAS ok*{ok : datatype}, LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
-    -- if (C' = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype}, TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
+    -- if (C = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype} :: gt*{gt : globaltype}, TABLES tt_I*{tt_I : tabletype} :: tt*{tt : tabletype}, MEMS mt_I*{mt_I : memtype} :: mt*{mt : memtype}, TAGS at_I*{at_I : tagtype} :: at*{at : tagtype}, ELEMS rt*{rt : elemtype}, DATAS ok*{ok : datatype}, LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
+    -- if (C' = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype}, TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
     -- if (x*{x : idx} = $funcidx_nonfuncs(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})))
     -- if (dt_I*{dt_I : deftype} = $funcsxt(xt_I*{xt_I : externtype}))
     -- if (gt_I*{gt_I : globaltype} = $globalsxt(xt_I*{xt_I : externtype}))
     -- if (tt_I*{tt_I : tabletype} = $tablesxt(xt_I*{xt_I : externtype}))
     -- if (mt_I*{mt_I : memtype} = $memsxt(xt_I*{xt_I : externtype}))
+    -- if (at_I*{at_I : tagtype} = $tagsxt(xt_I*{xt_I : externtype}))
 
 ;; 7-runtime-typing.watsup
 relation Num_type: `%|-%:%`(store, num, numtype)
@@ -5059,19 +5270,23 @@ relation Ref_type: `%|-%:%`(store, ref, reftype)
     `%|-%:%`(s, REF.FUNC_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), (dt : deftype <: heaptype)))
     -- if (s.FUNCS_store[a].TYPE_funcinst = dt)
 
-  ;; 7-runtime-typing.watsup:35.1-36.39
+  ;; 7-runtime-typing.watsup:35.1-36.38
+  rule exn{s : store, a : addr}:
+    `%|-%:%`(s, REF.EXN_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), EXN_heaptype))
+
+  ;; 7-runtime-typing.watsup:38.1-39.39
   rule host{s : store, a : addr}:
     `%|-%:%`(s, REF.HOST_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), ANY_heaptype))
 
-  ;; 7-runtime-typing.watsup:38.1-39.45
+  ;; 7-runtime-typing.watsup:41.1-42.45
   rule extern{s : store, addrref : addrref}:
     `%|-%:%`(s, REF.EXTERN_ref(addrref), REF_reftype(`NULL%?`_nul(?()), EXTERN_heaptype))
 
-  ;; 7-runtime-typing.watsup:41.1-44.34
+  ;; 7-runtime-typing.watsup:44.1-47.34
   rule sub{s : store, ref : ref, rt : reftype, rt' : reftype}:
     `%|-%:%`(s, ref, rt)
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', rt)
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', rt)
 }
 
 ;; 7-runtime-typing.watsup
@@ -5094,33 +5309,38 @@ relation Val_type: `%|-%:%`(store, val, valtype)
 ;; 7-runtime-typing.watsup
 rec {
 
-;; 7-runtime-typing.watsup:64.1-64.57
-relation Externval_type: `%|-%:%`(store, externval, externtype)
-  ;; 7-runtime-typing.watsup:66.1-68.30
+;; 7-runtime-typing.watsup:67.1-67.59
+relation Externaddr_type: `%|-%:%`(store, externaddr, externtype)
+  ;; 7-runtime-typing.watsup:69.1-71.30
   rule func{s : store, a : addr, funcinst : funcinst}:
-    `%|-%:%`(s, FUNC_externval(a), FUNC_externtype((funcinst.TYPE_funcinst : deftype <: typeuse)))
+    `%|-%:%`(s, FUNC_externaddr(a), FUNC_externtype((funcinst.TYPE_funcinst : deftype <: typeuse)))
     -- if (s.FUNCS_store[a] = funcinst)
 
-  ;; 7-runtime-typing.watsup:70.1-72.34
+  ;; 7-runtime-typing.watsup:73.1-75.34
   rule global{s : store, a : addr, globalinst : globalinst}:
-    `%|-%:%`(s, GLOBAL_externval(a), GLOBAL_externtype(globalinst.TYPE_globalinst))
+    `%|-%:%`(s, GLOBAL_externaddr(a), GLOBAL_externtype(globalinst.TYPE_globalinst))
     -- if (s.GLOBALS_store[a] = globalinst)
 
-  ;; 7-runtime-typing.watsup:74.1-76.32
+  ;; 7-runtime-typing.watsup:77.1-79.32
   rule table{s : store, a : addr, tableinst : tableinst}:
-    `%|-%:%`(s, TABLE_externval(a), TABLE_externtype(tableinst.TYPE_tableinst))
+    `%|-%:%`(s, TABLE_externaddr(a), TABLE_externtype(tableinst.TYPE_tableinst))
     -- if (s.TABLES_store[a] = tableinst)
 
-  ;; 7-runtime-typing.watsup:78.1-80.28
+  ;; 7-runtime-typing.watsup:81.1-83.28
   rule mem{s : store, a : addr, meminst : meminst}:
-    `%|-%:%`(s, MEM_externval(a), MEM_externtype(meminst.TYPE_meminst))
+    `%|-%:%`(s, MEM_externaddr(a), MEM_externtype(meminst.TYPE_meminst))
     -- if (s.MEMS_store[a] = meminst)
 
-  ;; 7-runtime-typing.watsup:82.1-85.37
-  rule sub{s : store, externval : externval, xt : externtype, xt' : externtype}:
-    `%|-%:%`(s, externval, xt)
-    -- Externval_type: `%|-%:%`(s, externval, xt')
-    -- Externtype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, xt', xt)
+  ;; 7-runtime-typing.watsup:85.1-87.28
+  rule tag{s : store, a : addr, taginst : taginst}:
+    `%|-%:%`(s, TAG_externaddr(a), TAG_externtype((taginst.TYPE_taginst : deftype <: typeuse)))
+    -- if (s.TAGS_store[a] = taginst)
+
+  ;; 7-runtime-typing.watsup:89.1-92.37
+  rule sub{s : store, externaddr : externaddr, xt : externtype, xt' : externtype}:
+    `%|-%:%`(s, externaddr, xt)
+    -- Externaddr_type: `%|-%:%`(s, externaddr, xt')
+    -- Externtype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, xt', xt)
 }
 
 ;; 8-reduction.watsup
@@ -5162,15 +5382,19 @@ relation Step_pure: `%~>%`(instr*, instr*)
     `%~>%`([`LABEL_%{%}%`_instr(n, instr*{instr : instr}, (val : val <: instr)*{val : val})], (val : val <: instr)*{val : val})
 
   ;; 8-reduction.watsup
-  rule br-zero{n : n, instr'* : instr*, val'* : val*, val^n : val^n, l : labelidx, instr* : instr*}:
+  rule br-label-zero{n : n, instr'* : instr*, val'* : val*, val^n : val^n, l : labelidx, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val' : val <: instr)*{val' : val} :: (val : val <: instr)^n{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)^n{val : val} :: instr'*{instr' : instr})
     -- if (l = `%`_labelidx(0))
 
   ;; 8-reduction.watsup
-  rule br-succ{n : n, instr'* : instr*, val* : val*, l : labelidx, instr* : instr*}:
+  rule br-label-succ{n : n, instr'* : instr*, val* : val*, l : labelidx, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val : val <: instr)*{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [BR_instr(`%`_labelidx((l!`%`_labelidx.0 - 1)))])
     -- if (l!`%`_labelidx.0 > 0)
 
+  ;; 8-reduction.watsup
+  rule br-handler{n : n, catch* : catch*, val* : val*, l : labelidx, instr* : instr*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [BR_instr(l)])
+
   ;; 8-reduction.watsup
   rule br_if-true{c : num_(I32_numtype), l : labelidx}:
     `%~>%`([CONST_instr(I32_numtype, c) BR_IF_instr(l)], [BR_instr(l)])
@@ -5231,6 +5455,14 @@ relation Step_pure: `%~>%`(instr*, instr*)
   rule return-label{n : n, instr'* : instr*, val* : val*, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val : val <: instr)*{val : val} :: [RETURN_instr] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [RETURN_instr])
 
+  ;; 8-reduction.watsup
+  rule return-handler{n : n, catch* : catch*, val* : val*, instr* : instr*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val} :: [RETURN_instr] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [RETURN_instr])
+
+  ;; 8-reduction.watsup
+  rule handler-vals{n : n, catch* : catch*, val* : val*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val})], (val : val <: instr)*{val : val})
+
   ;; 8-reduction.watsup
   rule trap-vals{val* : val*, instr* : instr*}:
     `%~>%`((val : val <: instr)*{val : val} :: [TRAP_instr] :: instr*{instr : instr}, [TRAP_instr])
@@ -5521,7 +5753,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule br_on_cast-succeed{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype, rt : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) BR_ON_CAST_instr(l, rt_1, rt_2)]), [(ref : ref <: instr) BR_instr(l)])
     -- Ref_type: `%|-%:%`(s, ref, rt)
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
 
   ;; 8-reduction.watsup
   rule br_on_cast-fail{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype}:
@@ -5532,7 +5764,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule br_on_cast_fail-succeed{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype, rt : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) BR_ON_CAST_FAIL_instr(l, rt_1, rt_2)]), [(ref : ref <: instr)])
     -- Ref_type: `%|-%:%`(s, ref, rt)
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
 
   ;; 8-reduction.watsup
   rule br_on_cast_fail-fail{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype}:
@@ -5574,6 +5806,57 @@ relation Step_read: `%~>%`(config, instr*)
     `%~>%`(`%;%`_config(z, [`FRAME_%{%}%`_instr(k, f, (val' : val <: instr)*{val' : val} :: (val : val <: instr)^n{val : val} :: [REF.FUNC_ADDR_instr(a)] :: [RETURN_CALL_REF_instr(yy)] :: instr*{instr : instr})]), (val : val <: instr)^n{val : val} :: [REF.FUNC_ADDR_instr(a) CALL_REF_instr(yy)])
     -- Expand: `%~~%`($funcinst(z)[a].TYPE_funcinst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1^n{t_1 : valtype}), `%`_resulttype(t_2^m{t_2 : valtype}))))
 
+  ;; 8-reduction.watsup
+  rule throw_ref-null{z : state, ht : heaptype}:
+    `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) THROW_REF_instr]), [TRAP_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-vals{z : state, val* : val*, a : addr, instr* : instr*}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)*{val : val} :: [REF.EXN_ADDR_instr(a)] :: [THROW_REF_instr] :: instr*{instr : instr}), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+    -- if ((val*{val : val} =/= []) \/ (instr*{instr : instr} =/= []))
+
+  ;; 8-reduction.watsup
+  rule throw_ref-label{z : state, n : n, instr'* : instr*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-frame{z : state, n : n, f : frame, a : addr}:
+    `%~>%`(`%;%`_config(z, [`FRAME_%{%}%`_instr(n, f, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-empty{z : state, n : n, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [], [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch{z : state, n : n, x : idx, l : labelidx, catch'* : catch*, a : addr, val* : val*}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_catch(x, l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), (val : val <: instr)*{val : val} :: [BR_instr(l)])
+    -- if ($exninst(z)[a].TAG_exninst = $tagaddr(z)[x!`%`_idx.0])
+    -- if (val*{val : val} = $exninst(z)[a].FIELDS_exninst)
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_ref{z : state, n : n, x : idx, l : labelidx, catch'* : catch*, a : addr, val* : val*}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_REF_catch(x, l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), (val : val <: instr)*{val : val} :: [REF.EXN_ADDR_instr(a) BR_instr(l)])
+    -- if ($exninst(z)[a].TAG_exninst = $tagaddr(z)[x!`%`_idx.0])
+    -- if (val*{val : val} = $exninst(z)[a].FIELDS_exninst)
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_all{z : state, n : n, l : labelidx, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_ALL_catch(l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [BR_instr(l)])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_all_ref{z : state, n : n, l : labelidx, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_ALL_REF_catch(l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) BR_instr(l)])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-next{z : state, n : n, catch : catch, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [catch] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [`HANDLER_%{%}%`_instr(n, catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])])
+    -- otherwise
+
+  ;; 8-reduction.watsup
+  rule try_table{z : state, val^m : val^m, m : m, bt : blocktype, catch* : catch*, instr* : instr*, n : n, t_1^m : valtype^m, t_2^n : valtype^n}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)^m{val : val} :: [TRY_TABLE_instr(bt, `%`_list(catch*{catch : catch}), instr*{instr : instr})]), [`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, [`LABEL_%{%}%`_instr(n, [], (val : val <: instr)^m{val : val} :: instr*{instr : instr})])])
+    -- if ($blocktype_(z, bt) = `%->%`_functype(`%`_resulttype(t_1^m{t_1 : valtype}), `%`_resulttype(t_2^n{t_2 : valtype})))
+
   ;; 8-reduction.watsup
   rule ref.null-idx{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(($idx(x) : typevar <: heaptype))]), [REF.NULL_instr(($type(z, x) : deftype <: heaptype))])
@@ -5586,7 +5869,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule ref.test-true{s : store, f : frame, ref : ref, rt : reftype, rt' : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) REF.TEST_instr(rt)]), [CONST_instr(I32_numtype, `%`_num_(1))])
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
 
   ;; 8-reduction.watsup
   rule ref.test-false{s : store, f : frame, ref : ref, rt : reftype}:
@@ -5597,7 +5880,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule ref.cast-succeed{s : store, f : frame, ref : ref, rt : reftype, rt' : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) REF.CAST_instr(rt)]), [(ref : ref <: instr)])
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
 
   ;; 8-reduction.watsup
   rule ref.cast-fail{s : store, f : frame, ref : ref, rt : reftype}:
@@ -6012,135 +6295,142 @@ relation Step: `%~>%`(config, config)
     `%~>%`(`%;%`_config(z, instr*{instr : instr}), `%;%`_config(z, instr'*{instr' : instr}))
     -- Step_read: `%~>%`(`%;%`_config(z, instr*{instr : instr}), instr'*{instr' : instr})
 
-  ;; 8-reduction.watsup:225.1-227.36
+  ;; 8-reduction.watsup:218.1-223.49
+  rule throw{z : state, val^n : val^n, n : n, x : idx, exn : exninst, a : addr, t^n : valtype^n}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [THROW_instr(x)]), `%;%`_config($add_exninst(z, [exn]), [REF.EXN_ADDR_instr(a) THROW_REF_instr]))
+    -- Expand: `%~~%`($tag(z, x).TYPE_taginst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t^n{t : valtype}), `%`_resulttype([]))))
+    -- if (a = |$exninst(z)|)
+    -- if (exn = {TAG $tagaddr(z)[x!`%`_idx.0], FIELDS val^n{val : val}})
+
+  ;; 8-reduction.watsup:285.1-287.36
   rule ctxt-label{z : state, n : n, instr_0* : instr*, instr* : instr*, z' : state, instr'* : instr*}:
     `%~>%`(`%;%`_config(z, [`LABEL_%{%}%`_instr(n, instr_0*{instr_0 : instr}, instr*{instr : instr})]), `%;%`_config(z', [`LABEL_%{%}%`_instr(n, instr_0*{instr_0 : instr}, instr'*{instr' : instr})]))
     -- Step: `%~>%`(`%;%`_config(z, instr*{instr : instr}), `%;%`_config(z', instr'*{instr' : instr}))
 
-  ;; 8-reduction.watsup:229.1-231.44
+  ;; 8-reduction.watsup:289.1-291.44
   rule ctxt-frame{s : store, f : frame, n : n, f' : frame, instr* : instr*, s' : store, instr'* : instr*}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [`FRAME_%{%}%`_instr(n, f', instr*{instr : instr})]), `%;%`_config(`%;%`_state(s', f), [`FRAME_%{%}%`_instr(n, f', instr'*{instr' : instr})]))
     -- Step: `%~>%`(`%;%`_config(`%;%`_state(s, f'), instr*{instr : instr}), `%;%`_config(`%;%`_state(s', f'), instr'*{instr' : instr}))
 
-  ;; 8-reduction.watsup:349.1-353.65
+  ;; 8-reduction.watsup:409.1-413.65
   rule struct.new{z : state, val^n : val^n, n : n, x : idx, si : structinst, a : addr, mut^n : mut^n, zt^n : storagetype^n}:
     `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [STRUCT.NEW_instr(x)]), `%;%`_config($add_structinst(z, [si]), [REF.STRUCT_ADDR_instr(a)]))
     -- Expand: `%~~%`($type(z, x), STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)^n{mut : mut, zt : storagetype})))
     -- if (a = |$structinst(z)|)
     -- if (si = {TYPE $type(z, x), FIELDS $packfield_(zt, val)^n{val : val, zt : storagetype}})
 
-  ;; 8-reduction.watsup:369.1-370.53
+  ;; 8-reduction.watsup:429.1-430.53
   rule struct.set-null{z : state, ht : heaptype, val : val, x : idx, i : nat}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) (val : val <: instr) STRUCT.SET_instr(x, `%`_u32(i))]), `%;%`_config(z, [TRAP_instr]))
 
-  ;; 8-reduction.watsup:372.1-374.45
+  ;; 8-reduction.watsup:432.1-434.45
   rule struct.set-struct{z : state, a : addr, val : val, x : idx, i : nat, zt* : storagetype*, mut* : mut*}:
     `%~>%`(`%;%`_config(z, [REF.STRUCT_ADDR_instr(a) (val : val <: instr) STRUCT.SET_instr(x, `%`_u32(i))]), `%;%`_config($with_struct(z, a, i, $packfield_(zt*{zt : storagetype}[i], val)), []))
     -- Expand: `%~~%`($type(z, x), STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
 
-  ;; 8-reduction.watsup:387.1-392.65
+  ;; 8-reduction.watsup:447.1-452.65
   rule array.new_fixed{z : state, val^n : val^n, n : n, x : idx, ai : arrayinst, a : addr, mut : mut, zt : storagetype}:
     `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [ARRAY.NEW_FIXED_instr(x, `%`_u32(n))]), `%;%`_config($add_arrayinst(z, [ai]), [REF.ARRAY_ADDR_instr(a)]))
     -- Expand: `%~~%`($type(z, x), ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ((a = |$arrayinst(z)|) /\ (ai = {TYPE $type(z, x), FIELDS $packfield_(zt, val)^n{val : val}}))
 
-  ;; 8-reduction.watsup:432.1-433.64
+  ;; 8-reduction.watsup:492.1-493.64
   rule array.set-null{z : state, ht : heaptype, i : nat, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
 
-  ;; 8-reduction.watsup:435.1-437.39
+  ;; 8-reduction.watsup:495.1-497.39
   rule array.set-oob{z : state, a : addr, i : nat, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.ARRAY_ADDR_instr(a) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
     -- if (i >= |$arrayinst(z)[a].FIELDS_arrayinst|)
 
-  ;; 8-reduction.watsup:439.1-442.43
+  ;; 8-reduction.watsup:499.1-502.43
   rule array.set-array{z : state, a : addr, i : nat, val : val, x : idx, zt : storagetype, mut : mut}:
     `%~>%`(`%;%`_config(z, [REF.ARRAY_ADDR_instr(a) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config($with_array(z, a, i, $packfield_(zt, val)), []))
     -- Expand: `%~~%`($type(z, x), ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 8-reduction.watsup:743.1-744.56
+  ;; 8-reduction.watsup:803.1-804.56
   rule local.set{z : state, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [(val : val <: instr) LOCAL.SET_instr(x)]), `%;%`_config($with_local(z, x, val), []))
 
-  ;; 8-reduction.watsup:756.1-757.58
+  ;; 8-reduction.watsup:816.1-817.58
   rule global.set{z : state, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [(val : val <: instr) GLOBAL.SET_instr(x)]), `%;%`_config($with_global(z, x, val), []))
 
-  ;; 8-reduction.watsup:770.1-772.33
+  ;; 8-reduction.watsup:830.1-832.33
   rule table.set-oob{z : state, i : nat, ref : ref, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) (ref : ref <: instr) TABLE.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
     -- if (i >= |$table(z, x).REFS_tableinst|)
 
-  ;; 8-reduction.watsup:774.1-776.32
+  ;; 8-reduction.watsup:834.1-836.32
   rule table.set-val{z : state, i : nat, ref : ref, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) (ref : ref <: instr) TABLE.SET_instr(x)]), `%;%`_config($with_table(z, x, i, ref), []))
     -- if (i < |$table(z, x).REFS_tableinst|)
 
-  ;; 8-reduction.watsup:784.1-787.46
+  ;; 8-reduction.watsup:844.1-847.46
   rule table.grow-succeed{z : state, ref : ref, n : n, x : idx, ti : tableinst}:
     `%~>%`(`%;%`_config(z, [(ref : ref <: instr) CONST_instr(I32_numtype, `%`_num_(n)) TABLE.GROW_instr(x)]), `%;%`_config($with_tableinst(z, x, ti), [CONST_instr(I32_numtype, `%`_num_(|$table(z, x).REFS_tableinst|))]))
     -- if (ti = $growtable($table(z, x), n, ref))
 
-  ;; 8-reduction.watsup:789.1-790.81
+  ;; 8-reduction.watsup:849.1-850.81
   rule table.grow-fail{z : state, ref : ref, n : n, x : idx}:
     `%~>%`(`%;%`_config(z, [(ref : ref <: instr) CONST_instr(I32_numtype, `%`_num_(n)) TABLE.GROW_instr(x)]), `%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_($invsigned_(32, - (1 : nat <: int))))]))
 
-  ;; 8-reduction.watsup:850.1-851.51
+  ;; 8-reduction.watsup:910.1-911.51
   rule elem.drop{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [ELEM.DROP_instr(x)]), `%;%`_config($with_elem(z, x, []), []))
 
-  ;; 8-reduction.watsup:934.1-937.60
+  ;; 8-reduction.watsup:994.1-997.60
   rule store-num-oob{z : state, i : nat, nt : numtype, c : num_(nt), x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr(nt, c) STORE_instr(nt, ?(), x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + ($size(nt) / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:939.1-943.29
+  ;; 8-reduction.watsup:999.1-1003.29
   rule store-num-val{z : state, i : nat, nt : numtype, c : num_(nt), x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr(nt, c) STORE_instr(nt, ?(), x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), ($size(nt) / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $nbytes_(nt, c))
 
-  ;; 8-reduction.watsup:945.1-948.52
+  ;; 8-reduction.watsup:1005.1-1008.52
   rule store-pack-oob{z : state, i : nat, Inn : Inn, c : num_((Inn : Inn <: numtype)), nt : numtype, n : n, x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr((Inn : Inn <: numtype), c) STORE_instr(nt, ?(`%`_sz(n)), x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + (n / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:950.1-954.52
+  ;; 8-reduction.watsup:1010.1-1014.52
   rule store-pack-val{z : state, i : nat, Inn : Inn, c : num_((Inn : Inn <: numtype)), nt : numtype, n : n, x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr((Inn : Inn <: numtype), c) STORE_instr(nt, ?(`%`_sz(n)), x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), (n / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $ibytes_(n, $wrap__($size((Inn : Inn <: numtype)), n, c)))
 
-  ;; 8-reduction.watsup:956.1-958.63
+  ;; 8-reduction.watsup:1016.1-1018.63
   rule vstore-oob{z : state, i : nat, c : vec_(V128_Vnn), x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_instr(V128_vectype, x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + ($vsize(V128_vectype) / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:960.1-962.31
+  ;; 8-reduction.watsup:1020.1-1022.31
   rule vstore-val{z : state, i : nat, c : vec_(V128_Vnn), x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_instr(V128_vectype, x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), ($vsize(V128_vectype) / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $vbytes_(V128_vectype, c))
 
-  ;; 8-reduction.watsup:965.1-967.50
+  ;; 8-reduction.watsup:1025.1-1027.50
   rule vstore_lane-oob{z : state, i : nat, c : vec_(V128_Vnn), N : N, x : idx, ao : memarg, j : nat}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, ao, `%`_laneidx(j))]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + N) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:969.1-973.49
+  ;; 8-reduction.watsup:1029.1-1033.49
   rule vstore_lane-val{z : state, i : nat, c : vec_(V128_Vnn), N : N, x : idx, ao : memarg, j : nat, b* : byte*, Jnn : Jnn, M : M}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, ao, `%`_laneidx(j))]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), (N / 8), b*{b : byte}), []))
     -- if (N = $lsize((Jnn : Jnn <: lanetype)))
     -- if (M = (128 / N))
     -- if (b*{b : byte} = $ibytes_(N, `%`_iN($lanes_(`%X%`_shape((Jnn : Jnn <: lanetype), `%`_dim(M)), c)[j]!`%`_lane_.0)))
 
-  ;; 8-reduction.watsup:981.1-984.37
+  ;; 8-reduction.watsup:1041.1-1044.37
   rule memory.grow-succeed{z : state, n : n, x : idx, mi : meminst}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(n)) MEMORY.GROW_instr(x)]), `%;%`_config($with_meminst(z, x, mi), [CONST_instr(I32_numtype, `%`_num_((|$mem(z, x).BYTES_meminst| / (64 * $Ki))))]))
     -- if (mi = $growmem($mem(z, x), n))
 
-  ;; 8-reduction.watsup:986.1-987.78
+  ;; 8-reduction.watsup:1046.1-1047.78
   rule memory.grow-fail{z : state, n : n, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(n)) MEMORY.GROW_instr(x)]), `%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_($invsigned_(32, - (1 : nat <: int))))]))
 
-  ;; 8-reduction.watsup:1047.1-1048.51
+  ;; 8-reduction.watsup:1107.1-1108.51
   rule data.drop{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [DATA.DROP_instr(x)]), `%;%`_config($with_data(z, x, []), []))
 }
@@ -6186,7 +6476,7 @@ def $alloctypes(type*) : deftype*
 ;; 9-module.watsup
 def $allocfunc(store : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst) : (store, funcaddr)
   ;; 9-module.watsup
-  def $allocfunc{s : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst, funcinst : funcinst}(s, deftype, funccode, moduleinst) = (s ++ {FUNCS [funcinst], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.FUNCS_store|)
+  def $allocfunc{s : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst, funcinst : funcinst}(s, deftype, funccode, moduleinst) = (s ++ {FUNCS [funcinst], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.FUNCS_store|)
     -- if (funcinst = {TYPE deftype, MODULE moduleinst, CODE funccode})
 
 ;; 9-module.watsup
@@ -6205,7 +6495,7 @@ def $allocfuncs(store : store, deftype*, funccode*, moduleinst*) : (store, funca
 ;; 9-module.watsup
 def $allocglobal(store : store, globaltype : globaltype, val : val) : (store, globaladdr)
   ;; 9-module.watsup
-  def $allocglobal{s : store, globaltype : globaltype, val : val, globalinst : globalinst}(s, globaltype, val) = (s ++ {FUNCS [], GLOBALS [globalinst], TABLES [], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.GLOBALS_store|)
+  def $allocglobal{s : store, globaltype : globaltype, val : val, globalinst : globalinst}(s, globaltype, val) = (s ++ {FUNCS [], GLOBALS [globalinst], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.GLOBALS_store|)
     -- if (globalinst = {TYPE globaltype, VALUE val})
 
 ;; 9-module.watsup
@@ -6224,7 +6514,7 @@ def $allocglobals(store : store, globaltype*, val*) : (store, globaladdr*)
 ;; 9-module.watsup
 def $alloctable(store : store, tabletype : tabletype, ref : ref) : (store, tableaddr)
   ;; 9-module.watsup
-  def $alloctable{s : store, i : nat, j : nat, rt : reftype, ref : ref, tableinst : tableinst}(s, `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), ref) = (s ++ {FUNCS [], GLOBALS [], TABLES [tableinst], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.TABLES_store|)
+  def $alloctable{s : store, i : nat, j : nat, rt : reftype, ref : ref, tableinst : tableinst}(s, `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), ref) = (s ++ {FUNCS [], GLOBALS [], TABLES [tableinst], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.TABLES_store|)
     -- if (tableinst = {TYPE `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), REFS ref^i{}})
 
 ;; 9-module.watsup
@@ -6243,7 +6533,7 @@ def $alloctables(store : store, tabletype*, ref*) : (store, tableaddr*)
 ;; 9-module.watsup
 def $allocmem(store : store, memtype : memtype) : (store, memaddr)
   ;; 9-module.watsup
-  def $allocmem{s : store, i : nat, j : nat, meminst : meminst}(s, `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)))) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [meminst], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.MEMS_store|)
+  def $allocmem{s : store, i : nat, j : nat, meminst : meminst}(s, `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)))) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [meminst], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.MEMS_store|)
     -- if (meminst = {TYPE `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j))), BYTES `%`_byte(0)^(i * (64 * $Ki)){}})
 
 ;; 9-module.watsup
@@ -6259,39 +6549,58 @@ def $allocmems(store : store, memtype*) : (store, memaddr*)
     -- if ((s_2, ma'*{ma' : memaddr}) = $allocmems(s_1, memtype'*{memtype' : memtype}))
 }
 
+;; 9-module.watsup
+def $alloctag(store : store, tagtype : tagtype) : (store, tagaddr)
+  ;; 9-module.watsup
+  def $alloctag{s : store, at : tagtype, taginst : taginst}(s, at) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [taginst], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.TAGS_store|)
+    -- if (taginst = {TYPE at})
+
+;; 9-module.watsup
+rec {
+
+;; 9-module.watsup:64.1-64.82
+def $alloctags(store : store, tagtype*) : (store, tagaddr*)
+  ;; 9-module.watsup:65.1-65.34
+  def $alloctags{s : store}(s, []) = (s, [])
+  ;; 9-module.watsup:66.1-68.44
+  def $alloctags{s : store, at : tagtype, at'* : tagtype*, s_2 : store, aa : tagaddr, aa'* : tagaddr*, s_1 : store}(s, [at] :: at'*{at' : tagtype}) = (s_2, [aa] :: aa'*{aa' : tagaddr})
+    -- if ((s_1, aa) = $alloctag(s, at))
+    -- if ((s_2, aa'*{aa' : tagaddr}) = $alloctags(s_1, at'*{at' : tagtype}))
+}
+
 ;; 9-module.watsup
 def $allocelem(store : store, elemtype : elemtype, ref*) : (store, elemaddr)
   ;; 9-module.watsup
-  def $allocelem{s : store, elemtype : elemtype, ref* : ref*, eleminst : eleminst}(s, elemtype, ref*{ref : ref}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [eleminst], DATAS [], STRUCTS [], ARRAYS []}, |s.ELEMS_store|)
+  def $allocelem{s : store, elemtype : elemtype, ref* : ref*, eleminst : eleminst}(s, elemtype, ref*{ref : ref}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [eleminst], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.ELEMS_store|)
     -- if (eleminst = {TYPE elemtype, REFS ref*{ref : ref}})
 
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:64.1-64.97
+;; 9-module.watsup:75.1-75.97
 def $allocelems(store : store, elemtype*, ref**) : (store, elemaddr*)
-  ;; 9-module.watsup:65.1-65.40
+  ;; 9-module.watsup:76.1-76.40
   def $allocelems{s : store}(s, [], []) = (s, [])
-  ;; 9-module.watsup:66.1-68.55
+  ;; 9-module.watsup:77.1-79.55
   def $allocelems{s : store, rt : reftype, rt'* : reftype*, ref* : ref*, ref'** : ref**, s_2 : store, ea : elemaddr, ea'* : elemaddr*, s_1 : store}(s, [rt] :: rt'*{rt' : elemtype}, [ref*{ref : ref}] :: ref'*{ref' : ref}*{ref' : ref}) = (s_2, [ea] :: ea'*{ea' : elemaddr})
     -- if ((s_1, ea) = $allocelem(s, rt, ref*{ref : ref}))
-    -- if ((s_2, ea'*{ea' : elemaddr}) = $allocelems(s_2, rt'*{rt' : elemtype}, ref'*{ref' : ref}*{ref' : ref}))
+    -- if ((s_2, ea'*{ea' : elemaddr}) = $allocelems(s_1, rt'*{rt' : elemtype}, ref'*{ref' : ref}*{ref' : ref}))
 }
 
 ;; 9-module.watsup
 def $allocdata(store : store, datatype : datatype, byte*) : (store, dataaddr)
   ;; 9-module.watsup
-  def $allocdata{s : store, byte* : byte*, datainst : datainst}(s, OK_datatype, byte*{byte : byte}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [datainst], STRUCTS [], ARRAYS []}, |s.DATAS_store|)
+  def $allocdata{s : store, byte* : byte*, datainst : datainst}(s, OK_datatype, byte*{byte : byte}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [datainst], STRUCTS [], ARRAYS [], EXNS []}, |s.DATAS_store|)
     -- if (datainst = {BYTES byte*{byte : byte}})
 
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:75.1-75.98
+;; 9-module.watsup:86.1-86.98
 def $allocdatas(store : store, datatype*, byte**) : (store, dataaddr*)
-  ;; 9-module.watsup:76.1-76.40
+  ;; 9-module.watsup:87.1-87.40
   def $allocdatas{s : store}(s, [], []) = (s, [])
-  ;; 9-module.watsup:77.1-79.53
+  ;; 9-module.watsup:88.1-90.53
   def $allocdatas{s : store, ok : datatype, ok'* : datatype*, b* : byte*, b'** : byte**, s_2 : store, da : dataaddr, da'* : dataaddr*, s_1 : store}(s, [ok] :: ok'*{ok' : datatype}, [b*{b : byte}] :: b'*{b' : byte}*{b' : byte}) = (s_2, [da] :: da'*{da' : dataaddr})
     -- if ((s_1, da) = $allocdata(s, ok, b*{b : byte}))
     -- if ((s_2, da'*{da' : dataaddr}) = $allocdatas(s_1, ok'*{ok' : datatype}, b'*{b' : byte}*{b' : byte}))
@@ -6300,13 +6609,15 @@ def $allocdatas(store : store, datatype*, byte**) : (store, dataaddr*)
 ;; 9-module.watsup
 def $allocexport(moduleinst : moduleinst, export : export) : exportinst
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, FUNC_externidx(x))) = {NAME name, VALUE FUNC_externval(moduleinst.FUNCS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, FUNC_externidx(x))) = {NAME name, ADDR FUNC_externaddr(moduleinst.FUNCS_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, GLOBAL_externidx(x))) = {NAME name, VALUE GLOBAL_externval(moduleinst.GLOBALS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, GLOBAL_externidx(x))) = {NAME name, ADDR GLOBAL_externaddr(moduleinst.GLOBALS_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TABLE_externidx(x))) = {NAME name, VALUE TABLE_externval(moduleinst.TABLES_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TABLE_externidx(x))) = {NAME name, ADDR TABLE_externaddr(moduleinst.TABLES_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, MEM_externidx(x))) = {NAME name, VALUE MEM_externval(moduleinst.MEMS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, MEM_externidx(x))) = {NAME name, ADDR MEM_externaddr(moduleinst.MEMS_moduleinst[x!`%`_idx.0])}
+  ;; 9-module.watsup
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TAG_externidx(x))) = {NAME name, ADDR TAG_externaddr(moduleinst.TAGS_moduleinst[x!`%`_idx.0])}
 
 ;; 9-module.watsup
 def $allocexports(moduleinst : moduleinst, export*) : exportinst*
@@ -6314,35 +6625,39 @@ def $allocexports(moduleinst : moduleinst, export*) : exportinst*
   def $allocexports{moduleinst : moduleinst, export* : export*}(moduleinst, export*{export : export}) = $allocexport(moduleinst, export)*{export : export}
 
 ;; 9-module.watsup
-def $allocmodule(store : store, module : module, externval*, val*, ref*, ref**) : (store, moduleinst)
+def $allocmodule(store : store, module : module, externaddr*, val*, ref*, ref**) : (store, moduleinst)
   ;; 9-module.watsup
-  def $allocmodule{s : store, module : module, externval* : externval*, val_G* : val*, ref_T* : ref*, ref_E** : ref**, s_6 : store, moduleinst : moduleinst, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, x* : idx*, local** : local**, expr_F* : expr*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, memtype* : memtype*, elemtype* : elemtype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, fa_I* : funcaddr*, ga_I* : globaladdr*, ta_I* : tableaddr*, ma_I* : memaddr*, fa* : funcaddr*, i_F^|func*{func : func}| : nat^|func*{func : func}|, ga* : globaladdr*, i_G^|global*{global : global}| : nat^|global*{global : global}|, ta* : tableaddr*, i_T^|table*{table : table}| : nat^|table*{table : table}|, ma* : memaddr*, i_M^|mem*{mem : mem}| : nat^|mem*{mem : mem}|, ea* : elemaddr*, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, da* : dataaddr*, i_D^|data*{data : data}| : nat^|data*{data : data}|, dt* : deftype*, s_1 : store, s_2 : store, s_3 : store, s_4 : store, s_5 : store, xi* : exportinst*}(s, module, externval*{externval : externval}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}) = (s_6, moduleinst)
-    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
+  def $allocmodule{s : store, module : module, externaddr* : externaddr*, val_G* : val*, ref_T* : ref*, ref_E** : ref**, s_7 : store, moduleinst : moduleinst, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, x* : idx*, local** : local**, expr_F* : expr*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, memtype* : memtype*, y* : idx*, elemtype* : elemtype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, fa_I* : funcaddr*, ga_I* : globaladdr*, ta_I* : tableaddr*, ma_I* : memaddr*, aa_I* : tagaddr*, fa* : nat*, i_F^|func*{func : func}| : nat^|func*{func : func}|, ga* : nat*, i_G^|global*{global : global}| : nat^|global*{global : global}|, ta* : nat*, i_T^|table*{table : table}| : nat^|table*{table : table}|, aa* : nat*, i_A^|tag*{tag : tag}| : nat^|tag*{tag : tag}|, ma* : nat*, i_M^|mem*{mem : mem}| : nat^|mem*{mem : mem}|, ea* : nat*, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, da* : nat*, i_D^|data*{data : data}| : nat^|data*{data : data}|, dt* : deftype*, s_1 : store, s_2 : store, s_3 : store, s_4 : store, s_5 : store, s_6 : store, xi* : exportinst*}(s, module, externaddr*{externaddr : externaddr}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}) = (s_7, moduleinst)
+    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
     -- if (func*{func : func} = FUNC_func(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx})
     -- if (global*{global : global} = GLOBAL_global(globaltype, expr_G)*{expr_G : expr, globaltype : globaltype})
     -- if (table*{table : table} = TABLE_table(tabletype, expr_T)*{expr_T : expr, tabletype : tabletype})
     -- if (mem*{mem : mem} = MEMORY_mem(memtype)*{memtype : memtype})
+    -- if (tag*{tag : tag} = TAG_tag(y)*{y : typeidx})
     -- if (elem*{elem : elem} = ELEM_elem(elemtype, expr_E*{expr_E : expr}, elemmode)*{elemmode : elemmode, elemtype : reftype, expr_E : expr})
     -- if (data*{data : data} = DATA_data(byte*{byte : byte}, datamode)*{byte : byte, datamode : datamode})
-    -- if (fa_I*{fa_I : funcaddr} = $funcsxv(externval*{externval : externval}))
-    -- if (ga_I*{ga_I : globaladdr} = $globalsxv(externval*{externval : externval}))
-    -- if (ta_I*{ta_I : tableaddr} = $tablesxv(externval*{externval : externval}))
-    -- if (ma_I*{ma_I : memaddr} = $memsxv(externval*{externval : externval}))
-    -- if (fa*{fa : funcaddr} = (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat})
-    -- if (ga*{ga : globaladdr} = (|s.GLOBALS_store| + i_G)^(i_G<|global*{global : global}|){i_G : nat})
-    -- if (ta*{ta : tableaddr} = (|s.TABLES_store| + i_T)^(i_T<|table*{table : table}|){i_T : nat})
-    -- if (ma*{ma : memaddr} = (|s.MEMS_store| + i_M)^(i_M<|mem*{mem : mem}|){i_M : nat})
-    -- if (ea*{ea : elemaddr} = (|s.ELEMS_store| + i_E)^(i_E<|elem*{elem : elem}|){i_E : nat})
-    -- if (da*{da : dataaddr} = (|s.DATAS_store| + i_D)^(i_D<|data*{data : data}|){i_D : nat})
+    -- if (fa_I*{fa_I : funcaddr} = $funcsxa(externaddr*{externaddr : externaddr}))
+    -- if (ga_I*{ga_I : globaladdr} = $globalsxa(externaddr*{externaddr : externaddr}))
+    -- if (ta_I*{ta_I : tableaddr} = $tablesxa(externaddr*{externaddr : externaddr}))
+    -- if (ma_I*{ma_I : memaddr} = $memsxa(externaddr*{externaddr : externaddr}))
+    -- if (aa_I*{aa_I : tagaddr} = $tagsxa(externaddr*{externaddr : externaddr}))
+    -- if (fa*{fa : nat} = (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat})
+    -- if (ga*{ga : nat} = (|s.GLOBALS_store| + i_G)^(i_G<|global*{global : global}|){i_G : nat})
+    -- if (ta*{ta : nat} = (|s.TABLES_store| + i_T)^(i_T<|table*{table : table}|){i_T : nat})
+    -- if (aa*{aa : nat} = (|s.TAGS_store| + i_A)^(i_A<|tag*{tag : tag}|){i_A : nat})
+    -- if (ma*{ma : nat} = (|s.MEMS_store| + i_M)^(i_M<|mem*{mem : mem}|){i_M : nat})
+    -- if (ea*{ea : nat} = (|s.ELEMS_store| + i_E)^(i_E<|elem*{elem : elem}|){i_E : nat})
+    -- if (da*{da : nat} = (|s.DATAS_store| + i_D)^(i_D<|data*{data : data}|){i_D : nat})
     -- if (dt*{dt : deftype} = $alloctypes(type*{type : type}))
-    -- if ((s_1, fa*{fa : funcaddr}) = $allocfuncs(s, dt*{dt : deftype}[x!`%`_idx.0]*{x : idx}, FUNC_funccode(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx}, moduleinst^|func*{func : func}|{}))
-    -- if ((s_2, ga*{ga : globaladdr}) = $allocglobals(s_1, globaltype*{globaltype : globaltype}, val_G*{val_G : val}))
-    -- if ((s_3, ta*{ta : tableaddr}) = $alloctables(s_2, tabletype*{tabletype : tabletype}, ref_T*{ref_T : ref}))
-    -- if ((s_4, ma*{ma : memaddr}) = $allocmems(s_3, memtype*{memtype : memtype}))
-    -- if ((s_5, ea*{ea : elemaddr}) = $allocelems(s_4, elemtype*{elemtype : elemtype}, ref_E*{ref_E : ref}*{ref_E : ref}))
-    -- if ((s_6, da*{da : dataaddr}) = $allocdatas(s_5, OK_datatype^|data*{data : data}|{}, byte*{byte : byte}*{byte : byte}))
-    -- if (xi*{xi : exportinst} = $allocexports({TYPES [], FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, ELEMS [], DATAS [], EXPORTS []}, export*{export : export}))
-    -- if (moduleinst = {TYPES dt*{dt : deftype}, FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, ELEMS ea*{ea : elemaddr}, DATAS da*{da : dataaddr}, EXPORTS xi*{xi : exportinst}})
+    -- if ((s_1, fa*{fa : nat}) = $allocfuncs(s, dt*{dt : deftype}[x!`%`_idx.0]*{x : idx}, FUNC_funccode(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx}, moduleinst^|func*{func : func}|{}))
+    -- if ((s_2, ga*{ga : nat}) = $allocglobals(s_1, globaltype*{globaltype : globaltype}, val_G*{val_G : val}))
+    -- if ((s_3, ta*{ta : nat}) = $alloctables(s_2, tabletype*{tabletype : tabletype}, ref_T*{ref_T : ref}))
+    -- if ((s_4, ma*{ma : nat}) = $allocmems(s_3, memtype*{memtype : memtype}))
+    -- if ((s_5, aa*{aa : nat}) = $alloctags(s_4, dt*{dt : deftype}[y!`%`_idx.0]*{y : idx}))
+    -- if ((s_6, ea*{ea : nat}) = $allocelems(s_5, elemtype*{elemtype : elemtype}, ref_E*{ref_E : ref}*{ref_E : ref}))
+    -- if ((s_7, da*{da : nat}) = $allocdatas(s_6, OK_datatype^|data*{data : data}|{}, byte*{byte : byte}*{byte : byte}))
+    -- if (xi*{xi : exportinst} = $allocexports({TYPES [], FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, TAGS aa_I*{aa_I : tagaddr} :: aa*{aa : tagaddr}, ELEMS [], DATAS [], EXPORTS []}, export*{export : export}))
+    -- if (moduleinst = {TYPES dt*{dt : deftype}, FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, TAGS aa_I*{aa_I : tagaddr} :: aa*{aa : tagaddr}, ELEMS ea*{ea : elemaddr}, DATAS da*{da : dataaddr}, EXPORTS xi*{xi : exportinst}})
 
 ;; 9-module.watsup
 def $runelem_(elemidx : elemidx, elem : elem) : instr*
@@ -6363,11 +6678,11 @@ def $rundata_(dataidx : dataidx, data : data) : instr*
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:152.1-152.94
+;; 9-module.watsup:169.1-169.94
 def $evalglobals(state : state, globaltype*, expr*) : (state, val*)
-  ;; 9-module.watsup:153.1-153.41
+  ;; 9-module.watsup:170.1-170.41
   def $evalglobals{z : state}(z, [], []) = (z, [])
-  ;; 9-module.watsup:154.1-159.81
+  ;; 9-module.watsup:171.1-176.81
   def $evalglobals{z : state, gt : globaltype, gt'* : globaltype*, expr : expr, expr'* : expr*, z' : state, val : val, val'* : val*, s : store, f : frame, s' : store, a : addr}(z, [gt] :: gt'*{gt' : globaltype}, [expr] :: expr'*{expr' : expr}) = (z', [val] :: val'*{val' : val})
     -- Eval_expr: `%;%~>*%;%`(z, expr, z, [val])
     -- if (z = `%;%`_state(s, f))
@@ -6376,23 +6691,23 @@ def $evalglobals(state : state, globaltype*, expr*) : (state, val*)
 }
 
 ;; 9-module.watsup
-def $instantiate(store : store, module : module, externval*) : config
+def $instantiate(store : store, module : module, externaddr*) : config
   ;; 9-module.watsup
-  def $instantiate{s : store, module : module, externval* : externval*, s' : store, f : frame, instr_E* : instr*, instr_D* : instr*, instr_S? : instr?, xt_I* : externtype*, xt_E* : externtype*, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, reftype* : reftype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, x? : idx?, moduleinst_0 : moduleinst, i_F^|func*{func : func}| : nat^|func*{func : func}|, z : state, z' : state, val_G* : val*, ref_T* : ref*, ref_E** : ref**, moduleinst : moduleinst, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, i_D^|data*{data : data}| : nat^|data*{data : data}|}(s, module, externval*{externval : externval}) = `%;%`_config(`%;%`_state(s', f), instr_E*{instr_E : instr} :: instr_D*{instr_D : instr} :: instr_S?{instr_S : instr})
+  def $instantiate{s : store, module : module, externaddr* : externaddr*, s' : store, f : frame, instr_E* : instr*, instr_D* : instr*, instr_S? : instr?, xt_I* : externtype*, xt_E* : externtype*, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, reftype* : reftype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, x? : idx?, moduleinst_0 : moduleinst, i_F^|func*{func : func}| : nat^|func*{func : func}|, z : state, z' : state, val_G* : val*, ref_T* : ref*, ref_E** : ref**, moduleinst : moduleinst, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, i_D^|data*{data : data}| : nat^|data*{data : data}|}(s, module, externaddr*{externaddr : externaddr}) = `%;%`_config(`%;%`_state(s', f), instr_E*{instr_E : instr} :: instr_D*{instr_D : instr} :: instr_S?{instr_S : instr})
     -- Module_ok: `|-%:%`(module, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype}))
-    -- (Externval_type: `%|-%:%`(s, externval, xt_I))*{externval : externval, xt_I : externtype}
-    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
+    -- (Externaddr_type: `%|-%:%`(s, externaddr, xt_I))*{externaddr : externaddr, xt_I : externtype}
+    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
     -- if (global*{global : global} = GLOBAL_global(globaltype, expr_G)*{expr_G : expr, globaltype : globaltype})
     -- if (table*{table : table} = TABLE_table(tabletype, expr_T)*{expr_T : expr, tabletype : tabletype})
     -- if (elem*{elem : elem} = ELEM_elem(reftype, expr_E*{expr_E : expr}, elemmode)*{elemmode : elemmode, expr_E : expr, reftype : reftype})
     -- if (data*{data : data} = DATA_data(byte*{byte : byte}, datamode)*{byte : byte, datamode : datamode})
     -- if (start?{start : start} = START_start(x)?{x : funcidx})
-    -- if (moduleinst_0 = {TYPES $alloctypes(type*{type : type}), FUNCS $funcsxv(externval*{externval : externval}) :: (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat}, GLOBALS $globalsxv(externval*{externval : externval}), TABLES [], MEMS [], ELEMS [], DATAS [], EXPORTS []})
+    -- if (moduleinst_0 = {TYPES $alloctypes(type*{type : type}), FUNCS $funcsxa(externaddr*{externaddr : externaddr}) :: (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat}, GLOBALS $globalsxa(externaddr*{externaddr : externaddr}), TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], EXPORTS []})
     -- if (z = `%;%`_state(s, {LOCALS [], MODULE moduleinst_0}))
     -- if ((z', val_G*{val_G : val}) = $evalglobals(z, globaltype*{globaltype : globaltype}, expr_G*{expr_G : expr}))
     -- (Eval_expr: `%;%~>*%;%`(z', expr_T, z', [(ref_T : ref <: val)]))*{expr_T : expr, ref_T : ref}
     -- (Eval_expr: `%;%~>*%;%`(z', expr_E, z', [(ref_E : ref <: val)]))*{expr_E : expr, ref_E : ref}*{expr_E : expr, ref_E : ref}
-    -- if ((s', moduleinst) = $allocmodule(s, module, externval*{externval : externval}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}))
+    -- if ((s', moduleinst) = $allocmodule(s, module, externaddr*{externaddr : externaddr}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}))
     -- if (f = {LOCALS [], MODULE moduleinst})
     -- if (instr_E*{instr_E : instr} = $concat_(syntax instr, $runelem_(`%`_elemidx(i_E), elem*{elem : elem}[i_E])^(i_E<|elem*{elem : elem}|){i_E : nat}))
     -- if (instr_D*{instr_D : instr} = $concat_(syntax instr, $rundata_(`%`_dataidx(i_D), data*{data : data}[i_D])^(i_D<|data*{data : data}|){i_D : nat}))
@@ -6404,7 +6719,7 @@ def $invoke(store : store, funcaddr : funcaddr, val*) : config
   def $invoke{s : store, funcaddr : funcaddr, val* : val*, f : frame, t_1* : valtype*, t_2* : valtype*}(s, funcaddr, val*{val : val}) = `%;%`_config(`%;%`_state(s, f), (val : val <: instr)*{val : val} :: [REF.FUNC_ADDR_instr(funcaddr) CALL_REF_instr((s.FUNCS_store[funcaddr].TYPE_funcinst : deftype <: typeuse))])
     -- Expand: `%~~%`(s.FUNCS_store[funcaddr].TYPE_funcinst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
     -- (Val_type: `%|-%:%`(s, val, t_1))*{t_1 : valtype, val : val}
-    -- if (f = {LOCALS [], MODULE {TYPES [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], EXPORTS []}})
+    -- if (f = {LOCALS [], MODULE {TYPES [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], EXPORTS []}})
 
 ;; A-binary.watsup
 grammar Bbyte : byte
@@ -6507,6 +6822,11 @@ grammar Bmemidx : memidx
   ;; A-binary.watsup
   prod{x : idx} x:Bu32 => x
 
+;; A-binary.watsup
+grammar Btagidx : tagidx
+  ;; A-binary.watsup
+  prod{x : idx} x:Bu32 => x
+
 ;; A-binary.watsup
 grammar Belemidx : elemidx
   ;; A-binary.watsup
@@ -6537,6 +6857,8 @@ grammar Bexternidx : externidx
   prod{x : idx} {0x02 x:Bmemidx} => MEM_externidx(x)
   ;; A-binary.watsup
   prod{x : idx} {0x03 x:Bglobalidx} => GLOBAL_externidx(x)
+  ;; A-binary.watsup
+  prod{x : idx} {0x04 x:Btagidx} => TAG_externidx(x)
 
 ;; A-binary.watsup
 grammar Bnumtype : numtype
@@ -6556,6 +6878,8 @@ grammar Bvectype : vectype
 
 ;; A-binary.watsup
 grammar Babsheaptype : heaptype
+  ;; A-binary.watsup
+  prod 0x69 => EXN_heaptype
   ;; A-binary.watsup
   prod 0x6A => ARRAY_heaptype
   ;; A-binary.watsup
@@ -6576,6 +6900,8 @@ grammar Babsheaptype : heaptype
   prod 0x72 => NOEXTERN_heaptype
   ;; A-binary.watsup
   prod 0x73 => NOFUNC_heaptype
+  ;; A-binary.watsup
+  prod 0x74 => NOEXN_heaptype
 
 ;; A-binary.watsup
 grammar Bheaptype : heaptype
@@ -6681,6 +7007,11 @@ grammar Bmemtype : memtype
   ;; A-binary.watsup
   prod{lim : limits} lim:Blimits => `%PAGE`_memtype(lim)
 
+;; A-binary.watsup
+grammar Btagtype : typeidx
+  ;; A-binary.watsup
+  prod{x : idx} {0x00 x:Btypeidx} => x
+
 ;; A-binary.watsup
 grammar Bexterntype : externtype
   ;; A-binary.watsup
@@ -6691,6 +7022,8 @@ grammar Bexterntype : externtype
   prod{mt : memtype} {0x02 mt:Bmemtype} => MEM_externtype(mt)
   ;; A-binary.watsup
   prod{gt : globaltype} {0x03 gt:Bglobaltype} => GLOBAL_externtype(gt)
+  ;; A-binary.watsup
+  prod{x : idx} {0x04 x:Btagtype} => TAG_externtype(($idx(x) : typevar <: typeuse))
 
 ;; A-binary.watsup
 grammar Bblocktype : blocktype
@@ -6702,6 +7035,17 @@ grammar Bblocktype : blocktype
   prod{i : nat} `%`_s33((i : nat <: int)):Bs33 => _IDX_blocktype(`%`_funcidx(i))
     -- if (i >= 0)
 
+;; A-binary.watsup
+grammar Bcatch : catch
+  ;; A-binary.watsup
+  prod{x : idx, l : labelidx} {0x00 x:Btagidx l:Blabelidx} => CATCH_catch(x, l)
+  ;; A-binary.watsup
+  prod{x : idx, l : labelidx} {0x01 x:Btagidx l:Blabelidx} => CATCH_REF_catch(x, l)
+  ;; A-binary.watsup
+  prod{l : labelidx} {0x02 l:Blabelidx} => CATCH_ALL_catch(l)
+  ;; A-binary.watsup
+  prod{l : labelidx} {0x03 l:Blabelidx} => CATCH_ALL_REF_catch(l)
+
 ;; A-binary.watsup
 syntax castop = (nul, nul)
 
@@ -6736,953 +7080,959 @@ grammar Blaneidx : laneidx
 ;; A-binary.watsup
 rec {
 
-;; A-binary.watsup:963.1-973.66
+;; A-binary.watsup:981.1-991.66
 grammar Binstr : instr
-  ;; A-binary.watsup:206.5-206.24
+  ;; A-binary.watsup:214.5-214.24
   prod 0x00 => UNREACHABLE_instr
-  ;; A-binary.watsup:207.5-207.16
+  ;; A-binary.watsup:215.5-215.16
   prod 0x01 => NOP_instr
-  ;; A-binary.watsup:208.5-208.57
+  ;; A-binary.watsup:216.5-216.57
   prod{bt : blocktype, in* : instr*} {0x02 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => BLOCK_instr(bt, in*{in : instr})
-  ;; A-binary.watsup:209.5-209.56
+  ;; A-binary.watsup:217.5-217.56
   prod{bt : blocktype, in* : instr*} {0x03 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => LOOP_instr(bt, in*{in : instr})
-  ;; A-binary.watsup:210.5-210.63
+  ;; A-binary.watsup:218.5-218.63
   prod{bt : blocktype, in* : instr*} {0x04 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => `IF%%ELSE%`_instr(bt, in*{in : instr}, [])
-  ;; A-binary.watsup:211.5-215.55
+  ;; A-binary.watsup:219.5-223.55
   prod{bt : blocktype, in_1* : instr*, in_2* : instr*} {0x04 bt:Bblocktype in_1:Binstr*{in_1 : instr} 0x05 in_2:Binstr*{in_2 : instr} 0x0B} => `IF%%ELSE%`_instr(bt, in_1*{in_1 : instr}, in_2*{in_2 : instr})
-  ;; A-binary.watsup:216.5-216.29
+  ;; A-binary.watsup:224.5-224.30
+  prod{x : idx} {0x08 x:Btagidx} => THROW_instr(x)
+  ;; A-binary.watsup:225.5-225.22
+  prod 0x0A => THROW_REF_instr
+  ;; A-binary.watsup:226.5-226.29
   prod{l : labelidx} {0x0C l:Blabelidx} => BR_instr(l)
-  ;; A-binary.watsup:217.5-217.32
+  ;; A-binary.watsup:227.5-227.32
   prod{l : labelidx} {0x0D l:Blabelidx} => BR_IF_instr(l)
-  ;; A-binary.watsup:218.5-218.62
+  ;; A-binary.watsup:228.5-228.62
   prod{l* : labelidx*, l_n : labelidx} {0x0E l*{l : labelidx}:Blist(syntax labelidx, grammar Blabelidx) l_n:Blabelidx} => BR_TABLE_instr(l*{l : labelidx}, l_n)
-  ;; A-binary.watsup:219.5-219.19
+  ;; A-binary.watsup:229.5-229.19
   prod 0x0F => RETURN_instr
-  ;; A-binary.watsup:220.5-220.30
+  ;; A-binary.watsup:230.5-230.30
   prod{x : idx} {0x10 x:Bfuncidx} => CALL_instr(x)
-  ;; A-binary.watsup:221.5-221.59
+  ;; A-binary.watsup:231.5-231.59
   prod{y : idx, x : idx} {0x11 y:Btypeidx x:Btableidx} => CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse))
-  ;; A-binary.watsup:222.5-222.37
+  ;; A-binary.watsup:232.5-232.37
   prod{x : idx} {0x12 x:Bfuncidx} => RETURN_CALL_instr(x)
-  ;; A-binary.watsup:223.5-223.66
+  ;; A-binary.watsup:233.5-233.66
   prod{y : idx, x : idx} {0x13 y:Btypeidx x:Btableidx} => RETURN_CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse))
-  ;; A-binary.watsup:238.5-238.37
+  ;; A-binary.watsup:234.5-235.26
+  prod{bt : blocktype, c* : catch*, in* : instr*} {0x1F bt:Bblocktype c*{c : catch}:Blist(syntax catch, grammar Bcatch) in:Binstr*{in : instr} 0x0B} => TRY_TABLE_instr(bt, `%`_list(c*{c : catch}), in*{in : instr})
+  ;; A-binary.watsup:256.5-256.37
   prod{ht : heaptype} {0xD0 ht:Bheaptype} => REF.NULL_instr(ht)
-  ;; A-binary.watsup:239.5-239.24
+  ;; A-binary.watsup:257.5-257.24
   prod 0xD1 => REF.IS_NULL_instr
-  ;; A-binary.watsup:240.5-240.34
+  ;; A-binary.watsup:258.5-258.34
   prod{x : idx} {0xD2 x:Bfuncidx} => REF.FUNC_instr(x)
-  ;; A-binary.watsup:241.5-241.19
+  ;; A-binary.watsup:259.5-259.19
   prod 0xD3 => REF.EQ_instr
-  ;; A-binary.watsup:242.5-242.28
+  ;; A-binary.watsup:260.5-260.28
   prod 0xD4 => REF.AS_NON_NULL_instr
-  ;; A-binary.watsup:243.5-243.37
+  ;; A-binary.watsup:261.5-261.37
   prod{l : labelidx} {0xD5 l:Blabelidx} => BR_ON_NULL_instr(l)
-  ;; A-binary.watsup:244.5-244.41
+  ;; A-binary.watsup:262.5-262.41
   prod{l : labelidx} {0xD6 l:Blabelidx} => BR_ON_NON_NULL_instr(l)
-  ;; A-binary.watsup:248.5-248.43
+  ;; A-binary.watsup:266.5-266.43
   prod{x : idx} {0xFB `%`_u32(0):Bu32 x:Btypeidx} => STRUCT.NEW_instr(x)
-  ;; A-binary.watsup:249.5-249.51
+  ;; A-binary.watsup:267.5-267.51
   prod{x : idx} {0xFB `%`_u32(1):Bu32 x:Btypeidx} => STRUCT.NEW_DEFAULT_instr(x)
-  ;; A-binary.watsup:250.5-250.52
+  ;; A-binary.watsup:268.5-268.52
   prod{x : idx, i : nat} {0xFB `%`_u32(2):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(), x, `%`_u32(i))
-  ;; A-binary.watsup:251.5-251.54
+  ;; A-binary.watsup:269.5-269.54
   prod{x : idx, i : nat} {0xFB `%`_u32(3):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(S_sx), x, `%`_u32(i))
-  ;; A-binary.watsup:252.5-252.54
+  ;; A-binary.watsup:270.5-270.54
   prod{x : idx, i : nat} {0xFB `%`_u32(4):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(U_sx), x, `%`_u32(i))
-  ;; A-binary.watsup:253.5-253.52
+  ;; A-binary.watsup:271.5-271.52
   prod{x : idx, i : nat} {0xFB `%`_u32(5):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.SET_instr(x, `%`_u32(i))
-  ;; A-binary.watsup:257.5-257.42
+  ;; A-binary.watsup:275.5-275.42
   prod{x : idx} {0xFB `%`_u32(6):Bu32 x:Btypeidx} => ARRAY.NEW_instr(x)
-  ;; A-binary.watsup:258.5-258.50
+  ;; A-binary.watsup:276.5-276.50
   prod{x : idx} {0xFB `%`_u32(7):Bu32 x:Btypeidx} => ARRAY.NEW_DEFAULT_instr(x)
-  ;; A-binary.watsup:259.5-259.57
+  ;; A-binary.watsup:277.5-277.57
   prod{x : idx, n : n} {0xFB `%`_u32(8):Bu32 x:Btypeidx `%`_u32(n):Bu32} => ARRAY.NEW_FIXED_instr(x, `%`_u32(n))
-  ;; A-binary.watsup:260.5-260.60
+  ;; A-binary.watsup:278.5-278.60
   prod{x : idx, y : idx} {0xFB `%`_u32(9):Bu32 x:Btypeidx y:Bdataidx} => ARRAY.NEW_DATA_instr(x, y)
-  ;; A-binary.watsup:261.5-261.61
+  ;; A-binary.watsup:279.5-279.61
   prod{x : idx, y : idx} {0xFB `%`_u32(10):Bu32 x:Btypeidx y:Belemidx} => ARRAY.NEW_ELEM_instr(x, y)
-  ;; A-binary.watsup:262.5-262.43
+  ;; A-binary.watsup:280.5-280.43
   prod{x : idx} {0xFB `%`_u32(11):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(), x)
-  ;; A-binary.watsup:263.5-263.45
+  ;; A-binary.watsup:281.5-281.45
   prod{x : idx} {0xFB `%`_u32(12):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(S_sx), x)
-  ;; A-binary.watsup:264.5-264.45
+  ;; A-binary.watsup:282.5-282.45
   prod{x : idx} {0xFB `%`_u32(13):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(U_sx), x)
-  ;; A-binary.watsup:265.5-265.43
+  ;; A-binary.watsup:283.5-283.43
   prod{x : idx} {0xFB `%`_u32(14):Bu32 x:Btypeidx} => ARRAY.SET_instr(x)
-  ;; A-binary.watsup:266.5-266.30
+  ;; A-binary.watsup:284.5-284.30
   prod {0xFB `%`_u32(15):Bu32} => ARRAY.LEN_instr
-  ;; A-binary.watsup:267.5-267.44
+  ;; A-binary.watsup:285.5-285.44
   prod{x : idx} {0xFB `%`_u32(16):Bu32 x:Btypeidx} => ARRAY.FILL_instr(x)
-  ;; A-binary.watsup:268.5-268.65
+  ;; A-binary.watsup:286.5-286.65
   prod{x_1 : idx, x_2 : idx} {0xFB `%`_u32(17):Bu32 x_1:Btypeidx x_2:Btypeidx} => ARRAY.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:269.5-269.62
+  ;; A-binary.watsup:287.5-287.62
   prod{x : idx, y : idx} {0xFB `%`_u32(18):Bu32 x:Btypeidx y:Bdataidx} => ARRAY.INIT_DATA_instr(x, y)
-  ;; A-binary.watsup:270.5-270.62
+  ;; A-binary.watsup:288.5-288.62
   prod{x : idx, y : idx} {0xFB `%`_u32(19):Bu32 x:Btypeidx y:Belemidx} => ARRAY.INIT_ELEM_instr(x, y)
-  ;; A-binary.watsup:274.5-274.51
+  ;; A-binary.watsup:292.5-292.51
   prod{ht : heaptype} {0xFB `%`_u32(20):Bu32 ht:Bheaptype} => REF.TEST_instr(REF_reftype(`NULL%?`_nul(?()), ht))
-  ;; A-binary.watsup:275.5-275.56
+  ;; A-binary.watsup:293.5-293.56
   prod{ht : heaptype} {0xFB `%`_u32(21):Bu32 ht:Bheaptype} => REF.TEST_instr(REF_reftype(`NULL%?`_nul(?(())), ht))
-  ;; A-binary.watsup:276.5-276.51
+  ;; A-binary.watsup:294.5-294.51
   prod{ht : heaptype} {0xFB `%`_u32(22):Bu32 ht:Bheaptype} => REF.CAST_instr(REF_reftype(`NULL%?`_nul(?()), ht))
-  ;; A-binary.watsup:277.5-277.56
+  ;; A-binary.watsup:295.5-295.56
   prod{ht : heaptype} {0xFB `%`_u32(23):Bu32 ht:Bheaptype} => REF.CAST_instr(REF_reftype(`NULL%?`_nul(?(())), ht))
-  ;; A-binary.watsup:278.5-282.94
+  ;; A-binary.watsup:296.5-300.94
   prod{nul1 : nul1, nul2 : nul2, l : labelidx, ht_1 : heaptype, ht_2 : heaptype} {0xFB `%`_u32(24):Bu32 (nul1, nul2):Bcastop l:Blabelidx ht_1:Bheaptype ht_2:Bheaptype} => BR_ON_CAST_instr(l, REF_reftype(nul1, ht_1), REF_reftype(nul2, ht_2))
-  ;; A-binary.watsup:283.5-287.99
+  ;; A-binary.watsup:301.5-305.99
   prod{nul1 : nul1, nul2 : nul2, l : labelidx, ht_1 : heaptype, ht_2 : heaptype} {0xFB `%`_u32(25):Bu32 (nul1, nul2):Bcastop l:Blabelidx ht_1:Bheaptype ht_2:Bheaptype} => BR_ON_CAST_FAIL_instr(l, REF_reftype(nul1, ht_1), REF_reftype(nul2, ht_2))
-  ;; A-binary.watsup:291.5-291.39
+  ;; A-binary.watsup:309.5-309.39
   prod {0xFB `%`_u32(26):Bu32} => ANY.CONVERT_EXTERN_instr
-  ;; A-binary.watsup:292.5-292.39
+  ;; A-binary.watsup:310.5-310.39
   prod {0xFB `%`_u32(27):Bu32} => EXTERN.CONVERT_ANY_instr
-  ;; A-binary.watsup:296.5-296.28
+  ;; A-binary.watsup:314.5-314.28
   prod {0xFB `%`_u32(28):Bu32} => REF.I31_instr
-  ;; A-binary.watsup:297.5-297.30
+  ;; A-binary.watsup:315.5-315.30
   prod {0xFB `%`_u32(29):Bu32} => I31.GET_instr(S_sx)
-  ;; A-binary.watsup:298.5-298.30
+  ;; A-binary.watsup:316.5-316.30
   prod {0xFB `%`_u32(30):Bu32} => I31.GET_instr(U_sx)
-  ;; A-binary.watsup:305.5-305.17
+  ;; A-binary.watsup:323.5-323.17
   prod 0x1A => DROP_instr
-  ;; A-binary.watsup:306.5-306.19
+  ;; A-binary.watsup:324.5-324.19
   prod 0x1B => `SELECT()%?`_instr(?())
-  ;; A-binary.watsup:307.5-307.41
+  ;; A-binary.watsup:325.5-325.41
   prod{ts : valtype} {0x1C [ts]:Blist(syntax valtype, grammar Bvaltype)} => `SELECT()%?`_instr(?([ts]))
-  ;; A-binary.watsup:314.5-314.36
+  ;; A-binary.watsup:332.5-332.36
   prod{x : idx} {0x20 x:Blocalidx} => LOCAL.GET_instr(x)
-  ;; A-binary.watsup:315.5-315.36
+  ;; A-binary.watsup:333.5-333.36
   prod{x : idx} {0x21 x:Blocalidx} => LOCAL.SET_instr(x)
-  ;; A-binary.watsup:316.5-316.36
+  ;; A-binary.watsup:334.5-334.36
   prod{x : idx} {0x22 x:Blocalidx} => LOCAL.TEE_instr(x)
-  ;; A-binary.watsup:320.5-320.38
+  ;; A-binary.watsup:338.5-338.38
   prod{x : idx} {0x23 x:Bglobalidx} => GLOBAL.GET_instr(x)
-  ;; A-binary.watsup:321.5-321.38
+  ;; A-binary.watsup:339.5-339.38
   prod{x : idx} {0x24 x:Bglobalidx} => GLOBAL.SET_instr(x)
-  ;; A-binary.watsup:328.5-328.36
+  ;; A-binary.watsup:346.5-346.36
   prod{x : idx} {0x25 x:Btableidx} => TABLE.GET_instr(x)
-  ;; A-binary.watsup:329.5-329.36
+  ;; A-binary.watsup:347.5-347.36
   prod{x : idx} {0x26 x:Btableidx} => TABLE.SET_instr(x)
-  ;; A-binary.watsup:330.5-330.58
+  ;; A-binary.watsup:348.5-348.58
   prod{y : idx, x : idx} {0xFC `%`_u32(12):Bu32 y:Belemidx x:Btableidx} => TABLE.INIT_instr(x, y)
-  ;; A-binary.watsup:331.5-331.43
+  ;; A-binary.watsup:349.5-349.43
   prod{x : idx} {0xFC `%`_u32(13):Bu32 x:Belemidx} => ELEM.DROP_instr(x)
-  ;; A-binary.watsup:332.5-332.67
+  ;; A-binary.watsup:350.5-350.67
   prod{x_1 : idx, x_2 : idx} {0xFC `%`_u32(14):Bu32 x_1:Btableidx x_2:Btableidx} => TABLE.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:333.5-333.45
+  ;; A-binary.watsup:351.5-351.45
   prod{x : idx} {0xFC `%`_u32(15):Bu32 x:Btableidx} => TABLE.GROW_instr(x)
-  ;; A-binary.watsup:334.5-334.45
+  ;; A-binary.watsup:352.5-352.45
   prod{x : idx} {0xFC `%`_u32(16):Bu32 x:Btableidx} => TABLE.SIZE_instr(x)
-  ;; A-binary.watsup:335.5-335.45
+  ;; A-binary.watsup:353.5-353.45
   prod{x : idx} {0xFC `%`_u32(17):Bu32 x:Btableidx} => TABLE.FILL_instr(x)
-  ;; A-binary.watsup:348.5-348.41
+  ;; A-binary.watsup:366.5-366.41
   prod{x : idx, ao : memarg} {0x28 (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:349.5-349.41
+  ;; A-binary.watsup:367.5-367.41
   prod{x : idx, ao : memarg} {0x29 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:350.5-350.41
+  ;; A-binary.watsup:368.5-368.41
   prod{x : idx, ao : memarg} {0x2A (x, ao):Bmemarg} => LOAD_instr(F32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:351.5-351.41
+  ;; A-binary.watsup:369.5-369.41
   prod{x : idx, ao : memarg} {0x2B (x, ao):Bmemarg} => LOAD_instr(F64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:352.5-352.48
+  ;; A-binary.watsup:370.5-370.48
   prod{x : idx, ao : memarg} {0x2C (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(8), S_sx)), x, ao)
-  ;; A-binary.watsup:353.5-353.48
+  ;; A-binary.watsup:371.5-371.48
   prod{x : idx, ao : memarg} {0x2D (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(8), U_sx)), x, ao)
-  ;; A-binary.watsup:354.5-354.49
+  ;; A-binary.watsup:372.5-372.49
   prod{x : idx, ao : memarg} {0x2E (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(16), S_sx)), x, ao)
-  ;; A-binary.watsup:355.5-355.49
+  ;; A-binary.watsup:373.5-373.49
   prod{x : idx, ao : memarg} {0x2F (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(16), U_sx)), x, ao)
-  ;; A-binary.watsup:356.5-356.48
+  ;; A-binary.watsup:374.5-374.48
   prod{x : idx, ao : memarg} {0x30 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(8), S_sx)), x, ao)
-  ;; A-binary.watsup:357.5-357.48
+  ;; A-binary.watsup:375.5-375.48
   prod{x : idx, ao : memarg} {0x31 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(8), U_sx)), x, ao)
-  ;; A-binary.watsup:358.5-358.49
+  ;; A-binary.watsup:376.5-376.49
   prod{x : idx, ao : memarg} {0x32 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(16), S_sx)), x, ao)
-  ;; A-binary.watsup:359.5-359.49
+  ;; A-binary.watsup:377.5-377.49
   prod{x : idx, ao : memarg} {0x33 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(16), U_sx)), x, ao)
-  ;; A-binary.watsup:360.5-360.49
+  ;; A-binary.watsup:378.5-378.49
   prod{x : idx, ao : memarg} {0x34 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(32), S_sx)), x, ao)
-  ;; A-binary.watsup:361.5-361.49
+  ;; A-binary.watsup:379.5-379.49
   prod{x : idx, ao : memarg} {0x35 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(32), U_sx)), x, ao)
-  ;; A-binary.watsup:362.5-362.42
+  ;; A-binary.watsup:380.5-380.42
   prod{x : idx, ao : memarg} {0x36 (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:363.5-363.42
+  ;; A-binary.watsup:381.5-381.42
   prod{x : idx, ao : memarg} {0x37 (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:364.5-364.42
+  ;; A-binary.watsup:382.5-382.42
   prod{x : idx, ao : memarg} {0x38 (x, ao):Bmemarg} => STORE_instr(F32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:365.5-365.42
+  ;; A-binary.watsup:383.5-383.42
   prod{x : idx, ao : memarg} {0x39 (x, ao):Bmemarg} => STORE_instr(F64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:366.5-366.45
+  ;; A-binary.watsup:384.5-384.45
   prod{x : idx, ao : memarg} {0x3A (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(`%`_sz(8)), x, ao)
-  ;; A-binary.watsup:367.5-367.46
+  ;; A-binary.watsup:385.5-385.46
   prod{x : idx, ao : memarg} {0x3B (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(`%`_sz(16)), x, ao)
-  ;; A-binary.watsup:368.5-368.45
+  ;; A-binary.watsup:386.5-386.45
   prod{x : idx, ao : memarg} {0x3C (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(8)), x, ao)
-  ;; A-binary.watsup:369.5-369.46
+  ;; A-binary.watsup:387.5-387.46
   prod{x : idx, ao : memarg} {0x3D (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(16)), x, ao)
-  ;; A-binary.watsup:370.5-370.46
+  ;; A-binary.watsup:388.5-388.46
   prod{x : idx, ao : memarg} {0x3E (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(32)), x, ao)
-  ;; A-binary.watsup:371.5-371.36
+  ;; A-binary.watsup:389.5-389.36
   prod{x : idx} {0x3F x:Bmemidx} => MEMORY.SIZE_instr(x)
-  ;; A-binary.watsup:372.5-372.36
+  ;; A-binary.watsup:390.5-390.36
   prod{x : idx} {0x40 x:Bmemidx} => MEMORY.GROW_instr(x)
-  ;; A-binary.watsup:373.5-373.56
+  ;; A-binary.watsup:391.5-391.56
   prod{y : idx, x : idx} {0xFC `%`_u32(8):Bu32 y:Bdataidx x:Bmemidx} => MEMORY.INIT_instr(x, y)
-  ;; A-binary.watsup:374.5-374.42
+  ;; A-binary.watsup:392.5-392.42
   prod{x : idx} {0xFC `%`_u32(9):Bu32 x:Bdataidx} => DATA.DROP_instr(x)
-  ;; A-binary.watsup:375.5-375.64
+  ;; A-binary.watsup:393.5-393.64
   prod{x_1 : idx, x_2 : idx} {0xFC `%`_u32(10):Bu32 x_1:Bmemidx x_2:Bmemidx} => MEMORY.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:376.5-376.44
+  ;; A-binary.watsup:394.5-394.44
   prod{x : idx} {0xFC `%`_u32(11):Bu32 x:Bmemidx} => MEMORY.FILL_instr(x)
-  ;; A-binary.watsup:384.5-384.31
+  ;; A-binary.watsup:402.5-402.31
   prod{n : n} {0x41 `%`_u32(n):Bu32} => CONST_instr(I32_numtype, `%`_num_(n))
-  ;; A-binary.watsup:385.5-385.31
+  ;; A-binary.watsup:403.5-403.31
   prod{n : n} {0x42 `%`_u64(n):Bu64} => CONST_instr(I64_numtype, `%`_num_(n))
-  ;; A-binary.watsup:386.5-386.31
+  ;; A-binary.watsup:404.5-404.31
   prod{p : f32} {0x43 p:Bf32} => CONST_instr(F32_numtype, p)
-  ;; A-binary.watsup:387.5-387.31
+  ;; A-binary.watsup:405.5-405.31
   prod{p : f64} {0x44 p:Bf64} => CONST_instr(F64_numtype, p)
-  ;; A-binary.watsup:391.5-391.27
+  ;; A-binary.watsup:409.5-409.27
   prod 0x45 => TESTOP_instr(I32_numtype, EQZ_testop_)
-  ;; A-binary.watsup:395.5-395.25
+  ;; A-binary.watsup:413.5-413.25
   prod 0x46 => RELOP_instr(I32_numtype, EQ_relop_)
-  ;; A-binary.watsup:396.5-396.25
+  ;; A-binary.watsup:414.5-414.25
   prod 0x47 => RELOP_instr(I32_numtype, NE_relop_)
-  ;; A-binary.watsup:397.5-397.29
+  ;; A-binary.watsup:415.5-415.29
   prod 0x48 => RELOP_instr(I32_numtype, LT_relop_(S_sx))
-  ;; A-binary.watsup:398.5-398.29
+  ;; A-binary.watsup:416.5-416.29
   prod 0x49 => RELOP_instr(I32_numtype, LT_relop_(U_sx))
-  ;; A-binary.watsup:399.5-399.29
+  ;; A-binary.watsup:417.5-417.29
   prod 0x4A => RELOP_instr(I32_numtype, GT_relop_(S_sx))
-  ;; A-binary.watsup:400.5-400.29
+  ;; A-binary.watsup:418.5-418.29
   prod 0x4B => RELOP_instr(I32_numtype, GT_relop_(U_sx))
-  ;; A-binary.watsup:401.5-401.29
+  ;; A-binary.watsup:419.5-419.29
   prod 0x4C => RELOP_instr(I32_numtype, LE_relop_(S_sx))
-  ;; A-binary.watsup:402.5-402.29
+  ;; A-binary.watsup:420.5-420.29
   prod 0x4D => RELOP_instr(I32_numtype, LE_relop_(U_sx))
-  ;; A-binary.watsup:403.5-403.29
+  ;; A-binary.watsup:421.5-421.29
   prod 0x4E => RELOP_instr(I32_numtype, GE_relop_(S_sx))
-  ;; A-binary.watsup:404.5-404.29
+  ;; A-binary.watsup:422.5-422.29
   prod 0x4F => RELOP_instr(I32_numtype, GE_relop_(U_sx))
-  ;; A-binary.watsup:408.5-408.27
+  ;; A-binary.watsup:426.5-426.27
   prod 0x50 => TESTOP_instr(I64_numtype, EQZ_testop_)
-  ;; A-binary.watsup:412.5-412.25
+  ;; A-binary.watsup:430.5-430.25
   prod 0x51 => RELOP_instr(I64_numtype, EQ_relop_)
-  ;; A-binary.watsup:413.5-413.25
+  ;; A-binary.watsup:431.5-431.25
   prod 0x52 => RELOP_instr(I64_numtype, NE_relop_)
-  ;; A-binary.watsup:414.5-414.29
+  ;; A-binary.watsup:432.5-432.29
   prod 0x53 => RELOP_instr(I64_numtype, LT_relop_(S_sx))
-  ;; A-binary.watsup:415.5-415.29
+  ;; A-binary.watsup:433.5-433.29
   prod 0x54 => RELOP_instr(I64_numtype, LT_relop_(U_sx))
-  ;; A-binary.watsup:416.5-416.29
+  ;; A-binary.watsup:434.5-434.29
   prod 0x55 => RELOP_instr(I64_numtype, GT_relop_(S_sx))
-  ;; A-binary.watsup:417.5-417.29
+  ;; A-binary.watsup:435.5-435.29
   prod 0x56 => RELOP_instr(I64_numtype, GT_relop_(U_sx))
-  ;; A-binary.watsup:418.5-418.29
+  ;; A-binary.watsup:436.5-436.29
   prod 0x57 => RELOP_instr(I64_numtype, LE_relop_(S_sx))
-  ;; A-binary.watsup:419.5-419.29
+  ;; A-binary.watsup:437.5-437.29
   prod 0x58 => RELOP_instr(I64_numtype, LE_relop_(U_sx))
-  ;; A-binary.watsup:420.5-420.29
+  ;; A-binary.watsup:438.5-438.29
   prod 0x59 => RELOP_instr(I64_numtype, GE_relop_(S_sx))
-  ;; A-binary.watsup:421.5-421.29
+  ;; A-binary.watsup:439.5-439.29
   prod 0x5A => RELOP_instr(I64_numtype, GE_relop_(U_sx))
-  ;; A-binary.watsup:425.5-425.25
+  ;; A-binary.watsup:443.5-443.25
   prod 0x5B => RELOP_instr(F32_numtype, EQ_relop_)
-  ;; A-binary.watsup:426.5-426.25
+  ;; A-binary.watsup:444.5-444.25
   prod 0x5C => RELOP_instr(F32_numtype, NE_relop_)
-  ;; A-binary.watsup:427.5-427.25
+  ;; A-binary.watsup:445.5-445.25
   prod 0x5D => RELOP_instr(F32_numtype, LT_relop_)
-  ;; A-binary.watsup:428.5-428.25
+  ;; A-binary.watsup:446.5-446.25
   prod 0x5E => RELOP_instr(F32_numtype, GT_relop_)
-  ;; A-binary.watsup:429.5-429.25
+  ;; A-binary.watsup:447.5-447.25
   prod 0x5F => RELOP_instr(F32_numtype, LE_relop_)
-  ;; A-binary.watsup:430.5-430.25
+  ;; A-binary.watsup:448.5-448.25
   prod 0x60 => RELOP_instr(F32_numtype, GE_relop_)
-  ;; A-binary.watsup:434.5-434.25
+  ;; A-binary.watsup:452.5-452.25
   prod 0x61 => RELOP_instr(F64_numtype, EQ_relop_)
-  ;; A-binary.watsup:435.5-435.25
+  ;; A-binary.watsup:453.5-453.25
   prod 0x62 => RELOP_instr(F64_numtype, NE_relop_)
-  ;; A-binary.watsup:436.5-436.25
+  ;; A-binary.watsup:454.5-454.25
   prod 0x63 => RELOP_instr(F64_numtype, LT_relop_)
-  ;; A-binary.watsup:437.5-437.25
+  ;; A-binary.watsup:455.5-455.25
   prod 0x64 => RELOP_instr(F64_numtype, GT_relop_)
-  ;; A-binary.watsup:438.5-438.25
+  ;; A-binary.watsup:456.5-456.25
   prod 0x65 => RELOP_instr(F64_numtype, LE_relop_)
-  ;; A-binary.watsup:439.5-439.25
+  ;; A-binary.watsup:457.5-457.25
   prod 0x66 => RELOP_instr(F64_numtype, GE_relop_)
-  ;; A-binary.watsup:443.5-443.25
+  ;; A-binary.watsup:461.5-461.25
   prod 0x67 => UNOP_instr(I32_numtype, CLZ_unop_)
-  ;; A-binary.watsup:444.5-444.25
+  ;; A-binary.watsup:462.5-462.25
   prod 0x68 => UNOP_instr(I32_numtype, CTZ_unop_)
-  ;; A-binary.watsup:445.5-445.28
+  ;; A-binary.watsup:463.5-463.28
   prod 0x69 => UNOP_instr(I32_numtype, POPCNT_unop_)
-  ;; A-binary.watsup:449.5-449.26
+  ;; A-binary.watsup:467.5-467.26
   prod 0x6A => BINOP_instr(I32_numtype, ADD_binop_)
-  ;; A-binary.watsup:450.5-450.26
+  ;; A-binary.watsup:468.5-468.26
   prod 0x6B => BINOP_instr(I32_numtype, SUB_binop_)
-  ;; A-binary.watsup:451.5-451.26
+  ;; A-binary.watsup:469.5-469.26
   prod 0x6C => BINOP_instr(I32_numtype, MUL_binop_)
-  ;; A-binary.watsup:452.5-452.30
+  ;; A-binary.watsup:470.5-470.30
   prod 0x6D => BINOP_instr(I32_numtype, DIV_binop_(S_sx))
-  ;; A-binary.watsup:453.5-453.30
+  ;; A-binary.watsup:471.5-471.30
   prod 0x6E => BINOP_instr(I32_numtype, DIV_binop_(U_sx))
-  ;; A-binary.watsup:454.5-454.30
+  ;; A-binary.watsup:472.5-472.30
   prod 0x6F => BINOP_instr(I32_numtype, REM_binop_(S_sx))
-  ;; A-binary.watsup:455.5-455.30
+  ;; A-binary.watsup:473.5-473.30
   prod 0x70 => BINOP_instr(I32_numtype, REM_binop_(U_sx))
-  ;; A-binary.watsup:456.5-456.26
+  ;; A-binary.watsup:474.5-474.26
   prod 0x71 => BINOP_instr(I32_numtype, AND_binop_)
-  ;; A-binary.watsup:457.5-457.25
+  ;; A-binary.watsup:475.5-475.25
   prod 0x72 => BINOP_instr(I32_numtype, OR_binop_)
-  ;; A-binary.watsup:458.5-458.26
+  ;; A-binary.watsup:476.5-476.26
   prod 0x73 => BINOP_instr(I32_numtype, XOR_binop_)
-  ;; A-binary.watsup:459.5-459.26
+  ;; A-binary.watsup:477.5-477.26
   prod 0x74 => BINOP_instr(I32_numtype, SHL_binop_)
-  ;; A-binary.watsup:460.5-460.30
+  ;; A-binary.watsup:478.5-478.30
   prod 0x75 => BINOP_instr(I32_numtype, SHR_binop_(S_sx))
-  ;; A-binary.watsup:461.5-461.30
+  ;; A-binary.watsup:479.5-479.30
   prod 0x76 => BINOP_instr(I32_numtype, SHR_binop_(U_sx))
-  ;; A-binary.watsup:462.5-462.27
+  ;; A-binary.watsup:480.5-480.27
   prod 0x77 => BINOP_instr(I32_numtype, ROTL_binop_)
-  ;; A-binary.watsup:463.5-463.27
+  ;; A-binary.watsup:481.5-481.27
   prod 0x78 => BINOP_instr(I32_numtype, ROTR_binop_)
-  ;; A-binary.watsup:467.5-467.25
+  ;; A-binary.watsup:485.5-485.25
   prod 0x79 => UNOP_instr(I64_numtype, CLZ_unop_)
-  ;; A-binary.watsup:468.5-468.25
+  ;; A-binary.watsup:486.5-486.25
   prod 0x7A => UNOP_instr(I64_numtype, CTZ_unop_)
-  ;; A-binary.watsup:469.5-469.28
+  ;; A-binary.watsup:487.5-487.28
   prod 0x7B => UNOP_instr(I64_numtype, POPCNT_unop_)
-  ;; A-binary.watsup:473.5-473.33
+  ;; A-binary.watsup:491.5-491.33
   prod 0xC0 => UNOP_instr(I32_numtype, EXTEND_unop_(`%`_sz(8)))
-  ;; A-binary.watsup:474.5-474.34
+  ;; A-binary.watsup:492.5-492.34
   prod 0xC1 => UNOP_instr(I32_numtype, EXTEND_unop_(`%`_sz(16)))
-  ;; A-binary.watsup:478.5-478.33
+  ;; A-binary.watsup:496.5-496.33
   prod 0xC2 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(8)))
-  ;; A-binary.watsup:479.5-479.34
+  ;; A-binary.watsup:497.5-497.34
   prod 0xC3 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(16)))
-  ;; A-binary.watsup:480.5-480.34
+  ;; A-binary.watsup:498.5-498.34
   prod 0xC4 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(32)))
-  ;; A-binary.watsup:484.5-484.26
+  ;; A-binary.watsup:502.5-502.26
   prod 0x7C => BINOP_instr(I64_numtype, ADD_binop_)
-  ;; A-binary.watsup:485.5-485.26
+  ;; A-binary.watsup:503.5-503.26
   prod 0x7D => BINOP_instr(I64_numtype, SUB_binop_)
-  ;; A-binary.watsup:486.5-486.26
+  ;; A-binary.watsup:504.5-504.26
   prod 0x7E => BINOP_instr(I64_numtype, MUL_binop_)
-  ;; A-binary.watsup:487.5-487.30
+  ;; A-binary.watsup:505.5-505.30
   prod 0x7F => BINOP_instr(I64_numtype, DIV_binop_(S_sx))
-  ;; A-binary.watsup:488.5-488.30
+  ;; A-binary.watsup:506.5-506.30
   prod 0x80 => BINOP_instr(I64_numtype, DIV_binop_(U_sx))
-  ;; A-binary.watsup:489.5-489.30
+  ;; A-binary.watsup:507.5-507.30
   prod 0x81 => BINOP_instr(I64_numtype, REM_binop_(S_sx))
-  ;; A-binary.watsup:490.5-490.30
+  ;; A-binary.watsup:508.5-508.30
   prod 0x82 => BINOP_instr(I64_numtype, REM_binop_(U_sx))
-  ;; A-binary.watsup:491.5-491.26
+  ;; A-binary.watsup:509.5-509.26
   prod 0x83 => BINOP_instr(I64_numtype, AND_binop_)
-  ;; A-binary.watsup:492.5-492.25
+  ;; A-binary.watsup:510.5-510.25
   prod 0x84 => BINOP_instr(I64_numtype, OR_binop_)
-  ;; A-binary.watsup:493.5-493.26
+  ;; A-binary.watsup:511.5-511.26
   prod 0x85 => BINOP_instr(I64_numtype, XOR_binop_)
-  ;; A-binary.watsup:494.5-494.26
+  ;; A-binary.watsup:512.5-512.26
   prod 0x86 => BINOP_instr(I64_numtype, SHL_binop_)
-  ;; A-binary.watsup:495.5-495.30
+  ;; A-binary.watsup:513.5-513.30
   prod 0x87 => BINOP_instr(I64_numtype, SHR_binop_(S_sx))
-  ;; A-binary.watsup:496.5-496.30
+  ;; A-binary.watsup:514.5-514.30
   prod 0x88 => BINOP_instr(I64_numtype, SHR_binop_(U_sx))
-  ;; A-binary.watsup:497.5-497.27
+  ;; A-binary.watsup:515.5-515.27
   prod 0x89 => BINOP_instr(I64_numtype, ROTL_binop_)
-  ;; A-binary.watsup:498.5-498.27
+  ;; A-binary.watsup:516.5-516.27
   prod 0x8A => BINOP_instr(I64_numtype, ROTR_binop_)
-  ;; A-binary.watsup:502.5-502.25
+  ;; A-binary.watsup:520.5-520.25
   prod 0x8B => UNOP_instr(F32_numtype, ABS_unop_)
-  ;; A-binary.watsup:503.5-503.25
+  ;; A-binary.watsup:521.5-521.25
   prod 0x8C => UNOP_instr(F32_numtype, NEG_unop_)
-  ;; A-binary.watsup:504.5-504.26
+  ;; A-binary.watsup:522.5-522.26
   prod 0x8D => UNOP_instr(F32_numtype, CEIL_unop_)
-  ;; A-binary.watsup:505.5-505.27
+  ;; A-binary.watsup:523.5-523.27
   prod 0x8E => UNOP_instr(F32_numtype, FLOOR_unop_)
-  ;; A-binary.watsup:506.5-506.27
+  ;; A-binary.watsup:524.5-524.27
   prod 0x8F => UNOP_instr(F32_numtype, TRUNC_unop_)
-  ;; A-binary.watsup:507.5-507.29
+  ;; A-binary.watsup:525.5-525.29
   prod 0x90 => UNOP_instr(F32_numtype, NEAREST_unop_)
-  ;; A-binary.watsup:508.5-508.26
+  ;; A-binary.watsup:526.5-526.26
   prod 0x91 => UNOP_instr(F32_numtype, SQRT_unop_)
-  ;; A-binary.watsup:512.5-512.26
+  ;; A-binary.watsup:530.5-530.26
   prod 0x92 => BINOP_instr(F32_numtype, ADD_binop_)
-  ;; A-binary.watsup:513.5-513.26
+  ;; A-binary.watsup:531.5-531.26
   prod 0x93 => BINOP_instr(F32_numtype, SUB_binop_)
-  ;; A-binary.watsup:514.5-514.26
+  ;; A-binary.watsup:532.5-532.26
   prod 0x94 => BINOP_instr(F32_numtype, MUL_binop_)
-  ;; A-binary.watsup:515.5-515.26
+  ;; A-binary.watsup:533.5-533.26
   prod 0x95 => BINOP_instr(F32_numtype, DIV_binop_)
-  ;; A-binary.watsup:516.5-516.26
+  ;; A-binary.watsup:534.5-534.26
   prod 0x96 => BINOP_instr(F32_numtype, MIN_binop_)
-  ;; A-binary.watsup:517.5-517.26
+  ;; A-binary.watsup:535.5-535.26
   prod 0x97 => BINOP_instr(F32_numtype, MAX_binop_)
-  ;; A-binary.watsup:518.5-518.31
+  ;; A-binary.watsup:536.5-536.31
   prod 0x98 => BINOP_instr(F32_numtype, COPYSIGN_binop_)
-  ;; A-binary.watsup:522.5-522.25
+  ;; A-binary.watsup:540.5-540.25
   prod 0x99 => UNOP_instr(F64_numtype, ABS_unop_)
-  ;; A-binary.watsup:523.5-523.25
+  ;; A-binary.watsup:541.5-541.25
   prod 0x9A => UNOP_instr(F64_numtype, NEG_unop_)
-  ;; A-binary.watsup:524.5-524.26
+  ;; A-binary.watsup:542.5-542.26
   prod 0x9B => UNOP_instr(F64_numtype, CEIL_unop_)
-  ;; A-binary.watsup:525.5-525.27
+  ;; A-binary.watsup:543.5-543.27
   prod 0x9C => UNOP_instr(F64_numtype, FLOOR_unop_)
-  ;; A-binary.watsup:526.5-526.27
+  ;; A-binary.watsup:544.5-544.27
   prod 0x9D => UNOP_instr(F64_numtype, TRUNC_unop_)
-  ;; A-binary.watsup:527.5-527.29
+  ;; A-binary.watsup:545.5-545.29
   prod 0x9E => UNOP_instr(F64_numtype, NEAREST_unop_)
-  ;; A-binary.watsup:528.5-528.26
+  ;; A-binary.watsup:546.5-546.26
   prod 0x9F => UNOP_instr(F64_numtype, SQRT_unop_)
-  ;; A-binary.watsup:532.5-532.26
+  ;; A-binary.watsup:550.5-550.26
   prod 0xA0 => BINOP_instr(F64_numtype, ADD_binop_)
-  ;; A-binary.watsup:533.5-533.26
+  ;; A-binary.watsup:551.5-551.26
   prod 0xA1 => BINOP_instr(F64_numtype, SUB_binop_)
-  ;; A-binary.watsup:534.5-534.26
+  ;; A-binary.watsup:552.5-552.26
   prod 0xA2 => BINOP_instr(F64_numtype, MUL_binop_)
-  ;; A-binary.watsup:535.5-535.26
+  ;; A-binary.watsup:553.5-553.26
   prod 0xA3 => BINOP_instr(F64_numtype, DIV_binop_)
-  ;; A-binary.watsup:536.5-536.26
+  ;; A-binary.watsup:554.5-554.26
   prod 0xA4 => BINOP_instr(F64_numtype, MIN_binop_)
-  ;; A-binary.watsup:537.5-537.26
+  ;; A-binary.watsup:555.5-555.26
   prod 0xA5 => BINOP_instr(F64_numtype, MAX_binop_)
-  ;; A-binary.watsup:538.5-538.31
+  ;; A-binary.watsup:556.5-556.31
   prod 0xA6 => BINOP_instr(F64_numtype, COPYSIGN_binop_)
-  ;; A-binary.watsup:543.5-543.31
+  ;; A-binary.watsup:561.5-561.31
   prod 0xA7 => CVTOP_instr(I32_numtype, I64_numtype, WRAP_cvtop__)
-  ;; A-binary.watsup:544.5-544.36
+  ;; A-binary.watsup:562.5-562.36
   prod 0xA8 => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:545.5-545.36
+  ;; A-binary.watsup:563.5-563.36
   prod 0xA9 => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:546.5-546.36
+  ;; A-binary.watsup:564.5-564.36
   prod 0xAA => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:547.5-547.36
+  ;; A-binary.watsup:565.5-565.36
   prod 0xAB => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:548.5-548.37
+  ;; A-binary.watsup:566.5-566.37
   prod 0xAC => CVTOP_instr(I64_numtype, I32_numtype, EXTEND_cvtop__(S_sx))
-  ;; A-binary.watsup:549.5-549.37
+  ;; A-binary.watsup:567.5-567.37
   prod 0xAD => CVTOP_instr(I64_numtype, I32_numtype, EXTEND_cvtop__(U_sx))
-  ;; A-binary.watsup:550.5-550.36
+  ;; A-binary.watsup:568.5-568.36
   prod 0xAE => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:551.5-551.36
+  ;; A-binary.watsup:569.5-569.36
   prod 0xAF => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:552.5-552.36
+  ;; A-binary.watsup:570.5-570.36
   prod 0xB0 => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:553.5-553.36
+  ;; A-binary.watsup:571.5-571.36
   prod 0xB1 => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:554.5-554.38
+  ;; A-binary.watsup:572.5-572.38
   prod 0xB2 => CVTOP_instr(F32_numtype, I32_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:555.5-555.38
+  ;; A-binary.watsup:573.5-573.38
   prod 0xB3 => CVTOP_instr(F32_numtype, I32_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:556.5-556.38
+  ;; A-binary.watsup:574.5-574.38
   prod 0xB4 => CVTOP_instr(F32_numtype, I64_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:557.5-557.38
+  ;; A-binary.watsup:575.5-575.38
   prod 0xB5 => CVTOP_instr(F32_numtype, I64_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:558.5-558.33
+  ;; A-binary.watsup:576.5-576.33
   prod 0xB6 => CVTOP_instr(F32_numtype, F64_numtype, DEMOTE_cvtop__)
-  ;; A-binary.watsup:559.5-559.38
+  ;; A-binary.watsup:577.5-577.38
   prod 0xB7 => CVTOP_instr(F64_numtype, I32_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:560.5-560.38
+  ;; A-binary.watsup:578.5-578.38
   prod 0xB8 => CVTOP_instr(F64_numtype, I32_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:561.5-561.38
+  ;; A-binary.watsup:579.5-579.38
   prod 0xB9 => CVTOP_instr(F64_numtype, I64_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:562.5-562.38
+  ;; A-binary.watsup:580.5-580.38
   prod 0xBA => CVTOP_instr(F64_numtype, I64_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:563.5-563.34
+  ;; A-binary.watsup:581.5-581.34
   prod 0xBB => CVTOP_instr(F32_numtype, F64_numtype, PROMOTE_cvtop__)
-  ;; A-binary.watsup:564.5-564.38
+  ;; A-binary.watsup:582.5-582.38
   prod 0xBC => CVTOP_instr(I32_numtype, F32_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:565.5-565.38
+  ;; A-binary.watsup:583.5-583.38
   prod 0xBD => CVTOP_instr(I64_numtype, F64_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:566.5-566.38
+  ;; A-binary.watsup:584.5-584.38
   prod 0xBE => CVTOP_instr(F32_numtype, I32_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:567.5-567.38
+  ;; A-binary.watsup:585.5-585.38
   prod 0xBF => CVTOP_instr(F64_numtype, I64_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:571.5-571.47
+  ;; A-binary.watsup:589.5-589.47
   prod {0xFC `%`_u32(0):Bu32} => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:572.5-572.47
+  ;; A-binary.watsup:590.5-590.47
   prod {0xFC `%`_u32(1):Bu32} => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:573.5-573.47
+  ;; A-binary.watsup:591.5-591.47
   prod {0xFC `%`_u32(2):Bu32} => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:574.5-574.47
+  ;; A-binary.watsup:592.5-592.47
   prod {0xFC `%`_u32(3):Bu32} => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:575.5-575.47
+  ;; A-binary.watsup:593.5-593.47
   prod {0xFC `%`_u32(4):Bu32} => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:576.5-576.47
+  ;; A-binary.watsup:594.5-594.47
   prod {0xFC `%`_u32(5):Bu32} => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:577.5-577.47
+  ;; A-binary.watsup:595.5-595.47
   prod {0xFC `%`_u32(6):Bu32} => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:578.5-578.47
+  ;; A-binary.watsup:596.5-596.47
   prod {0xFC `%`_u32(7):Bu32} => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:588.5-588.50
+  ;; A-binary.watsup:606.5-606.50
   prod{x : idx, ao : memarg} {0xFD `%`_u32(0):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(), x, ao)
-  ;; A-binary.watsup:589.5-589.68
+  ;; A-binary.watsup:607.5-607.68
   prod{x : idx, ao : memarg} {0xFD `%`_u32(1):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(8), 8, S_sx)), x, ao)
-  ;; A-binary.watsup:590.5-590.68
+  ;; A-binary.watsup:608.5-608.68
   prod{x : idx, ao : memarg} {0xFD `%`_u32(2):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(8), 8, U_sx)), x, ao)
-  ;; A-binary.watsup:591.5-591.69
+  ;; A-binary.watsup:609.5-609.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(3):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(16), 4, S_sx)), x, ao)
-  ;; A-binary.watsup:592.5-592.69
+  ;; A-binary.watsup:610.5-610.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(4):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(16), 4, U_sx)), x, ao)
-  ;; A-binary.watsup:593.5-593.69
+  ;; A-binary.watsup:611.5-611.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(5):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(32), 2, S_sx)), x, ao)
-  ;; A-binary.watsup:594.5-594.69
+  ;; A-binary.watsup:612.5-612.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(6):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(32), 2, U_sx)), x, ao)
-  ;; A-binary.watsup:595.5-595.61
+  ;; A-binary.watsup:613.5-613.61
   prod{x : idx, ao : memarg} {0xFD `%`_u32(7):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(8))), x, ao)
-  ;; A-binary.watsup:596.5-596.62
+  ;; A-binary.watsup:614.5-614.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(8):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(16))), x, ao)
-  ;; A-binary.watsup:597.5-597.62
+  ;; A-binary.watsup:615.5-615.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(9):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(32))), x, ao)
-  ;; A-binary.watsup:598.5-598.63
+  ;; A-binary.watsup:616.5-616.63
   prod{x : idx, ao : memarg} {0xFD `%`_u32(10):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(64))), x, ao)
-  ;; A-binary.watsup:599.5-599.52
+  ;; A-binary.watsup:617.5-617.52
   prod{x : idx, ao : memarg} {0xFD `%`_u32(11):Bu32 (x, ao):Bmemarg} => VSTORE_instr(V128_vectype, x, ao)
-  ;; A-binary.watsup:600.5-600.72
+  ;; A-binary.watsup:618.5-618.72
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(84):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(8), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:601.5-601.73
+  ;; A-binary.watsup:619.5-619.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(85):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(16), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:602.5-602.73
+  ;; A-binary.watsup:620.5-620.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(86):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(32), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:603.5-603.73
+  ;; A-binary.watsup:621.5-621.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(87):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(64), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:604.5-604.73
+  ;; A-binary.watsup:622.5-622.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(88):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(8), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:605.5-605.74
+  ;; A-binary.watsup:623.5-623.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(89):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(16), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:606.5-606.74
+  ;; A-binary.watsup:624.5-624.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(90):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(32), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:607.5-607.74
+  ;; A-binary.watsup:625.5-625.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(91):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(64), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:608.5-608.62
+  ;; A-binary.watsup:626.5-626.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(92):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(32))), x, ao)
-  ;; A-binary.watsup:609.5-609.62
+  ;; A-binary.watsup:627.5-627.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(93):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(64))), x, ao)
-  ;; A-binary.watsup:613.5-613.71
+  ;; A-binary.watsup:631.5-631.71
   prod{b^16 : byte^16} {0xFD `%`_u32(12):Bu32 b:Bbyte^16{b : byte}} => VCONST_instr(V128_vectype, $invibytes_(128, b^16{b : byte}))
-  ;; A-binary.watsup:617.5-617.58
+  ;; A-binary.watsup:635.5-635.58
   prod{l : labelidx} {0xFD `%`_u32(13):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx^16{}} => VSHUFFLE_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), [`%`_uN(l!`%`_labelidx.0)])
-  ;; A-binary.watsup:618.5-618.40
+  ;; A-binary.watsup:636.5-636.40
   prod {0xFD `%`_u32(14):Bu32} => VSWIZZLE_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)))
-  ;; A-binary.watsup:622.5-622.38
+  ;; A-binary.watsup:640.5-640.38
   prod {0xFD `%`_u32(15):Bu32} => VSPLAT_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)))
-  ;; A-binary.watsup:623.5-623.38
+  ;; A-binary.watsup:641.5-641.38
   prod {0xFD `%`_u32(16):Bu32} => VSPLAT_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)))
-  ;; A-binary.watsup:624.5-624.38
+  ;; A-binary.watsup:642.5-642.38
   prod {0xFD `%`_u32(17):Bu32} => VSPLAT_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)))
-  ;; A-binary.watsup:625.5-625.38
+  ;; A-binary.watsup:643.5-643.38
   prod {0xFD `%`_u32(18):Bu32} => VSPLAT_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)))
-  ;; A-binary.watsup:626.5-626.38
+  ;; A-binary.watsup:644.5-644.38
   prod {0xFD `%`_u32(19):Bu32} => VSPLAT_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)))
-  ;; A-binary.watsup:627.5-627.38
+  ;; A-binary.watsup:645.5-645.38
   prod {0xFD `%`_u32(20):Bu32} => VSPLAT_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)))
-  ;; A-binary.watsup:631.5-631.60
+  ;; A-binary.watsup:649.5-649.60
   prod{l : labelidx} {0xFD `%`_u32(21):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ?(S_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:632.5-632.60
+  ;; A-binary.watsup:650.5-650.60
   prod{l : labelidx} {0xFD `%`_u32(22):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ?(U_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:633.5-633.58
+  ;; A-binary.watsup:651.5-651.58
   prod{l : labelidx} {0xFD `%`_u32(23):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:634.5-634.60
+  ;; A-binary.watsup:652.5-652.60
   prod{l : labelidx} {0xFD `%`_u32(24):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ?(S_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:635.5-635.60
+  ;; A-binary.watsup:653.5-653.60
   prod{l : labelidx} {0xFD `%`_u32(25):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ?(U_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:636.5-636.58
+  ;; A-binary.watsup:654.5-654.58
   prod{l : labelidx} {0xFD `%`_u32(26):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:637.5-637.58
+  ;; A-binary.watsup:655.5-655.58
   prod{l : labelidx} {0xFD `%`_u32(27):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:638.5-638.58
+  ;; A-binary.watsup:656.5-656.58
   prod{l : labelidx} {0xFD `%`_u32(28):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:639.5-639.58
+  ;; A-binary.watsup:657.5-657.58
   prod{l : labelidx} {0xFD `%`_u32(29):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:640.5-640.58
+  ;; A-binary.watsup:658.5-658.58
   prod{l : labelidx} {0xFD `%`_u32(30):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:641.5-641.58
+  ;; A-binary.watsup:659.5-659.58
   prod{l : labelidx} {0xFD `%`_u32(31):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:642.5-642.58
+  ;; A-binary.watsup:660.5-660.58
   prod{l : labelidx} {0xFD `%`_u32(32):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:643.5-643.58
+  ;; A-binary.watsup:661.5-661.58
   prod{l : labelidx} {0xFD `%`_u32(33):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:644.5-644.58
+  ;; A-binary.watsup:662.5-662.58
   prod{l : labelidx} {0xFD `%`_u32(34):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:648.5-648.41
+  ;; A-binary.watsup:666.5-666.41
   prod {0xFD `%`_u32(35):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), EQ_vrelop_)
-  ;; A-binary.watsup:649.5-649.41
+  ;; A-binary.watsup:667.5-667.41
   prod {0xFD `%`_u32(36):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), NE_vrelop_)
-  ;; A-binary.watsup:650.5-650.45
+  ;; A-binary.watsup:668.5-668.45
   prod {0xFD `%`_u32(37):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:651.5-651.45
+  ;; A-binary.watsup:669.5-669.45
   prod {0xFD `%`_u32(38):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:652.5-652.45
+  ;; A-binary.watsup:670.5-670.45
   prod {0xFD `%`_u32(39):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:653.5-653.45
+  ;; A-binary.watsup:671.5-671.45
   prod {0xFD `%`_u32(40):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:654.5-654.45
+  ;; A-binary.watsup:672.5-672.45
   prod {0xFD `%`_u32(41):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:655.5-655.45
+  ;; A-binary.watsup:673.5-673.45
   prod {0xFD `%`_u32(42):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:656.5-656.45
+  ;; A-binary.watsup:674.5-674.45
   prod {0xFD `%`_u32(43):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:657.5-657.45
+  ;; A-binary.watsup:675.5-675.45
   prod {0xFD `%`_u32(44):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:661.5-661.41
+  ;; A-binary.watsup:679.5-679.41
   prod {0xFD `%`_u32(45):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), EQ_vrelop_)
-  ;; A-binary.watsup:662.5-662.41
+  ;; A-binary.watsup:680.5-680.41
   prod {0xFD `%`_u32(46):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), NE_vrelop_)
-  ;; A-binary.watsup:663.5-663.45
+  ;; A-binary.watsup:681.5-681.45
   prod {0xFD `%`_u32(47):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:664.5-664.45
+  ;; A-binary.watsup:682.5-682.45
   prod {0xFD `%`_u32(48):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:665.5-665.45
+  ;; A-binary.watsup:683.5-683.45
   prod {0xFD `%`_u32(49):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:666.5-666.45
+  ;; A-binary.watsup:684.5-684.45
   prod {0xFD `%`_u32(50):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:667.5-667.45
+  ;; A-binary.watsup:685.5-685.45
   prod {0xFD `%`_u32(51):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:668.5-668.45
+  ;; A-binary.watsup:686.5-686.45
   prod {0xFD `%`_u32(52):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:669.5-669.45
+  ;; A-binary.watsup:687.5-687.45
   prod {0xFD `%`_u32(53):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:670.5-670.45
+  ;; A-binary.watsup:688.5-688.45
   prod {0xFD `%`_u32(54):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:674.5-674.41
+  ;; A-binary.watsup:692.5-692.41
   prod {0xFD `%`_u32(55):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), EQ_vrelop_)
-  ;; A-binary.watsup:675.5-675.41
+  ;; A-binary.watsup:693.5-693.41
   prod {0xFD `%`_u32(56):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), NE_vrelop_)
-  ;; A-binary.watsup:676.5-676.45
+  ;; A-binary.watsup:694.5-694.45
   prod {0xFD `%`_u32(57):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:677.5-677.45
+  ;; A-binary.watsup:695.5-695.45
   prod {0xFD `%`_u32(58):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:678.5-678.45
+  ;; A-binary.watsup:696.5-696.45
   prod {0xFD `%`_u32(59):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:679.5-679.45
+  ;; A-binary.watsup:697.5-697.45
   prod {0xFD `%`_u32(60):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:680.5-680.45
+  ;; A-binary.watsup:698.5-698.45
   prod {0xFD `%`_u32(61):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:681.5-681.45
+  ;; A-binary.watsup:699.5-699.45
   prod {0xFD `%`_u32(62):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:682.5-682.45
+  ;; A-binary.watsup:700.5-700.45
   prod {0xFD `%`_u32(63):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:683.5-683.45
+  ;; A-binary.watsup:701.5-701.45
   prod {0xFD `%`_u32(64):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:687.5-687.41
+  ;; A-binary.watsup:705.5-705.41
   prod {0xFD `%`_u32(65):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), EQ_vrelop_)
-  ;; A-binary.watsup:688.5-688.41
+  ;; A-binary.watsup:706.5-706.41
   prod {0xFD `%`_u32(66):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NE_vrelop_)
-  ;; A-binary.watsup:689.5-689.41
+  ;; A-binary.watsup:707.5-707.41
   prod {0xFD `%`_u32(67):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), LT_vrelop_)
-  ;; A-binary.watsup:690.5-690.41
+  ;; A-binary.watsup:708.5-708.41
   prod {0xFD `%`_u32(68):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), GT_vrelop_)
-  ;; A-binary.watsup:691.5-691.41
+  ;; A-binary.watsup:709.5-709.41
   prod {0xFD `%`_u32(69):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), LE_vrelop_)
-  ;; A-binary.watsup:692.5-692.41
+  ;; A-binary.watsup:710.5-710.41
   prod {0xFD `%`_u32(70):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), GE_vrelop_)
-  ;; A-binary.watsup:696.5-696.41
+  ;; A-binary.watsup:714.5-714.41
   prod {0xFD `%`_u32(71):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), EQ_vrelop_)
-  ;; A-binary.watsup:697.5-697.41
+  ;; A-binary.watsup:715.5-715.41
   prod {0xFD `%`_u32(72):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NE_vrelop_)
-  ;; A-binary.watsup:698.5-698.41
+  ;; A-binary.watsup:716.5-716.41
   prod {0xFD `%`_u32(73):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), LT_vrelop_)
-  ;; A-binary.watsup:699.5-699.41
+  ;; A-binary.watsup:717.5-717.41
   prod {0xFD `%`_u32(74):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), GT_vrelop_)
-  ;; A-binary.watsup:700.5-700.41
+  ;; A-binary.watsup:718.5-718.41
   prod {0xFD `%`_u32(75):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), LE_vrelop_)
-  ;; A-binary.watsup:701.5-701.41
+  ;; A-binary.watsup:719.5-719.41
   prod {0xFD `%`_u32(76):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), GE_vrelop_)
-  ;; A-binary.watsup:705.5-705.36
+  ;; A-binary.watsup:723.5-723.36
   prod {0xFD `%`_u32(77):Bu32} => VVUNOP_instr(V128_vectype, NOT_vvunop)
-  ;; A-binary.watsup:709.5-709.37
+  ;; A-binary.watsup:727.5-727.37
   prod {0xFD `%`_u32(78):Bu32} => VVBINOP_instr(V128_vectype, AND_vvbinop)
-  ;; A-binary.watsup:710.5-710.40
+  ;; A-binary.watsup:728.5-728.40
   prod {0xFD `%`_u32(79):Bu32} => VVBINOP_instr(V128_vectype, ANDNOT_vvbinop)
-  ;; A-binary.watsup:711.5-711.36
+  ;; A-binary.watsup:729.5-729.36
   prod {0xFD `%`_u32(80):Bu32} => VVBINOP_instr(V128_vectype, OR_vvbinop)
-  ;; A-binary.watsup:712.5-712.37
+  ;; A-binary.watsup:730.5-730.37
   prod {0xFD `%`_u32(81):Bu32} => VVBINOP_instr(V128_vectype, XOR_vvbinop)
-  ;; A-binary.watsup:716.5-716.44
+  ;; A-binary.watsup:734.5-734.44
   prod {0xFD `%`_u32(82):Bu32} => VVTERNOP_instr(V128_vectype, BITSELECT_vvternop)
-  ;; A-binary.watsup:720.5-720.43
+  ;; A-binary.watsup:738.5-738.43
   prod {0xFD `%`_u32(83):Bu32} => VVTESTOP_instr(V128_vectype, ANY_TRUE_vvtestop)
-  ;; A-binary.watsup:724.5-724.41
+  ;; A-binary.watsup:742.5-742.41
   prod {0xFD `%`_u32(96):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ABS_vunop_)
-  ;; A-binary.watsup:725.5-725.41
+  ;; A-binary.watsup:743.5-743.41
   prod {0xFD `%`_u32(97):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), NEG_vunop_)
-  ;; A-binary.watsup:726.5-726.44
+  ;; A-binary.watsup:744.5-744.44
   prod {0xFD `%`_u32(98):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), POPCNT_vunop_)
-  ;; A-binary.watsup:730.5-730.48
+  ;; A-binary.watsup:748.5-748.48
   prod {0xFD `%`_u32(99):Bu32} => VTESTOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:734.5-734.41
+  ;; A-binary.watsup:752.5-752.41
   prod {0xFD `%`_u32(100):Bu32} => VBITMASK_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)))
-  ;; A-binary.watsup:738.5-738.53
+  ;; A-binary.watsup:756.5-756.53
   prod {0xFD `%`_u32(101):Bu32} => VNARROW_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), S_sx)
-  ;; A-binary.watsup:739.5-739.53
+  ;; A-binary.watsup:757.5-757.53
   prod {0xFD `%`_u32(102):Bu32} => VNARROW_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), U_sx)
-  ;; A-binary.watsup:743.5-743.45
+  ;; A-binary.watsup:761.5-761.45
   prod {0xFD `%`_u32(107):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHL_vshiftop_)
-  ;; A-binary.watsup:744.5-744.49
+  ;; A-binary.watsup:762.5-762.49
   prod {0xFD `%`_u32(108):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:745.5-745.49
+  ;; A-binary.watsup:763.5-763.49
   prod {0xFD `%`_u32(109):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:749.5-749.43
+  ;; A-binary.watsup:767.5-767.43
   prod {0xFD `%`_u32(110):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_vbinop_)
-  ;; A-binary.watsup:750.5-750.51
+  ;; A-binary.watsup:768.5-768.51
   prod {0xFD `%`_u32(111):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:751.5-751.51
+  ;; A-binary.watsup:769.5-769.51
   prod {0xFD `%`_u32(112):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:752.5-752.43
+  ;; A-binary.watsup:770.5-770.43
   prod {0xFD `%`_u32(113):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_vbinop_)
-  ;; A-binary.watsup:753.5-753.51
+  ;; A-binary.watsup:771.5-771.51
   prod {0xFD `%`_u32(114):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:754.5-754.51
+  ;; A-binary.watsup:772.5-772.51
   prod {0xFD `%`_u32(115):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:755.5-755.47
+  ;; A-binary.watsup:773.5-773.47
   prod {0xFD `%`_u32(118):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:756.5-756.47
+  ;; A-binary.watsup:774.5-774.47
   prod {0xFD `%`_u32(119):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:757.5-757.47
+  ;; A-binary.watsup:775.5-775.47
   prod {0xFD `%`_u32(120):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:758.5-758.47
+  ;; A-binary.watsup:776.5-776.47
   prod {0xFD `%`_u32(121):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:759.5-759.48
+  ;; A-binary.watsup:777.5-777.48
   prod {0xFD `%`_u32(123):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), `AVGRU`_vbinop_)
-  ;; A-binary.watsup:763.5-763.72
+  ;; A-binary.watsup:781.5-781.72
   prod {0xFD `%`_u32(124):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTADD_PAIRWISE_vextunop__(S_sx))
-  ;; A-binary.watsup:764.5-764.72
+  ;; A-binary.watsup:782.5-782.72
   prod {0xFD `%`_u32(125):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTADD_PAIRWISE_vextunop__(U_sx))
-  ;; A-binary.watsup:768.5-768.42
+  ;; A-binary.watsup:786.5-786.42
   prod {0xFD `%`_u32(128):Bu32} => VUNOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ABS_vunop_)
-  ;; A-binary.watsup:769.5-769.42
+  ;; A-binary.watsup:787.5-787.42
   prod {0xFD `%`_u32(129):Bu32} => VUNOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), NEG_vunop_)
-  ;; A-binary.watsup:773.5-773.55
+  ;; A-binary.watsup:791.5-791.55
   prod {0xFD `%`_u32(130):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `Q15MULR_SATS`_vbinop_)
-  ;; A-binary.watsup:777.5-777.49
+  ;; A-binary.watsup:795.5-795.49
   prod {0xFD `%`_u32(131):Bu32} => VTESTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:781.5-781.41
+  ;; A-binary.watsup:799.5-799.41
   prod {0xFD `%`_u32(132):Bu32} => VBITMASK_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)))
-  ;; A-binary.watsup:785.5-785.53
+  ;; A-binary.watsup:803.5-803.53
   prod {0xFD `%`_u32(133):Bu32} => VNARROW_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), S_sx)
-  ;; A-binary.watsup:786.5-786.53
+  ;; A-binary.watsup:804.5-804.53
   prod {0xFD `%`_u32(134):Bu32} => VNARROW_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), U_sx)
-  ;; A-binary.watsup:790.5-790.65
+  ;; A-binary.watsup:808.5-808.65
   prod {0xFD `%`_u32(135):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:791.5-791.66
+  ;; A-binary.watsup:809.5-809.66
   prod {0xFD `%`_u32(136):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:792.5-792.65
+  ;; A-binary.watsup:810.5-810.65
   prod {0xFD `%`_u32(137):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:793.5-793.66
+  ;; A-binary.watsup:811.5-811.66
   prod {0xFD `%`_u32(138):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:797.5-797.45
+  ;; A-binary.watsup:815.5-815.45
   prod {0xFD `%`_u32(139):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHL_vshiftop_)
-  ;; A-binary.watsup:798.5-798.49
+  ;; A-binary.watsup:816.5-816.49
   prod {0xFD `%`_u32(140):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:799.5-799.49
+  ;; A-binary.watsup:817.5-817.49
   prod {0xFD `%`_u32(141):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:803.5-803.43
+  ;; A-binary.watsup:821.5-821.43
   prod {0xFD `%`_u32(142):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_vbinop_)
-  ;; A-binary.watsup:804.5-804.51
+  ;; A-binary.watsup:822.5-822.51
   prod {0xFD `%`_u32(143):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:805.5-805.51
+  ;; A-binary.watsup:823.5-823.51
   prod {0xFD `%`_u32(144):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:806.5-806.43
+  ;; A-binary.watsup:824.5-824.43
   prod {0xFD `%`_u32(145):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_vbinop_)
-  ;; A-binary.watsup:807.5-807.51
+  ;; A-binary.watsup:825.5-825.51
   prod {0xFD `%`_u32(146):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:808.5-808.51
+  ;; A-binary.watsup:826.5-826.51
   prod {0xFD `%`_u32(147):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:809.5-809.43
+  ;; A-binary.watsup:827.5-827.43
   prod {0xFD `%`_u32(149):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MUL_vbinop_)
-  ;; A-binary.watsup:810.5-810.47
+  ;; A-binary.watsup:828.5-828.47
   prod {0xFD `%`_u32(150):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:811.5-811.47
+  ;; A-binary.watsup:829.5-829.47
   prod {0xFD `%`_u32(151):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:812.5-812.47
+  ;; A-binary.watsup:830.5-830.47
   prod {0xFD `%`_u32(152):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:813.5-813.47
+  ;; A-binary.watsup:831.5-831.47
   prod {0xFD `%`_u32(153):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:814.5-814.48
+  ;; A-binary.watsup:832.5-832.48
   prod {0xFD `%`_u32(155):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `AVGRU`_vbinop_)
-  ;; A-binary.watsup:818.5-818.68
+  ;; A-binary.watsup:836.5-836.68
   prod {0xFD `%`_u32(156):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:819.5-819.69
+  ;; A-binary.watsup:837.5-837.69
   prod {0xFD `%`_u32(157):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:820.5-820.68
+  ;; A-binary.watsup:838.5-838.68
   prod {0xFD `%`_u32(158):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:821.5-821.69
+  ;; A-binary.watsup:839.5-839.69
   prod {0xFD `%`_u32(159):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:825.5-825.72
+  ;; A-binary.watsup:843.5-843.72
   prod {0xFD `%`_u32(126):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTADD_PAIRWISE_vextunop__(S_sx))
-  ;; A-binary.watsup:826.5-826.72
+  ;; A-binary.watsup:844.5-844.72
   prod {0xFD `%`_u32(127):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTADD_PAIRWISE_vextunop__(U_sx))
-  ;; A-binary.watsup:830.5-830.42
+  ;; A-binary.watsup:848.5-848.42
   prod {0xFD `%`_u32(160):Bu32} => VUNOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ABS_vunop_)
-  ;; A-binary.watsup:831.5-831.42
+  ;; A-binary.watsup:849.5-849.42
   prod {0xFD `%`_u32(161):Bu32} => VUNOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), NEG_vunop_)
-  ;; A-binary.watsup:835.5-835.49
+  ;; A-binary.watsup:853.5-853.49
   prod {0xFD `%`_u32(163):Bu32} => VTESTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:839.5-839.41
+  ;; A-binary.watsup:857.5-857.41
   prod {0xFD `%`_u32(164):Bu32} => VBITMASK_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)))
-  ;; A-binary.watsup:843.5-843.65
+  ;; A-binary.watsup:861.5-861.65
   prod {0xFD `%`_u32(167):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:844.5-844.66
+  ;; A-binary.watsup:862.5-862.66
   prod {0xFD `%`_u32(168):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:845.5-845.65
+  ;; A-binary.watsup:863.5-863.65
   prod {0xFD `%`_u32(169):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:846.5-846.66
+  ;; A-binary.watsup:864.5-864.66
   prod {0xFD `%`_u32(170):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:850.5-850.45
+  ;; A-binary.watsup:868.5-868.45
   prod {0xFD `%`_u32(171):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHL_vshiftop_)
-  ;; A-binary.watsup:851.5-851.49
+  ;; A-binary.watsup:869.5-869.49
   prod {0xFD `%`_u32(172):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:852.5-852.49
+  ;; A-binary.watsup:870.5-870.49
   prod {0xFD `%`_u32(173):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:856.5-856.43
+  ;; A-binary.watsup:874.5-874.43
   prod {0xFD `%`_u32(174):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ADD_vbinop_)
-  ;; A-binary.watsup:857.5-857.43
+  ;; A-binary.watsup:875.5-875.43
   prod {0xFD `%`_u32(177):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), SUB_vbinop_)
-  ;; A-binary.watsup:858.5-858.43
+  ;; A-binary.watsup:876.5-876.43
   prod {0xFD `%`_u32(181):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MUL_vbinop_)
-  ;; A-binary.watsup:859.5-859.47
+  ;; A-binary.watsup:877.5-877.47
   prod {0xFD `%`_u32(182):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:860.5-860.47
+  ;; A-binary.watsup:878.5-878.47
   prod {0xFD `%`_u32(183):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:861.5-861.47
+  ;; A-binary.watsup:879.5-879.47
   prod {0xFD `%`_u32(184):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:862.5-862.47
+  ;; A-binary.watsup:880.5-880.47
   prod {0xFD `%`_u32(185):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:866.5-866.61
+  ;; A-binary.watsup:884.5-884.61
   prod {0xFD `%`_u32(186):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), `DOTS`_vextbinop__)
-  ;; A-binary.watsup:867.5-867.68
+  ;; A-binary.watsup:885.5-885.68
   prod {0xFD `%`_u32(188):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:868.5-868.69
+  ;; A-binary.watsup:886.5-886.69
   prod {0xFD `%`_u32(189):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:869.5-869.68
+  ;; A-binary.watsup:887.5-887.68
   prod {0xFD `%`_u32(190):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:870.5-870.69
+  ;; A-binary.watsup:888.5-888.69
   prod {0xFD `%`_u32(191):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:874.5-874.42
+  ;; A-binary.watsup:892.5-892.42
   prod {0xFD `%`_u32(192):Bu32} => VUNOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ABS_vunop_)
-  ;; A-binary.watsup:875.5-875.42
+  ;; A-binary.watsup:893.5-893.42
   prod {0xFD `%`_u32(193):Bu32} => VUNOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), NEG_vunop_)
-  ;; A-binary.watsup:879.5-879.49
+  ;; A-binary.watsup:897.5-897.49
   prod {0xFD `%`_u32(195):Bu32} => VTESTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:883.5-883.41
+  ;; A-binary.watsup:901.5-901.41
   prod {0xFD `%`_u32(196):Bu32} => VBITMASK_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)))
-  ;; A-binary.watsup:887.5-887.65
+  ;; A-binary.watsup:905.5-905.65
   prod {0xFD `%`_u32(199):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:888.5-888.66
+  ;; A-binary.watsup:906.5-906.66
   prod {0xFD `%`_u32(200):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:889.5-889.65
+  ;; A-binary.watsup:907.5-907.65
   prod {0xFD `%`_u32(201):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:890.5-890.66
+  ;; A-binary.watsup:908.5-908.66
   prod {0xFD `%`_u32(202):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:894.5-894.45
+  ;; A-binary.watsup:912.5-912.45
   prod {0xFD `%`_u32(203):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHL_vshiftop_)
-  ;; A-binary.watsup:895.5-895.49
+  ;; A-binary.watsup:913.5-913.49
   prod {0xFD `%`_u32(204):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:896.5-896.49
+  ;; A-binary.watsup:914.5-914.49
   prod {0xFD `%`_u32(205):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:900.5-900.43
+  ;; A-binary.watsup:918.5-918.43
   prod {0xFD `%`_u32(206):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ADD_vbinop_)
-  ;; A-binary.watsup:901.5-901.43
+  ;; A-binary.watsup:919.5-919.43
   prod {0xFD `%`_u32(209):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), SUB_vbinop_)
-  ;; A-binary.watsup:902.5-902.43
+  ;; A-binary.watsup:920.5-920.43
   prod {0xFD `%`_u32(213):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), MUL_vbinop_)
-  ;; A-binary.watsup:906.5-906.42
+  ;; A-binary.watsup:924.5-924.42
   prod {0xFD `%`_u32(214):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), EQ_vrelop_)
-  ;; A-binary.watsup:907.5-907.42
+  ;; A-binary.watsup:925.5-925.42
   prod {0xFD `%`_u32(215):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), NE_vrelop_)
-  ;; A-binary.watsup:908.5-908.46
+  ;; A-binary.watsup:926.5-926.46
   prod {0xFD `%`_u32(216):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:909.5-909.46
+  ;; A-binary.watsup:927.5-927.46
   prod {0xFD `%`_u32(217):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:910.5-910.46
+  ;; A-binary.watsup:928.5-928.46
   prod {0xFD `%`_u32(218):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:911.5-911.46
+  ;; A-binary.watsup:929.5-929.46
   prod {0xFD `%`_u32(219):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:915.5-915.68
+  ;; A-binary.watsup:933.5-933.68
   prod {0xFD `%`_u32(220):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:916.5-916.69
+  ;; A-binary.watsup:934.5-934.69
   prod {0xFD `%`_u32(221):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:917.5-917.68
+  ;; A-binary.watsup:935.5-935.68
   prod {0xFD `%`_u32(222):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:918.5-918.69
+  ;; A-binary.watsup:936.5-936.69
   prod {0xFD `%`_u32(223):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:922.5-922.43
+  ;; A-binary.watsup:940.5-940.43
   prod {0xFD `%`_u32(103):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), CEIL_vunop_)
-  ;; A-binary.watsup:923.5-923.44
+  ;; A-binary.watsup:941.5-941.44
   prod {0xFD `%`_u32(104):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), FLOOR_vunop_)
-  ;; A-binary.watsup:924.5-924.44
+  ;; A-binary.watsup:942.5-942.44
   prod {0xFD `%`_u32(105):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_vunop_)
-  ;; A-binary.watsup:925.5-925.46
+  ;; A-binary.watsup:943.5-943.46
   prod {0xFD `%`_u32(106):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NEAREST_vunop_)
-  ;; A-binary.watsup:926.5-926.42
+  ;; A-binary.watsup:944.5-944.42
   prod {0xFD `%`_u32(224):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ABS_vunop_)
-  ;; A-binary.watsup:927.5-927.42
+  ;; A-binary.watsup:945.5-945.42
   prod {0xFD `%`_u32(225):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NEG_vunop_)
-  ;; A-binary.watsup:928.5-928.43
+  ;; A-binary.watsup:946.5-946.43
   prod {0xFD `%`_u32(227):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), SQRT_vunop_)
-  ;; A-binary.watsup:932.5-932.43
+  ;; A-binary.watsup:950.5-950.43
   prod {0xFD `%`_u32(228):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ADD_vbinop_)
-  ;; A-binary.watsup:933.5-933.43
+  ;; A-binary.watsup:951.5-951.43
   prod {0xFD `%`_u32(229):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), SUB_vbinop_)
-  ;; A-binary.watsup:934.5-934.43
+  ;; A-binary.watsup:952.5-952.43
   prod {0xFD `%`_u32(230):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MUL_vbinop_)
-  ;; A-binary.watsup:935.5-935.43
+  ;; A-binary.watsup:953.5-953.43
   prod {0xFD `%`_u32(231):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), DIV_vbinop_)
-  ;; A-binary.watsup:936.5-936.43
+  ;; A-binary.watsup:954.5-954.43
   prod {0xFD `%`_u32(232):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MIN_vbinop_)
-  ;; A-binary.watsup:937.5-937.43
+  ;; A-binary.watsup:955.5-955.43
   prod {0xFD `%`_u32(233):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MAX_vbinop_)
-  ;; A-binary.watsup:938.5-938.44
+  ;; A-binary.watsup:956.5-956.44
   prod {0xFD `%`_u32(234):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), PMIN_vbinop_)
-  ;; A-binary.watsup:939.5-939.44
+  ;; A-binary.watsup:957.5-957.44
   prod {0xFD `%`_u32(235):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), PMAX_vbinop_)
-  ;; A-binary.watsup:943.5-943.43
+  ;; A-binary.watsup:961.5-961.43
   prod {0xFD `%`_u32(116):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), CEIL_vunop_)
-  ;; A-binary.watsup:944.5-944.44
+  ;; A-binary.watsup:962.5-962.44
   prod {0xFD `%`_u32(117):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), FLOOR_vunop_)
-  ;; A-binary.watsup:945.5-945.44
+  ;; A-binary.watsup:963.5-963.44
   prod {0xFD `%`_u32(122):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_vunop_)
-  ;; A-binary.watsup:946.5-946.46
+  ;; A-binary.watsup:964.5-964.46
   prod {0xFD `%`_u32(148):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NEAREST_vunop_)
-  ;; A-binary.watsup:947.5-947.42
+  ;; A-binary.watsup:965.5-965.42
   prod {0xFD `%`_u32(236):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ABS_vunop_)
-  ;; A-binary.watsup:948.5-948.42
+  ;; A-binary.watsup:966.5-966.42
   prod {0xFD `%`_u32(237):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NEG_vunop_)
-  ;; A-binary.watsup:949.5-949.43
+  ;; A-binary.watsup:967.5-967.43
   prod {0xFD `%`_u32(239):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), SQRT_vunop_)
-  ;; A-binary.watsup:953.5-953.43
+  ;; A-binary.watsup:971.5-971.43
   prod {0xFD `%`_u32(240):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ADD_vbinop_)
-  ;; A-binary.watsup:954.5-954.43
+  ;; A-binary.watsup:972.5-972.43
   prod {0xFD `%`_u32(241):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), SUB_vbinop_)
-  ;; A-binary.watsup:955.5-955.43
+  ;; A-binary.watsup:973.5-973.43
   prod {0xFD `%`_u32(242):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MUL_vbinop_)
-  ;; A-binary.watsup:956.5-956.43
+  ;; A-binary.watsup:974.5-974.43
   prod {0xFD `%`_u32(243):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), DIV_vbinop_)
-  ;; A-binary.watsup:957.5-957.43
+  ;; A-binary.watsup:975.5-975.43
   prod {0xFD `%`_u32(244):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MIN_vbinop_)
-  ;; A-binary.watsup:958.5-958.43
+  ;; A-binary.watsup:976.5-976.43
   prod {0xFD `%`_u32(245):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MAX_vbinop_)
-  ;; A-binary.watsup:959.5-959.44
+  ;; A-binary.watsup:977.5-977.44
   prod {0xFD `%`_u32(246):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), PMIN_vbinop_)
-  ;; A-binary.watsup:960.5-960.44
+  ;; A-binary.watsup:978.5-978.44
   prod {0xFD `%`_u32(247):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), PMAX_vbinop_)
-  ;; A-binary.watsup:964.5-964.61
+  ;; A-binary.watsup:982.5-982.61
   prod {0xFD `%`_u32(94):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), DEMOTE_vcvtop__, ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:965.5-965.61
+  ;; A-binary.watsup:983.5-983.61
   prod {0xFD `%`_u32(95):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(F32_lanetype, `%`_dim(4)), PROMOTE_vcvtop__, ?(LOW_half__), ?())
-  ;; A-binary.watsup:966.5-966.64
+  ;; A-binary.watsup:984.5-984.64
   prod {0xFD `%`_u32(248):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_SAT_vcvtop__(S_sx), ?(), ?())
-  ;; A-binary.watsup:967.5-967.64
+  ;; A-binary.watsup:985.5-985.64
   prod {0xFD `%`_u32(249):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_SAT_vcvtop__(U_sx), ?(), ?())
-  ;; A-binary.watsup:968.5-968.62
+  ;; A-binary.watsup:986.5-986.62
   prod {0xFD `%`_u32(250):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(S_sx), ?(), ?())
-  ;; A-binary.watsup:969.5-969.62
+  ;; A-binary.watsup:987.5-987.62
   prod {0xFD `%`_u32(251):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(U_sx), ?(), ?())
-  ;; A-binary.watsup:970.5-970.69
+  ;; A-binary.watsup:988.5-988.69
   prod {0xFD `%`_u32(252):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_SAT_vcvtop__(S_sx), ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:971.5-971.69
+  ;; A-binary.watsup:989.5-989.69
   prod {0xFD `%`_u32(253):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_SAT_vcvtop__(U_sx), ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:972.5-972.66
+  ;; A-binary.watsup:990.5-990.66
   prod {0xFD `%`_u32(254):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:973.5-973.66
+  ;; A-binary.watsup:991.5-991.66
   prod {0xFD `%`_u32(255):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(U_sx), ?(LOW_half__), ?())
 }
 
@@ -7871,6 +8221,16 @@ grammar Bdatacntsec : u32?
   ;; A-binary.watsup
   prod{nopt : nopt} nopt:Bsection_(12, syntax u32, grammar Bdatacnt) => $opt_(syntax u32, nopt)
 
+;; A-binary.watsup
+grammar Btag : tag
+  ;; A-binary.watsup
+  prod{x : idx} x:Btypeidx => TAG_tag(x)
+
+;; A-binary.watsup
+grammar Btagsec : tag*
+  ;; A-binary.watsup
+  prod{tag* : tag*} tag*{tag : tag}:Bsection_(13, syntax tag, grammar Blist(syntax tag, grammar Btag)) => tag*{tag : tag}
+
 ;; A-binary.watsup
 grammar Bmagic : ()
   ;; A-binary.watsup
@@ -7884,7 +8244,7 @@ grammar Bversion : ()
 ;; A-binary.watsup
 grammar Bmodule : module
   ;; A-binary.watsup
-  prod{type* : type*, import* : import*, typeidx* : typeidx*, table* : table*, mem* : mem*, global* : global*, export* : export*, start? : start?, elem* : elem*, n? : n?, local** : local**, expr* : expr*, data* : data*, func* : func*} {Bmagic Bversion Bcustomsec*{} type*{type : type}:Btypesec Bcustomsec*{} import*{import : import}:Bimportsec Bcustomsec*{} typeidx*{typeidx : typeidx}:Bfuncsec Bcustomsec*{} table*{table : table}:Btablesec Bcustomsec*{} mem*{mem : mem}:Bmemsec Bcustomsec*{} global*{global : global}:Bglobalsec Bcustomsec*{} export*{export : export}:Bexportsec Bcustomsec*{} start?{start : start}:Bstartsec Bcustomsec*{} elem*{elem : elem}:Belemsec Bcustomsec*{} `%`_u32(n)?{n : nat}:Bdatacntsec Bcustomsec*{} (local*{local : local}, expr)*{expr : expr, local : local}:Bcodesec Bcustomsec*{} data*{data : data}:Bdatasec Bcustomsec*{}} => MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})
+  prod{type* : type*, import* : import*, typeidx* : typeidx*, table* : table*, mem* : mem*, tag* : tag*, global* : global*, export* : export*, start? : start?, elem* : elem*, n? : n?, local** : local**, expr* : expr*, data* : data*, func* : func*} {Bmagic Bversion Bcustomsec*{} type*{type : type}:Btypesec Bcustomsec*{} import*{import : import}:Bimportsec Bcustomsec*{} typeidx*{typeidx : typeidx}:Bfuncsec Bcustomsec*{} table*{table : table}:Btablesec Bcustomsec*{} mem*{mem : mem}:Bmemsec Bcustomsec*{} tag*{tag : tag}:Btagsec Bcustomsec*{} global*{global : global}:Bglobalsec Bcustomsec*{} export*{export : export}:Bexportsec Bcustomsec*{} start?{start : start}:Bstartsec Bcustomsec*{} elem*{elem : elem}:Belemsec Bcustomsec*{} `%`_u32(n)?{n : nat}:Bdatacntsec Bcustomsec*{} (local*{local : local}, expr)*{expr : expr, local : local}:Bcodesec Bcustomsec*{} data*{data : data}:Bdatasec Bcustomsec*{}} => MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})
     -- (if (n = |data*{data : data}|))?{n : n}
     -- if ((n?{n : n} =/= ?()) \/ ($dataidx_funcs(func*{func : func}) = []))
     -- (if (func = FUNC_func(typeidx, local*{local : local}, expr)))*{expr : expr, func : func, local : local, typeidx : typeidx}
@@ -7959,7 +8319,7 @@ relation NotationTypingInstrScheme: `%|-%:%`(context, instr*, functype)
   rule block{C : context, blocktype : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, [BLOCK_instr(blocktype, instr*{instr : instr})], `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, blocktype, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- NotationTypingInstrScheme: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
+    -- NotationTypingInstrScheme: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
 }
 
 ;; C-conventions.watsup
diff --git a/spectec/test-interpreter/TEST.md b/spectec/test-interpreter/TEST.md
index 28c621f413..04a888864d 100644
--- a/spectec/test-interpreter/TEST.md
+++ b/spectec/test-interpreter/TEST.md
@@ -1158,7 +1158,7 @@ watsup 0.4 generator
 - 20/20 (100.00%)
 
 ===== ../../test-interpreter/spec-test-3/ref_null.wast =====
-- 26/26 (100.00%)
+- 34/34 (100.00%)
 
 ===== ../../test-interpreter/spec-test-3/return.wast =====
 - 64/64 (100.00%)
@@ -1394,12 +1394,24 @@ watsup 0.4 generator
 ===== ../../test-interpreter/spec-test-3/table_size.wast =====
 - 37/37 (100.00%)
 
+===== ../../test-interpreter/spec-test-3/tag.wast =====
+- 4/4 (100.00%)
+
+===== ../../test-interpreter/spec-test-3/throw.wast =====
+- 3/3 (100.00%)
+
+===== ../../test-interpreter/spec-test-3/throw_ref.wast =====
+- 6/6 (100.00%)
+
 ===== ../../test-interpreter/spec-test-3/token.wast =====
 - 35/35 (100.00%)
 
 ===== ../../test-interpreter/spec-test-3/traps.wast =====
 - 36/36 (100.00%)
 
+===== ../../test-interpreter/spec-test-3/try_table.wast =====
+- 45/45 (100.00%)
+
 ===== ../../test-interpreter/spec-test-3/type-canon.wast =====
 - 2/2 (100.00%)
 
@@ -1436,7 +1448,7 @@ watsup 0.4 generator
 ===== ../../test-interpreter/spec-test-3/utf8-invalid-encoding.wast =====
 - 0/0 (100.00%)
 
-Total [46897/46897] (100.00%)
+Total [46963/46963] (100.00%)
 
 == Complete.
 ```
diff --git a/spectec/test-latex/TEST.md b/spectec/test-latex/TEST.md
index 00cb916d89..7dca496be6 100644
--- a/spectec/test-latex/TEST.md
+++ b/spectec/test-latex/TEST.md
@@ -1806,6 +1806,7 @@ $$
 \mbox{(global index)} & {\mathit{globalidx}} &::=& {\mathit{idx}} \\
 \mbox{(table index)} & {\mathit{tableidx}} &::=& {\mathit{idx}} \\
 \mbox{(memory index)} & {\mathit{memidx}} &::=& {\mathit{idx}} \\
+\mbox{(tag index)} & {\mathit{tagidx}} &::=& {\mathit{idx}} \\
 \mbox{(elem index)} & {\mathit{elemidx}} &::=& {\mathit{idx}} \\
 \mbox{(data index)} & {\mathit{dataidx}} &::=& {\mathit{idx}} \\
 \mbox{(label index)} & {\mathit{labelidx}} &::=& {\mathit{idx}} \\
@@ -1828,6 +1829,7 @@ $$
 \mbox{(literal type)} & {\mathit{consttype}} &::=& {\mathit{numtype}} ~|~ {\mathit{vectype}} \\
 & {\mathit{absheaptype}} &::=& \mathsf{any} ~|~ \mathsf{eq} ~|~ \mathsf{i{\scriptstyle 31}} ~|~ \mathsf{struct} ~|~ \mathsf{array} ~|~ \mathsf{none} \\ &&|&
 \mathsf{func} ~|~ \mathsf{nofunc} \\ &&|&
+\mathsf{exn} ~|~ \mathsf{noexn} \\ &&|&
 \mathsf{extern} ~|~ \mathsf{noextern} \\ &&|&
 \mathsf{bot} \\
 \end{array}
@@ -1954,9 +1956,10 @@ $$
 \mbox{(global type)} & {\mathit{globaltype}} &::=& {\mathsf{mut}^?}~{\mathit{valtype}} \\
 \mbox{(table type)} & {\mathit{tabletype}} &::=& {\mathit{limits}}~{\mathit{reftype}} \\
 \mbox{(memory type)} & {\mathit{memtype}} &::=& {\mathit{limits}}~\mathsf{page} \\
+\mbox{(memory type)} & {\mathit{tagtype}} &::=& {\mathit{deftype}} \\
 \mbox{(element type)} & {\mathit{elemtype}} &::=& {\mathit{reftype}} \\
 \mbox{(data type)} & {\mathit{datatype}} &::=& \mathsf{ok} \\
-\mbox{(external type)} & {\mathit{externtype}} &::=& \mathsf{func}~{\mathit{typeuse}} ~|~ \mathsf{global}~{\mathit{globaltype}} ~|~ \mathsf{table}~{\mathit{tabletype}} ~|~ \mathsf{mem}~{\mathit{memtype}} \\
+\mbox{(external type)} & {\mathit{externtype}} &::=& \mathsf{func}~{\mathit{typeuse}} ~|~ \mathsf{global}~{\mathit{globaltype}} ~|~ \mathsf{table}~{\mathit{tabletype}} ~|~ \mathsf{mem}~{\mathit{memtype}} ~|~ \mathsf{tag}~{\mathit{typeuse}} \\
 \mbox{(module type)} & {\mathit{moduletype}} &::=& {{\mathit{externtype}}^\ast} \rightarrow {{\mathit{externtype}}^\ast} \\
 \end{array}
 $$
@@ -2278,6 +2281,22 @@ $$
 \mathsf{return\_call}~{\mathit{funcidx}} \\ &&|&
 \mathsf{return\_call\_ref}~{\mathit{typeuse}} \\ &&|&
 \mathsf{return\_call\_indirect}~{\mathit{tableidx}}~{\mathit{typeuse}} \\ &&|&
+\mathsf{throw}~{\mathit{tagidx}} \\ &&|&
+\mathsf{throw\_ref} \\ &&|&
+\mathsf{try\_table}~{\mathit{blocktype}}~{\mathit{list}}({\mathit{catch}})~{{\mathit{instr}}^\ast} \\ &&|&
+\ldots \\
+\mbox{(catch clause)} & {\mathit{catch}} &::=& \mathsf{catch}~{\mathit{tagidx}}~{\mathit{labelidx}} \\ &&|&
+\mathsf{catch\_ref}~{\mathit{tagidx}}~{\mathit{labelidx}} \\ &&|&
+\mathsf{catch\_all}~{\mathit{labelidx}} \\ &&|&
+\mathsf{catch\_all\_ref}~{\mathit{labelidx}} \\
+\end{array}
+$$
+
+\vspace{1ex}
+
+$$
+\begin{array}{@{}lrrl@{}l@{}}
+\mbox{(instruction)} & {\mathit{instr}} &::=& \ldots \\ &&|&
 {\mathit{numtype}}{.}\mathsf{const}~{{\mathit{num}}}_{{\mathit{numtype}}} \\ &&|&
 {\mathit{numtype}} {.} {{\mathit{unop}}}_{{\mathit{numtype}}} \\ &&|&
 {\mathit{numtype}} {.} {{\mathit{binop}}}_{{\mathit{numtype}}} \\ &&|&
@@ -2385,13 +2404,14 @@ $$
 \mbox{(global)} & {\mathit{global}} &::=& \mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}} \\
 \mbox{(table)} & {\mathit{table}} &::=& \mathsf{table}~{\mathit{tabletype}}~{\mathit{expr}} \\
 \mbox{(memory)} & {\mathit{mem}} &::=& \mathsf{memory}~{\mathit{memtype}} \\
+\mbox{(tag)} & {\mathit{tag}} &::=& \mathsf{tag}~{\mathit{typeidx}} \\
 \mbox{(table segment)} & {\mathit{elem}} &::=& \mathsf{elem}~{\mathit{reftype}}~{{\mathit{expr}}^\ast}~{\mathit{elemmode}} \\
 \mbox{(memory segment)} & {\mathit{data}} &::=& \mathsf{data}~{{\mathit{byte}}^\ast}~{\mathit{datamode}} \\
 \mbox{(start function)} & {\mathit{start}} &::=& \mathsf{start}~{\mathit{funcidx}} \\
-\mbox{(external index)} & {\mathit{externidx}} &::=& \mathsf{func}~{\mathit{funcidx}} ~|~ \mathsf{global}~{\mathit{globalidx}} ~|~ \mathsf{table}~{\mathit{tableidx}} ~|~ \mathsf{mem}~{\mathit{memidx}} \\
+\mbox{(external index)} & {\mathit{externidx}} &::=& \mathsf{func}~{\mathit{funcidx}} ~|~ \mathsf{global}~{\mathit{globalidx}} ~|~ \mathsf{table}~{\mathit{tableidx}} ~|~ \mathsf{mem}~{\mathit{memidx}} ~|~ \mathsf{tag}~{\mathit{tagidx}} \\
 \mbox{(export)} & {\mathit{export}} &::=& \mathsf{export}~{\mathit{name}}~{\mathit{externidx}} \\
 \mbox{(import)} & {\mathit{import}} &::=& \mathsf{import}~{\mathit{name}}~{\mathit{name}}~{\mathit{externtype}} \\
-\mbox{(module)} & {\mathit{module}} &::=& \mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast} \\
+\mbox{(module)} & {\mathit{module}} &::=& \mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast} \\
 \end{array}
 $$
 
@@ -3051,6 +3071,12 @@ $$
 \end{array}
 $$
 
+$$
+\begin{array}{@{}lcl@{}l@{}}
+{\mathrm{free}}_{\mathit{tag}}(\mathsf{tag}~{\mathit{typeidx}}) &=& {\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}}) \\
+\end{array}
+$$
+
 $$
 \begin{array}{@{}lcl@{}l@{}}
 {\mathrm{free}}_{\mathit{elemmode}}(\mathsf{active}~{\mathit{tableidx}}~{\mathit{expr}}) &=& {\mathrm{free}}_{\mathit{tableidx}}({\mathit{tableidx}}) \oplus {\mathrm{free}}_{\mathit{expr}}({\mathit{expr}}) \\
@@ -3103,7 +3129,7 @@ $$
 
 $$
 \begin{array}{@{}lcl@{}l@{}}
-{\mathrm{free}}_{\mathit{module}}(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast}) &=& {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{type}}({\mathit{type}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{import}}({\mathit{import}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{func}}({\mathit{func}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{global}}({\mathit{global}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{table}}({\mathit{table}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{mem}}({\mathit{mem}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{elem}}({\mathit{elem}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{data}}({\mathit{data}})^\ast}) \oplus {\mathrm{free}}_{\mathit{opt}}({{\mathrm{free}}_{\mathit{start}}({\mathit{start}})^?}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{export}}({\mathit{export}})^\ast}) \\
+{\mathrm{free}}_{\mathit{module}}(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast}) &=& {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{type}}({\mathit{type}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{import}}({\mathit{import}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{func}}({\mathit{func}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{global}}({\mathit{global}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{table}}({\mathit{table}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{mem}}({\mathit{mem}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{tag}}({\mathit{tag}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{elem}}({\mathit{elem}})^\ast}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{data}}({\mathit{data}})^\ast}) \oplus {\mathrm{free}}_{\mathit{opt}}({{\mathrm{free}}_{\mathit{start}}({\mathit{start}})^?}) \oplus {\mathrm{free}}_{\mathit{list}}({{\mathrm{free}}_{\mathit{export}}({\mathit{export}})^\ast}) \\
 \end{array}
 $$
 
@@ -3381,6 +3407,15 @@ $$
 \end{array}
 $$
 
+$$
+\begin{array}{@{}lcl@{}l@{}}
+{\mathrm{tags}}(\epsilon) &=& \epsilon \\
+{\mathrm{tags}}((\mathsf{tag}~x)~{{\mathit{xx}}^\ast}) &=& x~{\mathrm{tags}}({{\mathit{xx}}^\ast}) \\
+{\mathrm{tags}}({\mathit{externidx}}~{{\mathit{xx}}^\ast}) &=& {\mathrm{tags}}({{\mathit{xx}}^\ast})
+  &\qquad \mbox{otherwise} \\
+\end{array}
+$$
+
 \vspace{1ex}
 
 $$
@@ -3419,6 +3454,15 @@ $$
 \end{array}
 $$
 
+$$
+\begin{array}{@{}lcl@{}l@{}}
+{\mathrm{tags}}(\epsilon) &=& \epsilon \\
+{\mathrm{tags}}((\mathsf{tag}~{\mathit{at}})~{{\mathit{xt}}^\ast}) &=& {\mathit{at}}~{\mathrm{tags}}({{\mathit{xt}}^\ast}) \\
+{\mathrm{tags}}({\mathit{externtype}}~{{\mathit{xt}}^\ast}) &=& {\mathrm{tags}}({{\mathit{xt}}^\ast})
+  &\qquad \mbox{otherwise} \\
+\end{array}
+$$
+
 \vspace{1ex}
 
 \vspace{1ex}
@@ -3895,11 +3939,14 @@ $$
 \mbox{(global address)} & {\mathit{globaladdr}} &::=& {\mathit{addr}} \\
 \mbox{(table address)} & {\mathit{tableaddr}} &::=& {\mathit{addr}} \\
 \mbox{(memory address)} & {\mathit{memaddr}} &::=& {\mathit{addr}} \\
+\mbox{(tag address)} & {\mathit{tagaddr}} &::=& {\mathit{addr}} \\
 \mbox{(elem address)} & {\mathit{elemaddr}} &::=& {\mathit{addr}} \\
 \mbox{(data address)} & {\mathit{dataaddr}} &::=& {\mathit{addr}} \\
 \mbox{(host address)} & {\mathit{hostaddr}} &::=& {\mathit{addr}} \\
 \mbox{(structure address)} & {\mathit{structaddr}} &::=& {\mathit{addr}} \\
 \mbox{(array address)} & {\mathit{arrayaddr}} &::=& {\mathit{addr}} \\
+\mbox{(exception address)} & {\mathit{exnaddr}} &::=& {\mathit{addr}} \\
+\mbox{(external address)} & {\mathit{externaddr}} &::=& \mathsf{func}~{\mathit{funcaddr}} ~|~ \mathsf{global}~{\mathit{globaladdr}} ~|~ \mathsf{table}~{\mathit{tableaddr}} ~|~ \mathsf{mem}~{\mathit{memaddr}} ~|~ \mathsf{tag}~{\mathit{tagaddr}} \\
 \end{array}
 $$
 
@@ -3915,20 +3962,13 @@ $$
 \mathsf{ref{.}struct}~{\mathit{structaddr}} \\ &&|&
 \mathsf{ref{.}array}~{\mathit{arrayaddr}} \\ &&|&
 \mathsf{ref{.}func}~{\mathit{funcaddr}} \\ &&|&
+\mathsf{ref{.}exn}~{\mathit{exnaddr}} \\ &&|&
 \mathsf{ref{.}host}~{\mathit{hostaddr}} \\ &&|&
 \mathsf{ref{.}extern}~{\mathit{addrref}} \\
 \mbox{(reference value)} & {\mathit{ref}} &::=& {\mathit{addrref}} \\ &&|&
 \mathsf{ref{.}null}~{\mathit{heaptype}} \\
 \mbox{(value)} & {\mathit{val}} &::=& {\mathit{num}} ~|~ {\mathit{vec}} ~|~ {\mathit{ref}} \\
-\mbox{(result)} & {\mathit{result}} &::=& {{\mathit{val}}^\ast} ~|~ \mathsf{trap} \\
-\end{array}
-$$
-
-\vspace{1ex}
-
-$$
-\begin{array}{@{}lrrl@{}l@{}}
-\mbox{(external value)} & {\mathit{externval}} &::=& \mathsf{func}~{\mathit{funcaddr}} ~|~ \mathsf{global}~{\mathit{globaladdr}} ~|~ \mathsf{table}~{\mathit{tableaddr}} ~|~ \mathsf{mem}~{\mathit{memaddr}} \\
+\mbox{(result)} & {\mathit{result}} &::=& {{\mathit{val}}^\ast} ~|~ (\mathsf{ref{.}exn\_addr}~{\mathit{exnaddr}})~\mathsf{throw\_ref} ~|~ \mathsf{trap} \\
 \end{array}
 $$
 
@@ -3948,24 +3988,36 @@ $$
 \mathsf{type}~{\mathit{tabletype}},\; \mathsf{refs}~{{\mathit{ref}}^\ast} \}\end{array} \\
 \mbox{(memory instance)} & {\mathit{meminst}} &::=& \{ \begin{array}[t]{@{}l@{}l@{}}
 \mathsf{type}~{\mathit{memtype}},\; \mathsf{bytes}~{{\mathit{byte}}^\ast} \}\end{array} \\
+\mbox{(tag instance)} & {\mathit{taginst}} &::=& \{ \begin{array}[t]{@{}l@{}l@{}}
+\mathsf{type}~{\mathit{tagtype}} \}\end{array} \\
 \mbox{(element instance)} & {\mathit{eleminst}} &::=& \{ \begin{array}[t]{@{}l@{}l@{}}
 \mathsf{type}~{\mathit{elemtype}},\; \mathsf{refs}~{{\mathit{ref}}^\ast} \}\end{array} \\
 \mbox{(data instance)} & {\mathit{datainst}} &::=& \{ \begin{array}[t]{@{}l@{}l@{}}
 \mathsf{bytes}~{{\mathit{byte}}^\ast} \}\end{array} \\
 \mbox{(export instance)} & {\mathit{exportinst}} &::=& \{ \begin{array}[t]{@{}l@{}l@{}}
-\mathsf{name}~{\mathit{name}},\; \mathsf{value}~{\mathit{externval}} \}\end{array} \\
+\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~{\mathit{externaddr}} \}\end{array} \\
 \mbox{(packed value)} & {\mathit{packval}} &::=& {\mathit{packtype}}{.}\mathsf{pack}~{i}{N} \\
 \mbox{(field value)} & {\mathit{fieldval}} &::=& {\mathit{val}} ~|~ {\mathit{packval}} \\
 \mbox{(structure instance)} & {\mathit{structinst}} &::=& \{ \begin{array}[t]{@{}l@{}l@{}}
 \mathsf{type}~{\mathit{deftype}},\; \mathsf{fields}~{{\mathit{fieldval}}^\ast} \}\end{array} \\
 \mbox{(array instance)} & {\mathit{arrayinst}} &::=& \{ \begin{array}[t]{@{}l@{}l@{}}
 \mathsf{type}~{\mathit{deftype}},\; \mathsf{fields}~{{\mathit{fieldval}}^\ast} \}\end{array} \\
+\mbox{(exception instance)} & {\mathit{exninst}} &::=& \{ \begin{array}[t]{@{}l@{}l@{}}
+\mathsf{tag}~{\mathit{tagaddr}},\; \mathsf{fields}~{{\mathit{val}}^\ast} \}\end{array} \\
+\end{array}
+$$
+
+\vspace{1ex}
+
+$$
+\begin{array}{@{}lrrl@{}l@{}}
 \mbox{(module instance)} & {\mathit{moduleinst}} &::=& \{ \begin{array}[t]{@{}l@{}l@{}}
 \mathsf{types}~{{\mathit{deftype}}^\ast},\; \\
   \mathsf{funcs}~{{\mathit{funcaddr}}^\ast},\; \\
   \mathsf{globals}~{{\mathit{globaladdr}}^\ast},\; \\
   \mathsf{tables}~{{\mathit{tableaddr}}^\ast},\; \\
   \mathsf{mems}~{{\mathit{memaddr}}^\ast},\; \\
+  \mathsf{tags}~{{\mathit{tagaddr}}^\ast},\; \\
   \mathsf{elems}~{{\mathit{elemaddr}}^\ast},\; \\
   \mathsf{datas}~{{\mathit{dataaddr}}^\ast},\; \\
   \mathsf{exports}~{{\mathit{exportinst}}^\ast} \}\end{array} \\
@@ -3981,10 +4033,12 @@ $$
   \mathsf{globals}~{{\mathit{globalinst}}^\ast},\; \\
   \mathsf{tables}~{{\mathit{tableinst}}^\ast},\; \\
   \mathsf{mems}~{{\mathit{meminst}}^\ast},\; \\
+  \mathsf{tags}~{{\mathit{taginst}}^\ast},\; \\
   \mathsf{elems}~{{\mathit{eleminst}}^\ast},\; \\
   \mathsf{datas}~{{\mathit{datainst}}^\ast},\; \\
   \mathsf{structs}~{{\mathit{structinst}}^\ast},\; \\
-  \mathsf{arrays}~{{\mathit{arrayinst}}^\ast} \}\end{array} \\
+  \mathsf{arrays}~{{\mathit{arrayinst}}^\ast},\; \\
+  \mathsf{exns}~{{\mathit{exninst}}^\ast} \}\end{array} \\
 \mbox{(frame)} & {\mathit{frame}} &::=& \{ \begin{array}[t]{@{}l@{}l@{}}
 \mathsf{locals}~{({{\mathit{val}}^?})^\ast},\; \mathsf{module}~{\mathit{moduleinst}} \}\end{array} \\
 \mbox{(state)} & {\mathit{state}} &::=& {\mathit{store}} ; {\mathit{frame}} \\
@@ -4000,6 +4054,7 @@ $$
 {\mathit{addrref}} \\ &&|&
 {{\mathsf{label}}_{n}}{\{ {{\mathit{instr}}^\ast} \}}~{{\mathit{instr}}^\ast} \\ &&|&
 {{\mathsf{frame}}_{n}}{\{ {\mathit{frame}} \}}~{{\mathit{instr}}^\ast} \\ &&|&
+{{\mathsf{handler}}_{n}}{\{ {{\mathit{catch}}^\ast} \}}~{{\mathit{instr}}^\ast} \\ &&|&
 \mathsf{trap} \\
 \end{array}
 $$
@@ -4055,8 +4110,8 @@ $$
 $$
 \begin{array}{@{}lcl@{}l@{}}
 {\mathrm{funcs}}(\epsilon) &=& \epsilon \\
-{\mathrm{funcs}}((\mathsf{func}~{\mathit{fa}})~{{\mathit{xv}}^\ast}) &=& {\mathit{fa}}~{\mathrm{funcs}}({{\mathit{xv}}^\ast}) \\
-{\mathrm{funcs}}({\mathit{externval}}~{{\mathit{xv}}^\ast}) &=& {\mathrm{funcs}}({{\mathit{xv}}^\ast})
+{\mathrm{funcs}}((\mathsf{func}~{\mathit{fa}})~{{\mathit{xa}}^\ast}) &=& {\mathit{fa}}~{\mathrm{funcs}}({{\mathit{xa}}^\ast}) \\
+{\mathrm{funcs}}({\mathit{externaddr}}~{{\mathit{xa}}^\ast}) &=& {\mathrm{funcs}}({{\mathit{xa}}^\ast})
   &\qquad \mbox{otherwise} \\
 \end{array}
 $$
@@ -4064,8 +4119,8 @@ $$
 $$
 \begin{array}{@{}lcl@{}l@{}}
 {\mathrm{globals}}(\epsilon) &=& \epsilon \\
-{\mathrm{globals}}((\mathsf{global}~{\mathit{ga}})~{{\mathit{xv}}^\ast}) &=& {\mathit{ga}}~{\mathrm{globals}}({{\mathit{xv}}^\ast}) \\
-{\mathrm{globals}}({\mathit{externval}}~{{\mathit{xv}}^\ast}) &=& {\mathrm{globals}}({{\mathit{xv}}^\ast})
+{\mathrm{globals}}((\mathsf{global}~{\mathit{ga}})~{{\mathit{xa}}^\ast}) &=& {\mathit{ga}}~{\mathrm{globals}}({{\mathit{xa}}^\ast}) \\
+{\mathrm{globals}}({\mathit{externaddr}}~{{\mathit{xa}}^\ast}) &=& {\mathrm{globals}}({{\mathit{xa}}^\ast})
   &\qquad \mbox{otherwise} \\
 \end{array}
 $$
@@ -4073,8 +4128,8 @@ $$
 $$
 \begin{array}{@{}lcl@{}l@{}}
 {\mathrm{tables}}(\epsilon) &=& \epsilon \\
-{\mathrm{tables}}((\mathsf{table}~{\mathit{ta}})~{{\mathit{xv}}^\ast}) &=& {\mathit{ta}}~{\mathrm{tables}}({{\mathit{xv}}^\ast}) \\
-{\mathrm{tables}}({\mathit{externval}}~{{\mathit{xv}}^\ast}) &=& {\mathrm{tables}}({{\mathit{xv}}^\ast})
+{\mathrm{tables}}((\mathsf{table}~{\mathit{ta}})~{{\mathit{xa}}^\ast}) &=& {\mathit{ta}}~{\mathrm{tables}}({{\mathit{xa}}^\ast}) \\
+{\mathrm{tables}}({\mathit{externaddr}}~{{\mathit{xa}}^\ast}) &=& {\mathrm{tables}}({{\mathit{xa}}^\ast})
   &\qquad \mbox{otherwise} \\
 \end{array}
 $$
@@ -4082,8 +4137,17 @@ $$
 $$
 \begin{array}{@{}lcl@{}l@{}}
 {\mathrm{mems}}(\epsilon) &=& \epsilon \\
-{\mathrm{mems}}((\mathsf{mem}~{\mathit{ma}})~{{\mathit{xv}}^\ast}) &=& {\mathit{ma}}~{\mathrm{mems}}({{\mathit{xv}}^\ast}) \\
-{\mathrm{mems}}({\mathit{externval}}~{{\mathit{xv}}^\ast}) &=& {\mathrm{mems}}({{\mathit{xv}}^\ast})
+{\mathrm{mems}}((\mathsf{mem}~{\mathit{ma}})~{{\mathit{xa}}^\ast}) &=& {\mathit{ma}}~{\mathrm{mems}}({{\mathit{xa}}^\ast}) \\
+{\mathrm{mems}}({\mathit{externaddr}}~{{\mathit{xa}}^\ast}) &=& {\mathrm{mems}}({{\mathit{xa}}^\ast})
+  &\qquad \mbox{otherwise} \\
+\end{array}
+$$
+
+$$
+\begin{array}{@{}lcl@{}l@{}}
+{\mathrm{tags}}(\epsilon) &=& \epsilon \\
+{\mathrm{tags}}((\mathsf{tag}~{\mathit{ha}})~{{\mathit{xa}}^\ast}) &=& {\mathit{ha}}~{\mathrm{tags}}({{\mathit{xa}}^\ast}) \\
+{\mathrm{tags}}({\mathit{externaddr}}~{{\mathit{xa}}^\ast}) &=& {\mathrm{tags}}({{\mathit{xa}}^\ast})
   &\qquad \mbox{otherwise} \\
 \end{array}
 $$
@@ -4104,6 +4168,12 @@ $$
 \end{array}
 $$
 
+$$
+\begin{array}{@{}lcl@{}l@{}}
+(s ; f){.}\mathsf{tags} &=& f{.}\mathsf{module}{.}\mathsf{tags} \\
+\end{array}
+$$
+
 $$
 \begin{array}{@{}lcl@{}l@{}}
 (s ; f){.}\mathsf{module} &=& f{.}\mathsf{module} \\
@@ -4134,6 +4204,12 @@ $$
 \end{array}
 $$
 
+$$
+\begin{array}{@{}lcl@{}l@{}}
+(s ; f){.}\mathsf{tags} &=& s{.}\mathsf{tags} \\
+\end{array}
+$$
+
 $$
 \begin{array}{@{}lcl@{}l@{}}
 (s ; f){.}\mathsf{elems} &=& s{.}\mathsf{elems} \\
@@ -4158,6 +4234,12 @@ $$
 \end{array}
 $$
 
+$$
+\begin{array}{@{}lcl@{}l@{}}
+(s ; f){.}\mathsf{exns} &=& s{.}\mathsf{exns} \\
+\end{array}
+$$
+
 $$
 \begin{array}{@{}lcl@{}l@{}}
 (s ; f){.}\mathsf{types}{}[x] &=& f{.}\mathsf{module}{.}\mathsf{types}{}[x] \\
@@ -4188,6 +4270,12 @@ $$
 \end{array}
 $$
 
+$$
+\begin{array}{@{}lcl@{}l@{}}
+(s ; f){.}\mathsf{tags}{}[x] &=& s{.}\mathsf{tags}{}[f{.}\mathsf{module}{.}\mathsf{tags}{}[x]] \\
+\end{array}
+$$
+
 $$
 \begin{array}{@{}lcl@{}l@{}}
 (s ; f){.}\mathsf{elems}{}[x] &=& s{.}\mathsf{elems}{}[f{.}\mathsf{module}{.}\mathsf{elems}{}[x]] \\
@@ -4280,6 +4368,12 @@ $$
 \end{array}
 $$
 
+$$
+\begin{array}{@{}lcl@{}l@{}}
+(s ; f){}[{.}\mathsf{exns} \mathrel{{=}{\oplus}} {{\mathit{exn}}^\ast}] &=& s{}[{.}\mathsf{exns} \mathrel{{=}{\oplus}} {{\mathit{exn}}^\ast}] ; f \\
+\end{array}
+$$
+
 \vspace{1ex}
 
 $$
@@ -4323,6 +4417,7 @@ $$
   \mathsf{globals}~{{\mathit{globaltype}}^\ast},\; \\
   \mathsf{tables}~{{\mathit{tabletype}}^\ast},\; \\
   \mathsf{mems}~{{\mathit{memtype}}^\ast},\; \\
+  \mathsf{tags}~{{\mathit{tagtype}}^\ast},\; \\
   \mathsf{elems}~{{\mathit{elemtype}}^\ast},\; \\
   \mathsf{datas}~{{\mathit{datatype}}^\ast},\; \\
   \mathsf{locals}~{{\mathit{localtype}}^\ast},\; \\
@@ -4785,6 +4880,8 @@ $\boxed{{\mathit{context}} \vdash {\mathit{tabletype}} : \mathsf{ok}}$
 
 $\boxed{{\mathit{context}} \vdash {\mathit{memtype}} : \mathsf{ok}}$
 
+$\boxed{{\mathit{context}} \vdash {\mathit{tagtype}} : \mathsf{ok}}$
+
 $\boxed{{\mathit{context}} \vdash {\mathit{externtype}} : \mathsf{ok}}$
 
 \vspace{1ex}
@@ -4848,6 +4945,19 @@ C \vdash {\mathit{limits}}~\mathsf{page} : \mathsf{ok}
 \end{array}
 $$
 
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C \vdash {\mathit{deftype}} : \mathsf{ok}
+ \qquad
+{\mathit{deftype}} \approx \mathsf{func}~{\mathit{functype}}
+}{
+C \vdash {\mathit{deftype}} : \mathsf{ok}
+} \, {[\textsc{\scriptsize K{-}tag}]}
+\qquad
+\end{array}
+$$
+
 \vspace{1ex}
 
 $$
@@ -4896,6 +5006,17 @@ C \vdash \mathsf{mem}~{\mathit{memtype}} : \mathsf{ok}
 \end{array}
 $$
 
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C \vdash {\mathit{tagtype}} : \mathsf{ok}
+}{
+C \vdash \mathsf{tag}~{\mathit{tagtype}} : \mathsf{ok}
+} \, {[\textsc{\scriptsize K{-}extern{-}tag}]}
+\qquad
+\end{array}
+$$
+
 \vspace{1ex}
 
 \vspace{1ex}
@@ -5361,6 +5482,8 @@ $\boxed{{\mathit{context}} \vdash {\mathit{tabletype}} \leq {\mathit{tabletype}}
 
 $\boxed{{\mathit{context}} \vdash {\mathit{memtype}} \leq {\mathit{memtype}}}$
 
+$\boxed{{\mathit{context}} \vdash {\mathit{tagtype}} \leq {\mathit{tagtype}}}$
+
 $\boxed{{\mathit{context}} \vdash {\mathit{externtype}} \leq {\mathit{externtype}}}$
 
 \vspace{1ex}
@@ -5441,6 +5564,19 @@ C \vdash {\mathit{limits}}_1~\mathsf{page} \leq {\mathit{limits}}_2~\mathsf{page
 \end{array}
 $$
 
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C \vdash {\mathit{deftype}}_1 \leq {\mathit{deftype}}_2
+ \qquad
+C \vdash {\mathit{deftype}}_2 \leq {\mathit{deftype}}_1
+}{
+C \vdash {\mathit{deftype}}_1 \leq {\mathit{deftype}}_2
+} \, {[\textsc{\scriptsize S{-}tag}]}
+\qquad
+\end{array}
+$$
+
 \vspace{1ex}
 
 $$
@@ -5487,6 +5623,17 @@ C \vdash \mathsf{mem}~{\mathit{memtype}}_1 \leq \mathsf{mem}~{\mathit{memtype}}_
 \end{array}
 $$
 
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C \vdash {\mathit{tagtype}}_1 \leq {\mathit{tagtype}}_2
+}{
+C \vdash \mathsf{tag}~{\mathit{tagtype}}_1 \leq \mathsf{tag}~{\mathit{tagtype}}_2
+} \, {[\textsc{\scriptsize S{-}extern{-}tag}]}
+\qquad
+\end{array}
+$$
+
 \vspace{1ex}
 
 $\boxed{{\mathit{context}} \vdash {\mathit{instr}} : {\mathit{instrtype}}}$
@@ -5912,6 +6059,98 @@ $$
 
 \vspace{1ex}
 
+$\boxed{{\mathit{context}} \vdash {\mathit{catch}} : \mathsf{ok}}$
+
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C{.}\mathsf{tags}{}[x] \approx \mathsf{func}~({t^\ast} \rightarrow \epsilon)
+ \qquad
+C \vdash {t_1^\ast} \rightarrow {t_2^\ast} : \mathsf{ok}
+}{
+C \vdash \mathsf{throw}~x : {t_1^\ast}~{t^\ast} \rightarrow {t_2^\ast}
+} \, {[\textsc{\scriptsize T{-}throw}]}
+\qquad
+\end{array}
+$$
+
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C \vdash {t_1^\ast} \rightarrow {t_2^\ast} : \mathsf{ok}
+}{
+C \vdash \mathsf{throw\_ref} : {t_1^\ast}~(\mathsf{ref}~\mathsf{null}~\mathsf{exn}) \rightarrow {t_2^\ast}
+} \, {[\textsc{\scriptsize T{-}throw\_ref}]}
+\qquad
+\end{array}
+$$
+
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C \vdash {\mathit{bt}} : {t_1^\ast} \rightarrow {t_2^\ast}
+ \qquad
+\{ \begin{array}[t]{@{}l@{}}
+\mathsf{labels}~({t_2^\ast}) \}\end{array} \oplus C \vdash {{\mathit{instr}}^\ast} : {t_1^\ast} \rightarrow_{{x^\ast}} {t_2^\ast}
+ \qquad
+(C \vdash {\mathit{catch}} : \mathsf{ok})^\ast
+}{
+C \vdash \mathsf{try\_table}~{\mathit{bt}}~{{\mathit{catch}}^\ast}~{{\mathit{instr}}^\ast} : {t_1^\ast} \rightarrow {t_2^\ast}
+} \, {[\textsc{\scriptsize T{-}try\_table}]}
+\qquad
+\end{array}
+$$
+
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C{.}\mathsf{tags}{}[x] \approx \mathsf{func}~({t^\ast} \rightarrow \epsilon)
+ \qquad
+C \vdash {t^\ast} \leq C{.}\mathsf{labels}{}[l]
+}{
+C \vdash \mathsf{catch}~x~l : \mathsf{ok}
+} \, {[\textsc{\scriptsize T{-}catch}]}
+\qquad
+\end{array}
+$$
+
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C{.}\mathsf{tags}{}[x] \approx \mathsf{func}~({t^\ast} \rightarrow \epsilon)
+ \qquad
+C \vdash {t^\ast}~(\mathsf{ref}~\mathsf{exn}) \leq C{.}\mathsf{labels}{}[l]
+}{
+C \vdash \mathsf{catch\_ref}~x~l : \mathsf{ok}
+} \, {[\textsc{\scriptsize T{-}catch\_ref}]}
+\qquad
+\end{array}
+$$
+
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C \vdash \epsilon \leq C{.}\mathsf{labels}{}[l]
+}{
+C \vdash \mathsf{catch\_all}~l : \mathsf{ok}
+} \, {[\textsc{\scriptsize T{-}catch\_all}]}
+\qquad
+\end{array}
+$$
+
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C \vdash (\mathsf{ref}~\mathsf{exn}) \leq C{.}\mathsf{labels}{}[l]
+}{
+C \vdash \mathsf{catch\_all\_ref}~l : \mathsf{ok}
+} \, {[\textsc{\scriptsize T{-}catch\_all\_ref}]}
+\qquad
+\end{array}
+$$
+
+\vspace{1ex}
+
 $$
 \begin{array}{@{}c@{}}\displaystyle
 \frac{
@@ -7089,6 +7328,8 @@ $\boxed{{\mathit{context}} \vdash {\mathit{table}} : {\mathit{tabletype}}}$
 
 $\boxed{{\mathit{context}} \vdash {\mathit{mem}} : {\mathit{memtype}}}$
 
+$\boxed{{\mathit{context}} \vdash {\mathit{tag}} : {\mathit{tagtype}}}$
+
 $\boxed{{\mathit{context}} \vdash {\mathit{elem}} : {\mathit{elemtype}}}$
 
 $\boxed{{\mathit{context}} \vdash {\mathit{data}} : {\mathit{datatype}}}$
@@ -7194,6 +7435,17 @@ C \vdash \mathsf{memory}~{\mathit{memtype}} : {\mathit{memtype}}
 \end{array}
 $$
 
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C{.}\mathsf{types}{}[x] \approx \mathsf{func}~{\mathit{functype}}
+}{
+C \vdash \mathsf{tag}~x : C{.}\mathsf{types}{}[x]
+} \, {[\textsc{\scriptsize T{-}tag}]}
+\qquad
+\end{array}
+$$
+
 $$
 \begin{array}{@{}c@{}}\displaystyle
 \frac{
@@ -7365,6 +7617,17 @@ C \vdash \mathsf{mem}~x : \mathsf{mem}~{\mathit{mt}}
 \end{array}
 $$
 
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+C{.}\mathsf{tags}{}[x] = {\mathit{at}}
+}{
+C \vdash \mathsf{tag}~x : \mathsf{tag}~{\mathit{at}}
+} \, {[\textsc{\scriptsize T{-}externidx{-}tag}]}
+\qquad
+\end{array}
+$$
+
 \vspace{1ex}
 
 $\boxed{{\vdash}\, {\mathit{module}} : {\mathit{moduletype}}}$
@@ -7381,7 +7644,7 @@ $$
 
 $$
 \begin{array}{@{}lcl@{}l@{}}
-{\mathrm{funcidx}}({{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}) &=& {\mathrm{funcidx}}(\mathsf{module}~\epsilon~\epsilon~\epsilon~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~\epsilon~\epsilon) \\
+{\mathrm{funcidx}}({{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}) &=& {\mathrm{funcidx}}(\mathsf{module}~\epsilon~\epsilon~\epsilon~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~\epsilon~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~\epsilon~\epsilon) \\
 \end{array}
 $$
 
@@ -7401,6 +7664,8 @@ $$
  \qquad
 ({C'} \vdash {\mathit{mem}} : {\mathit{mt}})^\ast
  \qquad
+({C'} \vdash {\mathit{tag}} : {\mathit{at}})^\ast
+ \qquad
 (C \vdash {\mathit{func}} : {\mathit{dt}})^\ast
  \\
 (C \vdash {\mathit{elem}} : {\mathit{rt}})^\ast
@@ -7414,7 +7679,7 @@ $$
 {{\mathit{nm}}^\ast}~{\mathrm{disjoint}}
  \\
 C = \{ \begin{array}[t]{@{}l@{}}
-\mathsf{types}~{{\mathit{dt}'}^\ast},\; \mathsf{funcs}~{{\mathit{dt}}_{\mathsf{i}}^\ast}~{{\mathit{dt}}^\ast},\; \mathsf{globals}~{{\mathit{gt}}_{\mathsf{i}}^\ast}~{{\mathit{gt}}^\ast},\; \mathsf{tables}~{{\mathit{tt}}_{\mathsf{i}}^\ast}~{{\mathit{tt}}^\ast},\; \mathsf{mems}~{{\mathit{mt}}_{\mathsf{i}}^\ast}~{{\mathit{mt}}^\ast},\; \mathsf{elems}~{{\mathit{rt}}^\ast},\; \mathsf{datas}~{{\mathit{ok}}^\ast},\; \mathsf{refs}~{x^\ast} \}\end{array}
+\mathsf{types}~{{\mathit{dt}'}^\ast},\; \mathsf{funcs}~{{\mathit{dt}}_{\mathsf{i}}^\ast}~{{\mathit{dt}}^\ast},\; \mathsf{globals}~{{\mathit{gt}}_{\mathsf{i}}^\ast}~{{\mathit{gt}}^\ast},\; \mathsf{tables}~{{\mathit{tt}}_{\mathsf{i}}^\ast}~{{\mathit{tt}}^\ast},\; \mathsf{mems}~{{\mathit{mt}}_{\mathsf{i}}^\ast}~{{\mathit{mt}}^\ast},\; \mathsf{tags}~{{\mathit{at}}_{\mathsf{i}}^\ast}~{{\mathit{at}}^\ast},\; \mathsf{elems}~{{\mathit{rt}}^\ast},\; \mathsf{datas}~{{\mathit{ok}}^\ast},\; \mathsf{refs}~{x^\ast} \}\end{array}
  \\
 {C'} = \{ \begin{array}[t]{@{}l@{}}
 \mathsf{types}~{{\mathit{dt}'}^\ast},\; \mathsf{funcs}~{{\mathit{dt}}_{\mathsf{i}}^\ast}~{{\mathit{dt}}^\ast},\; \mathsf{globals}~{{\mathit{gt}}_{\mathsf{i}}^\ast},\; \mathsf{refs}~{x^\ast} \}\end{array}
@@ -7428,9 +7693,11 @@ C = \{ \begin{array}[t]{@{}l@{}}
 {{\mathit{tt}}_{\mathsf{i}}^\ast} = {\mathrm{tables}}({{\mathit{xt}}_{\mathsf{i}}^\ast})
  \qquad
 {{\mathit{mt}}_{\mathsf{i}}^\ast} = {\mathrm{mems}}({{\mathit{xt}}_{\mathsf{i}}^\ast})
+ \qquad
+{{\mathit{at}}_{\mathsf{i}}^\ast} = {\mathrm{tags}}({{\mathit{xt}}_{\mathsf{i}}^\ast})
 \end{array}
 }{
-{\vdash}\, \mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast} : {{\mathrm{clos}}}_{C}({{\mathit{xt}}_{\mathsf{i}}^\ast} \rightarrow {{\mathit{xt}}_{\mathsf{e}}^\ast})
+{\vdash}\, \mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast} : {{\mathrm{clos}}}_{C}({{\mathit{xt}}_{\mathsf{i}}^\ast} \rightarrow {{\mathit{xt}}_{\mathsf{e}}^\ast})
 } \, {[\textsc{\scriptsize T{-}module}]}
 \qquad
 \end{array}
@@ -7569,6 +7836,16 @@ s \vdash \mathsf{ref{.}func}~a : (\mathsf{ref}~\epsilon~{\mathit{dt}})
 \end{array}
 $$
 
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+}{
+s \vdash \mathsf{ref{.}exn}~a : (\mathsf{ref}~\epsilon~\mathsf{exn})
+} \, {[\textsc{\scriptsize Ref\_type{-}exn}]}
+\qquad
+\end{array}
+$$
+
 $$
 \begin{array}{@{}c@{}}\displaystyle
 \frac{
@@ -7640,7 +7917,7 @@ $$
 
 \vspace{1ex}
 
-$\boxed{{\mathit{store}} \vdash {\mathit{externval}} : {\mathit{externtype}}}$
+$\boxed{{\mathit{store}} \vdash {\mathit{externaddr}} : {\mathit{externtype}}}$
 
 $$
 \begin{array}{@{}c@{}}\displaystyle
@@ -7648,7 +7925,7 @@ $$
 s{.}\mathsf{funcs}{}[a] = {\mathit{funcinst}}
 }{
 s \vdash \mathsf{func}~a : \mathsf{func}~{\mathit{funcinst}}{.}\mathsf{type}
-} \, {[\textsc{\scriptsize Externval\_type{-}func}]}
+} \, {[\textsc{\scriptsize Externaddr\_type{-}func}]}
 \qquad
 \end{array}
 $$
@@ -7659,7 +7936,7 @@ $$
 s{.}\mathsf{globals}{}[a] = {\mathit{globalinst}}
 }{
 s \vdash \mathsf{global}~a : \mathsf{global}~{\mathit{globalinst}}{.}\mathsf{type}
-} \, {[\textsc{\scriptsize Externval\_type{-}global}]}
+} \, {[\textsc{\scriptsize Externaddr\_type{-}global}]}
 \qquad
 \end{array}
 $$
@@ -7670,7 +7947,7 @@ $$
 s{.}\mathsf{tables}{}[a] = {\mathit{tableinst}}
 }{
 s \vdash \mathsf{table}~a : \mathsf{table}~{\mathit{tableinst}}{.}\mathsf{type}
-} \, {[\textsc{\scriptsize Externval\_type{-}table}]}
+} \, {[\textsc{\scriptsize Externaddr\_type{-}table}]}
 \qquad
 \end{array}
 $$
@@ -7681,7 +7958,7 @@ $$
 s{.}\mathsf{mems}{}[a] = {\mathit{meminst}}
 }{
 s \vdash \mathsf{mem}~a : \mathsf{mem}~{\mathit{meminst}}{.}\mathsf{type}
-} \, {[\textsc{\scriptsize Externval\_type{-}mem}]}
+} \, {[\textsc{\scriptsize Externaddr\_type{-}mem}]}
 \qquad
 \end{array}
 $$
@@ -7689,13 +7966,24 @@ $$
 $$
 \begin{array}{@{}c@{}}\displaystyle
 \frac{
-s \vdash {\mathit{externval}} : {\mathit{xt}'}
+s{.}\mathsf{tags}{}[a] = {\mathit{taginst}}
+}{
+s \vdash \mathsf{tag}~a : \mathsf{tag}~{\mathit{taginst}}{.}\mathsf{type}
+} \, {[\textsc{\scriptsize Externaddr\_type{-}tag}]}
+\qquad
+\end{array}
+$$
+
+$$
+\begin{array}{@{}c@{}}\displaystyle
+\frac{
+s \vdash {\mathit{externaddr}} : {\mathit{xt}'}
  \qquad
 \{ \begin{array}[t]{@{}l@{}}
  \}\end{array} \vdash {\mathit{xt}'} \leq {\mathit{xt}}
 }{
-s \vdash {\mathit{externval}} : {\mathit{xt}}
-} \, {[\textsc{\scriptsize Externval\_type{-}sub}]}
+s \vdash {\mathit{externaddr}} : {\mathit{xt}}
+} \, {[\textsc{\scriptsize Externaddr\_type{-}sub}]}
 \qquad
 \end{array}
 $$
@@ -7800,10 +8088,11 @@ $$
 
 $$
 \begin{array}{@{}l@{}rcl@{}l@{}}
-{[\textsc{\scriptsize E{-}br{-}zero}]} \quad & ({{\mathsf{label}}_{n}}{\{ {{\mathit{instr}'}^\ast} \}}~{{\mathit{val}'}^\ast}~{{\mathit{val}}^{n}}~(\mathsf{br}~l)~{{\mathit{instr}}^\ast}) &\hookrightarrow& {{\mathit{val}}^{n}}~{{\mathit{instr}'}^\ast}
+{[\textsc{\scriptsize E{-}br{-}label{-}zero}]} \quad & ({{\mathsf{label}}_{n}}{\{ {{\mathit{instr}'}^\ast} \}}~{{\mathit{val}'}^\ast}~{{\mathit{val}}^{n}}~(\mathsf{br}~l)~{{\mathit{instr}}^\ast}) &\hookrightarrow& {{\mathit{val}}^{n}}~{{\mathit{instr}'}^\ast}
   &\qquad \mbox{if}~l = 0 \\
-{[\textsc{\scriptsize E{-}br{-}succ}]} \quad & ({{\mathsf{label}}_{n}}{\{ {{\mathit{instr}'}^\ast} \}}~{{\mathit{val}}^\ast}~(\mathsf{br}~l)~{{\mathit{instr}}^\ast}) &\hookrightarrow& {{\mathit{val}}^\ast}~(\mathsf{br}~l - 1)
+{[\textsc{\scriptsize E{-}br{-}label{-}succ}]} \quad & ({{\mathsf{label}}_{n}}{\{ {{\mathit{instr}'}^\ast} \}}~{{\mathit{val}}^\ast}~(\mathsf{br}~l)~{{\mathit{instr}}^\ast}) &\hookrightarrow& {{\mathit{val}}^\ast}~(\mathsf{br}~l - 1)
   &\qquad \mbox{if}~l > 0 \\
+{[\textsc{\scriptsize E{-}br{-}handler}]} \quad & ({{\mathsf{handler}}_{n}}{\{ {{\mathit{catch}}^\ast} \}}~{{\mathit{val}}^\ast}~(\mathsf{br}~l)~{{\mathit{instr}}^\ast}) &\hookrightarrow& {{\mathit{val}}^\ast}~(\mathsf{br}~l) \\
 \end{array}
 $$
 
@@ -7929,6 +8218,50 @@ $$
 {[\textsc{\scriptsize E{-}frame{-}vals}]} \quad & ({{\mathsf{frame}}_{n}}{\{ f \}}~{{\mathit{val}}^{n}}) &\hookrightarrow& {{\mathit{val}}^{n}} \\
 {[\textsc{\scriptsize E{-}return{-}frame}]} \quad & ({{\mathsf{frame}}_{n}}{\{ f \}}~{{\mathit{val}'}^\ast}~{{\mathit{val}}^{n}}~\mathsf{return}~{{\mathit{instr}}^\ast}) &\hookrightarrow& {{\mathit{val}}^{n}} \\
 {[\textsc{\scriptsize E{-}return{-}label}]} \quad & ({{\mathsf{label}}_{n}}{\{ {{\mathit{instr}'}^\ast} \}}~{{\mathit{val}}^\ast}~\mathsf{return}~{{\mathit{instr}}^\ast}) &\hookrightarrow& {{\mathit{val}}^\ast}~\mathsf{return} \\
+{[\textsc{\scriptsize E{-}return{-}handler}]} \quad & ({{\mathsf{handler}}_{n}}{\{ {{\mathit{catch}}^\ast} \}}~{{\mathit{val}}^\ast}~\mathsf{return}~{{\mathit{instr}}^\ast}) &\hookrightarrow& {{\mathit{val}}^\ast}~\mathsf{return} \\
+\end{array}
+$$
+
+\vspace{1ex}
+
+$$
+\begin{array}{@{}l@{}rcl@{}l@{}}
+{[\textsc{\scriptsize E{-}throw}]} \quad & z ; {{\mathit{val}}^{n}}~(\mathsf{throw}~x) &\hookrightarrow& z{}[{.}\mathsf{exns} \mathrel{{=}{\oplus}} {\mathit{exn}}] ; (\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref}
+  &\qquad \mbox{if}~z{.}\mathsf{tags}{}[x]{.}\mathsf{type} \approx \mathsf{func}~({t^{n}} \rightarrow \epsilon) \\
+  &&&&\qquad {\land}~a = {|z{.}\mathsf{exns}|} \\
+  &&&&\qquad {\land}~{\mathit{exn}} = \{ \begin{array}[t]{@{}l@{}}
+\mathsf{tag}~z{.}\mathsf{tags}{}[x],\; \mathsf{fields}~{{\mathit{val}}^{n}} \}\end{array} \\
+\end{array}
+$$
+
+$$
+\begin{array}{@{}l@{}rcl@{}l@{}}
+{[\textsc{\scriptsize E{-}throw\_ref{-}null}]} \quad & z ; (\mathsf{ref{.}null}~{\mathit{ht}})~\mathsf{throw\_ref} &\hookrightarrow& \mathsf{trap} \\
+{[\textsc{\scriptsize E{-}throw\_ref{-}vals}]} \quad & z ; {{\mathit{val}}^\ast}~(\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref}~{{\mathit{instr}}^\ast} &\hookrightarrow& (\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref}
+  &\qquad \mbox{if}~{{\mathit{val}}^\ast} \neq \epsilon \lor {{\mathit{instr}}^\ast} \neq \epsilon \\
+{[\textsc{\scriptsize E{-}throw\_ref{-}label}]} \quad & z ; ({{\mathsf{label}}_{n}}{\{ {{\mathit{instr}'}^\ast} \}}~(\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref}) &\hookrightarrow& (\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref} \\
+{[\textsc{\scriptsize E{-}throw\_ref{-}frame}]} \quad & z ; ({{\mathsf{frame}}_{n}}{\{ f \}}~(\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref}) &\hookrightarrow& (\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref} \\
+{[\textsc{\scriptsize E{-}throw\_ref{-}handler{-}empty}]} \quad & z ; ({{\mathsf{handler}}_{n}}{\{ \epsilon \}}~(\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref}) &\hookrightarrow& (\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref} \\
+{[\textsc{\scriptsize E{-}throw\_ref{-}handler{-}catch}]} \quad & z ; ({{\mathsf{handler}}_{n}}{\{ (\mathsf{catch}~x~l)~{{\mathit{catch}'}^\ast} \}}~(\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref}) &\hookrightarrow& {{\mathit{val}}^\ast}~(\mathsf{br}~l)
+  &\qquad \mbox{if}~z{.}\mathsf{exns}{}[a]{.}\mathsf{tag} = z{.}\mathsf{tags}{}[x] \\
+  &&&&\qquad {\land}~{{\mathit{val}}^\ast} = z{.}\mathsf{exns}{}[a]{.}\mathsf{fields} \\
+{[\textsc{\scriptsize E{-}throw\_ref{-}handler{-}catch\_ref}]} \quad & z ; ({{\mathsf{handler}}_{n}}{\{ (\mathsf{catch\_ref}~x~l)~{{\mathit{catch}'}^\ast} \}}~(\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref}) &\hookrightarrow& {{\mathit{val}}^\ast}~(\mathsf{ref{.}exn}~a)~(\mathsf{br}~l)
+  &\qquad \mbox{if}~z{.}\mathsf{exns}{}[a]{.}\mathsf{tag} = z{.}\mathsf{tags}{}[x] \\
+  &&&&\qquad {\land}~{{\mathit{val}}^\ast} = z{.}\mathsf{exns}{}[a]{.}\mathsf{fields} \\
+{[\textsc{\scriptsize E{-}throw\_ref{-}handler{-}catch\_all}]} \quad & z ; ({{\mathsf{handler}}_{n}}{\{ (\mathsf{catch\_all}~l)~{{\mathit{catch}'}^\ast} \}}~(\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref}) &\hookrightarrow& (\mathsf{br}~l) \\
+{[\textsc{\scriptsize E{-}throw\_ref{-}handler{-}catch\_all\_ref}]} \quad & z ; ({{\mathsf{handler}}_{n}}{\{ (\mathsf{catch\_all\_ref}~l)~{{\mathit{catch}'}^\ast} \}}~(\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref}) &\hookrightarrow& (\mathsf{ref{.}exn}~a)~(\mathsf{br}~l) \\
+{[\textsc{\scriptsize E{-}throw\_ref{-}handler{-}next}]} \quad & z ; ({{\mathsf{handler}}_{n}}{\{ {\mathit{catch}}~{{\mathit{catch}'}^\ast} \}}~(\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref}) &\hookrightarrow& ({{\mathsf{handler}}_{n}}{\{ {{\mathit{catch}'}^\ast} \}}~(\mathsf{ref{.}exn}~a)~\mathsf{throw\_ref})
+  &\qquad \mbox{otherwise} \\
+{[\textsc{\scriptsize E{-}try\_table}]} \quad & z ; {{\mathit{val}}^{m}}~(\mathsf{try\_table}~{\mathit{bt}}~{{\mathit{catch}}^\ast}~{{\mathit{instr}}^\ast}) &\hookrightarrow& ({{\mathsf{handler}}_{n}}{\{ {{\mathit{catch}}^\ast} \}}~({{\mathsf{label}}_{n}}{\{ \epsilon \}}~{{\mathit{val}}^{m}}~{{\mathit{instr}}^\ast}))
+  &\qquad \mbox{if}~{{\mathrm{blocktype}}}_{z}({\mathit{bt}}) = {t_1^{m}} \rightarrow {t_2^{n}} \\
+\end{array}
+$$
+
+\vspace{1ex}
+
+$$
+\begin{array}{@{}l@{}rcl@{}l@{}}
+{[\textsc{\scriptsize E{-}handler{-}vals}]} \quad & ({{\mathsf{handler}}_{n}}{\{ {{\mathit{catch}}^\ast} \}}~{{\mathit{val}}^\ast}) &\hookrightarrow& {{\mathit{val}}^\ast} \\
 \end{array}
 $$
 
@@ -8877,6 +9210,24 @@ $$
 \end{array}
 $$
 
+$$
+\begin{array}{@{}lcl@{}l@{}}
+{\mathrm{alloctag}}(s, {\mathit{at}}) &=& \multicolumn{2}{l@{}}{ (s \oplus \{ \begin{array}[t]{@{}l@{}}
+\mathsf{tags}~{\mathit{taginst}} \}\end{array}, {|s{.}\mathsf{tags}|}) } \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad \mbox{if}~{\mathit{taginst}} = \{ \begin{array}[t]{@{}l@{}}
+\mathsf{type}~{\mathit{at}} \}\end{array}} \\
+\end{array}
+$$
+
+$$
+\begin{array}{@{}lcl@{}l@{}}
+{{{\mathrm{alloctag}}^\ast}}{(s, \epsilon)} &=& (s, \epsilon) \\
+{{{\mathrm{alloctag}}^\ast}}{(s, {\mathit{at}}~{{\mathit{at}'}^\ast})} &=& (s_2, {\mathit{aa}}~{{\mathit{aa}'}^\ast})
+  &\qquad \mbox{if}~(s_1, {\mathit{aa}}) = {\mathrm{alloctag}}(s, {\mathit{at}}) \\
+  &&&\qquad {\land}~(s_2, {{\mathit{aa}'}^\ast}) = {{{\mathrm{alloctag}}^\ast}}{(s_1, {{\mathit{at}'}^\ast})} \\
+\end{array}
+$$
+
 $$
 \begin{array}{@{}lcl@{}l@{}}
 {\mathrm{allocelem}}(s, {\mathit{elemtype}}, {{\mathit{ref}}^\ast}) &=& \multicolumn{2}{l@{}}{ (s \oplus \{ \begin{array}[t]{@{}l@{}}
@@ -8891,7 +9242,7 @@ $$
 {{{\mathrm{allocelem}}^\ast}}{(s, \epsilon, \epsilon)} &=& (s, \epsilon) \\
 {{{\mathrm{allocelem}}^\ast}}{(s, {\mathit{rt}}~{{\mathit{rt}'}^\ast}, ({{\mathit{ref}}^\ast})~{({{\mathit{ref}'}^\ast})^\ast})} &=& (s_2, {\mathit{ea}}~{{\mathit{ea}'}^\ast})
   &\qquad \mbox{if}~(s_1, {\mathit{ea}}) = {\mathrm{allocelem}}(s, {\mathit{rt}}, {{\mathit{ref}}^\ast}) \\
-  &&&\qquad {\land}~(s_2, {{\mathit{ea}'}^\ast}) = {{{\mathrm{allocelem}}^\ast}}{(s_2, {{\mathit{rt}'}^\ast}, {({{\mathit{ref}'}^\ast})^\ast})} \\
+  &&&\qquad {\land}~(s_2, {{\mathit{ea}'}^\ast}) = {{{\mathrm{allocelem}}^\ast}}{(s_1, {{\mathit{rt}'}^\ast}, {({{\mathit{ref}'}^\ast})^\ast})} \\
 \end{array}
 $$
 
@@ -8916,13 +9267,15 @@ $$
 $$
 \begin{array}{@{}lcl@{}l@{}}
 {\mathrm{allocexport}}({\mathit{moduleinst}}, \mathsf{export}~{\mathit{name}}~(\mathsf{func}~x)) &=& \{ \begin{array}[t]{@{}l@{}}
-\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{func}~{\mathit{moduleinst}}{.}\mathsf{funcs}{}[x]) \}\end{array} \\
+\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{func}~{\mathit{moduleinst}}{.}\mathsf{funcs}{}[x]) \}\end{array} \\
 {\mathrm{allocexport}}({\mathit{moduleinst}}, \mathsf{export}~{\mathit{name}}~(\mathsf{global}~x)) &=& \{ \begin{array}[t]{@{}l@{}}
-\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{global}~{\mathit{moduleinst}}{.}\mathsf{globals}{}[x]) \}\end{array} \\
+\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{global}~{\mathit{moduleinst}}{.}\mathsf{globals}{}[x]) \}\end{array} \\
 {\mathrm{allocexport}}({\mathit{moduleinst}}, \mathsf{export}~{\mathit{name}}~(\mathsf{table}~x)) &=& \{ \begin{array}[t]{@{}l@{}}
-\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{table}~{\mathit{moduleinst}}{.}\mathsf{tables}{}[x]) \}\end{array} \\
+\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{table}~{\mathit{moduleinst}}{.}\mathsf{tables}{}[x]) \}\end{array} \\
 {\mathrm{allocexport}}({\mathit{moduleinst}}, \mathsf{export}~{\mathit{name}}~(\mathsf{mem}~x)) &=& \{ \begin{array}[t]{@{}l@{}}
-\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{mem}~{\mathit{moduleinst}}{.}\mathsf{mems}{}[x]) \}\end{array} \\
+\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{mem}~{\mathit{moduleinst}}{.}\mathsf{mems}{}[x]) \}\end{array} \\
+{\mathrm{allocexport}}({\mathit{moduleinst}}, \mathsf{export}~{\mathit{name}}~(\mathsf{tag}~x)) &=& \{ \begin{array}[t]{@{}l@{}}
+\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{tag}~{\mathit{moduleinst}}{.}\mathsf{tags}{}[x]) \}\end{array} \\
 \end{array}
 $$
 
@@ -8936,21 +9289,24 @@ $$
 
 $$
 \begin{array}{@{}lcl@{}l@{}}
-{\mathrm{allocmodule}}(s, {\mathit{module}}, {{\mathit{externval}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast}, {({{\mathit{ref}}_{\mathsf{e}}^\ast})^\ast}) &=& \multicolumn{2}{l@{}}{ (s_6, {\mathit{moduleinst}}) } \\
-   \multicolumn{4}{@{}l@{}}{\qquad\quad \mbox{if}~{\mathit{module}} = \mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast}} \\
+{\mathrm{allocmodule}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast}, {({{\mathit{ref}}_{\mathsf{e}}^\ast})^\ast}) &=& \multicolumn{2}{l@{}}{ (s_7, {\mathit{moduleinst}}) } \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad \mbox{if}~{\mathit{module}} = \mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{func}}^\ast} = {(\mathsf{func}~x~{{\mathit{local}}^\ast}~{\mathit{expr}}_{\mathsf{f}})^\ast}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{global}}^\ast} = {(\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}}_{\mathsf{g}})^\ast}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{table}}^\ast} = {(\mathsf{table}~{\mathit{tabletype}}~{\mathit{expr}}_{\mathsf{t}})^\ast}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{mem}}^\ast} = {(\mathsf{memory}~{\mathit{memtype}})^\ast}} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{tag}}^\ast} = {(\mathsf{tag}~y)^\ast}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{elem}}^\ast} = {(\mathsf{elem}~{\mathit{elemtype}}~{{\mathit{expr}}_{\mathsf{e}}^\ast}~{\mathit{elemmode}})^\ast}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{data}}^\ast} = {(\mathsf{data}~{{\mathit{byte}}^\ast}~{\mathit{datamode}})^\ast}} \\
-   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{fa}}_{\mathsf{i}}^\ast} = {\mathrm{funcs}}({{\mathit{externval}}^\ast})} \\
-   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{ga}}_{\mathsf{i}}^\ast} = {\mathrm{globals}}({{\mathit{externval}}^\ast})} \\
-   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{ta}}_{\mathsf{i}}^\ast} = {\mathrm{tables}}({{\mathit{externval}}^\ast})} \\
-   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{ma}}_{\mathsf{i}}^\ast} = {\mathrm{mems}}({{\mathit{externval}}^\ast})} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{fa}}_{\mathsf{i}}^\ast} = {\mathrm{funcs}}({{\mathit{externaddr}}^\ast})} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{ga}}_{\mathsf{i}}^\ast} = {\mathrm{globals}}({{\mathit{externaddr}}^\ast})} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{ta}}_{\mathsf{i}}^\ast} = {\mathrm{tables}}({{\mathit{externaddr}}^\ast})} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{ma}}_{\mathsf{i}}^\ast} = {\mathrm{mems}}({{\mathit{externaddr}}^\ast})} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{aa}}_{\mathsf{i}}^\ast} = {\mathrm{tags}}({{\mathit{externaddr}}^\ast})} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{fa}}^\ast} = {({|s{.}\mathsf{funcs}|} + i_{\mathsf{f}})^{i_{\mathsf{f}}<{|{{\mathit{func}}^\ast}|}}}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{ga}}^\ast} = {({|s{.}\mathsf{globals}|} + i_{\mathsf{g}})^{i_{\mathsf{g}}<{|{{\mathit{global}}^\ast}|}}}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{ta}}^\ast} = {({|s{.}\mathsf{tables}|} + i_{\mathsf{t}})^{i_{\mathsf{t}}<{|{{\mathit{table}}^\ast}|}}}} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{aa}}^\ast} = {({|s{.}\mathsf{tags}|} + i_{\mathsf{a}})^{i_{\mathsf{a}}<{|{{\mathit{tag}}^\ast}|}}}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{ma}}^\ast} = {({|s{.}\mathsf{mems}|} + i_{\mathsf{m}})^{i_{\mathsf{m}}<{|{{\mathit{mem}}^\ast}|}}}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{ea}}^\ast} = {({|s{.}\mathsf{elems}|} + i_{\mathsf{e}})^{i_{\mathsf{e}}<{|{{\mathit{elem}}^\ast}|}}}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{da}}^\ast} = {({|s{.}\mathsf{datas}|} + i_{\mathsf{d}})^{i_{\mathsf{d}}<{|{{\mathit{data}}^\ast}|}}}} \\
@@ -8959,14 +9315,16 @@ $$
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~(s_2, {{\mathit{ga}}^\ast}) = {{{\mathrm{allocglobal}}^\ast}}{(s_1, {{\mathit{globaltype}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast})}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~(s_3, {{\mathit{ta}}^\ast}) = {{{\mathrm{alloctable}}^\ast}}{(s_2, {{\mathit{tabletype}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast})}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~(s_4, {{\mathit{ma}}^\ast}) = {{{\mathrm{allocmem}}^\ast}}{(s_3, {{\mathit{memtype}}^\ast})}} \\
-   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~(s_5, {{\mathit{ea}}^\ast}) = {{{\mathrm{allocelem}}^\ast}}{(s_4, {{\mathit{elemtype}}^\ast}, {({{\mathit{ref}}_{\mathsf{e}}^\ast})^\ast})}} \\
-   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~(s_6, {{\mathit{da}}^\ast}) = {{{\mathrm{allocdata}}^\ast}}{(s_5, {\mathsf{ok}^{{|{{\mathit{data}}^\ast}|}}}, {({{\mathit{byte}}^\ast})^\ast})}} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~(s_5, {{\mathit{aa}}^\ast}) = {{{\mathrm{alloctag}}^\ast}}{(s_4, {{{\mathit{dt}}^\ast}{}[y]^\ast})}} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~(s_6, {{\mathit{ea}}^\ast}) = {{{\mathrm{allocelem}}^\ast}}{(s_5, {{\mathit{elemtype}}^\ast}, {({{\mathit{ref}}_{\mathsf{e}}^\ast})^\ast})}} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~(s_7, {{\mathit{da}}^\ast}) = {{{\mathrm{allocdata}}^\ast}}{(s_6, {\mathsf{ok}^{{|{{\mathit{data}}^\ast}|}}}, {({{\mathit{byte}}^\ast})^\ast})}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{xi}}^\ast} = {{{\mathrm{allocexport}}^\ast}}{(\{ \begin{array}[t]{@{}l@{}}
-\mathsf{funcs}~{{\mathit{fa}}_{\mathsf{i}}^\ast}~{{\mathit{fa}}^\ast},\; \mathsf{globals}~{{\mathit{ga}}_{\mathsf{i}}^\ast}~{{\mathit{ga}}^\ast},\; \mathsf{tables}~{{\mathit{ta}}_{\mathsf{i}}^\ast}~{{\mathit{ta}}^\ast},\; \mathsf{mems}~{{\mathit{ma}}_{\mathsf{i}}^\ast}~{{\mathit{ma}}^\ast} \}\end{array}, {{\mathit{export}}^\ast})}} \\
+\mathsf{funcs}~{{\mathit{fa}}_{\mathsf{i}}^\ast}~{{\mathit{fa}}^\ast},\; \mathsf{globals}~{{\mathit{ga}}_{\mathsf{i}}^\ast}~{{\mathit{ga}}^\ast},\; \mathsf{tables}~{{\mathit{ta}}_{\mathsf{i}}^\ast}~{{\mathit{ta}}^\ast},\; \mathsf{mems}~{{\mathit{ma}}_{\mathsf{i}}^\ast}~{{\mathit{ma}}^\ast},\; \mathsf{tags}~{{\mathit{aa}}_{\mathsf{i}}^\ast}~{{\mathit{aa}}^\ast} \}\end{array}, {{\mathit{export}}^\ast})}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{\mathit{moduleinst}} = \{ \begin{array}[t]{@{}l@{}}
 \mathsf{types}~{{\mathit{dt}}^\ast},\; \\
   \mathsf{funcs}~{{\mathit{fa}}_{\mathsf{i}}^\ast}~{{\mathit{fa}}^\ast},\; \mathsf{globals}~{{\mathit{ga}}_{\mathsf{i}}^\ast}~{{\mathit{ga}}^\ast},\; \\
   \mathsf{tables}~{{\mathit{ta}}_{\mathsf{i}}^\ast}~{{\mathit{ta}}^\ast},\; \mathsf{mems}~{{\mathit{ma}}_{\mathsf{i}}^\ast}~{{\mathit{ma}}^\ast},\; \\
+  \mathsf{tags}~{{\mathit{aa}}_{\mathsf{i}}^\ast}~{{\mathit{aa}}^\ast},\; \\
   \mathsf{elems}~{{\mathit{ea}}^\ast},\; \mathsf{datas}~{{\mathit{da}}^\ast},\; \\
   \mathsf{exports}~{{\mathit{xi}}^\ast} \}\end{array}} \\
 \end{array}
@@ -9002,10 +9360,10 @@ $$
 
 $$
 \begin{array}{@{}lcl@{}l@{}}
-{\mathrm{instantiate}}(s, {\mathit{module}}, {{\mathit{externval}}^\ast}) &=& \multicolumn{2}{l@{}}{ {s'} ; f ; {{\mathit{instr}}_{\mathsf{e}}^\ast}~{{\mathit{instr}}_{\mathsf{d}}^\ast}~{{\mathit{instr}}_{\mathsf{s}}^?} } \\
+{\mathrm{instantiate}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast}) &=& \multicolumn{2}{l@{}}{ {s'} ; f ; {{\mathit{instr}}_{\mathsf{e}}^\ast}~{{\mathit{instr}}_{\mathsf{d}}^\ast}~{{\mathit{instr}}_{\mathsf{s}}^?} } \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad \mbox{if}~{\vdash}\, {\mathit{module}} : {{\mathit{xt}}_{\mathsf{i}}^\ast} \rightarrow {{\mathit{xt}}_{\mathsf{e}}^\ast}} \\
-   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~(s \vdash {\mathit{externval}} : {\mathit{xt}}_{\mathsf{i}})^\ast} \\
-   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{\mathit{module}} = \mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast}} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~(s \vdash {\mathit{externaddr}} : {\mathit{xt}}_{\mathsf{i}})^\ast} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{\mathit{module}} = \mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{global}}^\ast} = {(\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}}_{\mathsf{g}})^\ast}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{table}}^\ast} = {(\mathsf{table}~{\mathit{tabletype}}~{\mathit{expr}}_{\mathsf{t}})^\ast}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{elem}}^\ast} = {(\mathsf{elem}~{\mathit{reftype}}~{{\mathit{expr}}_{\mathsf{e}}^\ast}~{\mathit{elemmode}})^\ast}} \\
@@ -9013,14 +9371,14 @@ $$
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{start}}^?} = {(\mathsf{start}~x)^?}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{\mathit{moduleinst}}_0 = \{ \begin{array}[t]{@{}l@{}}
 \mathsf{types}~{{{\mathrm{alloctype}}^\ast}}{({{\mathit{type}}^\ast})},\; \\
-  \mathsf{funcs}~{\mathrm{funcs}}({{\mathit{externval}}^\ast})~{({|s{.}\mathsf{funcs}|} + i_{\mathsf{f}})^{i_{\mathsf{f}}<{|{{\mathit{func}}^\ast}|}}},\; \\
-  \mathsf{globals}~{\mathrm{globals}}({{\mathit{externval}}^\ast}) \}\end{array}} \\
+  \mathsf{funcs}~{\mathrm{funcs}}({{\mathit{externaddr}}^\ast})~{({|s{.}\mathsf{funcs}|} + i_{\mathsf{f}})^{i_{\mathsf{f}}<{|{{\mathit{func}}^\ast}|}}},\; \\
+  \mathsf{globals}~{\mathrm{globals}}({{\mathit{externaddr}}^\ast}) \}\end{array}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~z = s ; \{ \begin{array}[t]{@{}l@{}}
 \mathsf{module}~{\mathit{moduleinst}}_0 \}\end{array}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~({z'}, {{\mathit{val}}_{\mathsf{g}}^\ast}) = {{{\mathrm{evalglobal}}^\ast}}{(z, {{\mathit{globaltype}}^\ast}, {{\mathit{expr}}_{\mathsf{g}}^\ast})}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~({z'} ; {\mathit{expr}}_{\mathsf{t}} \hookrightarrow^\ast {z'} ; {\mathit{ref}}_{\mathsf{t}})^\ast} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{({z'} ; {\mathit{expr}}_{\mathsf{e}} \hookrightarrow^\ast {z'} ; {\mathit{ref}}_{\mathsf{e}})^\ast}^\ast} \\
-   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~({s'}, {\mathit{moduleinst}}) = {\mathrm{allocmodule}}(s, {\mathit{module}}, {{\mathit{externval}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast}, {({{\mathit{ref}}_{\mathsf{e}}^\ast})^\ast})} \\
+   \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~({s'}, {\mathit{moduleinst}}) = {\mathrm{allocmodule}}(s, {\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast}, {({{\mathit{ref}}_{\mathsf{e}}^\ast})^\ast})} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~f = \{ \begin{array}[t]{@{}l@{}}
 \mathsf{module}~{\mathit{moduleinst}} \}\end{array}} \\
    \multicolumn{4}{@{}l@{}}{\qquad\quad {\land}~{{\mathit{instr}}_{\mathsf{e}}^\ast} = {\bigoplus}\, {{{\mathrm{runelem}}}_{i_{\mathsf{e}}}({{\mathit{elem}}^\ast}{}[i_{\mathsf{e}}])^{i_{\mathsf{e}}<{|{{\mathit{elem}}^\ast}|}}}} \\
@@ -9134,6 +9492,7 @@ $$
 & {\mathtt{globalidx}} &::=& x{:}{\mathtt{u32}} &\quad\Rightarrow&\quad x \\
 & {\mathtt{tableidx}} &::=& x{:}{\mathtt{u32}} &\quad\Rightarrow&\quad x \\
 & {\mathtt{memidx}} &::=& x{:}{\mathtt{u32}} &\quad\Rightarrow&\quad x \\
+& {\mathtt{tagidx}} &::=& x{:}{\mathtt{u32}} &\quad\Rightarrow&\quad x \\
 & {\mathtt{elemidx}} &::=& x{:}{\mathtt{u32}} &\quad\Rightarrow&\quad x \\
 & {\mathtt{dataidx}} &::=& x{:}{\mathtt{u32}} &\quad\Rightarrow&\quad x \\
 & {\mathtt{localidx}} &::=& x{:}{\mathtt{u32}} &\quad\Rightarrow&\quad x \\
@@ -9141,7 +9500,8 @@ $$
 & {\mathtt{externidx}} &::=& \mathtt{0x00}~~x{:}{\mathtt{funcidx}} &\quad\Rightarrow&\quad \mathsf{func}~x \\ &&|&
 \mathtt{0x01}~~x{:}{\mathtt{tableidx}} &\quad\Rightarrow&\quad \mathsf{table}~x \\ &&|&
 \mathtt{0x02}~~x{:}{\mathtt{memidx}} &\quad\Rightarrow&\quad \mathsf{mem}~x \\ &&|&
-\mathtt{0x03}~~x{:}{\mathtt{globalidx}} &\quad\Rightarrow&\quad \mathsf{global}~x \\
+\mathtt{0x03}~~x{:}{\mathtt{globalidx}} &\quad\Rightarrow&\quad \mathsf{global}~x \\ &&|&
+\mathtt{0x04}~~x{:}{\mathtt{tagidx}} &\quad\Rightarrow&\quad \mathsf{tag}~x \\
 \end{array}
 $$
 
@@ -9156,7 +9516,8 @@ $$
 \mathtt{0x7E} &\quad\Rightarrow&\quad \mathsf{i{\scriptstyle 64}} \\ &&|&
 \mathtt{0x7F} &\quad\Rightarrow&\quad \mathsf{i{\scriptstyle 32}} \\
 & {\mathtt{vectype}} &::=& \mathtt{0x7B} &\quad\Rightarrow&\quad \mathsf{v{\scriptstyle 128}} \\
-& {\mathtt{absheaptype}} &::=& \mathtt{0x6A} &\quad\Rightarrow&\quad \mathsf{array} \\ &&|&
+& {\mathtt{absheaptype}} &::=& \mathtt{0x69} &\quad\Rightarrow&\quad \mathsf{exn} \\ &&|&
+\mathtt{0x6A} &\quad\Rightarrow&\quad \mathsf{array} \\ &&|&
 \mathtt{0x6B} &\quad\Rightarrow&\quad \mathsf{struct} \\ &&|&
 \mathtt{0x6C} &\quad\Rightarrow&\quad \mathsf{i{\scriptstyle 31}} \\ &&|&
 \mathtt{0x6D} &\quad\Rightarrow&\quad \mathsf{eq} \\ &&|&
@@ -9165,7 +9526,8 @@ $$
 \mathtt{0x70} &\quad\Rightarrow&\quad \mathsf{func} \\ &&|&
 \mathtt{0x71} &\quad\Rightarrow&\quad \mathsf{none} \\ &&|&
 \mathtt{0x72} &\quad\Rightarrow&\quad \mathsf{noextern} \\ &&|&
-\mathtt{0x73} &\quad\Rightarrow&\quad \mathsf{nofunc} \\
+\mathtt{0x73} &\quad\Rightarrow&\quad \mathsf{nofunc} \\ &&|&
+\mathtt{0x74} &\quad\Rightarrow&\quad \mathsf{noexn} \\
 & {\mathtt{heaptype}} &::=& {\mathit{ht}}{:}{\mathtt{absheaptype}} &\quad\Rightarrow&\quad {\mathit{ht}} \\ &&|&
 x{:}{\mathtt{s33}} &\quad\Rightarrow&\quad x
   &\qquad \mbox{if}~x \geq 0 \\
@@ -9217,6 +9579,7 @@ $$
 & {\mathtt{globaltype}} &::=& t{:}{\mathtt{valtype}}~~{\mathsf{mut}^?}{:}{\mathtt{mut}} &\quad\Rightarrow&\quad {\mathsf{mut}^?}~t \\
 & {\mathtt{tabletype}} &::=& {\mathit{rt}}{:}{\mathtt{reftype}}~~{\mathit{lim}}{:}{\mathtt{limits}} &\quad\Rightarrow&\quad {\mathit{lim}}~{\mathit{rt}} \\
 & {\mathtt{memtype}} &::=& {\mathit{lim}}{:}{\mathtt{limits}} &\quad\Rightarrow&\quad {\mathit{lim}}~\mathsf{page} \\
+& {\mathtt{tagtype}} &::=& \mathtt{0x00}~~x{:}{\mathtt{typeidx}} &\quad\Rightarrow&\quad x \\
 \end{array}
 $$
 
@@ -9227,7 +9590,8 @@ $$
 & {\mathtt{externtype}} &::=& \mathtt{0x00}~~x{:}{\mathtt{typeidx}} &\quad\Rightarrow&\quad \mathsf{func}~x \\ &&|&
 \mathtt{0x01}~~{\mathit{tt}}{:}{\mathtt{tabletype}} &\quad\Rightarrow&\quad \mathsf{table}~{\mathit{tt}} \\ &&|&
 \mathtt{0x02}~~{\mathit{mt}}{:}{\mathtt{memtype}} &\quad\Rightarrow&\quad \mathsf{mem}~{\mathit{mt}} \\ &&|&
-\mathtt{0x03}~~{\mathit{gt}}{:}{\mathtt{globaltype}} &\quad\Rightarrow&\quad \mathsf{global}~{\mathit{gt}} \\
+\mathtt{0x03}~~{\mathit{gt}}{:}{\mathtt{globaltype}} &\quad\Rightarrow&\quad \mathsf{global}~{\mathit{gt}} \\ &&|&
+\mathtt{0x04}~~x{:}{\mathtt{tagtype}} &\quad\Rightarrow&\quad \mathsf{tag}~x \\
 \end{array}
 $$
 
@@ -9254,6 +9618,8 @@ $$
 \mathtt{0x03}~~{\mathit{bt}}{:}{\mathtt{blocktype}}~~{({\mathit{in}}{:}{\mathtt{instr}})^\ast}~~\mathtt{0x0B} &\quad\Rightarrow&\quad \mathsf{loop}~{\mathit{bt}}~{{\mathit{in}}^\ast} \\ &&|&
 \mathtt{0x04}~~{\mathit{bt}}{:}{\mathtt{blocktype}}~~{({\mathit{in}}{:}{\mathtt{instr}})^\ast}~~\mathtt{0x0B} &\quad\Rightarrow&\quad \mathsf{if}~{\mathit{bt}}~{{\mathit{in}}^\ast}~\mathsf{else}~\epsilon \\ &&|&
 \mathtt{0x04}~~{\mathit{bt}}{:}{\mathtt{blocktype}}~~{({\mathit{in}}_1{:}{\mathtt{instr}})^\ast} \\ &&& \mathtt{0x05}~~{({\mathit{in}}_2{:}{\mathtt{instr}})^\ast}~~\mathtt{0x0B} &\quad\Rightarrow&\quad \mathsf{if}~{\mathit{bt}}~{{\mathit{in}}_1^\ast}~\mathsf{else}~{{\mathit{in}}_2^\ast} \\ &&|&
+\mathtt{0x08}~~x{:}{\mathtt{tagidx}} &\quad\Rightarrow&\quad \mathsf{throw}~x \\ &&|&
+\mathtt{0x0A} &\quad\Rightarrow&\quad \mathsf{throw\_ref} \\ &&|&
 \mathtt{0x0C}~~l{:}{\mathtt{labelidx}} &\quad\Rightarrow&\quad \mathsf{br}~l \\ &&|&
 \mathtt{0x0D}~~l{:}{\mathtt{labelidx}} &\quad\Rightarrow&\quad \mathsf{br\_if}~l \\ &&|&
 \mathtt{0x0E}~~{l^\ast}{:}{\mathtt{list}}({\mathtt{labelidx}})~~l_n{:}{\mathtt{labelidx}} &\quad\Rightarrow&\quad \mathsf{br\_table}~{l^\ast}~l_n \\ &&|&
@@ -9262,7 +9628,13 @@ $$
 \mathtt{0x11}~~y{:}{\mathtt{typeidx}}~~x{:}{\mathtt{tableidx}} &\quad\Rightarrow&\quad \mathsf{call\_indirect}~x~y \\ &&|&
 \mathtt{0x12}~~x{:}{\mathtt{funcidx}} &\quad\Rightarrow&\quad \mathsf{return\_call}~x \\ &&|&
 \mathtt{0x13}~~y{:}{\mathtt{typeidx}}~~x{:}{\mathtt{tableidx}} &\quad\Rightarrow&\quad \mathsf{return\_call\_indirect}~x~y \\ &&|&
+\mathtt{0x1F}~~{\mathit{bt}}{:}{\mathtt{blocktype}}~~{c^\ast}{:}{\mathtt{list}}({\mathtt{catch}})~~{({\mathit{in}}{:}{\mathtt{instr}})^\ast}~~\mathtt{0x0B} &\quad\Rightarrow&\quad \\
+  &&& \multicolumn{3}{@{}l@{}}{\qquad \mathsf{try\_table}~{\mathit{bt}}~{c^\ast}~{{\mathit{in}}^\ast} } \\ &&|&
 \ldots \\
+& {\mathtt{catch}} &::=& \mathtt{0x00}~~x{:}{\mathtt{tagidx}}~~l{:}{\mathtt{labelidx}} &\quad\Rightarrow&\quad \mathsf{catch}~x~l \\ &&|&
+\mathtt{0x01}~~x{:}{\mathtt{tagidx}}~~l{:}{\mathtt{labelidx}} &\quad\Rightarrow&\quad \mathsf{catch\_ref}~x~l \\ &&|&
+\mathtt{0x02}~~l{:}{\mathtt{labelidx}} &\quad\Rightarrow&\quad \mathsf{catch\_all}~l \\ &&|&
+\mathtt{0x03}~~l{:}{\mathtt{labelidx}} &\quad\Rightarrow&\quad \mathsf{catch\_all\_ref}~l \\
 \end{array}
 $$
 
@@ -10009,12 +10381,21 @@ $$
 
 \vspace{1ex}
 
+$$
+\begin{array}{@{}l@{}rrl@{}l@{}l@{}l@{}}
+& {\mathtt{tag}} &::=& x{:}{\mathtt{typeidx}} &\quad\Rightarrow&\quad \mathsf{tag}~x \\
+& {\mathtt{tagsec}} &::=& {{\mathit{tag}}^\ast}{:}{{\mathtt{section}}}_{13}({\mathtt{list}}({\mathtt{tag}})) &\quad\Rightarrow&\quad {{\mathit{tag}}^\ast} \\
+\end{array}
+$$
+
+\vspace{1ex}
+
 $$
 \begin{array}{@{}l@{}rrl@{}l@{}l@{}l@{}}
 & {\mathtt{magic}} &::=& \mathtt{0x00}~~\mathtt{0x61}~~\mathtt{0x73}~~\mathtt{0x6D} \\
 & {\mathtt{version}} &::=& \mathtt{0x01}~~\mathtt{0x00}~~\mathtt{0x00}~~\mathtt{0x00} \\
-& {\mathtt{module}} &::=& {\mathtt{magic}}~~{\mathtt{version}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{type}}^\ast}{:}{\mathtt{typesec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{import}}^\ast}{:}{\mathtt{importsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{typeidx}}^\ast}{:}{\mathtt{funcsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{table}}^\ast}{:}{\mathtt{tablesec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{mem}}^\ast}{:}{\mathtt{memsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{global}}^\ast}{:}{\mathtt{globalsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{export}}^\ast}{:}{\mathtt{exportsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{start}}^?}{:}{\mathtt{startsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{elem}}^\ast}{:}{\mathtt{elemsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{n^?}{:}{\mathtt{datacntsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{({{\mathit{local}}^\ast}, {\mathit{expr}})^\ast}{:}{\mathtt{codesec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{data}}^\ast}{:}{\mathtt{datasec}} \\ &&& {{\mathtt{customsec}}^\ast} &\quad\Rightarrow&\quad \\
-  &&& \multicolumn{3}{@{}l@{}}{\qquad \mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast} } \\
+& {\mathtt{module}} &::=& {\mathtt{magic}}~~{\mathtt{version}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{type}}^\ast}{:}{\mathtt{typesec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{import}}^\ast}{:}{\mathtt{importsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{typeidx}}^\ast}{:}{\mathtt{funcsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{table}}^\ast}{:}{\mathtt{tablesec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{mem}}^\ast}{:}{\mathtt{memsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{tag}}^\ast}{:}{\mathtt{tagsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{global}}^\ast}{:}{\mathtt{globalsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{export}}^\ast}{:}{\mathtt{exportsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{start}}^?}{:}{\mathtt{startsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{elem}}^\ast}{:}{\mathtt{elemsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{n^?}{:}{\mathtt{datacntsec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{({{\mathit{local}}^\ast}, {\mathit{expr}})^\ast}{:}{\mathtt{codesec}} \\ &&& {{\mathtt{customsec}}^\ast}~~{{\mathit{data}}^\ast}{:}{\mathtt{datasec}} \\ &&& {{\mathtt{customsec}}^\ast} &\quad\Rightarrow&\quad \\
+  &&& \multicolumn{3}{@{}l@{}}{\qquad \mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast} } \\
   &&&&& \multicolumn{2}{l@{}}{\quad \mbox{if}~(n = {|{{\mathit{data}}^\ast}|})^?} \\
   &&&&& \multicolumn{2}{l@{}}{\quad {\land}~{n^?} \neq \epsilon \lor {\mathrm{dataidx}}({{\mathit{func}}^\ast}) = \epsilon} \\
   &&&&& \multicolumn{2}{l@{}}{\quad {\land}~({\mathit{func}} = \mathsf{func}~{\mathit{typeidx}}~{{\mathit{local}}^\ast}~{\mathit{expr}})^\ast} \\
diff --git a/spectec/test-middlend/TEST.md b/spectec/test-middlend/TEST.md
index 061ca30504..0081c02325 100644
--- a/spectec/test-middlend/TEST.md
+++ b/spectec/test-middlend/TEST.md
@@ -329,6 +329,9 @@ syntax tableidx = idx
 ;; 1-syntax.watsup
 syntax memidx = idx
 
+;; 1-syntax.watsup
+syntax tagidx = idx
+
 ;; 1-syntax.watsup
 syntax elemidx = idx
 
@@ -385,6 +388,8 @@ syntax absheaptype =
   | NONE
   | FUNC
   | NOFUNC
+  | EXN
+  | NOEXN
   | EXTERN
   | NOEXTERN
   | BOT
@@ -400,13 +405,13 @@ syntax fin =
 ;; 1-syntax.watsup
 rec {
 
-;; 1-syntax.watsup:153.1-154.26
+;; 1-syntax.watsup:155.1-156.26
 syntax typeuse =
   | _IDX{typeidx : typeidx}(typeidx : typeidx)
   | DEF{rectype : rectype, n : n}(rectype : rectype, n : n)
   | REC{n : n}(n : n)
 
-;; 1-syntax.watsup:156.1-157.26
+;; 1-syntax.watsup:158.1-159.26
 syntax heaptype =
   | ANY
   | EQ
@@ -416,6 +421,8 @@ syntax heaptype =
   | NONE
   | FUNC
   | NOFUNC
+  | EXN
+  | NOEXN
   | EXTERN
   | NOEXTERN
   | BOT
@@ -423,7 +430,7 @@ syntax heaptype =
   | REC{n : n}(n : n)
   | DEF{rectype : rectype, n : n}(rectype : rectype, n : n)
 
-;; 1-syntax.watsup:164.1-165.14
+;; 1-syntax.watsup:166.1-167.14
 syntax valtype =
   | I32
   | I64
@@ -433,10 +440,10 @@ syntax valtype =
   | REF{nul : nul, heaptype : heaptype}(nul : nul, heaptype : heaptype)
   | BOT
 
-;; 1-syntax.watsup:194.1-195.16
+;; 1-syntax.watsup:196.1-197.16
 syntax resulttype = list(syntax valtype)
 
-;; 1-syntax.watsup:202.1-202.66
+;; 1-syntax.watsup:204.1-204.66
 syntax storagetype =
   | BOT
   | I32
@@ -448,31 +455,31 @@ syntax storagetype =
   | I8
   | I16
 
-;; 1-syntax.watsup:218.1-218.60
+;; 1-syntax.watsup:220.1-220.60
 syntax fieldtype =
   | `%%`{mut : mut, storagetype : storagetype}(mut : mut, storagetype : storagetype)
 
-;; 1-syntax.watsup:220.1-220.90
+;; 1-syntax.watsup:222.1-222.90
 syntax functype =
   | `%->%`{resulttype : resulttype}(resulttype : resulttype, resulttype)
 
-;; 1-syntax.watsup:221.1-221.64
+;; 1-syntax.watsup:223.1-223.64
 syntax structtype = list(syntax fieldtype)
 
-;; 1-syntax.watsup:222.1-222.54
+;; 1-syntax.watsup:224.1-224.54
 syntax arraytype = fieldtype
 
-;; 1-syntax.watsup:224.1-227.18
+;; 1-syntax.watsup:226.1-229.18
 syntax comptype =
   | STRUCT{structtype : structtype}(structtype : structtype)
   | ARRAY{arraytype : arraytype}(arraytype : arraytype)
   | FUNC{functype : functype}(functype : functype)
 
-;; 1-syntax.watsup:229.1-230.30
+;; 1-syntax.watsup:231.1-232.30
 syntax subtype =
   | SUB{fin : fin, typeuse* : typeuse*, comptype : comptype}(fin : fin, typeuse*{typeuse : typeuse} : typeuse*, comptype : comptype)
 
-;; 1-syntax.watsup:232.1-233.22
+;; 1-syntax.watsup:234.1-235.22
 syntax rectype =
   | REC{list : list(syntax subtype)}(list : list(syntax subtype))
 }
@@ -616,6 +623,9 @@ syntax tabletype =
 syntax memtype =
   | `%PAGE`{limits : limits}(limits : limits)
 
+;; 1-syntax.watsup
+syntax tagtype = deftype
+
 ;; 1-syntax.watsup
 syntax elemtype = reftype
 
@@ -629,6 +639,7 @@ syntax externtype =
   | GLOBAL{globaltype : globaltype}(globaltype : globaltype)
   | TABLE{tabletype : tabletype}(tabletype : tabletype)
   | MEM{memtype : memtype}(memtype : memtype)
+  | TAG{typeuse : typeuse}(typeuse : typeuse)
 
 ;; 1-syntax.watsup
 syntax moduletype =
@@ -1118,6 +1129,9 @@ syntax addr = nat
 ;; 4-runtime.watsup
 syntax arrayaddr = addr
 
+;; 4-runtime.watsup
+syntax exnaddr = addr
+
 ;; 4-runtime.watsup
 syntax funcaddr = addr
 
@@ -1130,16 +1144,24 @@ syntax structaddr = addr
 ;; 4-runtime.watsup
 rec {
 
-;; 4-runtime.watsup:37.1-43.23
+;; 4-runtime.watsup:35.1-42.23
 syntax addrref =
   | REF.I31_NUM{u31 : u31}(u31 : u31)
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
 }
 
+;; 1-syntax.watsup
+syntax catch =
+  | CATCH{tagidx : tagidx, labelidx : labelidx}(tagidx : tagidx, labelidx : labelidx)
+  | CATCH_REF{tagidx : tagidx, labelidx : labelidx}(tagidx : tagidx, labelidx : labelidx)
+  | CATCH_ALL{labelidx : labelidx}(labelidx : labelidx)
+  | CATCH_ALL_REF{labelidx : labelidx}(labelidx : labelidx)
+
 ;; 4-runtime.watsup
 syntax dataaddr = addr
 
@@ -1156,17 +1178,21 @@ syntax memaddr = addr
 syntax tableaddr = addr
 
 ;; 4-runtime.watsup
-syntax externval =
+syntax tagaddr = addr
+
+;; 4-runtime.watsup
+syntax externaddr =
   | FUNC{funcaddr : funcaddr}(funcaddr : funcaddr)
   | GLOBAL{globaladdr : globaladdr}(globaladdr : globaladdr)
   | TABLE{tableaddr : tableaddr}(tableaddr : tableaddr)
   | MEM{memaddr : memaddr}(memaddr : memaddr)
+  | TAG{tagaddr : tagaddr}(tagaddr : tagaddr)
 
 ;; 4-runtime.watsup
 syntax exportinst =
 {
   NAME{name : name} name,
-  VALUE{externval : externval} externval
+  ADDR{externaddr : externaddr} externaddr
 }
 
 ;; 4-runtime.watsup
@@ -1177,6 +1203,7 @@ syntax moduleinst =
   GLOBALS{globaladdr* : globaladdr*} globaladdr*,
   TABLES{tableaddr* : tableaddr*} tableaddr*,
   MEMS{memaddr* : memaddr*} memaddr*,
+  TAGS{tagaddr* : tagaddr*} tagaddr*,
   ELEMS{elemaddr* : elemaddr*} elemaddr*,
   DATAS{dataaddr* : dataaddr*} dataaddr*,
   EXPORTS{exportinst* : exportinst*} exportinst*
@@ -1191,6 +1218,7 @@ syntax val =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
 
@@ -1204,7 +1232,7 @@ syntax frame =
 ;; 4-runtime.watsup
 rec {
 
-;; 4-runtime.watsup:151.1-156.9
+;; 4-runtime.watsup:151.1-157.9
 syntax instr =
   | NOP
   | UNREACHABLE
@@ -1227,6 +1255,9 @@ syntax instr =
   | RETURN_CALL{funcidx : funcidx}(funcidx : funcidx)
   | RETURN_CALL_REF{typeuse : typeuse}(typeuse : typeuse)
   | RETURN_CALL_INDIRECT{tableidx : tableidx, typeuse : typeuse}(tableidx : tableidx, typeuse : typeuse)
+  | THROW{tagidx : tagidx}(tagidx : tagidx)
+  | THROW_REF
+  | TRY_TABLE{blocktype : blocktype, list : list(syntax catch), instr* : instr*}(blocktype : blocktype, list : list(syntax catch), instr*{instr : instr} : instr*)
   | CONST{numtype : numtype, num_ : num_(numtype)}(numtype : numtype, num_ : num_(numtype))
   | UNOP{numtype : numtype, unop_ : unop_(numtype)}(numtype : numtype, unop_ : unop_(numtype))
   | BINOP{numtype : numtype, binop_ : binop_(numtype)}(numtype : numtype, binop_ : binop_(numtype))
@@ -1314,10 +1345,12 @@ syntax instr =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | `LABEL_%{%}%`{n : n, instr* : instr*}(n : n, instr*{instr : instr} : instr*, instr*)
   | `FRAME_%{%}%`{n : n, frame : frame, instr* : instr*}(n : n, frame : frame, instr*{instr : instr} : instr*)
+  | `HANDLER_%{%}%`{n : n, catch* : catch*, instr* : instr*}(n : n, catch*{catch : catch} : catch*, instr*{instr : instr} : instr*)
   | TRAP
 }
 
@@ -1359,6 +1392,10 @@ syntax table =
 syntax mem =
   | MEMORY{memtype : memtype}(memtype : memtype)
 
+;; 1-syntax.watsup
+syntax tag =
+  | TAG{typeidx : typeidx}(typeidx : typeidx)
+
 ;; 1-syntax.watsup
 syntax elem =
   | ELEM{reftype : reftype, expr* : expr*, elemmode : elemmode}(reftype : reftype, expr*{expr : expr} : expr*, elemmode : elemmode)
@@ -1377,6 +1414,7 @@ syntax externidx =
   | GLOBAL{globalidx : globalidx}(globalidx : globalidx)
   | TABLE{tableidx : tableidx}(tableidx : tableidx)
   | MEM{memidx : memidx}(memidx : memidx)
+  | TAG{tagidx : tagidx}(tagidx : tagidx)
 
 ;; 1-syntax.watsup
 syntax export =
@@ -1388,7 +1426,7 @@ syntax import =
 
 ;; 1-syntax.watsup
 syntax module =
-  | MODULE{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*}(type*{type : type} : type*, import*{import : import} : import*, func*{func : func} : func*, global*{global : global} : global*, table*{table : table} : table*, mem*{mem : mem} : mem*, elem*{elem : elem} : elem*, data*{data : data} : data*, start?{start : start} : start?, export*{export : export} : export*)
+  | MODULE{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*}(type*{type : type} : type*, import*{import : import} : import*, func*{func : func} : func*, global*{global : global} : global*, table*{table : table} : table*, mem*{mem : mem} : mem*, tag*{tag : tag} : tag*, elem*{elem : elem} : elem*, data*{data : data} : data*, start?{start : start} : start?, export*{export : export} : export*)
 
 ;; 2-syntax-aux.watsup
 def $IN(N : N) : Inn
@@ -2012,6 +2050,11 @@ def $free_mem(mem : mem) : free
   ;; 2-syntax-aux.watsup
   def $free_mem{memtype : memtype}(MEMORY_mem(memtype)) = $free_memtype(memtype)
 
+;; 2-syntax-aux.watsup
+def $free_tag(tag : tag) : free
+  ;; 2-syntax-aux.watsup
+  def $free_tag{typeidx : typeidx}(TAG_tag(typeidx)) = $free_typeidx(typeidx)
+
 ;; 2-syntax-aux.watsup
 def $free_elemmode(elemmode : elemmode) : free
   ;; 2-syntax-aux.watsup
@@ -2056,7 +2099,7 @@ def $free_import(import : import) : free
 ;; 2-syntax-aux.watsup
 def $free_module(module : module) : free
   ;; 2-syntax-aux.watsup
-  def $free_module{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*}(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})) = $free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})
+  def $free_module{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*}(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})) = $free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_tag(tag)*{tag : tag}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})
 
 ;; 2-syntax-aux.watsup
 def $funcidx_module(module : module) : funcidx*
@@ -2071,14 +2114,14 @@ def $dataidx_funcs(func*) : dataidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:531.1-531.112
+;; 2-syntax-aux.watsup:535.1-535.112
 def $subst_typevar(typevar : typevar, typevar*, typeuse*) : typeuse
-  ;; 2-syntax-aux.watsup:558.1-558.38
+  ;; 2-syntax-aux.watsup:562.1-562.38
   def $subst_typevar{tv : typevar}(tv, [], []) = (tv : typevar <: typeuse)
-  ;; 2-syntax-aux.watsup:559.1-559.95
+  ;; 2-syntax-aux.watsup:563.1-563.95
   def $subst_typevar{tv : typevar, tv_1 : typevar, tv'* : typevar*, tu_1 : typeuse, tu'* : typeuse*}(tv, [tv_1] :: tv'*{tv' : typevar}, [tu_1] :: tu'*{tu' : typeuse}) = tu_1
     -- if (tv = tv_1)
-  ;; 2-syntax-aux.watsup:560.1-560.92
+  ;; 2-syntax-aux.watsup:564.1-564.92
   def $subst_typevar{tv : typevar, tv_1 : typevar, tv'* : typevar*, tu_1 : typeuse, tu'* : typeuse*}(tv, [tv_1] :: tv'*{tv' : typevar}, [tu_1] :: tu'*{tu' : typeuse}) = $subst_typevar(tv, tv'*{tv' : typevar}, tu'*{tu' : typeuse})
     -- otherwise
 }
@@ -2101,78 +2144,78 @@ def $subst_vectype(vectype : vectype, typevar*, typeuse*) : vectype
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:532.1-532.112
+;; 2-syntax-aux.watsup:536.1-536.112
 def $subst_typeuse(typeuse : typeuse, typevar*, typeuse*) : typeuse
-  ;; 2-syntax-aux.watsup:562.1-562.66
+  ;; 2-syntax-aux.watsup:566.1-566.66
   def $subst_typeuse{tv' : typevar, tv* : typevar*, tu* : typeuse*}((tv' : typevar <: typeuse), tv*{tv : typevar}, tu*{tu : typeuse}) = $subst_typevar(tv', tv*{tv : typevar}, tu*{tu : typeuse})
-  ;; 2-syntax-aux.watsup:563.1-563.64
+  ;; 2-syntax-aux.watsup:567.1-567.64
   def $subst_typeuse{dt : deftype, tv* : typevar*, tu* : typeuse*}((dt : deftype <: typeuse), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_deftype(dt, tv*{tv : typevar}, tu*{tu : typeuse}) : deftype <: typeuse)
 
-;; 2-syntax-aux.watsup:536.1-536.112
+;; 2-syntax-aux.watsup:540.1-540.112
 def $subst_heaptype(heaptype : heaptype, typevar*, typeuse*) : heaptype
-  ;; 2-syntax-aux.watsup:568.1-568.67
+  ;; 2-syntax-aux.watsup:572.1-572.67
   def $subst_heaptype{tv' : typevar, tv* : typevar*, tu* : typeuse*}((tv' : typevar <: heaptype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_typevar(tv', tv*{tv : typevar}, tu*{tu : typeuse}) : typeuse <: heaptype)
-  ;; 2-syntax-aux.watsup:569.1-569.65
+  ;; 2-syntax-aux.watsup:573.1-573.65
   def $subst_heaptype{dt : deftype, tv* : typevar*, tu* : typeuse*}((dt : deftype <: heaptype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_deftype(dt, tv*{tv : typevar}, tu*{tu : typeuse}) : deftype <: heaptype)
-  ;; 2-syntax-aux.watsup:570.1-570.53
+  ;; 2-syntax-aux.watsup:574.1-574.53
   def $subst_heaptype{ht : heaptype, tv* : typevar*, tu* : typeuse*}(ht, tv*{tv : typevar}, tu*{tu : typeuse}) = ht
     -- otherwise
 
-;; 2-syntax-aux.watsup:537.1-537.112
+;; 2-syntax-aux.watsup:541.1-541.112
 def $subst_reftype(reftype : reftype, typevar*, typeuse*) : reftype
-  ;; 2-syntax-aux.watsup:572.1-572.83
+  ;; 2-syntax-aux.watsup:576.1-576.83
   def $subst_reftype{nul : nul, ht : heaptype, tv* : typevar*, tu* : typeuse*}(REF_reftype(nul, ht), tv*{tv : typevar}, tu*{tu : typeuse}) = REF_reftype(nul, $subst_heaptype(ht, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:538.1-538.112
+;; 2-syntax-aux.watsup:542.1-542.112
 def $subst_valtype(valtype : valtype, typevar*, typeuse*) : valtype
-  ;; 2-syntax-aux.watsup:574.1-574.64
+  ;; 2-syntax-aux.watsup:578.1-578.64
   def $subst_valtype{nt : numtype, tv* : typevar*, tu* : typeuse*}((nt : numtype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_numtype(nt, tv*{tv : typevar}, tu*{tu : typeuse}) : numtype <: valtype)
-  ;; 2-syntax-aux.watsup:575.1-575.64
+  ;; 2-syntax-aux.watsup:579.1-579.64
   def $subst_valtype{vt : vectype, tv* : typevar*, tu* : typeuse*}((vt : vectype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_vectype(vt, tv*{tv : typevar}, tu*{tu : typeuse}) : vectype <: valtype)
-  ;; 2-syntax-aux.watsup:576.1-576.64
+  ;; 2-syntax-aux.watsup:580.1-580.64
   def $subst_valtype{rt : reftype, tv* : typevar*, tu* : typeuse*}((rt : reftype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_reftype(rt, tv*{tv : typevar}, tu*{tu : typeuse}) : reftype <: valtype)
-  ;; 2-syntax-aux.watsup:577.1-577.40
+  ;; 2-syntax-aux.watsup:581.1-581.40
   def $subst_valtype{tv* : typevar*, tu* : typeuse*}(BOT_valtype, tv*{tv : typevar}, tu*{tu : typeuse}) = BOT_valtype
 
-;; 2-syntax-aux.watsup:541.1-541.112
+;; 2-syntax-aux.watsup:545.1-545.112
 def $subst_storagetype(storagetype : storagetype, typevar*, typeuse*) : storagetype
-  ;; 2-syntax-aux.watsup:581.1-581.66
+  ;; 2-syntax-aux.watsup:585.1-585.66
   def $subst_storagetype{t : valtype, tv* : typevar*, tu* : typeuse*}((t : valtype <: storagetype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_valtype(t, tv*{tv : typevar}, tu*{tu : typeuse}) : valtype <: storagetype)
-  ;; 2-syntax-aux.watsup:582.1-582.69
+  ;; 2-syntax-aux.watsup:586.1-586.69
   def $subst_storagetype{pt : packtype, tv* : typevar*, tu* : typeuse*}((pt : packtype <: storagetype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_packtype(pt, tv*{tv : typevar}, tu*{tu : typeuse}) : packtype <: storagetype)
 
-;; 2-syntax-aux.watsup:542.1-542.112
+;; 2-syntax-aux.watsup:546.1-546.112
 def $subst_fieldtype(fieldtype : fieldtype, typevar*, typeuse*) : fieldtype
-  ;; 2-syntax-aux.watsup:584.1-584.80
+  ;; 2-syntax-aux.watsup:588.1-588.80
   def $subst_fieldtype{mut : mut, zt : storagetype, tv* : typevar*, tu* : typeuse*}(`%%`_fieldtype(mut, zt), tv*{tv : typevar}, tu*{tu : typeuse}) = `%%`_fieldtype(mut, $subst_storagetype(zt, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:544.1-544.112
+;; 2-syntax-aux.watsup:548.1-548.112
 def $subst_comptype(comptype : comptype, typevar*, typeuse*) : comptype
-  ;; 2-syntax-aux.watsup:586.1-586.85
+  ;; 2-syntax-aux.watsup:590.1-590.85
   def $subst_comptype{yt* : fieldtype*, tv* : typevar*, tu* : typeuse*}(STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = STRUCT_comptype(`%`_structtype($subst_fieldtype(yt, tv*{tv : typevar}, tu*{tu : typeuse})*{yt : fieldtype}))
-  ;; 2-syntax-aux.watsup:587.1-587.81
+  ;; 2-syntax-aux.watsup:591.1-591.81
   def $subst_comptype{yt : fieldtype, tv* : typevar*, tu* : typeuse*}(ARRAY_comptype(yt), tv*{tv : typevar}, tu*{tu : typeuse}) = ARRAY_comptype($subst_fieldtype(yt, tv*{tv : typevar}, tu*{tu : typeuse}))
-  ;; 2-syntax-aux.watsup:588.1-588.78
+  ;; 2-syntax-aux.watsup:592.1-592.78
   def $subst_comptype{ft : functype, tv* : typevar*, tu* : typeuse*}(FUNC_comptype(ft), tv*{tv : typevar}, tu*{tu : typeuse}) = FUNC_comptype($subst_functype(ft, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:545.1-545.112
+;; 2-syntax-aux.watsup:549.1-549.112
 def $subst_subtype(subtype : subtype, typevar*, typeuse*) : subtype
-  ;; 2-syntax-aux.watsup:590.1-591.71
+  ;; 2-syntax-aux.watsup:594.1-595.71
   def $subst_subtype{fin : fin, tu'* : typeuse*, ct : comptype, tv* : typevar*, tu* : typeuse*}(SUB_subtype(fin, tu'*{tu' : typeuse}, ct), tv*{tv : typevar}, tu*{tu : typeuse}) = SUB_subtype(fin, $subst_typeuse(tu', tv*{tv : typevar}, tu*{tu : typeuse})*{tu' : typeuse}, $subst_comptype(ct, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:546.1-546.112
+;; 2-syntax-aux.watsup:550.1-550.112
 def $subst_rectype(rectype : rectype, typevar*, typeuse*) : rectype
-  ;; 2-syntax-aux.watsup:593.1-593.76
+  ;; 2-syntax-aux.watsup:597.1-597.76
   def $subst_rectype{st* : subtype*, tv* : typevar*, tu* : typeuse*}(REC_rectype(`%`_list(st*{st : subtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = REC_rectype(`%`_list($subst_subtype(st, tv*{tv : typevar}, tu*{tu : typeuse})*{st : subtype}))
 
-;; 2-syntax-aux.watsup:547.1-547.112
+;; 2-syntax-aux.watsup:551.1-551.112
 def $subst_deftype(deftype : deftype, typevar*, typeuse*) : deftype
-  ;; 2-syntax-aux.watsup:595.1-595.78
+  ;; 2-syntax-aux.watsup:599.1-599.78
   def $subst_deftype{qt : rectype, i : nat, tv* : typevar*, tu* : typeuse*}(DEF_deftype(qt, i), tv*{tv : typevar}, tu*{tu : typeuse}) = DEF_deftype($subst_rectype(qt, tv*{tv : typevar}, tu*{tu : typeuse}), i)
 
-;; 2-syntax-aux.watsup:550.1-550.112
+;; 2-syntax-aux.watsup:554.1-554.112
 def $subst_functype(functype : functype, typevar*, typeuse*) : functype
-  ;; 2-syntax-aux.watsup:598.1-598.113
+  ;; 2-syntax-aux.watsup:602.1-602.113
   def $subst_functype{t_1* : valtype*, t_2* : valtype*, tv* : typevar*, tu* : typeuse*}(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = `%->%`_functype(`%`_resulttype($subst_valtype(t_1, tv*{tv : typevar}, tu*{tu : typeuse})*{t_1 : valtype}), `%`_resulttype($subst_valtype(t_2, tv*{tv : typevar}, tu*{tu : typeuse})*{t_2 : valtype}))
 }
 
@@ -2230,11 +2273,11 @@ def $subst_all_moduletype(moduletype : moduletype, heaptype*) : moduletype
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:620.1-620.98
+;; 2-syntax-aux.watsup:624.1-624.98
 def $subst_all_deftypes(deftype*, heaptype*) : deftype*
-  ;; 2-syntax-aux.watsup:621.1-621.40
+  ;; 2-syntax-aux.watsup:625.1-625.40
   def $subst_all_deftypes{tu* : typeuse*}([], (tu : typeuse <: heaptype)*{tu : typeuse}) = []
-  ;; 2-syntax-aux.watsup:622.1-622.101
+  ;; 2-syntax-aux.watsup:626.1-626.101
   def $subst_all_deftypes{dt_1 : deftype, dt* : deftype*, tu* : typeuse*}([dt_1] :: dt*{dt : deftype}, (tu : typeuse <: heaptype)*{tu : typeuse}) = [$subst_all_deftype(dt_1, (tu : typeuse <: heaptype)*{tu : typeuse})] :: $subst_all_deftypes(dt*{dt : deftype}, (tu : typeuse <: heaptype)*{tu : typeuse})
 }
 
@@ -2278,13 +2321,13 @@ relation Expand: `%~~%`(deftype, comptype)
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:654.1-654.86
+;; 2-syntax-aux.watsup:658.1-658.86
 def $funcsxx(externidx*) : typeidx*
-  ;; 2-syntax-aux.watsup:659.1-659.24
+  ;; 2-syntax-aux.watsup:664.1-664.24
   def $funcsxx([]) = []
-  ;; 2-syntax-aux.watsup:660.1-660.45
+  ;; 2-syntax-aux.watsup:665.1-665.45
   def $funcsxx{x : idx, xx* : externidx*}([FUNC_externidx(x)] :: xx*{xx : externidx}) = [x] :: $funcsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:661.1-661.58
+  ;; 2-syntax-aux.watsup:666.1-666.58
   def $funcsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $funcsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -2292,13 +2335,13 @@ def $funcsxx(externidx*) : typeidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:655.1-655.88
+;; 2-syntax-aux.watsup:659.1-659.88
 def $globalsxx(externidx*) : globalidx*
-  ;; 2-syntax-aux.watsup:663.1-663.26
+  ;; 2-syntax-aux.watsup:668.1-668.26
   def $globalsxx([]) = []
-  ;; 2-syntax-aux.watsup:664.1-664.51
+  ;; 2-syntax-aux.watsup:669.1-669.51
   def $globalsxx{x : idx, xx* : externidx*}([GLOBAL_externidx(x)] :: xx*{xx : externidx}) = [x] :: $globalsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:665.1-665.62
+  ;; 2-syntax-aux.watsup:670.1-670.62
   def $globalsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $globalsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -2306,13 +2349,13 @@ def $globalsxx(externidx*) : globalidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:656.1-656.87
+;; 2-syntax-aux.watsup:660.1-660.87
 def $tablesxx(externidx*) : tableidx*
-  ;; 2-syntax-aux.watsup:667.1-667.25
+  ;; 2-syntax-aux.watsup:672.1-672.25
   def $tablesxx([]) = []
-  ;; 2-syntax-aux.watsup:668.1-668.48
+  ;; 2-syntax-aux.watsup:673.1-673.48
   def $tablesxx{x : idx, xx* : externidx*}([TABLE_externidx(x)] :: xx*{xx : externidx}) = [x] :: $tablesxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:669.1-669.60
+  ;; 2-syntax-aux.watsup:674.1-674.60
   def $tablesxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $tablesxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -2320,13 +2363,13 @@ def $tablesxx(externidx*) : tableidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:657.1-657.85
+;; 2-syntax-aux.watsup:661.1-661.85
 def $memsxx(externidx*) : memidx*
-  ;; 2-syntax-aux.watsup:671.1-671.23
+  ;; 2-syntax-aux.watsup:676.1-676.23
   def $memsxx([]) = []
-  ;; 2-syntax-aux.watsup:672.1-672.42
+  ;; 2-syntax-aux.watsup:677.1-677.42
   def $memsxx{x : idx, xx* : externidx*}([MEM_externidx(x)] :: xx*{xx : externidx}) = [x] :: $memsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:673.1-673.56
+  ;; 2-syntax-aux.watsup:678.1-678.56
   def $memsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $memsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -2334,13 +2377,27 @@ def $memsxx(externidx*) : memidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:676.1-676.88
+;; 2-syntax-aux.watsup:662.1-662.85
+def $tagsxx(externidx*) : tagidx*
+  ;; 2-syntax-aux.watsup:680.1-680.23
+  def $tagsxx([]) = []
+  ;; 2-syntax-aux.watsup:681.1-681.42
+  def $tagsxx{x : idx, xx* : externidx*}([TAG_externidx(x)] :: xx*{xx : externidx}) = [x] :: $tagsxx(xx*{xx : externidx})
+  ;; 2-syntax-aux.watsup:682.1-682.56
+  def $tagsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $tagsxx(xx*{xx : externidx})
+    -- otherwise
+}
+
+;; 2-syntax-aux.watsup
+rec {
+
+;; 2-syntax-aux.watsup:685.1-685.88
 def $funcsxt(externtype*) : deftype*
-  ;; 2-syntax-aux.watsup:681.1-681.24
+  ;; 2-syntax-aux.watsup:691.1-691.24
   def $funcsxt([]) = []
-  ;; 2-syntax-aux.watsup:682.1-682.47
+  ;; 2-syntax-aux.watsup:692.1-692.47
   def $funcsxt{dt : deftype, xt* : externtype*}([FUNC_externtype((dt : deftype <: typeuse))] :: xt*{xt : externtype}) = [dt] :: $funcsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:683.1-683.59
+  ;; 2-syntax-aux.watsup:693.1-693.59
   def $funcsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $funcsxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -2348,13 +2405,13 @@ def $funcsxt(externtype*) : deftype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:677.1-677.90
+;; 2-syntax-aux.watsup:686.1-686.90
 def $globalsxt(externtype*) : globaltype*
-  ;; 2-syntax-aux.watsup:685.1-685.26
+  ;; 2-syntax-aux.watsup:695.1-695.26
   def $globalsxt([]) = []
-  ;; 2-syntax-aux.watsup:686.1-686.53
+  ;; 2-syntax-aux.watsup:696.1-696.53
   def $globalsxt{gt : globaltype, xt* : externtype*}([GLOBAL_externtype(gt)] :: xt*{xt : externtype}) = [gt] :: $globalsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:687.1-687.63
+  ;; 2-syntax-aux.watsup:697.1-697.63
   def $globalsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $globalsxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -2362,13 +2419,13 @@ def $globalsxt(externtype*) : globaltype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:678.1-678.89
+;; 2-syntax-aux.watsup:687.1-687.89
 def $tablesxt(externtype*) : tabletype*
-  ;; 2-syntax-aux.watsup:689.1-689.25
+  ;; 2-syntax-aux.watsup:699.1-699.25
   def $tablesxt([]) = []
-  ;; 2-syntax-aux.watsup:690.1-690.50
+  ;; 2-syntax-aux.watsup:700.1-700.50
   def $tablesxt{tt : tabletype, xt* : externtype*}([TABLE_externtype(tt)] :: xt*{xt : externtype}) = [tt] :: $tablesxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:691.1-691.61
+  ;; 2-syntax-aux.watsup:701.1-701.61
   def $tablesxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $tablesxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -2376,17 +2433,31 @@ def $tablesxt(externtype*) : tabletype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:679.1-679.87
+;; 2-syntax-aux.watsup:688.1-688.87
 def $memsxt(externtype*) : memtype*
-  ;; 2-syntax-aux.watsup:693.1-693.23
+  ;; 2-syntax-aux.watsup:703.1-703.23
   def $memsxt([]) = []
-  ;; 2-syntax-aux.watsup:694.1-694.44
+  ;; 2-syntax-aux.watsup:704.1-704.44
   def $memsxt{mt : memtype, xt* : externtype*}([MEM_externtype(mt)] :: xt*{xt : externtype}) = [mt] :: $memsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:695.1-695.57
+  ;; 2-syntax-aux.watsup:705.1-705.57
   def $memsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $memsxt(xt*{xt : externtype})
     -- otherwise
 }
 
+;; 2-syntax-aux.watsup
+rec {
+
+;; 2-syntax-aux.watsup:689.1-689.87
+def $tagsxt(externtype*) : tagtype*
+  ;; 2-syntax-aux.watsup:707.1-707.23
+  def $tagsxt([]) = []
+  ;; 2-syntax-aux.watsup:708.1-708.44
+  def $tagsxt{at : tagtype, xt* : externtype*}([TAG_externtype((at : deftype <: typeuse))] :: xt*{xt : externtype}) = [at] :: $tagsxt(xt*{xt : externtype})
+  ;; 2-syntax-aux.watsup:709.1-709.57
+  def $tagsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $tagsxt(xt*{xt : externtype})
+    -- otherwise
+}
+
 ;; 2-syntax-aux.watsup
 def $memarg0 : memarg
   ;; 2-syntax-aux.watsup
@@ -3114,6 +3185,7 @@ syntax ref =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | REF.NULL{heaptype : heaptype}(heaptype : heaptype)
@@ -3121,6 +3193,7 @@ syntax ref =
 ;; 4-runtime.watsup
 syntax result =
   | _VALS{val* : val*}(val*{val : val} : val*)
+  | `_EXN(REF.EXN_ADDR%)THROW_REF`{exnaddr : exnaddr}(exnaddr : exnaddr)
   | TRAP
 
 ;; 4-runtime.watsup
@@ -3161,6 +3234,12 @@ syntax meminst =
   BYTES{byte* : byte*} byte*
 }
 
+;; 4-runtime.watsup
+syntax taginst =
+{
+  TYPE{tagtype : tagtype} tagtype
+}
+
 ;; 4-runtime.watsup
 syntax eleminst =
 {
@@ -3187,6 +3266,7 @@ syntax fieldval =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | PACK{packtype : packtype, iN : iN($psizenn(packtype))}(packtype : packtype, iN : iN($psizenn(packtype)))
@@ -3205,6 +3285,13 @@ syntax arrayinst =
   FIELDS{fieldval* : fieldval*} fieldval*
 }
 
+;; 4-runtime.watsup
+syntax exninst =
+{
+  TAG{tagaddr : tagaddr} tagaddr,
+  FIELDS{val* : val*} val*
+}
+
 ;; 4-runtime.watsup
 syntax store =
 {
@@ -3212,10 +3299,12 @@ syntax store =
   GLOBALS{globalinst* : globalinst*} globalinst*,
   TABLES{tableinst* : tableinst*} tableinst*,
   MEMS{meminst* : meminst*} meminst*,
+  TAGS{taginst* : taginst*} taginst*,
   ELEMS{eleminst* : eleminst*} eleminst*,
   DATAS{datainst* : datainst*} datainst*,
   STRUCTS{structinst* : structinst*} structinst*,
-  ARRAYS{arrayinst* : arrayinst*} arrayinst*
+  ARRAYS{arrayinst* : arrayinst*} arrayinst*,
+  EXNS{exninst* : exninst*} exninst*
 }
 
 ;; 4-runtime.watsup
@@ -3268,56 +3357,70 @@ def $unpackfield_(storagetype : storagetype, sx?, fieldval : fieldval) : val
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:46.1-46.86
-def $funcsxv(externval*) : funcaddr*
-  ;; 5-runtime-aux.watsup:51.1-51.24
-  def $funcsxv([]) = []
-  ;; 5-runtime-aux.watsup:52.1-52.47
-  def $funcsxv{fa : funcaddr, xv* : externval*}([FUNC_externval(fa)] :: xv*{xv : externval}) = [fa] :: $funcsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:53.1-53.58
-  def $funcsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $funcsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:46.1-46.87
+def $funcsxa(externaddr*) : funcaddr*
+  ;; 5-runtime-aux.watsup:52.1-52.24
+  def $funcsxa([]) = []
+  ;; 5-runtime-aux.watsup:53.1-53.47
+  def $funcsxa{fa : funcaddr, xa* : externaddr*}([FUNC_externaddr(fa)] :: xa*{xa : externaddr}) = [fa] :: $funcsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:54.1-54.59
+  def $funcsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $funcsxa(xa*{xa : externaddr})
+    -- otherwise
+}
+
+;; 5-runtime-aux.watsup
+rec {
+
+;; 5-runtime-aux.watsup:47.1-47.89
+def $globalsxa(externaddr*) : globaladdr*
+  ;; 5-runtime-aux.watsup:56.1-56.26
+  def $globalsxa([]) = []
+  ;; 5-runtime-aux.watsup:57.1-57.53
+  def $globalsxa{ga : globaladdr, xa* : externaddr*}([GLOBAL_externaddr(ga)] :: xa*{xa : externaddr}) = [ga] :: $globalsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:58.1-58.63
+  def $globalsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $globalsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:47.1-47.88
-def $globalsxv(externval*) : globaladdr*
-  ;; 5-runtime-aux.watsup:55.1-55.26
-  def $globalsxv([]) = []
-  ;; 5-runtime-aux.watsup:56.1-56.53
-  def $globalsxv{ga : globaladdr, xv* : externval*}([GLOBAL_externval(ga)] :: xv*{xv : externval}) = [ga] :: $globalsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:57.1-57.62
-  def $globalsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $globalsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:48.1-48.88
+def $tablesxa(externaddr*) : tableaddr*
+  ;; 5-runtime-aux.watsup:60.1-60.25
+  def $tablesxa([]) = []
+  ;; 5-runtime-aux.watsup:61.1-61.50
+  def $tablesxa{ta : tableaddr, xa* : externaddr*}([TABLE_externaddr(ta)] :: xa*{xa : externaddr}) = [ta] :: $tablesxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:62.1-62.61
+  def $tablesxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $tablesxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:48.1-48.87
-def $tablesxv(externval*) : tableaddr*
-  ;; 5-runtime-aux.watsup:59.1-59.25
-  def $tablesxv([]) = []
-  ;; 5-runtime-aux.watsup:60.1-60.50
-  def $tablesxv{ta : tableaddr, xv* : externval*}([TABLE_externval(ta)] :: xv*{xv : externval}) = [ta] :: $tablesxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:61.1-61.60
-  def $tablesxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $tablesxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:49.1-49.86
+def $memsxa(externaddr*) : memaddr*
+  ;; 5-runtime-aux.watsup:64.1-64.23
+  def $memsxa([]) = []
+  ;; 5-runtime-aux.watsup:65.1-65.44
+  def $memsxa{ma : memaddr, xa* : externaddr*}([MEM_externaddr(ma)] :: xa*{xa : externaddr}) = [ma] :: $memsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:66.1-66.57
+  def $memsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $memsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:49.1-49.85
-def $memsxv(externval*) : memaddr*
-  ;; 5-runtime-aux.watsup:63.1-63.23
-  def $memsxv([]) = []
-  ;; 5-runtime-aux.watsup:64.1-64.44
-  def $memsxv{ma : memaddr, xv* : externval*}([MEM_externval(ma)] :: xv*{xv : externval}) = [ma] :: $memsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:65.1-65.56
-  def $memsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $memsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:50.1-50.86
+def $tagsxa(externaddr*) : tagaddr*
+  ;; 5-runtime-aux.watsup:68.1-68.23
+  def $tagsxa([]) = []
+  ;; 5-runtime-aux.watsup:69.1-69.44
+  def $tagsxa{ha : tagaddr, xa* : externaddr*}([TAG_externaddr(ha)] :: xa*{xa : externaddr}) = [ha] :: $tagsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:70.1-70.57
+  def $tagsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $tagsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
@@ -3331,6 +3434,11 @@ def $frame(state : state) : frame
   ;; 5-runtime-aux.watsup
   def $frame{s : store, f : frame}(`%;%`_state(s, f)) = f
 
+;; 5-runtime-aux.watsup
+def $tagaddr(state : state) : tagaddr*
+  ;; 5-runtime-aux.watsup
+  def $tagaddr{s : store, f : frame}(`%;%`_state(s, f)) = f.MODULE_frame.TAGS_moduleinst
+
 ;; 5-runtime-aux.watsup
 def $moduleinst(state : state) : moduleinst
   ;; 5-runtime-aux.watsup
@@ -3356,6 +3464,11 @@ def $meminst(state : state) : meminst*
   ;; 5-runtime-aux.watsup
   def $meminst{s : store, f : frame}(`%;%`_state(s, f)) = s.MEMS_store
 
+;; 5-runtime-aux.watsup
+def $taginst(state : state) : taginst*
+  ;; 5-runtime-aux.watsup
+  def $taginst{s : store, f : frame}(`%;%`_state(s, f)) = s.TAGS_store
+
 ;; 5-runtime-aux.watsup
 def $eleminst(state : state) : eleminst*
   ;; 5-runtime-aux.watsup
@@ -3376,6 +3489,11 @@ def $arrayinst(state : state) : arrayinst*
   ;; 5-runtime-aux.watsup
   def $arrayinst{s : store, f : frame}(`%;%`_state(s, f)) = s.ARRAYS_store
 
+;; 5-runtime-aux.watsup
+def $exninst(state : state) : exninst*
+  ;; 5-runtime-aux.watsup
+  def $exninst{s : store, f : frame}(`%;%`_state(s, f)) = s.EXNS_store
+
 ;; 5-runtime-aux.watsup
 def $type(state : state, typeidx : typeidx) : deftype
   ;; 5-runtime-aux.watsup
@@ -3401,6 +3519,11 @@ def $mem(state : state, memidx : memidx) : meminst
   ;; 5-runtime-aux.watsup
   def $mem{s : store, f : frame, x : idx}(`%;%`_state(s, f), x) = s.MEMS_store[f.MODULE_frame.MEMS_moduleinst[x!`%`_idx.0]]
 
+;; 5-runtime-aux.watsup
+def $tag(state : state, tagidx : tagidx) : taginst
+  ;; 5-runtime-aux.watsup
+  def $tag{s : store, f : frame, x : idx}(`%;%`_state(s, f), x) = s.TAGS_store[f.MODULE_frame.TAGS_moduleinst[x!`%`_idx.0]]
+
 ;; 5-runtime-aux.watsup
 def $elem(state : state, tableidx : tableidx) : eleminst
   ;; 5-runtime-aux.watsup
@@ -3476,6 +3599,11 @@ def $add_arrayinst(state : state, arrayinst*) : state
   ;; 5-runtime-aux.watsup
   def $add_arrayinst{s : store, f : frame, ai* : arrayinst*}(`%;%`_state(s, f), ai*{ai : arrayinst}) = `%;%`_state(s[ARRAYS_store =++ ai*{ai : arrayinst}], f)
 
+;; 5-runtime-aux.watsup
+def $add_exninst(state : state, exninst*) : state
+  ;; 5-runtime-aux.watsup
+  def $add_exninst{s : store, f : frame, exn* : exninst*}(`%;%`_state(s, f), exn*{exn : exninst}) = `%;%`_state(s[EXNS_store =++ exn*{exn : exninst}], f)
+
 ;; 5-runtime-aux.watsup
 def $growtable(tableinst : tableinst, nat : nat, ref : ref) : tableinst
   ;; 5-runtime-aux.watsup
@@ -3514,6 +3642,7 @@ syntax context =
   GLOBALS{globaltype* : globaltype*} globaltype*,
   TABLES{tabletype* : tabletype*} tabletype*,
   MEMS{memtype* : memtype*} memtype*,
+  TAGS{tagtype* : tagtype*} tagtype*,
   ELEMS{elemtype* : elemtype*} elemtype*,
   DATAS{datatype* : datatype*} datatype*,
   LOCALS{localtype* : localtype*} localtype*,
@@ -3525,22 +3654,22 @@ syntax context =
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:36.1-36.86
+;; 6-typing.watsup:37.1-37.86
 def $with_locals(context : context, localidx*, localtype*) : context
-  ;; 6-typing.watsup:38.1-38.34
+  ;; 6-typing.watsup:39.1-39.34
   def $with_locals{C : context}(C, [], []) = C
-  ;; 6-typing.watsup:39.1-39.90
+  ;; 6-typing.watsup:40.1-40.90
   def $with_locals{C : context, x_1 : idx, x* : idx*, lct_1 : localtype, lct* : localtype*}(C, [x_1] :: x*{x : localidx}, [lct_1] :: lct*{lct : localtype}) = $with_locals(C[LOCALS_context[x_1!`%`_idx.0] = lct_1], x*{x : localidx}, lct*{lct : localtype})
 }
 
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:45.1-45.94
+;; 6-typing.watsup:46.1-46.94
 def $clos_deftypes(deftype*) : deftype*
-  ;; 6-typing.watsup:52.1-52.30
+  ;; 6-typing.watsup:53.1-53.30
   def $clos_deftypes([]) = []
-  ;; 6-typing.watsup:53.1-53.101
+  ;; 6-typing.watsup:54.1-54.101
   def $clos_deftypes{dt* : deftype*, dt_n : deftype, dt'* : deftype*}(dt*{dt : deftype} :: [dt_n]) = dt'*{dt' : deftype} :: [$subst_all_deftype(dt_n, (dt' : deftype <: heaptype)*{dt' : deftype})]
     -- if (dt'*{dt' : deftype} = $clos_deftypes(dt*{dt : deftype}))
 }
@@ -3708,99 +3837,99 @@ relation Numtype_sub: `%|-%<:%`(context, numtype, numtype)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:140.1-140.107
+;; 6-typing.watsup:141.1-141.107
 relation Deftype_sub: `%|-%<:%`(context, deftype, deftype)
-  ;; 6-typing.watsup:451.1-453.66
+  ;; 6-typing.watsup:462.1-464.66
   rule refl{C : context, deftype_1 : deftype, deftype_2 : deftype}:
     `%|-%<:%`(C, deftype_1, deftype_2)
     -- if ($clos_deftype(C, deftype_1) = $clos_deftype(C, deftype_2))
 
-  ;; 6-typing.watsup:455.1-458.49
+  ;; 6-typing.watsup:466.1-469.49
   rule super{C : context, deftype_1 : deftype, deftype_2 : deftype, fin : fin, typeuse* : typeuse*, ct : comptype, i : nat}:
     `%|-%<:%`(C, deftype_1, deftype_2)
     -- if ($unrolldt(deftype_1) = SUB_subtype(fin, typeuse*{typeuse : typeuse}, ct))
     -- Heaptype_sub: `%|-%<:%`(C, (typeuse*{typeuse : typeuse}[i] : typeuse <: heaptype), (deftype_2 : deftype <: heaptype))
 
-;; 6-typing.watsup:288.1-288.104
+;; 6-typing.watsup:299.1-299.104
 relation Heaptype_sub: `%|-%<:%`(context, heaptype, heaptype)
-  ;; 6-typing.watsup:299.1-300.28
+  ;; 6-typing.watsup:310.1-311.28
   rule refl{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, heaptype, heaptype)
 
-  ;; 6-typing.watsup:302.1-306.48
+  ;; 6-typing.watsup:313.1-317.48
   rule trans{C : context, heaptype_1 : heaptype, heaptype_2 : heaptype, heaptype' : heaptype}:
     `%|-%<:%`(C, heaptype_1, heaptype_2)
     -- Heaptype_ok: `%|-%:OK`(C, heaptype')
     -- Heaptype_sub: `%|-%<:%`(C, heaptype_1, heaptype')
     -- Heaptype_sub: `%|-%<:%`(C, heaptype', heaptype_2)
 
-  ;; 6-typing.watsup:308.1-309.17
+  ;; 6-typing.watsup:319.1-320.17
   rule eq-any{C : context}:
     `%|-%<:%`(C, EQ_heaptype, ANY_heaptype)
 
-  ;; 6-typing.watsup:311.1-312.17
+  ;; 6-typing.watsup:322.1-323.17
   rule i31-eq{C : context}:
     `%|-%<:%`(C, I31_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:314.1-315.20
+  ;; 6-typing.watsup:325.1-326.20
   rule struct-eq{C : context}:
     `%|-%<:%`(C, STRUCT_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:317.1-318.19
+  ;; 6-typing.watsup:328.1-329.19
   rule array-eq{C : context}:
     `%|-%<:%`(C, ARRAY_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:320.1-322.42
+  ;; 6-typing.watsup:331.1-333.42
   rule struct{C : context, deftype : deftype, fieldtype* : fieldtype*}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), STRUCT_heaptype)
     -- Expand: `%~~%`(deftype, STRUCT_comptype(`%`_structtype(fieldtype*{fieldtype : fieldtype})))
 
-  ;; 6-typing.watsup:324.1-326.40
+  ;; 6-typing.watsup:335.1-337.40
   rule array{C : context, deftype : deftype, fieldtype : fieldtype}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), ARRAY_heaptype)
     -- Expand: `%~~%`(deftype, ARRAY_comptype(fieldtype))
 
-  ;; 6-typing.watsup:328.1-330.38
+  ;; 6-typing.watsup:339.1-341.38
   rule func{C : context, deftype : deftype, functype : functype}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), FUNC_heaptype)
     -- Expand: `%~~%`(deftype, FUNC_comptype(functype))
 
-  ;; 6-typing.watsup:332.1-334.46
+  ;; 6-typing.watsup:343.1-345.46
   rule def{C : context, deftype_1 : deftype, deftype_2 : deftype}:
     `%|-%<:%`(C, (deftype_1 : deftype <: heaptype), (deftype_2 : deftype <: heaptype))
     -- Deftype_sub: `%|-%<:%`(C, deftype_1, deftype_2)
 
-  ;; 6-typing.watsup:336.1-338.53
+  ;; 6-typing.watsup:347.1-349.53
   rule typeidx-l{C : context, typeidx : typeidx, heaptype : heaptype}:
     `%|-%<:%`(C, _IDX_heaptype(typeidx), heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, (C.TYPES_context[typeidx!`%`_typeidx.0] : deftype <: heaptype), heaptype)
 
-  ;; 6-typing.watsup:340.1-342.53
+  ;; 6-typing.watsup:351.1-353.53
   rule typeidx-r{C : context, heaptype : heaptype, typeidx : typeidx}:
     `%|-%<:%`(C, heaptype, _IDX_heaptype(typeidx))
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, (C.TYPES_context[typeidx!`%`_typeidx.0] : deftype <: heaptype))
 
-  ;; 6-typing.watsup:344.1-346.40
+  ;; 6-typing.watsup:355.1-357.40
   rule rec{C : context, i : nat, typeuse* : typeuse*, j : nat, fin : fin, ct : comptype}:
     `%|-%<:%`(C, REC_heaptype(i), (typeuse*{typeuse : typeuse}[j] : typeuse <: heaptype))
     -- if (C.RECS_context[i] = SUB_subtype(fin, typeuse*{typeuse : typeuse}, ct))
 
-  ;; 6-typing.watsup:348.1-350.40
+  ;; 6-typing.watsup:359.1-361.40
   rule none{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NONE_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, ANY_heaptype)
 
-  ;; 6-typing.watsup:352.1-354.41
+  ;; 6-typing.watsup:363.1-365.41
   rule nofunc{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NOFUNC_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, FUNC_heaptype)
 
-  ;; 6-typing.watsup:356.1-358.43
+  ;; 6-typing.watsup:367.1-369.43
   rule noextern{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NOEXTERN_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, EXTERN_heaptype)
 
-  ;; 6-typing.watsup:360.1-361.23
+  ;; 6-typing.watsup:371.1-372.23
   rule bot{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, BOT_heaptype, heaptype)
 }
@@ -3944,13 +4073,13 @@ relation Subtype_ok2: `%|-%:%`(context, subtype, oktypeidxnat)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:135.1-135.105
+;; 6-typing.watsup:136.1-136.105
 relation Rectype_ok2: `%|-%:%`(context, rectype, oktypeidxnat)
-  ;; 6-typing.watsup:213.1-214.24
+  ;; 6-typing.watsup:214.1-215.24
   rule empty{C : context, x : idx, i : nat}:
     `%|-%:%`(C, REC_rectype(`%`_list([])), OK_oktypeidxnat(x, i))
 
-  ;; 6-typing.watsup:216.1-219.55
+  ;; 6-typing.watsup:217.1-220.55
   rule cons{C : context, subtype_1 : subtype, subtype* : subtype*, x : idx, i : nat}:
     `%|-%:%`(C, REC_rectype(`%`_list([subtype_1] :: subtype*{subtype : subtype})), OK_oktypeidxnat(x, i))
     -- Subtype_ok2: `%|-%:%`(C, subtype_1, OK_oktypeidxnat(x, i))
@@ -3960,22 +4089,22 @@ relation Rectype_ok2: `%|-%:%`(context, rectype, oktypeidxnat)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:133.1-133.102
+;; 6-typing.watsup:134.1-134.102
 relation Rectype_ok: `%|-%:%`(context, rectype, oktypeidx)
-  ;; 6-typing.watsup:201.1-202.23
+  ;; 6-typing.watsup:202.1-203.23
   rule empty{C : context, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list([])), OK_oktypeidx(x))
 
-  ;; 6-typing.watsup:204.1-207.48
+  ;; 6-typing.watsup:205.1-208.48
   rule cons{C : context, subtype_1 : subtype, subtype* : subtype*, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list([subtype_1] :: subtype*{subtype : subtype})), OK_oktypeidx(x))
     -- Subtype_ok: `%|-%:%`(C, subtype_1, OK_oktypeidx(x))
     -- Rectype_ok: `%|-%:%`(C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidx(`%`_typeidx((x!`%`_idx.0 + 1))))
 
-  ;; 6-typing.watsup:209.1-211.60
+  ;; 6-typing.watsup:210.1-212.60
   rule rec2{C : context, subtype* : subtype*, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidx(x))
-    -- Rectype_ok2: `%|-%:%`({TYPES [], RECS subtype*{subtype : subtype}, FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []} ++ C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidxnat(x, 0))
+    -- Rectype_ok2: `%|-%:%`({TYPES [], RECS subtype*{subtype : subtype}, FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []} ++ C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidxnat(x, 0))
 }
 
 ;; 6-typing.watsup
@@ -4016,6 +4145,14 @@ relation Memtype_ok: `%|-%:OK`(context, memtype)
     `%|-%:OK`(C, `%PAGE`_memtype(limits))
     -- Limits_ok: `%|-%:%`(C, limits, (2 ^ 16))
 
+;; 6-typing.watsup
+relation Tagtype_ok: `%|-%:OK`(context, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, deftype : deftype, functype : functype}:
+    `%|-%:OK`(C, deftype)
+    -- Deftype_ok: `%|-%:OK`(C, deftype)
+    -- Expand: `%~~%`(deftype, FUNC_comptype(functype))
+
 ;; 6-typing.watsup
 relation Externtype_ok: `%|-%:OK`(context, externtype)
   ;; 6-typing.watsup
@@ -4039,6 +4176,11 @@ relation Externtype_ok: `%|-%:OK`(context, externtype)
     `%|-%:OK`(C, MEM_externtype(memtype))
     -- Memtype_ok: `%|-%:OK`(C, memtype)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, tagtype : tagtype}:
+    `%|-%:OK`(C, TAG_externtype((tagtype : deftype <: typeuse)))
+    -- Tagtype_ok: `%|-%:OK`(C, tagtype)
+
 ;; 6-typing.watsup
 relation Instrtype_sub: `%|-%<:%`(context, instrtype, instrtype)
   ;; 6-typing.watsup
@@ -4086,6 +4228,14 @@ relation Memtype_sub: `%|-%<:%`(context, memtype, memtype)
     `%|-%<:%`(C, `%PAGE`_memtype(limits_1), `%PAGE`_memtype(limits_2))
     -- Limits_sub: `%|-%<:%`(C, limits_1, limits_2)
 
+;; 6-typing.watsup
+relation Tagtype_sub: `%|-%<:%`(context, tagtype, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, deftype_1 : deftype, deftype_2 : deftype}:
+    `%|-%<:%`(C, deftype_1, deftype_2)
+    -- Deftype_sub: `%|-%<:%`(C, deftype_1, deftype_2)
+    -- Deftype_sub: `%|-%<:%`(C, deftype_2, deftype_1)
+
 ;; 6-typing.watsup
 relation Externtype_sub: `%|-%<:%`(context, externtype, externtype)
   ;; 6-typing.watsup
@@ -4108,6 +4258,11 @@ relation Externtype_sub: `%|-%<:%`(context, externtype, externtype)
     `%|-%<:%`(C, MEM_externtype(memtype_1), MEM_externtype(memtype_2))
     -- Memtype_sub: `%|-%<:%`(C, memtype_1, memtype_2)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, tagtype_1 : tagtype, tagtype_2 : tagtype}:
+    `%|-%<:%`(C, TAG_externtype((tagtype_1 : deftype <: typeuse)), TAG_externtype((tagtype_2 : deftype <: typeuse)))
+    -- Tagtype_sub: `%|-%<:%`(C, tagtype_1, tagtype_2)
+
 ;; 6-typing.watsup
 relation Blocktype_ok: `%|-%:%`(context, blocktype, instrtype)
   ;; 6-typing.watsup
@@ -4120,86 +4275,110 @@ relation Blocktype_ok: `%|-%:%`(context, blocktype, instrtype)
     `%|-%:%`(C, _IDX_blocktype(typeidx), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[typeidx!`%`_typeidx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
+;; 6-typing.watsup
+relation Catch_ok: `%|-%:OK`(context, catch)
+  ;; 6-typing.watsup
+  rule catch{C : context, x : idx, l : labelidx, t* : valtype*}:
+    `%|-%:OK`(C, CATCH_catch(x, l))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_ref{C : context, x : idx, l : labelidx, t* : valtype*}:
+    `%|-%:OK`(C, CATCH_REF_catch(x, l))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), EXN_heaptype)], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_all{C : context, l : labelidx}:
+    `%|-%:OK`(C, CATCH_ALL_catch(l))
+    -- Resulttype_sub: `%|-%<:%`(C, [], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_all_ref{C : context, l : labelidx}:
+    `%|-%:OK`(C, CATCH_ALL_REF_catch(l))
+    -- Resulttype_sub: `%|-%<:%`(C, [REF_valtype(`NULL%?`_nul(?()), EXN_heaptype)], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:522.1-522.95
+;; 6-typing.watsup:543.1-543.95
 relation Instr_ok: `%|-%:%`(context, instr, instrtype)
-  ;; 6-typing.watsup:561.1-562.24
+  ;; 6-typing.watsup:582.1-583.24
   rule nop{C : context}:
     `%|-%:%`(C, NOP_instr, `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
 
-  ;; 6-typing.watsup:564.1-566.42
+  ;; 6-typing.watsup:585.1-587.42
   rule unreachable{C : context, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, UNREACHABLE_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:568.1-570.29
+  ;; 6-typing.watsup:589.1-591.29
   rule drop{C : context, t : valtype}:
     `%|-%:%`(C, DROP_instr, `%->_%%`_instrtype(`%`_resulttype([t]), [], `%`_resulttype([])))
     -- Valtype_ok: `%|-%:OK`(C, t)
 
-  ;; 6-typing.watsup:573.1-575.29
+  ;; 6-typing.watsup:594.1-596.29
   rule select-expl{C : context, t : valtype}:
     `%|-%:%`(C, `SELECT()%?`_instr(?([t])), `%->_%%`_instrtype(`%`_resulttype([t t I32_valtype]), [], `%`_resulttype([t])))
     -- Valtype_ok: `%|-%:OK`(C, t)
 
-  ;; 6-typing.watsup:577.1-581.37
+  ;; 6-typing.watsup:598.1-602.37
   rule select-impl{C : context, t : valtype, t' : valtype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, `SELECT()%?`_instr(?()), `%->_%%`_instrtype(`%`_resulttype([t t I32_valtype]), [], `%`_resulttype([t])))
     -- Valtype_ok: `%|-%:OK`(C, t)
     -- Valtype_sub: `%|-%<:%`(C, t, t')
     -- if ((t' = (numtype : numtype <: valtype)) \/ (t' = (vectype : vectype <: valtype)))
 
-  ;; 6-typing.watsup:597.1-600.67
+  ;; 6-typing.watsup:618.1-621.67
   rule block{C : context, bt : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
     `%|-%:%`(C, BLOCK_instr(bt, instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:602.1-605.67
+  ;; 6-typing.watsup:623.1-626.67
   rule loop{C : context, bt : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
     `%|-%:%`(C, LOOP_instr(bt, instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_1*{t_1 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_1*{t_1 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:607.1-611.71
+  ;; 6-typing.watsup:628.1-632.71
   rule if{C : context, bt : blocktype, instr_1* : instr*, instr_2* : instr*, t_1* : valtype*, t_2* : valtype*, x_1* : idx*, x_2* : idx*}:
     `%|-%:%`(C, `IF%%ELSE%`_instr(bt, instr_1*{instr_1 : instr}, instr_2*{instr_2 : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_1*{instr_1 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_1*{instr_1 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:616.1-619.42
+  ;; 6-typing.watsup:637.1-640.42
   rule br{C : context, l : labelidx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, BR_instr(l), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:621.1-623.25
+  ;; 6-typing.watsup:642.1-644.25
   rule br_if{C : context, l : labelidx, t* : valtype*}:
     `%|-%:%`(C, BR_IF_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [I32_valtype]), [], `%`_resulttype(t*{t : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
 
-  ;; 6-typing.watsup:625.1-629.42
+  ;; 6-typing.watsup:646.1-650.42
   rule br_table{C : context, l* : labelidx*, l' : labelidx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, BR_TABLE_instr(l*{l : labelidx}, l'), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- (Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0))*{l : labelidx}
     -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l'!`%`_labelidx.0]!`%`_resulttype.0)
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:631.1-634.31
+  ;; 6-typing.watsup:652.1-655.31
   rule br_on_null{C : context, l : labelidx, t* : valtype*, ht : heaptype}:
     `%|-%:%`(C, BR_ON_NULL_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), ht)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:636.1-638.34
+  ;; 6-typing.watsup:657.1-659.34
   rule br_on_non_null{C : context, l : labelidx, t* : valtype*, ht : heaptype}:
     `%|-%:%`(C, BR_ON_NON_NULL_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype(t*{t : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), ht)]))
 
-  ;; 6-typing.watsup:640.1-646.34
+  ;; 6-typing.watsup:661.1-667.34
   rule br_on_cast{C : context, l : labelidx, rt_1 : reftype, rt_2 : reftype, t* : valtype*, rt : reftype}:
     `%|-%:%`(C, BR_ON_CAST_instr(l, rt_1, rt_2), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [(rt_1 : reftype <: valtype)]), [], `%`_resulttype(t*{t : valtype} :: [($diffrt(rt_1, rt_2) : reftype <: valtype)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [(rt : reftype <: valtype)]))
@@ -4208,7 +4387,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt)
 
-  ;; 6-typing.watsup:648.1-654.49
+  ;; 6-typing.watsup:669.1-675.49
   rule br_on_cast_fail{C : context, l : labelidx, rt_1 : reftype, rt_2 : reftype, t* : valtype*, rt : reftype}:
     `%|-%:%`(C, BR_ON_CAST_FAIL_instr(l, rt_1, rt_2), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [(rt_1 : reftype <: valtype)]), [], `%`_resulttype(t*{t : valtype} :: [(rt_2 : reftype <: valtype)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [(rt : reftype <: valtype)]))
@@ -4217,30 +4396,30 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
     -- Reftype_sub: `%|-%<:%`(C, $diffrt(rt_1, rt_2), rt)
 
-  ;; 6-typing.watsup:659.1-661.47
+  ;; 6-typing.watsup:680.1-682.47
   rule call{C : context, x : idx, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, CALL_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.FUNCS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:663.1-665.47
+  ;; 6-typing.watsup:684.1-686.47
   rule call_ref{C : context, x : idx, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, CALL_REF_instr(($idx(x) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:667.1-671.47
+  ;; 6-typing.watsup:688.1-692.47
   rule call_indirect{C : context, x : idx, y : idx, t_1* : valtype*, t_2* : valtype*, lim : limits, rt : reftype}:
     `%|-%:%`(C, CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
     -- Reftype_sub: `%|-%<:%`(C, rt, REF_reftype(`NULL%?`_nul(?(())), FUNC_heaptype))
     -- Expand: `%~~%`(C.TYPES_context[y!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:673.1-676.42
+  ;; 6-typing.watsup:694.1-697.42
   rule return{C : context, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, RETURN_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.RETURN_context = ?(`%`_list(t*{t : valtype})))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:679.1-684.42
+  ;; 6-typing.watsup:700.1-705.42
   rule return_call{C : context, x : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- Expand: `%~~%`(C.FUNCS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
@@ -4248,7 +4427,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:687.1-692.42
+  ;; 6-typing.watsup:708.1-713.42
   rule return_call_ref{C : context, x : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_REF_instr(($idx(x) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
@@ -4256,7 +4435,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:695.1-703.42
+  ;; 6-typing.watsup:716.1-724.42
   rule return_call_indirect{C : context, x : idx, y : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, lim : limits, rt : reftype, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
@@ -4266,452 +4445,470 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:708.1-709.33
+  ;; 6-typing.watsup:731.1-734.42
+  rule throw{C : context, x : idx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
+    `%|-%:%`(C, THROW_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+
+  ;; 6-typing.watsup:736.1-738.42
+  rule throw_ref{C : context, t_1* : valtype*, t_2* : valtype*}:
+    `%|-%:%`(C, THROW_REF_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), EXN_heaptype)]), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+
+  ;; 6-typing.watsup:740.1-744.34
+  rule try_table{C : context, bt : blocktype, catch* : catch*, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
+    `%|-%:%`(C, TRY_TABLE_instr(bt, `%`_list(catch*{catch : catch}), instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- (Catch_ok: `%|-%:OK`(C, catch))*{catch : catch}
+
+  ;; 6-typing.watsup:767.1-768.33
   rule const{C : context, nt : numtype, c_nt : num_(nt)}:
     `%|-%:%`(C, CONST_instr(nt, c_nt), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:711.1-712.34
+  ;; 6-typing.watsup:770.1-771.34
   rule unop{C : context, nt : numtype, unop_nt : unop_(nt)}:
     `%|-%:%`(C, UNOP_instr(nt, unop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype)]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:714.1-715.39
+  ;; 6-typing.watsup:773.1-774.39
   rule binop{C : context, nt : numtype, binop_nt : binop_(nt)}:
     `%|-%:%`(C, BINOP_instr(nt, binop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype) (nt : numtype <: valtype)]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:717.1-718.39
+  ;; 6-typing.watsup:776.1-777.39
   rule testop{C : context, nt : numtype, testop_nt : testop_(nt)}:
     `%|-%:%`(C, TESTOP_instr(nt, testop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:720.1-721.40
+  ;; 6-typing.watsup:779.1-780.40
   rule relop{C : context, nt : numtype, relop_nt : relop_(nt)}:
     `%|-%:%`(C, RELOP_instr(nt, relop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype) (nt : numtype <: valtype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:723.1-724.44
+  ;; 6-typing.watsup:782.1-783.44
   rule cvtop{C : context, nt_1 : numtype, nt_2 : numtype, cvtop : cvtop__(nt_2, nt_1)}:
     `%|-%:%`(C, CVTOP_instr(nt_1, nt_2, cvtop), `%->_%%`_instrtype(`%`_resulttype([(nt_2 : numtype <: valtype)]), [], `%`_resulttype([(nt_1 : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:729.1-731.31
+  ;; 6-typing.watsup:788.1-790.31
   rule ref.null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.NULL_instr(ht), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:733.1-736.20
+  ;; 6-typing.watsup:792.1-795.20
   rule ref.func{C : context, x : idx, dt : deftype}:
     `%|-%:%`(C, REF.FUNC_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), (dt : deftype <: heaptype))])))
     -- if (C.FUNCS_context[x!`%`_idx.0] = dt)
     -- if x <- C.REFS_context
 
-  ;; 6-typing.watsup:738.1-739.34
+  ;; 6-typing.watsup:797.1-798.34
   rule ref.i31{C : context}:
     `%|-%:%`(C, REF.I31_instr, `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), I31_heaptype)])))
 
-  ;; 6-typing.watsup:741.1-743.31
+  ;; 6-typing.watsup:800.1-802.31
   rule ref.is_null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.IS_NULL_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype([I32_valtype])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:745.1-747.31
+  ;; 6-typing.watsup:804.1-806.31
   rule ref.as_non_null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.AS_NON_NULL_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ht)])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:749.1-750.51
+  ;; 6-typing.watsup:808.1-809.51
   rule ref.eq{C : context}:
     `%|-%:%`(C, REF.EQ_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), EQ_heaptype) REF_valtype(`NULL%?`_nul(?(())), EQ_heaptype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:752.1-756.33
+  ;; 6-typing.watsup:811.1-815.33
   rule ref.test{C : context, rt : reftype, rt' : reftype}:
     `%|-%:%`(C, REF.TEST_instr(rt), `%->_%%`_instrtype(`%`_resulttype([(rt' : reftype <: valtype)]), [], `%`_resulttype([I32_valtype])))
     -- Reftype_ok: `%|-%:OK`(C, rt)
     -- Reftype_ok: `%|-%:OK`(C, rt')
     -- Reftype_sub: `%|-%<:%`(C, rt, rt')
 
-  ;; 6-typing.watsup:758.1-762.33
+  ;; 6-typing.watsup:817.1-821.33
   rule ref.cast{C : context, rt : reftype, rt' : reftype}:
     `%|-%:%`(C, REF.CAST_instr(rt), `%->_%%`_instrtype(`%`_resulttype([(rt' : reftype <: valtype)]), [], `%`_resulttype([(rt : reftype <: valtype)])))
     -- Reftype_ok: `%|-%:OK`(C, rt)
     -- Reftype_ok: `%|-%:OK`(C, rt')
     -- Reftype_sub: `%|-%<:%`(C, rt, rt')
 
-  ;; 6-typing.watsup:767.1-768.42
+  ;; 6-typing.watsup:826.1-827.42
   rule i31.get{C : context, sx : sx}:
     `%|-%:%`(C, I31.GET_instr(sx), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), I31_heaptype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:773.1-775.44
+  ;; 6-typing.watsup:832.1-834.44
   rule struct.new{C : context, x : idx, zt* : storagetype*, mut* : mut*}:
     `%|-%:%`(C, STRUCT.NEW_instr(x), `%->_%%`_instrtype(`%`_resulttype($unpack(zt)*{zt : storagetype}), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
 
-  ;; 6-typing.watsup:777.1-780.40
+  ;; 6-typing.watsup:836.1-839.40
   rule struct.new_default{C : context, x : idx, mut* : mut*, zt* : storagetype*, val* : val*}:
     `%|-%:%`(C, STRUCT.NEW_DEFAULT_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
     -- (if ($default_($unpack(zt)) = ?(val)))*{val : val, zt : storagetype}
 
-  ;; 6-typing.watsup:782.1-786.39
+  ;; 6-typing.watsup:841.1-845.39
   rule struct.get{C : context, sx? : sx?, x : idx, i : nat, zt : storagetype, yt* : fieldtype*, mut : mut}:
     `%|-%:%`(C, STRUCT.GET_instr(sx?{sx : sx}, x, `%`_u32(i)), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype([$unpack(zt)])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})))
     -- if (yt*{yt : fieldtype}[i] = `%%`_fieldtype(mut, zt))
     -- if ((sx?{sx : sx} = ?()) <=> (zt = ($unpack(zt) : valtype <: storagetype)))
 
-  ;; 6-typing.watsup:788.1-791.24
+  ;; 6-typing.watsup:847.1-850.24
   rule struct.set{C : context, x : idx, i : nat, zt : storagetype, yt* : fieldtype*}:
     `%|-%:%`(C, STRUCT.SET_instr(x, `%`_u32(i)), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) $unpack(zt)]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})))
     -- if (yt*{yt : fieldtype}[i] = `%%`_fieldtype(`MUT%?`_mut(?(())), zt))
 
-  ;; 6-typing.watsup:796.1-798.42
+  ;; 6-typing.watsup:855.1-857.42
   rule array.new{C : context, x : idx, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.NEW_instr(x), `%->_%%`_instrtype(`%`_resulttype([$unpack(zt) I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 6-typing.watsup:800.1-803.37
+  ;; 6-typing.watsup:859.1-862.37
   rule array.new_default{C : context, x : idx, mut : mut, zt : storagetype, val : val}:
     `%|-%:%`(C, ARRAY.NEW_DEFAULT_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ($default_($unpack(zt)) = ?(val))
 
-  ;; 6-typing.watsup:805.1-807.42
+  ;; 6-typing.watsup:864.1-866.42
   rule array.new_fixed{C : context, x : idx, n : n, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.NEW_FIXED_instr(x, `%`_u32(n)), `%->_%%`_instrtype(`%`_resulttype($unpack(zt)^n{}), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 6-typing.watsup:809.1-812.40
+  ;; 6-typing.watsup:868.1-871.40
   rule array.new_elem{C : context, x : idx, y : idx, mut : mut, rt : reftype}:
     `%|-%:%`(C, ARRAY.NEW_ELEM_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, (rt : reftype <: storagetype))))
     -- Reftype_sub: `%|-%<:%`(C, C.ELEMS_context[y!`%`_idx.0], rt)
 
-  ;; 6-typing.watsup:814.1-818.24
+  ;; 6-typing.watsup:873.1-877.24
   rule array.new_data{C : context, x : idx, y : idx, mut : mut, zt : storagetype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, ARRAY.NEW_DATA_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if (($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:820.1-823.39
+  ;; 6-typing.watsup:879.1-882.39
   rule array.get{C : context, sx? : sx?, x : idx, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.GET_instr(sx?{sx : sx}, x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype]), [], `%`_resulttype([$unpack(zt)])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ((sx?{sx : sx} = ?()) <=> (zt = ($unpack(zt) : valtype <: storagetype)))
 
-  ;; 6-typing.watsup:825.1-827.42
+  ;; 6-typing.watsup:884.1-886.42
   rule array.set{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype $unpack(zt)]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:829.1-831.42
+  ;; 6-typing.watsup:888.1-890.42
   rule array.len{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.LEN_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ARRAY_heaptype)]), [], `%`_resulttype([I32_valtype])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:833.1-835.42
+  ;; 6-typing.watsup:892.1-894.42
   rule array.fill{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype $unpack(zt) I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:837.1-841.40
+  ;; 6-typing.watsup:896.1-900.40
   rule array.copy{C : context, x_1 : idx, x_2 : idx, zt_1 : storagetype, mut : mut, zt_2 : storagetype}:
     `%|-%:%`(C, ARRAY.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x_1) : typevar <: heaptype)) I32_valtype REF_valtype(`NULL%?`_nul(?(())), ($idx(x_2) : typevar <: heaptype)) I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x_1!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt_1)))
     -- Expand: `%~~%`(C.TYPES_context[x_2!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt_2)))
     -- Storagetype_sub: `%|-%<:%`(C, zt_2, zt_1)
 
-  ;; 6-typing.watsup:843.1-846.44
+  ;; 6-typing.watsup:902.1-905.44
   rule array.init_elem{C : context, x : idx, y : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.INIT_ELEM_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
     -- Storagetype_sub: `%|-%<:%`(C, (C.ELEMS_context[y!`%`_idx.0] : reftype <: storagetype), zt)
 
-  ;; 6-typing.watsup:848.1-852.24
+  ;; 6-typing.watsup:907.1-911.24
   rule array.init_data{C : context, x : idx, y : idx, zt : storagetype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, ARRAY.INIT_DATA_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
     -- if (($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:857.1-858.62
+  ;; 6-typing.watsup:916.1-917.62
   rule extern.convert_any{C : context, nul : nul}:
     `%|-%:%`(C, EXTERN.CONVERT_ANY_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(nul, ANY_heaptype)]), [], `%`_resulttype([REF_valtype(nul, EXTERN_heaptype)])))
 
-  ;; 6-typing.watsup:860.1-861.62
+  ;; 6-typing.watsup:919.1-920.62
   rule any.convert_extern{C : context, nul : nul}:
     `%|-%:%`(C, ANY.CONVERT_EXTERN_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(nul, EXTERN_heaptype)]), [], `%`_resulttype([REF_valtype(nul, ANY_heaptype)])))
 
-  ;; 6-typing.watsup:866.1-867.35
+  ;; 6-typing.watsup:925.1-926.35
   rule vconst{C : context, c : vec_(V128_Vnn)}:
     `%|-%:%`(C, VCONST_instr(V128_vectype, c), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:869.1-870.41
+  ;; 6-typing.watsup:928.1-929.41
   rule vvunop{C : context, vvunop : vvunop}:
     `%|-%:%`(C, VVUNOP_instr(V128_vectype, vvunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:872.1-873.48
+  ;; 6-typing.watsup:931.1-932.48
   rule vvbinop{C : context, vvbinop : vvbinop}:
     `%|-%:%`(C, VVBINOP_instr(V128_vectype, vvbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:875.1-876.55
+  ;; 6-typing.watsup:934.1-935.55
   rule vvternop{C : context, vvternop : vvternop}:
     `%|-%:%`(C, VVTERNOP_instr(V128_vectype, vvternop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:878.1-879.44
+  ;; 6-typing.watsup:937.1-938.44
   rule vvtestop{C : context, vvtestop : vvtestop}:
     `%|-%:%`(C, VVTESTOP_instr(V128_vectype, vvtestop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:881.1-882.37
+  ;; 6-typing.watsup:940.1-941.37
   rule vunop{C : context, sh : shape, vunop : vunop_(sh)}:
     `%|-%:%`(C, VUNOP_instr(sh, vunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:884.1-885.44
+  ;; 6-typing.watsup:943.1-944.44
   rule vbinop{C : context, sh : shape, vbinop : vbinop_(sh)}:
     `%|-%:%`(C, VBINOP_instr(sh, vbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:887.1-888.40
+  ;; 6-typing.watsup:946.1-947.40
   rule vtestop{C : context, sh : shape, vtestop : vtestop_(sh)}:
     `%|-%:%`(C, VTESTOP_instr(sh, vtestop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:890.1-891.44
+  ;; 6-typing.watsup:949.1-950.44
   rule vrelop{C : context, sh : shape, vrelop : vrelop_(sh)}:
     `%|-%:%`(C, VRELOP_instr(sh, vrelop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:893.1-894.47
+  ;; 6-typing.watsup:952.1-953.47
   rule vshiftop{C : context, sh : ishape, vshiftop : vshiftop_(sh)}:
     `%|-%:%`(C, VSHIFTOP_instr(sh, vshiftop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype I32_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:896.1-897.33
+  ;; 6-typing.watsup:955.1-956.33
   rule vbitmask{C : context, sh : ishape}:
     `%|-%:%`(C, VBITMASK_instr(sh), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:899.1-900.39
+  ;; 6-typing.watsup:958.1-959.39
   rule vswizzle{C : context, sh : ishape}:
     `%|-%:%`(C, VSWIZZLE_instr(sh), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:902.1-904.29
+  ;; 6-typing.watsup:961.1-963.29
   rule vshuffle{C : context, sh : ishape, i* : nat*}:
     `%|-%:%`(C, VSHUFFLE_instr(sh, `%`_laneidx(i)*{i : nat}), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
     -- (if (i < (2 * $dim((sh : ishape <: shape))!`%`_dim.0)))*{i : nat}
 
-  ;; 6-typing.watsup:906.1-907.44
+  ;; 6-typing.watsup:965.1-966.44
   rule vsplat{C : context, sh : shape}:
     `%|-%:%`(C, VSPLAT_instr(sh), `%->_%%`_instrtype(`%`_resulttype([($unpackshape(sh) : numtype <: valtype)]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:909.1-911.21
+  ;; 6-typing.watsup:968.1-970.21
   rule vextract_lane{C : context, sh : shape, sx? : sx?, i : nat}:
     `%|-%:%`(C, VEXTRACT_LANE_instr(sh, sx?{sx : sx}, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([($unpackshape(sh) : numtype <: valtype)])))
     -- if (i < $dim(sh)!`%`_dim.0)
 
-  ;; 6-typing.watsup:913.1-915.21
+  ;; 6-typing.watsup:972.1-974.21
   rule vreplace_lane{C : context, sh : shape, i : nat}:
     `%|-%:%`(C, VREPLACE_LANE_instr(sh, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([V128_valtype ($unpackshape(sh) : numtype <: valtype)]), [], `%`_resulttype([V128_valtype])))
     -- if (i < $dim(sh)!`%`_dim.0)
 
-  ;; 6-typing.watsup:917.1-918.50
+  ;; 6-typing.watsup:976.1-977.50
   rule vextunop{C : context, sh_1 : ishape, sh_2 : ishape, vextunop : vextunop__(sh_2, sh_1)}:
     `%|-%:%`(C, VEXTUNOP_instr(sh_1, sh_2, vextunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:920.1-921.57
+  ;; 6-typing.watsup:979.1-980.57
   rule vextbinop{C : context, sh_1 : ishape, sh_2 : ishape, vextbinop : vextbinop__(sh_2, sh_1)}:
     `%|-%:%`(C, VEXTBINOP_instr(sh_1, sh_2, vextbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:923.1-924.48
+  ;; 6-typing.watsup:982.1-983.48
   rule vnarrow{C : context, sh_1 : ishape, sh_2 : ishape, sx : sx}:
     `%|-%:%`(C, VNARROW_instr(sh_1, sh_2, sx), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:926.1-927.58
+  ;; 6-typing.watsup:985.1-986.58
   rule vcvtop{C : context, sh_1 : shape, sh_2 : shape, vcvtop : vcvtop__(sh_2, sh_1), half? : half__(sh_2, sh_1)?, zero? : zero__(sh_2, sh_1)?}:
     `%|-%:%`(C, VCVTOP_instr(sh_1, sh_2, vcvtop, half?{half : half__(sh_2, sh_1)}, zero?{zero : zero__(sh_2, sh_1)}), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:932.1-934.28
+  ;; 6-typing.watsup:991.1-993.28
   rule local.get{C : context, x : idx, t : valtype}:
     `%|-%:%`(C, LOCAL.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([t])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(SET_init, t))
 
-  ;; 6-typing.watsup:936.1-938.29
+  ;; 6-typing.watsup:995.1-997.29
   rule local.set{C : context, x : idx, t : valtype, init : init}:
     `%|-%:%`(C, LOCAL.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [x], `%`_resulttype([])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(init, t))
 
-  ;; 6-typing.watsup:940.1-942.29
+  ;; 6-typing.watsup:999.1-1001.29
   rule local.tee{C : context, x : idx, t : valtype, init : init}:
     `%|-%:%`(C, LOCAL.TEE_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [x], `%`_resulttype([t])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(init, t))
 
-  ;; 6-typing.watsup:947.1-949.29
+  ;; 6-typing.watsup:1006.1-1008.29
   rule global.get{C : context, x : idx, t : valtype, mut : mut}:
     `%|-%:%`(C, GLOBAL.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([t])))
     -- if (C.GLOBALS_context[x!`%`_idx.0] = `%%`_globaltype(mut, t))
 
-  ;; 6-typing.watsup:951.1-953.29
+  ;; 6-typing.watsup:1010.1-1012.29
   rule global.set{C : context, x : idx, t : valtype}:
     `%|-%:%`(C, GLOBAL.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [], `%`_resulttype([])))
     -- if (C.GLOBALS_context[x!`%`_idx.0] = `%%`_globaltype(`MUT%?`_mut(?(())), t))
 
-  ;; 6-typing.watsup:958.1-960.29
+  ;; 6-typing.watsup:1017.1-1019.29
   rule table.get{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(rt : reftype <: valtype)])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:962.1-964.29
+  ;; 6-typing.watsup:1021.1-1023.29
   rule table.set{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (rt : reftype <: valtype)]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:966.1-968.29
+  ;; 6-typing.watsup:1025.1-1027.29
   rule table.size{C : context, x : idx, lim : limits, rt : reftype}:
     `%|-%:%`(C, TABLE.SIZE_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([I32_valtype])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:970.1-972.29
+  ;; 6-typing.watsup:1029.1-1031.29
   rule table.grow{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.GROW_instr(x), `%->_%%`_instrtype(`%`_resulttype([(rt : reftype <: valtype) I32_valtype]), [], `%`_resulttype([I32_valtype])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:974.1-976.29
+  ;; 6-typing.watsup:1033.1-1035.29
   rule table.fill{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (rt : reftype <: valtype) I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:978.1-982.36
+  ;; 6-typing.watsup:1037.1-1041.36
   rule table.copy{C : context, x_1 : idx, x_2 : idx, lim_1 : limits, rt_1 : reftype, lim_2 : limits, rt_2 : reftype}:
     `%|-%:%`(C, TABLE.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x_1!`%`_idx.0] = `%%`_tabletype(lim_1, rt_1))
     -- if (C.TABLES_context[x_2!`%`_idx.0] = `%%`_tabletype(lim_2, rt_2))
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
 
-  ;; 6-typing.watsup:984.1-988.36
+  ;; 6-typing.watsup:1043.1-1047.36
   rule table.init{C : context, x : idx, y : idx, lim : limits, rt_1 : reftype, rt_2 : reftype}:
     `%|-%:%`(C, TABLE.INIT_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt_1))
     -- if (C.ELEMS_context[y!`%`_idx.0] = rt_2)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
 
-  ;; 6-typing.watsup:990.1-992.24
+  ;; 6-typing.watsup:1049.1-1051.24
   rule elem.drop{C : context, x : idx, rt : reftype}:
     `%|-%:%`(C, ELEM.DROP_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
     -- if (C.ELEMS_context[x!`%`_idx.0] = rt)
 
-  ;; 6-typing.watsup:997.1-999.23
+  ;; 6-typing.watsup:1056.1-1058.23
   rule memory.size{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.SIZE_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([I32_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1001.1-1003.23
+  ;; 6-typing.watsup:1060.1-1062.23
   rule memory.grow{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.GROW_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([I32_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1005.1-1007.23
+  ;; 6-typing.watsup:1064.1-1066.23
   rule memory.fill{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1009.1-1012.27
+  ;; 6-typing.watsup:1068.1-1071.27
   rule memory.copy{C : context, x_1 : idx, x_2 : idx, mt_1 : memtype, mt_2 : memtype}:
     `%|-%:%`(C, MEMORY.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x_1!`%`_idx.0] = mt_1)
     -- if (C.MEMS_context[x_2!`%`_idx.0] = mt_2)
 
-  ;; 6-typing.watsup:1014.1-1017.24
+  ;; 6-typing.watsup:1073.1-1076.24
   rule memory.init{C : context, x : idx, y : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.INIT_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:1019.1-1021.24
+  ;; 6-typing.watsup:1078.1-1080.24
   rule data.drop{C : context, x : idx}:
     `%|-%:%`(C, DATA.DROP_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
     -- if (C.DATAS_context[x!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:1032.1-1035.43
+  ;; 6-typing.watsup:1091.1-1094.43
   rule load-val{C : context, nt : numtype, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, LOAD_instr(nt, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(nt : numtype <: valtype)])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($size(nt) / 8))
 
-  ;; 6-typing.watsup:1037.1-1040.35
+  ;; 6-typing.watsup:1096.1-1099.35
   rule load-pack{C : context, Inn : Inn, M : M, sx : sx, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, LOAD_instr((Inn : Inn <: numtype), ?(`%%`_loadop_(`%`_sz(M), sx)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(Inn : Inn <: valtype)])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (M / 8))
 
-  ;; 6-typing.watsup:1051.1-1054.43
+  ;; 6-typing.watsup:1110.1-1113.43
   rule store-val{C : context, nt : numtype, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, STORE_instr(nt, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (nt : numtype <: valtype)]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($size(nt) / 8))
 
-  ;; 6-typing.watsup:1056.1-1059.35
+  ;; 6-typing.watsup:1115.1-1118.35
   rule store-pack{C : context, Inn : Inn, M : M, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, STORE_instr((Inn : Inn <: numtype), ?(`%`_sz(M)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (Inn : Inn <: valtype)]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (M / 8))
 
-  ;; 6-typing.watsup:1061.1-1064.46
+  ;; 6-typing.watsup:1120.1-1123.46
   rule vload-val{C : context, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($vsize(V128_vectype) / 8))
 
-  ;; 6-typing.watsup:1066.1-1069.39
+  ;; 6-typing.watsup:1125.1-1128.39
   rule vload-pack{C : context, M : M, N : N, sx : sx, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(M), N, sx)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ((M / 8) * N))
 
-  ;; 6-typing.watsup:1071.1-1074.35
+  ;; 6-typing.watsup:1130.1-1133.35
   rule vload-splat{C : context, N : N, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(N))), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
 
-  ;; 6-typing.watsup:1076.1-1079.35
+  ;; 6-typing.watsup:1135.1-1138.35
   rule vload-zero{C : context, N : N, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(N))), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
 
-  ;; 6-typing.watsup:1081.1-1085.21
+  ;; 6-typing.watsup:1140.1-1144.21
   rule vload_lane{C : context, N : N, x : idx, memarg : memarg, i : nat, mt : memtype}:
     `%|-%:%`(C, VLOAD_LANE_instr(V128_vectype, `%`_sz(N), x, memarg, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
     -- if (i < (128 / N))
 
-  ;; 6-typing.watsup:1087.1-1090.46
+  ;; 6-typing.watsup:1146.1-1149.46
   rule vstore{C : context, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VSTORE_instr(V128_vectype, x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($vsize(V128_vectype) / 8))
 
-  ;; 6-typing.watsup:1092.1-1096.21
+  ;; 6-typing.watsup:1151.1-1155.21
   rule vstore_lane{C : context, N : N, x : idx, memarg : memarg, i : nat, mt : memtype}:
     `%|-%:%`(C, VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, memarg, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
     -- if (i < (128 / N))
 
-;; 6-typing.watsup:523.1-523.96
+;; 6-typing.watsup:544.1-544.96
 relation Instrs_ok: `%|-%:%`(context, instr*, instrtype)
-  ;; 6-typing.watsup:536.1-537.24
+  ;; 6-typing.watsup:557.1-558.24
   rule empty{C : context}:
     `%|-%:%`(C, [], `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
 
-  ;; 6-typing.watsup:540.1-544.82
+  ;; 6-typing.watsup:561.1-565.82
   rule seq{C : context, instr_1 : instr, instr_2* : instr*, t_1* : valtype*, x_1* : idx*, x_2* : idx*, t_3* : valtype*, t_2* : valtype*, init* : init*, t* : valtype*}:
     `%|-%:%`(C, [instr_1] :: instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx} :: x_2*{x_2 : localidx}, `%`_resulttype(t_3*{t_3 : valtype})))
     -- Instr_ok: `%|-%:%`(C, instr_1, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
     -- (if (C.LOCALS_context[x_1!`%`_idx.0] = `%%`_localtype(init, t)))*{init : init, t : valtype, x_1 : idx}
     -- Instrs_ok: `%|-%:%`($with_locals(C, x_1*{x_1 : localidx}, `%%`_localtype(SET_init, t)*{t : valtype}), instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_2*{t_2 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_3*{t_3 : valtype})))
 
-  ;; 6-typing.watsup:546.1-550.33
+  ;; 6-typing.watsup:567.1-571.33
   rule sub{C : context, instr* : instr*, it' : instrtype, it : instrtype}:
     `%|-%:%`(C, instr*{instr : instr}, it')
     -- Instrs_ok: `%|-%:%`(C, instr*{instr : instr}, it)
     -- Instrtype_sub: `%|-%<:%`(C, it, it')
     -- Instrtype_ok: `%|-%:OK`(C, it')
 
-  ;; 6-typing.watsup:553.1-556.33
+  ;; 6-typing.watsup:574.1-577.33
   rule frame{C : context, instr* : instr*, t* : valtype*, t_1* : valtype*, x* : idx*, t_2* : valtype*}:
     `%|-%:%`(C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t*{t : valtype} :: t_2*{t_2 : valtype})))
     -- Instrs_ok: `%|-%:%`(C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
@@ -4808,7 +5005,7 @@ relation Type_ok: `%|-%:%`(context, type, deftype*)
     `%|-%:%`(C, TYPE_type(rectype), dt*{dt : deftype})
     -- if (x = `%`_idx(|C.TYPES_context|))
     -- if (dt*{dt : deftype} = $rolldt(x, rectype))
-    -- Rectype_ok: `%|-%:%`(C ++ {TYPES dt*{dt : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rectype, OK_oktypeidx(x))
+    -- Rectype_ok: `%|-%:%`(C ++ {TYPES dt*{dt : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rectype, OK_oktypeidx(x))
 
 ;; 6-typing.watsup
 relation Local_ok: `%|-%:%`(context, local, localtype)
@@ -4829,7 +5026,7 @@ relation Func_ok: `%|-%:%`(context, func, deftype)
     `%|-%:%`(C, FUNC_func(x, local*{local : local}, expr), C.TYPES_context[x!`%`_idx.0])
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
     -- (Local_ok: `%|-%:%`(C, local, lct))*{lct : localtype, local : local}
-    -- Expr_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS `%%`_localtype(SET_init, t_1)*{t_1 : valtype} :: lct*{lct : localtype}, LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(`%`_resulttype(t_2*{t_2 : valtype})), REFS []}, expr, `%`_resulttype(t_2*{t_2 : valtype}))
+    -- Expr_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS `%%`_localtype(SET_init, t_1)*{t_1 : valtype} :: lct*{lct : localtype}, LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(`%`_resulttype(t_2*{t_2 : valtype})), REFS []}, expr, `%`_resulttype(t_2*{t_2 : valtype}))
 
 ;; 6-typing.watsup
 relation Global_ok: `%|-%:%`(context, global, globaltype)
@@ -4856,6 +5053,13 @@ relation Mem_ok: `%|-%:%`(context, mem, memtype)
     `%|-%:%`(C, MEMORY_mem(memtype), memtype)
     -- Memtype_ok: `%|-%:OK`(C, memtype)
 
+;; 6-typing.watsup
+relation Tag_ok: `%|-%:%`(context, tag, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, x : idx, functype : functype}:
+    `%|-%:%`(C, TAG_tag(x), C.TYPES_context[x!`%`_idx.0])
+    -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(functype))
+
 ;; 6-typing.watsup
 relation Elemmode_ok: `%|-%:%`(context, elemmode, elemtype)
   ;; 6-typing.watsup
@@ -4937,6 +5141,11 @@ relation Externidx_ok: `%|-%:%`(context, externidx, externtype)
     `%|-%:%`(C, MEM_externidx(x), MEM_externtype(mt))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, x : idx, at : tagtype}:
+    `%|-%:%`(C, TAG_externidx(x), TAG_externtype((at : deftype <: typeuse)))
+    -- if (C.TAGS_context[x!`%`_idx.0] = at)
+
 ;; 6-typing.watsup
 relation Export_ok: `%|-%:%%`(context, export, name, externtype)
   ;; 6-typing.watsup
@@ -4947,33 +5156,33 @@ relation Export_ok: `%|-%:%%`(context, export, name, externtype)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:1288.1-1288.100
+;; 6-typing.watsup:1356.1-1356.100
 relation Globals_ok: `%|-%:%`(context, global*, globaltype*)
-  ;; 6-typing.watsup:1330.1-1331.17
+  ;; 6-typing.watsup:1400.1-1401.17
   rule empty{C : context}:
     `%|-%:%`(C, [], [])
 
-  ;; 6-typing.watsup:1333.1-1336.54
+  ;; 6-typing.watsup:1403.1-1406.54
   rule cons{C : context, global_1 : global, global : global, gt_1 : globaltype, gt* : globaltype*}:
     `%|-%:%`(C, [global_1] :: global*{}, [gt_1] :: gt*{gt : globaltype})
     -- Global_ok: `%|-%:%`(C, global, gt_1)
-    -- Globals_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [gt_1], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, global*{}, gt*{gt : globaltype})
+    -- Globals_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [gt_1], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, global*{}, gt*{gt : globaltype})
 }
 
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:1287.1-1287.98
+;; 6-typing.watsup:1355.1-1355.98
 relation Types_ok: `%|-%:%`(context, type*, deftype*)
-  ;; 6-typing.watsup:1322.1-1323.17
+  ;; 6-typing.watsup:1392.1-1393.17
   rule empty{C : context}:
     `%|-%:%`(C, [], [])
 
-  ;; 6-typing.watsup:1325.1-1328.49
+  ;; 6-typing.watsup:1395.1-1398.49
   rule cons{C : context, type_1 : type, type* : type*, dt_1* : deftype*, dt* : deftype*}:
     `%|-%:%`(C, [type_1] :: type*{type : type}, dt_1*{dt_1 : deftype} :: dt*{dt : deftype})
     -- Type_ok: `%|-%:%`(C, type_1, dt_1*{dt_1 : deftype})
-    -- Types_ok: `%|-%:%`(C ++ {TYPES dt_1*{dt_1 : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt*{dt : deftype})
+    -- Types_ok: `%|-%:%`(C ++ {TYPES dt_1*{dt_1 : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt*{dt : deftype})
 }
 
 ;; 6-typing.watsup
@@ -4983,31 +5192,33 @@ syntax nonfuncs =
 ;; 6-typing.watsup
 def $funcidx_nonfuncs(nonfuncs : nonfuncs) : funcidx*
   ;; 6-typing.watsup
-  def $funcidx_nonfuncs{global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*}(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})) = $funcidx_module(MODULE_module([], [], [], global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, ?(), []))
+  def $funcidx_nonfuncs{global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*}(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})) = $funcidx_module(MODULE_module([], [], [], global*{global : global}, table*{table : table}, mem*{mem : mem}, [], elem*{elem : elem}, data*{data : data}, ?(), []))
 
 ;; 6-typing.watsup
 relation Module_ok: `|-%:%`(module, moduletype)
   ;; 6-typing.watsup
-  rule _{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, C : context, xt_I* : externtype*, xt_E* : externtype*, dt'* : deftype*, C' : context, gt* : globaltype*, tt* : tabletype*, mt* : memtype*, dt* : deftype*, rt* : reftype*, ok* : datatype*, nm* : name*, dt_I* : deftype*, gt_I* : globaltype*, tt_I* : tabletype*, mt_I* : memtype*, x* : idx*}:
-    `|-%:%`(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}), $clos_moduletype(C, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype})))
-    -- Types_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt'*{dt' : deftype})
-    -- (Import_ok: `%|-%:%`({TYPES dt'*{dt' : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, import, xt_I))*{import : import, xt_I : externtype}
+  rule _{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, C : context, xt_I* : externtype*, xt_E* : externtype*, dt'* : deftype*, C' : context, gt* : globaltype*, tt* : tabletype*, mt* : memtype*, at* : tagtype*, dt* : deftype*, rt* : reftype*, ok* : datatype*, nm* : name*, dt_I* : deftype*, gt_I* : globaltype*, tt_I* : tabletype*, mt_I* : memtype*, at_I* : tagtype*, x* : idx*}:
+    `|-%:%`(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}), $clos_moduletype(C, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype})))
+    -- Types_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt'*{dt' : deftype})
+    -- (Import_ok: `%|-%:%`({TYPES dt'*{dt' : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, import, xt_I))*{import : import, xt_I : externtype}
     -- Globals_ok: `%|-%:%`(C', global*{global : global}, gt*{gt : globaltype})
     -- (Table_ok: `%|-%:%`(C', table, tt))*{table : table, tt : tabletype}
     -- (Mem_ok: `%|-%:%`(C', mem, mt))*{mem : mem, mt : memtype}
+    -- (Tag_ok: `%|-%:%`(C', tag, at))*{at : tagtype, tag : tag}
     -- (Func_ok: `%|-%:%`(C, func, dt))*{dt : deftype, func : func}
     -- (Elem_ok: `%|-%:%`(C, elem, rt))*{elem : elem, rt : elemtype}
     -- (Data_ok: `%|-%:%`(C, data, ok))*{data : data, ok : datatype}
     -- (Start_ok: `%|-%:OK`(C, start))?{start : start}
     -- (Export_ok: `%|-%:%%`(C, export, nm, xt_E))*{export : export, nm : name, xt_E : externtype}
     -- if $disjoint_(syntax name, nm*{nm : name})
-    -- if (C = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype} :: gt*{gt : globaltype}, TABLES tt_I*{tt_I : tabletype} :: tt*{tt : tabletype}, MEMS mt_I*{mt_I : memtype} :: mt*{mt : memtype}, ELEMS rt*{rt : elemtype}, DATAS ok*{ok : datatype}, LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
-    -- if (C' = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype}, TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
+    -- if (C = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype} :: gt*{gt : globaltype}, TABLES tt_I*{tt_I : tabletype} :: tt*{tt : tabletype}, MEMS mt_I*{mt_I : memtype} :: mt*{mt : memtype}, TAGS at_I*{at_I : tagtype} :: at*{at : tagtype}, ELEMS rt*{rt : elemtype}, DATAS ok*{ok : datatype}, LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
+    -- if (C' = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype}, TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
     -- if (x*{x : idx} = $funcidx_nonfuncs(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})))
     -- if (dt_I*{dt_I : deftype} = $funcsxt(xt_I*{xt_I : externtype}))
     -- if (gt_I*{gt_I : globaltype} = $globalsxt(xt_I*{xt_I : externtype}))
     -- if (tt_I*{tt_I : tabletype} = $tablesxt(xt_I*{xt_I : externtype}))
     -- if (mt_I*{mt_I : memtype} = $memsxt(xt_I*{xt_I : externtype}))
+    -- if (at_I*{at_I : tagtype} = $tagsxt(xt_I*{xt_I : externtype}))
 
 ;; 7-runtime-typing.watsup
 relation Num_type: `%|-%:%`(store, num, numtype)
@@ -5049,19 +5260,23 @@ relation Ref_type: `%|-%:%`(store, ref, reftype)
     `%|-%:%`(s, REF.FUNC_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), (dt : deftype <: heaptype)))
     -- if (s.FUNCS_store[a].TYPE_funcinst = dt)
 
-  ;; 7-runtime-typing.watsup:35.1-36.39
+  ;; 7-runtime-typing.watsup:35.1-36.38
+  rule exn{s : store, a : addr}:
+    `%|-%:%`(s, REF.EXN_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), EXN_heaptype))
+
+  ;; 7-runtime-typing.watsup:38.1-39.39
   rule host{s : store, a : addr}:
     `%|-%:%`(s, REF.HOST_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), ANY_heaptype))
 
-  ;; 7-runtime-typing.watsup:38.1-39.45
+  ;; 7-runtime-typing.watsup:41.1-42.45
   rule extern{s : store, addrref : addrref}:
     `%|-%:%`(s, REF.EXTERN_ref(addrref), REF_reftype(`NULL%?`_nul(?()), EXTERN_heaptype))
 
-  ;; 7-runtime-typing.watsup:41.1-44.34
+  ;; 7-runtime-typing.watsup:44.1-47.34
   rule sub{s : store, ref : ref, rt : reftype, rt' : reftype}:
     `%|-%:%`(s, ref, rt)
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', rt)
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', rt)
 }
 
 ;; 7-runtime-typing.watsup
@@ -5084,33 +5299,38 @@ relation Val_type: `%|-%:%`(store, val, valtype)
 ;; 7-runtime-typing.watsup
 rec {
 
-;; 7-runtime-typing.watsup:64.1-64.57
-relation Externval_type: `%|-%:%`(store, externval, externtype)
-  ;; 7-runtime-typing.watsup:66.1-68.30
+;; 7-runtime-typing.watsup:67.1-67.59
+relation Externaddr_type: `%|-%:%`(store, externaddr, externtype)
+  ;; 7-runtime-typing.watsup:69.1-71.30
   rule func{s : store, a : addr, funcinst : funcinst}:
-    `%|-%:%`(s, FUNC_externval(a), FUNC_externtype((funcinst.TYPE_funcinst : deftype <: typeuse)))
+    `%|-%:%`(s, FUNC_externaddr(a), FUNC_externtype((funcinst.TYPE_funcinst : deftype <: typeuse)))
     -- if (s.FUNCS_store[a] = funcinst)
 
-  ;; 7-runtime-typing.watsup:70.1-72.34
+  ;; 7-runtime-typing.watsup:73.1-75.34
   rule global{s : store, a : addr, globalinst : globalinst}:
-    `%|-%:%`(s, GLOBAL_externval(a), GLOBAL_externtype(globalinst.TYPE_globalinst))
+    `%|-%:%`(s, GLOBAL_externaddr(a), GLOBAL_externtype(globalinst.TYPE_globalinst))
     -- if (s.GLOBALS_store[a] = globalinst)
 
-  ;; 7-runtime-typing.watsup:74.1-76.32
+  ;; 7-runtime-typing.watsup:77.1-79.32
   rule table{s : store, a : addr, tableinst : tableinst}:
-    `%|-%:%`(s, TABLE_externval(a), TABLE_externtype(tableinst.TYPE_tableinst))
+    `%|-%:%`(s, TABLE_externaddr(a), TABLE_externtype(tableinst.TYPE_tableinst))
     -- if (s.TABLES_store[a] = tableinst)
 
-  ;; 7-runtime-typing.watsup:78.1-80.28
+  ;; 7-runtime-typing.watsup:81.1-83.28
   rule mem{s : store, a : addr, meminst : meminst}:
-    `%|-%:%`(s, MEM_externval(a), MEM_externtype(meminst.TYPE_meminst))
+    `%|-%:%`(s, MEM_externaddr(a), MEM_externtype(meminst.TYPE_meminst))
     -- if (s.MEMS_store[a] = meminst)
 
-  ;; 7-runtime-typing.watsup:82.1-85.37
-  rule sub{s : store, externval : externval, xt : externtype, xt' : externtype}:
-    `%|-%:%`(s, externval, xt)
-    -- Externval_type: `%|-%:%`(s, externval, xt')
-    -- Externtype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, xt', xt)
+  ;; 7-runtime-typing.watsup:85.1-87.28
+  rule tag{s : store, a : addr, taginst : taginst}:
+    `%|-%:%`(s, TAG_externaddr(a), TAG_externtype((taginst.TYPE_taginst : deftype <: typeuse)))
+    -- if (s.TAGS_store[a] = taginst)
+
+  ;; 7-runtime-typing.watsup:89.1-92.37
+  rule sub{s : store, externaddr : externaddr, xt : externtype, xt' : externtype}:
+    `%|-%:%`(s, externaddr, xt)
+    -- Externaddr_type: `%|-%:%`(s, externaddr, xt')
+    -- Externtype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, xt', xt)
 }
 
 ;; 8-reduction.watsup
@@ -5152,15 +5372,19 @@ relation Step_pure: `%~>%`(instr*, instr*)
     `%~>%`([`LABEL_%{%}%`_instr(n, instr*{instr : instr}, (val : val <: instr)*{val : val})], (val : val <: instr)*{val : val})
 
   ;; 8-reduction.watsup
-  rule br-zero{n : n, instr'* : instr*, val'* : val*, val^n : val^n, l : labelidx, instr* : instr*}:
+  rule br-label-zero{n : n, instr'* : instr*, val'* : val*, val^n : val^n, l : labelidx, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val' : val <: instr)*{val' : val} :: (val : val <: instr)^n{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)^n{val : val} :: instr'*{instr' : instr})
     -- if (l = `%`_labelidx(0))
 
   ;; 8-reduction.watsup
-  rule br-succ{n : n, instr'* : instr*, val* : val*, l : labelidx, instr* : instr*}:
+  rule br-label-succ{n : n, instr'* : instr*, val* : val*, l : labelidx, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val : val <: instr)*{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [BR_instr(`%`_labelidx((l!`%`_labelidx.0 - 1)))])
     -- if (l!`%`_labelidx.0 > 0)
 
+  ;; 8-reduction.watsup
+  rule br-handler{n : n, catch* : catch*, val* : val*, l : labelidx, instr* : instr*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [BR_instr(l)])
+
   ;; 8-reduction.watsup
   rule br_if-true{c : num_(I32_numtype), l : labelidx}:
     `%~>%`([CONST_instr(I32_numtype, c) BR_IF_instr(l)], [BR_instr(l)])
@@ -5221,6 +5445,14 @@ relation Step_pure: `%~>%`(instr*, instr*)
   rule return-label{n : n, instr'* : instr*, val* : val*, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val : val <: instr)*{val : val} :: [RETURN_instr] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [RETURN_instr])
 
+  ;; 8-reduction.watsup
+  rule return-handler{n : n, catch* : catch*, val* : val*, instr* : instr*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val} :: [RETURN_instr] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [RETURN_instr])
+
+  ;; 8-reduction.watsup
+  rule handler-vals{n : n, catch* : catch*, val* : val*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val})], (val : val <: instr)*{val : val})
+
   ;; 8-reduction.watsup
   rule trap-vals{val* : val*, instr* : instr*}:
     `%~>%`((val : val <: instr)*{val : val} :: [TRAP_instr] :: instr*{instr : instr}, [TRAP_instr])
@@ -5511,7 +5743,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule br_on_cast-succeed{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype, rt : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) BR_ON_CAST_instr(l, rt_1, rt_2)]), [(ref : ref <: instr) BR_instr(l)])
     -- Ref_type: `%|-%:%`(s, ref, rt)
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
 
   ;; 8-reduction.watsup
   rule br_on_cast-fail{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype}:
@@ -5522,7 +5754,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule br_on_cast_fail-succeed{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype, rt : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) BR_ON_CAST_FAIL_instr(l, rt_1, rt_2)]), [(ref : ref <: instr)])
     -- Ref_type: `%|-%:%`(s, ref, rt)
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
 
   ;; 8-reduction.watsup
   rule br_on_cast_fail-fail{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype}:
@@ -5564,6 +5796,57 @@ relation Step_read: `%~>%`(config, instr*)
     `%~>%`(`%;%`_config(z, [`FRAME_%{%}%`_instr(k, f, (val' : val <: instr)*{val' : val} :: (val : val <: instr)^n{val : val} :: [REF.FUNC_ADDR_instr(a)] :: [RETURN_CALL_REF_instr(yy)] :: instr*{instr : instr})]), (val : val <: instr)^n{val : val} :: [REF.FUNC_ADDR_instr(a) CALL_REF_instr(yy)])
     -- Expand: `%~~%`($funcinst(z)[a].TYPE_funcinst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1^n{t_1 : valtype}), `%`_resulttype(t_2^m{t_2 : valtype}))))
 
+  ;; 8-reduction.watsup
+  rule throw_ref-null{z : state, ht : heaptype}:
+    `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) THROW_REF_instr]), [TRAP_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-vals{z : state, val* : val*, a : addr, instr* : instr*}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)*{val : val} :: [REF.EXN_ADDR_instr(a)] :: [THROW_REF_instr] :: instr*{instr : instr}), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+    -- if ((val*{val : val} =/= []) \/ (instr*{instr : instr} =/= []))
+
+  ;; 8-reduction.watsup
+  rule throw_ref-label{z : state, n : n, instr'* : instr*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-frame{z : state, n : n, f : frame, a : addr}:
+    `%~>%`(`%;%`_config(z, [`FRAME_%{%}%`_instr(n, f, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-empty{z : state, n : n, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [], [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch{z : state, n : n, x : idx, l : labelidx, catch'* : catch*, a : addr, val* : val*}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_catch(x, l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), (val : val <: instr)*{val : val} :: [BR_instr(l)])
+    -- if ($exninst(z)[a].TAG_exninst = $tagaddr(z)[x!`%`_idx.0])
+    -- if (val*{val : val} = $exninst(z)[a].FIELDS_exninst)
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_ref{z : state, n : n, x : idx, l : labelidx, catch'* : catch*, a : addr, val* : val*}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_REF_catch(x, l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), (val : val <: instr)*{val : val} :: [REF.EXN_ADDR_instr(a) BR_instr(l)])
+    -- if ($exninst(z)[a].TAG_exninst = $tagaddr(z)[x!`%`_idx.0])
+    -- if (val*{val : val} = $exninst(z)[a].FIELDS_exninst)
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_all{z : state, n : n, l : labelidx, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_ALL_catch(l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [BR_instr(l)])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_all_ref{z : state, n : n, l : labelidx, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_ALL_REF_catch(l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) BR_instr(l)])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-next{z : state, n : n, catch : catch, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [catch] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [`HANDLER_%{%}%`_instr(n, catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])])
+    -- otherwise
+
+  ;; 8-reduction.watsup
+  rule try_table{z : state, val^m : val^m, m : m, bt : blocktype, catch* : catch*, instr* : instr*, n : n, t_1^m : valtype^m, t_2^n : valtype^n}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)^m{val : val} :: [TRY_TABLE_instr(bt, `%`_list(catch*{catch : catch}), instr*{instr : instr})]), [`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, [`LABEL_%{%}%`_instr(n, [], (val : val <: instr)^m{val : val} :: instr*{instr : instr})])])
+    -- if ($blocktype_(z, bt) = `%->%`_functype(`%`_resulttype(t_1^m{t_1 : valtype}), `%`_resulttype(t_2^n{t_2 : valtype})))
+
   ;; 8-reduction.watsup
   rule ref.null-idx{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(($idx(x) : typevar <: heaptype))]), [REF.NULL_instr(($type(z, x) : deftype <: heaptype))])
@@ -5576,7 +5859,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule ref.test-true{s : store, f : frame, ref : ref, rt : reftype, rt' : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) REF.TEST_instr(rt)]), [CONST_instr(I32_numtype, `%`_num_(1))])
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
 
   ;; 8-reduction.watsup
   rule ref.test-false{s : store, f : frame, ref : ref, rt : reftype}:
@@ -5587,7 +5870,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule ref.cast-succeed{s : store, f : frame, ref : ref, rt : reftype, rt' : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) REF.CAST_instr(rt)]), [(ref : ref <: instr)])
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
 
   ;; 8-reduction.watsup
   rule ref.cast-fail{s : store, f : frame, ref : ref, rt : reftype}:
@@ -6002,135 +6285,142 @@ relation Step: `%~>%`(config, config)
     `%~>%`(`%;%`_config(z, instr*{instr : instr}), `%;%`_config(z, instr'*{instr' : instr}))
     -- Step_read: `%~>%`(`%;%`_config(z, instr*{instr : instr}), instr'*{instr' : instr})
 
-  ;; 8-reduction.watsup:225.1-227.36
+  ;; 8-reduction.watsup:218.1-223.49
+  rule throw{z : state, val^n : val^n, n : n, x : idx, exn : exninst, a : addr, t^n : valtype^n}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [THROW_instr(x)]), `%;%`_config($add_exninst(z, [exn]), [REF.EXN_ADDR_instr(a) THROW_REF_instr]))
+    -- Expand: `%~~%`($tag(z, x).TYPE_taginst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t^n{t : valtype}), `%`_resulttype([]))))
+    -- if (a = |$exninst(z)|)
+    -- if (exn = {TAG $tagaddr(z)[x!`%`_idx.0], FIELDS val^n{val : val}})
+
+  ;; 8-reduction.watsup:285.1-287.36
   rule ctxt-label{z : state, n : n, instr_0* : instr*, instr* : instr*, z' : state, instr'* : instr*}:
     `%~>%`(`%;%`_config(z, [`LABEL_%{%}%`_instr(n, instr_0*{instr_0 : instr}, instr*{instr : instr})]), `%;%`_config(z', [`LABEL_%{%}%`_instr(n, instr_0*{instr_0 : instr}, instr'*{instr' : instr})]))
     -- Step: `%~>%`(`%;%`_config(z, instr*{instr : instr}), `%;%`_config(z', instr'*{instr' : instr}))
 
-  ;; 8-reduction.watsup:229.1-231.44
+  ;; 8-reduction.watsup:289.1-291.44
   rule ctxt-frame{s : store, f : frame, n : n, f' : frame, instr* : instr*, s' : store, instr'* : instr*}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [`FRAME_%{%}%`_instr(n, f', instr*{instr : instr})]), `%;%`_config(`%;%`_state(s', f), [`FRAME_%{%}%`_instr(n, f', instr'*{instr' : instr})]))
     -- Step: `%~>%`(`%;%`_config(`%;%`_state(s, f'), instr*{instr : instr}), `%;%`_config(`%;%`_state(s', f'), instr'*{instr' : instr}))
 
-  ;; 8-reduction.watsup:349.1-353.65
+  ;; 8-reduction.watsup:409.1-413.65
   rule struct.new{z : state, val^n : val^n, n : n, x : idx, si : structinst, a : addr, mut^n : mut^n, zt^n : storagetype^n}:
     `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [STRUCT.NEW_instr(x)]), `%;%`_config($add_structinst(z, [si]), [REF.STRUCT_ADDR_instr(a)]))
     -- Expand: `%~~%`($type(z, x), STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)^n{mut : mut, zt : storagetype})))
     -- if (a = |$structinst(z)|)
     -- if (si = {TYPE $type(z, x), FIELDS $packfield_(zt, val)^n{val : val, zt : storagetype}})
 
-  ;; 8-reduction.watsup:369.1-370.53
+  ;; 8-reduction.watsup:429.1-430.53
   rule struct.set-null{z : state, ht : heaptype, val : val, x : idx, i : nat}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) (val : val <: instr) STRUCT.SET_instr(x, `%`_u32(i))]), `%;%`_config(z, [TRAP_instr]))
 
-  ;; 8-reduction.watsup:372.1-374.45
+  ;; 8-reduction.watsup:432.1-434.45
   rule struct.set-struct{z : state, a : addr, val : val, x : idx, i : nat, zt* : storagetype*, mut* : mut*}:
     `%~>%`(`%;%`_config(z, [REF.STRUCT_ADDR_instr(a) (val : val <: instr) STRUCT.SET_instr(x, `%`_u32(i))]), `%;%`_config($with_struct(z, a, i, $packfield_(zt*{zt : storagetype}[i], val)), []))
     -- Expand: `%~~%`($type(z, x), STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
 
-  ;; 8-reduction.watsup:387.1-392.65
+  ;; 8-reduction.watsup:447.1-452.65
   rule array.new_fixed{z : state, val^n : val^n, n : n, x : idx, ai : arrayinst, a : addr, mut : mut, zt : storagetype}:
     `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [ARRAY.NEW_FIXED_instr(x, `%`_u32(n))]), `%;%`_config($add_arrayinst(z, [ai]), [REF.ARRAY_ADDR_instr(a)]))
     -- Expand: `%~~%`($type(z, x), ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ((a = |$arrayinst(z)|) /\ (ai = {TYPE $type(z, x), FIELDS $packfield_(zt, val)^n{val : val}}))
 
-  ;; 8-reduction.watsup:432.1-433.64
+  ;; 8-reduction.watsup:492.1-493.64
   rule array.set-null{z : state, ht : heaptype, i : nat, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
 
-  ;; 8-reduction.watsup:435.1-437.39
+  ;; 8-reduction.watsup:495.1-497.39
   rule array.set-oob{z : state, a : addr, i : nat, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.ARRAY_ADDR_instr(a) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
     -- if (i >= |$arrayinst(z)[a].FIELDS_arrayinst|)
 
-  ;; 8-reduction.watsup:439.1-442.43
+  ;; 8-reduction.watsup:499.1-502.43
   rule array.set-array{z : state, a : addr, i : nat, val : val, x : idx, zt : storagetype, mut : mut}:
     `%~>%`(`%;%`_config(z, [REF.ARRAY_ADDR_instr(a) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config($with_array(z, a, i, $packfield_(zt, val)), []))
     -- Expand: `%~~%`($type(z, x), ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 8-reduction.watsup:743.1-744.56
+  ;; 8-reduction.watsup:803.1-804.56
   rule local.set{z : state, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [(val : val <: instr) LOCAL.SET_instr(x)]), `%;%`_config($with_local(z, x, val), []))
 
-  ;; 8-reduction.watsup:756.1-757.58
+  ;; 8-reduction.watsup:816.1-817.58
   rule global.set{z : state, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [(val : val <: instr) GLOBAL.SET_instr(x)]), `%;%`_config($with_global(z, x, val), []))
 
-  ;; 8-reduction.watsup:770.1-772.33
+  ;; 8-reduction.watsup:830.1-832.33
   rule table.set-oob{z : state, i : nat, ref : ref, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) (ref : ref <: instr) TABLE.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
     -- if (i >= |$table(z, x).REFS_tableinst|)
 
-  ;; 8-reduction.watsup:774.1-776.32
+  ;; 8-reduction.watsup:834.1-836.32
   rule table.set-val{z : state, i : nat, ref : ref, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) (ref : ref <: instr) TABLE.SET_instr(x)]), `%;%`_config($with_table(z, x, i, ref), []))
     -- if (i < |$table(z, x).REFS_tableinst|)
 
-  ;; 8-reduction.watsup:784.1-787.46
+  ;; 8-reduction.watsup:844.1-847.46
   rule table.grow-succeed{z : state, ref : ref, n : n, x : idx, ti : tableinst}:
     `%~>%`(`%;%`_config(z, [(ref : ref <: instr) CONST_instr(I32_numtype, `%`_num_(n)) TABLE.GROW_instr(x)]), `%;%`_config($with_tableinst(z, x, ti), [CONST_instr(I32_numtype, `%`_num_(|$table(z, x).REFS_tableinst|))]))
     -- if (ti = $growtable($table(z, x), n, ref))
 
-  ;; 8-reduction.watsup:789.1-790.81
+  ;; 8-reduction.watsup:849.1-850.81
   rule table.grow-fail{z : state, ref : ref, n : n, x : idx}:
     `%~>%`(`%;%`_config(z, [(ref : ref <: instr) CONST_instr(I32_numtype, `%`_num_(n)) TABLE.GROW_instr(x)]), `%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_($invsigned_(32, - (1 : nat <: int))))]))
 
-  ;; 8-reduction.watsup:850.1-851.51
+  ;; 8-reduction.watsup:910.1-911.51
   rule elem.drop{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [ELEM.DROP_instr(x)]), `%;%`_config($with_elem(z, x, []), []))
 
-  ;; 8-reduction.watsup:934.1-937.60
+  ;; 8-reduction.watsup:994.1-997.60
   rule store-num-oob{z : state, i : nat, nt : numtype, c : num_(nt), x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr(nt, c) STORE_instr(nt, ?(), x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + ($size(nt) / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:939.1-943.29
+  ;; 8-reduction.watsup:999.1-1003.29
   rule store-num-val{z : state, i : nat, nt : numtype, c : num_(nt), x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr(nt, c) STORE_instr(nt, ?(), x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), ($size(nt) / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $nbytes_(nt, c))
 
-  ;; 8-reduction.watsup:945.1-948.52
+  ;; 8-reduction.watsup:1005.1-1008.52
   rule store-pack-oob{z : state, i : nat, Inn : Inn, c : num_((Inn : Inn <: numtype)), nt : numtype, n : n, x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr((Inn : Inn <: numtype), c) STORE_instr(nt, ?(`%`_sz(n)), x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + (n / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:950.1-954.52
+  ;; 8-reduction.watsup:1010.1-1014.52
   rule store-pack-val{z : state, i : nat, Inn : Inn, c : num_((Inn : Inn <: numtype)), nt : numtype, n : n, x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr((Inn : Inn <: numtype), c) STORE_instr(nt, ?(`%`_sz(n)), x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), (n / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $ibytes_(n, $wrap__($size((Inn : Inn <: numtype)), n, c)))
 
-  ;; 8-reduction.watsup:956.1-958.63
+  ;; 8-reduction.watsup:1016.1-1018.63
   rule vstore-oob{z : state, i : nat, c : vec_(V128_Vnn), x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_instr(V128_vectype, x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + ($vsize(V128_vectype) / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:960.1-962.31
+  ;; 8-reduction.watsup:1020.1-1022.31
   rule vstore-val{z : state, i : nat, c : vec_(V128_Vnn), x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_instr(V128_vectype, x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), ($vsize(V128_vectype) / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $vbytes_(V128_vectype, c))
 
-  ;; 8-reduction.watsup:965.1-967.50
+  ;; 8-reduction.watsup:1025.1-1027.50
   rule vstore_lane-oob{z : state, i : nat, c : vec_(V128_Vnn), N : N, x : idx, ao : memarg, j : nat}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, ao, `%`_laneidx(j))]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + N) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:969.1-973.49
+  ;; 8-reduction.watsup:1029.1-1033.49
   rule vstore_lane-val{z : state, i : nat, c : vec_(V128_Vnn), N : N, x : idx, ao : memarg, j : nat, b* : byte*, Jnn : Jnn, M : M}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, ao, `%`_laneidx(j))]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), (N / 8), b*{b : byte}), []))
     -- if (N = $lsize((Jnn : Jnn <: lanetype)))
     -- if (M = (128 / N))
     -- if (b*{b : byte} = $ibytes_(N, `%`_iN($lanes_(`%X%`_shape((Jnn : Jnn <: lanetype), `%`_dim(M)), c)[j]!`%`_lane_.0)))
 
-  ;; 8-reduction.watsup:981.1-984.37
+  ;; 8-reduction.watsup:1041.1-1044.37
   rule memory.grow-succeed{z : state, n : n, x : idx, mi : meminst}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(n)) MEMORY.GROW_instr(x)]), `%;%`_config($with_meminst(z, x, mi), [CONST_instr(I32_numtype, `%`_num_((|$mem(z, x).BYTES_meminst| / (64 * $Ki))))]))
     -- if (mi = $growmem($mem(z, x), n))
 
-  ;; 8-reduction.watsup:986.1-987.78
+  ;; 8-reduction.watsup:1046.1-1047.78
   rule memory.grow-fail{z : state, n : n, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(n)) MEMORY.GROW_instr(x)]), `%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_($invsigned_(32, - (1 : nat <: int))))]))
 
-  ;; 8-reduction.watsup:1047.1-1048.51
+  ;; 8-reduction.watsup:1107.1-1108.51
   rule data.drop{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [DATA.DROP_instr(x)]), `%;%`_config($with_data(z, x, []), []))
 }
@@ -6176,7 +6466,7 @@ def $alloctypes(type*) : deftype*
 ;; 9-module.watsup
 def $allocfunc(store : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst) : (store, funcaddr)
   ;; 9-module.watsup
-  def $allocfunc{s : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst, funcinst : funcinst}(s, deftype, funccode, moduleinst) = (s ++ {FUNCS [funcinst], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.FUNCS_store|)
+  def $allocfunc{s : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst, funcinst : funcinst}(s, deftype, funccode, moduleinst) = (s ++ {FUNCS [funcinst], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.FUNCS_store|)
     -- if (funcinst = {TYPE deftype, MODULE moduleinst, CODE funccode})
 
 ;; 9-module.watsup
@@ -6195,7 +6485,7 @@ def $allocfuncs(store : store, deftype*, funccode*, moduleinst*) : (store, funca
 ;; 9-module.watsup
 def $allocglobal(store : store, globaltype : globaltype, val : val) : (store, globaladdr)
   ;; 9-module.watsup
-  def $allocglobal{s : store, globaltype : globaltype, val : val, globalinst : globalinst}(s, globaltype, val) = (s ++ {FUNCS [], GLOBALS [globalinst], TABLES [], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.GLOBALS_store|)
+  def $allocglobal{s : store, globaltype : globaltype, val : val, globalinst : globalinst}(s, globaltype, val) = (s ++ {FUNCS [], GLOBALS [globalinst], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.GLOBALS_store|)
     -- if (globalinst = {TYPE globaltype, VALUE val})
 
 ;; 9-module.watsup
@@ -6214,7 +6504,7 @@ def $allocglobals(store : store, globaltype*, val*) : (store, globaladdr*)
 ;; 9-module.watsup
 def $alloctable(store : store, tabletype : tabletype, ref : ref) : (store, tableaddr)
   ;; 9-module.watsup
-  def $alloctable{s : store, i : nat, j : nat, rt : reftype, ref : ref, tableinst : tableinst}(s, `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), ref) = (s ++ {FUNCS [], GLOBALS [], TABLES [tableinst], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.TABLES_store|)
+  def $alloctable{s : store, i : nat, j : nat, rt : reftype, ref : ref, tableinst : tableinst}(s, `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), ref) = (s ++ {FUNCS [], GLOBALS [], TABLES [tableinst], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.TABLES_store|)
     -- if (tableinst = {TYPE `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), REFS ref^i{}})
 
 ;; 9-module.watsup
@@ -6233,7 +6523,7 @@ def $alloctables(store : store, tabletype*, ref*) : (store, tableaddr*)
 ;; 9-module.watsup
 def $allocmem(store : store, memtype : memtype) : (store, memaddr)
   ;; 9-module.watsup
-  def $allocmem{s : store, i : nat, j : nat, meminst : meminst}(s, `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)))) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [meminst], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.MEMS_store|)
+  def $allocmem{s : store, i : nat, j : nat, meminst : meminst}(s, `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)))) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [meminst], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.MEMS_store|)
     -- if (meminst = {TYPE `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j))), BYTES `%`_byte(0)^(i * (64 * $Ki)){}})
 
 ;; 9-module.watsup
@@ -6249,39 +6539,58 @@ def $allocmems(store : store, memtype*) : (store, memaddr*)
     -- if ((s_2, ma'*{ma' : memaddr}) = $allocmems(s_1, memtype'*{memtype' : memtype}))
 }
 
+;; 9-module.watsup
+def $alloctag(store : store, tagtype : tagtype) : (store, tagaddr)
+  ;; 9-module.watsup
+  def $alloctag{s : store, at : tagtype, taginst : taginst}(s, at) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [taginst], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.TAGS_store|)
+    -- if (taginst = {TYPE at})
+
+;; 9-module.watsup
+rec {
+
+;; 9-module.watsup:64.1-64.82
+def $alloctags(store : store, tagtype*) : (store, tagaddr*)
+  ;; 9-module.watsup:65.1-65.34
+  def $alloctags{s : store}(s, []) = (s, [])
+  ;; 9-module.watsup:66.1-68.44
+  def $alloctags{s : store, at : tagtype, at'* : tagtype*, s_2 : store, aa : tagaddr, aa'* : tagaddr*, s_1 : store}(s, [at] :: at'*{at' : tagtype}) = (s_2, [aa] :: aa'*{aa' : tagaddr})
+    -- if ((s_1, aa) = $alloctag(s, at))
+    -- if ((s_2, aa'*{aa' : tagaddr}) = $alloctags(s_1, at'*{at' : tagtype}))
+}
+
 ;; 9-module.watsup
 def $allocelem(store : store, elemtype : elemtype, ref*) : (store, elemaddr)
   ;; 9-module.watsup
-  def $allocelem{s : store, elemtype : elemtype, ref* : ref*, eleminst : eleminst}(s, elemtype, ref*{ref : ref}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [eleminst], DATAS [], STRUCTS [], ARRAYS []}, |s.ELEMS_store|)
+  def $allocelem{s : store, elemtype : elemtype, ref* : ref*, eleminst : eleminst}(s, elemtype, ref*{ref : ref}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [eleminst], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.ELEMS_store|)
     -- if (eleminst = {TYPE elemtype, REFS ref*{ref : ref}})
 
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:64.1-64.97
+;; 9-module.watsup:75.1-75.97
 def $allocelems(store : store, elemtype*, ref**) : (store, elemaddr*)
-  ;; 9-module.watsup:65.1-65.40
+  ;; 9-module.watsup:76.1-76.40
   def $allocelems{s : store}(s, [], []) = (s, [])
-  ;; 9-module.watsup:66.1-68.55
+  ;; 9-module.watsup:77.1-79.55
   def $allocelems{s : store, rt : reftype, rt'* : reftype*, ref* : ref*, ref'** : ref**, s_2 : store, ea : elemaddr, ea'* : elemaddr*, s_1 : store}(s, [rt] :: rt'*{rt' : elemtype}, [ref*{ref : ref}] :: ref'*{ref' : ref}*{ref' : ref}) = (s_2, [ea] :: ea'*{ea' : elemaddr})
     -- if ((s_1, ea) = $allocelem(s, rt, ref*{ref : ref}))
-    -- if ((s_2, ea'*{ea' : elemaddr}) = $allocelems(s_2, rt'*{rt' : elemtype}, ref'*{ref' : ref}*{ref' : ref}))
+    -- if ((s_2, ea'*{ea' : elemaddr}) = $allocelems(s_1, rt'*{rt' : elemtype}, ref'*{ref' : ref}*{ref' : ref}))
 }
 
 ;; 9-module.watsup
 def $allocdata(store : store, datatype : datatype, byte*) : (store, dataaddr)
   ;; 9-module.watsup
-  def $allocdata{s : store, byte* : byte*, datainst : datainst}(s, OK_datatype, byte*{byte : byte}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [datainst], STRUCTS [], ARRAYS []}, |s.DATAS_store|)
+  def $allocdata{s : store, byte* : byte*, datainst : datainst}(s, OK_datatype, byte*{byte : byte}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [datainst], STRUCTS [], ARRAYS [], EXNS []}, |s.DATAS_store|)
     -- if (datainst = {BYTES byte*{byte : byte}})
 
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:75.1-75.98
+;; 9-module.watsup:86.1-86.98
 def $allocdatas(store : store, datatype*, byte**) : (store, dataaddr*)
-  ;; 9-module.watsup:76.1-76.40
+  ;; 9-module.watsup:87.1-87.40
   def $allocdatas{s : store}(s, [], []) = (s, [])
-  ;; 9-module.watsup:77.1-79.53
+  ;; 9-module.watsup:88.1-90.53
   def $allocdatas{s : store, ok : datatype, ok'* : datatype*, b* : byte*, b'** : byte**, s_2 : store, da : dataaddr, da'* : dataaddr*, s_1 : store}(s, [ok] :: ok'*{ok' : datatype}, [b*{b : byte}] :: b'*{b' : byte}*{b' : byte}) = (s_2, [da] :: da'*{da' : dataaddr})
     -- if ((s_1, da) = $allocdata(s, ok, b*{b : byte}))
     -- if ((s_2, da'*{da' : dataaddr}) = $allocdatas(s_1, ok'*{ok' : datatype}, b'*{b' : byte}*{b' : byte}))
@@ -6290,13 +6599,15 @@ def $allocdatas(store : store, datatype*, byte**) : (store, dataaddr*)
 ;; 9-module.watsup
 def $allocexport(moduleinst : moduleinst, export : export) : exportinst
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, FUNC_externidx(x))) = {NAME name, VALUE FUNC_externval(moduleinst.FUNCS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, FUNC_externidx(x))) = {NAME name, ADDR FUNC_externaddr(moduleinst.FUNCS_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, GLOBAL_externidx(x))) = {NAME name, VALUE GLOBAL_externval(moduleinst.GLOBALS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, GLOBAL_externidx(x))) = {NAME name, ADDR GLOBAL_externaddr(moduleinst.GLOBALS_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TABLE_externidx(x))) = {NAME name, VALUE TABLE_externval(moduleinst.TABLES_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TABLE_externidx(x))) = {NAME name, ADDR TABLE_externaddr(moduleinst.TABLES_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, MEM_externidx(x))) = {NAME name, VALUE MEM_externval(moduleinst.MEMS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, MEM_externidx(x))) = {NAME name, ADDR MEM_externaddr(moduleinst.MEMS_moduleinst[x!`%`_idx.0])}
+  ;; 9-module.watsup
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TAG_externidx(x))) = {NAME name, ADDR TAG_externaddr(moduleinst.TAGS_moduleinst[x!`%`_idx.0])}
 
 ;; 9-module.watsup
 def $allocexports(moduleinst : moduleinst, export*) : exportinst*
@@ -6304,35 +6615,39 @@ def $allocexports(moduleinst : moduleinst, export*) : exportinst*
   def $allocexports{moduleinst : moduleinst, export* : export*}(moduleinst, export*{export : export}) = $allocexport(moduleinst, export)*{export : export}
 
 ;; 9-module.watsup
-def $allocmodule(store : store, module : module, externval*, val*, ref*, ref**) : (store, moduleinst)
+def $allocmodule(store : store, module : module, externaddr*, val*, ref*, ref**) : (store, moduleinst)
   ;; 9-module.watsup
-  def $allocmodule{s : store, module : module, externval* : externval*, val_G* : val*, ref_T* : ref*, ref_E** : ref**, s_6 : store, moduleinst : moduleinst, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, x* : idx*, local** : local**, expr_F* : expr*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, memtype* : memtype*, elemtype* : elemtype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, fa_I* : funcaddr*, ga_I* : globaladdr*, ta_I* : tableaddr*, ma_I* : memaddr*, fa* : funcaddr*, i_F^|func*{func : func}| : nat^|func*{func : func}|, ga* : globaladdr*, i_G^|global*{global : global}| : nat^|global*{global : global}|, ta* : tableaddr*, i_T^|table*{table : table}| : nat^|table*{table : table}|, ma* : memaddr*, i_M^|mem*{mem : mem}| : nat^|mem*{mem : mem}|, ea* : elemaddr*, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, da* : dataaddr*, i_D^|data*{data : data}| : nat^|data*{data : data}|, dt* : deftype*, s_1 : store, s_2 : store, s_3 : store, s_4 : store, s_5 : store, xi* : exportinst*}(s, module, externval*{externval : externval}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}) = (s_6, moduleinst)
-    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
+  def $allocmodule{s : store, module : module, externaddr* : externaddr*, val_G* : val*, ref_T* : ref*, ref_E** : ref**, s_7 : store, moduleinst : moduleinst, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, x* : idx*, local** : local**, expr_F* : expr*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, memtype* : memtype*, y* : idx*, elemtype* : elemtype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, fa_I* : funcaddr*, ga_I* : globaladdr*, ta_I* : tableaddr*, ma_I* : memaddr*, aa_I* : tagaddr*, fa* : nat*, i_F^|func*{func : func}| : nat^|func*{func : func}|, ga* : nat*, i_G^|global*{global : global}| : nat^|global*{global : global}|, ta* : nat*, i_T^|table*{table : table}| : nat^|table*{table : table}|, aa* : nat*, i_A^|tag*{tag : tag}| : nat^|tag*{tag : tag}|, ma* : nat*, i_M^|mem*{mem : mem}| : nat^|mem*{mem : mem}|, ea* : nat*, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, da* : nat*, i_D^|data*{data : data}| : nat^|data*{data : data}|, dt* : deftype*, s_1 : store, s_2 : store, s_3 : store, s_4 : store, s_5 : store, s_6 : store, xi* : exportinst*}(s, module, externaddr*{externaddr : externaddr}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}) = (s_7, moduleinst)
+    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
     -- if (func*{func : func} = FUNC_func(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx})
     -- if (global*{global : global} = GLOBAL_global(globaltype, expr_G)*{expr_G : expr, globaltype : globaltype})
     -- if (table*{table : table} = TABLE_table(tabletype, expr_T)*{expr_T : expr, tabletype : tabletype})
     -- if (mem*{mem : mem} = MEMORY_mem(memtype)*{memtype : memtype})
+    -- if (tag*{tag : tag} = TAG_tag(y)*{y : typeidx})
     -- if (elem*{elem : elem} = ELEM_elem(elemtype, expr_E*{expr_E : expr}, elemmode)*{elemmode : elemmode, elemtype : reftype, expr_E : expr})
     -- if (data*{data : data} = DATA_data(byte*{byte : byte}, datamode)*{byte : byte, datamode : datamode})
-    -- if (fa_I*{fa_I : funcaddr} = $funcsxv(externval*{externval : externval}))
-    -- if (ga_I*{ga_I : globaladdr} = $globalsxv(externval*{externval : externval}))
-    -- if (ta_I*{ta_I : tableaddr} = $tablesxv(externval*{externval : externval}))
-    -- if (ma_I*{ma_I : memaddr} = $memsxv(externval*{externval : externval}))
-    -- if (fa*{fa : funcaddr} = (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat})
-    -- if (ga*{ga : globaladdr} = (|s.GLOBALS_store| + i_G)^(i_G<|global*{global : global}|){i_G : nat})
-    -- if (ta*{ta : tableaddr} = (|s.TABLES_store| + i_T)^(i_T<|table*{table : table}|){i_T : nat})
-    -- if (ma*{ma : memaddr} = (|s.MEMS_store| + i_M)^(i_M<|mem*{mem : mem}|){i_M : nat})
-    -- if (ea*{ea : elemaddr} = (|s.ELEMS_store| + i_E)^(i_E<|elem*{elem : elem}|){i_E : nat})
-    -- if (da*{da : dataaddr} = (|s.DATAS_store| + i_D)^(i_D<|data*{data : data}|){i_D : nat})
+    -- if (fa_I*{fa_I : funcaddr} = $funcsxa(externaddr*{externaddr : externaddr}))
+    -- if (ga_I*{ga_I : globaladdr} = $globalsxa(externaddr*{externaddr : externaddr}))
+    -- if (ta_I*{ta_I : tableaddr} = $tablesxa(externaddr*{externaddr : externaddr}))
+    -- if (ma_I*{ma_I : memaddr} = $memsxa(externaddr*{externaddr : externaddr}))
+    -- if (aa_I*{aa_I : tagaddr} = $tagsxa(externaddr*{externaddr : externaddr}))
+    -- if (fa*{fa : nat} = (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat})
+    -- if (ga*{ga : nat} = (|s.GLOBALS_store| + i_G)^(i_G<|global*{global : global}|){i_G : nat})
+    -- if (ta*{ta : nat} = (|s.TABLES_store| + i_T)^(i_T<|table*{table : table}|){i_T : nat})
+    -- if (aa*{aa : nat} = (|s.TAGS_store| + i_A)^(i_A<|tag*{tag : tag}|){i_A : nat})
+    -- if (ma*{ma : nat} = (|s.MEMS_store| + i_M)^(i_M<|mem*{mem : mem}|){i_M : nat})
+    -- if (ea*{ea : nat} = (|s.ELEMS_store| + i_E)^(i_E<|elem*{elem : elem}|){i_E : nat})
+    -- if (da*{da : nat} = (|s.DATAS_store| + i_D)^(i_D<|data*{data : data}|){i_D : nat})
     -- if (dt*{dt : deftype} = $alloctypes(type*{type : type}))
-    -- if ((s_1, fa*{fa : funcaddr}) = $allocfuncs(s, dt*{dt : deftype}[x!`%`_idx.0]*{x : idx}, FUNC_funccode(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx}, moduleinst^|func*{func : func}|{}))
-    -- if ((s_2, ga*{ga : globaladdr}) = $allocglobals(s_1, globaltype*{globaltype : globaltype}, val_G*{val_G : val}))
-    -- if ((s_3, ta*{ta : tableaddr}) = $alloctables(s_2, tabletype*{tabletype : tabletype}, ref_T*{ref_T : ref}))
-    -- if ((s_4, ma*{ma : memaddr}) = $allocmems(s_3, memtype*{memtype : memtype}))
-    -- if ((s_5, ea*{ea : elemaddr}) = $allocelems(s_4, elemtype*{elemtype : elemtype}, ref_E*{ref_E : ref}*{ref_E : ref}))
-    -- if ((s_6, da*{da : dataaddr}) = $allocdatas(s_5, OK_datatype^|data*{data : data}|{}, byte*{byte : byte}*{byte : byte}))
-    -- if (xi*{xi : exportinst} = $allocexports({TYPES [], FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, ELEMS [], DATAS [], EXPORTS []}, export*{export : export}))
-    -- if (moduleinst = {TYPES dt*{dt : deftype}, FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, ELEMS ea*{ea : elemaddr}, DATAS da*{da : dataaddr}, EXPORTS xi*{xi : exportinst}})
+    -- if ((s_1, fa*{fa : nat}) = $allocfuncs(s, dt*{dt : deftype}[x!`%`_idx.0]*{x : idx}, FUNC_funccode(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx}, moduleinst^|func*{func : func}|{}))
+    -- if ((s_2, ga*{ga : nat}) = $allocglobals(s_1, globaltype*{globaltype : globaltype}, val_G*{val_G : val}))
+    -- if ((s_3, ta*{ta : nat}) = $alloctables(s_2, tabletype*{tabletype : tabletype}, ref_T*{ref_T : ref}))
+    -- if ((s_4, ma*{ma : nat}) = $allocmems(s_3, memtype*{memtype : memtype}))
+    -- if ((s_5, aa*{aa : nat}) = $alloctags(s_4, dt*{dt : deftype}[y!`%`_idx.0]*{y : idx}))
+    -- if ((s_6, ea*{ea : nat}) = $allocelems(s_5, elemtype*{elemtype : elemtype}, ref_E*{ref_E : ref}*{ref_E : ref}))
+    -- if ((s_7, da*{da : nat}) = $allocdatas(s_6, OK_datatype^|data*{data : data}|{}, byte*{byte : byte}*{byte : byte}))
+    -- if (xi*{xi : exportinst} = $allocexports({TYPES [], FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, TAGS aa_I*{aa_I : tagaddr} :: aa*{aa : tagaddr}, ELEMS [], DATAS [], EXPORTS []}, export*{export : export}))
+    -- if (moduleinst = {TYPES dt*{dt : deftype}, FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, TAGS aa_I*{aa_I : tagaddr} :: aa*{aa : tagaddr}, ELEMS ea*{ea : elemaddr}, DATAS da*{da : dataaddr}, EXPORTS xi*{xi : exportinst}})
 
 ;; 9-module.watsup
 def $runelem_(elemidx : elemidx, elem : elem) : instr*
@@ -6353,11 +6668,11 @@ def $rundata_(dataidx : dataidx, data : data) : instr*
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:152.1-152.94
+;; 9-module.watsup:169.1-169.94
 def $evalglobals(state : state, globaltype*, expr*) : (state, val*)
-  ;; 9-module.watsup:153.1-153.41
+  ;; 9-module.watsup:170.1-170.41
   def $evalglobals{z : state}(z, [], []) = (z, [])
-  ;; 9-module.watsup:154.1-159.81
+  ;; 9-module.watsup:171.1-176.81
   def $evalglobals{z : state, gt : globaltype, gt'* : globaltype*, expr : expr, expr'* : expr*, z' : state, val : val, val'* : val*, s : store, f : frame, s' : store, a : addr}(z, [gt] :: gt'*{gt' : globaltype}, [expr] :: expr'*{expr' : expr}) = (z', [val] :: val'*{val' : val})
     -- Eval_expr: `%;%~>*%;%`(z, expr, z, [val])
     -- if (z = `%;%`_state(s, f))
@@ -6366,23 +6681,23 @@ def $evalglobals(state : state, globaltype*, expr*) : (state, val*)
 }
 
 ;; 9-module.watsup
-def $instantiate(store : store, module : module, externval*) : config
+def $instantiate(store : store, module : module, externaddr*) : config
   ;; 9-module.watsup
-  def $instantiate{s : store, module : module, externval* : externval*, s' : store, f : frame, instr_E* : instr*, instr_D* : instr*, instr_S? : instr?, xt_I* : externtype*, xt_E* : externtype*, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, reftype* : reftype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, x? : idx?, moduleinst_0 : moduleinst, i_F^|func*{func : func}| : nat^|func*{func : func}|, z : state, z' : state, val_G* : val*, ref_T* : ref*, ref_E** : ref**, moduleinst : moduleinst, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, i_D^|data*{data : data}| : nat^|data*{data : data}|}(s, module, externval*{externval : externval}) = `%;%`_config(`%;%`_state(s', f), instr_E*{instr_E : instr} :: instr_D*{instr_D : instr} :: instr_S?{instr_S : instr})
+  def $instantiate{s : store, module : module, externaddr* : externaddr*, s' : store, f : frame, instr_E* : instr*, instr_D* : instr*, instr_S? : instr?, xt_I* : externtype*, xt_E* : externtype*, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, reftype* : reftype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, x? : idx?, moduleinst_0 : moduleinst, i_F^|func*{func : func}| : nat^|func*{func : func}|, z : state, z' : state, val_G* : val*, ref_T* : ref*, ref_E** : ref**, moduleinst : moduleinst, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, i_D^|data*{data : data}| : nat^|data*{data : data}|}(s, module, externaddr*{externaddr : externaddr}) = `%;%`_config(`%;%`_state(s', f), instr_E*{instr_E : instr} :: instr_D*{instr_D : instr} :: instr_S?{instr_S : instr})
     -- Module_ok: `|-%:%`(module, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype}))
-    -- (Externval_type: `%|-%:%`(s, externval, xt_I))*{externval : externval, xt_I : externtype}
-    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
+    -- (Externaddr_type: `%|-%:%`(s, externaddr, xt_I))*{externaddr : externaddr, xt_I : externtype}
+    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
     -- if (global*{global : global} = GLOBAL_global(globaltype, expr_G)*{expr_G : expr, globaltype : globaltype})
     -- if (table*{table : table} = TABLE_table(tabletype, expr_T)*{expr_T : expr, tabletype : tabletype})
     -- if (elem*{elem : elem} = ELEM_elem(reftype, expr_E*{expr_E : expr}, elemmode)*{elemmode : elemmode, expr_E : expr, reftype : reftype})
     -- if (data*{data : data} = DATA_data(byte*{byte : byte}, datamode)*{byte : byte, datamode : datamode})
     -- if (start?{start : start} = START_start(x)?{x : funcidx})
-    -- if (moduleinst_0 = {TYPES $alloctypes(type*{type : type}), FUNCS $funcsxv(externval*{externval : externval}) :: (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat}, GLOBALS $globalsxv(externval*{externval : externval}), TABLES [], MEMS [], ELEMS [], DATAS [], EXPORTS []})
+    -- if (moduleinst_0 = {TYPES $alloctypes(type*{type : type}), FUNCS $funcsxa(externaddr*{externaddr : externaddr}) :: (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat}, GLOBALS $globalsxa(externaddr*{externaddr : externaddr}), TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], EXPORTS []})
     -- if (z = `%;%`_state(s, {LOCALS [], MODULE moduleinst_0}))
     -- if ((z', val_G*{val_G : val}) = $evalglobals(z, globaltype*{globaltype : globaltype}, expr_G*{expr_G : expr}))
     -- (Eval_expr: `%;%~>*%;%`(z', expr_T, z', [(ref_T : ref <: val)]))*{expr_T : expr, ref_T : ref}
     -- (Eval_expr: `%;%~>*%;%`(z', expr_E, z', [(ref_E : ref <: val)]))*{expr_E : expr, ref_E : ref}*{expr_E : expr, ref_E : ref}
-    -- if ((s', moduleinst) = $allocmodule(s, module, externval*{externval : externval}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}))
+    -- if ((s', moduleinst) = $allocmodule(s, module, externaddr*{externaddr : externaddr}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}))
     -- if (f = {LOCALS [], MODULE moduleinst})
     -- if (instr_E*{instr_E : instr} = $concat_(syntax instr, $runelem_(`%`_elemidx(i_E), elem*{elem : elem}[i_E])^(i_E<|elem*{elem : elem}|){i_E : nat}))
     -- if (instr_D*{instr_D : instr} = $concat_(syntax instr, $rundata_(`%`_dataidx(i_D), data*{data : data}[i_D])^(i_D<|data*{data : data}|){i_D : nat}))
@@ -6394,7 +6709,7 @@ def $invoke(store : store, funcaddr : funcaddr, val*) : config
   def $invoke{s : store, funcaddr : funcaddr, val* : val*, f : frame, t_1* : valtype*, t_2* : valtype*}(s, funcaddr, val*{val : val}) = `%;%`_config(`%;%`_state(s, f), (val : val <: instr)*{val : val} :: [REF.FUNC_ADDR_instr(funcaddr) CALL_REF_instr((s.FUNCS_store[funcaddr].TYPE_funcinst : deftype <: typeuse))])
     -- Expand: `%~~%`(s.FUNCS_store[funcaddr].TYPE_funcinst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
     -- (Val_type: `%|-%:%`(s, val, t_1))*{t_1 : valtype, val : val}
-    -- if (f = {LOCALS [], MODULE {TYPES [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], EXPORTS []}})
+    -- if (f = {LOCALS [], MODULE {TYPES [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], EXPORTS []}})
 
 ;; A-binary.watsup
 grammar Bbyte : byte
@@ -6497,6 +6812,11 @@ grammar Bmemidx : memidx
   ;; A-binary.watsup
   prod{x : idx} x:Bu32 => x
 
+;; A-binary.watsup
+grammar Btagidx : tagidx
+  ;; A-binary.watsup
+  prod{x : idx} x:Bu32 => x
+
 ;; A-binary.watsup
 grammar Belemidx : elemidx
   ;; A-binary.watsup
@@ -6527,6 +6847,8 @@ grammar Bexternidx : externidx
   prod{x : idx} {0x02 x:Bmemidx} => MEM_externidx(x)
   ;; A-binary.watsup
   prod{x : idx} {0x03 x:Bglobalidx} => GLOBAL_externidx(x)
+  ;; A-binary.watsup
+  prod{x : idx} {0x04 x:Btagidx} => TAG_externidx(x)
 
 ;; A-binary.watsup
 grammar Bnumtype : numtype
@@ -6546,6 +6868,8 @@ grammar Bvectype : vectype
 
 ;; A-binary.watsup
 grammar Babsheaptype : heaptype
+  ;; A-binary.watsup
+  prod 0x69 => EXN_heaptype
   ;; A-binary.watsup
   prod 0x6A => ARRAY_heaptype
   ;; A-binary.watsup
@@ -6566,6 +6890,8 @@ grammar Babsheaptype : heaptype
   prod 0x72 => NOEXTERN_heaptype
   ;; A-binary.watsup
   prod 0x73 => NOFUNC_heaptype
+  ;; A-binary.watsup
+  prod 0x74 => NOEXN_heaptype
 
 ;; A-binary.watsup
 grammar Bheaptype : heaptype
@@ -6671,6 +6997,11 @@ grammar Bmemtype : memtype
   ;; A-binary.watsup
   prod{lim : limits} lim:Blimits => `%PAGE`_memtype(lim)
 
+;; A-binary.watsup
+grammar Btagtype : typeidx
+  ;; A-binary.watsup
+  prod{x : idx} {0x00 x:Btypeidx} => x
+
 ;; A-binary.watsup
 grammar Bexterntype : externtype
   ;; A-binary.watsup
@@ -6681,6 +7012,8 @@ grammar Bexterntype : externtype
   prod{mt : memtype} {0x02 mt:Bmemtype} => MEM_externtype(mt)
   ;; A-binary.watsup
   prod{gt : globaltype} {0x03 gt:Bglobaltype} => GLOBAL_externtype(gt)
+  ;; A-binary.watsup
+  prod{x : idx} {0x04 x:Btagtype} => TAG_externtype(($idx(x) : typevar <: typeuse))
 
 ;; A-binary.watsup
 grammar Bblocktype : blocktype
@@ -6692,6 +7025,17 @@ grammar Bblocktype : blocktype
   prod{i : nat} `%`_s33((i : nat <: int)):Bs33 => _IDX_blocktype(`%`_funcidx(i))
     -- if (i >= 0)
 
+;; A-binary.watsup
+grammar Bcatch : catch
+  ;; A-binary.watsup
+  prod{x : idx, l : labelidx} {0x00 x:Btagidx l:Blabelidx} => CATCH_catch(x, l)
+  ;; A-binary.watsup
+  prod{x : idx, l : labelidx} {0x01 x:Btagidx l:Blabelidx} => CATCH_REF_catch(x, l)
+  ;; A-binary.watsup
+  prod{l : labelidx} {0x02 l:Blabelidx} => CATCH_ALL_catch(l)
+  ;; A-binary.watsup
+  prod{l : labelidx} {0x03 l:Blabelidx} => CATCH_ALL_REF_catch(l)
+
 ;; A-binary.watsup
 syntax castop = (nul, nul)
 
@@ -6726,953 +7070,959 @@ grammar Blaneidx : laneidx
 ;; A-binary.watsup
 rec {
 
-;; A-binary.watsup:963.1-973.66
+;; A-binary.watsup:981.1-991.66
 grammar Binstr : instr
-  ;; A-binary.watsup:206.5-206.24
+  ;; A-binary.watsup:214.5-214.24
   prod 0x00 => UNREACHABLE_instr
-  ;; A-binary.watsup:207.5-207.16
+  ;; A-binary.watsup:215.5-215.16
   prod 0x01 => NOP_instr
-  ;; A-binary.watsup:208.5-208.57
+  ;; A-binary.watsup:216.5-216.57
   prod{bt : blocktype, in* : instr*} {0x02 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => BLOCK_instr(bt, in*{in : instr})
-  ;; A-binary.watsup:209.5-209.56
+  ;; A-binary.watsup:217.5-217.56
   prod{bt : blocktype, in* : instr*} {0x03 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => LOOP_instr(bt, in*{in : instr})
-  ;; A-binary.watsup:210.5-210.63
+  ;; A-binary.watsup:218.5-218.63
   prod{bt : blocktype, in* : instr*} {0x04 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => `IF%%ELSE%`_instr(bt, in*{in : instr}, [])
-  ;; A-binary.watsup:211.5-215.55
+  ;; A-binary.watsup:219.5-223.55
   prod{bt : blocktype, in_1* : instr*, in_2* : instr*} {0x04 bt:Bblocktype in_1:Binstr*{in_1 : instr} 0x05 in_2:Binstr*{in_2 : instr} 0x0B} => `IF%%ELSE%`_instr(bt, in_1*{in_1 : instr}, in_2*{in_2 : instr})
-  ;; A-binary.watsup:216.5-216.29
+  ;; A-binary.watsup:224.5-224.30
+  prod{x : idx} {0x08 x:Btagidx} => THROW_instr(x)
+  ;; A-binary.watsup:225.5-225.22
+  prod 0x0A => THROW_REF_instr
+  ;; A-binary.watsup:226.5-226.29
   prod{l : labelidx} {0x0C l:Blabelidx} => BR_instr(l)
-  ;; A-binary.watsup:217.5-217.32
+  ;; A-binary.watsup:227.5-227.32
   prod{l : labelidx} {0x0D l:Blabelidx} => BR_IF_instr(l)
-  ;; A-binary.watsup:218.5-218.62
+  ;; A-binary.watsup:228.5-228.62
   prod{l* : labelidx*, l_n : labelidx} {0x0E l*{l : labelidx}:Blist(syntax labelidx, grammar Blabelidx) l_n:Blabelidx} => BR_TABLE_instr(l*{l : labelidx}, l_n)
-  ;; A-binary.watsup:219.5-219.19
+  ;; A-binary.watsup:229.5-229.19
   prod 0x0F => RETURN_instr
-  ;; A-binary.watsup:220.5-220.30
+  ;; A-binary.watsup:230.5-230.30
   prod{x : idx} {0x10 x:Bfuncidx} => CALL_instr(x)
-  ;; A-binary.watsup:221.5-221.59
+  ;; A-binary.watsup:231.5-231.59
   prod{y : idx, x : idx} {0x11 y:Btypeidx x:Btableidx} => CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse))
-  ;; A-binary.watsup:222.5-222.37
+  ;; A-binary.watsup:232.5-232.37
   prod{x : idx} {0x12 x:Bfuncidx} => RETURN_CALL_instr(x)
-  ;; A-binary.watsup:223.5-223.66
+  ;; A-binary.watsup:233.5-233.66
   prod{y : idx, x : idx} {0x13 y:Btypeidx x:Btableidx} => RETURN_CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse))
-  ;; A-binary.watsup:238.5-238.37
+  ;; A-binary.watsup:234.5-235.26
+  prod{bt : blocktype, c* : catch*, in* : instr*} {0x1F bt:Bblocktype c*{c : catch}:Blist(syntax catch, grammar Bcatch) in:Binstr*{in : instr} 0x0B} => TRY_TABLE_instr(bt, `%`_list(c*{c : catch}), in*{in : instr})
+  ;; A-binary.watsup:256.5-256.37
   prod{ht : heaptype} {0xD0 ht:Bheaptype} => REF.NULL_instr(ht)
-  ;; A-binary.watsup:239.5-239.24
+  ;; A-binary.watsup:257.5-257.24
   prod 0xD1 => REF.IS_NULL_instr
-  ;; A-binary.watsup:240.5-240.34
+  ;; A-binary.watsup:258.5-258.34
   prod{x : idx} {0xD2 x:Bfuncidx} => REF.FUNC_instr(x)
-  ;; A-binary.watsup:241.5-241.19
+  ;; A-binary.watsup:259.5-259.19
   prod 0xD3 => REF.EQ_instr
-  ;; A-binary.watsup:242.5-242.28
+  ;; A-binary.watsup:260.5-260.28
   prod 0xD4 => REF.AS_NON_NULL_instr
-  ;; A-binary.watsup:243.5-243.37
+  ;; A-binary.watsup:261.5-261.37
   prod{l : labelidx} {0xD5 l:Blabelidx} => BR_ON_NULL_instr(l)
-  ;; A-binary.watsup:244.5-244.41
+  ;; A-binary.watsup:262.5-262.41
   prod{l : labelidx} {0xD6 l:Blabelidx} => BR_ON_NON_NULL_instr(l)
-  ;; A-binary.watsup:248.5-248.43
+  ;; A-binary.watsup:266.5-266.43
   prod{x : idx} {0xFB `%`_u32(0):Bu32 x:Btypeidx} => STRUCT.NEW_instr(x)
-  ;; A-binary.watsup:249.5-249.51
+  ;; A-binary.watsup:267.5-267.51
   prod{x : idx} {0xFB `%`_u32(1):Bu32 x:Btypeidx} => STRUCT.NEW_DEFAULT_instr(x)
-  ;; A-binary.watsup:250.5-250.52
+  ;; A-binary.watsup:268.5-268.52
   prod{x : idx, i : nat} {0xFB `%`_u32(2):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(), x, `%`_u32(i))
-  ;; A-binary.watsup:251.5-251.54
+  ;; A-binary.watsup:269.5-269.54
   prod{x : idx, i : nat} {0xFB `%`_u32(3):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(S_sx), x, `%`_u32(i))
-  ;; A-binary.watsup:252.5-252.54
+  ;; A-binary.watsup:270.5-270.54
   prod{x : idx, i : nat} {0xFB `%`_u32(4):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(U_sx), x, `%`_u32(i))
-  ;; A-binary.watsup:253.5-253.52
+  ;; A-binary.watsup:271.5-271.52
   prod{x : idx, i : nat} {0xFB `%`_u32(5):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.SET_instr(x, `%`_u32(i))
-  ;; A-binary.watsup:257.5-257.42
+  ;; A-binary.watsup:275.5-275.42
   prod{x : idx} {0xFB `%`_u32(6):Bu32 x:Btypeidx} => ARRAY.NEW_instr(x)
-  ;; A-binary.watsup:258.5-258.50
+  ;; A-binary.watsup:276.5-276.50
   prod{x : idx} {0xFB `%`_u32(7):Bu32 x:Btypeidx} => ARRAY.NEW_DEFAULT_instr(x)
-  ;; A-binary.watsup:259.5-259.57
+  ;; A-binary.watsup:277.5-277.57
   prod{x : idx, n : n} {0xFB `%`_u32(8):Bu32 x:Btypeidx `%`_u32(n):Bu32} => ARRAY.NEW_FIXED_instr(x, `%`_u32(n))
-  ;; A-binary.watsup:260.5-260.60
+  ;; A-binary.watsup:278.5-278.60
   prod{x : idx, y : idx} {0xFB `%`_u32(9):Bu32 x:Btypeidx y:Bdataidx} => ARRAY.NEW_DATA_instr(x, y)
-  ;; A-binary.watsup:261.5-261.61
+  ;; A-binary.watsup:279.5-279.61
   prod{x : idx, y : idx} {0xFB `%`_u32(10):Bu32 x:Btypeidx y:Belemidx} => ARRAY.NEW_ELEM_instr(x, y)
-  ;; A-binary.watsup:262.5-262.43
+  ;; A-binary.watsup:280.5-280.43
   prod{x : idx} {0xFB `%`_u32(11):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(), x)
-  ;; A-binary.watsup:263.5-263.45
+  ;; A-binary.watsup:281.5-281.45
   prod{x : idx} {0xFB `%`_u32(12):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(S_sx), x)
-  ;; A-binary.watsup:264.5-264.45
+  ;; A-binary.watsup:282.5-282.45
   prod{x : idx} {0xFB `%`_u32(13):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(U_sx), x)
-  ;; A-binary.watsup:265.5-265.43
+  ;; A-binary.watsup:283.5-283.43
   prod{x : idx} {0xFB `%`_u32(14):Bu32 x:Btypeidx} => ARRAY.SET_instr(x)
-  ;; A-binary.watsup:266.5-266.30
+  ;; A-binary.watsup:284.5-284.30
   prod {0xFB `%`_u32(15):Bu32} => ARRAY.LEN_instr
-  ;; A-binary.watsup:267.5-267.44
+  ;; A-binary.watsup:285.5-285.44
   prod{x : idx} {0xFB `%`_u32(16):Bu32 x:Btypeidx} => ARRAY.FILL_instr(x)
-  ;; A-binary.watsup:268.5-268.65
+  ;; A-binary.watsup:286.5-286.65
   prod{x_1 : idx, x_2 : idx} {0xFB `%`_u32(17):Bu32 x_1:Btypeidx x_2:Btypeidx} => ARRAY.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:269.5-269.62
+  ;; A-binary.watsup:287.5-287.62
   prod{x : idx, y : idx} {0xFB `%`_u32(18):Bu32 x:Btypeidx y:Bdataidx} => ARRAY.INIT_DATA_instr(x, y)
-  ;; A-binary.watsup:270.5-270.62
+  ;; A-binary.watsup:288.5-288.62
   prod{x : idx, y : idx} {0xFB `%`_u32(19):Bu32 x:Btypeidx y:Belemidx} => ARRAY.INIT_ELEM_instr(x, y)
-  ;; A-binary.watsup:274.5-274.51
+  ;; A-binary.watsup:292.5-292.51
   prod{ht : heaptype} {0xFB `%`_u32(20):Bu32 ht:Bheaptype} => REF.TEST_instr(REF_reftype(`NULL%?`_nul(?()), ht))
-  ;; A-binary.watsup:275.5-275.56
+  ;; A-binary.watsup:293.5-293.56
   prod{ht : heaptype} {0xFB `%`_u32(21):Bu32 ht:Bheaptype} => REF.TEST_instr(REF_reftype(`NULL%?`_nul(?(())), ht))
-  ;; A-binary.watsup:276.5-276.51
+  ;; A-binary.watsup:294.5-294.51
   prod{ht : heaptype} {0xFB `%`_u32(22):Bu32 ht:Bheaptype} => REF.CAST_instr(REF_reftype(`NULL%?`_nul(?()), ht))
-  ;; A-binary.watsup:277.5-277.56
+  ;; A-binary.watsup:295.5-295.56
   prod{ht : heaptype} {0xFB `%`_u32(23):Bu32 ht:Bheaptype} => REF.CAST_instr(REF_reftype(`NULL%?`_nul(?(())), ht))
-  ;; A-binary.watsup:278.5-282.94
+  ;; A-binary.watsup:296.5-300.94
   prod{nul1 : nul1, nul2 : nul2, l : labelidx, ht_1 : heaptype, ht_2 : heaptype} {0xFB `%`_u32(24):Bu32 (nul1, nul2):Bcastop l:Blabelidx ht_1:Bheaptype ht_2:Bheaptype} => BR_ON_CAST_instr(l, REF_reftype(nul1, ht_1), REF_reftype(nul2, ht_2))
-  ;; A-binary.watsup:283.5-287.99
+  ;; A-binary.watsup:301.5-305.99
   prod{nul1 : nul1, nul2 : nul2, l : labelidx, ht_1 : heaptype, ht_2 : heaptype} {0xFB `%`_u32(25):Bu32 (nul1, nul2):Bcastop l:Blabelidx ht_1:Bheaptype ht_2:Bheaptype} => BR_ON_CAST_FAIL_instr(l, REF_reftype(nul1, ht_1), REF_reftype(nul2, ht_2))
-  ;; A-binary.watsup:291.5-291.39
+  ;; A-binary.watsup:309.5-309.39
   prod {0xFB `%`_u32(26):Bu32} => ANY.CONVERT_EXTERN_instr
-  ;; A-binary.watsup:292.5-292.39
+  ;; A-binary.watsup:310.5-310.39
   prod {0xFB `%`_u32(27):Bu32} => EXTERN.CONVERT_ANY_instr
-  ;; A-binary.watsup:296.5-296.28
+  ;; A-binary.watsup:314.5-314.28
   prod {0xFB `%`_u32(28):Bu32} => REF.I31_instr
-  ;; A-binary.watsup:297.5-297.30
+  ;; A-binary.watsup:315.5-315.30
   prod {0xFB `%`_u32(29):Bu32} => I31.GET_instr(S_sx)
-  ;; A-binary.watsup:298.5-298.30
+  ;; A-binary.watsup:316.5-316.30
   prod {0xFB `%`_u32(30):Bu32} => I31.GET_instr(U_sx)
-  ;; A-binary.watsup:305.5-305.17
+  ;; A-binary.watsup:323.5-323.17
   prod 0x1A => DROP_instr
-  ;; A-binary.watsup:306.5-306.19
+  ;; A-binary.watsup:324.5-324.19
   prod 0x1B => `SELECT()%?`_instr(?())
-  ;; A-binary.watsup:307.5-307.41
+  ;; A-binary.watsup:325.5-325.41
   prod{ts : valtype} {0x1C [ts]:Blist(syntax valtype, grammar Bvaltype)} => `SELECT()%?`_instr(?([ts]))
-  ;; A-binary.watsup:314.5-314.36
+  ;; A-binary.watsup:332.5-332.36
   prod{x : idx} {0x20 x:Blocalidx} => LOCAL.GET_instr(x)
-  ;; A-binary.watsup:315.5-315.36
+  ;; A-binary.watsup:333.5-333.36
   prod{x : idx} {0x21 x:Blocalidx} => LOCAL.SET_instr(x)
-  ;; A-binary.watsup:316.5-316.36
+  ;; A-binary.watsup:334.5-334.36
   prod{x : idx} {0x22 x:Blocalidx} => LOCAL.TEE_instr(x)
-  ;; A-binary.watsup:320.5-320.38
+  ;; A-binary.watsup:338.5-338.38
   prod{x : idx} {0x23 x:Bglobalidx} => GLOBAL.GET_instr(x)
-  ;; A-binary.watsup:321.5-321.38
+  ;; A-binary.watsup:339.5-339.38
   prod{x : idx} {0x24 x:Bglobalidx} => GLOBAL.SET_instr(x)
-  ;; A-binary.watsup:328.5-328.36
+  ;; A-binary.watsup:346.5-346.36
   prod{x : idx} {0x25 x:Btableidx} => TABLE.GET_instr(x)
-  ;; A-binary.watsup:329.5-329.36
+  ;; A-binary.watsup:347.5-347.36
   prod{x : idx} {0x26 x:Btableidx} => TABLE.SET_instr(x)
-  ;; A-binary.watsup:330.5-330.58
+  ;; A-binary.watsup:348.5-348.58
   prod{y : idx, x : idx} {0xFC `%`_u32(12):Bu32 y:Belemidx x:Btableidx} => TABLE.INIT_instr(x, y)
-  ;; A-binary.watsup:331.5-331.43
+  ;; A-binary.watsup:349.5-349.43
   prod{x : idx} {0xFC `%`_u32(13):Bu32 x:Belemidx} => ELEM.DROP_instr(x)
-  ;; A-binary.watsup:332.5-332.67
+  ;; A-binary.watsup:350.5-350.67
   prod{x_1 : idx, x_2 : idx} {0xFC `%`_u32(14):Bu32 x_1:Btableidx x_2:Btableidx} => TABLE.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:333.5-333.45
+  ;; A-binary.watsup:351.5-351.45
   prod{x : idx} {0xFC `%`_u32(15):Bu32 x:Btableidx} => TABLE.GROW_instr(x)
-  ;; A-binary.watsup:334.5-334.45
+  ;; A-binary.watsup:352.5-352.45
   prod{x : idx} {0xFC `%`_u32(16):Bu32 x:Btableidx} => TABLE.SIZE_instr(x)
-  ;; A-binary.watsup:335.5-335.45
+  ;; A-binary.watsup:353.5-353.45
   prod{x : idx} {0xFC `%`_u32(17):Bu32 x:Btableidx} => TABLE.FILL_instr(x)
-  ;; A-binary.watsup:348.5-348.41
+  ;; A-binary.watsup:366.5-366.41
   prod{x : idx, ao : memarg} {0x28 (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:349.5-349.41
+  ;; A-binary.watsup:367.5-367.41
   prod{x : idx, ao : memarg} {0x29 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:350.5-350.41
+  ;; A-binary.watsup:368.5-368.41
   prod{x : idx, ao : memarg} {0x2A (x, ao):Bmemarg} => LOAD_instr(F32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:351.5-351.41
+  ;; A-binary.watsup:369.5-369.41
   prod{x : idx, ao : memarg} {0x2B (x, ao):Bmemarg} => LOAD_instr(F64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:352.5-352.48
+  ;; A-binary.watsup:370.5-370.48
   prod{x : idx, ao : memarg} {0x2C (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(8), S_sx)), x, ao)
-  ;; A-binary.watsup:353.5-353.48
+  ;; A-binary.watsup:371.5-371.48
   prod{x : idx, ao : memarg} {0x2D (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(8), U_sx)), x, ao)
-  ;; A-binary.watsup:354.5-354.49
+  ;; A-binary.watsup:372.5-372.49
   prod{x : idx, ao : memarg} {0x2E (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(16), S_sx)), x, ao)
-  ;; A-binary.watsup:355.5-355.49
+  ;; A-binary.watsup:373.5-373.49
   prod{x : idx, ao : memarg} {0x2F (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(16), U_sx)), x, ao)
-  ;; A-binary.watsup:356.5-356.48
+  ;; A-binary.watsup:374.5-374.48
   prod{x : idx, ao : memarg} {0x30 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(8), S_sx)), x, ao)
-  ;; A-binary.watsup:357.5-357.48
+  ;; A-binary.watsup:375.5-375.48
   prod{x : idx, ao : memarg} {0x31 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(8), U_sx)), x, ao)
-  ;; A-binary.watsup:358.5-358.49
+  ;; A-binary.watsup:376.5-376.49
   prod{x : idx, ao : memarg} {0x32 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(16), S_sx)), x, ao)
-  ;; A-binary.watsup:359.5-359.49
+  ;; A-binary.watsup:377.5-377.49
   prod{x : idx, ao : memarg} {0x33 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(16), U_sx)), x, ao)
-  ;; A-binary.watsup:360.5-360.49
+  ;; A-binary.watsup:378.5-378.49
   prod{x : idx, ao : memarg} {0x34 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(32), S_sx)), x, ao)
-  ;; A-binary.watsup:361.5-361.49
+  ;; A-binary.watsup:379.5-379.49
   prod{x : idx, ao : memarg} {0x35 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(32), U_sx)), x, ao)
-  ;; A-binary.watsup:362.5-362.42
+  ;; A-binary.watsup:380.5-380.42
   prod{x : idx, ao : memarg} {0x36 (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:363.5-363.42
+  ;; A-binary.watsup:381.5-381.42
   prod{x : idx, ao : memarg} {0x37 (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:364.5-364.42
+  ;; A-binary.watsup:382.5-382.42
   prod{x : idx, ao : memarg} {0x38 (x, ao):Bmemarg} => STORE_instr(F32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:365.5-365.42
+  ;; A-binary.watsup:383.5-383.42
   prod{x : idx, ao : memarg} {0x39 (x, ao):Bmemarg} => STORE_instr(F64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:366.5-366.45
+  ;; A-binary.watsup:384.5-384.45
   prod{x : idx, ao : memarg} {0x3A (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(`%`_sz(8)), x, ao)
-  ;; A-binary.watsup:367.5-367.46
+  ;; A-binary.watsup:385.5-385.46
   prod{x : idx, ao : memarg} {0x3B (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(`%`_sz(16)), x, ao)
-  ;; A-binary.watsup:368.5-368.45
+  ;; A-binary.watsup:386.5-386.45
   prod{x : idx, ao : memarg} {0x3C (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(8)), x, ao)
-  ;; A-binary.watsup:369.5-369.46
+  ;; A-binary.watsup:387.5-387.46
   prod{x : idx, ao : memarg} {0x3D (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(16)), x, ao)
-  ;; A-binary.watsup:370.5-370.46
+  ;; A-binary.watsup:388.5-388.46
   prod{x : idx, ao : memarg} {0x3E (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(32)), x, ao)
-  ;; A-binary.watsup:371.5-371.36
+  ;; A-binary.watsup:389.5-389.36
   prod{x : idx} {0x3F x:Bmemidx} => MEMORY.SIZE_instr(x)
-  ;; A-binary.watsup:372.5-372.36
+  ;; A-binary.watsup:390.5-390.36
   prod{x : idx} {0x40 x:Bmemidx} => MEMORY.GROW_instr(x)
-  ;; A-binary.watsup:373.5-373.56
+  ;; A-binary.watsup:391.5-391.56
   prod{y : idx, x : idx} {0xFC `%`_u32(8):Bu32 y:Bdataidx x:Bmemidx} => MEMORY.INIT_instr(x, y)
-  ;; A-binary.watsup:374.5-374.42
+  ;; A-binary.watsup:392.5-392.42
   prod{x : idx} {0xFC `%`_u32(9):Bu32 x:Bdataidx} => DATA.DROP_instr(x)
-  ;; A-binary.watsup:375.5-375.64
+  ;; A-binary.watsup:393.5-393.64
   prod{x_1 : idx, x_2 : idx} {0xFC `%`_u32(10):Bu32 x_1:Bmemidx x_2:Bmemidx} => MEMORY.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:376.5-376.44
+  ;; A-binary.watsup:394.5-394.44
   prod{x : idx} {0xFC `%`_u32(11):Bu32 x:Bmemidx} => MEMORY.FILL_instr(x)
-  ;; A-binary.watsup:384.5-384.31
+  ;; A-binary.watsup:402.5-402.31
   prod{n : n} {0x41 `%`_u32(n):Bu32} => CONST_instr(I32_numtype, `%`_num_(n))
-  ;; A-binary.watsup:385.5-385.31
+  ;; A-binary.watsup:403.5-403.31
   prod{n : n} {0x42 `%`_u64(n):Bu64} => CONST_instr(I64_numtype, `%`_num_(n))
-  ;; A-binary.watsup:386.5-386.31
+  ;; A-binary.watsup:404.5-404.31
   prod{p : f32} {0x43 p:Bf32} => CONST_instr(F32_numtype, p)
-  ;; A-binary.watsup:387.5-387.31
+  ;; A-binary.watsup:405.5-405.31
   prod{p : f64} {0x44 p:Bf64} => CONST_instr(F64_numtype, p)
-  ;; A-binary.watsup:391.5-391.27
+  ;; A-binary.watsup:409.5-409.27
   prod 0x45 => TESTOP_instr(I32_numtype, EQZ_testop_)
-  ;; A-binary.watsup:395.5-395.25
+  ;; A-binary.watsup:413.5-413.25
   prod 0x46 => RELOP_instr(I32_numtype, EQ_relop_)
-  ;; A-binary.watsup:396.5-396.25
+  ;; A-binary.watsup:414.5-414.25
   prod 0x47 => RELOP_instr(I32_numtype, NE_relop_)
-  ;; A-binary.watsup:397.5-397.29
+  ;; A-binary.watsup:415.5-415.29
   prod 0x48 => RELOP_instr(I32_numtype, LT_relop_(S_sx))
-  ;; A-binary.watsup:398.5-398.29
+  ;; A-binary.watsup:416.5-416.29
   prod 0x49 => RELOP_instr(I32_numtype, LT_relop_(U_sx))
-  ;; A-binary.watsup:399.5-399.29
+  ;; A-binary.watsup:417.5-417.29
   prod 0x4A => RELOP_instr(I32_numtype, GT_relop_(S_sx))
-  ;; A-binary.watsup:400.5-400.29
+  ;; A-binary.watsup:418.5-418.29
   prod 0x4B => RELOP_instr(I32_numtype, GT_relop_(U_sx))
-  ;; A-binary.watsup:401.5-401.29
+  ;; A-binary.watsup:419.5-419.29
   prod 0x4C => RELOP_instr(I32_numtype, LE_relop_(S_sx))
-  ;; A-binary.watsup:402.5-402.29
+  ;; A-binary.watsup:420.5-420.29
   prod 0x4D => RELOP_instr(I32_numtype, LE_relop_(U_sx))
-  ;; A-binary.watsup:403.5-403.29
+  ;; A-binary.watsup:421.5-421.29
   prod 0x4E => RELOP_instr(I32_numtype, GE_relop_(S_sx))
-  ;; A-binary.watsup:404.5-404.29
+  ;; A-binary.watsup:422.5-422.29
   prod 0x4F => RELOP_instr(I32_numtype, GE_relop_(U_sx))
-  ;; A-binary.watsup:408.5-408.27
+  ;; A-binary.watsup:426.5-426.27
   prod 0x50 => TESTOP_instr(I64_numtype, EQZ_testop_)
-  ;; A-binary.watsup:412.5-412.25
+  ;; A-binary.watsup:430.5-430.25
   prod 0x51 => RELOP_instr(I64_numtype, EQ_relop_)
-  ;; A-binary.watsup:413.5-413.25
+  ;; A-binary.watsup:431.5-431.25
   prod 0x52 => RELOP_instr(I64_numtype, NE_relop_)
-  ;; A-binary.watsup:414.5-414.29
+  ;; A-binary.watsup:432.5-432.29
   prod 0x53 => RELOP_instr(I64_numtype, LT_relop_(S_sx))
-  ;; A-binary.watsup:415.5-415.29
+  ;; A-binary.watsup:433.5-433.29
   prod 0x54 => RELOP_instr(I64_numtype, LT_relop_(U_sx))
-  ;; A-binary.watsup:416.5-416.29
+  ;; A-binary.watsup:434.5-434.29
   prod 0x55 => RELOP_instr(I64_numtype, GT_relop_(S_sx))
-  ;; A-binary.watsup:417.5-417.29
+  ;; A-binary.watsup:435.5-435.29
   prod 0x56 => RELOP_instr(I64_numtype, GT_relop_(U_sx))
-  ;; A-binary.watsup:418.5-418.29
+  ;; A-binary.watsup:436.5-436.29
   prod 0x57 => RELOP_instr(I64_numtype, LE_relop_(S_sx))
-  ;; A-binary.watsup:419.5-419.29
+  ;; A-binary.watsup:437.5-437.29
   prod 0x58 => RELOP_instr(I64_numtype, LE_relop_(U_sx))
-  ;; A-binary.watsup:420.5-420.29
+  ;; A-binary.watsup:438.5-438.29
   prod 0x59 => RELOP_instr(I64_numtype, GE_relop_(S_sx))
-  ;; A-binary.watsup:421.5-421.29
+  ;; A-binary.watsup:439.5-439.29
   prod 0x5A => RELOP_instr(I64_numtype, GE_relop_(U_sx))
-  ;; A-binary.watsup:425.5-425.25
+  ;; A-binary.watsup:443.5-443.25
   prod 0x5B => RELOP_instr(F32_numtype, EQ_relop_)
-  ;; A-binary.watsup:426.5-426.25
+  ;; A-binary.watsup:444.5-444.25
   prod 0x5C => RELOP_instr(F32_numtype, NE_relop_)
-  ;; A-binary.watsup:427.5-427.25
+  ;; A-binary.watsup:445.5-445.25
   prod 0x5D => RELOP_instr(F32_numtype, LT_relop_)
-  ;; A-binary.watsup:428.5-428.25
+  ;; A-binary.watsup:446.5-446.25
   prod 0x5E => RELOP_instr(F32_numtype, GT_relop_)
-  ;; A-binary.watsup:429.5-429.25
+  ;; A-binary.watsup:447.5-447.25
   prod 0x5F => RELOP_instr(F32_numtype, LE_relop_)
-  ;; A-binary.watsup:430.5-430.25
+  ;; A-binary.watsup:448.5-448.25
   prod 0x60 => RELOP_instr(F32_numtype, GE_relop_)
-  ;; A-binary.watsup:434.5-434.25
+  ;; A-binary.watsup:452.5-452.25
   prod 0x61 => RELOP_instr(F64_numtype, EQ_relop_)
-  ;; A-binary.watsup:435.5-435.25
+  ;; A-binary.watsup:453.5-453.25
   prod 0x62 => RELOP_instr(F64_numtype, NE_relop_)
-  ;; A-binary.watsup:436.5-436.25
+  ;; A-binary.watsup:454.5-454.25
   prod 0x63 => RELOP_instr(F64_numtype, LT_relop_)
-  ;; A-binary.watsup:437.5-437.25
+  ;; A-binary.watsup:455.5-455.25
   prod 0x64 => RELOP_instr(F64_numtype, GT_relop_)
-  ;; A-binary.watsup:438.5-438.25
+  ;; A-binary.watsup:456.5-456.25
   prod 0x65 => RELOP_instr(F64_numtype, LE_relop_)
-  ;; A-binary.watsup:439.5-439.25
+  ;; A-binary.watsup:457.5-457.25
   prod 0x66 => RELOP_instr(F64_numtype, GE_relop_)
-  ;; A-binary.watsup:443.5-443.25
+  ;; A-binary.watsup:461.5-461.25
   prod 0x67 => UNOP_instr(I32_numtype, CLZ_unop_)
-  ;; A-binary.watsup:444.5-444.25
+  ;; A-binary.watsup:462.5-462.25
   prod 0x68 => UNOP_instr(I32_numtype, CTZ_unop_)
-  ;; A-binary.watsup:445.5-445.28
+  ;; A-binary.watsup:463.5-463.28
   prod 0x69 => UNOP_instr(I32_numtype, POPCNT_unop_)
-  ;; A-binary.watsup:449.5-449.26
+  ;; A-binary.watsup:467.5-467.26
   prod 0x6A => BINOP_instr(I32_numtype, ADD_binop_)
-  ;; A-binary.watsup:450.5-450.26
+  ;; A-binary.watsup:468.5-468.26
   prod 0x6B => BINOP_instr(I32_numtype, SUB_binop_)
-  ;; A-binary.watsup:451.5-451.26
+  ;; A-binary.watsup:469.5-469.26
   prod 0x6C => BINOP_instr(I32_numtype, MUL_binop_)
-  ;; A-binary.watsup:452.5-452.30
+  ;; A-binary.watsup:470.5-470.30
   prod 0x6D => BINOP_instr(I32_numtype, DIV_binop_(S_sx))
-  ;; A-binary.watsup:453.5-453.30
+  ;; A-binary.watsup:471.5-471.30
   prod 0x6E => BINOP_instr(I32_numtype, DIV_binop_(U_sx))
-  ;; A-binary.watsup:454.5-454.30
+  ;; A-binary.watsup:472.5-472.30
   prod 0x6F => BINOP_instr(I32_numtype, REM_binop_(S_sx))
-  ;; A-binary.watsup:455.5-455.30
+  ;; A-binary.watsup:473.5-473.30
   prod 0x70 => BINOP_instr(I32_numtype, REM_binop_(U_sx))
-  ;; A-binary.watsup:456.5-456.26
+  ;; A-binary.watsup:474.5-474.26
   prod 0x71 => BINOP_instr(I32_numtype, AND_binop_)
-  ;; A-binary.watsup:457.5-457.25
+  ;; A-binary.watsup:475.5-475.25
   prod 0x72 => BINOP_instr(I32_numtype, OR_binop_)
-  ;; A-binary.watsup:458.5-458.26
+  ;; A-binary.watsup:476.5-476.26
   prod 0x73 => BINOP_instr(I32_numtype, XOR_binop_)
-  ;; A-binary.watsup:459.5-459.26
+  ;; A-binary.watsup:477.5-477.26
   prod 0x74 => BINOP_instr(I32_numtype, SHL_binop_)
-  ;; A-binary.watsup:460.5-460.30
+  ;; A-binary.watsup:478.5-478.30
   prod 0x75 => BINOP_instr(I32_numtype, SHR_binop_(S_sx))
-  ;; A-binary.watsup:461.5-461.30
+  ;; A-binary.watsup:479.5-479.30
   prod 0x76 => BINOP_instr(I32_numtype, SHR_binop_(U_sx))
-  ;; A-binary.watsup:462.5-462.27
+  ;; A-binary.watsup:480.5-480.27
   prod 0x77 => BINOP_instr(I32_numtype, ROTL_binop_)
-  ;; A-binary.watsup:463.5-463.27
+  ;; A-binary.watsup:481.5-481.27
   prod 0x78 => BINOP_instr(I32_numtype, ROTR_binop_)
-  ;; A-binary.watsup:467.5-467.25
+  ;; A-binary.watsup:485.5-485.25
   prod 0x79 => UNOP_instr(I64_numtype, CLZ_unop_)
-  ;; A-binary.watsup:468.5-468.25
+  ;; A-binary.watsup:486.5-486.25
   prod 0x7A => UNOP_instr(I64_numtype, CTZ_unop_)
-  ;; A-binary.watsup:469.5-469.28
+  ;; A-binary.watsup:487.5-487.28
   prod 0x7B => UNOP_instr(I64_numtype, POPCNT_unop_)
-  ;; A-binary.watsup:473.5-473.33
+  ;; A-binary.watsup:491.5-491.33
   prod 0xC0 => UNOP_instr(I32_numtype, EXTEND_unop_(`%`_sz(8)))
-  ;; A-binary.watsup:474.5-474.34
+  ;; A-binary.watsup:492.5-492.34
   prod 0xC1 => UNOP_instr(I32_numtype, EXTEND_unop_(`%`_sz(16)))
-  ;; A-binary.watsup:478.5-478.33
+  ;; A-binary.watsup:496.5-496.33
   prod 0xC2 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(8)))
-  ;; A-binary.watsup:479.5-479.34
+  ;; A-binary.watsup:497.5-497.34
   prod 0xC3 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(16)))
-  ;; A-binary.watsup:480.5-480.34
+  ;; A-binary.watsup:498.5-498.34
   prod 0xC4 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(32)))
-  ;; A-binary.watsup:484.5-484.26
+  ;; A-binary.watsup:502.5-502.26
   prod 0x7C => BINOP_instr(I64_numtype, ADD_binop_)
-  ;; A-binary.watsup:485.5-485.26
+  ;; A-binary.watsup:503.5-503.26
   prod 0x7D => BINOP_instr(I64_numtype, SUB_binop_)
-  ;; A-binary.watsup:486.5-486.26
+  ;; A-binary.watsup:504.5-504.26
   prod 0x7E => BINOP_instr(I64_numtype, MUL_binop_)
-  ;; A-binary.watsup:487.5-487.30
+  ;; A-binary.watsup:505.5-505.30
   prod 0x7F => BINOP_instr(I64_numtype, DIV_binop_(S_sx))
-  ;; A-binary.watsup:488.5-488.30
+  ;; A-binary.watsup:506.5-506.30
   prod 0x80 => BINOP_instr(I64_numtype, DIV_binop_(U_sx))
-  ;; A-binary.watsup:489.5-489.30
+  ;; A-binary.watsup:507.5-507.30
   prod 0x81 => BINOP_instr(I64_numtype, REM_binop_(S_sx))
-  ;; A-binary.watsup:490.5-490.30
+  ;; A-binary.watsup:508.5-508.30
   prod 0x82 => BINOP_instr(I64_numtype, REM_binop_(U_sx))
-  ;; A-binary.watsup:491.5-491.26
+  ;; A-binary.watsup:509.5-509.26
   prod 0x83 => BINOP_instr(I64_numtype, AND_binop_)
-  ;; A-binary.watsup:492.5-492.25
+  ;; A-binary.watsup:510.5-510.25
   prod 0x84 => BINOP_instr(I64_numtype, OR_binop_)
-  ;; A-binary.watsup:493.5-493.26
+  ;; A-binary.watsup:511.5-511.26
   prod 0x85 => BINOP_instr(I64_numtype, XOR_binop_)
-  ;; A-binary.watsup:494.5-494.26
+  ;; A-binary.watsup:512.5-512.26
   prod 0x86 => BINOP_instr(I64_numtype, SHL_binop_)
-  ;; A-binary.watsup:495.5-495.30
+  ;; A-binary.watsup:513.5-513.30
   prod 0x87 => BINOP_instr(I64_numtype, SHR_binop_(S_sx))
-  ;; A-binary.watsup:496.5-496.30
+  ;; A-binary.watsup:514.5-514.30
   prod 0x88 => BINOP_instr(I64_numtype, SHR_binop_(U_sx))
-  ;; A-binary.watsup:497.5-497.27
+  ;; A-binary.watsup:515.5-515.27
   prod 0x89 => BINOP_instr(I64_numtype, ROTL_binop_)
-  ;; A-binary.watsup:498.5-498.27
+  ;; A-binary.watsup:516.5-516.27
   prod 0x8A => BINOP_instr(I64_numtype, ROTR_binop_)
-  ;; A-binary.watsup:502.5-502.25
+  ;; A-binary.watsup:520.5-520.25
   prod 0x8B => UNOP_instr(F32_numtype, ABS_unop_)
-  ;; A-binary.watsup:503.5-503.25
+  ;; A-binary.watsup:521.5-521.25
   prod 0x8C => UNOP_instr(F32_numtype, NEG_unop_)
-  ;; A-binary.watsup:504.5-504.26
+  ;; A-binary.watsup:522.5-522.26
   prod 0x8D => UNOP_instr(F32_numtype, CEIL_unop_)
-  ;; A-binary.watsup:505.5-505.27
+  ;; A-binary.watsup:523.5-523.27
   prod 0x8E => UNOP_instr(F32_numtype, FLOOR_unop_)
-  ;; A-binary.watsup:506.5-506.27
+  ;; A-binary.watsup:524.5-524.27
   prod 0x8F => UNOP_instr(F32_numtype, TRUNC_unop_)
-  ;; A-binary.watsup:507.5-507.29
+  ;; A-binary.watsup:525.5-525.29
   prod 0x90 => UNOP_instr(F32_numtype, NEAREST_unop_)
-  ;; A-binary.watsup:508.5-508.26
+  ;; A-binary.watsup:526.5-526.26
   prod 0x91 => UNOP_instr(F32_numtype, SQRT_unop_)
-  ;; A-binary.watsup:512.5-512.26
+  ;; A-binary.watsup:530.5-530.26
   prod 0x92 => BINOP_instr(F32_numtype, ADD_binop_)
-  ;; A-binary.watsup:513.5-513.26
+  ;; A-binary.watsup:531.5-531.26
   prod 0x93 => BINOP_instr(F32_numtype, SUB_binop_)
-  ;; A-binary.watsup:514.5-514.26
+  ;; A-binary.watsup:532.5-532.26
   prod 0x94 => BINOP_instr(F32_numtype, MUL_binop_)
-  ;; A-binary.watsup:515.5-515.26
+  ;; A-binary.watsup:533.5-533.26
   prod 0x95 => BINOP_instr(F32_numtype, DIV_binop_)
-  ;; A-binary.watsup:516.5-516.26
+  ;; A-binary.watsup:534.5-534.26
   prod 0x96 => BINOP_instr(F32_numtype, MIN_binop_)
-  ;; A-binary.watsup:517.5-517.26
+  ;; A-binary.watsup:535.5-535.26
   prod 0x97 => BINOP_instr(F32_numtype, MAX_binop_)
-  ;; A-binary.watsup:518.5-518.31
+  ;; A-binary.watsup:536.5-536.31
   prod 0x98 => BINOP_instr(F32_numtype, COPYSIGN_binop_)
-  ;; A-binary.watsup:522.5-522.25
+  ;; A-binary.watsup:540.5-540.25
   prod 0x99 => UNOP_instr(F64_numtype, ABS_unop_)
-  ;; A-binary.watsup:523.5-523.25
+  ;; A-binary.watsup:541.5-541.25
   prod 0x9A => UNOP_instr(F64_numtype, NEG_unop_)
-  ;; A-binary.watsup:524.5-524.26
+  ;; A-binary.watsup:542.5-542.26
   prod 0x9B => UNOP_instr(F64_numtype, CEIL_unop_)
-  ;; A-binary.watsup:525.5-525.27
+  ;; A-binary.watsup:543.5-543.27
   prod 0x9C => UNOP_instr(F64_numtype, FLOOR_unop_)
-  ;; A-binary.watsup:526.5-526.27
+  ;; A-binary.watsup:544.5-544.27
   prod 0x9D => UNOP_instr(F64_numtype, TRUNC_unop_)
-  ;; A-binary.watsup:527.5-527.29
+  ;; A-binary.watsup:545.5-545.29
   prod 0x9E => UNOP_instr(F64_numtype, NEAREST_unop_)
-  ;; A-binary.watsup:528.5-528.26
+  ;; A-binary.watsup:546.5-546.26
   prod 0x9F => UNOP_instr(F64_numtype, SQRT_unop_)
-  ;; A-binary.watsup:532.5-532.26
+  ;; A-binary.watsup:550.5-550.26
   prod 0xA0 => BINOP_instr(F64_numtype, ADD_binop_)
-  ;; A-binary.watsup:533.5-533.26
+  ;; A-binary.watsup:551.5-551.26
   prod 0xA1 => BINOP_instr(F64_numtype, SUB_binop_)
-  ;; A-binary.watsup:534.5-534.26
+  ;; A-binary.watsup:552.5-552.26
   prod 0xA2 => BINOP_instr(F64_numtype, MUL_binop_)
-  ;; A-binary.watsup:535.5-535.26
+  ;; A-binary.watsup:553.5-553.26
   prod 0xA3 => BINOP_instr(F64_numtype, DIV_binop_)
-  ;; A-binary.watsup:536.5-536.26
+  ;; A-binary.watsup:554.5-554.26
   prod 0xA4 => BINOP_instr(F64_numtype, MIN_binop_)
-  ;; A-binary.watsup:537.5-537.26
+  ;; A-binary.watsup:555.5-555.26
   prod 0xA5 => BINOP_instr(F64_numtype, MAX_binop_)
-  ;; A-binary.watsup:538.5-538.31
+  ;; A-binary.watsup:556.5-556.31
   prod 0xA6 => BINOP_instr(F64_numtype, COPYSIGN_binop_)
-  ;; A-binary.watsup:543.5-543.31
+  ;; A-binary.watsup:561.5-561.31
   prod 0xA7 => CVTOP_instr(I32_numtype, I64_numtype, WRAP_cvtop__)
-  ;; A-binary.watsup:544.5-544.36
+  ;; A-binary.watsup:562.5-562.36
   prod 0xA8 => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:545.5-545.36
+  ;; A-binary.watsup:563.5-563.36
   prod 0xA9 => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:546.5-546.36
+  ;; A-binary.watsup:564.5-564.36
   prod 0xAA => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:547.5-547.36
+  ;; A-binary.watsup:565.5-565.36
   prod 0xAB => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:548.5-548.37
+  ;; A-binary.watsup:566.5-566.37
   prod 0xAC => CVTOP_instr(I64_numtype, I32_numtype, EXTEND_cvtop__(S_sx))
-  ;; A-binary.watsup:549.5-549.37
+  ;; A-binary.watsup:567.5-567.37
   prod 0xAD => CVTOP_instr(I64_numtype, I32_numtype, EXTEND_cvtop__(U_sx))
-  ;; A-binary.watsup:550.5-550.36
+  ;; A-binary.watsup:568.5-568.36
   prod 0xAE => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:551.5-551.36
+  ;; A-binary.watsup:569.5-569.36
   prod 0xAF => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:552.5-552.36
+  ;; A-binary.watsup:570.5-570.36
   prod 0xB0 => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:553.5-553.36
+  ;; A-binary.watsup:571.5-571.36
   prod 0xB1 => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:554.5-554.38
+  ;; A-binary.watsup:572.5-572.38
   prod 0xB2 => CVTOP_instr(F32_numtype, I32_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:555.5-555.38
+  ;; A-binary.watsup:573.5-573.38
   prod 0xB3 => CVTOP_instr(F32_numtype, I32_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:556.5-556.38
+  ;; A-binary.watsup:574.5-574.38
   prod 0xB4 => CVTOP_instr(F32_numtype, I64_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:557.5-557.38
+  ;; A-binary.watsup:575.5-575.38
   prod 0xB5 => CVTOP_instr(F32_numtype, I64_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:558.5-558.33
+  ;; A-binary.watsup:576.5-576.33
   prod 0xB6 => CVTOP_instr(F32_numtype, F64_numtype, DEMOTE_cvtop__)
-  ;; A-binary.watsup:559.5-559.38
+  ;; A-binary.watsup:577.5-577.38
   prod 0xB7 => CVTOP_instr(F64_numtype, I32_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:560.5-560.38
+  ;; A-binary.watsup:578.5-578.38
   prod 0xB8 => CVTOP_instr(F64_numtype, I32_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:561.5-561.38
+  ;; A-binary.watsup:579.5-579.38
   prod 0xB9 => CVTOP_instr(F64_numtype, I64_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:562.5-562.38
+  ;; A-binary.watsup:580.5-580.38
   prod 0xBA => CVTOP_instr(F64_numtype, I64_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:563.5-563.34
+  ;; A-binary.watsup:581.5-581.34
   prod 0xBB => CVTOP_instr(F32_numtype, F64_numtype, PROMOTE_cvtop__)
-  ;; A-binary.watsup:564.5-564.38
+  ;; A-binary.watsup:582.5-582.38
   prod 0xBC => CVTOP_instr(I32_numtype, F32_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:565.5-565.38
+  ;; A-binary.watsup:583.5-583.38
   prod 0xBD => CVTOP_instr(I64_numtype, F64_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:566.5-566.38
+  ;; A-binary.watsup:584.5-584.38
   prod 0xBE => CVTOP_instr(F32_numtype, I32_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:567.5-567.38
+  ;; A-binary.watsup:585.5-585.38
   prod 0xBF => CVTOP_instr(F64_numtype, I64_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:571.5-571.47
+  ;; A-binary.watsup:589.5-589.47
   prod {0xFC `%`_u32(0):Bu32} => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:572.5-572.47
+  ;; A-binary.watsup:590.5-590.47
   prod {0xFC `%`_u32(1):Bu32} => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:573.5-573.47
+  ;; A-binary.watsup:591.5-591.47
   prod {0xFC `%`_u32(2):Bu32} => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:574.5-574.47
+  ;; A-binary.watsup:592.5-592.47
   prod {0xFC `%`_u32(3):Bu32} => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:575.5-575.47
+  ;; A-binary.watsup:593.5-593.47
   prod {0xFC `%`_u32(4):Bu32} => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:576.5-576.47
+  ;; A-binary.watsup:594.5-594.47
   prod {0xFC `%`_u32(5):Bu32} => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:577.5-577.47
+  ;; A-binary.watsup:595.5-595.47
   prod {0xFC `%`_u32(6):Bu32} => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:578.5-578.47
+  ;; A-binary.watsup:596.5-596.47
   prod {0xFC `%`_u32(7):Bu32} => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:588.5-588.50
+  ;; A-binary.watsup:606.5-606.50
   prod{x : idx, ao : memarg} {0xFD `%`_u32(0):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(), x, ao)
-  ;; A-binary.watsup:589.5-589.68
+  ;; A-binary.watsup:607.5-607.68
   prod{x : idx, ao : memarg} {0xFD `%`_u32(1):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(8), 8, S_sx)), x, ao)
-  ;; A-binary.watsup:590.5-590.68
+  ;; A-binary.watsup:608.5-608.68
   prod{x : idx, ao : memarg} {0xFD `%`_u32(2):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(8), 8, U_sx)), x, ao)
-  ;; A-binary.watsup:591.5-591.69
+  ;; A-binary.watsup:609.5-609.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(3):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(16), 4, S_sx)), x, ao)
-  ;; A-binary.watsup:592.5-592.69
+  ;; A-binary.watsup:610.5-610.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(4):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(16), 4, U_sx)), x, ao)
-  ;; A-binary.watsup:593.5-593.69
+  ;; A-binary.watsup:611.5-611.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(5):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(32), 2, S_sx)), x, ao)
-  ;; A-binary.watsup:594.5-594.69
+  ;; A-binary.watsup:612.5-612.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(6):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(32), 2, U_sx)), x, ao)
-  ;; A-binary.watsup:595.5-595.61
+  ;; A-binary.watsup:613.5-613.61
   prod{x : idx, ao : memarg} {0xFD `%`_u32(7):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(8))), x, ao)
-  ;; A-binary.watsup:596.5-596.62
+  ;; A-binary.watsup:614.5-614.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(8):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(16))), x, ao)
-  ;; A-binary.watsup:597.5-597.62
+  ;; A-binary.watsup:615.5-615.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(9):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(32))), x, ao)
-  ;; A-binary.watsup:598.5-598.63
+  ;; A-binary.watsup:616.5-616.63
   prod{x : idx, ao : memarg} {0xFD `%`_u32(10):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(64))), x, ao)
-  ;; A-binary.watsup:599.5-599.52
+  ;; A-binary.watsup:617.5-617.52
   prod{x : idx, ao : memarg} {0xFD `%`_u32(11):Bu32 (x, ao):Bmemarg} => VSTORE_instr(V128_vectype, x, ao)
-  ;; A-binary.watsup:600.5-600.72
+  ;; A-binary.watsup:618.5-618.72
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(84):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(8), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:601.5-601.73
+  ;; A-binary.watsup:619.5-619.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(85):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(16), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:602.5-602.73
+  ;; A-binary.watsup:620.5-620.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(86):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(32), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:603.5-603.73
+  ;; A-binary.watsup:621.5-621.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(87):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(64), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:604.5-604.73
+  ;; A-binary.watsup:622.5-622.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(88):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(8), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:605.5-605.74
+  ;; A-binary.watsup:623.5-623.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(89):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(16), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:606.5-606.74
+  ;; A-binary.watsup:624.5-624.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(90):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(32), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:607.5-607.74
+  ;; A-binary.watsup:625.5-625.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(91):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(64), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:608.5-608.62
+  ;; A-binary.watsup:626.5-626.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(92):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(32))), x, ao)
-  ;; A-binary.watsup:609.5-609.62
+  ;; A-binary.watsup:627.5-627.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(93):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(64))), x, ao)
-  ;; A-binary.watsup:613.5-613.71
+  ;; A-binary.watsup:631.5-631.71
   prod{b^16 : byte^16} {0xFD `%`_u32(12):Bu32 b:Bbyte^16{b : byte}} => VCONST_instr(V128_vectype, $invibytes_(128, b^16{b : byte}))
-  ;; A-binary.watsup:617.5-617.58
+  ;; A-binary.watsup:635.5-635.58
   prod{l : labelidx} {0xFD `%`_u32(13):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx^16{}} => VSHUFFLE_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), [`%`_uN(l!`%`_labelidx.0)])
-  ;; A-binary.watsup:618.5-618.40
+  ;; A-binary.watsup:636.5-636.40
   prod {0xFD `%`_u32(14):Bu32} => VSWIZZLE_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)))
-  ;; A-binary.watsup:622.5-622.38
+  ;; A-binary.watsup:640.5-640.38
   prod {0xFD `%`_u32(15):Bu32} => VSPLAT_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)))
-  ;; A-binary.watsup:623.5-623.38
+  ;; A-binary.watsup:641.5-641.38
   prod {0xFD `%`_u32(16):Bu32} => VSPLAT_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)))
-  ;; A-binary.watsup:624.5-624.38
+  ;; A-binary.watsup:642.5-642.38
   prod {0xFD `%`_u32(17):Bu32} => VSPLAT_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)))
-  ;; A-binary.watsup:625.5-625.38
+  ;; A-binary.watsup:643.5-643.38
   prod {0xFD `%`_u32(18):Bu32} => VSPLAT_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)))
-  ;; A-binary.watsup:626.5-626.38
+  ;; A-binary.watsup:644.5-644.38
   prod {0xFD `%`_u32(19):Bu32} => VSPLAT_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)))
-  ;; A-binary.watsup:627.5-627.38
+  ;; A-binary.watsup:645.5-645.38
   prod {0xFD `%`_u32(20):Bu32} => VSPLAT_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)))
-  ;; A-binary.watsup:631.5-631.60
+  ;; A-binary.watsup:649.5-649.60
   prod{l : labelidx} {0xFD `%`_u32(21):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ?(S_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:632.5-632.60
+  ;; A-binary.watsup:650.5-650.60
   prod{l : labelidx} {0xFD `%`_u32(22):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ?(U_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:633.5-633.58
+  ;; A-binary.watsup:651.5-651.58
   prod{l : labelidx} {0xFD `%`_u32(23):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:634.5-634.60
+  ;; A-binary.watsup:652.5-652.60
   prod{l : labelidx} {0xFD `%`_u32(24):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ?(S_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:635.5-635.60
+  ;; A-binary.watsup:653.5-653.60
   prod{l : labelidx} {0xFD `%`_u32(25):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ?(U_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:636.5-636.58
+  ;; A-binary.watsup:654.5-654.58
   prod{l : labelidx} {0xFD `%`_u32(26):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:637.5-637.58
+  ;; A-binary.watsup:655.5-655.58
   prod{l : labelidx} {0xFD `%`_u32(27):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:638.5-638.58
+  ;; A-binary.watsup:656.5-656.58
   prod{l : labelidx} {0xFD `%`_u32(28):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:639.5-639.58
+  ;; A-binary.watsup:657.5-657.58
   prod{l : labelidx} {0xFD `%`_u32(29):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:640.5-640.58
+  ;; A-binary.watsup:658.5-658.58
   prod{l : labelidx} {0xFD `%`_u32(30):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:641.5-641.58
+  ;; A-binary.watsup:659.5-659.58
   prod{l : labelidx} {0xFD `%`_u32(31):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:642.5-642.58
+  ;; A-binary.watsup:660.5-660.58
   prod{l : labelidx} {0xFD `%`_u32(32):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:643.5-643.58
+  ;; A-binary.watsup:661.5-661.58
   prod{l : labelidx} {0xFD `%`_u32(33):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:644.5-644.58
+  ;; A-binary.watsup:662.5-662.58
   prod{l : labelidx} {0xFD `%`_u32(34):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:648.5-648.41
+  ;; A-binary.watsup:666.5-666.41
   prod {0xFD `%`_u32(35):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), EQ_vrelop_)
-  ;; A-binary.watsup:649.5-649.41
+  ;; A-binary.watsup:667.5-667.41
   prod {0xFD `%`_u32(36):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), NE_vrelop_)
-  ;; A-binary.watsup:650.5-650.45
+  ;; A-binary.watsup:668.5-668.45
   prod {0xFD `%`_u32(37):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:651.5-651.45
+  ;; A-binary.watsup:669.5-669.45
   prod {0xFD `%`_u32(38):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:652.5-652.45
+  ;; A-binary.watsup:670.5-670.45
   prod {0xFD `%`_u32(39):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:653.5-653.45
+  ;; A-binary.watsup:671.5-671.45
   prod {0xFD `%`_u32(40):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:654.5-654.45
+  ;; A-binary.watsup:672.5-672.45
   prod {0xFD `%`_u32(41):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:655.5-655.45
+  ;; A-binary.watsup:673.5-673.45
   prod {0xFD `%`_u32(42):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:656.5-656.45
+  ;; A-binary.watsup:674.5-674.45
   prod {0xFD `%`_u32(43):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:657.5-657.45
+  ;; A-binary.watsup:675.5-675.45
   prod {0xFD `%`_u32(44):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:661.5-661.41
+  ;; A-binary.watsup:679.5-679.41
   prod {0xFD `%`_u32(45):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), EQ_vrelop_)
-  ;; A-binary.watsup:662.5-662.41
+  ;; A-binary.watsup:680.5-680.41
   prod {0xFD `%`_u32(46):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), NE_vrelop_)
-  ;; A-binary.watsup:663.5-663.45
+  ;; A-binary.watsup:681.5-681.45
   prod {0xFD `%`_u32(47):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:664.5-664.45
+  ;; A-binary.watsup:682.5-682.45
   prod {0xFD `%`_u32(48):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:665.5-665.45
+  ;; A-binary.watsup:683.5-683.45
   prod {0xFD `%`_u32(49):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:666.5-666.45
+  ;; A-binary.watsup:684.5-684.45
   prod {0xFD `%`_u32(50):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:667.5-667.45
+  ;; A-binary.watsup:685.5-685.45
   prod {0xFD `%`_u32(51):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:668.5-668.45
+  ;; A-binary.watsup:686.5-686.45
   prod {0xFD `%`_u32(52):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:669.5-669.45
+  ;; A-binary.watsup:687.5-687.45
   prod {0xFD `%`_u32(53):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:670.5-670.45
+  ;; A-binary.watsup:688.5-688.45
   prod {0xFD `%`_u32(54):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:674.5-674.41
+  ;; A-binary.watsup:692.5-692.41
   prod {0xFD `%`_u32(55):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), EQ_vrelop_)
-  ;; A-binary.watsup:675.5-675.41
+  ;; A-binary.watsup:693.5-693.41
   prod {0xFD `%`_u32(56):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), NE_vrelop_)
-  ;; A-binary.watsup:676.5-676.45
+  ;; A-binary.watsup:694.5-694.45
   prod {0xFD `%`_u32(57):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:677.5-677.45
+  ;; A-binary.watsup:695.5-695.45
   prod {0xFD `%`_u32(58):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:678.5-678.45
+  ;; A-binary.watsup:696.5-696.45
   prod {0xFD `%`_u32(59):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:679.5-679.45
+  ;; A-binary.watsup:697.5-697.45
   prod {0xFD `%`_u32(60):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:680.5-680.45
+  ;; A-binary.watsup:698.5-698.45
   prod {0xFD `%`_u32(61):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:681.5-681.45
+  ;; A-binary.watsup:699.5-699.45
   prod {0xFD `%`_u32(62):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:682.5-682.45
+  ;; A-binary.watsup:700.5-700.45
   prod {0xFD `%`_u32(63):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:683.5-683.45
+  ;; A-binary.watsup:701.5-701.45
   prod {0xFD `%`_u32(64):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:687.5-687.41
+  ;; A-binary.watsup:705.5-705.41
   prod {0xFD `%`_u32(65):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), EQ_vrelop_)
-  ;; A-binary.watsup:688.5-688.41
+  ;; A-binary.watsup:706.5-706.41
   prod {0xFD `%`_u32(66):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NE_vrelop_)
-  ;; A-binary.watsup:689.5-689.41
+  ;; A-binary.watsup:707.5-707.41
   prod {0xFD `%`_u32(67):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), LT_vrelop_)
-  ;; A-binary.watsup:690.5-690.41
+  ;; A-binary.watsup:708.5-708.41
   prod {0xFD `%`_u32(68):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), GT_vrelop_)
-  ;; A-binary.watsup:691.5-691.41
+  ;; A-binary.watsup:709.5-709.41
   prod {0xFD `%`_u32(69):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), LE_vrelop_)
-  ;; A-binary.watsup:692.5-692.41
+  ;; A-binary.watsup:710.5-710.41
   prod {0xFD `%`_u32(70):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), GE_vrelop_)
-  ;; A-binary.watsup:696.5-696.41
+  ;; A-binary.watsup:714.5-714.41
   prod {0xFD `%`_u32(71):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), EQ_vrelop_)
-  ;; A-binary.watsup:697.5-697.41
+  ;; A-binary.watsup:715.5-715.41
   prod {0xFD `%`_u32(72):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NE_vrelop_)
-  ;; A-binary.watsup:698.5-698.41
+  ;; A-binary.watsup:716.5-716.41
   prod {0xFD `%`_u32(73):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), LT_vrelop_)
-  ;; A-binary.watsup:699.5-699.41
+  ;; A-binary.watsup:717.5-717.41
   prod {0xFD `%`_u32(74):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), GT_vrelop_)
-  ;; A-binary.watsup:700.5-700.41
+  ;; A-binary.watsup:718.5-718.41
   prod {0xFD `%`_u32(75):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), LE_vrelop_)
-  ;; A-binary.watsup:701.5-701.41
+  ;; A-binary.watsup:719.5-719.41
   prod {0xFD `%`_u32(76):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), GE_vrelop_)
-  ;; A-binary.watsup:705.5-705.36
+  ;; A-binary.watsup:723.5-723.36
   prod {0xFD `%`_u32(77):Bu32} => VVUNOP_instr(V128_vectype, NOT_vvunop)
-  ;; A-binary.watsup:709.5-709.37
+  ;; A-binary.watsup:727.5-727.37
   prod {0xFD `%`_u32(78):Bu32} => VVBINOP_instr(V128_vectype, AND_vvbinop)
-  ;; A-binary.watsup:710.5-710.40
+  ;; A-binary.watsup:728.5-728.40
   prod {0xFD `%`_u32(79):Bu32} => VVBINOP_instr(V128_vectype, ANDNOT_vvbinop)
-  ;; A-binary.watsup:711.5-711.36
+  ;; A-binary.watsup:729.5-729.36
   prod {0xFD `%`_u32(80):Bu32} => VVBINOP_instr(V128_vectype, OR_vvbinop)
-  ;; A-binary.watsup:712.5-712.37
+  ;; A-binary.watsup:730.5-730.37
   prod {0xFD `%`_u32(81):Bu32} => VVBINOP_instr(V128_vectype, XOR_vvbinop)
-  ;; A-binary.watsup:716.5-716.44
+  ;; A-binary.watsup:734.5-734.44
   prod {0xFD `%`_u32(82):Bu32} => VVTERNOP_instr(V128_vectype, BITSELECT_vvternop)
-  ;; A-binary.watsup:720.5-720.43
+  ;; A-binary.watsup:738.5-738.43
   prod {0xFD `%`_u32(83):Bu32} => VVTESTOP_instr(V128_vectype, ANY_TRUE_vvtestop)
-  ;; A-binary.watsup:724.5-724.41
+  ;; A-binary.watsup:742.5-742.41
   prod {0xFD `%`_u32(96):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ABS_vunop_)
-  ;; A-binary.watsup:725.5-725.41
+  ;; A-binary.watsup:743.5-743.41
   prod {0xFD `%`_u32(97):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), NEG_vunop_)
-  ;; A-binary.watsup:726.5-726.44
+  ;; A-binary.watsup:744.5-744.44
   prod {0xFD `%`_u32(98):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), POPCNT_vunop_)
-  ;; A-binary.watsup:730.5-730.48
+  ;; A-binary.watsup:748.5-748.48
   prod {0xFD `%`_u32(99):Bu32} => VTESTOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:734.5-734.41
+  ;; A-binary.watsup:752.5-752.41
   prod {0xFD `%`_u32(100):Bu32} => VBITMASK_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)))
-  ;; A-binary.watsup:738.5-738.53
+  ;; A-binary.watsup:756.5-756.53
   prod {0xFD `%`_u32(101):Bu32} => VNARROW_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), S_sx)
-  ;; A-binary.watsup:739.5-739.53
+  ;; A-binary.watsup:757.5-757.53
   prod {0xFD `%`_u32(102):Bu32} => VNARROW_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), U_sx)
-  ;; A-binary.watsup:743.5-743.45
+  ;; A-binary.watsup:761.5-761.45
   prod {0xFD `%`_u32(107):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHL_vshiftop_)
-  ;; A-binary.watsup:744.5-744.49
+  ;; A-binary.watsup:762.5-762.49
   prod {0xFD `%`_u32(108):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:745.5-745.49
+  ;; A-binary.watsup:763.5-763.49
   prod {0xFD `%`_u32(109):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:749.5-749.43
+  ;; A-binary.watsup:767.5-767.43
   prod {0xFD `%`_u32(110):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_vbinop_)
-  ;; A-binary.watsup:750.5-750.51
+  ;; A-binary.watsup:768.5-768.51
   prod {0xFD `%`_u32(111):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:751.5-751.51
+  ;; A-binary.watsup:769.5-769.51
   prod {0xFD `%`_u32(112):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:752.5-752.43
+  ;; A-binary.watsup:770.5-770.43
   prod {0xFD `%`_u32(113):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_vbinop_)
-  ;; A-binary.watsup:753.5-753.51
+  ;; A-binary.watsup:771.5-771.51
   prod {0xFD `%`_u32(114):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:754.5-754.51
+  ;; A-binary.watsup:772.5-772.51
   prod {0xFD `%`_u32(115):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:755.5-755.47
+  ;; A-binary.watsup:773.5-773.47
   prod {0xFD `%`_u32(118):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:756.5-756.47
+  ;; A-binary.watsup:774.5-774.47
   prod {0xFD `%`_u32(119):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:757.5-757.47
+  ;; A-binary.watsup:775.5-775.47
   prod {0xFD `%`_u32(120):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:758.5-758.47
+  ;; A-binary.watsup:776.5-776.47
   prod {0xFD `%`_u32(121):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:759.5-759.48
+  ;; A-binary.watsup:777.5-777.48
   prod {0xFD `%`_u32(123):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), `AVGRU`_vbinop_)
-  ;; A-binary.watsup:763.5-763.72
+  ;; A-binary.watsup:781.5-781.72
   prod {0xFD `%`_u32(124):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTADD_PAIRWISE_vextunop__(S_sx))
-  ;; A-binary.watsup:764.5-764.72
+  ;; A-binary.watsup:782.5-782.72
   prod {0xFD `%`_u32(125):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTADD_PAIRWISE_vextunop__(U_sx))
-  ;; A-binary.watsup:768.5-768.42
+  ;; A-binary.watsup:786.5-786.42
   prod {0xFD `%`_u32(128):Bu32} => VUNOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ABS_vunop_)
-  ;; A-binary.watsup:769.5-769.42
+  ;; A-binary.watsup:787.5-787.42
   prod {0xFD `%`_u32(129):Bu32} => VUNOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), NEG_vunop_)
-  ;; A-binary.watsup:773.5-773.55
+  ;; A-binary.watsup:791.5-791.55
   prod {0xFD `%`_u32(130):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `Q15MULR_SATS`_vbinop_)
-  ;; A-binary.watsup:777.5-777.49
+  ;; A-binary.watsup:795.5-795.49
   prod {0xFD `%`_u32(131):Bu32} => VTESTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:781.5-781.41
+  ;; A-binary.watsup:799.5-799.41
   prod {0xFD `%`_u32(132):Bu32} => VBITMASK_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)))
-  ;; A-binary.watsup:785.5-785.53
+  ;; A-binary.watsup:803.5-803.53
   prod {0xFD `%`_u32(133):Bu32} => VNARROW_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), S_sx)
-  ;; A-binary.watsup:786.5-786.53
+  ;; A-binary.watsup:804.5-804.53
   prod {0xFD `%`_u32(134):Bu32} => VNARROW_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), U_sx)
-  ;; A-binary.watsup:790.5-790.65
+  ;; A-binary.watsup:808.5-808.65
   prod {0xFD `%`_u32(135):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:791.5-791.66
+  ;; A-binary.watsup:809.5-809.66
   prod {0xFD `%`_u32(136):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:792.5-792.65
+  ;; A-binary.watsup:810.5-810.65
   prod {0xFD `%`_u32(137):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:793.5-793.66
+  ;; A-binary.watsup:811.5-811.66
   prod {0xFD `%`_u32(138):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:797.5-797.45
+  ;; A-binary.watsup:815.5-815.45
   prod {0xFD `%`_u32(139):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHL_vshiftop_)
-  ;; A-binary.watsup:798.5-798.49
+  ;; A-binary.watsup:816.5-816.49
   prod {0xFD `%`_u32(140):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:799.5-799.49
+  ;; A-binary.watsup:817.5-817.49
   prod {0xFD `%`_u32(141):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:803.5-803.43
+  ;; A-binary.watsup:821.5-821.43
   prod {0xFD `%`_u32(142):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_vbinop_)
-  ;; A-binary.watsup:804.5-804.51
+  ;; A-binary.watsup:822.5-822.51
   prod {0xFD `%`_u32(143):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:805.5-805.51
+  ;; A-binary.watsup:823.5-823.51
   prod {0xFD `%`_u32(144):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:806.5-806.43
+  ;; A-binary.watsup:824.5-824.43
   prod {0xFD `%`_u32(145):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_vbinop_)
-  ;; A-binary.watsup:807.5-807.51
+  ;; A-binary.watsup:825.5-825.51
   prod {0xFD `%`_u32(146):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:808.5-808.51
+  ;; A-binary.watsup:826.5-826.51
   prod {0xFD `%`_u32(147):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:809.5-809.43
+  ;; A-binary.watsup:827.5-827.43
   prod {0xFD `%`_u32(149):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MUL_vbinop_)
-  ;; A-binary.watsup:810.5-810.47
+  ;; A-binary.watsup:828.5-828.47
   prod {0xFD `%`_u32(150):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:811.5-811.47
+  ;; A-binary.watsup:829.5-829.47
   prod {0xFD `%`_u32(151):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:812.5-812.47
+  ;; A-binary.watsup:830.5-830.47
   prod {0xFD `%`_u32(152):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:813.5-813.47
+  ;; A-binary.watsup:831.5-831.47
   prod {0xFD `%`_u32(153):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:814.5-814.48
+  ;; A-binary.watsup:832.5-832.48
   prod {0xFD `%`_u32(155):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `AVGRU`_vbinop_)
-  ;; A-binary.watsup:818.5-818.68
+  ;; A-binary.watsup:836.5-836.68
   prod {0xFD `%`_u32(156):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:819.5-819.69
+  ;; A-binary.watsup:837.5-837.69
   prod {0xFD `%`_u32(157):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:820.5-820.68
+  ;; A-binary.watsup:838.5-838.68
   prod {0xFD `%`_u32(158):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:821.5-821.69
+  ;; A-binary.watsup:839.5-839.69
   prod {0xFD `%`_u32(159):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:825.5-825.72
+  ;; A-binary.watsup:843.5-843.72
   prod {0xFD `%`_u32(126):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTADD_PAIRWISE_vextunop__(S_sx))
-  ;; A-binary.watsup:826.5-826.72
+  ;; A-binary.watsup:844.5-844.72
   prod {0xFD `%`_u32(127):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTADD_PAIRWISE_vextunop__(U_sx))
-  ;; A-binary.watsup:830.5-830.42
+  ;; A-binary.watsup:848.5-848.42
   prod {0xFD `%`_u32(160):Bu32} => VUNOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ABS_vunop_)
-  ;; A-binary.watsup:831.5-831.42
+  ;; A-binary.watsup:849.5-849.42
   prod {0xFD `%`_u32(161):Bu32} => VUNOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), NEG_vunop_)
-  ;; A-binary.watsup:835.5-835.49
+  ;; A-binary.watsup:853.5-853.49
   prod {0xFD `%`_u32(163):Bu32} => VTESTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:839.5-839.41
+  ;; A-binary.watsup:857.5-857.41
   prod {0xFD `%`_u32(164):Bu32} => VBITMASK_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)))
-  ;; A-binary.watsup:843.5-843.65
+  ;; A-binary.watsup:861.5-861.65
   prod {0xFD `%`_u32(167):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:844.5-844.66
+  ;; A-binary.watsup:862.5-862.66
   prod {0xFD `%`_u32(168):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:845.5-845.65
+  ;; A-binary.watsup:863.5-863.65
   prod {0xFD `%`_u32(169):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:846.5-846.66
+  ;; A-binary.watsup:864.5-864.66
   prod {0xFD `%`_u32(170):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:850.5-850.45
+  ;; A-binary.watsup:868.5-868.45
   prod {0xFD `%`_u32(171):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHL_vshiftop_)
-  ;; A-binary.watsup:851.5-851.49
+  ;; A-binary.watsup:869.5-869.49
   prod {0xFD `%`_u32(172):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:852.5-852.49
+  ;; A-binary.watsup:870.5-870.49
   prod {0xFD `%`_u32(173):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:856.5-856.43
+  ;; A-binary.watsup:874.5-874.43
   prod {0xFD `%`_u32(174):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ADD_vbinop_)
-  ;; A-binary.watsup:857.5-857.43
+  ;; A-binary.watsup:875.5-875.43
   prod {0xFD `%`_u32(177):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), SUB_vbinop_)
-  ;; A-binary.watsup:858.5-858.43
+  ;; A-binary.watsup:876.5-876.43
   prod {0xFD `%`_u32(181):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MUL_vbinop_)
-  ;; A-binary.watsup:859.5-859.47
+  ;; A-binary.watsup:877.5-877.47
   prod {0xFD `%`_u32(182):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:860.5-860.47
+  ;; A-binary.watsup:878.5-878.47
   prod {0xFD `%`_u32(183):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:861.5-861.47
+  ;; A-binary.watsup:879.5-879.47
   prod {0xFD `%`_u32(184):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:862.5-862.47
+  ;; A-binary.watsup:880.5-880.47
   prod {0xFD `%`_u32(185):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:866.5-866.61
+  ;; A-binary.watsup:884.5-884.61
   prod {0xFD `%`_u32(186):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), `DOTS`_vextbinop__)
-  ;; A-binary.watsup:867.5-867.68
+  ;; A-binary.watsup:885.5-885.68
   prod {0xFD `%`_u32(188):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:868.5-868.69
+  ;; A-binary.watsup:886.5-886.69
   prod {0xFD `%`_u32(189):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:869.5-869.68
+  ;; A-binary.watsup:887.5-887.68
   prod {0xFD `%`_u32(190):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:870.5-870.69
+  ;; A-binary.watsup:888.5-888.69
   prod {0xFD `%`_u32(191):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:874.5-874.42
+  ;; A-binary.watsup:892.5-892.42
   prod {0xFD `%`_u32(192):Bu32} => VUNOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ABS_vunop_)
-  ;; A-binary.watsup:875.5-875.42
+  ;; A-binary.watsup:893.5-893.42
   prod {0xFD `%`_u32(193):Bu32} => VUNOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), NEG_vunop_)
-  ;; A-binary.watsup:879.5-879.49
+  ;; A-binary.watsup:897.5-897.49
   prod {0xFD `%`_u32(195):Bu32} => VTESTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:883.5-883.41
+  ;; A-binary.watsup:901.5-901.41
   prod {0xFD `%`_u32(196):Bu32} => VBITMASK_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)))
-  ;; A-binary.watsup:887.5-887.65
+  ;; A-binary.watsup:905.5-905.65
   prod {0xFD `%`_u32(199):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:888.5-888.66
+  ;; A-binary.watsup:906.5-906.66
   prod {0xFD `%`_u32(200):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:889.5-889.65
+  ;; A-binary.watsup:907.5-907.65
   prod {0xFD `%`_u32(201):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:890.5-890.66
+  ;; A-binary.watsup:908.5-908.66
   prod {0xFD `%`_u32(202):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:894.5-894.45
+  ;; A-binary.watsup:912.5-912.45
   prod {0xFD `%`_u32(203):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHL_vshiftop_)
-  ;; A-binary.watsup:895.5-895.49
+  ;; A-binary.watsup:913.5-913.49
   prod {0xFD `%`_u32(204):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:896.5-896.49
+  ;; A-binary.watsup:914.5-914.49
   prod {0xFD `%`_u32(205):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:900.5-900.43
+  ;; A-binary.watsup:918.5-918.43
   prod {0xFD `%`_u32(206):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ADD_vbinop_)
-  ;; A-binary.watsup:901.5-901.43
+  ;; A-binary.watsup:919.5-919.43
   prod {0xFD `%`_u32(209):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), SUB_vbinop_)
-  ;; A-binary.watsup:902.5-902.43
+  ;; A-binary.watsup:920.5-920.43
   prod {0xFD `%`_u32(213):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), MUL_vbinop_)
-  ;; A-binary.watsup:906.5-906.42
+  ;; A-binary.watsup:924.5-924.42
   prod {0xFD `%`_u32(214):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), EQ_vrelop_)
-  ;; A-binary.watsup:907.5-907.42
+  ;; A-binary.watsup:925.5-925.42
   prod {0xFD `%`_u32(215):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), NE_vrelop_)
-  ;; A-binary.watsup:908.5-908.46
+  ;; A-binary.watsup:926.5-926.46
   prod {0xFD `%`_u32(216):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:909.5-909.46
+  ;; A-binary.watsup:927.5-927.46
   prod {0xFD `%`_u32(217):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:910.5-910.46
+  ;; A-binary.watsup:928.5-928.46
   prod {0xFD `%`_u32(218):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:911.5-911.46
+  ;; A-binary.watsup:929.5-929.46
   prod {0xFD `%`_u32(219):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:915.5-915.68
+  ;; A-binary.watsup:933.5-933.68
   prod {0xFD `%`_u32(220):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:916.5-916.69
+  ;; A-binary.watsup:934.5-934.69
   prod {0xFD `%`_u32(221):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:917.5-917.68
+  ;; A-binary.watsup:935.5-935.68
   prod {0xFD `%`_u32(222):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:918.5-918.69
+  ;; A-binary.watsup:936.5-936.69
   prod {0xFD `%`_u32(223):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:922.5-922.43
+  ;; A-binary.watsup:940.5-940.43
   prod {0xFD `%`_u32(103):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), CEIL_vunop_)
-  ;; A-binary.watsup:923.5-923.44
+  ;; A-binary.watsup:941.5-941.44
   prod {0xFD `%`_u32(104):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), FLOOR_vunop_)
-  ;; A-binary.watsup:924.5-924.44
+  ;; A-binary.watsup:942.5-942.44
   prod {0xFD `%`_u32(105):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_vunop_)
-  ;; A-binary.watsup:925.5-925.46
+  ;; A-binary.watsup:943.5-943.46
   prod {0xFD `%`_u32(106):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NEAREST_vunop_)
-  ;; A-binary.watsup:926.5-926.42
+  ;; A-binary.watsup:944.5-944.42
   prod {0xFD `%`_u32(224):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ABS_vunop_)
-  ;; A-binary.watsup:927.5-927.42
+  ;; A-binary.watsup:945.5-945.42
   prod {0xFD `%`_u32(225):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NEG_vunop_)
-  ;; A-binary.watsup:928.5-928.43
+  ;; A-binary.watsup:946.5-946.43
   prod {0xFD `%`_u32(227):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), SQRT_vunop_)
-  ;; A-binary.watsup:932.5-932.43
+  ;; A-binary.watsup:950.5-950.43
   prod {0xFD `%`_u32(228):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ADD_vbinop_)
-  ;; A-binary.watsup:933.5-933.43
+  ;; A-binary.watsup:951.5-951.43
   prod {0xFD `%`_u32(229):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), SUB_vbinop_)
-  ;; A-binary.watsup:934.5-934.43
+  ;; A-binary.watsup:952.5-952.43
   prod {0xFD `%`_u32(230):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MUL_vbinop_)
-  ;; A-binary.watsup:935.5-935.43
+  ;; A-binary.watsup:953.5-953.43
   prod {0xFD `%`_u32(231):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), DIV_vbinop_)
-  ;; A-binary.watsup:936.5-936.43
+  ;; A-binary.watsup:954.5-954.43
   prod {0xFD `%`_u32(232):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MIN_vbinop_)
-  ;; A-binary.watsup:937.5-937.43
+  ;; A-binary.watsup:955.5-955.43
   prod {0xFD `%`_u32(233):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MAX_vbinop_)
-  ;; A-binary.watsup:938.5-938.44
+  ;; A-binary.watsup:956.5-956.44
   prod {0xFD `%`_u32(234):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), PMIN_vbinop_)
-  ;; A-binary.watsup:939.5-939.44
+  ;; A-binary.watsup:957.5-957.44
   prod {0xFD `%`_u32(235):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), PMAX_vbinop_)
-  ;; A-binary.watsup:943.5-943.43
+  ;; A-binary.watsup:961.5-961.43
   prod {0xFD `%`_u32(116):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), CEIL_vunop_)
-  ;; A-binary.watsup:944.5-944.44
+  ;; A-binary.watsup:962.5-962.44
   prod {0xFD `%`_u32(117):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), FLOOR_vunop_)
-  ;; A-binary.watsup:945.5-945.44
+  ;; A-binary.watsup:963.5-963.44
   prod {0xFD `%`_u32(122):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_vunop_)
-  ;; A-binary.watsup:946.5-946.46
+  ;; A-binary.watsup:964.5-964.46
   prod {0xFD `%`_u32(148):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NEAREST_vunop_)
-  ;; A-binary.watsup:947.5-947.42
+  ;; A-binary.watsup:965.5-965.42
   prod {0xFD `%`_u32(236):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ABS_vunop_)
-  ;; A-binary.watsup:948.5-948.42
+  ;; A-binary.watsup:966.5-966.42
   prod {0xFD `%`_u32(237):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NEG_vunop_)
-  ;; A-binary.watsup:949.5-949.43
+  ;; A-binary.watsup:967.5-967.43
   prod {0xFD `%`_u32(239):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), SQRT_vunop_)
-  ;; A-binary.watsup:953.5-953.43
+  ;; A-binary.watsup:971.5-971.43
   prod {0xFD `%`_u32(240):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ADD_vbinop_)
-  ;; A-binary.watsup:954.5-954.43
+  ;; A-binary.watsup:972.5-972.43
   prod {0xFD `%`_u32(241):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), SUB_vbinop_)
-  ;; A-binary.watsup:955.5-955.43
+  ;; A-binary.watsup:973.5-973.43
   prod {0xFD `%`_u32(242):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MUL_vbinop_)
-  ;; A-binary.watsup:956.5-956.43
+  ;; A-binary.watsup:974.5-974.43
   prod {0xFD `%`_u32(243):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), DIV_vbinop_)
-  ;; A-binary.watsup:957.5-957.43
+  ;; A-binary.watsup:975.5-975.43
   prod {0xFD `%`_u32(244):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MIN_vbinop_)
-  ;; A-binary.watsup:958.5-958.43
+  ;; A-binary.watsup:976.5-976.43
   prod {0xFD `%`_u32(245):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MAX_vbinop_)
-  ;; A-binary.watsup:959.5-959.44
+  ;; A-binary.watsup:977.5-977.44
   prod {0xFD `%`_u32(246):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), PMIN_vbinop_)
-  ;; A-binary.watsup:960.5-960.44
+  ;; A-binary.watsup:978.5-978.44
   prod {0xFD `%`_u32(247):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), PMAX_vbinop_)
-  ;; A-binary.watsup:964.5-964.61
+  ;; A-binary.watsup:982.5-982.61
   prod {0xFD `%`_u32(94):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), DEMOTE_vcvtop__, ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:965.5-965.61
+  ;; A-binary.watsup:983.5-983.61
   prod {0xFD `%`_u32(95):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(F32_lanetype, `%`_dim(4)), PROMOTE_vcvtop__, ?(LOW_half__), ?())
-  ;; A-binary.watsup:966.5-966.64
+  ;; A-binary.watsup:984.5-984.64
   prod {0xFD `%`_u32(248):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_SAT_vcvtop__(S_sx), ?(), ?())
-  ;; A-binary.watsup:967.5-967.64
+  ;; A-binary.watsup:985.5-985.64
   prod {0xFD `%`_u32(249):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_SAT_vcvtop__(U_sx), ?(), ?())
-  ;; A-binary.watsup:968.5-968.62
+  ;; A-binary.watsup:986.5-986.62
   prod {0xFD `%`_u32(250):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(S_sx), ?(), ?())
-  ;; A-binary.watsup:969.5-969.62
+  ;; A-binary.watsup:987.5-987.62
   prod {0xFD `%`_u32(251):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(U_sx), ?(), ?())
-  ;; A-binary.watsup:970.5-970.69
+  ;; A-binary.watsup:988.5-988.69
   prod {0xFD `%`_u32(252):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_SAT_vcvtop__(S_sx), ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:971.5-971.69
+  ;; A-binary.watsup:989.5-989.69
   prod {0xFD `%`_u32(253):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_SAT_vcvtop__(U_sx), ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:972.5-972.66
+  ;; A-binary.watsup:990.5-990.66
   prod {0xFD `%`_u32(254):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:973.5-973.66
+  ;; A-binary.watsup:991.5-991.66
   prod {0xFD `%`_u32(255):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(U_sx), ?(LOW_half__), ?())
 }
 
@@ -7861,6 +8211,16 @@ grammar Bdatacntsec : u32?
   ;; A-binary.watsup
   prod{nopt : nopt} nopt:Bsection_(12, syntax u32, grammar Bdatacnt) => $opt_(syntax u32, nopt)
 
+;; A-binary.watsup
+grammar Btag : tag
+  ;; A-binary.watsup
+  prod{x : idx} x:Btypeidx => TAG_tag(x)
+
+;; A-binary.watsup
+grammar Btagsec : tag*
+  ;; A-binary.watsup
+  prod{tag* : tag*} tag*{tag : tag}:Bsection_(13, syntax tag, grammar Blist(syntax tag, grammar Btag)) => tag*{tag : tag}
+
 ;; A-binary.watsup
 grammar Bmagic : ()
   ;; A-binary.watsup
@@ -7874,7 +8234,7 @@ grammar Bversion : ()
 ;; A-binary.watsup
 grammar Bmodule : module
   ;; A-binary.watsup
-  prod{type* : type*, import* : import*, typeidx* : typeidx*, table* : table*, mem* : mem*, global* : global*, export* : export*, start? : start?, elem* : elem*, n? : n?, local** : local**, expr* : expr*, data* : data*, func* : func*} {Bmagic Bversion Bcustomsec*{} type*{type : type}:Btypesec Bcustomsec*{} import*{import : import}:Bimportsec Bcustomsec*{} typeidx*{typeidx : typeidx}:Bfuncsec Bcustomsec*{} table*{table : table}:Btablesec Bcustomsec*{} mem*{mem : mem}:Bmemsec Bcustomsec*{} global*{global : global}:Bglobalsec Bcustomsec*{} export*{export : export}:Bexportsec Bcustomsec*{} start?{start : start}:Bstartsec Bcustomsec*{} elem*{elem : elem}:Belemsec Bcustomsec*{} `%`_u32(n)?{n : nat}:Bdatacntsec Bcustomsec*{} (local*{local : local}, expr)*{expr : expr, local : local}:Bcodesec Bcustomsec*{} data*{data : data}:Bdatasec Bcustomsec*{}} => MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})
+  prod{type* : type*, import* : import*, typeidx* : typeidx*, table* : table*, mem* : mem*, tag* : tag*, global* : global*, export* : export*, start? : start?, elem* : elem*, n? : n?, local** : local**, expr* : expr*, data* : data*, func* : func*} {Bmagic Bversion Bcustomsec*{} type*{type : type}:Btypesec Bcustomsec*{} import*{import : import}:Bimportsec Bcustomsec*{} typeidx*{typeidx : typeidx}:Bfuncsec Bcustomsec*{} table*{table : table}:Btablesec Bcustomsec*{} mem*{mem : mem}:Bmemsec Bcustomsec*{} tag*{tag : tag}:Btagsec Bcustomsec*{} global*{global : global}:Bglobalsec Bcustomsec*{} export*{export : export}:Bexportsec Bcustomsec*{} start?{start : start}:Bstartsec Bcustomsec*{} elem*{elem : elem}:Belemsec Bcustomsec*{} `%`_u32(n)?{n : nat}:Bdatacntsec Bcustomsec*{} (local*{local : local}, expr)*{expr : expr, local : local}:Bcodesec Bcustomsec*{} data*{data : data}:Bdatasec Bcustomsec*{}} => MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})
     -- (if (n = |data*{data : data}|))?{n : n}
     -- if ((n?{n : n} =/= ?()) \/ ($dataidx_funcs(func*{func : func}) = []))
     -- (if (func = FUNC_func(typeidx, local*{local : local}, expr)))*{expr : expr, func : func, local : local, typeidx : typeidx}
@@ -7949,7 +8309,7 @@ relation NotationTypingInstrScheme: `%|-%:%`(context, instr*, functype)
   rule block{C : context, blocktype : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, [BLOCK_instr(blocktype, instr*{instr : instr})], `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, blocktype, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- NotationTypingInstrScheme: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
+    -- NotationTypingInstrScheme: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
 }
 
 ;; C-conventions.watsup
@@ -8347,6 +8707,9 @@ syntax tableidx = idx
 ;; 1-syntax.watsup
 syntax memidx = idx
 
+;; 1-syntax.watsup
+syntax tagidx = idx
+
 ;; 1-syntax.watsup
 syntax elemidx = idx
 
@@ -8403,6 +8766,8 @@ syntax absheaptype =
   | NONE
   | FUNC
   | NOFUNC
+  | EXN
+  | NOEXN
   | EXTERN
   | NOEXTERN
   | BOT
@@ -8418,13 +8783,13 @@ syntax fin =
 ;; 1-syntax.watsup
 rec {
 
-;; 1-syntax.watsup:153.1-154.26
+;; 1-syntax.watsup:155.1-156.26
 syntax typeuse =
   | _IDX{typeidx : typeidx}(typeidx : typeidx)
   | DEF{rectype : rectype, n : n}(rectype : rectype, n : n)
   | REC{n : n}(n : n)
 
-;; 1-syntax.watsup:156.1-157.26
+;; 1-syntax.watsup:158.1-159.26
 syntax heaptype =
   | ANY
   | EQ
@@ -8434,6 +8799,8 @@ syntax heaptype =
   | NONE
   | FUNC
   | NOFUNC
+  | EXN
+  | NOEXN
   | EXTERN
   | NOEXTERN
   | BOT
@@ -8441,7 +8808,7 @@ syntax heaptype =
   | REC{n : n}(n : n)
   | DEF{rectype : rectype, n : n}(rectype : rectype, n : n)
 
-;; 1-syntax.watsup:164.1-165.14
+;; 1-syntax.watsup:166.1-167.14
 syntax valtype =
   | I32
   | I64
@@ -8451,10 +8818,10 @@ syntax valtype =
   | REF{nul : nul, heaptype : heaptype}(nul : nul, heaptype : heaptype)
   | BOT
 
-;; 1-syntax.watsup:194.1-195.16
+;; 1-syntax.watsup:196.1-197.16
 syntax resulttype = list(syntax valtype)
 
-;; 1-syntax.watsup:202.1-202.66
+;; 1-syntax.watsup:204.1-204.66
 syntax storagetype =
   | BOT
   | I32
@@ -8466,31 +8833,31 @@ syntax storagetype =
   | I8
   | I16
 
-;; 1-syntax.watsup:218.1-218.60
+;; 1-syntax.watsup:220.1-220.60
 syntax fieldtype =
   | `%%`{mut : mut, storagetype : storagetype}(mut : mut, storagetype : storagetype)
 
-;; 1-syntax.watsup:220.1-220.90
+;; 1-syntax.watsup:222.1-222.90
 syntax functype =
   | `%->%`{resulttype : resulttype}(resulttype : resulttype, resulttype)
 
-;; 1-syntax.watsup:221.1-221.64
+;; 1-syntax.watsup:223.1-223.64
 syntax structtype = list(syntax fieldtype)
 
-;; 1-syntax.watsup:222.1-222.54
+;; 1-syntax.watsup:224.1-224.54
 syntax arraytype = fieldtype
 
-;; 1-syntax.watsup:224.1-227.18
+;; 1-syntax.watsup:226.1-229.18
 syntax comptype =
   | STRUCT{structtype : structtype}(structtype : structtype)
   | ARRAY{arraytype : arraytype}(arraytype : arraytype)
   | FUNC{functype : functype}(functype : functype)
 
-;; 1-syntax.watsup:229.1-230.30
+;; 1-syntax.watsup:231.1-232.30
 syntax subtype =
   | SUB{fin : fin, typeuse* : typeuse*, comptype : comptype}(fin : fin, typeuse*{typeuse : typeuse} : typeuse*, comptype : comptype)
 
-;; 1-syntax.watsup:232.1-233.22
+;; 1-syntax.watsup:234.1-235.22
 syntax rectype =
   | REC{list : list(syntax subtype)}(list : list(syntax subtype))
 }
@@ -8634,6 +9001,9 @@ syntax tabletype =
 syntax memtype =
   | `%PAGE`{limits : limits}(limits : limits)
 
+;; 1-syntax.watsup
+syntax tagtype = deftype
+
 ;; 1-syntax.watsup
 syntax elemtype = reftype
 
@@ -8647,6 +9017,7 @@ syntax externtype =
   | GLOBAL{globaltype : globaltype}(globaltype : globaltype)
   | TABLE{tabletype : tabletype}(tabletype : tabletype)
   | MEM{memtype : memtype}(memtype : memtype)
+  | TAG{typeuse : typeuse}(typeuse : typeuse)
 
 ;; 1-syntax.watsup
 syntax moduletype =
@@ -9136,6 +9507,9 @@ syntax addr = nat
 ;; 4-runtime.watsup
 syntax arrayaddr = addr
 
+;; 4-runtime.watsup
+syntax exnaddr = addr
+
 ;; 4-runtime.watsup
 syntax funcaddr = addr
 
@@ -9148,16 +9522,24 @@ syntax structaddr = addr
 ;; 4-runtime.watsup
 rec {
 
-;; 4-runtime.watsup:37.1-43.23
+;; 4-runtime.watsup:35.1-42.23
 syntax addrref =
   | REF.I31_NUM{u31 : u31}(u31 : u31)
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
 }
 
+;; 1-syntax.watsup
+syntax catch =
+  | CATCH{tagidx : tagidx, labelidx : labelidx}(tagidx : tagidx, labelidx : labelidx)
+  | CATCH_REF{tagidx : tagidx, labelidx : labelidx}(tagidx : tagidx, labelidx : labelidx)
+  | CATCH_ALL{labelidx : labelidx}(labelidx : labelidx)
+  | CATCH_ALL_REF{labelidx : labelidx}(labelidx : labelidx)
+
 ;; 4-runtime.watsup
 syntax dataaddr = addr
 
@@ -9174,17 +9556,21 @@ syntax memaddr = addr
 syntax tableaddr = addr
 
 ;; 4-runtime.watsup
-syntax externval =
+syntax tagaddr = addr
+
+;; 4-runtime.watsup
+syntax externaddr =
   | FUNC{funcaddr : funcaddr}(funcaddr : funcaddr)
   | GLOBAL{globaladdr : globaladdr}(globaladdr : globaladdr)
   | TABLE{tableaddr : tableaddr}(tableaddr : tableaddr)
   | MEM{memaddr : memaddr}(memaddr : memaddr)
+  | TAG{tagaddr : tagaddr}(tagaddr : tagaddr)
 
 ;; 4-runtime.watsup
 syntax exportinst =
 {
   NAME{name : name} name,
-  VALUE{externval : externval} externval
+  ADDR{externaddr : externaddr} externaddr
 }
 
 ;; 4-runtime.watsup
@@ -9195,6 +9581,7 @@ syntax moduleinst =
   GLOBALS{globaladdr* : globaladdr*} globaladdr*,
   TABLES{tableaddr* : tableaddr*} tableaddr*,
   MEMS{memaddr* : memaddr*} memaddr*,
+  TAGS{tagaddr* : tagaddr*} tagaddr*,
   ELEMS{elemaddr* : elemaddr*} elemaddr*,
   DATAS{dataaddr* : dataaddr*} dataaddr*,
   EXPORTS{exportinst* : exportinst*} exportinst*
@@ -9209,6 +9596,7 @@ syntax val =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
 
@@ -9222,7 +9610,7 @@ syntax frame =
 ;; 4-runtime.watsup
 rec {
 
-;; 4-runtime.watsup:151.1-156.9
+;; 4-runtime.watsup:151.1-157.9
 syntax instr =
   | NOP
   | UNREACHABLE
@@ -9245,6 +9633,9 @@ syntax instr =
   | RETURN_CALL{funcidx : funcidx}(funcidx : funcidx)
   | RETURN_CALL_REF{typeuse : typeuse}(typeuse : typeuse)
   | RETURN_CALL_INDIRECT{tableidx : tableidx, typeuse : typeuse}(tableidx : tableidx, typeuse : typeuse)
+  | THROW{tagidx : tagidx}(tagidx : tagidx)
+  | THROW_REF
+  | TRY_TABLE{blocktype : blocktype, list : list(syntax catch), instr* : instr*}(blocktype : blocktype, list : list(syntax catch), instr*{instr : instr} : instr*)
   | CONST{numtype : numtype, num_ : num_(numtype)}(numtype : numtype, num_ : num_(numtype))
   | UNOP{numtype : numtype, unop_ : unop_(numtype)}(numtype : numtype, unop_ : unop_(numtype))
   | BINOP{numtype : numtype, binop_ : binop_(numtype)}(numtype : numtype, binop_ : binop_(numtype))
@@ -9332,10 +9723,12 @@ syntax instr =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | `LABEL_%{%}%`{n : n, instr* : instr*}(n : n, instr*{instr : instr} : instr*, instr*)
   | `FRAME_%{%}%`{n : n, frame : frame, instr* : instr*}(n : n, frame : frame, instr*{instr : instr} : instr*)
+  | `HANDLER_%{%}%`{n : n, catch* : catch*, instr* : instr*}(n : n, catch*{catch : catch} : catch*, instr*{instr : instr} : instr*)
   | TRAP
 }
 
@@ -9377,6 +9770,10 @@ syntax table =
 syntax mem =
   | MEMORY{memtype : memtype}(memtype : memtype)
 
+;; 1-syntax.watsup
+syntax tag =
+  | TAG{typeidx : typeidx}(typeidx : typeidx)
+
 ;; 1-syntax.watsup
 syntax elem =
   | ELEM{reftype : reftype, expr* : expr*, elemmode : elemmode}(reftype : reftype, expr*{expr : expr} : expr*, elemmode : elemmode)
@@ -9395,6 +9792,7 @@ syntax externidx =
   | GLOBAL{globalidx : globalidx}(globalidx : globalidx)
   | TABLE{tableidx : tableidx}(tableidx : tableidx)
   | MEM{memidx : memidx}(memidx : memidx)
+  | TAG{tagidx : tagidx}(tagidx : tagidx)
 
 ;; 1-syntax.watsup
 syntax export =
@@ -9406,7 +9804,7 @@ syntax import =
 
 ;; 1-syntax.watsup
 syntax module =
-  | MODULE{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*}(type*{type : type} : type*, import*{import : import} : import*, func*{func : func} : func*, global*{global : global} : global*, table*{table : table} : table*, mem*{mem : mem} : mem*, elem*{elem : elem} : elem*, data*{data : data} : data*, start?{start : start} : start?, export*{export : export} : export*)
+  | MODULE{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*}(type*{type : type} : type*, import*{import : import} : import*, func*{func : func} : func*, global*{global : global} : global*, table*{table : table} : table*, mem*{mem : mem} : mem*, tag*{tag : tag} : tag*, elem*{elem : elem} : elem*, data*{data : data} : data*, start?{start : start} : start?, export*{export : export} : export*)
 
 ;; 2-syntax-aux.watsup
 def $IN(N : N) : Inn
@@ -10033,6 +10431,11 @@ def $free_mem(mem : mem) : free
   ;; 2-syntax-aux.watsup
   def $free_mem{memtype : memtype}(MEMORY_mem(memtype)) = $free_memtype(memtype)
 
+;; 2-syntax-aux.watsup
+def $free_tag(tag : tag) : free
+  ;; 2-syntax-aux.watsup
+  def $free_tag{typeidx : typeidx}(TAG_tag(typeidx)) = $free_typeidx(typeidx)
+
 ;; 2-syntax-aux.watsup
 def $free_elemmode(elemmode : elemmode) : free
   ;; 2-syntax-aux.watsup
@@ -10077,7 +10480,7 @@ def $free_import(import : import) : free
 ;; 2-syntax-aux.watsup
 def $free_module(module : module) : free
   ;; 2-syntax-aux.watsup
-  def $free_module{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*}(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})) = $free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})
+  def $free_module{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*}(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})) = $free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_tag(tag)*{tag : tag}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})
 
 ;; 2-syntax-aux.watsup
 def $funcidx_module(module : module) : funcidx*
@@ -10092,14 +10495,14 @@ def $dataidx_funcs(func*) : dataidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:531.1-531.112
+;; 2-syntax-aux.watsup:535.1-535.112
 def $subst_typevar(typevar : typevar, typevar*, typeuse*) : typeuse
-  ;; 2-syntax-aux.watsup:558.1-558.38
+  ;; 2-syntax-aux.watsup:562.1-562.38
   def $subst_typevar{tv : typevar}(tv, [], []) = (tv : typevar <: typeuse)
-  ;; 2-syntax-aux.watsup:559.1-559.95
+  ;; 2-syntax-aux.watsup:563.1-563.95
   def $subst_typevar{tv : typevar, tv_1 : typevar, tv'* : typevar*, tu_1 : typeuse, tu'* : typeuse*}(tv, [tv_1] :: tv'*{tv' : typevar}, [tu_1] :: tu'*{tu' : typeuse}) = tu_1
     -- if (tv = tv_1)
-  ;; 2-syntax-aux.watsup:560.1-560.92
+  ;; 2-syntax-aux.watsup:564.1-564.92
   def $subst_typevar{tv : typevar, tv_1 : typevar, tv'* : typevar*, tu_1 : typeuse, tu'* : typeuse*}(tv, [tv_1] :: tv'*{tv' : typevar}, [tu_1] :: tu'*{tu' : typeuse}) = $subst_typevar(tv, tv'*{tv' : typevar}, tu'*{tu' : typeuse})
     -- otherwise
 }
@@ -10122,78 +10525,78 @@ def $subst_vectype(vectype : vectype, typevar*, typeuse*) : vectype
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:532.1-532.112
+;; 2-syntax-aux.watsup:536.1-536.112
 def $subst_typeuse(typeuse : typeuse, typevar*, typeuse*) : typeuse
-  ;; 2-syntax-aux.watsup:562.1-562.66
+  ;; 2-syntax-aux.watsup:566.1-566.66
   def $subst_typeuse{tv' : typevar, tv* : typevar*, tu* : typeuse*}((tv' : typevar <: typeuse), tv*{tv : typevar}, tu*{tu : typeuse}) = $subst_typevar(tv', tv*{tv : typevar}, tu*{tu : typeuse})
-  ;; 2-syntax-aux.watsup:563.1-563.64
+  ;; 2-syntax-aux.watsup:567.1-567.64
   def $subst_typeuse{dt : deftype, tv* : typevar*, tu* : typeuse*}((dt : deftype <: typeuse), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_deftype(dt, tv*{tv : typevar}, tu*{tu : typeuse}) : deftype <: typeuse)
 
-;; 2-syntax-aux.watsup:536.1-536.112
+;; 2-syntax-aux.watsup:540.1-540.112
 def $subst_heaptype(heaptype : heaptype, typevar*, typeuse*) : heaptype
-  ;; 2-syntax-aux.watsup:568.1-568.67
+  ;; 2-syntax-aux.watsup:572.1-572.67
   def $subst_heaptype{tv' : typevar, tv* : typevar*, tu* : typeuse*}((tv' : typevar <: heaptype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_typevar(tv', tv*{tv : typevar}, tu*{tu : typeuse}) : typeuse <: heaptype)
-  ;; 2-syntax-aux.watsup:569.1-569.65
+  ;; 2-syntax-aux.watsup:573.1-573.65
   def $subst_heaptype{dt : deftype, tv* : typevar*, tu* : typeuse*}((dt : deftype <: heaptype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_deftype(dt, tv*{tv : typevar}, tu*{tu : typeuse}) : deftype <: heaptype)
-  ;; 2-syntax-aux.watsup:570.1-570.53
+  ;; 2-syntax-aux.watsup:574.1-574.53
   def $subst_heaptype{ht : heaptype, tv* : typevar*, tu* : typeuse*}(ht, tv*{tv : typevar}, tu*{tu : typeuse}) = ht
     -- otherwise
 
-;; 2-syntax-aux.watsup:537.1-537.112
+;; 2-syntax-aux.watsup:541.1-541.112
 def $subst_reftype(reftype : reftype, typevar*, typeuse*) : reftype
-  ;; 2-syntax-aux.watsup:572.1-572.83
+  ;; 2-syntax-aux.watsup:576.1-576.83
   def $subst_reftype{nul : nul, ht : heaptype, tv* : typevar*, tu* : typeuse*}(REF_reftype(nul, ht), tv*{tv : typevar}, tu*{tu : typeuse}) = REF_reftype(nul, $subst_heaptype(ht, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:538.1-538.112
+;; 2-syntax-aux.watsup:542.1-542.112
 def $subst_valtype(valtype : valtype, typevar*, typeuse*) : valtype
-  ;; 2-syntax-aux.watsup:574.1-574.64
+  ;; 2-syntax-aux.watsup:578.1-578.64
   def $subst_valtype{nt : numtype, tv* : typevar*, tu* : typeuse*}((nt : numtype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_numtype(nt, tv*{tv : typevar}, tu*{tu : typeuse}) : numtype <: valtype)
-  ;; 2-syntax-aux.watsup:575.1-575.64
+  ;; 2-syntax-aux.watsup:579.1-579.64
   def $subst_valtype{vt : vectype, tv* : typevar*, tu* : typeuse*}((vt : vectype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_vectype(vt, tv*{tv : typevar}, tu*{tu : typeuse}) : vectype <: valtype)
-  ;; 2-syntax-aux.watsup:576.1-576.64
+  ;; 2-syntax-aux.watsup:580.1-580.64
   def $subst_valtype{rt : reftype, tv* : typevar*, tu* : typeuse*}((rt : reftype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_reftype(rt, tv*{tv : typevar}, tu*{tu : typeuse}) : reftype <: valtype)
-  ;; 2-syntax-aux.watsup:577.1-577.40
+  ;; 2-syntax-aux.watsup:581.1-581.40
   def $subst_valtype{tv* : typevar*, tu* : typeuse*}(BOT_valtype, tv*{tv : typevar}, tu*{tu : typeuse}) = BOT_valtype
 
-;; 2-syntax-aux.watsup:541.1-541.112
+;; 2-syntax-aux.watsup:545.1-545.112
 def $subst_storagetype(storagetype : storagetype, typevar*, typeuse*) : storagetype
-  ;; 2-syntax-aux.watsup:581.1-581.66
+  ;; 2-syntax-aux.watsup:585.1-585.66
   def $subst_storagetype{t : valtype, tv* : typevar*, tu* : typeuse*}((t : valtype <: storagetype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_valtype(t, tv*{tv : typevar}, tu*{tu : typeuse}) : valtype <: storagetype)
-  ;; 2-syntax-aux.watsup:582.1-582.69
+  ;; 2-syntax-aux.watsup:586.1-586.69
   def $subst_storagetype{pt : packtype, tv* : typevar*, tu* : typeuse*}((pt : packtype <: storagetype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_packtype(pt, tv*{tv : typevar}, tu*{tu : typeuse}) : packtype <: storagetype)
 
-;; 2-syntax-aux.watsup:542.1-542.112
+;; 2-syntax-aux.watsup:546.1-546.112
 def $subst_fieldtype(fieldtype : fieldtype, typevar*, typeuse*) : fieldtype
-  ;; 2-syntax-aux.watsup:584.1-584.80
+  ;; 2-syntax-aux.watsup:588.1-588.80
   def $subst_fieldtype{mut : mut, zt : storagetype, tv* : typevar*, tu* : typeuse*}(`%%`_fieldtype(mut, zt), tv*{tv : typevar}, tu*{tu : typeuse}) = `%%`_fieldtype(mut, $subst_storagetype(zt, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:544.1-544.112
+;; 2-syntax-aux.watsup:548.1-548.112
 def $subst_comptype(comptype : comptype, typevar*, typeuse*) : comptype
-  ;; 2-syntax-aux.watsup:586.1-586.85
+  ;; 2-syntax-aux.watsup:590.1-590.85
   def $subst_comptype{yt* : fieldtype*, tv* : typevar*, tu* : typeuse*}(STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = STRUCT_comptype(`%`_structtype($subst_fieldtype(yt, tv*{tv : typevar}, tu*{tu : typeuse})*{yt : fieldtype}))
-  ;; 2-syntax-aux.watsup:587.1-587.81
+  ;; 2-syntax-aux.watsup:591.1-591.81
   def $subst_comptype{yt : fieldtype, tv* : typevar*, tu* : typeuse*}(ARRAY_comptype(yt), tv*{tv : typevar}, tu*{tu : typeuse}) = ARRAY_comptype($subst_fieldtype(yt, tv*{tv : typevar}, tu*{tu : typeuse}))
-  ;; 2-syntax-aux.watsup:588.1-588.78
+  ;; 2-syntax-aux.watsup:592.1-592.78
   def $subst_comptype{ft : functype, tv* : typevar*, tu* : typeuse*}(FUNC_comptype(ft), tv*{tv : typevar}, tu*{tu : typeuse}) = FUNC_comptype($subst_functype(ft, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:545.1-545.112
+;; 2-syntax-aux.watsup:549.1-549.112
 def $subst_subtype(subtype : subtype, typevar*, typeuse*) : subtype
-  ;; 2-syntax-aux.watsup:590.1-591.71
+  ;; 2-syntax-aux.watsup:594.1-595.71
   def $subst_subtype{fin : fin, tu'* : typeuse*, ct : comptype, tv* : typevar*, tu* : typeuse*}(SUB_subtype(fin, tu'*{tu' : typeuse}, ct), tv*{tv : typevar}, tu*{tu : typeuse}) = SUB_subtype(fin, $subst_typeuse(tu', tv*{tv : typevar}, tu*{tu : typeuse})*{tu' : typeuse}, $subst_comptype(ct, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:546.1-546.112
+;; 2-syntax-aux.watsup:550.1-550.112
 def $subst_rectype(rectype : rectype, typevar*, typeuse*) : rectype
-  ;; 2-syntax-aux.watsup:593.1-593.76
+  ;; 2-syntax-aux.watsup:597.1-597.76
   def $subst_rectype{st* : subtype*, tv* : typevar*, tu* : typeuse*}(REC_rectype(`%`_list(st*{st : subtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = REC_rectype(`%`_list($subst_subtype(st, tv*{tv : typevar}, tu*{tu : typeuse})*{st : subtype}))
 
-;; 2-syntax-aux.watsup:547.1-547.112
+;; 2-syntax-aux.watsup:551.1-551.112
 def $subst_deftype(deftype : deftype, typevar*, typeuse*) : deftype
-  ;; 2-syntax-aux.watsup:595.1-595.78
+  ;; 2-syntax-aux.watsup:599.1-599.78
   def $subst_deftype{qt : rectype, i : nat, tv* : typevar*, tu* : typeuse*}(DEF_deftype(qt, i), tv*{tv : typevar}, tu*{tu : typeuse}) = DEF_deftype($subst_rectype(qt, tv*{tv : typevar}, tu*{tu : typeuse}), i)
 
-;; 2-syntax-aux.watsup:550.1-550.112
+;; 2-syntax-aux.watsup:554.1-554.112
 def $subst_functype(functype : functype, typevar*, typeuse*) : functype
-  ;; 2-syntax-aux.watsup:598.1-598.113
+  ;; 2-syntax-aux.watsup:602.1-602.113
   def $subst_functype{t_1* : valtype*, t_2* : valtype*, tv* : typevar*, tu* : typeuse*}(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = `%->%`_functype(`%`_resulttype($subst_valtype(t_1, tv*{tv : typevar}, tu*{tu : typeuse})*{t_1 : valtype}), `%`_resulttype($subst_valtype(t_2, tv*{tv : typevar}, tu*{tu : typeuse})*{t_2 : valtype}))
 }
 
@@ -10251,11 +10654,11 @@ def $subst_all_moduletype(moduletype : moduletype, heaptype*) : moduletype
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:620.1-620.98
+;; 2-syntax-aux.watsup:624.1-624.98
 def $subst_all_deftypes(deftype*, heaptype*) : deftype*
-  ;; 2-syntax-aux.watsup:621.1-621.40
+  ;; 2-syntax-aux.watsup:625.1-625.40
   def $subst_all_deftypes{tu* : typeuse*}([], (tu : typeuse <: heaptype)*{tu : typeuse}) = []
-  ;; 2-syntax-aux.watsup:622.1-622.101
+  ;; 2-syntax-aux.watsup:626.1-626.101
   def $subst_all_deftypes{dt_1 : deftype, dt* : deftype*, tu* : typeuse*}([dt_1] :: dt*{dt : deftype}, (tu : typeuse <: heaptype)*{tu : typeuse}) = [$subst_all_deftype(dt_1, (tu : typeuse <: heaptype)*{tu : typeuse})] :: $subst_all_deftypes(dt*{dt : deftype}, (tu : typeuse <: heaptype)*{tu : typeuse})
 }
 
@@ -10299,13 +10702,13 @@ relation Expand: `%~~%`(deftype, comptype)
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:654.1-654.86
+;; 2-syntax-aux.watsup:658.1-658.86
 def $funcsxx(externidx*) : typeidx*
-  ;; 2-syntax-aux.watsup:659.1-659.24
+  ;; 2-syntax-aux.watsup:664.1-664.24
   def $funcsxx([]) = []
-  ;; 2-syntax-aux.watsup:660.1-660.45
+  ;; 2-syntax-aux.watsup:665.1-665.45
   def $funcsxx{x : idx, xx* : externidx*}([FUNC_externidx(x)] :: xx*{xx : externidx}) = [x] :: $funcsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:661.1-661.58
+  ;; 2-syntax-aux.watsup:666.1-666.58
   def $funcsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $funcsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -10313,13 +10716,13 @@ def $funcsxx(externidx*) : typeidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:655.1-655.88
+;; 2-syntax-aux.watsup:659.1-659.88
 def $globalsxx(externidx*) : globalidx*
-  ;; 2-syntax-aux.watsup:663.1-663.26
+  ;; 2-syntax-aux.watsup:668.1-668.26
   def $globalsxx([]) = []
-  ;; 2-syntax-aux.watsup:664.1-664.51
+  ;; 2-syntax-aux.watsup:669.1-669.51
   def $globalsxx{x : idx, xx* : externidx*}([GLOBAL_externidx(x)] :: xx*{xx : externidx}) = [x] :: $globalsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:665.1-665.62
+  ;; 2-syntax-aux.watsup:670.1-670.62
   def $globalsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $globalsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -10327,13 +10730,13 @@ def $globalsxx(externidx*) : globalidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:656.1-656.87
+;; 2-syntax-aux.watsup:660.1-660.87
 def $tablesxx(externidx*) : tableidx*
-  ;; 2-syntax-aux.watsup:667.1-667.25
+  ;; 2-syntax-aux.watsup:672.1-672.25
   def $tablesxx([]) = []
-  ;; 2-syntax-aux.watsup:668.1-668.48
+  ;; 2-syntax-aux.watsup:673.1-673.48
   def $tablesxx{x : idx, xx* : externidx*}([TABLE_externidx(x)] :: xx*{xx : externidx}) = [x] :: $tablesxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:669.1-669.60
+  ;; 2-syntax-aux.watsup:674.1-674.60
   def $tablesxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $tablesxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -10341,13 +10744,13 @@ def $tablesxx(externidx*) : tableidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:657.1-657.85
+;; 2-syntax-aux.watsup:661.1-661.85
 def $memsxx(externidx*) : memidx*
-  ;; 2-syntax-aux.watsup:671.1-671.23
+  ;; 2-syntax-aux.watsup:676.1-676.23
   def $memsxx([]) = []
-  ;; 2-syntax-aux.watsup:672.1-672.42
+  ;; 2-syntax-aux.watsup:677.1-677.42
   def $memsxx{x : idx, xx* : externidx*}([MEM_externidx(x)] :: xx*{xx : externidx}) = [x] :: $memsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:673.1-673.56
+  ;; 2-syntax-aux.watsup:678.1-678.56
   def $memsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $memsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -10355,13 +10758,27 @@ def $memsxx(externidx*) : memidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:676.1-676.88
-def $funcsxt(externtype*) : deftype*
-  ;; 2-syntax-aux.watsup:681.1-681.24
-  def $funcsxt([]) = []
-  ;; 2-syntax-aux.watsup:682.1-682.47
-  def $funcsxt{dt : deftype, xt* : externtype*}([FUNC_externtype((dt : deftype <: typeuse))] :: xt*{xt : externtype}) = [dt] :: $funcsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:683.1-683.59
+;; 2-syntax-aux.watsup:662.1-662.85
+def $tagsxx(externidx*) : tagidx*
+  ;; 2-syntax-aux.watsup:680.1-680.23
+  def $tagsxx([]) = []
+  ;; 2-syntax-aux.watsup:681.1-681.42
+  def $tagsxx{x : idx, xx* : externidx*}([TAG_externidx(x)] :: xx*{xx : externidx}) = [x] :: $tagsxx(xx*{xx : externidx})
+  ;; 2-syntax-aux.watsup:682.1-682.56
+  def $tagsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $tagsxx(xx*{xx : externidx})
+    -- otherwise
+}
+
+;; 2-syntax-aux.watsup
+rec {
+
+;; 2-syntax-aux.watsup:685.1-685.88
+def $funcsxt(externtype*) : deftype*
+  ;; 2-syntax-aux.watsup:691.1-691.24
+  def $funcsxt([]) = []
+  ;; 2-syntax-aux.watsup:692.1-692.47
+  def $funcsxt{dt : deftype, xt* : externtype*}([FUNC_externtype((dt : deftype <: typeuse))] :: xt*{xt : externtype}) = [dt] :: $funcsxt(xt*{xt : externtype})
+  ;; 2-syntax-aux.watsup:693.1-693.59
   def $funcsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $funcsxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -10369,13 +10786,13 @@ def $funcsxt(externtype*) : deftype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:677.1-677.90
+;; 2-syntax-aux.watsup:686.1-686.90
 def $globalsxt(externtype*) : globaltype*
-  ;; 2-syntax-aux.watsup:685.1-685.26
+  ;; 2-syntax-aux.watsup:695.1-695.26
   def $globalsxt([]) = []
-  ;; 2-syntax-aux.watsup:686.1-686.53
+  ;; 2-syntax-aux.watsup:696.1-696.53
   def $globalsxt{gt : globaltype, xt* : externtype*}([GLOBAL_externtype(gt)] :: xt*{xt : externtype}) = [gt] :: $globalsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:687.1-687.63
+  ;; 2-syntax-aux.watsup:697.1-697.63
   def $globalsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $globalsxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -10383,13 +10800,13 @@ def $globalsxt(externtype*) : globaltype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:678.1-678.89
+;; 2-syntax-aux.watsup:687.1-687.89
 def $tablesxt(externtype*) : tabletype*
-  ;; 2-syntax-aux.watsup:689.1-689.25
+  ;; 2-syntax-aux.watsup:699.1-699.25
   def $tablesxt([]) = []
-  ;; 2-syntax-aux.watsup:690.1-690.50
+  ;; 2-syntax-aux.watsup:700.1-700.50
   def $tablesxt{tt : tabletype, xt* : externtype*}([TABLE_externtype(tt)] :: xt*{xt : externtype}) = [tt] :: $tablesxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:691.1-691.61
+  ;; 2-syntax-aux.watsup:701.1-701.61
   def $tablesxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $tablesxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -10397,17 +10814,31 @@ def $tablesxt(externtype*) : tabletype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:679.1-679.87
+;; 2-syntax-aux.watsup:688.1-688.87
 def $memsxt(externtype*) : memtype*
-  ;; 2-syntax-aux.watsup:693.1-693.23
+  ;; 2-syntax-aux.watsup:703.1-703.23
   def $memsxt([]) = []
-  ;; 2-syntax-aux.watsup:694.1-694.44
+  ;; 2-syntax-aux.watsup:704.1-704.44
   def $memsxt{mt : memtype, xt* : externtype*}([MEM_externtype(mt)] :: xt*{xt : externtype}) = [mt] :: $memsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:695.1-695.57
+  ;; 2-syntax-aux.watsup:705.1-705.57
   def $memsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $memsxt(xt*{xt : externtype})
     -- otherwise
 }
 
+;; 2-syntax-aux.watsup
+rec {
+
+;; 2-syntax-aux.watsup:689.1-689.87
+def $tagsxt(externtype*) : tagtype*
+  ;; 2-syntax-aux.watsup:707.1-707.23
+  def $tagsxt([]) = []
+  ;; 2-syntax-aux.watsup:708.1-708.44
+  def $tagsxt{at : tagtype, xt* : externtype*}([TAG_externtype((at : deftype <: typeuse))] :: xt*{xt : externtype}) = [at] :: $tagsxt(xt*{xt : externtype})
+  ;; 2-syntax-aux.watsup:709.1-709.57
+  def $tagsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $tagsxt(xt*{xt : externtype})
+    -- otherwise
+}
+
 ;; 2-syntax-aux.watsup
 def $memarg0 : memarg
   ;; 2-syntax-aux.watsup
@@ -11135,6 +11566,7 @@ syntax ref =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | REF.NULL{heaptype : heaptype}(heaptype : heaptype)
@@ -11142,6 +11574,7 @@ syntax ref =
 ;; 4-runtime.watsup
 syntax result =
   | _VALS{val* : val*}(val*{val : val} : val*)
+  | `_EXN(REF.EXN_ADDR%)THROW_REF`{exnaddr : exnaddr}(exnaddr : exnaddr)
   | TRAP
 
 ;; 4-runtime.watsup
@@ -11182,6 +11615,12 @@ syntax meminst =
   BYTES{byte* : byte*} byte*
 }
 
+;; 4-runtime.watsup
+syntax taginst =
+{
+  TYPE{tagtype : tagtype} tagtype
+}
+
 ;; 4-runtime.watsup
 syntax eleminst =
 {
@@ -11208,6 +11647,7 @@ syntax fieldval =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | PACK{packtype : packtype, iN : iN($psizenn(packtype))}(packtype : packtype, iN : iN($psizenn(packtype)))
@@ -11226,6 +11666,13 @@ syntax arrayinst =
   FIELDS{fieldval* : fieldval*} fieldval*
 }
 
+;; 4-runtime.watsup
+syntax exninst =
+{
+  TAG{tagaddr : tagaddr} tagaddr,
+  FIELDS{val* : val*} val*
+}
+
 ;; 4-runtime.watsup
 syntax store =
 {
@@ -11233,10 +11680,12 @@ syntax store =
   GLOBALS{globalinst* : globalinst*} globalinst*,
   TABLES{tableinst* : tableinst*} tableinst*,
   MEMS{meminst* : meminst*} meminst*,
+  TAGS{taginst* : taginst*} taginst*,
   ELEMS{eleminst* : eleminst*} eleminst*,
   DATAS{datainst* : datainst*} datainst*,
   STRUCTS{structinst* : structinst*} structinst*,
-  ARRAYS{arrayinst* : arrayinst*} arrayinst*
+  ARRAYS{arrayinst* : arrayinst*} arrayinst*,
+  EXNS{exninst* : exninst*} exninst*
 }
 
 ;; 4-runtime.watsup
@@ -11289,56 +11738,70 @@ def $unpackfield_(storagetype : storagetype, sx?, fieldval : fieldval) : val
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:46.1-46.86
-def $funcsxv(externval*) : funcaddr*
-  ;; 5-runtime-aux.watsup:51.1-51.24
-  def $funcsxv([]) = []
-  ;; 5-runtime-aux.watsup:52.1-52.47
-  def $funcsxv{fa : funcaddr, xv* : externval*}([FUNC_externval(fa)] :: xv*{xv : externval}) = [fa] :: $funcsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:53.1-53.58
-  def $funcsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $funcsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:46.1-46.87
+def $funcsxa(externaddr*) : funcaddr*
+  ;; 5-runtime-aux.watsup:52.1-52.24
+  def $funcsxa([]) = []
+  ;; 5-runtime-aux.watsup:53.1-53.47
+  def $funcsxa{fa : funcaddr, xa* : externaddr*}([FUNC_externaddr(fa)] :: xa*{xa : externaddr}) = [fa] :: $funcsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:54.1-54.59
+  def $funcsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $funcsxa(xa*{xa : externaddr})
+    -- otherwise
+}
+
+;; 5-runtime-aux.watsup
+rec {
+
+;; 5-runtime-aux.watsup:47.1-47.89
+def $globalsxa(externaddr*) : globaladdr*
+  ;; 5-runtime-aux.watsup:56.1-56.26
+  def $globalsxa([]) = []
+  ;; 5-runtime-aux.watsup:57.1-57.53
+  def $globalsxa{ga : globaladdr, xa* : externaddr*}([GLOBAL_externaddr(ga)] :: xa*{xa : externaddr}) = [ga] :: $globalsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:58.1-58.63
+  def $globalsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $globalsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:47.1-47.88
-def $globalsxv(externval*) : globaladdr*
-  ;; 5-runtime-aux.watsup:55.1-55.26
-  def $globalsxv([]) = []
-  ;; 5-runtime-aux.watsup:56.1-56.53
-  def $globalsxv{ga : globaladdr, xv* : externval*}([GLOBAL_externval(ga)] :: xv*{xv : externval}) = [ga] :: $globalsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:57.1-57.62
-  def $globalsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $globalsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:48.1-48.88
+def $tablesxa(externaddr*) : tableaddr*
+  ;; 5-runtime-aux.watsup:60.1-60.25
+  def $tablesxa([]) = []
+  ;; 5-runtime-aux.watsup:61.1-61.50
+  def $tablesxa{ta : tableaddr, xa* : externaddr*}([TABLE_externaddr(ta)] :: xa*{xa : externaddr}) = [ta] :: $tablesxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:62.1-62.61
+  def $tablesxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $tablesxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:48.1-48.87
-def $tablesxv(externval*) : tableaddr*
-  ;; 5-runtime-aux.watsup:59.1-59.25
-  def $tablesxv([]) = []
-  ;; 5-runtime-aux.watsup:60.1-60.50
-  def $tablesxv{ta : tableaddr, xv* : externval*}([TABLE_externval(ta)] :: xv*{xv : externval}) = [ta] :: $tablesxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:61.1-61.60
-  def $tablesxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $tablesxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:49.1-49.86
+def $memsxa(externaddr*) : memaddr*
+  ;; 5-runtime-aux.watsup:64.1-64.23
+  def $memsxa([]) = []
+  ;; 5-runtime-aux.watsup:65.1-65.44
+  def $memsxa{ma : memaddr, xa* : externaddr*}([MEM_externaddr(ma)] :: xa*{xa : externaddr}) = [ma] :: $memsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:66.1-66.57
+  def $memsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $memsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:49.1-49.85
-def $memsxv(externval*) : memaddr*
-  ;; 5-runtime-aux.watsup:63.1-63.23
-  def $memsxv([]) = []
-  ;; 5-runtime-aux.watsup:64.1-64.44
-  def $memsxv{ma : memaddr, xv* : externval*}([MEM_externval(ma)] :: xv*{xv : externval}) = [ma] :: $memsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:65.1-65.56
-  def $memsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $memsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:50.1-50.86
+def $tagsxa(externaddr*) : tagaddr*
+  ;; 5-runtime-aux.watsup:68.1-68.23
+  def $tagsxa([]) = []
+  ;; 5-runtime-aux.watsup:69.1-69.44
+  def $tagsxa{ha : tagaddr, xa* : externaddr*}([TAG_externaddr(ha)] :: xa*{xa : externaddr}) = [ha] :: $tagsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:70.1-70.57
+  def $tagsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $tagsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
@@ -11352,6 +11815,11 @@ def $frame(state : state) : frame
   ;; 5-runtime-aux.watsup
   def $frame{s : store, f : frame}(`%;%`_state(s, f)) = f
 
+;; 5-runtime-aux.watsup
+def $tagaddr(state : state) : tagaddr*
+  ;; 5-runtime-aux.watsup
+  def $tagaddr{s : store, f : frame}(`%;%`_state(s, f)) = f.MODULE_frame.TAGS_moduleinst
+
 ;; 5-runtime-aux.watsup
 def $moduleinst(state : state) : moduleinst
   ;; 5-runtime-aux.watsup
@@ -11377,6 +11845,11 @@ def $meminst(state : state) : meminst*
   ;; 5-runtime-aux.watsup
   def $meminst{s : store, f : frame}(`%;%`_state(s, f)) = s.MEMS_store
 
+;; 5-runtime-aux.watsup
+def $taginst(state : state) : taginst*
+  ;; 5-runtime-aux.watsup
+  def $taginst{s : store, f : frame}(`%;%`_state(s, f)) = s.TAGS_store
+
 ;; 5-runtime-aux.watsup
 def $eleminst(state : state) : eleminst*
   ;; 5-runtime-aux.watsup
@@ -11397,6 +11870,11 @@ def $arrayinst(state : state) : arrayinst*
   ;; 5-runtime-aux.watsup
   def $arrayinst{s : store, f : frame}(`%;%`_state(s, f)) = s.ARRAYS_store
 
+;; 5-runtime-aux.watsup
+def $exninst(state : state) : exninst*
+  ;; 5-runtime-aux.watsup
+  def $exninst{s : store, f : frame}(`%;%`_state(s, f)) = s.EXNS_store
+
 ;; 5-runtime-aux.watsup
 def $type(state : state, typeidx : typeidx) : deftype
   ;; 5-runtime-aux.watsup
@@ -11422,6 +11900,11 @@ def $mem(state : state, memidx : memidx) : meminst
   ;; 5-runtime-aux.watsup
   def $mem{s : store, f : frame, x : idx}(`%;%`_state(s, f), x) = s.MEMS_store[f.MODULE_frame.MEMS_moduleinst[x!`%`_idx.0]]
 
+;; 5-runtime-aux.watsup
+def $tag(state : state, tagidx : tagidx) : taginst
+  ;; 5-runtime-aux.watsup
+  def $tag{s : store, f : frame, x : idx}(`%;%`_state(s, f), x) = s.TAGS_store[f.MODULE_frame.TAGS_moduleinst[x!`%`_idx.0]]
+
 ;; 5-runtime-aux.watsup
 def $elem(state : state, tableidx : tableidx) : eleminst
   ;; 5-runtime-aux.watsup
@@ -11497,6 +11980,11 @@ def $add_arrayinst(state : state, arrayinst*) : state
   ;; 5-runtime-aux.watsup
   def $add_arrayinst{s : store, f : frame, ai* : arrayinst*}(`%;%`_state(s, f), ai*{ai : arrayinst}) = `%;%`_state(s[ARRAYS_store =++ ai*{ai : arrayinst}], f)
 
+;; 5-runtime-aux.watsup
+def $add_exninst(state : state, exninst*) : state
+  ;; 5-runtime-aux.watsup
+  def $add_exninst{s : store, f : frame, exn* : exninst*}(`%;%`_state(s, f), exn*{exn : exninst}) = `%;%`_state(s[EXNS_store =++ exn*{exn : exninst}], f)
+
 ;; 5-runtime-aux.watsup
 def $growtable(tableinst : tableinst, nat : nat, ref : ref) : tableinst?
   ;; 5-runtime-aux.watsup
@@ -11537,6 +12025,7 @@ syntax context =
   GLOBALS{globaltype* : globaltype*} globaltype*,
   TABLES{tabletype* : tabletype*} tabletype*,
   MEMS{memtype* : memtype*} memtype*,
+  TAGS{tagtype* : tagtype*} tagtype*,
   ELEMS{elemtype* : elemtype*} elemtype*,
   DATAS{datatype* : datatype*} datatype*,
   LOCALS{localtype* : localtype*} localtype*,
@@ -11548,22 +12037,22 @@ syntax context =
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:36.1-36.86
+;; 6-typing.watsup:37.1-37.86
 def $with_locals(context : context, localidx*, localtype*) : context
-  ;; 6-typing.watsup:38.1-38.34
+  ;; 6-typing.watsup:39.1-39.34
   def $with_locals{C : context}(C, [], []) = C
-  ;; 6-typing.watsup:39.1-39.90
+  ;; 6-typing.watsup:40.1-40.90
   def $with_locals{C : context, x_1 : idx, x* : idx*, lct_1 : localtype, lct* : localtype*}(C, [x_1] :: x*{x : localidx}, [lct_1] :: lct*{lct : localtype}) = $with_locals(C[LOCALS_context[x_1!`%`_idx.0] = lct_1], x*{x : localidx}, lct*{lct : localtype})
 }
 
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:45.1-45.94
+;; 6-typing.watsup:46.1-46.94
 def $clos_deftypes(deftype*) : deftype*
-  ;; 6-typing.watsup:52.1-52.30
+  ;; 6-typing.watsup:53.1-53.30
   def $clos_deftypes([]) = []
-  ;; 6-typing.watsup:53.1-53.101
+  ;; 6-typing.watsup:54.1-54.101
   def $clos_deftypes{dt* : deftype*, dt_n : deftype, dt'* : deftype*}(dt*{dt : deftype} :: [dt_n]) = dt'*{dt' : deftype} :: [$subst_all_deftype(dt_n, (dt' : deftype <: heaptype)*{dt' : deftype})]
     -- if (dt'*{dt' : deftype} = $clos_deftypes(dt*{dt : deftype}))
 }
@@ -11731,99 +12220,99 @@ relation Numtype_sub: `%|-%<:%`(context, numtype, numtype)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:140.1-140.107
+;; 6-typing.watsup:141.1-141.107
 relation Deftype_sub: `%|-%<:%`(context, deftype, deftype)
-  ;; 6-typing.watsup:451.1-453.66
+  ;; 6-typing.watsup:462.1-464.66
   rule refl{C : context, deftype_1 : deftype, deftype_2 : deftype}:
     `%|-%<:%`(C, deftype_1, deftype_2)
     -- if ($clos_deftype(C, deftype_1) = $clos_deftype(C, deftype_2))
 
-  ;; 6-typing.watsup:455.1-458.49
+  ;; 6-typing.watsup:466.1-469.49
   rule super{C : context, deftype_1 : deftype, deftype_2 : deftype, fin : fin, typeuse* : typeuse*, ct : comptype, i : nat}:
     `%|-%<:%`(C, deftype_1, deftype_2)
     -- if ($unrolldt(deftype_1) = SUB_subtype(fin, typeuse*{typeuse : typeuse}, ct))
     -- Heaptype_sub: `%|-%<:%`(C, (typeuse*{typeuse : typeuse}[i] : typeuse <: heaptype), (deftype_2 : deftype <: heaptype))
 
-;; 6-typing.watsup:288.1-288.104
+;; 6-typing.watsup:299.1-299.104
 relation Heaptype_sub: `%|-%<:%`(context, heaptype, heaptype)
-  ;; 6-typing.watsup:299.1-300.28
+  ;; 6-typing.watsup:310.1-311.28
   rule refl{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, heaptype, heaptype)
 
-  ;; 6-typing.watsup:302.1-306.48
+  ;; 6-typing.watsup:313.1-317.48
   rule trans{C : context, heaptype_1 : heaptype, heaptype_2 : heaptype, heaptype' : heaptype}:
     `%|-%<:%`(C, heaptype_1, heaptype_2)
     -- Heaptype_ok: `%|-%:OK`(C, heaptype')
     -- Heaptype_sub: `%|-%<:%`(C, heaptype_1, heaptype')
     -- Heaptype_sub: `%|-%<:%`(C, heaptype', heaptype_2)
 
-  ;; 6-typing.watsup:308.1-309.17
+  ;; 6-typing.watsup:319.1-320.17
   rule eq-any{C : context}:
     `%|-%<:%`(C, EQ_heaptype, ANY_heaptype)
 
-  ;; 6-typing.watsup:311.1-312.17
+  ;; 6-typing.watsup:322.1-323.17
   rule i31-eq{C : context}:
     `%|-%<:%`(C, I31_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:314.1-315.20
+  ;; 6-typing.watsup:325.1-326.20
   rule struct-eq{C : context}:
     `%|-%<:%`(C, STRUCT_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:317.1-318.19
+  ;; 6-typing.watsup:328.1-329.19
   rule array-eq{C : context}:
     `%|-%<:%`(C, ARRAY_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:320.1-322.42
+  ;; 6-typing.watsup:331.1-333.42
   rule struct{C : context, deftype : deftype, fieldtype* : fieldtype*}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), STRUCT_heaptype)
     -- Expand: `%~~%`(deftype, STRUCT_comptype(`%`_structtype(fieldtype*{fieldtype : fieldtype})))
 
-  ;; 6-typing.watsup:324.1-326.40
+  ;; 6-typing.watsup:335.1-337.40
   rule array{C : context, deftype : deftype, fieldtype : fieldtype}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), ARRAY_heaptype)
     -- Expand: `%~~%`(deftype, ARRAY_comptype(fieldtype))
 
-  ;; 6-typing.watsup:328.1-330.38
+  ;; 6-typing.watsup:339.1-341.38
   rule func{C : context, deftype : deftype, functype : functype}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), FUNC_heaptype)
     -- Expand: `%~~%`(deftype, FUNC_comptype(functype))
 
-  ;; 6-typing.watsup:332.1-334.46
+  ;; 6-typing.watsup:343.1-345.46
   rule def{C : context, deftype_1 : deftype, deftype_2 : deftype}:
     `%|-%<:%`(C, (deftype_1 : deftype <: heaptype), (deftype_2 : deftype <: heaptype))
     -- Deftype_sub: `%|-%<:%`(C, deftype_1, deftype_2)
 
-  ;; 6-typing.watsup:336.1-338.53
+  ;; 6-typing.watsup:347.1-349.53
   rule typeidx-l{C : context, typeidx : typeidx, heaptype : heaptype}:
     `%|-%<:%`(C, _IDX_heaptype(typeidx), heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, (C.TYPES_context[typeidx!`%`_typeidx.0] : deftype <: heaptype), heaptype)
 
-  ;; 6-typing.watsup:340.1-342.53
+  ;; 6-typing.watsup:351.1-353.53
   rule typeidx-r{C : context, heaptype : heaptype, typeidx : typeidx}:
     `%|-%<:%`(C, heaptype, _IDX_heaptype(typeidx))
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, (C.TYPES_context[typeidx!`%`_typeidx.0] : deftype <: heaptype))
 
-  ;; 6-typing.watsup:344.1-346.40
+  ;; 6-typing.watsup:355.1-357.40
   rule rec{C : context, i : nat, typeuse* : typeuse*, j : nat, fin : fin, ct : comptype}:
     `%|-%<:%`(C, REC_heaptype(i), (typeuse*{typeuse : typeuse}[j] : typeuse <: heaptype))
     -- if (C.RECS_context[i] = SUB_subtype(fin, typeuse*{typeuse : typeuse}, ct))
 
-  ;; 6-typing.watsup:348.1-350.40
+  ;; 6-typing.watsup:359.1-361.40
   rule none{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NONE_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, ANY_heaptype)
 
-  ;; 6-typing.watsup:352.1-354.41
+  ;; 6-typing.watsup:363.1-365.41
   rule nofunc{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NOFUNC_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, FUNC_heaptype)
 
-  ;; 6-typing.watsup:356.1-358.43
+  ;; 6-typing.watsup:367.1-369.43
   rule noextern{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NOEXTERN_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, EXTERN_heaptype)
 
-  ;; 6-typing.watsup:360.1-361.23
+  ;; 6-typing.watsup:371.1-372.23
   rule bot{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, BOT_heaptype, heaptype)
 }
@@ -11967,13 +12456,13 @@ relation Subtype_ok2: `%|-%:%`(context, subtype, oktypeidxnat)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:135.1-135.105
+;; 6-typing.watsup:136.1-136.105
 relation Rectype_ok2: `%|-%:%`(context, rectype, oktypeidxnat)
-  ;; 6-typing.watsup:213.1-214.24
+  ;; 6-typing.watsup:214.1-215.24
   rule empty{C : context, x : idx, i : nat}:
     `%|-%:%`(C, REC_rectype(`%`_list([])), OK_oktypeidxnat(x, i))
 
-  ;; 6-typing.watsup:216.1-219.55
+  ;; 6-typing.watsup:217.1-220.55
   rule cons{C : context, subtype_1 : subtype, subtype* : subtype*, x : idx, i : nat}:
     `%|-%:%`(C, REC_rectype(`%`_list([subtype_1] :: subtype*{subtype : subtype})), OK_oktypeidxnat(x, i))
     -- Subtype_ok2: `%|-%:%`(C, subtype_1, OK_oktypeidxnat(x, i))
@@ -11983,22 +12472,22 @@ relation Rectype_ok2: `%|-%:%`(context, rectype, oktypeidxnat)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:133.1-133.102
+;; 6-typing.watsup:134.1-134.102
 relation Rectype_ok: `%|-%:%`(context, rectype, oktypeidx)
-  ;; 6-typing.watsup:201.1-202.23
+  ;; 6-typing.watsup:202.1-203.23
   rule empty{C : context, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list([])), OK_oktypeidx(x))
 
-  ;; 6-typing.watsup:204.1-207.48
+  ;; 6-typing.watsup:205.1-208.48
   rule cons{C : context, subtype_1 : subtype, subtype* : subtype*, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list([subtype_1] :: subtype*{subtype : subtype})), OK_oktypeidx(x))
     -- Subtype_ok: `%|-%:%`(C, subtype_1, OK_oktypeidx(x))
     -- Rectype_ok: `%|-%:%`(C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidx(`%`_typeidx((x!`%`_idx.0 + 1))))
 
-  ;; 6-typing.watsup:209.1-211.60
+  ;; 6-typing.watsup:210.1-212.60
   rule rec2{C : context, subtype* : subtype*, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidx(x))
-    -- Rectype_ok2: `%|-%:%`({TYPES [], RECS subtype*{subtype : subtype}, FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []} ++ C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidxnat(x, 0))
+    -- Rectype_ok2: `%|-%:%`({TYPES [], RECS subtype*{subtype : subtype}, FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []} ++ C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidxnat(x, 0))
 }
 
 ;; 6-typing.watsup
@@ -12039,6 +12528,14 @@ relation Memtype_ok: `%|-%:OK`(context, memtype)
     `%|-%:OK`(C, `%PAGE`_memtype(limits))
     -- Limits_ok: `%|-%:%`(C, limits, (2 ^ 16))
 
+;; 6-typing.watsup
+relation Tagtype_ok: `%|-%:OK`(context, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, deftype : deftype, functype : functype}:
+    `%|-%:OK`(C, deftype)
+    -- Deftype_ok: `%|-%:OK`(C, deftype)
+    -- Expand: `%~~%`(deftype, FUNC_comptype(functype))
+
 ;; 6-typing.watsup
 relation Externtype_ok: `%|-%:OK`(context, externtype)
   ;; 6-typing.watsup
@@ -12062,6 +12559,11 @@ relation Externtype_ok: `%|-%:OK`(context, externtype)
     `%|-%:OK`(C, MEM_externtype(memtype))
     -- Memtype_ok: `%|-%:OK`(C, memtype)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, tagtype : tagtype}:
+    `%|-%:OK`(C, TAG_externtype((tagtype : deftype <: typeuse)))
+    -- Tagtype_ok: `%|-%:OK`(C, tagtype)
+
 ;; 6-typing.watsup
 relation Instrtype_sub: `%|-%<:%`(context, instrtype, instrtype)
   ;; 6-typing.watsup
@@ -12109,6 +12611,14 @@ relation Memtype_sub: `%|-%<:%`(context, memtype, memtype)
     `%|-%<:%`(C, `%PAGE`_memtype(limits_1), `%PAGE`_memtype(limits_2))
     -- Limits_sub: `%|-%<:%`(C, limits_1, limits_2)
 
+;; 6-typing.watsup
+relation Tagtype_sub: `%|-%<:%`(context, tagtype, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, deftype_1 : deftype, deftype_2 : deftype}:
+    `%|-%<:%`(C, deftype_1, deftype_2)
+    -- Deftype_sub: `%|-%<:%`(C, deftype_1, deftype_2)
+    -- Deftype_sub: `%|-%<:%`(C, deftype_2, deftype_1)
+
 ;; 6-typing.watsup
 relation Externtype_sub: `%|-%<:%`(context, externtype, externtype)
   ;; 6-typing.watsup
@@ -12131,6 +12641,11 @@ relation Externtype_sub: `%|-%<:%`(context, externtype, externtype)
     `%|-%<:%`(C, MEM_externtype(memtype_1), MEM_externtype(memtype_2))
     -- Memtype_sub: `%|-%<:%`(C, memtype_1, memtype_2)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, tagtype_1 : tagtype, tagtype_2 : tagtype}:
+    `%|-%<:%`(C, TAG_externtype((tagtype_1 : deftype <: typeuse)), TAG_externtype((tagtype_2 : deftype <: typeuse)))
+    -- Tagtype_sub: `%|-%<:%`(C, tagtype_1, tagtype_2)
+
 ;; 6-typing.watsup
 relation Blocktype_ok: `%|-%:%`(context, blocktype, instrtype)
   ;; 6-typing.watsup
@@ -12143,86 +12658,110 @@ relation Blocktype_ok: `%|-%:%`(context, blocktype, instrtype)
     `%|-%:%`(C, _IDX_blocktype(typeidx), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[typeidx!`%`_typeidx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
+;; 6-typing.watsup
+relation Catch_ok: `%|-%:OK`(context, catch)
+  ;; 6-typing.watsup
+  rule catch{C : context, x : idx, l : labelidx, t* : valtype*}:
+    `%|-%:OK`(C, CATCH_catch(x, l))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_ref{C : context, x : idx, l : labelidx, t* : valtype*}:
+    `%|-%:OK`(C, CATCH_REF_catch(x, l))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), EXN_heaptype)], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_all{C : context, l : labelidx}:
+    `%|-%:OK`(C, CATCH_ALL_catch(l))
+    -- Resulttype_sub: `%|-%<:%`(C, [], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_all_ref{C : context, l : labelidx}:
+    `%|-%:OK`(C, CATCH_ALL_REF_catch(l))
+    -- Resulttype_sub: `%|-%<:%`(C, [REF_valtype(`NULL%?`_nul(?()), EXN_heaptype)], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:522.1-522.95
+;; 6-typing.watsup:543.1-543.95
 relation Instr_ok: `%|-%:%`(context, instr, instrtype)
-  ;; 6-typing.watsup:561.1-562.24
+  ;; 6-typing.watsup:582.1-583.24
   rule nop{C : context}:
     `%|-%:%`(C, NOP_instr, `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
 
-  ;; 6-typing.watsup:564.1-566.42
+  ;; 6-typing.watsup:585.1-587.42
   rule unreachable{C : context, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, UNREACHABLE_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:568.1-570.29
+  ;; 6-typing.watsup:589.1-591.29
   rule drop{C : context, t : valtype}:
     `%|-%:%`(C, DROP_instr, `%->_%%`_instrtype(`%`_resulttype([t]), [], `%`_resulttype([])))
     -- Valtype_ok: `%|-%:OK`(C, t)
 
-  ;; 6-typing.watsup:573.1-575.29
+  ;; 6-typing.watsup:594.1-596.29
   rule select-expl{C : context, t : valtype}:
     `%|-%:%`(C, `SELECT()%?`_instr(?([t])), `%->_%%`_instrtype(`%`_resulttype([t t I32_valtype]), [], `%`_resulttype([t])))
     -- Valtype_ok: `%|-%:OK`(C, t)
 
-  ;; 6-typing.watsup:577.1-581.37
+  ;; 6-typing.watsup:598.1-602.37
   rule select-impl{C : context, t : valtype, t' : valtype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, `SELECT()%?`_instr(?()), `%->_%%`_instrtype(`%`_resulttype([t t I32_valtype]), [], `%`_resulttype([t])))
     -- Valtype_ok: `%|-%:OK`(C, t)
     -- Valtype_sub: `%|-%<:%`(C, t, t')
     -- if ((t' = (numtype : numtype <: valtype)) \/ (t' = (vectype : vectype <: valtype)))
 
-  ;; 6-typing.watsup:597.1-600.67
+  ;; 6-typing.watsup:618.1-621.67
   rule block{C : context, bt : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
     `%|-%:%`(C, BLOCK_instr(bt, instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:602.1-605.67
+  ;; 6-typing.watsup:623.1-626.67
   rule loop{C : context, bt : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
     `%|-%:%`(C, LOOP_instr(bt, instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_1*{t_1 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_1*{t_1 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:607.1-611.71
+  ;; 6-typing.watsup:628.1-632.71
   rule if{C : context, bt : blocktype, instr_1* : instr*, instr_2* : instr*, t_1* : valtype*, t_2* : valtype*, x_1* : idx*, x_2* : idx*}:
     `%|-%:%`(C, `IF%%ELSE%`_instr(bt, instr_1*{instr_1 : instr}, instr_2*{instr_2 : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_1*{instr_1 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_1*{instr_1 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:616.1-619.42
+  ;; 6-typing.watsup:637.1-640.42
   rule br{C : context, l : labelidx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, BR_instr(l), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:621.1-623.25
+  ;; 6-typing.watsup:642.1-644.25
   rule br_if{C : context, l : labelidx, t* : valtype*}:
     `%|-%:%`(C, BR_IF_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [I32_valtype]), [], `%`_resulttype(t*{t : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
 
-  ;; 6-typing.watsup:625.1-629.42
+  ;; 6-typing.watsup:646.1-650.42
   rule br_table{C : context, l* : labelidx*, l' : labelidx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, BR_TABLE_instr(l*{l : labelidx}, l'), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- (Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0))*{l : labelidx}
     -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l'!`%`_labelidx.0]!`%`_resulttype.0)
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:631.1-634.31
+  ;; 6-typing.watsup:652.1-655.31
   rule br_on_null{C : context, l : labelidx, t* : valtype*, ht : heaptype}:
     `%|-%:%`(C, BR_ON_NULL_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), ht)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:636.1-638.34
+  ;; 6-typing.watsup:657.1-659.34
   rule br_on_non_null{C : context, l : labelidx, t* : valtype*, ht : heaptype}:
     `%|-%:%`(C, BR_ON_NON_NULL_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype(t*{t : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), ht)]))
 
-  ;; 6-typing.watsup:640.1-646.34
+  ;; 6-typing.watsup:661.1-667.34
   rule br_on_cast{C : context, l : labelidx, rt_1 : reftype, rt_2 : reftype, t* : valtype*, rt : reftype}:
     `%|-%:%`(C, BR_ON_CAST_instr(l, rt_1, rt_2), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [(rt_1 : reftype <: valtype)]), [], `%`_resulttype(t*{t : valtype} :: [($diffrt(rt_1, rt_2) : reftype <: valtype)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [(rt : reftype <: valtype)]))
@@ -12231,7 +12770,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt)
 
-  ;; 6-typing.watsup:648.1-654.49
+  ;; 6-typing.watsup:669.1-675.49
   rule br_on_cast_fail{C : context, l : labelidx, rt_1 : reftype, rt_2 : reftype, t* : valtype*, rt : reftype}:
     `%|-%:%`(C, BR_ON_CAST_FAIL_instr(l, rt_1, rt_2), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [(rt_1 : reftype <: valtype)]), [], `%`_resulttype(t*{t : valtype} :: [(rt_2 : reftype <: valtype)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [(rt : reftype <: valtype)]))
@@ -12240,30 +12779,30 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
     -- Reftype_sub: `%|-%<:%`(C, $diffrt(rt_1, rt_2), rt)
 
-  ;; 6-typing.watsup:659.1-661.47
+  ;; 6-typing.watsup:680.1-682.47
   rule call{C : context, x : idx, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, CALL_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.FUNCS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:663.1-665.47
+  ;; 6-typing.watsup:684.1-686.47
   rule call_ref{C : context, x : idx, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, CALL_REF_instr(($idx(x) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:667.1-671.47
+  ;; 6-typing.watsup:688.1-692.47
   rule call_indirect{C : context, x : idx, y : idx, t_1* : valtype*, t_2* : valtype*, lim : limits, rt : reftype}:
     `%|-%:%`(C, CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
     -- Reftype_sub: `%|-%<:%`(C, rt, REF_reftype(`NULL%?`_nul(?(())), FUNC_heaptype))
     -- Expand: `%~~%`(C.TYPES_context[y!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:673.1-676.42
+  ;; 6-typing.watsup:694.1-697.42
   rule return{C : context, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, RETURN_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.RETURN_context = ?(`%`_list(t*{t : valtype})))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:679.1-684.42
+  ;; 6-typing.watsup:700.1-705.42
   rule return_call{C : context, x : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- Expand: `%~~%`(C.FUNCS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
@@ -12271,7 +12810,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:687.1-692.42
+  ;; 6-typing.watsup:708.1-713.42
   rule return_call_ref{C : context, x : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_REF_instr(($idx(x) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
@@ -12279,7 +12818,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:695.1-703.42
+  ;; 6-typing.watsup:716.1-724.42
   rule return_call_indirect{C : context, x : idx, y : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, lim : limits, rt : reftype, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
@@ -12289,452 +12828,470 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:708.1-709.33
+  ;; 6-typing.watsup:731.1-734.42
+  rule throw{C : context, x : idx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
+    `%|-%:%`(C, THROW_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+
+  ;; 6-typing.watsup:736.1-738.42
+  rule throw_ref{C : context, t_1* : valtype*, t_2* : valtype*}:
+    `%|-%:%`(C, THROW_REF_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), EXN_heaptype)]), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+
+  ;; 6-typing.watsup:740.1-744.34
+  rule try_table{C : context, bt : blocktype, catch* : catch*, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
+    `%|-%:%`(C, TRY_TABLE_instr(bt, `%`_list(catch*{catch : catch}), instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- (Catch_ok: `%|-%:OK`(C, catch))*{catch : catch}
+
+  ;; 6-typing.watsup:767.1-768.33
   rule const{C : context, nt : numtype, c_nt : num_(nt)}:
     `%|-%:%`(C, CONST_instr(nt, c_nt), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:711.1-712.34
+  ;; 6-typing.watsup:770.1-771.34
   rule unop{C : context, nt : numtype, unop_nt : unop_(nt)}:
     `%|-%:%`(C, UNOP_instr(nt, unop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype)]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:714.1-715.39
+  ;; 6-typing.watsup:773.1-774.39
   rule binop{C : context, nt : numtype, binop_nt : binop_(nt)}:
     `%|-%:%`(C, BINOP_instr(nt, binop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype) (nt : numtype <: valtype)]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:717.1-718.39
+  ;; 6-typing.watsup:776.1-777.39
   rule testop{C : context, nt : numtype, testop_nt : testop_(nt)}:
     `%|-%:%`(C, TESTOP_instr(nt, testop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:720.1-721.40
+  ;; 6-typing.watsup:779.1-780.40
   rule relop{C : context, nt : numtype, relop_nt : relop_(nt)}:
     `%|-%:%`(C, RELOP_instr(nt, relop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype) (nt : numtype <: valtype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:723.1-724.44
+  ;; 6-typing.watsup:782.1-783.44
   rule cvtop{C : context, nt_1 : numtype, nt_2 : numtype, cvtop : cvtop__(nt_2, nt_1)}:
     `%|-%:%`(C, CVTOP_instr(nt_1, nt_2, cvtop), `%->_%%`_instrtype(`%`_resulttype([(nt_2 : numtype <: valtype)]), [], `%`_resulttype([(nt_1 : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:729.1-731.31
+  ;; 6-typing.watsup:788.1-790.31
   rule ref.null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.NULL_instr(ht), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:733.1-736.20
+  ;; 6-typing.watsup:792.1-795.20
   rule ref.func{C : context, x : idx, dt : deftype}:
     `%|-%:%`(C, REF.FUNC_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), (dt : deftype <: heaptype))])))
     -- if (C.FUNCS_context[x!`%`_idx.0] = dt)
     -- if x <- C.REFS_context
 
-  ;; 6-typing.watsup:738.1-739.34
+  ;; 6-typing.watsup:797.1-798.34
   rule ref.i31{C : context}:
     `%|-%:%`(C, REF.I31_instr, `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), I31_heaptype)])))
 
-  ;; 6-typing.watsup:741.1-743.31
+  ;; 6-typing.watsup:800.1-802.31
   rule ref.is_null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.IS_NULL_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype([I32_valtype])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:745.1-747.31
+  ;; 6-typing.watsup:804.1-806.31
   rule ref.as_non_null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.AS_NON_NULL_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ht)])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:749.1-750.51
+  ;; 6-typing.watsup:808.1-809.51
   rule ref.eq{C : context}:
     `%|-%:%`(C, REF.EQ_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), EQ_heaptype) REF_valtype(`NULL%?`_nul(?(())), EQ_heaptype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:752.1-756.33
+  ;; 6-typing.watsup:811.1-815.33
   rule ref.test{C : context, rt : reftype, rt' : reftype}:
     `%|-%:%`(C, REF.TEST_instr(rt), `%->_%%`_instrtype(`%`_resulttype([(rt' : reftype <: valtype)]), [], `%`_resulttype([I32_valtype])))
     -- Reftype_ok: `%|-%:OK`(C, rt)
     -- Reftype_ok: `%|-%:OK`(C, rt')
     -- Reftype_sub: `%|-%<:%`(C, rt, rt')
 
-  ;; 6-typing.watsup:758.1-762.33
+  ;; 6-typing.watsup:817.1-821.33
   rule ref.cast{C : context, rt : reftype, rt' : reftype}:
     `%|-%:%`(C, REF.CAST_instr(rt), `%->_%%`_instrtype(`%`_resulttype([(rt' : reftype <: valtype)]), [], `%`_resulttype([(rt : reftype <: valtype)])))
     -- Reftype_ok: `%|-%:OK`(C, rt)
     -- Reftype_ok: `%|-%:OK`(C, rt')
     -- Reftype_sub: `%|-%<:%`(C, rt, rt')
 
-  ;; 6-typing.watsup:767.1-768.42
+  ;; 6-typing.watsup:826.1-827.42
   rule i31.get{C : context, sx : sx}:
     `%|-%:%`(C, I31.GET_instr(sx), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), I31_heaptype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:773.1-775.44
+  ;; 6-typing.watsup:832.1-834.44
   rule struct.new{C : context, x : idx, zt* : storagetype*, mut* : mut*}:
     `%|-%:%`(C, STRUCT.NEW_instr(x), `%->_%%`_instrtype(`%`_resulttype($unpack(zt)*{zt : storagetype}), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
 
-  ;; 6-typing.watsup:777.1-780.40
+  ;; 6-typing.watsup:836.1-839.40
   rule struct.new_default{C : context, x : idx, mut* : mut*, zt* : storagetype*, val* : val*}:
     `%|-%:%`(C, STRUCT.NEW_DEFAULT_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
     -- (if ($default_($unpack(zt)) = ?(val)))*{val : val, zt : storagetype}
 
-  ;; 6-typing.watsup:782.1-786.39
+  ;; 6-typing.watsup:841.1-845.39
   rule struct.get{C : context, sx? : sx?, x : idx, i : nat, zt : storagetype, yt* : fieldtype*, mut : mut}:
     `%|-%:%`(C, STRUCT.GET_instr(sx?{sx : sx}, x, `%`_u32(i)), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype([$unpack(zt)])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})))
     -- if (yt*{yt : fieldtype}[i] = `%%`_fieldtype(mut, zt))
     -- if ((sx?{sx : sx} = ?()) <=> (zt = ($unpack(zt) : valtype <: storagetype)))
 
-  ;; 6-typing.watsup:788.1-791.24
+  ;; 6-typing.watsup:847.1-850.24
   rule struct.set{C : context, x : idx, i : nat, zt : storagetype, yt* : fieldtype*}:
     `%|-%:%`(C, STRUCT.SET_instr(x, `%`_u32(i)), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) $unpack(zt)]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})))
     -- if (yt*{yt : fieldtype}[i] = `%%`_fieldtype(`MUT%?`_mut(?(())), zt))
 
-  ;; 6-typing.watsup:796.1-798.42
+  ;; 6-typing.watsup:855.1-857.42
   rule array.new{C : context, x : idx, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.NEW_instr(x), `%->_%%`_instrtype(`%`_resulttype([$unpack(zt) I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 6-typing.watsup:800.1-803.37
+  ;; 6-typing.watsup:859.1-862.37
   rule array.new_default{C : context, x : idx, mut : mut, zt : storagetype, val : val}:
     `%|-%:%`(C, ARRAY.NEW_DEFAULT_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ($default_($unpack(zt)) = ?(val))
 
-  ;; 6-typing.watsup:805.1-807.42
+  ;; 6-typing.watsup:864.1-866.42
   rule array.new_fixed{C : context, x : idx, n : n, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.NEW_FIXED_instr(x, `%`_u32(n)), `%->_%%`_instrtype(`%`_resulttype($unpack(zt)^n{}), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 6-typing.watsup:809.1-812.40
+  ;; 6-typing.watsup:868.1-871.40
   rule array.new_elem{C : context, x : idx, y : idx, mut : mut, rt : reftype}:
     `%|-%:%`(C, ARRAY.NEW_ELEM_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, (rt : reftype <: storagetype))))
     -- Reftype_sub: `%|-%<:%`(C, C.ELEMS_context[y!`%`_idx.0], rt)
 
-  ;; 6-typing.watsup:814.1-818.24
+  ;; 6-typing.watsup:873.1-877.24
   rule array.new_data{C : context, x : idx, y : idx, mut : mut, zt : storagetype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, ARRAY.NEW_DATA_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if (($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:820.1-823.39
+  ;; 6-typing.watsup:879.1-882.39
   rule array.get{C : context, sx? : sx?, x : idx, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.GET_instr(sx?{sx : sx}, x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype]), [], `%`_resulttype([$unpack(zt)])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ((sx?{sx : sx} = ?()) <=> (zt = ($unpack(zt) : valtype <: storagetype)))
 
-  ;; 6-typing.watsup:825.1-827.42
+  ;; 6-typing.watsup:884.1-886.42
   rule array.set{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype $unpack(zt)]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:829.1-831.42
+  ;; 6-typing.watsup:888.1-890.42
   rule array.len{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.LEN_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ARRAY_heaptype)]), [], `%`_resulttype([I32_valtype])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:833.1-835.42
+  ;; 6-typing.watsup:892.1-894.42
   rule array.fill{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype $unpack(zt) I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:837.1-841.40
+  ;; 6-typing.watsup:896.1-900.40
   rule array.copy{C : context, x_1 : idx, x_2 : idx, zt_1 : storagetype, mut : mut, zt_2 : storagetype}:
     `%|-%:%`(C, ARRAY.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x_1) : typevar <: heaptype)) I32_valtype REF_valtype(`NULL%?`_nul(?(())), ($idx(x_2) : typevar <: heaptype)) I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x_1!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt_1)))
     -- Expand: `%~~%`(C.TYPES_context[x_2!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt_2)))
     -- Storagetype_sub: `%|-%<:%`(C, zt_2, zt_1)
 
-  ;; 6-typing.watsup:843.1-846.44
+  ;; 6-typing.watsup:902.1-905.44
   rule array.init_elem{C : context, x : idx, y : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.INIT_ELEM_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
     -- Storagetype_sub: `%|-%<:%`(C, (C.ELEMS_context[y!`%`_idx.0] : reftype <: storagetype), zt)
 
-  ;; 6-typing.watsup:848.1-852.24
+  ;; 6-typing.watsup:907.1-911.24
   rule array.init_data{C : context, x : idx, y : idx, zt : storagetype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, ARRAY.INIT_DATA_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
     -- if (($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:857.1-858.62
+  ;; 6-typing.watsup:916.1-917.62
   rule extern.convert_any{C : context, nul : nul}:
     `%|-%:%`(C, EXTERN.CONVERT_ANY_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(nul, ANY_heaptype)]), [], `%`_resulttype([REF_valtype(nul, EXTERN_heaptype)])))
 
-  ;; 6-typing.watsup:860.1-861.62
+  ;; 6-typing.watsup:919.1-920.62
   rule any.convert_extern{C : context, nul : nul}:
     `%|-%:%`(C, ANY.CONVERT_EXTERN_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(nul, EXTERN_heaptype)]), [], `%`_resulttype([REF_valtype(nul, ANY_heaptype)])))
 
-  ;; 6-typing.watsup:866.1-867.35
+  ;; 6-typing.watsup:925.1-926.35
   rule vconst{C : context, c : vec_(V128_Vnn)}:
     `%|-%:%`(C, VCONST_instr(V128_vectype, c), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:869.1-870.41
+  ;; 6-typing.watsup:928.1-929.41
   rule vvunop{C : context, vvunop : vvunop}:
     `%|-%:%`(C, VVUNOP_instr(V128_vectype, vvunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:872.1-873.48
+  ;; 6-typing.watsup:931.1-932.48
   rule vvbinop{C : context, vvbinop : vvbinop}:
     `%|-%:%`(C, VVBINOP_instr(V128_vectype, vvbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:875.1-876.55
+  ;; 6-typing.watsup:934.1-935.55
   rule vvternop{C : context, vvternop : vvternop}:
     `%|-%:%`(C, VVTERNOP_instr(V128_vectype, vvternop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:878.1-879.44
+  ;; 6-typing.watsup:937.1-938.44
   rule vvtestop{C : context, vvtestop : vvtestop}:
     `%|-%:%`(C, VVTESTOP_instr(V128_vectype, vvtestop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:881.1-882.37
+  ;; 6-typing.watsup:940.1-941.37
   rule vunop{C : context, sh : shape, vunop : vunop_(sh)}:
     `%|-%:%`(C, VUNOP_instr(sh, vunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:884.1-885.44
+  ;; 6-typing.watsup:943.1-944.44
   rule vbinop{C : context, sh : shape, vbinop : vbinop_(sh)}:
     `%|-%:%`(C, VBINOP_instr(sh, vbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:887.1-888.40
+  ;; 6-typing.watsup:946.1-947.40
   rule vtestop{C : context, sh : shape, vtestop : vtestop_(sh)}:
     `%|-%:%`(C, VTESTOP_instr(sh, vtestop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:890.1-891.44
+  ;; 6-typing.watsup:949.1-950.44
   rule vrelop{C : context, sh : shape, vrelop : vrelop_(sh)}:
     `%|-%:%`(C, VRELOP_instr(sh, vrelop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:893.1-894.47
+  ;; 6-typing.watsup:952.1-953.47
   rule vshiftop{C : context, sh : ishape, vshiftop : vshiftop_(sh)}:
     `%|-%:%`(C, VSHIFTOP_instr(sh, vshiftop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype I32_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:896.1-897.33
+  ;; 6-typing.watsup:955.1-956.33
   rule vbitmask{C : context, sh : ishape}:
     `%|-%:%`(C, VBITMASK_instr(sh), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:899.1-900.39
+  ;; 6-typing.watsup:958.1-959.39
   rule vswizzle{C : context, sh : ishape}:
     `%|-%:%`(C, VSWIZZLE_instr(sh), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:902.1-904.29
+  ;; 6-typing.watsup:961.1-963.29
   rule vshuffle{C : context, sh : ishape, i* : nat*}:
     `%|-%:%`(C, VSHUFFLE_instr(sh, `%`_laneidx(i)*{i : nat}), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
     -- (if (i < (2 * $dim((sh : ishape <: shape))!`%`_dim.0)))*{i : nat}
 
-  ;; 6-typing.watsup:906.1-907.44
+  ;; 6-typing.watsup:965.1-966.44
   rule vsplat{C : context, sh : shape}:
     `%|-%:%`(C, VSPLAT_instr(sh), `%->_%%`_instrtype(`%`_resulttype([($unpackshape(sh) : numtype <: valtype)]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:909.1-911.21
+  ;; 6-typing.watsup:968.1-970.21
   rule vextract_lane{C : context, sh : shape, sx? : sx?, i : nat}:
     `%|-%:%`(C, VEXTRACT_LANE_instr(sh, sx?{sx : sx}, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([($unpackshape(sh) : numtype <: valtype)])))
     -- if (i < $dim(sh)!`%`_dim.0)
 
-  ;; 6-typing.watsup:913.1-915.21
+  ;; 6-typing.watsup:972.1-974.21
   rule vreplace_lane{C : context, sh : shape, i : nat}:
     `%|-%:%`(C, VREPLACE_LANE_instr(sh, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([V128_valtype ($unpackshape(sh) : numtype <: valtype)]), [], `%`_resulttype([V128_valtype])))
     -- if (i < $dim(sh)!`%`_dim.0)
 
-  ;; 6-typing.watsup:917.1-918.50
+  ;; 6-typing.watsup:976.1-977.50
   rule vextunop{C : context, sh_1 : ishape, sh_2 : ishape, vextunop : vextunop__(sh_2, sh_1)}:
     `%|-%:%`(C, VEXTUNOP_instr(sh_1, sh_2, vextunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:920.1-921.57
+  ;; 6-typing.watsup:979.1-980.57
   rule vextbinop{C : context, sh_1 : ishape, sh_2 : ishape, vextbinop : vextbinop__(sh_2, sh_1)}:
     `%|-%:%`(C, VEXTBINOP_instr(sh_1, sh_2, vextbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:923.1-924.48
+  ;; 6-typing.watsup:982.1-983.48
   rule vnarrow{C : context, sh_1 : ishape, sh_2 : ishape, sx : sx}:
     `%|-%:%`(C, VNARROW_instr(sh_1, sh_2, sx), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:926.1-927.58
+  ;; 6-typing.watsup:985.1-986.58
   rule vcvtop{C : context, sh_1 : shape, sh_2 : shape, vcvtop : vcvtop__(sh_2, sh_1), half? : half__(sh_2, sh_1)?, zero? : zero__(sh_2, sh_1)?}:
     `%|-%:%`(C, VCVTOP_instr(sh_1, sh_2, vcvtop, half?{half : half__(sh_2, sh_1)}, zero?{zero : zero__(sh_2, sh_1)}), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:932.1-934.28
+  ;; 6-typing.watsup:991.1-993.28
   rule local.get{C : context, x : idx, t : valtype}:
     `%|-%:%`(C, LOCAL.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([t])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(SET_init, t))
 
-  ;; 6-typing.watsup:936.1-938.29
+  ;; 6-typing.watsup:995.1-997.29
   rule local.set{C : context, x : idx, t : valtype, init : init}:
     `%|-%:%`(C, LOCAL.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [x], `%`_resulttype([])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(init, t))
 
-  ;; 6-typing.watsup:940.1-942.29
+  ;; 6-typing.watsup:999.1-1001.29
   rule local.tee{C : context, x : idx, t : valtype, init : init}:
     `%|-%:%`(C, LOCAL.TEE_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [x], `%`_resulttype([t])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(init, t))
 
-  ;; 6-typing.watsup:947.1-949.29
+  ;; 6-typing.watsup:1006.1-1008.29
   rule global.get{C : context, x : idx, t : valtype, mut : mut}:
     `%|-%:%`(C, GLOBAL.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([t])))
     -- if (C.GLOBALS_context[x!`%`_idx.0] = `%%`_globaltype(mut, t))
 
-  ;; 6-typing.watsup:951.1-953.29
+  ;; 6-typing.watsup:1010.1-1012.29
   rule global.set{C : context, x : idx, t : valtype}:
     `%|-%:%`(C, GLOBAL.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [], `%`_resulttype([])))
     -- if (C.GLOBALS_context[x!`%`_idx.0] = `%%`_globaltype(`MUT%?`_mut(?(())), t))
 
-  ;; 6-typing.watsup:958.1-960.29
+  ;; 6-typing.watsup:1017.1-1019.29
   rule table.get{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(rt : reftype <: valtype)])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:962.1-964.29
+  ;; 6-typing.watsup:1021.1-1023.29
   rule table.set{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (rt : reftype <: valtype)]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:966.1-968.29
+  ;; 6-typing.watsup:1025.1-1027.29
   rule table.size{C : context, x : idx, lim : limits, rt : reftype}:
     `%|-%:%`(C, TABLE.SIZE_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([I32_valtype])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:970.1-972.29
+  ;; 6-typing.watsup:1029.1-1031.29
   rule table.grow{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.GROW_instr(x), `%->_%%`_instrtype(`%`_resulttype([(rt : reftype <: valtype) I32_valtype]), [], `%`_resulttype([I32_valtype])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:974.1-976.29
+  ;; 6-typing.watsup:1033.1-1035.29
   rule table.fill{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (rt : reftype <: valtype) I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:978.1-982.36
+  ;; 6-typing.watsup:1037.1-1041.36
   rule table.copy{C : context, x_1 : idx, x_2 : idx, lim_1 : limits, rt_1 : reftype, lim_2 : limits, rt_2 : reftype}:
     `%|-%:%`(C, TABLE.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x_1!`%`_idx.0] = `%%`_tabletype(lim_1, rt_1))
     -- if (C.TABLES_context[x_2!`%`_idx.0] = `%%`_tabletype(lim_2, rt_2))
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
 
-  ;; 6-typing.watsup:984.1-988.36
+  ;; 6-typing.watsup:1043.1-1047.36
   rule table.init{C : context, x : idx, y : idx, lim : limits, rt_1 : reftype, rt_2 : reftype}:
     `%|-%:%`(C, TABLE.INIT_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt_1))
     -- if (C.ELEMS_context[y!`%`_idx.0] = rt_2)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
 
-  ;; 6-typing.watsup:990.1-992.24
+  ;; 6-typing.watsup:1049.1-1051.24
   rule elem.drop{C : context, x : idx, rt : reftype}:
     `%|-%:%`(C, ELEM.DROP_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
     -- if (C.ELEMS_context[x!`%`_idx.0] = rt)
 
-  ;; 6-typing.watsup:997.1-999.23
+  ;; 6-typing.watsup:1056.1-1058.23
   rule memory.size{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.SIZE_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([I32_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1001.1-1003.23
+  ;; 6-typing.watsup:1060.1-1062.23
   rule memory.grow{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.GROW_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([I32_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1005.1-1007.23
+  ;; 6-typing.watsup:1064.1-1066.23
   rule memory.fill{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1009.1-1012.27
+  ;; 6-typing.watsup:1068.1-1071.27
   rule memory.copy{C : context, x_1 : idx, x_2 : idx, mt_1 : memtype, mt_2 : memtype}:
     `%|-%:%`(C, MEMORY.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x_1!`%`_idx.0] = mt_1)
     -- if (C.MEMS_context[x_2!`%`_idx.0] = mt_2)
 
-  ;; 6-typing.watsup:1014.1-1017.24
+  ;; 6-typing.watsup:1073.1-1076.24
   rule memory.init{C : context, x : idx, y : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.INIT_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:1019.1-1021.24
+  ;; 6-typing.watsup:1078.1-1080.24
   rule data.drop{C : context, x : idx}:
     `%|-%:%`(C, DATA.DROP_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
     -- if (C.DATAS_context[x!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:1032.1-1035.43
+  ;; 6-typing.watsup:1091.1-1094.43
   rule load-val{C : context, nt : numtype, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, LOAD_instr(nt, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(nt : numtype <: valtype)])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($size(nt) / 8))
 
-  ;; 6-typing.watsup:1037.1-1040.35
+  ;; 6-typing.watsup:1096.1-1099.35
   rule load-pack{C : context, Inn : Inn, M : M, sx : sx, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, LOAD_instr((Inn : Inn <: numtype), ?(`%%`_loadop_(`%`_sz(M), sx)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(Inn : Inn <: valtype)])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (M / 8))
 
-  ;; 6-typing.watsup:1051.1-1054.43
+  ;; 6-typing.watsup:1110.1-1113.43
   rule store-val{C : context, nt : numtype, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, STORE_instr(nt, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (nt : numtype <: valtype)]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($size(nt) / 8))
 
-  ;; 6-typing.watsup:1056.1-1059.35
+  ;; 6-typing.watsup:1115.1-1118.35
   rule store-pack{C : context, Inn : Inn, M : M, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, STORE_instr((Inn : Inn <: numtype), ?(`%`_sz(M)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (Inn : Inn <: valtype)]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (M / 8))
 
-  ;; 6-typing.watsup:1061.1-1064.46
+  ;; 6-typing.watsup:1120.1-1123.46
   rule vload-val{C : context, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($vsize(V128_vectype) / 8))
 
-  ;; 6-typing.watsup:1066.1-1069.39
+  ;; 6-typing.watsup:1125.1-1128.39
   rule vload-pack{C : context, M : M, N : N, sx : sx, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(M), N, sx)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ((M / 8) * N))
 
-  ;; 6-typing.watsup:1071.1-1074.35
+  ;; 6-typing.watsup:1130.1-1133.35
   rule vload-splat{C : context, N : N, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(N))), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
 
-  ;; 6-typing.watsup:1076.1-1079.35
+  ;; 6-typing.watsup:1135.1-1138.35
   rule vload-zero{C : context, N : N, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(N))), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
 
-  ;; 6-typing.watsup:1081.1-1085.21
+  ;; 6-typing.watsup:1140.1-1144.21
   rule vload_lane{C : context, N : N, x : idx, memarg : memarg, i : nat, mt : memtype}:
     `%|-%:%`(C, VLOAD_LANE_instr(V128_vectype, `%`_sz(N), x, memarg, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
     -- if (i < (128 / N))
 
-  ;; 6-typing.watsup:1087.1-1090.46
+  ;; 6-typing.watsup:1146.1-1149.46
   rule vstore{C : context, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VSTORE_instr(V128_vectype, x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($vsize(V128_vectype) / 8))
 
-  ;; 6-typing.watsup:1092.1-1096.21
+  ;; 6-typing.watsup:1151.1-1155.21
   rule vstore_lane{C : context, N : N, x : idx, memarg : memarg, i : nat, mt : memtype}:
     `%|-%:%`(C, VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, memarg, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
     -- if (i < (128 / N))
 
-;; 6-typing.watsup:523.1-523.96
+;; 6-typing.watsup:544.1-544.96
 relation Instrs_ok: `%|-%:%`(context, instr*, instrtype)
-  ;; 6-typing.watsup:536.1-537.24
+  ;; 6-typing.watsup:557.1-558.24
   rule empty{C : context}:
     `%|-%:%`(C, [], `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
 
-  ;; 6-typing.watsup:540.1-544.82
+  ;; 6-typing.watsup:561.1-565.82
   rule seq{C : context, instr_1 : instr, instr_2* : instr*, t_1* : valtype*, x_1* : idx*, x_2* : idx*, t_3* : valtype*, t_2* : valtype*, init* : init*, t* : valtype*}:
     `%|-%:%`(C, [instr_1] :: instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx} :: x_2*{x_2 : localidx}, `%`_resulttype(t_3*{t_3 : valtype})))
     -- Instr_ok: `%|-%:%`(C, instr_1, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
     -- (if (C.LOCALS_context[x_1!`%`_idx.0] = `%%`_localtype(init, t)))*{init : init, t : valtype, x_1 : idx}
     -- Instrs_ok: `%|-%:%`($with_locals(C, x_1*{x_1 : localidx}, `%%`_localtype(SET_init, t)*{t : valtype}), instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_2*{t_2 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_3*{t_3 : valtype})))
 
-  ;; 6-typing.watsup:546.1-550.33
+  ;; 6-typing.watsup:567.1-571.33
   rule sub{C : context, instr* : instr*, it' : instrtype, it : instrtype}:
     `%|-%:%`(C, instr*{instr : instr}, it')
     -- Instrs_ok: `%|-%:%`(C, instr*{instr : instr}, it)
     -- Instrtype_sub: `%|-%<:%`(C, it, it')
     -- Instrtype_ok: `%|-%:OK`(C, it')
 
-  ;; 6-typing.watsup:553.1-556.33
+  ;; 6-typing.watsup:574.1-577.33
   rule frame{C : context, instr* : instr*, t* : valtype*, t_1* : valtype*, x* : idx*, t_2* : valtype*}:
     `%|-%:%`(C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t*{t : valtype} :: t_2*{t_2 : valtype})))
     -- Instrs_ok: `%|-%:%`(C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
@@ -12831,7 +13388,7 @@ relation Type_ok: `%|-%:%`(context, type, deftype*)
     `%|-%:%`(C, TYPE_type(rectype), dt*{dt : deftype})
     -- if (x = `%`_idx(|C.TYPES_context|))
     -- if (dt*{dt : deftype} = $rolldt(x, rectype))
-    -- Rectype_ok: `%|-%:%`(C ++ {TYPES dt*{dt : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rectype, OK_oktypeidx(x))
+    -- Rectype_ok: `%|-%:%`(C ++ {TYPES dt*{dt : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rectype, OK_oktypeidx(x))
 
 ;; 6-typing.watsup
 relation Local_ok: `%|-%:%`(context, local, localtype)
@@ -12852,7 +13409,7 @@ relation Func_ok: `%|-%:%`(context, func, deftype)
     `%|-%:%`(C, FUNC_func(x, local*{local : local}, expr), C.TYPES_context[x!`%`_idx.0])
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
     -- (Local_ok: `%|-%:%`(C, local, lct))*{lct : localtype, local : local}
-    -- Expr_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS `%%`_localtype(SET_init, t_1)*{t_1 : valtype} :: lct*{lct : localtype}, LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(`%`_resulttype(t_2*{t_2 : valtype})), REFS []}, expr, `%`_resulttype(t_2*{t_2 : valtype}))
+    -- Expr_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS `%%`_localtype(SET_init, t_1)*{t_1 : valtype} :: lct*{lct : localtype}, LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(`%`_resulttype(t_2*{t_2 : valtype})), REFS []}, expr, `%`_resulttype(t_2*{t_2 : valtype}))
 
 ;; 6-typing.watsup
 relation Global_ok: `%|-%:%`(context, global, globaltype)
@@ -12879,6 +13436,13 @@ relation Mem_ok: `%|-%:%`(context, mem, memtype)
     `%|-%:%`(C, MEMORY_mem(memtype), memtype)
     -- Memtype_ok: `%|-%:OK`(C, memtype)
 
+;; 6-typing.watsup
+relation Tag_ok: `%|-%:%`(context, tag, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, x : idx, functype : functype}:
+    `%|-%:%`(C, TAG_tag(x), C.TYPES_context[x!`%`_idx.0])
+    -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(functype))
+
 ;; 6-typing.watsup
 relation Elemmode_ok: `%|-%:%`(context, elemmode, elemtype)
   ;; 6-typing.watsup
@@ -12960,6 +13524,11 @@ relation Externidx_ok: `%|-%:%`(context, externidx, externtype)
     `%|-%:%`(C, MEM_externidx(x), MEM_externtype(mt))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, x : idx, at : tagtype}:
+    `%|-%:%`(C, TAG_externidx(x), TAG_externtype((at : deftype <: typeuse)))
+    -- if (C.TAGS_context[x!`%`_idx.0] = at)
+
 ;; 6-typing.watsup
 relation Export_ok: `%|-%:%%`(context, export, name, externtype)
   ;; 6-typing.watsup
@@ -12970,33 +13539,33 @@ relation Export_ok: `%|-%:%%`(context, export, name, externtype)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:1288.1-1288.100
+;; 6-typing.watsup:1356.1-1356.100
 relation Globals_ok: `%|-%:%`(context, global*, globaltype*)
-  ;; 6-typing.watsup:1330.1-1331.17
+  ;; 6-typing.watsup:1400.1-1401.17
   rule empty{C : context}:
     `%|-%:%`(C, [], [])
 
-  ;; 6-typing.watsup:1333.1-1336.54
+  ;; 6-typing.watsup:1403.1-1406.54
   rule cons{C : context, global_1 : global, global : global, gt_1 : globaltype, gt* : globaltype*}:
     `%|-%:%`(C, [global_1] :: global*{}, [gt_1] :: gt*{gt : globaltype})
     -- Global_ok: `%|-%:%`(C, global, gt_1)
-    -- Globals_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [gt_1], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, global*{}, gt*{gt : globaltype})
+    -- Globals_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [gt_1], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, global*{}, gt*{gt : globaltype})
 }
 
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:1287.1-1287.98
+;; 6-typing.watsup:1355.1-1355.98
 relation Types_ok: `%|-%:%`(context, type*, deftype*)
-  ;; 6-typing.watsup:1322.1-1323.17
+  ;; 6-typing.watsup:1392.1-1393.17
   rule empty{C : context}:
     `%|-%:%`(C, [], [])
 
-  ;; 6-typing.watsup:1325.1-1328.49
+  ;; 6-typing.watsup:1395.1-1398.49
   rule cons{C : context, type_1 : type, type* : type*, dt_1* : deftype*, dt* : deftype*}:
     `%|-%:%`(C, [type_1] :: type*{type : type}, dt_1*{dt_1 : deftype} :: dt*{dt : deftype})
     -- Type_ok: `%|-%:%`(C, type_1, dt_1*{dt_1 : deftype})
-    -- Types_ok: `%|-%:%`(C ++ {TYPES dt_1*{dt_1 : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt*{dt : deftype})
+    -- Types_ok: `%|-%:%`(C ++ {TYPES dt_1*{dt_1 : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt*{dt : deftype})
 }
 
 ;; 6-typing.watsup
@@ -13006,31 +13575,33 @@ syntax nonfuncs =
 ;; 6-typing.watsup
 def $funcidx_nonfuncs(nonfuncs : nonfuncs) : funcidx*
   ;; 6-typing.watsup
-  def $funcidx_nonfuncs{global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*}(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})) = $funcidx_module(MODULE_module([], [], [], global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, ?(), []))
+  def $funcidx_nonfuncs{global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*}(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})) = $funcidx_module(MODULE_module([], [], [], global*{global : global}, table*{table : table}, mem*{mem : mem}, [], elem*{elem : elem}, data*{data : data}, ?(), []))
 
 ;; 6-typing.watsup
 relation Module_ok: `|-%:%`(module, moduletype)
   ;; 6-typing.watsup
-  rule _{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, C : context, xt_I* : externtype*, xt_E* : externtype*, dt'* : deftype*, C' : context, gt* : globaltype*, tt* : tabletype*, mt* : memtype*, dt* : deftype*, rt* : reftype*, ok* : datatype*, nm* : name*, dt_I* : deftype*, gt_I* : globaltype*, tt_I* : tabletype*, mt_I* : memtype*, x* : idx*}:
-    `|-%:%`(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}), $clos_moduletype(C, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype})))
-    -- Types_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt'*{dt' : deftype})
-    -- (Import_ok: `%|-%:%`({TYPES dt'*{dt' : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, import, xt_I))*{import : import, xt_I : externtype}
+  rule _{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, C : context, xt_I* : externtype*, xt_E* : externtype*, dt'* : deftype*, C' : context, gt* : globaltype*, tt* : tabletype*, mt* : memtype*, at* : tagtype*, dt* : deftype*, rt* : reftype*, ok* : datatype*, nm* : name*, dt_I* : deftype*, gt_I* : globaltype*, tt_I* : tabletype*, mt_I* : memtype*, at_I* : tagtype*, x* : idx*}:
+    `|-%:%`(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}), $clos_moduletype(C, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype})))
+    -- Types_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt'*{dt' : deftype})
+    -- (Import_ok: `%|-%:%`({TYPES dt'*{dt' : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, import, xt_I))*{import : import, xt_I : externtype}
     -- Globals_ok: `%|-%:%`(C', global*{global : global}, gt*{gt : globaltype})
     -- (Table_ok: `%|-%:%`(C', table, tt))*{table : table, tt : tabletype}
     -- (Mem_ok: `%|-%:%`(C', mem, mt))*{mem : mem, mt : memtype}
+    -- (Tag_ok: `%|-%:%`(C', tag, at))*{at : tagtype, tag : tag}
     -- (Func_ok: `%|-%:%`(C, func, dt))*{dt : deftype, func : func}
     -- (Elem_ok: `%|-%:%`(C, elem, rt))*{elem : elem, rt : elemtype}
     -- (Data_ok: `%|-%:%`(C, data, ok))*{data : data, ok : datatype}
     -- (Start_ok: `%|-%:OK`(C, start))?{start : start}
     -- (Export_ok: `%|-%:%%`(C, export, nm, xt_E))*{export : export, nm : name, xt_E : externtype}
     -- if $disjoint_(syntax name, nm*{nm : name})
-    -- if (C = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype} :: gt*{gt : globaltype}, TABLES tt_I*{tt_I : tabletype} :: tt*{tt : tabletype}, MEMS mt_I*{mt_I : memtype} :: mt*{mt : memtype}, ELEMS rt*{rt : elemtype}, DATAS ok*{ok : datatype}, LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
-    -- if (C' = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype}, TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
+    -- if (C = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype} :: gt*{gt : globaltype}, TABLES tt_I*{tt_I : tabletype} :: tt*{tt : tabletype}, MEMS mt_I*{mt_I : memtype} :: mt*{mt : memtype}, TAGS at_I*{at_I : tagtype} :: at*{at : tagtype}, ELEMS rt*{rt : elemtype}, DATAS ok*{ok : datatype}, LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
+    -- if (C' = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype}, TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
     -- if (x*{x : idx} = $funcidx_nonfuncs(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})))
     -- if (dt_I*{dt_I : deftype} = $funcsxt(xt_I*{xt_I : externtype}))
     -- if (gt_I*{gt_I : globaltype} = $globalsxt(xt_I*{xt_I : externtype}))
     -- if (tt_I*{tt_I : tabletype} = $tablesxt(xt_I*{xt_I : externtype}))
     -- if (mt_I*{mt_I : memtype} = $memsxt(xt_I*{xt_I : externtype}))
+    -- if (at_I*{at_I : tagtype} = $tagsxt(xt_I*{xt_I : externtype}))
 
 ;; 7-runtime-typing.watsup
 relation Num_type: `%|-%:%`(store, num, numtype)
@@ -13072,19 +13643,23 @@ relation Ref_type: `%|-%:%`(store, ref, reftype)
     `%|-%:%`(s, REF.FUNC_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), (dt : deftype <: heaptype)))
     -- if (s.FUNCS_store[a].TYPE_funcinst = dt)
 
-  ;; 7-runtime-typing.watsup:35.1-36.39
+  ;; 7-runtime-typing.watsup:35.1-36.38
+  rule exn{s : store, a : addr}:
+    `%|-%:%`(s, REF.EXN_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), EXN_heaptype))
+
+  ;; 7-runtime-typing.watsup:38.1-39.39
   rule host{s : store, a : addr}:
     `%|-%:%`(s, REF.HOST_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), ANY_heaptype))
 
-  ;; 7-runtime-typing.watsup:38.1-39.45
+  ;; 7-runtime-typing.watsup:41.1-42.45
   rule extern{s : store, addrref : addrref}:
     `%|-%:%`(s, REF.EXTERN_ref(addrref), REF_reftype(`NULL%?`_nul(?()), EXTERN_heaptype))
 
-  ;; 7-runtime-typing.watsup:41.1-44.34
+  ;; 7-runtime-typing.watsup:44.1-47.34
   rule sub{s : store, ref : ref, rt : reftype, rt' : reftype}:
     `%|-%:%`(s, ref, rt)
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', rt)
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', rt)
 }
 
 ;; 7-runtime-typing.watsup
@@ -13107,33 +13682,38 @@ relation Val_type: `%|-%:%`(store, val, valtype)
 ;; 7-runtime-typing.watsup
 rec {
 
-;; 7-runtime-typing.watsup:64.1-64.57
-relation Externval_type: `%|-%:%`(store, externval, externtype)
-  ;; 7-runtime-typing.watsup:66.1-68.30
+;; 7-runtime-typing.watsup:67.1-67.59
+relation Externaddr_type: `%|-%:%`(store, externaddr, externtype)
+  ;; 7-runtime-typing.watsup:69.1-71.30
   rule func{s : store, a : addr, funcinst : funcinst}:
-    `%|-%:%`(s, FUNC_externval(a), FUNC_externtype((funcinst.TYPE_funcinst : deftype <: typeuse)))
+    `%|-%:%`(s, FUNC_externaddr(a), FUNC_externtype((funcinst.TYPE_funcinst : deftype <: typeuse)))
     -- if (s.FUNCS_store[a] = funcinst)
 
-  ;; 7-runtime-typing.watsup:70.1-72.34
+  ;; 7-runtime-typing.watsup:73.1-75.34
   rule global{s : store, a : addr, globalinst : globalinst}:
-    `%|-%:%`(s, GLOBAL_externval(a), GLOBAL_externtype(globalinst.TYPE_globalinst))
+    `%|-%:%`(s, GLOBAL_externaddr(a), GLOBAL_externtype(globalinst.TYPE_globalinst))
     -- if (s.GLOBALS_store[a] = globalinst)
 
-  ;; 7-runtime-typing.watsup:74.1-76.32
+  ;; 7-runtime-typing.watsup:77.1-79.32
   rule table{s : store, a : addr, tableinst : tableinst}:
-    `%|-%:%`(s, TABLE_externval(a), TABLE_externtype(tableinst.TYPE_tableinst))
+    `%|-%:%`(s, TABLE_externaddr(a), TABLE_externtype(tableinst.TYPE_tableinst))
     -- if (s.TABLES_store[a] = tableinst)
 
-  ;; 7-runtime-typing.watsup:78.1-80.28
+  ;; 7-runtime-typing.watsup:81.1-83.28
   rule mem{s : store, a : addr, meminst : meminst}:
-    `%|-%:%`(s, MEM_externval(a), MEM_externtype(meminst.TYPE_meminst))
+    `%|-%:%`(s, MEM_externaddr(a), MEM_externtype(meminst.TYPE_meminst))
     -- if (s.MEMS_store[a] = meminst)
 
-  ;; 7-runtime-typing.watsup:82.1-85.37
-  rule sub{s : store, externval : externval, xt : externtype, xt' : externtype}:
-    `%|-%:%`(s, externval, xt)
-    -- Externval_type: `%|-%:%`(s, externval, xt')
-    -- Externtype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, xt', xt)
+  ;; 7-runtime-typing.watsup:85.1-87.28
+  rule tag{s : store, a : addr, taginst : taginst}:
+    `%|-%:%`(s, TAG_externaddr(a), TAG_externtype((taginst.TYPE_taginst : deftype <: typeuse)))
+    -- if (s.TAGS_store[a] = taginst)
+
+  ;; 7-runtime-typing.watsup:89.1-92.37
+  rule sub{s : store, externaddr : externaddr, xt : externtype, xt' : externtype}:
+    `%|-%:%`(s, externaddr, xt)
+    -- Externaddr_type: `%|-%:%`(s, externaddr, xt')
+    -- Externtype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, xt', xt)
 }
 
 ;; 8-reduction.watsup
@@ -13175,15 +13755,19 @@ relation Step_pure: `%~>%`(instr*, instr*)
     `%~>%`([`LABEL_%{%}%`_instr(n, instr*{instr : instr}, (val : val <: instr)*{val : val})], (val : val <: instr)*{val : val})
 
   ;; 8-reduction.watsup
-  rule br-zero{n : n, instr'* : instr*, val'* : val*, val^n : val^n, l : labelidx, instr* : instr*}:
+  rule br-label-zero{n : n, instr'* : instr*, val'* : val*, val^n : val^n, l : labelidx, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val' : val <: instr)*{val' : val} :: (val : val <: instr)^n{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)^n{val : val} :: instr'*{instr' : instr})
     -- if (l = `%`_labelidx(0))
 
   ;; 8-reduction.watsup
-  rule br-succ{n : n, instr'* : instr*, val* : val*, l : labelidx, instr* : instr*}:
+  rule br-label-succ{n : n, instr'* : instr*, val* : val*, l : labelidx, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val : val <: instr)*{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [BR_instr(`%`_labelidx((l!`%`_labelidx.0 - 1)))])
     -- if (l!`%`_labelidx.0 > 0)
 
+  ;; 8-reduction.watsup
+  rule br-handler{n : n, catch* : catch*, val* : val*, l : labelidx, instr* : instr*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [BR_instr(l)])
+
   ;; 8-reduction.watsup
   rule br_if-true{c : num_(I32_numtype), l : labelidx}:
     `%~>%`([CONST_instr(I32_numtype, c) BR_IF_instr(l)], [BR_instr(l)])
@@ -13244,6 +13828,14 @@ relation Step_pure: `%~>%`(instr*, instr*)
   rule return-label{n : n, instr'* : instr*, val* : val*, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val : val <: instr)*{val : val} :: [RETURN_instr] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [RETURN_instr])
 
+  ;; 8-reduction.watsup
+  rule return-handler{n : n, catch* : catch*, val* : val*, instr* : instr*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val} :: [RETURN_instr] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [RETURN_instr])
+
+  ;; 8-reduction.watsup
+  rule handler-vals{n : n, catch* : catch*, val* : val*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val})], (val : val <: instr)*{val : val})
+
   ;; 8-reduction.watsup
   rule trap-vals{val* : val*, instr* : instr*}:
     `%~>%`((val : val <: instr)*{val : val} :: [TRAP_instr] :: instr*{instr : instr}, [TRAP_instr])
@@ -13534,7 +14126,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule br_on_cast-succeed{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype, rt : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) BR_ON_CAST_instr(l, rt_1, rt_2)]), [(ref : ref <: instr) BR_instr(l)])
     -- Ref_type: `%|-%:%`(s, ref, rt)
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
 
   ;; 8-reduction.watsup
   rule br_on_cast-fail{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype}:
@@ -13545,7 +14137,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule br_on_cast_fail-succeed{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype, rt : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) BR_ON_CAST_FAIL_instr(l, rt_1, rt_2)]), [(ref : ref <: instr)])
     -- Ref_type: `%|-%:%`(s, ref, rt)
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
 
   ;; 8-reduction.watsup
   rule br_on_cast_fail-fail{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype}:
@@ -13587,6 +14179,57 @@ relation Step_read: `%~>%`(config, instr*)
     `%~>%`(`%;%`_config(z, [`FRAME_%{%}%`_instr(k, f, (val' : val <: instr)*{val' : val} :: (val : val <: instr)^n{val : val} :: [REF.FUNC_ADDR_instr(a)] :: [RETURN_CALL_REF_instr(yy)] :: instr*{instr : instr})]), (val : val <: instr)^n{val : val} :: [REF.FUNC_ADDR_instr(a) CALL_REF_instr(yy)])
     -- Expand: `%~~%`($funcinst(z)[a].TYPE_funcinst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1^n{t_1 : valtype}), `%`_resulttype(t_2^m{t_2 : valtype}))))
 
+  ;; 8-reduction.watsup
+  rule throw_ref-null{z : state, ht : heaptype}:
+    `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) THROW_REF_instr]), [TRAP_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-vals{z : state, val* : val*, a : addr, instr* : instr*}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)*{val : val} :: [REF.EXN_ADDR_instr(a)] :: [THROW_REF_instr] :: instr*{instr : instr}), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+    -- if ((val*{val : val} =/= []) \/ (instr*{instr : instr} =/= []))
+
+  ;; 8-reduction.watsup
+  rule throw_ref-label{z : state, n : n, instr'* : instr*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-frame{z : state, n : n, f : frame, a : addr}:
+    `%~>%`(`%;%`_config(z, [`FRAME_%{%}%`_instr(n, f, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-empty{z : state, n : n, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [], [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch{z : state, n : n, x : idx, l : labelidx, catch'* : catch*, a : addr, val* : val*}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_catch(x, l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), (val : val <: instr)*{val : val} :: [BR_instr(l)])
+    -- if ($exninst(z)[a].TAG_exninst = $tagaddr(z)[x!`%`_idx.0])
+    -- if (val*{val : val} = $exninst(z)[a].FIELDS_exninst)
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_ref{z : state, n : n, x : idx, l : labelidx, catch'* : catch*, a : addr, val* : val*}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_REF_catch(x, l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), (val : val <: instr)*{val : val} :: [REF.EXN_ADDR_instr(a) BR_instr(l)])
+    -- if ($exninst(z)[a].TAG_exninst = $tagaddr(z)[x!`%`_idx.0])
+    -- if (val*{val : val} = $exninst(z)[a].FIELDS_exninst)
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_all{z : state, n : n, l : labelidx, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_ALL_catch(l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [BR_instr(l)])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_all_ref{z : state, n : n, l : labelidx, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_ALL_REF_catch(l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) BR_instr(l)])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-next{z : state, n : n, catch : catch, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [catch] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [`HANDLER_%{%}%`_instr(n, catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])])
+    -- otherwise
+
+  ;; 8-reduction.watsup
+  rule try_table{z : state, val^m : val^m, m : m, bt : blocktype, catch* : catch*, instr* : instr*, n : n, t_1^m : valtype^m, t_2^n : valtype^n}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)^m{val : val} :: [TRY_TABLE_instr(bt, `%`_list(catch*{catch : catch}), instr*{instr : instr})]), [`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, [`LABEL_%{%}%`_instr(n, [], (val : val <: instr)^m{val : val} :: instr*{instr : instr})])])
+    -- if ($blocktype_(z, bt) = `%->%`_functype(`%`_resulttype(t_1^m{t_1 : valtype}), `%`_resulttype(t_2^n{t_2 : valtype})))
+
   ;; 8-reduction.watsup
   rule ref.null-idx{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(($idx(x) : typevar <: heaptype))]), [REF.NULL_instr(($type(z, x) : deftype <: heaptype))])
@@ -13599,7 +14242,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule ref.test-true{s : store, f : frame, ref : ref, rt : reftype, rt' : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) REF.TEST_instr(rt)]), [CONST_instr(I32_numtype, `%`_num_(1))])
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
 
   ;; 8-reduction.watsup
   rule ref.test-false{s : store, f : frame, ref : ref, rt : reftype}:
@@ -13610,7 +14253,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule ref.cast-succeed{s : store, f : frame, ref : ref, rt : reftype, rt' : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) REF.CAST_instr(rt)]), [(ref : ref <: instr)])
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
 
   ;; 8-reduction.watsup
   rule ref.cast-fail{s : store, f : frame, ref : ref, rt : reftype}:
@@ -14025,135 +14668,142 @@ relation Step: `%~>%`(config, config)
     `%~>%`(`%;%`_config(z, instr*{instr : instr}), `%;%`_config(z, instr'*{instr' : instr}))
     -- Step_read: `%~>%`(`%;%`_config(z, instr*{instr : instr}), instr'*{instr' : instr})
 
-  ;; 8-reduction.watsup:225.1-227.36
+  ;; 8-reduction.watsup:218.1-223.49
+  rule throw{z : state, val^n : val^n, n : n, x : idx, exn : exninst, a : addr, t^n : valtype^n}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [THROW_instr(x)]), `%;%`_config($add_exninst(z, [exn]), [REF.EXN_ADDR_instr(a) THROW_REF_instr]))
+    -- Expand: `%~~%`($tag(z, x).TYPE_taginst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t^n{t : valtype}), `%`_resulttype([]))))
+    -- if (a = |$exninst(z)|)
+    -- if (exn = {TAG $tagaddr(z)[x!`%`_idx.0], FIELDS val^n{val : val}})
+
+  ;; 8-reduction.watsup:285.1-287.36
   rule ctxt-label{z : state, n : n, instr_0* : instr*, instr* : instr*, z' : state, instr'* : instr*}:
     `%~>%`(`%;%`_config(z, [`LABEL_%{%}%`_instr(n, instr_0*{instr_0 : instr}, instr*{instr : instr})]), `%;%`_config(z', [`LABEL_%{%}%`_instr(n, instr_0*{instr_0 : instr}, instr'*{instr' : instr})]))
     -- Step: `%~>%`(`%;%`_config(z, instr*{instr : instr}), `%;%`_config(z', instr'*{instr' : instr}))
 
-  ;; 8-reduction.watsup:229.1-231.44
+  ;; 8-reduction.watsup:289.1-291.44
   rule ctxt-frame{s : store, f : frame, n : n, f' : frame, instr* : instr*, s' : store, instr'* : instr*}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [`FRAME_%{%}%`_instr(n, f', instr*{instr : instr})]), `%;%`_config(`%;%`_state(s', f), [`FRAME_%{%}%`_instr(n, f', instr'*{instr' : instr})]))
     -- Step: `%~>%`(`%;%`_config(`%;%`_state(s, f'), instr*{instr : instr}), `%;%`_config(`%;%`_state(s', f'), instr'*{instr' : instr}))
 
-  ;; 8-reduction.watsup:349.1-353.65
+  ;; 8-reduction.watsup:409.1-413.65
   rule struct.new{z : state, val^n : val^n, n : n, x : idx, si : structinst, a : addr, mut^n : mut^n, zt^n : storagetype^n}:
     `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [STRUCT.NEW_instr(x)]), `%;%`_config($add_structinst(z, [si]), [REF.STRUCT_ADDR_instr(a)]))
     -- Expand: `%~~%`($type(z, x), STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)^n{mut : mut, zt : storagetype})))
     -- if (a = |$structinst(z)|)
     -- if (si = {TYPE $type(z, x), FIELDS $packfield_(zt, val)^n{val : val, zt : storagetype}})
 
-  ;; 8-reduction.watsup:369.1-370.53
+  ;; 8-reduction.watsup:429.1-430.53
   rule struct.set-null{z : state, ht : heaptype, val : val, x : idx, i : nat}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) (val : val <: instr) STRUCT.SET_instr(x, `%`_u32(i))]), `%;%`_config(z, [TRAP_instr]))
 
-  ;; 8-reduction.watsup:372.1-374.45
+  ;; 8-reduction.watsup:432.1-434.45
   rule struct.set-struct{z : state, a : addr, val : val, x : idx, i : nat, zt* : storagetype*, mut* : mut*}:
     `%~>%`(`%;%`_config(z, [REF.STRUCT_ADDR_instr(a) (val : val <: instr) STRUCT.SET_instr(x, `%`_u32(i))]), `%;%`_config($with_struct(z, a, i, $packfield_(zt*{zt : storagetype}[i], val)), []))
     -- Expand: `%~~%`($type(z, x), STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
 
-  ;; 8-reduction.watsup:387.1-392.65
+  ;; 8-reduction.watsup:447.1-452.65
   rule array.new_fixed{z : state, val^n : val^n, n : n, x : idx, ai : arrayinst, a : addr, mut : mut, zt : storagetype}:
     `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [ARRAY.NEW_FIXED_instr(x, `%`_u32(n))]), `%;%`_config($add_arrayinst(z, [ai]), [REF.ARRAY_ADDR_instr(a)]))
     -- Expand: `%~~%`($type(z, x), ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ((a = |$arrayinst(z)|) /\ (ai = {TYPE $type(z, x), FIELDS $packfield_(zt, val)^n{val : val}}))
 
-  ;; 8-reduction.watsup:432.1-433.64
+  ;; 8-reduction.watsup:492.1-493.64
   rule array.set-null{z : state, ht : heaptype, i : nat, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
 
-  ;; 8-reduction.watsup:435.1-437.39
+  ;; 8-reduction.watsup:495.1-497.39
   rule array.set-oob{z : state, a : addr, i : nat, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.ARRAY_ADDR_instr(a) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
     -- if (i >= |$arrayinst(z)[a].FIELDS_arrayinst|)
 
-  ;; 8-reduction.watsup:439.1-442.43
+  ;; 8-reduction.watsup:499.1-502.43
   rule array.set-array{z : state, a : addr, i : nat, val : val, x : idx, zt : storagetype, mut : mut}:
     `%~>%`(`%;%`_config(z, [REF.ARRAY_ADDR_instr(a) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config($with_array(z, a, i, $packfield_(zt, val)), []))
     -- Expand: `%~~%`($type(z, x), ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 8-reduction.watsup:743.1-744.56
+  ;; 8-reduction.watsup:803.1-804.56
   rule local.set{z : state, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [(val : val <: instr) LOCAL.SET_instr(x)]), `%;%`_config($with_local(z, x, val), []))
 
-  ;; 8-reduction.watsup:756.1-757.58
+  ;; 8-reduction.watsup:816.1-817.58
   rule global.set{z : state, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [(val : val <: instr) GLOBAL.SET_instr(x)]), `%;%`_config($with_global(z, x, val), []))
 
-  ;; 8-reduction.watsup:770.1-772.33
+  ;; 8-reduction.watsup:830.1-832.33
   rule table.set-oob{z : state, i : nat, ref : ref, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) (ref : ref <: instr) TABLE.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
     -- if (i >= |$table(z, x).REFS_tableinst|)
 
-  ;; 8-reduction.watsup:774.1-776.32
+  ;; 8-reduction.watsup:834.1-836.32
   rule table.set-val{z : state, i : nat, ref : ref, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) (ref : ref <: instr) TABLE.SET_instr(x)]), `%;%`_config($with_table(z, x, i, ref), []))
     -- if (i < |$table(z, x).REFS_tableinst|)
 
-  ;; 8-reduction.watsup:784.1-787.46
+  ;; 8-reduction.watsup:844.1-847.46
   rule table.grow-succeed{z : state, ref : ref, n : n, x : idx, ti : tableinst}:
     `%~>%`(`%;%`_config(z, [(ref : ref <: instr) CONST_instr(I32_numtype, `%`_num_(n)) TABLE.GROW_instr(x)]), `%;%`_config($with_tableinst(z, x, ti), [CONST_instr(I32_numtype, `%`_num_(|$table(z, x).REFS_tableinst|))]))
     -- if (ti = !($growtable($table(z, x), n, ref)))
 
-  ;; 8-reduction.watsup:789.1-790.81
+  ;; 8-reduction.watsup:849.1-850.81
   rule table.grow-fail{z : state, ref : ref, n : n, x : idx}:
     `%~>%`(`%;%`_config(z, [(ref : ref <: instr) CONST_instr(I32_numtype, `%`_num_(n)) TABLE.GROW_instr(x)]), `%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_($invsigned_(32, - (1 : nat <: int))))]))
 
-  ;; 8-reduction.watsup:850.1-851.51
+  ;; 8-reduction.watsup:910.1-911.51
   rule elem.drop{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [ELEM.DROP_instr(x)]), `%;%`_config($with_elem(z, x, []), []))
 
-  ;; 8-reduction.watsup:934.1-937.60
+  ;; 8-reduction.watsup:994.1-997.60
   rule store-num-oob{z : state, i : nat, nt : numtype, c : num_(nt), x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr(nt, c) STORE_instr(nt, ?(), x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + ($size(nt) / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:939.1-943.29
+  ;; 8-reduction.watsup:999.1-1003.29
   rule store-num-val{z : state, i : nat, nt : numtype, c : num_(nt), x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr(nt, c) STORE_instr(nt, ?(), x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), ($size(nt) / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $nbytes_(nt, c))
 
-  ;; 8-reduction.watsup:945.1-948.52
+  ;; 8-reduction.watsup:1005.1-1008.52
   rule store-pack-oob{z : state, i : nat, Inn : Inn, c : num_((Inn : Inn <: numtype)), nt : numtype, n : n, x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr((Inn : Inn <: numtype), c) STORE_instr(nt, ?(`%`_sz(n)), x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + (n / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:950.1-954.52
+  ;; 8-reduction.watsup:1010.1-1014.52
   rule store-pack-val{z : state, i : nat, Inn : Inn, c : num_((Inn : Inn <: numtype)), nt : numtype, n : n, x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr((Inn : Inn <: numtype), c) STORE_instr(nt, ?(`%`_sz(n)), x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), (n / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $ibytes_(n, $wrap__($size((Inn : Inn <: numtype)), n, c)))
 
-  ;; 8-reduction.watsup:956.1-958.63
+  ;; 8-reduction.watsup:1016.1-1018.63
   rule vstore-oob{z : state, i : nat, c : vec_(V128_Vnn), x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_instr(V128_vectype, x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + ($vsize(V128_vectype) / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:960.1-962.31
+  ;; 8-reduction.watsup:1020.1-1022.31
   rule vstore-val{z : state, i : nat, c : vec_(V128_Vnn), x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_instr(V128_vectype, x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), ($vsize(V128_vectype) / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $vbytes_(V128_vectype, c))
 
-  ;; 8-reduction.watsup:965.1-967.50
+  ;; 8-reduction.watsup:1025.1-1027.50
   rule vstore_lane-oob{z : state, i : nat, c : vec_(V128_Vnn), N : N, x : idx, ao : memarg, j : nat}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, ao, `%`_laneidx(j))]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + N) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:969.1-973.49
+  ;; 8-reduction.watsup:1029.1-1033.49
   rule vstore_lane-val{z : state, i : nat, c : vec_(V128_Vnn), N : N, x : idx, ao : memarg, j : nat, b* : byte*, Jnn : Jnn, M : M}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, ao, `%`_laneidx(j))]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), (N / 8), b*{b : byte}), []))
     -- if (N = $lsize((Jnn : Jnn <: lanetype)))
     -- if (M = (128 / N))
     -- if (b*{b : byte} = $ibytes_(N, `%`_iN($lanes_(`%X%`_shape((Jnn : Jnn <: lanetype), `%`_dim(M)), c)[j]!`%`_lane_.0)))
 
-  ;; 8-reduction.watsup:981.1-984.37
+  ;; 8-reduction.watsup:1041.1-1044.37
   rule memory.grow-succeed{z : state, n : n, x : idx, mi : meminst}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(n)) MEMORY.GROW_instr(x)]), `%;%`_config($with_meminst(z, x, mi), [CONST_instr(I32_numtype, `%`_num_((|$mem(z, x).BYTES_meminst| / (64 * $Ki))))]))
     -- if (mi = !($growmem($mem(z, x), n)))
 
-  ;; 8-reduction.watsup:986.1-987.78
+  ;; 8-reduction.watsup:1046.1-1047.78
   rule memory.grow-fail{z : state, n : n, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(n)) MEMORY.GROW_instr(x)]), `%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_($invsigned_(32, - (1 : nat <: int))))]))
 
-  ;; 8-reduction.watsup:1047.1-1048.51
+  ;; 8-reduction.watsup:1107.1-1108.51
   rule data.drop{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [DATA.DROP_instr(x)]), `%;%`_config($with_data(z, x, []), []))
 }
@@ -14199,7 +14849,7 @@ def $alloctypes(type*) : deftype*
 ;; 9-module.watsup
 def $allocfunc(store : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst) : (store, funcaddr)
   ;; 9-module.watsup
-  def $allocfunc{s : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst, funcinst : funcinst}(s, deftype, funccode, moduleinst) = (s ++ {FUNCS [funcinst], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.FUNCS_store|)
+  def $allocfunc{s : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst, funcinst : funcinst}(s, deftype, funccode, moduleinst) = (s ++ {FUNCS [funcinst], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.FUNCS_store|)
     -- if (funcinst = {TYPE deftype, MODULE moduleinst, CODE funccode})
 
 ;; 9-module.watsup
@@ -14218,7 +14868,7 @@ def $allocfuncs(store : store, deftype*, funccode*, moduleinst*) : (store, funca
 ;; 9-module.watsup
 def $allocglobal(store : store, globaltype : globaltype, val : val) : (store, globaladdr)
   ;; 9-module.watsup
-  def $allocglobal{s : store, globaltype : globaltype, val : val, globalinst : globalinst}(s, globaltype, val) = (s ++ {FUNCS [], GLOBALS [globalinst], TABLES [], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.GLOBALS_store|)
+  def $allocglobal{s : store, globaltype : globaltype, val : val, globalinst : globalinst}(s, globaltype, val) = (s ++ {FUNCS [], GLOBALS [globalinst], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.GLOBALS_store|)
     -- if (globalinst = {TYPE globaltype, VALUE val})
 
 ;; 9-module.watsup
@@ -14237,7 +14887,7 @@ def $allocglobals(store : store, globaltype*, val*) : (store, globaladdr*)
 ;; 9-module.watsup
 def $alloctable(store : store, tabletype : tabletype, ref : ref) : (store, tableaddr)
   ;; 9-module.watsup
-  def $alloctable{s : store, i : nat, j : nat, rt : reftype, ref : ref, tableinst : tableinst}(s, `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), ref) = (s ++ {FUNCS [], GLOBALS [], TABLES [tableinst], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.TABLES_store|)
+  def $alloctable{s : store, i : nat, j : nat, rt : reftype, ref : ref, tableinst : tableinst}(s, `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), ref) = (s ++ {FUNCS [], GLOBALS [], TABLES [tableinst], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.TABLES_store|)
     -- if (tableinst = {TYPE `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), REFS ref^i{}})
 
 ;; 9-module.watsup
@@ -14256,7 +14906,7 @@ def $alloctables(store : store, tabletype*, ref*) : (store, tableaddr*)
 ;; 9-module.watsup
 def $allocmem(store : store, memtype : memtype) : (store, memaddr)
   ;; 9-module.watsup
-  def $allocmem{s : store, i : nat, j : nat, meminst : meminst}(s, `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)))) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [meminst], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.MEMS_store|)
+  def $allocmem{s : store, i : nat, j : nat, meminst : meminst}(s, `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)))) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [meminst], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.MEMS_store|)
     -- if (meminst = {TYPE `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j))), BYTES `%`_byte(0)^(i * (64 * $Ki)){}})
 
 ;; 9-module.watsup
@@ -14272,39 +14922,58 @@ def $allocmems(store : store, memtype*) : (store, memaddr*)
     -- if ((s_2, ma'*{ma' : memaddr}) = $allocmems(s_1, memtype'*{memtype' : memtype}))
 }
 
+;; 9-module.watsup
+def $alloctag(store : store, tagtype : tagtype) : (store, tagaddr)
+  ;; 9-module.watsup
+  def $alloctag{s : store, at : tagtype, taginst : taginst}(s, at) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [taginst], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.TAGS_store|)
+    -- if (taginst = {TYPE at})
+
+;; 9-module.watsup
+rec {
+
+;; 9-module.watsup:64.1-64.82
+def $alloctags(store : store, tagtype*) : (store, tagaddr*)
+  ;; 9-module.watsup:65.1-65.34
+  def $alloctags{s : store}(s, []) = (s, [])
+  ;; 9-module.watsup:66.1-68.44
+  def $alloctags{s : store, at : tagtype, at'* : tagtype*, s_2 : store, aa : tagaddr, aa'* : tagaddr*, s_1 : store}(s, [at] :: at'*{at' : tagtype}) = (s_2, [aa] :: aa'*{aa' : tagaddr})
+    -- if ((s_1, aa) = $alloctag(s, at))
+    -- if ((s_2, aa'*{aa' : tagaddr}) = $alloctags(s_1, at'*{at' : tagtype}))
+}
+
 ;; 9-module.watsup
 def $allocelem(store : store, elemtype : elemtype, ref*) : (store, elemaddr)
   ;; 9-module.watsup
-  def $allocelem{s : store, elemtype : elemtype, ref* : ref*, eleminst : eleminst}(s, elemtype, ref*{ref : ref}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [eleminst], DATAS [], STRUCTS [], ARRAYS []}, |s.ELEMS_store|)
+  def $allocelem{s : store, elemtype : elemtype, ref* : ref*, eleminst : eleminst}(s, elemtype, ref*{ref : ref}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [eleminst], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.ELEMS_store|)
     -- if (eleminst = {TYPE elemtype, REFS ref*{ref : ref}})
 
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:64.1-64.97
+;; 9-module.watsup:75.1-75.97
 def $allocelems(store : store, elemtype*, ref**) : (store, elemaddr*)
-  ;; 9-module.watsup:65.1-65.40
+  ;; 9-module.watsup:76.1-76.40
   def $allocelems{s : store}(s, [], []) = (s, [])
-  ;; 9-module.watsup:66.1-68.55
+  ;; 9-module.watsup:77.1-79.55
   def $allocelems{s : store, rt : reftype, rt'* : reftype*, ref* : ref*, ref'** : ref**, s_2 : store, ea : elemaddr, ea'* : elemaddr*, s_1 : store}(s, [rt] :: rt'*{rt' : elemtype}, [ref*{ref : ref}] :: ref'*{ref' : ref}*{ref' : ref}) = (s_2, [ea] :: ea'*{ea' : elemaddr})
     -- if ((s_1, ea) = $allocelem(s, rt, ref*{ref : ref}))
-    -- if ((s_2, ea'*{ea' : elemaddr}) = $allocelems(s_2, rt'*{rt' : elemtype}, ref'*{ref' : ref}*{ref' : ref}))
+    -- if ((s_2, ea'*{ea' : elemaddr}) = $allocelems(s_1, rt'*{rt' : elemtype}, ref'*{ref' : ref}*{ref' : ref}))
 }
 
 ;; 9-module.watsup
 def $allocdata(store : store, datatype : datatype, byte*) : (store, dataaddr)
   ;; 9-module.watsup
-  def $allocdata{s : store, byte* : byte*, datainst : datainst}(s, OK_datatype, byte*{byte : byte}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [datainst], STRUCTS [], ARRAYS []}, |s.DATAS_store|)
+  def $allocdata{s : store, byte* : byte*, datainst : datainst}(s, OK_datatype, byte*{byte : byte}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [datainst], STRUCTS [], ARRAYS [], EXNS []}, |s.DATAS_store|)
     -- if (datainst = {BYTES byte*{byte : byte}})
 
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:75.1-75.98
+;; 9-module.watsup:86.1-86.98
 def $allocdatas(store : store, datatype*, byte**) : (store, dataaddr*)
-  ;; 9-module.watsup:76.1-76.40
+  ;; 9-module.watsup:87.1-87.40
   def $allocdatas{s : store}(s, [], []) = (s, [])
-  ;; 9-module.watsup:77.1-79.53
+  ;; 9-module.watsup:88.1-90.53
   def $allocdatas{s : store, ok : datatype, ok'* : datatype*, b* : byte*, b'** : byte**, s_2 : store, da : dataaddr, da'* : dataaddr*, s_1 : store}(s, [ok] :: ok'*{ok' : datatype}, [b*{b : byte}] :: b'*{b' : byte}*{b' : byte}) = (s_2, [da] :: da'*{da' : dataaddr})
     -- if ((s_1, da) = $allocdata(s, ok, b*{b : byte}))
     -- if ((s_2, da'*{da' : dataaddr}) = $allocdatas(s_1, ok'*{ok' : datatype}, b'*{b' : byte}*{b' : byte}))
@@ -14313,13 +14982,15 @@ def $allocdatas(store : store, datatype*, byte**) : (store, dataaddr*)
 ;; 9-module.watsup
 def $allocexport(moduleinst : moduleinst, export : export) : exportinst
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, FUNC_externidx(x))) = {NAME name, VALUE FUNC_externval(moduleinst.FUNCS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, FUNC_externidx(x))) = {NAME name, ADDR FUNC_externaddr(moduleinst.FUNCS_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, GLOBAL_externidx(x))) = {NAME name, VALUE GLOBAL_externval(moduleinst.GLOBALS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, GLOBAL_externidx(x))) = {NAME name, ADDR GLOBAL_externaddr(moduleinst.GLOBALS_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TABLE_externidx(x))) = {NAME name, VALUE TABLE_externval(moduleinst.TABLES_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TABLE_externidx(x))) = {NAME name, ADDR TABLE_externaddr(moduleinst.TABLES_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, MEM_externidx(x))) = {NAME name, VALUE MEM_externval(moduleinst.MEMS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, MEM_externidx(x))) = {NAME name, ADDR MEM_externaddr(moduleinst.MEMS_moduleinst[x!`%`_idx.0])}
+  ;; 9-module.watsup
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TAG_externidx(x))) = {NAME name, ADDR TAG_externaddr(moduleinst.TAGS_moduleinst[x!`%`_idx.0])}
 
 ;; 9-module.watsup
 def $allocexports(moduleinst : moduleinst, export*) : exportinst*
@@ -14327,35 +14998,39 @@ def $allocexports(moduleinst : moduleinst, export*) : exportinst*
   def $allocexports{moduleinst : moduleinst, export* : export*}(moduleinst, export*{export : export}) = $allocexport(moduleinst, export)*{export : export}
 
 ;; 9-module.watsup
-def $allocmodule(store : store, module : module, externval*, val*, ref*, ref**) : (store, moduleinst)
+def $allocmodule(store : store, module : module, externaddr*, val*, ref*, ref**) : (store, moduleinst)
   ;; 9-module.watsup
-  def $allocmodule{s : store, module : module, externval* : externval*, val_G* : val*, ref_T* : ref*, ref_E** : ref**, s_6 : store, moduleinst : moduleinst, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, x* : idx*, local** : local**, expr_F* : expr*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, memtype* : memtype*, elemtype* : elemtype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, fa_I* : funcaddr*, ga_I* : globaladdr*, ta_I* : tableaddr*, ma_I* : memaddr*, fa* : funcaddr*, i_F^|func*{func : func}| : nat^|func*{func : func}|, ga* : globaladdr*, i_G^|global*{global : global}| : nat^|global*{global : global}|, ta* : tableaddr*, i_T^|table*{table : table}| : nat^|table*{table : table}|, ma* : memaddr*, i_M^|mem*{mem : mem}| : nat^|mem*{mem : mem}|, ea* : elemaddr*, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, da* : dataaddr*, i_D^|data*{data : data}| : nat^|data*{data : data}|, dt* : deftype*, s_1 : store, s_2 : store, s_3 : store, s_4 : store, s_5 : store, xi* : exportinst*}(s, module, externval*{externval : externval}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}) = (s_6, moduleinst)
-    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
+  def $allocmodule{s : store, module : module, externaddr* : externaddr*, val_G* : val*, ref_T* : ref*, ref_E** : ref**, s_7 : store, moduleinst : moduleinst, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, x* : idx*, local** : local**, expr_F* : expr*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, memtype* : memtype*, y* : idx*, elemtype* : elemtype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, fa_I* : funcaddr*, ga_I* : globaladdr*, ta_I* : tableaddr*, ma_I* : memaddr*, aa_I* : tagaddr*, fa* : nat*, i_F^|func*{func : func}| : nat^|func*{func : func}|, ga* : nat*, i_G^|global*{global : global}| : nat^|global*{global : global}|, ta* : nat*, i_T^|table*{table : table}| : nat^|table*{table : table}|, aa* : nat*, i_A^|tag*{tag : tag}| : nat^|tag*{tag : tag}|, ma* : nat*, i_M^|mem*{mem : mem}| : nat^|mem*{mem : mem}|, ea* : nat*, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, da* : nat*, i_D^|data*{data : data}| : nat^|data*{data : data}|, dt* : deftype*, s_1 : store, s_2 : store, s_3 : store, s_4 : store, s_5 : store, s_6 : store, xi* : exportinst*}(s, module, externaddr*{externaddr : externaddr}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}) = (s_7, moduleinst)
+    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
     -- if (func*{func : func} = FUNC_func(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx})
     -- if (global*{global : global} = GLOBAL_global(globaltype, expr_G)*{expr_G : expr, globaltype : globaltype})
     -- if (table*{table : table} = TABLE_table(tabletype, expr_T)*{expr_T : expr, tabletype : tabletype})
     -- if (mem*{mem : mem} = MEMORY_mem(memtype)*{memtype : memtype})
+    -- if (tag*{tag : tag} = TAG_tag(y)*{y : typeidx})
     -- if (elem*{elem : elem} = ELEM_elem(elemtype, expr_E*{expr_E : expr}, elemmode)*{elemmode : elemmode, elemtype : reftype, expr_E : expr})
     -- if (data*{data : data} = DATA_data(byte*{byte : byte}, datamode)*{byte : byte, datamode : datamode})
-    -- if (fa_I*{fa_I : funcaddr} = $funcsxv(externval*{externval : externval}))
-    -- if (ga_I*{ga_I : globaladdr} = $globalsxv(externval*{externval : externval}))
-    -- if (ta_I*{ta_I : tableaddr} = $tablesxv(externval*{externval : externval}))
-    -- if (ma_I*{ma_I : memaddr} = $memsxv(externval*{externval : externval}))
-    -- if (fa*{fa : funcaddr} = (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat})
-    -- if (ga*{ga : globaladdr} = (|s.GLOBALS_store| + i_G)^(i_G<|global*{global : global}|){i_G : nat})
-    -- if (ta*{ta : tableaddr} = (|s.TABLES_store| + i_T)^(i_T<|table*{table : table}|){i_T : nat})
-    -- if (ma*{ma : memaddr} = (|s.MEMS_store| + i_M)^(i_M<|mem*{mem : mem}|){i_M : nat})
-    -- if (ea*{ea : elemaddr} = (|s.ELEMS_store| + i_E)^(i_E<|elem*{elem : elem}|){i_E : nat})
-    -- if (da*{da : dataaddr} = (|s.DATAS_store| + i_D)^(i_D<|data*{data : data}|){i_D : nat})
+    -- if (fa_I*{fa_I : funcaddr} = $funcsxa(externaddr*{externaddr : externaddr}))
+    -- if (ga_I*{ga_I : globaladdr} = $globalsxa(externaddr*{externaddr : externaddr}))
+    -- if (ta_I*{ta_I : tableaddr} = $tablesxa(externaddr*{externaddr : externaddr}))
+    -- if (ma_I*{ma_I : memaddr} = $memsxa(externaddr*{externaddr : externaddr}))
+    -- if (aa_I*{aa_I : tagaddr} = $tagsxa(externaddr*{externaddr : externaddr}))
+    -- if (fa*{fa : nat} = (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat})
+    -- if (ga*{ga : nat} = (|s.GLOBALS_store| + i_G)^(i_G<|global*{global : global}|){i_G : nat})
+    -- if (ta*{ta : nat} = (|s.TABLES_store| + i_T)^(i_T<|table*{table : table}|){i_T : nat})
+    -- if (aa*{aa : nat} = (|s.TAGS_store| + i_A)^(i_A<|tag*{tag : tag}|){i_A : nat})
+    -- if (ma*{ma : nat} = (|s.MEMS_store| + i_M)^(i_M<|mem*{mem : mem}|){i_M : nat})
+    -- if (ea*{ea : nat} = (|s.ELEMS_store| + i_E)^(i_E<|elem*{elem : elem}|){i_E : nat})
+    -- if (da*{da : nat} = (|s.DATAS_store| + i_D)^(i_D<|data*{data : data}|){i_D : nat})
     -- if (dt*{dt : deftype} = $alloctypes(type*{type : type}))
-    -- if ((s_1, fa*{fa : funcaddr}) = $allocfuncs(s, dt*{dt : deftype}[x!`%`_idx.0]*{x : idx}, FUNC_funccode(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx}, moduleinst^|func*{func : func}|{}))
-    -- if ((s_2, ga*{ga : globaladdr}) = $allocglobals(s_1, globaltype*{globaltype : globaltype}, val_G*{val_G : val}))
-    -- if ((s_3, ta*{ta : tableaddr}) = $alloctables(s_2, tabletype*{tabletype : tabletype}, ref_T*{ref_T : ref}))
-    -- if ((s_4, ma*{ma : memaddr}) = $allocmems(s_3, memtype*{memtype : memtype}))
-    -- if ((s_5, ea*{ea : elemaddr}) = $allocelems(s_4, elemtype*{elemtype : elemtype}, ref_E*{ref_E : ref}*{ref_E : ref}))
-    -- if ((s_6, da*{da : dataaddr}) = $allocdatas(s_5, OK_datatype^|data*{data : data}|{}, byte*{byte : byte}*{byte : byte}))
-    -- if (xi*{xi : exportinst} = $allocexports({TYPES [], FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, ELEMS [], DATAS [], EXPORTS []}, export*{export : export}))
-    -- if (moduleinst = {TYPES dt*{dt : deftype}, FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, ELEMS ea*{ea : elemaddr}, DATAS da*{da : dataaddr}, EXPORTS xi*{xi : exportinst}})
+    -- if ((s_1, fa*{fa : nat}) = $allocfuncs(s, dt*{dt : deftype}[x!`%`_idx.0]*{x : idx}, FUNC_funccode(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx}, moduleinst^|func*{func : func}|{}))
+    -- if ((s_2, ga*{ga : nat}) = $allocglobals(s_1, globaltype*{globaltype : globaltype}, val_G*{val_G : val}))
+    -- if ((s_3, ta*{ta : nat}) = $alloctables(s_2, tabletype*{tabletype : tabletype}, ref_T*{ref_T : ref}))
+    -- if ((s_4, ma*{ma : nat}) = $allocmems(s_3, memtype*{memtype : memtype}))
+    -- if ((s_5, aa*{aa : nat}) = $alloctags(s_4, dt*{dt : deftype}[y!`%`_idx.0]*{y : idx}))
+    -- if ((s_6, ea*{ea : nat}) = $allocelems(s_5, elemtype*{elemtype : elemtype}, ref_E*{ref_E : ref}*{ref_E : ref}))
+    -- if ((s_7, da*{da : nat}) = $allocdatas(s_6, OK_datatype^|data*{data : data}|{}, byte*{byte : byte}*{byte : byte}))
+    -- if (xi*{xi : exportinst} = $allocexports({TYPES [], FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, TAGS aa_I*{aa_I : tagaddr} :: aa*{aa : tagaddr}, ELEMS [], DATAS [], EXPORTS []}, export*{export : export}))
+    -- if (moduleinst = {TYPES dt*{dt : deftype}, FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, TAGS aa_I*{aa_I : tagaddr} :: aa*{aa : tagaddr}, ELEMS ea*{ea : elemaddr}, DATAS da*{da : dataaddr}, EXPORTS xi*{xi : exportinst}})
 
 ;; 9-module.watsup
 def $runelem_(elemidx : elemidx, elem : elem) : instr*
@@ -14376,11 +15051,11 @@ def $rundata_(dataidx : dataidx, data : data) : instr*
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:152.1-152.94
+;; 9-module.watsup:169.1-169.94
 def $evalglobals(state : state, globaltype*, expr*) : (state, val*)
-  ;; 9-module.watsup:153.1-153.41
+  ;; 9-module.watsup:170.1-170.41
   def $evalglobals{z : state}(z, [], []) = (z, [])
-  ;; 9-module.watsup:154.1-159.81
+  ;; 9-module.watsup:171.1-176.81
   def $evalglobals{z : state, gt : globaltype, gt'* : globaltype*, expr : expr, expr'* : expr*, z' : state, val : val, val'* : val*, s : store, f : frame, s' : store, a : addr}(z, [gt] :: gt'*{gt' : globaltype}, [expr] :: expr'*{expr' : expr}) = (z', [val] :: val'*{val' : val})
     -- Eval_expr: `%;%~>*%;%`(z, expr, z, [val])
     -- if (z = `%;%`_state(s, f))
@@ -14389,23 +15064,23 @@ def $evalglobals(state : state, globaltype*, expr*) : (state, val*)
 }
 
 ;; 9-module.watsup
-def $instantiate(store : store, module : module, externval*) : config
+def $instantiate(store : store, module : module, externaddr*) : config
   ;; 9-module.watsup
-  def $instantiate{s : store, module : module, externval* : externval*, s' : store, f : frame, instr_E* : instr*, instr_D* : instr*, instr_S? : instr?, xt_I* : externtype*, xt_E* : externtype*, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, reftype* : reftype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, x? : idx?, moduleinst_0 : moduleinst, i_F^|func*{func : func}| : nat^|func*{func : func}|, z : state, z' : state, val_G* : val*, ref_T* : ref*, ref_E** : ref**, moduleinst : moduleinst, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, i_D^|data*{data : data}| : nat^|data*{data : data}|}(s, module, externval*{externval : externval}) = `%;%`_config(`%;%`_state(s', f), instr_E*{instr_E : instr} :: instr_D*{instr_D : instr} :: instr_S?{instr_S : instr})
+  def $instantiate{s : store, module : module, externaddr* : externaddr*, s' : store, f : frame, instr_E* : instr*, instr_D* : instr*, instr_S? : instr?, xt_I* : externtype*, xt_E* : externtype*, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, reftype* : reftype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, x? : idx?, moduleinst_0 : moduleinst, i_F^|func*{func : func}| : nat^|func*{func : func}|, z : state, z' : state, val_G* : val*, ref_T* : ref*, ref_E** : ref**, moduleinst : moduleinst, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, i_D^|data*{data : data}| : nat^|data*{data : data}|}(s, module, externaddr*{externaddr : externaddr}) = `%;%`_config(`%;%`_state(s', f), instr_E*{instr_E : instr} :: instr_D*{instr_D : instr} :: instr_S?{instr_S : instr})
     -- Module_ok: `|-%:%`(module, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype}))
-    -- (Externval_type: `%|-%:%`(s, externval, xt_I))*{externval : externval, xt_I : externtype}
-    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
+    -- (Externaddr_type: `%|-%:%`(s, externaddr, xt_I))*{externaddr : externaddr, xt_I : externtype}
+    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
     -- if (global*{global : global} = GLOBAL_global(globaltype, expr_G)*{expr_G : expr, globaltype : globaltype})
     -- if (table*{table : table} = TABLE_table(tabletype, expr_T)*{expr_T : expr, tabletype : tabletype})
     -- if (elem*{elem : elem} = ELEM_elem(reftype, expr_E*{expr_E : expr}, elemmode)*{elemmode : elemmode, expr_E : expr, reftype : reftype})
     -- if (data*{data : data} = DATA_data(byte*{byte : byte}, datamode)*{byte : byte, datamode : datamode})
     -- if (start?{start : start} = START_start(x)?{x : funcidx})
-    -- if (moduleinst_0 = {TYPES $alloctypes(type*{type : type}), FUNCS $funcsxv(externval*{externval : externval}) :: (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat}, GLOBALS $globalsxv(externval*{externval : externval}), TABLES [], MEMS [], ELEMS [], DATAS [], EXPORTS []})
+    -- if (moduleinst_0 = {TYPES $alloctypes(type*{type : type}), FUNCS $funcsxa(externaddr*{externaddr : externaddr}) :: (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat}, GLOBALS $globalsxa(externaddr*{externaddr : externaddr}), TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], EXPORTS []})
     -- if (z = `%;%`_state(s, {LOCALS [], MODULE moduleinst_0}))
     -- if ((z', val_G*{val_G : val}) = $evalglobals(z, globaltype*{globaltype : globaltype}, expr_G*{expr_G : expr}))
     -- (Eval_expr: `%;%~>*%;%`(z', expr_T, z', [(ref_T : ref <: val)]))*{expr_T : expr, ref_T : ref}
     -- (Eval_expr: `%;%~>*%;%`(z', expr_E, z', [(ref_E : ref <: val)]))*{expr_E : expr, ref_E : ref}*{expr_E : expr, ref_E : ref}
-    -- if ((s', moduleinst) = $allocmodule(s, module, externval*{externval : externval}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}))
+    -- if ((s', moduleinst) = $allocmodule(s, module, externaddr*{externaddr : externaddr}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}))
     -- if (f = {LOCALS [], MODULE moduleinst})
     -- if (instr_E*{instr_E : instr} = $concat_(syntax instr, $runelem_(`%`_elemidx(i_E), elem*{elem : elem}[i_E])^(i_E<|elem*{elem : elem}|){i_E : nat}))
     -- if (instr_D*{instr_D : instr} = $concat_(syntax instr, $rundata_(`%`_dataidx(i_D), data*{data : data}[i_D])^(i_D<|data*{data : data}|){i_D : nat}))
@@ -14417,7 +15092,7 @@ def $invoke(store : store, funcaddr : funcaddr, val*) : config
   def $invoke{s : store, funcaddr : funcaddr, val* : val*, f : frame, t_1* : valtype*, t_2* : valtype*}(s, funcaddr, val*{val : val}) = `%;%`_config(`%;%`_state(s, f), (val : val <: instr)*{val : val} :: [REF.FUNC_ADDR_instr(funcaddr) CALL_REF_instr((s.FUNCS_store[funcaddr].TYPE_funcinst : deftype <: typeuse))])
     -- Expand: `%~~%`(s.FUNCS_store[funcaddr].TYPE_funcinst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
     -- (Val_type: `%|-%:%`(s, val, t_1))*{t_1 : valtype, val : val}
-    -- if (f = {LOCALS [], MODULE {TYPES [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], EXPORTS []}})
+    -- if (f = {LOCALS [], MODULE {TYPES [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], EXPORTS []}})
 
 ;; A-binary.watsup
 grammar Bbyte : byte
@@ -14520,6 +15195,11 @@ grammar Bmemidx : memidx
   ;; A-binary.watsup
   prod{x : idx} x:Bu32 => x
 
+;; A-binary.watsup
+grammar Btagidx : tagidx
+  ;; A-binary.watsup
+  prod{x : idx} x:Bu32 => x
+
 ;; A-binary.watsup
 grammar Belemidx : elemidx
   ;; A-binary.watsup
@@ -14550,6 +15230,8 @@ grammar Bexternidx : externidx
   prod{x : idx} {0x02 x:Bmemidx} => MEM_externidx(x)
   ;; A-binary.watsup
   prod{x : idx} {0x03 x:Bglobalidx} => GLOBAL_externidx(x)
+  ;; A-binary.watsup
+  prod{x : idx} {0x04 x:Btagidx} => TAG_externidx(x)
 
 ;; A-binary.watsup
 grammar Bnumtype : numtype
@@ -14569,6 +15251,8 @@ grammar Bvectype : vectype
 
 ;; A-binary.watsup
 grammar Babsheaptype : heaptype
+  ;; A-binary.watsup
+  prod 0x69 => EXN_heaptype
   ;; A-binary.watsup
   prod 0x6A => ARRAY_heaptype
   ;; A-binary.watsup
@@ -14589,6 +15273,8 @@ grammar Babsheaptype : heaptype
   prod 0x72 => NOEXTERN_heaptype
   ;; A-binary.watsup
   prod 0x73 => NOFUNC_heaptype
+  ;; A-binary.watsup
+  prod 0x74 => NOEXN_heaptype
 
 ;; A-binary.watsup
 grammar Bheaptype : heaptype
@@ -14694,6 +15380,11 @@ grammar Bmemtype : memtype
   ;; A-binary.watsup
   prod{lim : limits} lim:Blimits => `%PAGE`_memtype(lim)
 
+;; A-binary.watsup
+grammar Btagtype : typeidx
+  ;; A-binary.watsup
+  prod{x : idx} {0x00 x:Btypeidx} => x
+
 ;; A-binary.watsup
 grammar Bexterntype : externtype
   ;; A-binary.watsup
@@ -14704,6 +15395,8 @@ grammar Bexterntype : externtype
   prod{mt : memtype} {0x02 mt:Bmemtype} => MEM_externtype(mt)
   ;; A-binary.watsup
   prod{gt : globaltype} {0x03 gt:Bglobaltype} => GLOBAL_externtype(gt)
+  ;; A-binary.watsup
+  prod{x : idx} {0x04 x:Btagtype} => TAG_externtype(($idx(x) : typevar <: typeuse))
 
 ;; A-binary.watsup
 grammar Bblocktype : blocktype
@@ -14715,6 +15408,17 @@ grammar Bblocktype : blocktype
   prod{i : nat} `%`_s33((i : nat <: int)):Bs33 => _IDX_blocktype(`%`_funcidx(i))
     -- if (i >= 0)
 
+;; A-binary.watsup
+grammar Bcatch : catch
+  ;; A-binary.watsup
+  prod{x : idx, l : labelidx} {0x00 x:Btagidx l:Blabelidx} => CATCH_catch(x, l)
+  ;; A-binary.watsup
+  prod{x : idx, l : labelidx} {0x01 x:Btagidx l:Blabelidx} => CATCH_REF_catch(x, l)
+  ;; A-binary.watsup
+  prod{l : labelidx} {0x02 l:Blabelidx} => CATCH_ALL_catch(l)
+  ;; A-binary.watsup
+  prod{l : labelidx} {0x03 l:Blabelidx} => CATCH_ALL_REF_catch(l)
+
 ;; A-binary.watsup
 syntax castop = (nul, nul)
 
@@ -14749,953 +15453,959 @@ grammar Blaneidx : laneidx
 ;; A-binary.watsup
 rec {
 
-;; A-binary.watsup:963.1-973.66
+;; A-binary.watsup:981.1-991.66
 grammar Binstr : instr
-  ;; A-binary.watsup:206.5-206.24
+  ;; A-binary.watsup:214.5-214.24
   prod 0x00 => UNREACHABLE_instr
-  ;; A-binary.watsup:207.5-207.16
+  ;; A-binary.watsup:215.5-215.16
   prod 0x01 => NOP_instr
-  ;; A-binary.watsup:208.5-208.57
+  ;; A-binary.watsup:216.5-216.57
   prod{bt : blocktype, in* : instr*} {0x02 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => BLOCK_instr(bt, in*{in : instr})
-  ;; A-binary.watsup:209.5-209.56
+  ;; A-binary.watsup:217.5-217.56
   prod{bt : blocktype, in* : instr*} {0x03 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => LOOP_instr(bt, in*{in : instr})
-  ;; A-binary.watsup:210.5-210.63
+  ;; A-binary.watsup:218.5-218.63
   prod{bt : blocktype, in* : instr*} {0x04 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => `IF%%ELSE%`_instr(bt, in*{in : instr}, [])
-  ;; A-binary.watsup:211.5-215.55
+  ;; A-binary.watsup:219.5-223.55
   prod{bt : blocktype, in_1* : instr*, in_2* : instr*} {0x04 bt:Bblocktype in_1:Binstr*{in_1 : instr} 0x05 in_2:Binstr*{in_2 : instr} 0x0B} => `IF%%ELSE%`_instr(bt, in_1*{in_1 : instr}, in_2*{in_2 : instr})
-  ;; A-binary.watsup:216.5-216.29
+  ;; A-binary.watsup:224.5-224.30
+  prod{x : idx} {0x08 x:Btagidx} => THROW_instr(x)
+  ;; A-binary.watsup:225.5-225.22
+  prod 0x0A => THROW_REF_instr
+  ;; A-binary.watsup:226.5-226.29
   prod{l : labelidx} {0x0C l:Blabelidx} => BR_instr(l)
-  ;; A-binary.watsup:217.5-217.32
+  ;; A-binary.watsup:227.5-227.32
   prod{l : labelidx} {0x0D l:Blabelidx} => BR_IF_instr(l)
-  ;; A-binary.watsup:218.5-218.62
+  ;; A-binary.watsup:228.5-228.62
   prod{l* : labelidx*, l_n : labelidx} {0x0E l*{l : labelidx}:Blist(syntax labelidx, grammar Blabelidx) l_n:Blabelidx} => BR_TABLE_instr(l*{l : labelidx}, l_n)
-  ;; A-binary.watsup:219.5-219.19
+  ;; A-binary.watsup:229.5-229.19
   prod 0x0F => RETURN_instr
-  ;; A-binary.watsup:220.5-220.30
+  ;; A-binary.watsup:230.5-230.30
   prod{x : idx} {0x10 x:Bfuncidx} => CALL_instr(x)
-  ;; A-binary.watsup:221.5-221.59
+  ;; A-binary.watsup:231.5-231.59
   prod{y : idx, x : idx} {0x11 y:Btypeidx x:Btableidx} => CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse))
-  ;; A-binary.watsup:222.5-222.37
+  ;; A-binary.watsup:232.5-232.37
   prod{x : idx} {0x12 x:Bfuncidx} => RETURN_CALL_instr(x)
-  ;; A-binary.watsup:223.5-223.66
+  ;; A-binary.watsup:233.5-233.66
   prod{y : idx, x : idx} {0x13 y:Btypeidx x:Btableidx} => RETURN_CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse))
-  ;; A-binary.watsup:238.5-238.37
+  ;; A-binary.watsup:234.5-235.26
+  prod{bt : blocktype, c* : catch*, in* : instr*} {0x1F bt:Bblocktype c*{c : catch}:Blist(syntax catch, grammar Bcatch) in:Binstr*{in : instr} 0x0B} => TRY_TABLE_instr(bt, `%`_list(c*{c : catch}), in*{in : instr})
+  ;; A-binary.watsup:256.5-256.37
   prod{ht : heaptype} {0xD0 ht:Bheaptype} => REF.NULL_instr(ht)
-  ;; A-binary.watsup:239.5-239.24
+  ;; A-binary.watsup:257.5-257.24
   prod 0xD1 => REF.IS_NULL_instr
-  ;; A-binary.watsup:240.5-240.34
+  ;; A-binary.watsup:258.5-258.34
   prod{x : idx} {0xD2 x:Bfuncidx} => REF.FUNC_instr(x)
-  ;; A-binary.watsup:241.5-241.19
+  ;; A-binary.watsup:259.5-259.19
   prod 0xD3 => REF.EQ_instr
-  ;; A-binary.watsup:242.5-242.28
+  ;; A-binary.watsup:260.5-260.28
   prod 0xD4 => REF.AS_NON_NULL_instr
-  ;; A-binary.watsup:243.5-243.37
+  ;; A-binary.watsup:261.5-261.37
   prod{l : labelidx} {0xD5 l:Blabelidx} => BR_ON_NULL_instr(l)
-  ;; A-binary.watsup:244.5-244.41
+  ;; A-binary.watsup:262.5-262.41
   prod{l : labelidx} {0xD6 l:Blabelidx} => BR_ON_NON_NULL_instr(l)
-  ;; A-binary.watsup:248.5-248.43
+  ;; A-binary.watsup:266.5-266.43
   prod{x : idx} {0xFB `%`_u32(0):Bu32 x:Btypeidx} => STRUCT.NEW_instr(x)
-  ;; A-binary.watsup:249.5-249.51
+  ;; A-binary.watsup:267.5-267.51
   prod{x : idx} {0xFB `%`_u32(1):Bu32 x:Btypeidx} => STRUCT.NEW_DEFAULT_instr(x)
-  ;; A-binary.watsup:250.5-250.52
+  ;; A-binary.watsup:268.5-268.52
   prod{x : idx, i : nat} {0xFB `%`_u32(2):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(), x, `%`_u32(i))
-  ;; A-binary.watsup:251.5-251.54
+  ;; A-binary.watsup:269.5-269.54
   prod{x : idx, i : nat} {0xFB `%`_u32(3):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(S_sx), x, `%`_u32(i))
-  ;; A-binary.watsup:252.5-252.54
+  ;; A-binary.watsup:270.5-270.54
   prod{x : idx, i : nat} {0xFB `%`_u32(4):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(U_sx), x, `%`_u32(i))
-  ;; A-binary.watsup:253.5-253.52
+  ;; A-binary.watsup:271.5-271.52
   prod{x : idx, i : nat} {0xFB `%`_u32(5):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.SET_instr(x, `%`_u32(i))
-  ;; A-binary.watsup:257.5-257.42
+  ;; A-binary.watsup:275.5-275.42
   prod{x : idx} {0xFB `%`_u32(6):Bu32 x:Btypeidx} => ARRAY.NEW_instr(x)
-  ;; A-binary.watsup:258.5-258.50
+  ;; A-binary.watsup:276.5-276.50
   prod{x : idx} {0xFB `%`_u32(7):Bu32 x:Btypeidx} => ARRAY.NEW_DEFAULT_instr(x)
-  ;; A-binary.watsup:259.5-259.57
+  ;; A-binary.watsup:277.5-277.57
   prod{x : idx, n : n} {0xFB `%`_u32(8):Bu32 x:Btypeidx `%`_u32(n):Bu32} => ARRAY.NEW_FIXED_instr(x, `%`_u32(n))
-  ;; A-binary.watsup:260.5-260.60
+  ;; A-binary.watsup:278.5-278.60
   prod{x : idx, y : idx} {0xFB `%`_u32(9):Bu32 x:Btypeidx y:Bdataidx} => ARRAY.NEW_DATA_instr(x, y)
-  ;; A-binary.watsup:261.5-261.61
+  ;; A-binary.watsup:279.5-279.61
   prod{x : idx, y : idx} {0xFB `%`_u32(10):Bu32 x:Btypeidx y:Belemidx} => ARRAY.NEW_ELEM_instr(x, y)
-  ;; A-binary.watsup:262.5-262.43
+  ;; A-binary.watsup:280.5-280.43
   prod{x : idx} {0xFB `%`_u32(11):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(), x)
-  ;; A-binary.watsup:263.5-263.45
+  ;; A-binary.watsup:281.5-281.45
   prod{x : idx} {0xFB `%`_u32(12):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(S_sx), x)
-  ;; A-binary.watsup:264.5-264.45
+  ;; A-binary.watsup:282.5-282.45
   prod{x : idx} {0xFB `%`_u32(13):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(U_sx), x)
-  ;; A-binary.watsup:265.5-265.43
+  ;; A-binary.watsup:283.5-283.43
   prod{x : idx} {0xFB `%`_u32(14):Bu32 x:Btypeidx} => ARRAY.SET_instr(x)
-  ;; A-binary.watsup:266.5-266.30
+  ;; A-binary.watsup:284.5-284.30
   prod {0xFB `%`_u32(15):Bu32} => ARRAY.LEN_instr
-  ;; A-binary.watsup:267.5-267.44
+  ;; A-binary.watsup:285.5-285.44
   prod{x : idx} {0xFB `%`_u32(16):Bu32 x:Btypeidx} => ARRAY.FILL_instr(x)
-  ;; A-binary.watsup:268.5-268.65
+  ;; A-binary.watsup:286.5-286.65
   prod{x_1 : idx, x_2 : idx} {0xFB `%`_u32(17):Bu32 x_1:Btypeidx x_2:Btypeidx} => ARRAY.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:269.5-269.62
+  ;; A-binary.watsup:287.5-287.62
   prod{x : idx, y : idx} {0xFB `%`_u32(18):Bu32 x:Btypeidx y:Bdataidx} => ARRAY.INIT_DATA_instr(x, y)
-  ;; A-binary.watsup:270.5-270.62
+  ;; A-binary.watsup:288.5-288.62
   prod{x : idx, y : idx} {0xFB `%`_u32(19):Bu32 x:Btypeidx y:Belemidx} => ARRAY.INIT_ELEM_instr(x, y)
-  ;; A-binary.watsup:274.5-274.51
+  ;; A-binary.watsup:292.5-292.51
   prod{ht : heaptype} {0xFB `%`_u32(20):Bu32 ht:Bheaptype} => REF.TEST_instr(REF_reftype(`NULL%?`_nul(?()), ht))
-  ;; A-binary.watsup:275.5-275.56
+  ;; A-binary.watsup:293.5-293.56
   prod{ht : heaptype} {0xFB `%`_u32(21):Bu32 ht:Bheaptype} => REF.TEST_instr(REF_reftype(`NULL%?`_nul(?(())), ht))
-  ;; A-binary.watsup:276.5-276.51
+  ;; A-binary.watsup:294.5-294.51
   prod{ht : heaptype} {0xFB `%`_u32(22):Bu32 ht:Bheaptype} => REF.CAST_instr(REF_reftype(`NULL%?`_nul(?()), ht))
-  ;; A-binary.watsup:277.5-277.56
+  ;; A-binary.watsup:295.5-295.56
   prod{ht : heaptype} {0xFB `%`_u32(23):Bu32 ht:Bheaptype} => REF.CAST_instr(REF_reftype(`NULL%?`_nul(?(())), ht))
-  ;; A-binary.watsup:278.5-282.94
+  ;; A-binary.watsup:296.5-300.94
   prod{nul1 : nul1, nul2 : nul2, l : labelidx, ht_1 : heaptype, ht_2 : heaptype} {0xFB `%`_u32(24):Bu32 (nul1, nul2):Bcastop l:Blabelidx ht_1:Bheaptype ht_2:Bheaptype} => BR_ON_CAST_instr(l, REF_reftype(nul1, ht_1), REF_reftype(nul2, ht_2))
-  ;; A-binary.watsup:283.5-287.99
+  ;; A-binary.watsup:301.5-305.99
   prod{nul1 : nul1, nul2 : nul2, l : labelidx, ht_1 : heaptype, ht_2 : heaptype} {0xFB `%`_u32(25):Bu32 (nul1, nul2):Bcastop l:Blabelidx ht_1:Bheaptype ht_2:Bheaptype} => BR_ON_CAST_FAIL_instr(l, REF_reftype(nul1, ht_1), REF_reftype(nul2, ht_2))
-  ;; A-binary.watsup:291.5-291.39
+  ;; A-binary.watsup:309.5-309.39
   prod {0xFB `%`_u32(26):Bu32} => ANY.CONVERT_EXTERN_instr
-  ;; A-binary.watsup:292.5-292.39
+  ;; A-binary.watsup:310.5-310.39
   prod {0xFB `%`_u32(27):Bu32} => EXTERN.CONVERT_ANY_instr
-  ;; A-binary.watsup:296.5-296.28
+  ;; A-binary.watsup:314.5-314.28
   prod {0xFB `%`_u32(28):Bu32} => REF.I31_instr
-  ;; A-binary.watsup:297.5-297.30
+  ;; A-binary.watsup:315.5-315.30
   prod {0xFB `%`_u32(29):Bu32} => I31.GET_instr(S_sx)
-  ;; A-binary.watsup:298.5-298.30
+  ;; A-binary.watsup:316.5-316.30
   prod {0xFB `%`_u32(30):Bu32} => I31.GET_instr(U_sx)
-  ;; A-binary.watsup:305.5-305.17
+  ;; A-binary.watsup:323.5-323.17
   prod 0x1A => DROP_instr
-  ;; A-binary.watsup:306.5-306.19
+  ;; A-binary.watsup:324.5-324.19
   prod 0x1B => `SELECT()%?`_instr(?())
-  ;; A-binary.watsup:307.5-307.41
+  ;; A-binary.watsup:325.5-325.41
   prod{ts : valtype} {0x1C [ts]:Blist(syntax valtype, grammar Bvaltype)} => `SELECT()%?`_instr(?([ts]))
-  ;; A-binary.watsup:314.5-314.36
+  ;; A-binary.watsup:332.5-332.36
   prod{x : idx} {0x20 x:Blocalidx} => LOCAL.GET_instr(x)
-  ;; A-binary.watsup:315.5-315.36
+  ;; A-binary.watsup:333.5-333.36
   prod{x : idx} {0x21 x:Blocalidx} => LOCAL.SET_instr(x)
-  ;; A-binary.watsup:316.5-316.36
+  ;; A-binary.watsup:334.5-334.36
   prod{x : idx} {0x22 x:Blocalidx} => LOCAL.TEE_instr(x)
-  ;; A-binary.watsup:320.5-320.38
+  ;; A-binary.watsup:338.5-338.38
   prod{x : idx} {0x23 x:Bglobalidx} => GLOBAL.GET_instr(x)
-  ;; A-binary.watsup:321.5-321.38
+  ;; A-binary.watsup:339.5-339.38
   prod{x : idx} {0x24 x:Bglobalidx} => GLOBAL.SET_instr(x)
-  ;; A-binary.watsup:328.5-328.36
+  ;; A-binary.watsup:346.5-346.36
   prod{x : idx} {0x25 x:Btableidx} => TABLE.GET_instr(x)
-  ;; A-binary.watsup:329.5-329.36
+  ;; A-binary.watsup:347.5-347.36
   prod{x : idx} {0x26 x:Btableidx} => TABLE.SET_instr(x)
-  ;; A-binary.watsup:330.5-330.58
+  ;; A-binary.watsup:348.5-348.58
   prod{y : idx, x : idx} {0xFC `%`_u32(12):Bu32 y:Belemidx x:Btableidx} => TABLE.INIT_instr(x, y)
-  ;; A-binary.watsup:331.5-331.43
+  ;; A-binary.watsup:349.5-349.43
   prod{x : idx} {0xFC `%`_u32(13):Bu32 x:Belemidx} => ELEM.DROP_instr(x)
-  ;; A-binary.watsup:332.5-332.67
+  ;; A-binary.watsup:350.5-350.67
   prod{x_1 : idx, x_2 : idx} {0xFC `%`_u32(14):Bu32 x_1:Btableidx x_2:Btableidx} => TABLE.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:333.5-333.45
+  ;; A-binary.watsup:351.5-351.45
   prod{x : idx} {0xFC `%`_u32(15):Bu32 x:Btableidx} => TABLE.GROW_instr(x)
-  ;; A-binary.watsup:334.5-334.45
+  ;; A-binary.watsup:352.5-352.45
   prod{x : idx} {0xFC `%`_u32(16):Bu32 x:Btableidx} => TABLE.SIZE_instr(x)
-  ;; A-binary.watsup:335.5-335.45
+  ;; A-binary.watsup:353.5-353.45
   prod{x : idx} {0xFC `%`_u32(17):Bu32 x:Btableidx} => TABLE.FILL_instr(x)
-  ;; A-binary.watsup:348.5-348.41
+  ;; A-binary.watsup:366.5-366.41
   prod{x : idx, ao : memarg} {0x28 (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:349.5-349.41
+  ;; A-binary.watsup:367.5-367.41
   prod{x : idx, ao : memarg} {0x29 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:350.5-350.41
+  ;; A-binary.watsup:368.5-368.41
   prod{x : idx, ao : memarg} {0x2A (x, ao):Bmemarg} => LOAD_instr(F32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:351.5-351.41
+  ;; A-binary.watsup:369.5-369.41
   prod{x : idx, ao : memarg} {0x2B (x, ao):Bmemarg} => LOAD_instr(F64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:352.5-352.48
+  ;; A-binary.watsup:370.5-370.48
   prod{x : idx, ao : memarg} {0x2C (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(8), S_sx)), x, ao)
-  ;; A-binary.watsup:353.5-353.48
+  ;; A-binary.watsup:371.5-371.48
   prod{x : idx, ao : memarg} {0x2D (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(8), U_sx)), x, ao)
-  ;; A-binary.watsup:354.5-354.49
+  ;; A-binary.watsup:372.5-372.49
   prod{x : idx, ao : memarg} {0x2E (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(16), S_sx)), x, ao)
-  ;; A-binary.watsup:355.5-355.49
+  ;; A-binary.watsup:373.5-373.49
   prod{x : idx, ao : memarg} {0x2F (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(16), U_sx)), x, ao)
-  ;; A-binary.watsup:356.5-356.48
+  ;; A-binary.watsup:374.5-374.48
   prod{x : idx, ao : memarg} {0x30 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(8), S_sx)), x, ao)
-  ;; A-binary.watsup:357.5-357.48
+  ;; A-binary.watsup:375.5-375.48
   prod{x : idx, ao : memarg} {0x31 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(8), U_sx)), x, ao)
-  ;; A-binary.watsup:358.5-358.49
+  ;; A-binary.watsup:376.5-376.49
   prod{x : idx, ao : memarg} {0x32 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(16), S_sx)), x, ao)
-  ;; A-binary.watsup:359.5-359.49
+  ;; A-binary.watsup:377.5-377.49
   prod{x : idx, ao : memarg} {0x33 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(16), U_sx)), x, ao)
-  ;; A-binary.watsup:360.5-360.49
+  ;; A-binary.watsup:378.5-378.49
   prod{x : idx, ao : memarg} {0x34 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(32), S_sx)), x, ao)
-  ;; A-binary.watsup:361.5-361.49
+  ;; A-binary.watsup:379.5-379.49
   prod{x : idx, ao : memarg} {0x35 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(32), U_sx)), x, ao)
-  ;; A-binary.watsup:362.5-362.42
+  ;; A-binary.watsup:380.5-380.42
   prod{x : idx, ao : memarg} {0x36 (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:363.5-363.42
+  ;; A-binary.watsup:381.5-381.42
   prod{x : idx, ao : memarg} {0x37 (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:364.5-364.42
+  ;; A-binary.watsup:382.5-382.42
   prod{x : idx, ao : memarg} {0x38 (x, ao):Bmemarg} => STORE_instr(F32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:365.5-365.42
+  ;; A-binary.watsup:383.5-383.42
   prod{x : idx, ao : memarg} {0x39 (x, ao):Bmemarg} => STORE_instr(F64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:366.5-366.45
+  ;; A-binary.watsup:384.5-384.45
   prod{x : idx, ao : memarg} {0x3A (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(`%`_sz(8)), x, ao)
-  ;; A-binary.watsup:367.5-367.46
+  ;; A-binary.watsup:385.5-385.46
   prod{x : idx, ao : memarg} {0x3B (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(`%`_sz(16)), x, ao)
-  ;; A-binary.watsup:368.5-368.45
+  ;; A-binary.watsup:386.5-386.45
   prod{x : idx, ao : memarg} {0x3C (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(8)), x, ao)
-  ;; A-binary.watsup:369.5-369.46
+  ;; A-binary.watsup:387.5-387.46
   prod{x : idx, ao : memarg} {0x3D (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(16)), x, ao)
-  ;; A-binary.watsup:370.5-370.46
+  ;; A-binary.watsup:388.5-388.46
   prod{x : idx, ao : memarg} {0x3E (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(32)), x, ao)
-  ;; A-binary.watsup:371.5-371.36
+  ;; A-binary.watsup:389.5-389.36
   prod{x : idx} {0x3F x:Bmemidx} => MEMORY.SIZE_instr(x)
-  ;; A-binary.watsup:372.5-372.36
+  ;; A-binary.watsup:390.5-390.36
   prod{x : idx} {0x40 x:Bmemidx} => MEMORY.GROW_instr(x)
-  ;; A-binary.watsup:373.5-373.56
+  ;; A-binary.watsup:391.5-391.56
   prod{y : idx, x : idx} {0xFC `%`_u32(8):Bu32 y:Bdataidx x:Bmemidx} => MEMORY.INIT_instr(x, y)
-  ;; A-binary.watsup:374.5-374.42
+  ;; A-binary.watsup:392.5-392.42
   prod{x : idx} {0xFC `%`_u32(9):Bu32 x:Bdataidx} => DATA.DROP_instr(x)
-  ;; A-binary.watsup:375.5-375.64
+  ;; A-binary.watsup:393.5-393.64
   prod{x_1 : idx, x_2 : idx} {0xFC `%`_u32(10):Bu32 x_1:Bmemidx x_2:Bmemidx} => MEMORY.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:376.5-376.44
+  ;; A-binary.watsup:394.5-394.44
   prod{x : idx} {0xFC `%`_u32(11):Bu32 x:Bmemidx} => MEMORY.FILL_instr(x)
-  ;; A-binary.watsup:384.5-384.31
+  ;; A-binary.watsup:402.5-402.31
   prod{n : n} {0x41 `%`_u32(n):Bu32} => CONST_instr(I32_numtype, `%`_num_(n))
-  ;; A-binary.watsup:385.5-385.31
+  ;; A-binary.watsup:403.5-403.31
   prod{n : n} {0x42 `%`_u64(n):Bu64} => CONST_instr(I64_numtype, `%`_num_(n))
-  ;; A-binary.watsup:386.5-386.31
+  ;; A-binary.watsup:404.5-404.31
   prod{p : f32} {0x43 p:Bf32} => CONST_instr(F32_numtype, p)
-  ;; A-binary.watsup:387.5-387.31
+  ;; A-binary.watsup:405.5-405.31
   prod{p : f64} {0x44 p:Bf64} => CONST_instr(F64_numtype, p)
-  ;; A-binary.watsup:391.5-391.27
+  ;; A-binary.watsup:409.5-409.27
   prod 0x45 => TESTOP_instr(I32_numtype, EQZ_testop_)
-  ;; A-binary.watsup:395.5-395.25
+  ;; A-binary.watsup:413.5-413.25
   prod 0x46 => RELOP_instr(I32_numtype, EQ_relop_)
-  ;; A-binary.watsup:396.5-396.25
+  ;; A-binary.watsup:414.5-414.25
   prod 0x47 => RELOP_instr(I32_numtype, NE_relop_)
-  ;; A-binary.watsup:397.5-397.29
+  ;; A-binary.watsup:415.5-415.29
   prod 0x48 => RELOP_instr(I32_numtype, LT_relop_(S_sx))
-  ;; A-binary.watsup:398.5-398.29
+  ;; A-binary.watsup:416.5-416.29
   prod 0x49 => RELOP_instr(I32_numtype, LT_relop_(U_sx))
-  ;; A-binary.watsup:399.5-399.29
+  ;; A-binary.watsup:417.5-417.29
   prod 0x4A => RELOP_instr(I32_numtype, GT_relop_(S_sx))
-  ;; A-binary.watsup:400.5-400.29
+  ;; A-binary.watsup:418.5-418.29
   prod 0x4B => RELOP_instr(I32_numtype, GT_relop_(U_sx))
-  ;; A-binary.watsup:401.5-401.29
+  ;; A-binary.watsup:419.5-419.29
   prod 0x4C => RELOP_instr(I32_numtype, LE_relop_(S_sx))
-  ;; A-binary.watsup:402.5-402.29
+  ;; A-binary.watsup:420.5-420.29
   prod 0x4D => RELOP_instr(I32_numtype, LE_relop_(U_sx))
-  ;; A-binary.watsup:403.5-403.29
+  ;; A-binary.watsup:421.5-421.29
   prod 0x4E => RELOP_instr(I32_numtype, GE_relop_(S_sx))
-  ;; A-binary.watsup:404.5-404.29
+  ;; A-binary.watsup:422.5-422.29
   prod 0x4F => RELOP_instr(I32_numtype, GE_relop_(U_sx))
-  ;; A-binary.watsup:408.5-408.27
+  ;; A-binary.watsup:426.5-426.27
   prod 0x50 => TESTOP_instr(I64_numtype, EQZ_testop_)
-  ;; A-binary.watsup:412.5-412.25
+  ;; A-binary.watsup:430.5-430.25
   prod 0x51 => RELOP_instr(I64_numtype, EQ_relop_)
-  ;; A-binary.watsup:413.5-413.25
+  ;; A-binary.watsup:431.5-431.25
   prod 0x52 => RELOP_instr(I64_numtype, NE_relop_)
-  ;; A-binary.watsup:414.5-414.29
+  ;; A-binary.watsup:432.5-432.29
   prod 0x53 => RELOP_instr(I64_numtype, LT_relop_(S_sx))
-  ;; A-binary.watsup:415.5-415.29
+  ;; A-binary.watsup:433.5-433.29
   prod 0x54 => RELOP_instr(I64_numtype, LT_relop_(U_sx))
-  ;; A-binary.watsup:416.5-416.29
+  ;; A-binary.watsup:434.5-434.29
   prod 0x55 => RELOP_instr(I64_numtype, GT_relop_(S_sx))
-  ;; A-binary.watsup:417.5-417.29
+  ;; A-binary.watsup:435.5-435.29
   prod 0x56 => RELOP_instr(I64_numtype, GT_relop_(U_sx))
-  ;; A-binary.watsup:418.5-418.29
+  ;; A-binary.watsup:436.5-436.29
   prod 0x57 => RELOP_instr(I64_numtype, LE_relop_(S_sx))
-  ;; A-binary.watsup:419.5-419.29
+  ;; A-binary.watsup:437.5-437.29
   prod 0x58 => RELOP_instr(I64_numtype, LE_relop_(U_sx))
-  ;; A-binary.watsup:420.5-420.29
+  ;; A-binary.watsup:438.5-438.29
   prod 0x59 => RELOP_instr(I64_numtype, GE_relop_(S_sx))
-  ;; A-binary.watsup:421.5-421.29
+  ;; A-binary.watsup:439.5-439.29
   prod 0x5A => RELOP_instr(I64_numtype, GE_relop_(U_sx))
-  ;; A-binary.watsup:425.5-425.25
+  ;; A-binary.watsup:443.5-443.25
   prod 0x5B => RELOP_instr(F32_numtype, EQ_relop_)
-  ;; A-binary.watsup:426.5-426.25
+  ;; A-binary.watsup:444.5-444.25
   prod 0x5C => RELOP_instr(F32_numtype, NE_relop_)
-  ;; A-binary.watsup:427.5-427.25
+  ;; A-binary.watsup:445.5-445.25
   prod 0x5D => RELOP_instr(F32_numtype, LT_relop_)
-  ;; A-binary.watsup:428.5-428.25
+  ;; A-binary.watsup:446.5-446.25
   prod 0x5E => RELOP_instr(F32_numtype, GT_relop_)
-  ;; A-binary.watsup:429.5-429.25
+  ;; A-binary.watsup:447.5-447.25
   prod 0x5F => RELOP_instr(F32_numtype, LE_relop_)
-  ;; A-binary.watsup:430.5-430.25
+  ;; A-binary.watsup:448.5-448.25
   prod 0x60 => RELOP_instr(F32_numtype, GE_relop_)
-  ;; A-binary.watsup:434.5-434.25
+  ;; A-binary.watsup:452.5-452.25
   prod 0x61 => RELOP_instr(F64_numtype, EQ_relop_)
-  ;; A-binary.watsup:435.5-435.25
+  ;; A-binary.watsup:453.5-453.25
   prod 0x62 => RELOP_instr(F64_numtype, NE_relop_)
-  ;; A-binary.watsup:436.5-436.25
+  ;; A-binary.watsup:454.5-454.25
   prod 0x63 => RELOP_instr(F64_numtype, LT_relop_)
-  ;; A-binary.watsup:437.5-437.25
+  ;; A-binary.watsup:455.5-455.25
   prod 0x64 => RELOP_instr(F64_numtype, GT_relop_)
-  ;; A-binary.watsup:438.5-438.25
+  ;; A-binary.watsup:456.5-456.25
   prod 0x65 => RELOP_instr(F64_numtype, LE_relop_)
-  ;; A-binary.watsup:439.5-439.25
+  ;; A-binary.watsup:457.5-457.25
   prod 0x66 => RELOP_instr(F64_numtype, GE_relop_)
-  ;; A-binary.watsup:443.5-443.25
+  ;; A-binary.watsup:461.5-461.25
   prod 0x67 => UNOP_instr(I32_numtype, CLZ_unop_)
-  ;; A-binary.watsup:444.5-444.25
+  ;; A-binary.watsup:462.5-462.25
   prod 0x68 => UNOP_instr(I32_numtype, CTZ_unop_)
-  ;; A-binary.watsup:445.5-445.28
+  ;; A-binary.watsup:463.5-463.28
   prod 0x69 => UNOP_instr(I32_numtype, POPCNT_unop_)
-  ;; A-binary.watsup:449.5-449.26
+  ;; A-binary.watsup:467.5-467.26
   prod 0x6A => BINOP_instr(I32_numtype, ADD_binop_)
-  ;; A-binary.watsup:450.5-450.26
+  ;; A-binary.watsup:468.5-468.26
   prod 0x6B => BINOP_instr(I32_numtype, SUB_binop_)
-  ;; A-binary.watsup:451.5-451.26
+  ;; A-binary.watsup:469.5-469.26
   prod 0x6C => BINOP_instr(I32_numtype, MUL_binop_)
-  ;; A-binary.watsup:452.5-452.30
+  ;; A-binary.watsup:470.5-470.30
   prod 0x6D => BINOP_instr(I32_numtype, DIV_binop_(S_sx))
-  ;; A-binary.watsup:453.5-453.30
+  ;; A-binary.watsup:471.5-471.30
   prod 0x6E => BINOP_instr(I32_numtype, DIV_binop_(U_sx))
-  ;; A-binary.watsup:454.5-454.30
+  ;; A-binary.watsup:472.5-472.30
   prod 0x6F => BINOP_instr(I32_numtype, REM_binop_(S_sx))
-  ;; A-binary.watsup:455.5-455.30
+  ;; A-binary.watsup:473.5-473.30
   prod 0x70 => BINOP_instr(I32_numtype, REM_binop_(U_sx))
-  ;; A-binary.watsup:456.5-456.26
+  ;; A-binary.watsup:474.5-474.26
   prod 0x71 => BINOP_instr(I32_numtype, AND_binop_)
-  ;; A-binary.watsup:457.5-457.25
+  ;; A-binary.watsup:475.5-475.25
   prod 0x72 => BINOP_instr(I32_numtype, OR_binop_)
-  ;; A-binary.watsup:458.5-458.26
+  ;; A-binary.watsup:476.5-476.26
   prod 0x73 => BINOP_instr(I32_numtype, XOR_binop_)
-  ;; A-binary.watsup:459.5-459.26
+  ;; A-binary.watsup:477.5-477.26
   prod 0x74 => BINOP_instr(I32_numtype, SHL_binop_)
-  ;; A-binary.watsup:460.5-460.30
+  ;; A-binary.watsup:478.5-478.30
   prod 0x75 => BINOP_instr(I32_numtype, SHR_binop_(S_sx))
-  ;; A-binary.watsup:461.5-461.30
+  ;; A-binary.watsup:479.5-479.30
   prod 0x76 => BINOP_instr(I32_numtype, SHR_binop_(U_sx))
-  ;; A-binary.watsup:462.5-462.27
+  ;; A-binary.watsup:480.5-480.27
   prod 0x77 => BINOP_instr(I32_numtype, ROTL_binop_)
-  ;; A-binary.watsup:463.5-463.27
+  ;; A-binary.watsup:481.5-481.27
   prod 0x78 => BINOP_instr(I32_numtype, ROTR_binop_)
-  ;; A-binary.watsup:467.5-467.25
+  ;; A-binary.watsup:485.5-485.25
   prod 0x79 => UNOP_instr(I64_numtype, CLZ_unop_)
-  ;; A-binary.watsup:468.5-468.25
+  ;; A-binary.watsup:486.5-486.25
   prod 0x7A => UNOP_instr(I64_numtype, CTZ_unop_)
-  ;; A-binary.watsup:469.5-469.28
+  ;; A-binary.watsup:487.5-487.28
   prod 0x7B => UNOP_instr(I64_numtype, POPCNT_unop_)
-  ;; A-binary.watsup:473.5-473.33
+  ;; A-binary.watsup:491.5-491.33
   prod 0xC0 => UNOP_instr(I32_numtype, EXTEND_unop_(`%`_sz(8)))
-  ;; A-binary.watsup:474.5-474.34
+  ;; A-binary.watsup:492.5-492.34
   prod 0xC1 => UNOP_instr(I32_numtype, EXTEND_unop_(`%`_sz(16)))
-  ;; A-binary.watsup:478.5-478.33
+  ;; A-binary.watsup:496.5-496.33
   prod 0xC2 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(8)))
-  ;; A-binary.watsup:479.5-479.34
+  ;; A-binary.watsup:497.5-497.34
   prod 0xC3 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(16)))
-  ;; A-binary.watsup:480.5-480.34
+  ;; A-binary.watsup:498.5-498.34
   prod 0xC4 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(32)))
-  ;; A-binary.watsup:484.5-484.26
+  ;; A-binary.watsup:502.5-502.26
   prod 0x7C => BINOP_instr(I64_numtype, ADD_binop_)
-  ;; A-binary.watsup:485.5-485.26
+  ;; A-binary.watsup:503.5-503.26
   prod 0x7D => BINOP_instr(I64_numtype, SUB_binop_)
-  ;; A-binary.watsup:486.5-486.26
+  ;; A-binary.watsup:504.5-504.26
   prod 0x7E => BINOP_instr(I64_numtype, MUL_binop_)
-  ;; A-binary.watsup:487.5-487.30
+  ;; A-binary.watsup:505.5-505.30
   prod 0x7F => BINOP_instr(I64_numtype, DIV_binop_(S_sx))
-  ;; A-binary.watsup:488.5-488.30
+  ;; A-binary.watsup:506.5-506.30
   prod 0x80 => BINOP_instr(I64_numtype, DIV_binop_(U_sx))
-  ;; A-binary.watsup:489.5-489.30
+  ;; A-binary.watsup:507.5-507.30
   prod 0x81 => BINOP_instr(I64_numtype, REM_binop_(S_sx))
-  ;; A-binary.watsup:490.5-490.30
+  ;; A-binary.watsup:508.5-508.30
   prod 0x82 => BINOP_instr(I64_numtype, REM_binop_(U_sx))
-  ;; A-binary.watsup:491.5-491.26
+  ;; A-binary.watsup:509.5-509.26
   prod 0x83 => BINOP_instr(I64_numtype, AND_binop_)
-  ;; A-binary.watsup:492.5-492.25
+  ;; A-binary.watsup:510.5-510.25
   prod 0x84 => BINOP_instr(I64_numtype, OR_binop_)
-  ;; A-binary.watsup:493.5-493.26
+  ;; A-binary.watsup:511.5-511.26
   prod 0x85 => BINOP_instr(I64_numtype, XOR_binop_)
-  ;; A-binary.watsup:494.5-494.26
+  ;; A-binary.watsup:512.5-512.26
   prod 0x86 => BINOP_instr(I64_numtype, SHL_binop_)
-  ;; A-binary.watsup:495.5-495.30
+  ;; A-binary.watsup:513.5-513.30
   prod 0x87 => BINOP_instr(I64_numtype, SHR_binop_(S_sx))
-  ;; A-binary.watsup:496.5-496.30
+  ;; A-binary.watsup:514.5-514.30
   prod 0x88 => BINOP_instr(I64_numtype, SHR_binop_(U_sx))
-  ;; A-binary.watsup:497.5-497.27
+  ;; A-binary.watsup:515.5-515.27
   prod 0x89 => BINOP_instr(I64_numtype, ROTL_binop_)
-  ;; A-binary.watsup:498.5-498.27
+  ;; A-binary.watsup:516.5-516.27
   prod 0x8A => BINOP_instr(I64_numtype, ROTR_binop_)
-  ;; A-binary.watsup:502.5-502.25
+  ;; A-binary.watsup:520.5-520.25
   prod 0x8B => UNOP_instr(F32_numtype, ABS_unop_)
-  ;; A-binary.watsup:503.5-503.25
+  ;; A-binary.watsup:521.5-521.25
   prod 0x8C => UNOP_instr(F32_numtype, NEG_unop_)
-  ;; A-binary.watsup:504.5-504.26
+  ;; A-binary.watsup:522.5-522.26
   prod 0x8D => UNOP_instr(F32_numtype, CEIL_unop_)
-  ;; A-binary.watsup:505.5-505.27
+  ;; A-binary.watsup:523.5-523.27
   prod 0x8E => UNOP_instr(F32_numtype, FLOOR_unop_)
-  ;; A-binary.watsup:506.5-506.27
+  ;; A-binary.watsup:524.5-524.27
   prod 0x8F => UNOP_instr(F32_numtype, TRUNC_unop_)
-  ;; A-binary.watsup:507.5-507.29
+  ;; A-binary.watsup:525.5-525.29
   prod 0x90 => UNOP_instr(F32_numtype, NEAREST_unop_)
-  ;; A-binary.watsup:508.5-508.26
+  ;; A-binary.watsup:526.5-526.26
   prod 0x91 => UNOP_instr(F32_numtype, SQRT_unop_)
-  ;; A-binary.watsup:512.5-512.26
+  ;; A-binary.watsup:530.5-530.26
   prod 0x92 => BINOP_instr(F32_numtype, ADD_binop_)
-  ;; A-binary.watsup:513.5-513.26
+  ;; A-binary.watsup:531.5-531.26
   prod 0x93 => BINOP_instr(F32_numtype, SUB_binop_)
-  ;; A-binary.watsup:514.5-514.26
+  ;; A-binary.watsup:532.5-532.26
   prod 0x94 => BINOP_instr(F32_numtype, MUL_binop_)
-  ;; A-binary.watsup:515.5-515.26
+  ;; A-binary.watsup:533.5-533.26
   prod 0x95 => BINOP_instr(F32_numtype, DIV_binop_)
-  ;; A-binary.watsup:516.5-516.26
+  ;; A-binary.watsup:534.5-534.26
   prod 0x96 => BINOP_instr(F32_numtype, MIN_binop_)
-  ;; A-binary.watsup:517.5-517.26
+  ;; A-binary.watsup:535.5-535.26
   prod 0x97 => BINOP_instr(F32_numtype, MAX_binop_)
-  ;; A-binary.watsup:518.5-518.31
+  ;; A-binary.watsup:536.5-536.31
   prod 0x98 => BINOP_instr(F32_numtype, COPYSIGN_binop_)
-  ;; A-binary.watsup:522.5-522.25
+  ;; A-binary.watsup:540.5-540.25
   prod 0x99 => UNOP_instr(F64_numtype, ABS_unop_)
-  ;; A-binary.watsup:523.5-523.25
+  ;; A-binary.watsup:541.5-541.25
   prod 0x9A => UNOP_instr(F64_numtype, NEG_unop_)
-  ;; A-binary.watsup:524.5-524.26
+  ;; A-binary.watsup:542.5-542.26
   prod 0x9B => UNOP_instr(F64_numtype, CEIL_unop_)
-  ;; A-binary.watsup:525.5-525.27
+  ;; A-binary.watsup:543.5-543.27
   prod 0x9C => UNOP_instr(F64_numtype, FLOOR_unop_)
-  ;; A-binary.watsup:526.5-526.27
+  ;; A-binary.watsup:544.5-544.27
   prod 0x9D => UNOP_instr(F64_numtype, TRUNC_unop_)
-  ;; A-binary.watsup:527.5-527.29
+  ;; A-binary.watsup:545.5-545.29
   prod 0x9E => UNOP_instr(F64_numtype, NEAREST_unop_)
-  ;; A-binary.watsup:528.5-528.26
+  ;; A-binary.watsup:546.5-546.26
   prod 0x9F => UNOP_instr(F64_numtype, SQRT_unop_)
-  ;; A-binary.watsup:532.5-532.26
+  ;; A-binary.watsup:550.5-550.26
   prod 0xA0 => BINOP_instr(F64_numtype, ADD_binop_)
-  ;; A-binary.watsup:533.5-533.26
+  ;; A-binary.watsup:551.5-551.26
   prod 0xA1 => BINOP_instr(F64_numtype, SUB_binop_)
-  ;; A-binary.watsup:534.5-534.26
+  ;; A-binary.watsup:552.5-552.26
   prod 0xA2 => BINOP_instr(F64_numtype, MUL_binop_)
-  ;; A-binary.watsup:535.5-535.26
+  ;; A-binary.watsup:553.5-553.26
   prod 0xA3 => BINOP_instr(F64_numtype, DIV_binop_)
-  ;; A-binary.watsup:536.5-536.26
+  ;; A-binary.watsup:554.5-554.26
   prod 0xA4 => BINOP_instr(F64_numtype, MIN_binop_)
-  ;; A-binary.watsup:537.5-537.26
+  ;; A-binary.watsup:555.5-555.26
   prod 0xA5 => BINOP_instr(F64_numtype, MAX_binop_)
-  ;; A-binary.watsup:538.5-538.31
+  ;; A-binary.watsup:556.5-556.31
   prod 0xA6 => BINOP_instr(F64_numtype, COPYSIGN_binop_)
-  ;; A-binary.watsup:543.5-543.31
+  ;; A-binary.watsup:561.5-561.31
   prod 0xA7 => CVTOP_instr(I32_numtype, I64_numtype, WRAP_cvtop__)
-  ;; A-binary.watsup:544.5-544.36
+  ;; A-binary.watsup:562.5-562.36
   prod 0xA8 => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:545.5-545.36
+  ;; A-binary.watsup:563.5-563.36
   prod 0xA9 => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:546.5-546.36
+  ;; A-binary.watsup:564.5-564.36
   prod 0xAA => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:547.5-547.36
+  ;; A-binary.watsup:565.5-565.36
   prod 0xAB => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:548.5-548.37
+  ;; A-binary.watsup:566.5-566.37
   prod 0xAC => CVTOP_instr(I64_numtype, I32_numtype, EXTEND_cvtop__(S_sx))
-  ;; A-binary.watsup:549.5-549.37
+  ;; A-binary.watsup:567.5-567.37
   prod 0xAD => CVTOP_instr(I64_numtype, I32_numtype, EXTEND_cvtop__(U_sx))
-  ;; A-binary.watsup:550.5-550.36
+  ;; A-binary.watsup:568.5-568.36
   prod 0xAE => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:551.5-551.36
+  ;; A-binary.watsup:569.5-569.36
   prod 0xAF => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:552.5-552.36
+  ;; A-binary.watsup:570.5-570.36
   prod 0xB0 => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:553.5-553.36
+  ;; A-binary.watsup:571.5-571.36
   prod 0xB1 => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:554.5-554.38
+  ;; A-binary.watsup:572.5-572.38
   prod 0xB2 => CVTOP_instr(F32_numtype, I32_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:555.5-555.38
+  ;; A-binary.watsup:573.5-573.38
   prod 0xB3 => CVTOP_instr(F32_numtype, I32_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:556.5-556.38
+  ;; A-binary.watsup:574.5-574.38
   prod 0xB4 => CVTOP_instr(F32_numtype, I64_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:557.5-557.38
+  ;; A-binary.watsup:575.5-575.38
   prod 0xB5 => CVTOP_instr(F32_numtype, I64_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:558.5-558.33
+  ;; A-binary.watsup:576.5-576.33
   prod 0xB6 => CVTOP_instr(F32_numtype, F64_numtype, DEMOTE_cvtop__)
-  ;; A-binary.watsup:559.5-559.38
+  ;; A-binary.watsup:577.5-577.38
   prod 0xB7 => CVTOP_instr(F64_numtype, I32_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:560.5-560.38
+  ;; A-binary.watsup:578.5-578.38
   prod 0xB8 => CVTOP_instr(F64_numtype, I32_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:561.5-561.38
+  ;; A-binary.watsup:579.5-579.38
   prod 0xB9 => CVTOP_instr(F64_numtype, I64_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:562.5-562.38
+  ;; A-binary.watsup:580.5-580.38
   prod 0xBA => CVTOP_instr(F64_numtype, I64_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:563.5-563.34
+  ;; A-binary.watsup:581.5-581.34
   prod 0xBB => CVTOP_instr(F32_numtype, F64_numtype, PROMOTE_cvtop__)
-  ;; A-binary.watsup:564.5-564.38
+  ;; A-binary.watsup:582.5-582.38
   prod 0xBC => CVTOP_instr(I32_numtype, F32_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:565.5-565.38
+  ;; A-binary.watsup:583.5-583.38
   prod 0xBD => CVTOP_instr(I64_numtype, F64_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:566.5-566.38
+  ;; A-binary.watsup:584.5-584.38
   prod 0xBE => CVTOP_instr(F32_numtype, I32_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:567.5-567.38
+  ;; A-binary.watsup:585.5-585.38
   prod 0xBF => CVTOP_instr(F64_numtype, I64_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:571.5-571.47
+  ;; A-binary.watsup:589.5-589.47
   prod {0xFC `%`_u32(0):Bu32} => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:572.5-572.47
+  ;; A-binary.watsup:590.5-590.47
   prod {0xFC `%`_u32(1):Bu32} => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:573.5-573.47
+  ;; A-binary.watsup:591.5-591.47
   prod {0xFC `%`_u32(2):Bu32} => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:574.5-574.47
+  ;; A-binary.watsup:592.5-592.47
   prod {0xFC `%`_u32(3):Bu32} => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:575.5-575.47
+  ;; A-binary.watsup:593.5-593.47
   prod {0xFC `%`_u32(4):Bu32} => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:576.5-576.47
+  ;; A-binary.watsup:594.5-594.47
   prod {0xFC `%`_u32(5):Bu32} => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:577.5-577.47
+  ;; A-binary.watsup:595.5-595.47
   prod {0xFC `%`_u32(6):Bu32} => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:578.5-578.47
+  ;; A-binary.watsup:596.5-596.47
   prod {0xFC `%`_u32(7):Bu32} => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:588.5-588.50
+  ;; A-binary.watsup:606.5-606.50
   prod{x : idx, ao : memarg} {0xFD `%`_u32(0):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(), x, ao)
-  ;; A-binary.watsup:589.5-589.68
+  ;; A-binary.watsup:607.5-607.68
   prod{x : idx, ao : memarg} {0xFD `%`_u32(1):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(8), 8, S_sx)), x, ao)
-  ;; A-binary.watsup:590.5-590.68
+  ;; A-binary.watsup:608.5-608.68
   prod{x : idx, ao : memarg} {0xFD `%`_u32(2):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(8), 8, U_sx)), x, ao)
-  ;; A-binary.watsup:591.5-591.69
+  ;; A-binary.watsup:609.5-609.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(3):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(16), 4, S_sx)), x, ao)
-  ;; A-binary.watsup:592.5-592.69
+  ;; A-binary.watsup:610.5-610.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(4):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(16), 4, U_sx)), x, ao)
-  ;; A-binary.watsup:593.5-593.69
+  ;; A-binary.watsup:611.5-611.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(5):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(32), 2, S_sx)), x, ao)
-  ;; A-binary.watsup:594.5-594.69
+  ;; A-binary.watsup:612.5-612.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(6):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(32), 2, U_sx)), x, ao)
-  ;; A-binary.watsup:595.5-595.61
+  ;; A-binary.watsup:613.5-613.61
   prod{x : idx, ao : memarg} {0xFD `%`_u32(7):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(8))), x, ao)
-  ;; A-binary.watsup:596.5-596.62
+  ;; A-binary.watsup:614.5-614.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(8):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(16))), x, ao)
-  ;; A-binary.watsup:597.5-597.62
+  ;; A-binary.watsup:615.5-615.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(9):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(32))), x, ao)
-  ;; A-binary.watsup:598.5-598.63
+  ;; A-binary.watsup:616.5-616.63
   prod{x : idx, ao : memarg} {0xFD `%`_u32(10):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(64))), x, ao)
-  ;; A-binary.watsup:599.5-599.52
+  ;; A-binary.watsup:617.5-617.52
   prod{x : idx, ao : memarg} {0xFD `%`_u32(11):Bu32 (x, ao):Bmemarg} => VSTORE_instr(V128_vectype, x, ao)
-  ;; A-binary.watsup:600.5-600.72
+  ;; A-binary.watsup:618.5-618.72
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(84):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(8), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:601.5-601.73
+  ;; A-binary.watsup:619.5-619.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(85):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(16), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:602.5-602.73
+  ;; A-binary.watsup:620.5-620.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(86):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(32), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:603.5-603.73
+  ;; A-binary.watsup:621.5-621.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(87):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(64), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:604.5-604.73
+  ;; A-binary.watsup:622.5-622.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(88):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(8), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:605.5-605.74
+  ;; A-binary.watsup:623.5-623.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(89):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(16), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:606.5-606.74
+  ;; A-binary.watsup:624.5-624.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(90):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(32), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:607.5-607.74
+  ;; A-binary.watsup:625.5-625.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(91):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(64), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:608.5-608.62
+  ;; A-binary.watsup:626.5-626.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(92):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(32))), x, ao)
-  ;; A-binary.watsup:609.5-609.62
+  ;; A-binary.watsup:627.5-627.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(93):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(64))), x, ao)
-  ;; A-binary.watsup:613.5-613.71
+  ;; A-binary.watsup:631.5-631.71
   prod{b^16 : byte^16} {0xFD `%`_u32(12):Bu32 b:Bbyte^16{b : byte}} => VCONST_instr(V128_vectype, $invibytes_(128, b^16{b : byte}))
-  ;; A-binary.watsup:617.5-617.58
+  ;; A-binary.watsup:635.5-635.58
   prod{l : labelidx} {0xFD `%`_u32(13):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx^16{}} => VSHUFFLE_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), [`%`_uN(l!`%`_labelidx.0)])
-  ;; A-binary.watsup:618.5-618.40
+  ;; A-binary.watsup:636.5-636.40
   prod {0xFD `%`_u32(14):Bu32} => VSWIZZLE_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)))
-  ;; A-binary.watsup:622.5-622.38
+  ;; A-binary.watsup:640.5-640.38
   prod {0xFD `%`_u32(15):Bu32} => VSPLAT_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)))
-  ;; A-binary.watsup:623.5-623.38
+  ;; A-binary.watsup:641.5-641.38
   prod {0xFD `%`_u32(16):Bu32} => VSPLAT_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)))
-  ;; A-binary.watsup:624.5-624.38
+  ;; A-binary.watsup:642.5-642.38
   prod {0xFD `%`_u32(17):Bu32} => VSPLAT_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)))
-  ;; A-binary.watsup:625.5-625.38
+  ;; A-binary.watsup:643.5-643.38
   prod {0xFD `%`_u32(18):Bu32} => VSPLAT_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)))
-  ;; A-binary.watsup:626.5-626.38
+  ;; A-binary.watsup:644.5-644.38
   prod {0xFD `%`_u32(19):Bu32} => VSPLAT_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)))
-  ;; A-binary.watsup:627.5-627.38
+  ;; A-binary.watsup:645.5-645.38
   prod {0xFD `%`_u32(20):Bu32} => VSPLAT_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)))
-  ;; A-binary.watsup:631.5-631.60
+  ;; A-binary.watsup:649.5-649.60
   prod{l : labelidx} {0xFD `%`_u32(21):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ?(S_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:632.5-632.60
+  ;; A-binary.watsup:650.5-650.60
   prod{l : labelidx} {0xFD `%`_u32(22):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ?(U_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:633.5-633.58
+  ;; A-binary.watsup:651.5-651.58
   prod{l : labelidx} {0xFD `%`_u32(23):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:634.5-634.60
+  ;; A-binary.watsup:652.5-652.60
   prod{l : labelidx} {0xFD `%`_u32(24):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ?(S_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:635.5-635.60
+  ;; A-binary.watsup:653.5-653.60
   prod{l : labelidx} {0xFD `%`_u32(25):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ?(U_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:636.5-636.58
+  ;; A-binary.watsup:654.5-654.58
   prod{l : labelidx} {0xFD `%`_u32(26):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:637.5-637.58
+  ;; A-binary.watsup:655.5-655.58
   prod{l : labelidx} {0xFD `%`_u32(27):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:638.5-638.58
+  ;; A-binary.watsup:656.5-656.58
   prod{l : labelidx} {0xFD `%`_u32(28):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:639.5-639.58
+  ;; A-binary.watsup:657.5-657.58
   prod{l : labelidx} {0xFD `%`_u32(29):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:640.5-640.58
+  ;; A-binary.watsup:658.5-658.58
   prod{l : labelidx} {0xFD `%`_u32(30):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:641.5-641.58
+  ;; A-binary.watsup:659.5-659.58
   prod{l : labelidx} {0xFD `%`_u32(31):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:642.5-642.58
+  ;; A-binary.watsup:660.5-660.58
   prod{l : labelidx} {0xFD `%`_u32(32):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:643.5-643.58
+  ;; A-binary.watsup:661.5-661.58
   prod{l : labelidx} {0xFD `%`_u32(33):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:644.5-644.58
+  ;; A-binary.watsup:662.5-662.58
   prod{l : labelidx} {0xFD `%`_u32(34):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:648.5-648.41
+  ;; A-binary.watsup:666.5-666.41
   prod {0xFD `%`_u32(35):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), EQ_vrelop_)
-  ;; A-binary.watsup:649.5-649.41
+  ;; A-binary.watsup:667.5-667.41
   prod {0xFD `%`_u32(36):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), NE_vrelop_)
-  ;; A-binary.watsup:650.5-650.45
+  ;; A-binary.watsup:668.5-668.45
   prod {0xFD `%`_u32(37):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:651.5-651.45
+  ;; A-binary.watsup:669.5-669.45
   prod {0xFD `%`_u32(38):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:652.5-652.45
+  ;; A-binary.watsup:670.5-670.45
   prod {0xFD `%`_u32(39):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:653.5-653.45
+  ;; A-binary.watsup:671.5-671.45
   prod {0xFD `%`_u32(40):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:654.5-654.45
+  ;; A-binary.watsup:672.5-672.45
   prod {0xFD `%`_u32(41):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:655.5-655.45
+  ;; A-binary.watsup:673.5-673.45
   prod {0xFD `%`_u32(42):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:656.5-656.45
+  ;; A-binary.watsup:674.5-674.45
   prod {0xFD `%`_u32(43):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:657.5-657.45
+  ;; A-binary.watsup:675.5-675.45
   prod {0xFD `%`_u32(44):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:661.5-661.41
+  ;; A-binary.watsup:679.5-679.41
   prod {0xFD `%`_u32(45):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), EQ_vrelop_)
-  ;; A-binary.watsup:662.5-662.41
+  ;; A-binary.watsup:680.5-680.41
   prod {0xFD `%`_u32(46):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), NE_vrelop_)
-  ;; A-binary.watsup:663.5-663.45
+  ;; A-binary.watsup:681.5-681.45
   prod {0xFD `%`_u32(47):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:664.5-664.45
+  ;; A-binary.watsup:682.5-682.45
   prod {0xFD `%`_u32(48):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:665.5-665.45
+  ;; A-binary.watsup:683.5-683.45
   prod {0xFD `%`_u32(49):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:666.5-666.45
+  ;; A-binary.watsup:684.5-684.45
   prod {0xFD `%`_u32(50):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:667.5-667.45
+  ;; A-binary.watsup:685.5-685.45
   prod {0xFD `%`_u32(51):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:668.5-668.45
+  ;; A-binary.watsup:686.5-686.45
   prod {0xFD `%`_u32(52):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:669.5-669.45
+  ;; A-binary.watsup:687.5-687.45
   prod {0xFD `%`_u32(53):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:670.5-670.45
+  ;; A-binary.watsup:688.5-688.45
   prod {0xFD `%`_u32(54):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:674.5-674.41
+  ;; A-binary.watsup:692.5-692.41
   prod {0xFD `%`_u32(55):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), EQ_vrelop_)
-  ;; A-binary.watsup:675.5-675.41
+  ;; A-binary.watsup:693.5-693.41
   prod {0xFD `%`_u32(56):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), NE_vrelop_)
-  ;; A-binary.watsup:676.5-676.45
+  ;; A-binary.watsup:694.5-694.45
   prod {0xFD `%`_u32(57):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:677.5-677.45
+  ;; A-binary.watsup:695.5-695.45
   prod {0xFD `%`_u32(58):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:678.5-678.45
+  ;; A-binary.watsup:696.5-696.45
   prod {0xFD `%`_u32(59):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:679.5-679.45
+  ;; A-binary.watsup:697.5-697.45
   prod {0xFD `%`_u32(60):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:680.5-680.45
+  ;; A-binary.watsup:698.5-698.45
   prod {0xFD `%`_u32(61):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:681.5-681.45
+  ;; A-binary.watsup:699.5-699.45
   prod {0xFD `%`_u32(62):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:682.5-682.45
+  ;; A-binary.watsup:700.5-700.45
   prod {0xFD `%`_u32(63):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:683.5-683.45
+  ;; A-binary.watsup:701.5-701.45
   prod {0xFD `%`_u32(64):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:687.5-687.41
+  ;; A-binary.watsup:705.5-705.41
   prod {0xFD `%`_u32(65):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), EQ_vrelop_)
-  ;; A-binary.watsup:688.5-688.41
+  ;; A-binary.watsup:706.5-706.41
   prod {0xFD `%`_u32(66):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NE_vrelop_)
-  ;; A-binary.watsup:689.5-689.41
+  ;; A-binary.watsup:707.5-707.41
   prod {0xFD `%`_u32(67):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), LT_vrelop_)
-  ;; A-binary.watsup:690.5-690.41
+  ;; A-binary.watsup:708.5-708.41
   prod {0xFD `%`_u32(68):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), GT_vrelop_)
-  ;; A-binary.watsup:691.5-691.41
+  ;; A-binary.watsup:709.5-709.41
   prod {0xFD `%`_u32(69):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), LE_vrelop_)
-  ;; A-binary.watsup:692.5-692.41
+  ;; A-binary.watsup:710.5-710.41
   prod {0xFD `%`_u32(70):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), GE_vrelop_)
-  ;; A-binary.watsup:696.5-696.41
+  ;; A-binary.watsup:714.5-714.41
   prod {0xFD `%`_u32(71):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), EQ_vrelop_)
-  ;; A-binary.watsup:697.5-697.41
+  ;; A-binary.watsup:715.5-715.41
   prod {0xFD `%`_u32(72):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NE_vrelop_)
-  ;; A-binary.watsup:698.5-698.41
+  ;; A-binary.watsup:716.5-716.41
   prod {0xFD `%`_u32(73):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), LT_vrelop_)
-  ;; A-binary.watsup:699.5-699.41
+  ;; A-binary.watsup:717.5-717.41
   prod {0xFD `%`_u32(74):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), GT_vrelop_)
-  ;; A-binary.watsup:700.5-700.41
+  ;; A-binary.watsup:718.5-718.41
   prod {0xFD `%`_u32(75):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), LE_vrelop_)
-  ;; A-binary.watsup:701.5-701.41
+  ;; A-binary.watsup:719.5-719.41
   prod {0xFD `%`_u32(76):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), GE_vrelop_)
-  ;; A-binary.watsup:705.5-705.36
+  ;; A-binary.watsup:723.5-723.36
   prod {0xFD `%`_u32(77):Bu32} => VVUNOP_instr(V128_vectype, NOT_vvunop)
-  ;; A-binary.watsup:709.5-709.37
+  ;; A-binary.watsup:727.5-727.37
   prod {0xFD `%`_u32(78):Bu32} => VVBINOP_instr(V128_vectype, AND_vvbinop)
-  ;; A-binary.watsup:710.5-710.40
+  ;; A-binary.watsup:728.5-728.40
   prod {0xFD `%`_u32(79):Bu32} => VVBINOP_instr(V128_vectype, ANDNOT_vvbinop)
-  ;; A-binary.watsup:711.5-711.36
+  ;; A-binary.watsup:729.5-729.36
   prod {0xFD `%`_u32(80):Bu32} => VVBINOP_instr(V128_vectype, OR_vvbinop)
-  ;; A-binary.watsup:712.5-712.37
+  ;; A-binary.watsup:730.5-730.37
   prod {0xFD `%`_u32(81):Bu32} => VVBINOP_instr(V128_vectype, XOR_vvbinop)
-  ;; A-binary.watsup:716.5-716.44
+  ;; A-binary.watsup:734.5-734.44
   prod {0xFD `%`_u32(82):Bu32} => VVTERNOP_instr(V128_vectype, BITSELECT_vvternop)
-  ;; A-binary.watsup:720.5-720.43
+  ;; A-binary.watsup:738.5-738.43
   prod {0xFD `%`_u32(83):Bu32} => VVTESTOP_instr(V128_vectype, ANY_TRUE_vvtestop)
-  ;; A-binary.watsup:724.5-724.41
+  ;; A-binary.watsup:742.5-742.41
   prod {0xFD `%`_u32(96):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ABS_vunop_)
-  ;; A-binary.watsup:725.5-725.41
+  ;; A-binary.watsup:743.5-743.41
   prod {0xFD `%`_u32(97):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), NEG_vunop_)
-  ;; A-binary.watsup:726.5-726.44
+  ;; A-binary.watsup:744.5-744.44
   prod {0xFD `%`_u32(98):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), POPCNT_vunop_)
-  ;; A-binary.watsup:730.5-730.48
+  ;; A-binary.watsup:748.5-748.48
   prod {0xFD `%`_u32(99):Bu32} => VTESTOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:734.5-734.41
+  ;; A-binary.watsup:752.5-752.41
   prod {0xFD `%`_u32(100):Bu32} => VBITMASK_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)))
-  ;; A-binary.watsup:738.5-738.53
+  ;; A-binary.watsup:756.5-756.53
   prod {0xFD `%`_u32(101):Bu32} => VNARROW_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), S_sx)
-  ;; A-binary.watsup:739.5-739.53
+  ;; A-binary.watsup:757.5-757.53
   prod {0xFD `%`_u32(102):Bu32} => VNARROW_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), U_sx)
-  ;; A-binary.watsup:743.5-743.45
+  ;; A-binary.watsup:761.5-761.45
   prod {0xFD `%`_u32(107):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHL_vshiftop_)
-  ;; A-binary.watsup:744.5-744.49
+  ;; A-binary.watsup:762.5-762.49
   prod {0xFD `%`_u32(108):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:745.5-745.49
+  ;; A-binary.watsup:763.5-763.49
   prod {0xFD `%`_u32(109):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:749.5-749.43
+  ;; A-binary.watsup:767.5-767.43
   prod {0xFD `%`_u32(110):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_vbinop_)
-  ;; A-binary.watsup:750.5-750.51
+  ;; A-binary.watsup:768.5-768.51
   prod {0xFD `%`_u32(111):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:751.5-751.51
+  ;; A-binary.watsup:769.5-769.51
   prod {0xFD `%`_u32(112):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:752.5-752.43
+  ;; A-binary.watsup:770.5-770.43
   prod {0xFD `%`_u32(113):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_vbinop_)
-  ;; A-binary.watsup:753.5-753.51
+  ;; A-binary.watsup:771.5-771.51
   prod {0xFD `%`_u32(114):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:754.5-754.51
+  ;; A-binary.watsup:772.5-772.51
   prod {0xFD `%`_u32(115):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:755.5-755.47
+  ;; A-binary.watsup:773.5-773.47
   prod {0xFD `%`_u32(118):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:756.5-756.47
+  ;; A-binary.watsup:774.5-774.47
   prod {0xFD `%`_u32(119):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:757.5-757.47
+  ;; A-binary.watsup:775.5-775.47
   prod {0xFD `%`_u32(120):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:758.5-758.47
+  ;; A-binary.watsup:776.5-776.47
   prod {0xFD `%`_u32(121):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:759.5-759.48
+  ;; A-binary.watsup:777.5-777.48
   prod {0xFD `%`_u32(123):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), `AVGRU`_vbinop_)
-  ;; A-binary.watsup:763.5-763.72
+  ;; A-binary.watsup:781.5-781.72
   prod {0xFD `%`_u32(124):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTADD_PAIRWISE_vextunop__(S_sx))
-  ;; A-binary.watsup:764.5-764.72
+  ;; A-binary.watsup:782.5-782.72
   prod {0xFD `%`_u32(125):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTADD_PAIRWISE_vextunop__(U_sx))
-  ;; A-binary.watsup:768.5-768.42
+  ;; A-binary.watsup:786.5-786.42
   prod {0xFD `%`_u32(128):Bu32} => VUNOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ABS_vunop_)
-  ;; A-binary.watsup:769.5-769.42
+  ;; A-binary.watsup:787.5-787.42
   prod {0xFD `%`_u32(129):Bu32} => VUNOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), NEG_vunop_)
-  ;; A-binary.watsup:773.5-773.55
+  ;; A-binary.watsup:791.5-791.55
   prod {0xFD `%`_u32(130):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `Q15MULR_SATS`_vbinop_)
-  ;; A-binary.watsup:777.5-777.49
+  ;; A-binary.watsup:795.5-795.49
   prod {0xFD `%`_u32(131):Bu32} => VTESTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:781.5-781.41
+  ;; A-binary.watsup:799.5-799.41
   prod {0xFD `%`_u32(132):Bu32} => VBITMASK_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)))
-  ;; A-binary.watsup:785.5-785.53
+  ;; A-binary.watsup:803.5-803.53
   prod {0xFD `%`_u32(133):Bu32} => VNARROW_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), S_sx)
-  ;; A-binary.watsup:786.5-786.53
+  ;; A-binary.watsup:804.5-804.53
   prod {0xFD `%`_u32(134):Bu32} => VNARROW_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), U_sx)
-  ;; A-binary.watsup:790.5-790.65
+  ;; A-binary.watsup:808.5-808.65
   prod {0xFD `%`_u32(135):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:791.5-791.66
+  ;; A-binary.watsup:809.5-809.66
   prod {0xFD `%`_u32(136):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:792.5-792.65
+  ;; A-binary.watsup:810.5-810.65
   prod {0xFD `%`_u32(137):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:793.5-793.66
+  ;; A-binary.watsup:811.5-811.66
   prod {0xFD `%`_u32(138):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:797.5-797.45
+  ;; A-binary.watsup:815.5-815.45
   prod {0xFD `%`_u32(139):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHL_vshiftop_)
-  ;; A-binary.watsup:798.5-798.49
+  ;; A-binary.watsup:816.5-816.49
   prod {0xFD `%`_u32(140):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:799.5-799.49
+  ;; A-binary.watsup:817.5-817.49
   prod {0xFD `%`_u32(141):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:803.5-803.43
+  ;; A-binary.watsup:821.5-821.43
   prod {0xFD `%`_u32(142):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_vbinop_)
-  ;; A-binary.watsup:804.5-804.51
+  ;; A-binary.watsup:822.5-822.51
   prod {0xFD `%`_u32(143):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:805.5-805.51
+  ;; A-binary.watsup:823.5-823.51
   prod {0xFD `%`_u32(144):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:806.5-806.43
+  ;; A-binary.watsup:824.5-824.43
   prod {0xFD `%`_u32(145):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_vbinop_)
-  ;; A-binary.watsup:807.5-807.51
+  ;; A-binary.watsup:825.5-825.51
   prod {0xFD `%`_u32(146):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:808.5-808.51
+  ;; A-binary.watsup:826.5-826.51
   prod {0xFD `%`_u32(147):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:809.5-809.43
+  ;; A-binary.watsup:827.5-827.43
   prod {0xFD `%`_u32(149):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MUL_vbinop_)
-  ;; A-binary.watsup:810.5-810.47
+  ;; A-binary.watsup:828.5-828.47
   prod {0xFD `%`_u32(150):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:811.5-811.47
+  ;; A-binary.watsup:829.5-829.47
   prod {0xFD `%`_u32(151):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:812.5-812.47
+  ;; A-binary.watsup:830.5-830.47
   prod {0xFD `%`_u32(152):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:813.5-813.47
+  ;; A-binary.watsup:831.5-831.47
   prod {0xFD `%`_u32(153):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:814.5-814.48
+  ;; A-binary.watsup:832.5-832.48
   prod {0xFD `%`_u32(155):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `AVGRU`_vbinop_)
-  ;; A-binary.watsup:818.5-818.68
+  ;; A-binary.watsup:836.5-836.68
   prod {0xFD `%`_u32(156):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:819.5-819.69
+  ;; A-binary.watsup:837.5-837.69
   prod {0xFD `%`_u32(157):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:820.5-820.68
+  ;; A-binary.watsup:838.5-838.68
   prod {0xFD `%`_u32(158):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:821.5-821.69
+  ;; A-binary.watsup:839.5-839.69
   prod {0xFD `%`_u32(159):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:825.5-825.72
+  ;; A-binary.watsup:843.5-843.72
   prod {0xFD `%`_u32(126):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTADD_PAIRWISE_vextunop__(S_sx))
-  ;; A-binary.watsup:826.5-826.72
+  ;; A-binary.watsup:844.5-844.72
   prod {0xFD `%`_u32(127):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTADD_PAIRWISE_vextunop__(U_sx))
-  ;; A-binary.watsup:830.5-830.42
+  ;; A-binary.watsup:848.5-848.42
   prod {0xFD `%`_u32(160):Bu32} => VUNOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ABS_vunop_)
-  ;; A-binary.watsup:831.5-831.42
+  ;; A-binary.watsup:849.5-849.42
   prod {0xFD `%`_u32(161):Bu32} => VUNOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), NEG_vunop_)
-  ;; A-binary.watsup:835.5-835.49
+  ;; A-binary.watsup:853.5-853.49
   prod {0xFD `%`_u32(163):Bu32} => VTESTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:839.5-839.41
+  ;; A-binary.watsup:857.5-857.41
   prod {0xFD `%`_u32(164):Bu32} => VBITMASK_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)))
-  ;; A-binary.watsup:843.5-843.65
+  ;; A-binary.watsup:861.5-861.65
   prod {0xFD `%`_u32(167):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:844.5-844.66
+  ;; A-binary.watsup:862.5-862.66
   prod {0xFD `%`_u32(168):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:845.5-845.65
+  ;; A-binary.watsup:863.5-863.65
   prod {0xFD `%`_u32(169):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:846.5-846.66
+  ;; A-binary.watsup:864.5-864.66
   prod {0xFD `%`_u32(170):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:850.5-850.45
+  ;; A-binary.watsup:868.5-868.45
   prod {0xFD `%`_u32(171):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHL_vshiftop_)
-  ;; A-binary.watsup:851.5-851.49
+  ;; A-binary.watsup:869.5-869.49
   prod {0xFD `%`_u32(172):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:852.5-852.49
+  ;; A-binary.watsup:870.5-870.49
   prod {0xFD `%`_u32(173):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:856.5-856.43
+  ;; A-binary.watsup:874.5-874.43
   prod {0xFD `%`_u32(174):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ADD_vbinop_)
-  ;; A-binary.watsup:857.5-857.43
+  ;; A-binary.watsup:875.5-875.43
   prod {0xFD `%`_u32(177):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), SUB_vbinop_)
-  ;; A-binary.watsup:858.5-858.43
+  ;; A-binary.watsup:876.5-876.43
   prod {0xFD `%`_u32(181):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MUL_vbinop_)
-  ;; A-binary.watsup:859.5-859.47
+  ;; A-binary.watsup:877.5-877.47
   prod {0xFD `%`_u32(182):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:860.5-860.47
+  ;; A-binary.watsup:878.5-878.47
   prod {0xFD `%`_u32(183):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:861.5-861.47
+  ;; A-binary.watsup:879.5-879.47
   prod {0xFD `%`_u32(184):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:862.5-862.47
+  ;; A-binary.watsup:880.5-880.47
   prod {0xFD `%`_u32(185):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:866.5-866.61
+  ;; A-binary.watsup:884.5-884.61
   prod {0xFD `%`_u32(186):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), `DOTS`_vextbinop__)
-  ;; A-binary.watsup:867.5-867.68
+  ;; A-binary.watsup:885.5-885.68
   prod {0xFD `%`_u32(188):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:868.5-868.69
+  ;; A-binary.watsup:886.5-886.69
   prod {0xFD `%`_u32(189):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:869.5-869.68
+  ;; A-binary.watsup:887.5-887.68
   prod {0xFD `%`_u32(190):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:870.5-870.69
+  ;; A-binary.watsup:888.5-888.69
   prod {0xFD `%`_u32(191):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:874.5-874.42
+  ;; A-binary.watsup:892.5-892.42
   prod {0xFD `%`_u32(192):Bu32} => VUNOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ABS_vunop_)
-  ;; A-binary.watsup:875.5-875.42
+  ;; A-binary.watsup:893.5-893.42
   prod {0xFD `%`_u32(193):Bu32} => VUNOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), NEG_vunop_)
-  ;; A-binary.watsup:879.5-879.49
+  ;; A-binary.watsup:897.5-897.49
   prod {0xFD `%`_u32(195):Bu32} => VTESTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:883.5-883.41
+  ;; A-binary.watsup:901.5-901.41
   prod {0xFD `%`_u32(196):Bu32} => VBITMASK_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)))
-  ;; A-binary.watsup:887.5-887.65
+  ;; A-binary.watsup:905.5-905.65
   prod {0xFD `%`_u32(199):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:888.5-888.66
+  ;; A-binary.watsup:906.5-906.66
   prod {0xFD `%`_u32(200):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:889.5-889.65
+  ;; A-binary.watsup:907.5-907.65
   prod {0xFD `%`_u32(201):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:890.5-890.66
+  ;; A-binary.watsup:908.5-908.66
   prod {0xFD `%`_u32(202):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:894.5-894.45
+  ;; A-binary.watsup:912.5-912.45
   prod {0xFD `%`_u32(203):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHL_vshiftop_)
-  ;; A-binary.watsup:895.5-895.49
+  ;; A-binary.watsup:913.5-913.49
   prod {0xFD `%`_u32(204):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:896.5-896.49
+  ;; A-binary.watsup:914.5-914.49
   prod {0xFD `%`_u32(205):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:900.5-900.43
+  ;; A-binary.watsup:918.5-918.43
   prod {0xFD `%`_u32(206):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ADD_vbinop_)
-  ;; A-binary.watsup:901.5-901.43
+  ;; A-binary.watsup:919.5-919.43
   prod {0xFD `%`_u32(209):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), SUB_vbinop_)
-  ;; A-binary.watsup:902.5-902.43
+  ;; A-binary.watsup:920.5-920.43
   prod {0xFD `%`_u32(213):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), MUL_vbinop_)
-  ;; A-binary.watsup:906.5-906.42
+  ;; A-binary.watsup:924.5-924.42
   prod {0xFD `%`_u32(214):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), EQ_vrelop_)
-  ;; A-binary.watsup:907.5-907.42
+  ;; A-binary.watsup:925.5-925.42
   prod {0xFD `%`_u32(215):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), NE_vrelop_)
-  ;; A-binary.watsup:908.5-908.46
+  ;; A-binary.watsup:926.5-926.46
   prod {0xFD `%`_u32(216):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:909.5-909.46
+  ;; A-binary.watsup:927.5-927.46
   prod {0xFD `%`_u32(217):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:910.5-910.46
+  ;; A-binary.watsup:928.5-928.46
   prod {0xFD `%`_u32(218):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:911.5-911.46
+  ;; A-binary.watsup:929.5-929.46
   prod {0xFD `%`_u32(219):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:915.5-915.68
+  ;; A-binary.watsup:933.5-933.68
   prod {0xFD `%`_u32(220):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:916.5-916.69
+  ;; A-binary.watsup:934.5-934.69
   prod {0xFD `%`_u32(221):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:917.5-917.68
+  ;; A-binary.watsup:935.5-935.68
   prod {0xFD `%`_u32(222):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:918.5-918.69
+  ;; A-binary.watsup:936.5-936.69
   prod {0xFD `%`_u32(223):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:922.5-922.43
+  ;; A-binary.watsup:940.5-940.43
   prod {0xFD `%`_u32(103):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), CEIL_vunop_)
-  ;; A-binary.watsup:923.5-923.44
+  ;; A-binary.watsup:941.5-941.44
   prod {0xFD `%`_u32(104):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), FLOOR_vunop_)
-  ;; A-binary.watsup:924.5-924.44
+  ;; A-binary.watsup:942.5-942.44
   prod {0xFD `%`_u32(105):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_vunop_)
-  ;; A-binary.watsup:925.5-925.46
+  ;; A-binary.watsup:943.5-943.46
   prod {0xFD `%`_u32(106):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NEAREST_vunop_)
-  ;; A-binary.watsup:926.5-926.42
+  ;; A-binary.watsup:944.5-944.42
   prod {0xFD `%`_u32(224):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ABS_vunop_)
-  ;; A-binary.watsup:927.5-927.42
+  ;; A-binary.watsup:945.5-945.42
   prod {0xFD `%`_u32(225):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NEG_vunop_)
-  ;; A-binary.watsup:928.5-928.43
+  ;; A-binary.watsup:946.5-946.43
   prod {0xFD `%`_u32(227):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), SQRT_vunop_)
-  ;; A-binary.watsup:932.5-932.43
+  ;; A-binary.watsup:950.5-950.43
   prod {0xFD `%`_u32(228):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ADD_vbinop_)
-  ;; A-binary.watsup:933.5-933.43
+  ;; A-binary.watsup:951.5-951.43
   prod {0xFD `%`_u32(229):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), SUB_vbinop_)
-  ;; A-binary.watsup:934.5-934.43
+  ;; A-binary.watsup:952.5-952.43
   prod {0xFD `%`_u32(230):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MUL_vbinop_)
-  ;; A-binary.watsup:935.5-935.43
+  ;; A-binary.watsup:953.5-953.43
   prod {0xFD `%`_u32(231):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), DIV_vbinop_)
-  ;; A-binary.watsup:936.5-936.43
+  ;; A-binary.watsup:954.5-954.43
   prod {0xFD `%`_u32(232):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MIN_vbinop_)
-  ;; A-binary.watsup:937.5-937.43
+  ;; A-binary.watsup:955.5-955.43
   prod {0xFD `%`_u32(233):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MAX_vbinop_)
-  ;; A-binary.watsup:938.5-938.44
+  ;; A-binary.watsup:956.5-956.44
   prod {0xFD `%`_u32(234):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), PMIN_vbinop_)
-  ;; A-binary.watsup:939.5-939.44
+  ;; A-binary.watsup:957.5-957.44
   prod {0xFD `%`_u32(235):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), PMAX_vbinop_)
-  ;; A-binary.watsup:943.5-943.43
+  ;; A-binary.watsup:961.5-961.43
   prod {0xFD `%`_u32(116):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), CEIL_vunop_)
-  ;; A-binary.watsup:944.5-944.44
+  ;; A-binary.watsup:962.5-962.44
   prod {0xFD `%`_u32(117):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), FLOOR_vunop_)
-  ;; A-binary.watsup:945.5-945.44
+  ;; A-binary.watsup:963.5-963.44
   prod {0xFD `%`_u32(122):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_vunop_)
-  ;; A-binary.watsup:946.5-946.46
+  ;; A-binary.watsup:964.5-964.46
   prod {0xFD `%`_u32(148):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NEAREST_vunop_)
-  ;; A-binary.watsup:947.5-947.42
+  ;; A-binary.watsup:965.5-965.42
   prod {0xFD `%`_u32(236):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ABS_vunop_)
-  ;; A-binary.watsup:948.5-948.42
+  ;; A-binary.watsup:966.5-966.42
   prod {0xFD `%`_u32(237):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NEG_vunop_)
-  ;; A-binary.watsup:949.5-949.43
+  ;; A-binary.watsup:967.5-967.43
   prod {0xFD `%`_u32(239):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), SQRT_vunop_)
-  ;; A-binary.watsup:953.5-953.43
+  ;; A-binary.watsup:971.5-971.43
   prod {0xFD `%`_u32(240):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ADD_vbinop_)
-  ;; A-binary.watsup:954.5-954.43
+  ;; A-binary.watsup:972.5-972.43
   prod {0xFD `%`_u32(241):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), SUB_vbinop_)
-  ;; A-binary.watsup:955.5-955.43
+  ;; A-binary.watsup:973.5-973.43
   prod {0xFD `%`_u32(242):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MUL_vbinop_)
-  ;; A-binary.watsup:956.5-956.43
+  ;; A-binary.watsup:974.5-974.43
   prod {0xFD `%`_u32(243):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), DIV_vbinop_)
-  ;; A-binary.watsup:957.5-957.43
+  ;; A-binary.watsup:975.5-975.43
   prod {0xFD `%`_u32(244):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MIN_vbinop_)
-  ;; A-binary.watsup:958.5-958.43
+  ;; A-binary.watsup:976.5-976.43
   prod {0xFD `%`_u32(245):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MAX_vbinop_)
-  ;; A-binary.watsup:959.5-959.44
+  ;; A-binary.watsup:977.5-977.44
   prod {0xFD `%`_u32(246):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), PMIN_vbinop_)
-  ;; A-binary.watsup:960.5-960.44
+  ;; A-binary.watsup:978.5-978.44
   prod {0xFD `%`_u32(247):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), PMAX_vbinop_)
-  ;; A-binary.watsup:964.5-964.61
+  ;; A-binary.watsup:982.5-982.61
   prod {0xFD `%`_u32(94):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), DEMOTE_vcvtop__, ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:965.5-965.61
+  ;; A-binary.watsup:983.5-983.61
   prod {0xFD `%`_u32(95):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(F32_lanetype, `%`_dim(4)), PROMOTE_vcvtop__, ?(LOW_half__), ?())
-  ;; A-binary.watsup:966.5-966.64
+  ;; A-binary.watsup:984.5-984.64
   prod {0xFD `%`_u32(248):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_SAT_vcvtop__(S_sx), ?(), ?())
-  ;; A-binary.watsup:967.5-967.64
+  ;; A-binary.watsup:985.5-985.64
   prod {0xFD `%`_u32(249):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_SAT_vcvtop__(U_sx), ?(), ?())
-  ;; A-binary.watsup:968.5-968.62
+  ;; A-binary.watsup:986.5-986.62
   prod {0xFD `%`_u32(250):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(S_sx), ?(), ?())
-  ;; A-binary.watsup:969.5-969.62
+  ;; A-binary.watsup:987.5-987.62
   prod {0xFD `%`_u32(251):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(U_sx), ?(), ?())
-  ;; A-binary.watsup:970.5-970.69
+  ;; A-binary.watsup:988.5-988.69
   prod {0xFD `%`_u32(252):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_SAT_vcvtop__(S_sx), ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:971.5-971.69
+  ;; A-binary.watsup:989.5-989.69
   prod {0xFD `%`_u32(253):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_SAT_vcvtop__(U_sx), ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:972.5-972.66
+  ;; A-binary.watsup:990.5-990.66
   prod {0xFD `%`_u32(254):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:973.5-973.66
+  ;; A-binary.watsup:991.5-991.66
   prod {0xFD `%`_u32(255):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(U_sx), ?(LOW_half__), ?())
 }
 
@@ -15884,6 +16594,16 @@ grammar Bdatacntsec : u32?
   ;; A-binary.watsup
   prod{nopt : nopt} nopt:Bsection_(12, syntax u32, grammar Bdatacnt) => $opt_(syntax u32, nopt)
 
+;; A-binary.watsup
+grammar Btag : tag
+  ;; A-binary.watsup
+  prod{x : idx} x:Btypeidx => TAG_tag(x)
+
+;; A-binary.watsup
+grammar Btagsec : tag*
+  ;; A-binary.watsup
+  prod{tag* : tag*} tag*{tag : tag}:Bsection_(13, syntax tag, grammar Blist(syntax tag, grammar Btag)) => tag*{tag : tag}
+
 ;; A-binary.watsup
 grammar Bmagic : ()
   ;; A-binary.watsup
@@ -15897,7 +16617,7 @@ grammar Bversion : ()
 ;; A-binary.watsup
 grammar Bmodule : module
   ;; A-binary.watsup
-  prod{type* : type*, import* : import*, typeidx* : typeidx*, table* : table*, mem* : mem*, global* : global*, export* : export*, start? : start?, elem* : elem*, n? : n?, local** : local**, expr* : expr*, data* : data*, func* : func*} {Bmagic Bversion Bcustomsec*{} type*{type : type}:Btypesec Bcustomsec*{} import*{import : import}:Bimportsec Bcustomsec*{} typeidx*{typeidx : typeidx}:Bfuncsec Bcustomsec*{} table*{table : table}:Btablesec Bcustomsec*{} mem*{mem : mem}:Bmemsec Bcustomsec*{} global*{global : global}:Bglobalsec Bcustomsec*{} export*{export : export}:Bexportsec Bcustomsec*{} start?{start : start}:Bstartsec Bcustomsec*{} elem*{elem : elem}:Belemsec Bcustomsec*{} `%`_u32(n)?{n : nat}:Bdatacntsec Bcustomsec*{} (local*{local : local}, expr)*{expr : expr, local : local}:Bcodesec Bcustomsec*{} data*{data : data}:Bdatasec Bcustomsec*{}} => MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})
+  prod{type* : type*, import* : import*, typeidx* : typeidx*, table* : table*, mem* : mem*, tag* : tag*, global* : global*, export* : export*, start? : start?, elem* : elem*, n? : n?, local** : local**, expr* : expr*, data* : data*, func* : func*} {Bmagic Bversion Bcustomsec*{} type*{type : type}:Btypesec Bcustomsec*{} import*{import : import}:Bimportsec Bcustomsec*{} typeidx*{typeidx : typeidx}:Bfuncsec Bcustomsec*{} table*{table : table}:Btablesec Bcustomsec*{} mem*{mem : mem}:Bmemsec Bcustomsec*{} tag*{tag : tag}:Btagsec Bcustomsec*{} global*{global : global}:Bglobalsec Bcustomsec*{} export*{export : export}:Bexportsec Bcustomsec*{} start?{start : start}:Bstartsec Bcustomsec*{} elem*{elem : elem}:Belemsec Bcustomsec*{} `%`_u32(n)?{n : nat}:Bdatacntsec Bcustomsec*{} (local*{local : local}, expr)*{expr : expr, local : local}:Bcodesec Bcustomsec*{} data*{data : data}:Bdatasec Bcustomsec*{}} => MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})
     -- (if (n = |data*{data : data}|))?{n : n}
     -- if ((n?{n : n} =/= ?()) \/ ($dataidx_funcs(func*{func : func}) = []))
     -- (if (func = FUNC_func(typeidx, local*{local : local}, expr)))*{expr : expr, func : func, local : local, typeidx : typeidx}
@@ -15972,7 +16692,7 @@ relation NotationTypingInstrScheme: `%|-%:%`(context, instr*, functype)
   rule block{C : context, blocktype : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, [BLOCK_instr(blocktype, instr*{instr : instr})], `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, blocktype, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- NotationTypingInstrScheme: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
+    -- NotationTypingInstrScheme: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
 }
 
 ;; C-conventions.watsup
@@ -16370,6 +17090,9 @@ syntax tableidx = idx
 ;; 1-syntax.watsup
 syntax memidx = idx
 
+;; 1-syntax.watsup
+syntax tagidx = idx
+
 ;; 1-syntax.watsup
 syntax elemidx = idx
 
@@ -16426,6 +17149,8 @@ syntax absheaptype =
   | NONE
   | FUNC
   | NOFUNC
+  | EXN
+  | NOEXN
   | EXTERN
   | NOEXTERN
   | BOT
@@ -16441,13 +17166,13 @@ syntax fin =
 ;; 1-syntax.watsup
 rec {
 
-;; 1-syntax.watsup:153.1-154.26
+;; 1-syntax.watsup:155.1-156.26
 syntax typeuse =
   | _IDX{typeidx : typeidx}(typeidx : typeidx)
   | DEF{rectype : rectype, n : n}(rectype : rectype, n : n)
   | REC{n : n}(n : n)
 
-;; 1-syntax.watsup:156.1-157.26
+;; 1-syntax.watsup:158.1-159.26
 syntax heaptype =
   | ANY
   | EQ
@@ -16457,6 +17182,8 @@ syntax heaptype =
   | NONE
   | FUNC
   | NOFUNC
+  | EXN
+  | NOEXN
   | EXTERN
   | NOEXTERN
   | BOT
@@ -16464,7 +17191,7 @@ syntax heaptype =
   | REC{n : n}(n : n)
   | DEF{rectype : rectype, n : n}(rectype : rectype, n : n)
 
-;; 1-syntax.watsup:164.1-165.14
+;; 1-syntax.watsup:166.1-167.14
 syntax valtype =
   | I32
   | I64
@@ -16474,10 +17201,10 @@ syntax valtype =
   | REF{nul : nul, heaptype : heaptype}(nul : nul, heaptype : heaptype)
   | BOT
 
-;; 1-syntax.watsup:194.1-195.16
+;; 1-syntax.watsup:196.1-197.16
 syntax resulttype = list(syntax valtype)
 
-;; 1-syntax.watsup:202.1-202.66
+;; 1-syntax.watsup:204.1-204.66
 syntax storagetype =
   | BOT
   | I32
@@ -16489,31 +17216,31 @@ syntax storagetype =
   | I8
   | I16
 
-;; 1-syntax.watsup:218.1-218.60
+;; 1-syntax.watsup:220.1-220.60
 syntax fieldtype =
   | `%%`{mut : mut, storagetype : storagetype}(mut : mut, storagetype : storagetype)
 
-;; 1-syntax.watsup:220.1-220.90
+;; 1-syntax.watsup:222.1-222.90
 syntax functype =
   | `%->%`{resulttype : resulttype}(resulttype : resulttype, resulttype)
 
-;; 1-syntax.watsup:221.1-221.64
+;; 1-syntax.watsup:223.1-223.64
 syntax structtype = list(syntax fieldtype)
 
-;; 1-syntax.watsup:222.1-222.54
+;; 1-syntax.watsup:224.1-224.54
 syntax arraytype = fieldtype
 
-;; 1-syntax.watsup:224.1-227.18
+;; 1-syntax.watsup:226.1-229.18
 syntax comptype =
   | STRUCT{structtype : structtype}(structtype : structtype)
   | ARRAY{arraytype : arraytype}(arraytype : arraytype)
   | FUNC{functype : functype}(functype : functype)
 
-;; 1-syntax.watsup:229.1-230.30
+;; 1-syntax.watsup:231.1-232.30
 syntax subtype =
   | SUB{fin : fin, typeuse* : typeuse*, comptype : comptype}(fin : fin, typeuse*{typeuse : typeuse} : typeuse*, comptype : comptype)
 
-;; 1-syntax.watsup:232.1-233.22
+;; 1-syntax.watsup:234.1-235.22
 syntax rectype =
   | REC{list : list(syntax subtype)}(list : list(syntax subtype))
 }
@@ -16657,6 +17384,9 @@ syntax tabletype =
 syntax memtype =
   | `%PAGE`{limits : limits}(limits : limits)
 
+;; 1-syntax.watsup
+syntax tagtype = deftype
+
 ;; 1-syntax.watsup
 syntax elemtype = reftype
 
@@ -16670,6 +17400,7 @@ syntax externtype =
   | GLOBAL{globaltype : globaltype}(globaltype : globaltype)
   | TABLE{tabletype : tabletype}(tabletype : tabletype)
   | MEM{memtype : memtype}(memtype : memtype)
+  | TAG{typeuse : typeuse}(typeuse : typeuse)
 
 ;; 1-syntax.watsup
 syntax moduletype =
@@ -17159,6 +17890,9 @@ syntax addr = nat
 ;; 4-runtime.watsup
 syntax arrayaddr = addr
 
+;; 4-runtime.watsup
+syntax exnaddr = addr
+
 ;; 4-runtime.watsup
 syntax funcaddr = addr
 
@@ -17171,16 +17905,24 @@ syntax structaddr = addr
 ;; 4-runtime.watsup
 rec {
 
-;; 4-runtime.watsup:37.1-43.23
+;; 4-runtime.watsup:35.1-42.23
 syntax addrref =
   | REF.I31_NUM{u31 : u31}(u31 : u31)
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
 }
 
+;; 1-syntax.watsup
+syntax catch =
+  | CATCH{tagidx : tagidx, labelidx : labelidx}(tagidx : tagidx, labelidx : labelidx)
+  | CATCH_REF{tagidx : tagidx, labelidx : labelidx}(tagidx : tagidx, labelidx : labelidx)
+  | CATCH_ALL{labelidx : labelidx}(labelidx : labelidx)
+  | CATCH_ALL_REF{labelidx : labelidx}(labelidx : labelidx)
+
 ;; 4-runtime.watsup
 syntax dataaddr = addr
 
@@ -17197,17 +17939,21 @@ syntax memaddr = addr
 syntax tableaddr = addr
 
 ;; 4-runtime.watsup
-syntax externval =
+syntax tagaddr = addr
+
+;; 4-runtime.watsup
+syntax externaddr =
   | FUNC{funcaddr : funcaddr}(funcaddr : funcaddr)
   | GLOBAL{globaladdr : globaladdr}(globaladdr : globaladdr)
   | TABLE{tableaddr : tableaddr}(tableaddr : tableaddr)
   | MEM{memaddr : memaddr}(memaddr : memaddr)
+  | TAG{tagaddr : tagaddr}(tagaddr : tagaddr)
 
 ;; 4-runtime.watsup
 syntax exportinst =
 {
   NAME{name : name} name,
-  VALUE{externval : externval} externval
+  ADDR{externaddr : externaddr} externaddr
 }
 
 ;; 4-runtime.watsup
@@ -17218,6 +17964,7 @@ syntax moduleinst =
   GLOBALS{globaladdr* : globaladdr*} globaladdr*,
   TABLES{tableaddr* : tableaddr*} tableaddr*,
   MEMS{memaddr* : memaddr*} memaddr*,
+  TAGS{tagaddr* : tagaddr*} tagaddr*,
   ELEMS{elemaddr* : elemaddr*} elemaddr*,
   DATAS{dataaddr* : dataaddr*} dataaddr*,
   EXPORTS{exportinst* : exportinst*} exportinst*
@@ -17232,6 +17979,7 @@ syntax val =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
 
@@ -17245,7 +17993,7 @@ syntax frame =
 ;; 4-runtime.watsup
 rec {
 
-;; 4-runtime.watsup:151.1-156.9
+;; 4-runtime.watsup:151.1-157.9
 syntax instr =
   | NOP
   | UNREACHABLE
@@ -17268,6 +18016,9 @@ syntax instr =
   | RETURN_CALL{funcidx : funcidx}(funcidx : funcidx)
   | RETURN_CALL_REF{typeuse : typeuse}(typeuse : typeuse)
   | RETURN_CALL_INDIRECT{tableidx : tableidx, typeuse : typeuse}(tableidx : tableidx, typeuse : typeuse)
+  | THROW{tagidx : tagidx}(tagidx : tagidx)
+  | THROW_REF
+  | TRY_TABLE{blocktype : blocktype, list : list(syntax catch), instr* : instr*}(blocktype : blocktype, list : list(syntax catch), instr*{instr : instr} : instr*)
   | CONST{numtype : numtype, num_ : num_(numtype)}(numtype : numtype, num_ : num_(numtype))
   | UNOP{numtype : numtype, unop_ : unop_(numtype)}(numtype : numtype, unop_ : unop_(numtype))
   | BINOP{numtype : numtype, binop_ : binop_(numtype)}(numtype : numtype, binop_ : binop_(numtype))
@@ -17355,10 +18106,12 @@ syntax instr =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | `LABEL_%{%}%`{n : n, instr* : instr*}(n : n, instr*{instr : instr} : instr*, instr*)
   | `FRAME_%{%}%`{n : n, frame : frame, instr* : instr*}(n : n, frame : frame, instr*{instr : instr} : instr*)
+  | `HANDLER_%{%}%`{n : n, catch* : catch*, instr* : instr*}(n : n, catch*{catch : catch} : catch*, instr*{instr : instr} : instr*)
   | TRAP
 }
 
@@ -17400,6 +18153,10 @@ syntax table =
 syntax mem =
   | MEMORY{memtype : memtype}(memtype : memtype)
 
+;; 1-syntax.watsup
+syntax tag =
+  | TAG{typeidx : typeidx}(typeidx : typeidx)
+
 ;; 1-syntax.watsup
 syntax elem =
   | ELEM{reftype : reftype, expr* : expr*, elemmode : elemmode}(reftype : reftype, expr*{expr : expr} : expr*, elemmode : elemmode)
@@ -17418,6 +18175,7 @@ syntax externidx =
   | GLOBAL{globalidx : globalidx}(globalidx : globalidx)
   | TABLE{tableidx : tableidx}(tableidx : tableidx)
   | MEM{memidx : memidx}(memidx : memidx)
+  | TAG{tagidx : tagidx}(tagidx : tagidx)
 
 ;; 1-syntax.watsup
 syntax export =
@@ -17429,7 +18187,7 @@ syntax import =
 
 ;; 1-syntax.watsup
 syntax module =
-  | MODULE{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*}(type*{type : type} : type*, import*{import : import} : import*, func*{func : func} : func*, global*{global : global} : global*, table*{table : table} : table*, mem*{mem : mem} : mem*, elem*{elem : elem} : elem*, data*{data : data} : data*, start?{start : start} : start?, export*{export : export} : export*)
+  | MODULE{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*}(type*{type : type} : type*, import*{import : import} : import*, func*{func : func} : func*, global*{global : global} : global*, table*{table : table} : table*, mem*{mem : mem} : mem*, tag*{tag : tag} : tag*, elem*{elem : elem} : elem*, data*{data : data} : data*, start?{start : start} : start?, export*{export : export} : export*)
 
 ;; 2-syntax-aux.watsup
 def $IN(N : N) : Inn
@@ -18056,6 +18814,11 @@ def $free_mem(mem : mem) : free
   ;; 2-syntax-aux.watsup
   def $free_mem{memtype : memtype}(MEMORY_mem(memtype)) = $free_memtype(memtype)
 
+;; 2-syntax-aux.watsup
+def $free_tag(tag : tag) : free
+  ;; 2-syntax-aux.watsup
+  def $free_tag{typeidx : typeidx}(TAG_tag(typeidx)) = $free_typeidx(typeidx)
+
 ;; 2-syntax-aux.watsup
 def $free_elemmode(elemmode : elemmode) : free
   ;; 2-syntax-aux.watsup
@@ -18100,7 +18863,7 @@ def $free_import(import : import) : free
 ;; 2-syntax-aux.watsup
 def $free_module(module : module) : free
   ;; 2-syntax-aux.watsup
-  def $free_module{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*}(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})) = $free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})
+  def $free_module{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*}(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})) = $free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_tag(tag)*{tag : tag}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})
 
 ;; 2-syntax-aux.watsup
 def $funcidx_module(module : module) : funcidx*
@@ -18115,14 +18878,14 @@ def $dataidx_funcs(func*) : dataidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:531.1-531.112
+;; 2-syntax-aux.watsup:535.1-535.112
 def $subst_typevar(typevar : typevar, typevar*, typeuse*) : typeuse
-  ;; 2-syntax-aux.watsup:558.1-558.38
+  ;; 2-syntax-aux.watsup:562.1-562.38
   def $subst_typevar{tv : typevar}(tv, [], []) = (tv : typevar <: typeuse)
-  ;; 2-syntax-aux.watsup:559.1-559.95
+  ;; 2-syntax-aux.watsup:563.1-563.95
   def $subst_typevar{tv : typevar, tv_1 : typevar, tv'* : typevar*, tu_1 : typeuse, tu'* : typeuse*}(tv, [tv_1] :: tv'*{tv' : typevar}, [tu_1] :: tu'*{tu' : typeuse}) = tu_1
     -- if (tv = tv_1)
-  ;; 2-syntax-aux.watsup:560.1-560.92
+  ;; 2-syntax-aux.watsup:564.1-564.92
   def $subst_typevar{tv : typevar, tv_1 : typevar, tv'* : typevar*, tu_1 : typeuse, tu'* : typeuse*}(tv, [tv_1] :: tv'*{tv' : typevar}, [tu_1] :: tu'*{tu' : typeuse}) = $subst_typevar(tv, tv'*{tv' : typevar}, tu'*{tu' : typeuse})
     -- otherwise
 }
@@ -18145,78 +18908,78 @@ def $subst_vectype(vectype : vectype, typevar*, typeuse*) : vectype
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:532.1-532.112
+;; 2-syntax-aux.watsup:536.1-536.112
 def $subst_typeuse(typeuse : typeuse, typevar*, typeuse*) : typeuse
-  ;; 2-syntax-aux.watsup:562.1-562.66
+  ;; 2-syntax-aux.watsup:566.1-566.66
   def $subst_typeuse{tv' : typevar, tv* : typevar*, tu* : typeuse*}((tv' : typevar <: typeuse), tv*{tv : typevar}, tu*{tu : typeuse}) = $subst_typevar(tv', tv*{tv : typevar}, tu*{tu : typeuse})
-  ;; 2-syntax-aux.watsup:563.1-563.64
+  ;; 2-syntax-aux.watsup:567.1-567.64
   def $subst_typeuse{dt : deftype, tv* : typevar*, tu* : typeuse*}((dt : deftype <: typeuse), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_deftype(dt, tv*{tv : typevar}, tu*{tu : typeuse}) : deftype <: typeuse)
 
-;; 2-syntax-aux.watsup:536.1-536.112
+;; 2-syntax-aux.watsup:540.1-540.112
 def $subst_heaptype(heaptype : heaptype, typevar*, typeuse*) : heaptype
-  ;; 2-syntax-aux.watsup:568.1-568.67
+  ;; 2-syntax-aux.watsup:572.1-572.67
   def $subst_heaptype{tv' : typevar, tv* : typevar*, tu* : typeuse*}((tv' : typevar <: heaptype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_typevar(tv', tv*{tv : typevar}, tu*{tu : typeuse}) : typeuse <: heaptype)
-  ;; 2-syntax-aux.watsup:569.1-569.65
+  ;; 2-syntax-aux.watsup:573.1-573.65
   def $subst_heaptype{dt : deftype, tv* : typevar*, tu* : typeuse*}((dt : deftype <: heaptype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_deftype(dt, tv*{tv : typevar}, tu*{tu : typeuse}) : deftype <: heaptype)
-  ;; 2-syntax-aux.watsup:570.1-570.53
+  ;; 2-syntax-aux.watsup:574.1-574.53
   def $subst_heaptype{ht : heaptype, tv* : typevar*, tu* : typeuse*}(ht, tv*{tv : typevar}, tu*{tu : typeuse}) = ht
     -- otherwise
 
-;; 2-syntax-aux.watsup:537.1-537.112
+;; 2-syntax-aux.watsup:541.1-541.112
 def $subst_reftype(reftype : reftype, typevar*, typeuse*) : reftype
-  ;; 2-syntax-aux.watsup:572.1-572.83
+  ;; 2-syntax-aux.watsup:576.1-576.83
   def $subst_reftype{nul : nul, ht : heaptype, tv* : typevar*, tu* : typeuse*}(REF_reftype(nul, ht), tv*{tv : typevar}, tu*{tu : typeuse}) = REF_reftype(nul, $subst_heaptype(ht, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:538.1-538.112
+;; 2-syntax-aux.watsup:542.1-542.112
 def $subst_valtype(valtype : valtype, typevar*, typeuse*) : valtype
-  ;; 2-syntax-aux.watsup:574.1-574.64
+  ;; 2-syntax-aux.watsup:578.1-578.64
   def $subst_valtype{nt : numtype, tv* : typevar*, tu* : typeuse*}((nt : numtype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_numtype(nt, tv*{tv : typevar}, tu*{tu : typeuse}) : numtype <: valtype)
-  ;; 2-syntax-aux.watsup:575.1-575.64
+  ;; 2-syntax-aux.watsup:579.1-579.64
   def $subst_valtype{vt : vectype, tv* : typevar*, tu* : typeuse*}((vt : vectype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_vectype(vt, tv*{tv : typevar}, tu*{tu : typeuse}) : vectype <: valtype)
-  ;; 2-syntax-aux.watsup:576.1-576.64
+  ;; 2-syntax-aux.watsup:580.1-580.64
   def $subst_valtype{rt : reftype, tv* : typevar*, tu* : typeuse*}((rt : reftype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_reftype(rt, tv*{tv : typevar}, tu*{tu : typeuse}) : reftype <: valtype)
-  ;; 2-syntax-aux.watsup:577.1-577.40
+  ;; 2-syntax-aux.watsup:581.1-581.40
   def $subst_valtype{tv* : typevar*, tu* : typeuse*}(BOT_valtype, tv*{tv : typevar}, tu*{tu : typeuse}) = BOT_valtype
 
-;; 2-syntax-aux.watsup:541.1-541.112
+;; 2-syntax-aux.watsup:545.1-545.112
 def $subst_storagetype(storagetype : storagetype, typevar*, typeuse*) : storagetype
-  ;; 2-syntax-aux.watsup:581.1-581.66
+  ;; 2-syntax-aux.watsup:585.1-585.66
   def $subst_storagetype{t : valtype, tv* : typevar*, tu* : typeuse*}((t : valtype <: storagetype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_valtype(t, tv*{tv : typevar}, tu*{tu : typeuse}) : valtype <: storagetype)
-  ;; 2-syntax-aux.watsup:582.1-582.69
+  ;; 2-syntax-aux.watsup:586.1-586.69
   def $subst_storagetype{pt : packtype, tv* : typevar*, tu* : typeuse*}((pt : packtype <: storagetype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_packtype(pt, tv*{tv : typevar}, tu*{tu : typeuse}) : packtype <: storagetype)
 
-;; 2-syntax-aux.watsup:542.1-542.112
+;; 2-syntax-aux.watsup:546.1-546.112
 def $subst_fieldtype(fieldtype : fieldtype, typevar*, typeuse*) : fieldtype
-  ;; 2-syntax-aux.watsup:584.1-584.80
+  ;; 2-syntax-aux.watsup:588.1-588.80
   def $subst_fieldtype{mut : mut, zt : storagetype, tv* : typevar*, tu* : typeuse*}(`%%`_fieldtype(mut, zt), tv*{tv : typevar}, tu*{tu : typeuse}) = `%%`_fieldtype(mut, $subst_storagetype(zt, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:544.1-544.112
+;; 2-syntax-aux.watsup:548.1-548.112
 def $subst_comptype(comptype : comptype, typevar*, typeuse*) : comptype
-  ;; 2-syntax-aux.watsup:586.1-586.85
+  ;; 2-syntax-aux.watsup:590.1-590.85
   def $subst_comptype{yt* : fieldtype*, tv* : typevar*, tu* : typeuse*}(STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = STRUCT_comptype(`%`_structtype($subst_fieldtype(yt, tv*{tv : typevar}, tu*{tu : typeuse})*{yt : fieldtype}))
-  ;; 2-syntax-aux.watsup:587.1-587.81
+  ;; 2-syntax-aux.watsup:591.1-591.81
   def $subst_comptype{yt : fieldtype, tv* : typevar*, tu* : typeuse*}(ARRAY_comptype(yt), tv*{tv : typevar}, tu*{tu : typeuse}) = ARRAY_comptype($subst_fieldtype(yt, tv*{tv : typevar}, tu*{tu : typeuse}))
-  ;; 2-syntax-aux.watsup:588.1-588.78
+  ;; 2-syntax-aux.watsup:592.1-592.78
   def $subst_comptype{ft : functype, tv* : typevar*, tu* : typeuse*}(FUNC_comptype(ft), tv*{tv : typevar}, tu*{tu : typeuse}) = FUNC_comptype($subst_functype(ft, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:545.1-545.112
+;; 2-syntax-aux.watsup:549.1-549.112
 def $subst_subtype(subtype : subtype, typevar*, typeuse*) : subtype
-  ;; 2-syntax-aux.watsup:590.1-591.71
+  ;; 2-syntax-aux.watsup:594.1-595.71
   def $subst_subtype{fin : fin, tu'* : typeuse*, ct : comptype, tv* : typevar*, tu* : typeuse*}(SUB_subtype(fin, tu'*{tu' : typeuse}, ct), tv*{tv : typevar}, tu*{tu : typeuse}) = SUB_subtype(fin, $subst_typeuse(tu', tv*{tv : typevar}, tu*{tu : typeuse})*{tu' : typeuse}, $subst_comptype(ct, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:546.1-546.112
+;; 2-syntax-aux.watsup:550.1-550.112
 def $subst_rectype(rectype : rectype, typevar*, typeuse*) : rectype
-  ;; 2-syntax-aux.watsup:593.1-593.76
+  ;; 2-syntax-aux.watsup:597.1-597.76
   def $subst_rectype{st* : subtype*, tv* : typevar*, tu* : typeuse*}(REC_rectype(`%`_list(st*{st : subtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = REC_rectype(`%`_list($subst_subtype(st, tv*{tv : typevar}, tu*{tu : typeuse})*{st : subtype}))
 
-;; 2-syntax-aux.watsup:547.1-547.112
+;; 2-syntax-aux.watsup:551.1-551.112
 def $subst_deftype(deftype : deftype, typevar*, typeuse*) : deftype
-  ;; 2-syntax-aux.watsup:595.1-595.78
+  ;; 2-syntax-aux.watsup:599.1-599.78
   def $subst_deftype{qt : rectype, i : nat, tv* : typevar*, tu* : typeuse*}(DEF_deftype(qt, i), tv*{tv : typevar}, tu*{tu : typeuse}) = DEF_deftype($subst_rectype(qt, tv*{tv : typevar}, tu*{tu : typeuse}), i)
 
-;; 2-syntax-aux.watsup:550.1-550.112
+;; 2-syntax-aux.watsup:554.1-554.112
 def $subst_functype(functype : functype, typevar*, typeuse*) : functype
-  ;; 2-syntax-aux.watsup:598.1-598.113
+  ;; 2-syntax-aux.watsup:602.1-602.113
   def $subst_functype{t_1* : valtype*, t_2* : valtype*, tv* : typevar*, tu* : typeuse*}(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = `%->%`_functype(`%`_resulttype($subst_valtype(t_1, tv*{tv : typevar}, tu*{tu : typeuse})*{t_1 : valtype}), `%`_resulttype($subst_valtype(t_2, tv*{tv : typevar}, tu*{tu : typeuse})*{t_2 : valtype}))
 }
 
@@ -18274,11 +19037,11 @@ def $subst_all_moduletype(moduletype : moduletype, heaptype*) : moduletype
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:620.1-620.98
+;; 2-syntax-aux.watsup:624.1-624.98
 def $subst_all_deftypes(deftype*, heaptype*) : deftype*
-  ;; 2-syntax-aux.watsup:621.1-621.40
+  ;; 2-syntax-aux.watsup:625.1-625.40
   def $subst_all_deftypes{tu* : typeuse*}([], (tu : typeuse <: heaptype)*{tu : typeuse}) = []
-  ;; 2-syntax-aux.watsup:622.1-622.101
+  ;; 2-syntax-aux.watsup:626.1-626.101
   def $subst_all_deftypes{dt_1 : deftype, dt* : deftype*, tu* : typeuse*}([dt_1] :: dt*{dt : deftype}, (tu : typeuse <: heaptype)*{tu : typeuse}) = [$subst_all_deftype(dt_1, (tu : typeuse <: heaptype)*{tu : typeuse})] :: $subst_all_deftypes(dt*{dt : deftype}, (tu : typeuse <: heaptype)*{tu : typeuse})
 }
 
@@ -18322,13 +19085,13 @@ relation Expand: `%~~%`(deftype, comptype)
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:654.1-654.86
+;; 2-syntax-aux.watsup:658.1-658.86
 def $funcsxx(externidx*) : typeidx*
-  ;; 2-syntax-aux.watsup:659.1-659.24
+  ;; 2-syntax-aux.watsup:664.1-664.24
   def $funcsxx([]) = []
-  ;; 2-syntax-aux.watsup:660.1-660.45
+  ;; 2-syntax-aux.watsup:665.1-665.45
   def $funcsxx{x : idx, xx* : externidx*}([FUNC_externidx(x)] :: xx*{xx : externidx}) = [x] :: $funcsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:661.1-661.58
+  ;; 2-syntax-aux.watsup:666.1-666.58
   def $funcsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $funcsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -18336,13 +19099,13 @@ def $funcsxx(externidx*) : typeidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:655.1-655.88
+;; 2-syntax-aux.watsup:659.1-659.88
 def $globalsxx(externidx*) : globalidx*
-  ;; 2-syntax-aux.watsup:663.1-663.26
+  ;; 2-syntax-aux.watsup:668.1-668.26
   def $globalsxx([]) = []
-  ;; 2-syntax-aux.watsup:664.1-664.51
+  ;; 2-syntax-aux.watsup:669.1-669.51
   def $globalsxx{x : idx, xx* : externidx*}([GLOBAL_externidx(x)] :: xx*{xx : externidx}) = [x] :: $globalsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:665.1-665.62
+  ;; 2-syntax-aux.watsup:670.1-670.62
   def $globalsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $globalsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -18350,13 +19113,13 @@ def $globalsxx(externidx*) : globalidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:656.1-656.87
+;; 2-syntax-aux.watsup:660.1-660.87
 def $tablesxx(externidx*) : tableidx*
-  ;; 2-syntax-aux.watsup:667.1-667.25
+  ;; 2-syntax-aux.watsup:672.1-672.25
   def $tablesxx([]) = []
-  ;; 2-syntax-aux.watsup:668.1-668.48
+  ;; 2-syntax-aux.watsup:673.1-673.48
   def $tablesxx{x : idx, xx* : externidx*}([TABLE_externidx(x)] :: xx*{xx : externidx}) = [x] :: $tablesxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:669.1-669.60
+  ;; 2-syntax-aux.watsup:674.1-674.60
   def $tablesxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $tablesxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -18364,13 +19127,13 @@ def $tablesxx(externidx*) : tableidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:657.1-657.85
+;; 2-syntax-aux.watsup:661.1-661.85
 def $memsxx(externidx*) : memidx*
-  ;; 2-syntax-aux.watsup:671.1-671.23
+  ;; 2-syntax-aux.watsup:676.1-676.23
   def $memsxx([]) = []
-  ;; 2-syntax-aux.watsup:672.1-672.42
+  ;; 2-syntax-aux.watsup:677.1-677.42
   def $memsxx{x : idx, xx* : externidx*}([MEM_externidx(x)] :: xx*{xx : externidx}) = [x] :: $memsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:673.1-673.56
+  ;; 2-syntax-aux.watsup:678.1-678.56
   def $memsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $memsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -18378,13 +19141,27 @@ def $memsxx(externidx*) : memidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:676.1-676.88
+;; 2-syntax-aux.watsup:662.1-662.85
+def $tagsxx(externidx*) : tagidx*
+  ;; 2-syntax-aux.watsup:680.1-680.23
+  def $tagsxx([]) = []
+  ;; 2-syntax-aux.watsup:681.1-681.42
+  def $tagsxx{x : idx, xx* : externidx*}([TAG_externidx(x)] :: xx*{xx : externidx}) = [x] :: $tagsxx(xx*{xx : externidx})
+  ;; 2-syntax-aux.watsup:682.1-682.56
+  def $tagsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $tagsxx(xx*{xx : externidx})
+    -- otherwise
+}
+
+;; 2-syntax-aux.watsup
+rec {
+
+;; 2-syntax-aux.watsup:685.1-685.88
 def $funcsxt(externtype*) : deftype*
-  ;; 2-syntax-aux.watsup:681.1-681.24
+  ;; 2-syntax-aux.watsup:691.1-691.24
   def $funcsxt([]) = []
-  ;; 2-syntax-aux.watsup:682.1-682.47
+  ;; 2-syntax-aux.watsup:692.1-692.47
   def $funcsxt{dt : deftype, xt* : externtype*}([FUNC_externtype((dt : deftype <: typeuse))] :: xt*{xt : externtype}) = [dt] :: $funcsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:683.1-683.59
+  ;; 2-syntax-aux.watsup:693.1-693.59
   def $funcsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $funcsxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -18392,13 +19169,13 @@ def $funcsxt(externtype*) : deftype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:677.1-677.90
+;; 2-syntax-aux.watsup:686.1-686.90
 def $globalsxt(externtype*) : globaltype*
-  ;; 2-syntax-aux.watsup:685.1-685.26
+  ;; 2-syntax-aux.watsup:695.1-695.26
   def $globalsxt([]) = []
-  ;; 2-syntax-aux.watsup:686.1-686.53
+  ;; 2-syntax-aux.watsup:696.1-696.53
   def $globalsxt{gt : globaltype, xt* : externtype*}([GLOBAL_externtype(gt)] :: xt*{xt : externtype}) = [gt] :: $globalsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:687.1-687.63
+  ;; 2-syntax-aux.watsup:697.1-697.63
   def $globalsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $globalsxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -18406,13 +19183,13 @@ def $globalsxt(externtype*) : globaltype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:678.1-678.89
+;; 2-syntax-aux.watsup:687.1-687.89
 def $tablesxt(externtype*) : tabletype*
-  ;; 2-syntax-aux.watsup:689.1-689.25
+  ;; 2-syntax-aux.watsup:699.1-699.25
   def $tablesxt([]) = []
-  ;; 2-syntax-aux.watsup:690.1-690.50
+  ;; 2-syntax-aux.watsup:700.1-700.50
   def $tablesxt{tt : tabletype, xt* : externtype*}([TABLE_externtype(tt)] :: xt*{xt : externtype}) = [tt] :: $tablesxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:691.1-691.61
+  ;; 2-syntax-aux.watsup:701.1-701.61
   def $tablesxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $tablesxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -18420,17 +19197,31 @@ def $tablesxt(externtype*) : tabletype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:679.1-679.87
+;; 2-syntax-aux.watsup:688.1-688.87
 def $memsxt(externtype*) : memtype*
-  ;; 2-syntax-aux.watsup:693.1-693.23
+  ;; 2-syntax-aux.watsup:703.1-703.23
   def $memsxt([]) = []
-  ;; 2-syntax-aux.watsup:694.1-694.44
+  ;; 2-syntax-aux.watsup:704.1-704.44
   def $memsxt{mt : memtype, xt* : externtype*}([MEM_externtype(mt)] :: xt*{xt : externtype}) = [mt] :: $memsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:695.1-695.57
+  ;; 2-syntax-aux.watsup:705.1-705.57
   def $memsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $memsxt(xt*{xt : externtype})
     -- otherwise
 }
 
+;; 2-syntax-aux.watsup
+rec {
+
+;; 2-syntax-aux.watsup:689.1-689.87
+def $tagsxt(externtype*) : tagtype*
+  ;; 2-syntax-aux.watsup:707.1-707.23
+  def $tagsxt([]) = []
+  ;; 2-syntax-aux.watsup:708.1-708.44
+  def $tagsxt{at : tagtype, xt* : externtype*}([TAG_externtype((at : deftype <: typeuse))] :: xt*{xt : externtype}) = [at] :: $tagsxt(xt*{xt : externtype})
+  ;; 2-syntax-aux.watsup:709.1-709.57
+  def $tagsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $tagsxt(xt*{xt : externtype})
+    -- otherwise
+}
+
 ;; 2-syntax-aux.watsup
 def $memarg0 : memarg
   ;; 2-syntax-aux.watsup
@@ -19158,6 +19949,7 @@ syntax ref =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | REF.NULL{heaptype : heaptype}(heaptype : heaptype)
@@ -19165,6 +19957,7 @@ syntax ref =
 ;; 4-runtime.watsup
 syntax result =
   | _VALS{val* : val*}(val*{val : val} : val*)
+  | `_EXN(REF.EXN_ADDR%)THROW_REF`{exnaddr : exnaddr}(exnaddr : exnaddr)
   | TRAP
 
 ;; 4-runtime.watsup
@@ -19205,6 +19998,12 @@ syntax meminst =
   BYTES{byte* : byte*} byte*
 }
 
+;; 4-runtime.watsup
+syntax taginst =
+{
+  TYPE{tagtype : tagtype} tagtype
+}
+
 ;; 4-runtime.watsup
 syntax eleminst =
 {
@@ -19231,6 +20030,7 @@ syntax fieldval =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | PACK{packtype : packtype, iN : iN($psizenn(packtype))}(packtype : packtype, iN : iN($psizenn(packtype)))
@@ -19249,6 +20049,13 @@ syntax arrayinst =
   FIELDS{fieldval* : fieldval*} fieldval*
 }
 
+;; 4-runtime.watsup
+syntax exninst =
+{
+  TAG{tagaddr : tagaddr} tagaddr,
+  FIELDS{val* : val*} val*
+}
+
 ;; 4-runtime.watsup
 syntax store =
 {
@@ -19256,10 +20063,12 @@ syntax store =
   GLOBALS{globalinst* : globalinst*} globalinst*,
   TABLES{tableinst* : tableinst*} tableinst*,
   MEMS{meminst* : meminst*} meminst*,
+  TAGS{taginst* : taginst*} taginst*,
   ELEMS{eleminst* : eleminst*} eleminst*,
   DATAS{datainst* : datainst*} datainst*,
   STRUCTS{structinst* : structinst*} structinst*,
-  ARRAYS{arrayinst* : arrayinst*} arrayinst*
+  ARRAYS{arrayinst* : arrayinst*} arrayinst*,
+  EXNS{exninst* : exninst*} exninst*
 }
 
 ;; 4-runtime.watsup
@@ -19312,56 +20121,70 @@ def $unpackfield_(storagetype : storagetype, sx?, fieldval : fieldval) : val
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:46.1-46.86
-def $funcsxv(externval*) : funcaddr*
-  ;; 5-runtime-aux.watsup:51.1-51.24
-  def $funcsxv([]) = []
-  ;; 5-runtime-aux.watsup:52.1-52.47
-  def $funcsxv{fa : funcaddr, xv* : externval*}([FUNC_externval(fa)] :: xv*{xv : externval}) = [fa] :: $funcsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:53.1-53.58
-  def $funcsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $funcsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:46.1-46.87
+def $funcsxa(externaddr*) : funcaddr*
+  ;; 5-runtime-aux.watsup:52.1-52.24
+  def $funcsxa([]) = []
+  ;; 5-runtime-aux.watsup:53.1-53.47
+  def $funcsxa{fa : funcaddr, xa* : externaddr*}([FUNC_externaddr(fa)] :: xa*{xa : externaddr}) = [fa] :: $funcsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:54.1-54.59
+  def $funcsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $funcsxa(xa*{xa : externaddr})
+    -- otherwise
+}
+
+;; 5-runtime-aux.watsup
+rec {
+
+;; 5-runtime-aux.watsup:47.1-47.89
+def $globalsxa(externaddr*) : globaladdr*
+  ;; 5-runtime-aux.watsup:56.1-56.26
+  def $globalsxa([]) = []
+  ;; 5-runtime-aux.watsup:57.1-57.53
+  def $globalsxa{ga : globaladdr, xa* : externaddr*}([GLOBAL_externaddr(ga)] :: xa*{xa : externaddr}) = [ga] :: $globalsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:58.1-58.63
+  def $globalsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $globalsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:47.1-47.88
-def $globalsxv(externval*) : globaladdr*
-  ;; 5-runtime-aux.watsup:55.1-55.26
-  def $globalsxv([]) = []
-  ;; 5-runtime-aux.watsup:56.1-56.53
-  def $globalsxv{ga : globaladdr, xv* : externval*}([GLOBAL_externval(ga)] :: xv*{xv : externval}) = [ga] :: $globalsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:57.1-57.62
-  def $globalsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $globalsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:48.1-48.88
+def $tablesxa(externaddr*) : tableaddr*
+  ;; 5-runtime-aux.watsup:60.1-60.25
+  def $tablesxa([]) = []
+  ;; 5-runtime-aux.watsup:61.1-61.50
+  def $tablesxa{ta : tableaddr, xa* : externaddr*}([TABLE_externaddr(ta)] :: xa*{xa : externaddr}) = [ta] :: $tablesxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:62.1-62.61
+  def $tablesxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $tablesxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:48.1-48.87
-def $tablesxv(externval*) : tableaddr*
-  ;; 5-runtime-aux.watsup:59.1-59.25
-  def $tablesxv([]) = []
-  ;; 5-runtime-aux.watsup:60.1-60.50
-  def $tablesxv{ta : tableaddr, xv* : externval*}([TABLE_externval(ta)] :: xv*{xv : externval}) = [ta] :: $tablesxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:61.1-61.60
-  def $tablesxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $tablesxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:49.1-49.86
+def $memsxa(externaddr*) : memaddr*
+  ;; 5-runtime-aux.watsup:64.1-64.23
+  def $memsxa([]) = []
+  ;; 5-runtime-aux.watsup:65.1-65.44
+  def $memsxa{ma : memaddr, xa* : externaddr*}([MEM_externaddr(ma)] :: xa*{xa : externaddr}) = [ma] :: $memsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:66.1-66.57
+  def $memsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $memsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:49.1-49.85
-def $memsxv(externval*) : memaddr*
-  ;; 5-runtime-aux.watsup:63.1-63.23
-  def $memsxv([]) = []
-  ;; 5-runtime-aux.watsup:64.1-64.44
-  def $memsxv{ma : memaddr, xv* : externval*}([MEM_externval(ma)] :: xv*{xv : externval}) = [ma] :: $memsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:65.1-65.56
-  def $memsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $memsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:50.1-50.86
+def $tagsxa(externaddr*) : tagaddr*
+  ;; 5-runtime-aux.watsup:68.1-68.23
+  def $tagsxa([]) = []
+  ;; 5-runtime-aux.watsup:69.1-69.44
+  def $tagsxa{ha : tagaddr, xa* : externaddr*}([TAG_externaddr(ha)] :: xa*{xa : externaddr}) = [ha] :: $tagsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:70.1-70.57
+  def $tagsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $tagsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
@@ -19376,7 +20199,12 @@ def $frame(state : state) : frame
   def $frame{s : store, f : frame}(`%;%`_state(s, f)) = f
 
 ;; 5-runtime-aux.watsup
-def $moduleinst(state : state) : moduleinst
+def $tagaddr(state : state) : tagaddr*
+  ;; 5-runtime-aux.watsup
+  def $tagaddr{s : store, f : frame}(`%;%`_state(s, f)) = f.MODULE_frame.TAGS_moduleinst
+
+;; 5-runtime-aux.watsup
+def $moduleinst(state : state) : moduleinst
   ;; 5-runtime-aux.watsup
   def $moduleinst{s : store, f : frame}(`%;%`_state(s, f)) = f.MODULE_frame
 
@@ -19400,6 +20228,11 @@ def $meminst(state : state) : meminst*
   ;; 5-runtime-aux.watsup
   def $meminst{s : store, f : frame}(`%;%`_state(s, f)) = s.MEMS_store
 
+;; 5-runtime-aux.watsup
+def $taginst(state : state) : taginst*
+  ;; 5-runtime-aux.watsup
+  def $taginst{s : store, f : frame}(`%;%`_state(s, f)) = s.TAGS_store
+
 ;; 5-runtime-aux.watsup
 def $eleminst(state : state) : eleminst*
   ;; 5-runtime-aux.watsup
@@ -19420,6 +20253,11 @@ def $arrayinst(state : state) : arrayinst*
   ;; 5-runtime-aux.watsup
   def $arrayinst{s : store, f : frame}(`%;%`_state(s, f)) = s.ARRAYS_store
 
+;; 5-runtime-aux.watsup
+def $exninst(state : state) : exninst*
+  ;; 5-runtime-aux.watsup
+  def $exninst{s : store, f : frame}(`%;%`_state(s, f)) = s.EXNS_store
+
 ;; 5-runtime-aux.watsup
 def $type(state : state, typeidx : typeidx) : deftype
   ;; 5-runtime-aux.watsup
@@ -19445,6 +20283,11 @@ def $mem(state : state, memidx : memidx) : meminst
   ;; 5-runtime-aux.watsup
   def $mem{s : store, f : frame, x : idx}(`%;%`_state(s, f), x) = s.MEMS_store[f.MODULE_frame.MEMS_moduleinst[x!`%`_idx.0]]
 
+;; 5-runtime-aux.watsup
+def $tag(state : state, tagidx : tagidx) : taginst
+  ;; 5-runtime-aux.watsup
+  def $tag{s : store, f : frame, x : idx}(`%;%`_state(s, f), x) = s.TAGS_store[f.MODULE_frame.TAGS_moduleinst[x!`%`_idx.0]]
+
 ;; 5-runtime-aux.watsup
 def $elem(state : state, tableidx : tableidx) : eleminst
   ;; 5-runtime-aux.watsup
@@ -19520,6 +20363,11 @@ def $add_arrayinst(state : state, arrayinst*) : state
   ;; 5-runtime-aux.watsup
   def $add_arrayinst{s : store, f : frame, ai* : arrayinst*}(`%;%`_state(s, f), ai*{ai : arrayinst}) = `%;%`_state(s[ARRAYS_store =++ ai*{ai : arrayinst}], f)
 
+;; 5-runtime-aux.watsup
+def $add_exninst(state : state, exninst*) : state
+  ;; 5-runtime-aux.watsup
+  def $add_exninst{s : store, f : frame, exn* : exninst*}(`%;%`_state(s, f), exn*{exn : exninst}) = `%;%`_state(s[EXNS_store =++ exn*{exn : exninst}], f)
+
 ;; 5-runtime-aux.watsup
 def $growtable(tableinst : tableinst, nat : nat, ref : ref) : tableinst?
   ;; 5-runtime-aux.watsup
@@ -19560,6 +20408,7 @@ syntax context =
   GLOBALS{globaltype* : globaltype*} globaltype*,
   TABLES{tabletype* : tabletype*} tabletype*,
   MEMS{memtype* : memtype*} memtype*,
+  TAGS{tagtype* : tagtype*} tagtype*,
   ELEMS{elemtype* : elemtype*} elemtype*,
   DATAS{datatype* : datatype*} datatype*,
   LOCALS{localtype* : localtype*} localtype*,
@@ -19571,22 +20420,22 @@ syntax context =
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:36.1-36.86
+;; 6-typing.watsup:37.1-37.86
 def $with_locals(context : context, localidx*, localtype*) : context
-  ;; 6-typing.watsup:38.1-38.34
+  ;; 6-typing.watsup:39.1-39.34
   def $with_locals{C : context}(C, [], []) = C
-  ;; 6-typing.watsup:39.1-39.90
+  ;; 6-typing.watsup:40.1-40.90
   def $with_locals{C : context, x_1 : idx, x* : idx*, lct_1 : localtype, lct* : localtype*}(C, [x_1] :: x*{x : localidx}, [lct_1] :: lct*{lct : localtype}) = $with_locals(C[LOCALS_context[x_1!`%`_idx.0] = lct_1], x*{x : localidx}, lct*{lct : localtype})
 }
 
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:45.1-45.94
+;; 6-typing.watsup:46.1-46.94
 def $clos_deftypes(deftype*) : deftype*
-  ;; 6-typing.watsup:52.1-52.30
+  ;; 6-typing.watsup:53.1-53.30
   def $clos_deftypes([]) = []
-  ;; 6-typing.watsup:53.1-53.101
+  ;; 6-typing.watsup:54.1-54.101
   def $clos_deftypes{dt* : deftype*, dt_n : deftype, dt'* : deftype*}(dt*{dt : deftype} :: [dt_n]) = dt'*{dt' : deftype} :: [$subst_all_deftype(dt_n, (dt' : deftype <: heaptype)*{dt' : deftype})]
     -- if (dt'*{dt' : deftype} = $clos_deftypes(dt*{dt : deftype}))
 }
@@ -19754,99 +20603,99 @@ relation Numtype_sub: `%|-%<:%`(context, numtype, numtype)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:140.1-140.107
+;; 6-typing.watsup:141.1-141.107
 relation Deftype_sub: `%|-%<:%`(context, deftype, deftype)
-  ;; 6-typing.watsup:451.1-453.66
+  ;; 6-typing.watsup:462.1-464.66
   rule refl{C : context, deftype_1 : deftype, deftype_2 : deftype}:
     `%|-%<:%`(C, deftype_1, deftype_2)
     -- if ($clos_deftype(C, deftype_1) = $clos_deftype(C, deftype_2))
 
-  ;; 6-typing.watsup:455.1-458.49
+  ;; 6-typing.watsup:466.1-469.49
   rule super{C : context, deftype_1 : deftype, deftype_2 : deftype, fin : fin, typeuse* : typeuse*, ct : comptype, i : nat}:
     `%|-%<:%`(C, deftype_1, deftype_2)
     -- if ($unrolldt(deftype_1) = SUB_subtype(fin, typeuse*{typeuse : typeuse}, ct))
     -- Heaptype_sub: `%|-%<:%`(C, (typeuse*{typeuse : typeuse}[i] : typeuse <: heaptype), (deftype_2 : deftype <: heaptype))
 
-;; 6-typing.watsup:288.1-288.104
+;; 6-typing.watsup:299.1-299.104
 relation Heaptype_sub: `%|-%<:%`(context, heaptype, heaptype)
-  ;; 6-typing.watsup:299.1-300.28
+  ;; 6-typing.watsup:310.1-311.28
   rule refl{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, heaptype, heaptype)
 
-  ;; 6-typing.watsup:302.1-306.48
+  ;; 6-typing.watsup:313.1-317.48
   rule trans{C : context, heaptype_1 : heaptype, heaptype_2 : heaptype, heaptype' : heaptype}:
     `%|-%<:%`(C, heaptype_1, heaptype_2)
     -- Heaptype_ok: `%|-%:OK`(C, heaptype')
     -- Heaptype_sub: `%|-%<:%`(C, heaptype_1, heaptype')
     -- Heaptype_sub: `%|-%<:%`(C, heaptype', heaptype_2)
 
-  ;; 6-typing.watsup:308.1-309.17
+  ;; 6-typing.watsup:319.1-320.17
   rule eq-any{C : context}:
     `%|-%<:%`(C, EQ_heaptype, ANY_heaptype)
 
-  ;; 6-typing.watsup:311.1-312.17
+  ;; 6-typing.watsup:322.1-323.17
   rule i31-eq{C : context}:
     `%|-%<:%`(C, I31_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:314.1-315.20
+  ;; 6-typing.watsup:325.1-326.20
   rule struct-eq{C : context}:
     `%|-%<:%`(C, STRUCT_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:317.1-318.19
+  ;; 6-typing.watsup:328.1-329.19
   rule array-eq{C : context}:
     `%|-%<:%`(C, ARRAY_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:320.1-322.42
+  ;; 6-typing.watsup:331.1-333.42
   rule struct{C : context, deftype : deftype, fieldtype* : fieldtype*}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), STRUCT_heaptype)
     -- Expand: `%~~%`(deftype, STRUCT_comptype(`%`_structtype(fieldtype*{fieldtype : fieldtype})))
 
-  ;; 6-typing.watsup:324.1-326.40
+  ;; 6-typing.watsup:335.1-337.40
   rule array{C : context, deftype : deftype, fieldtype : fieldtype}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), ARRAY_heaptype)
     -- Expand: `%~~%`(deftype, ARRAY_comptype(fieldtype))
 
-  ;; 6-typing.watsup:328.1-330.38
+  ;; 6-typing.watsup:339.1-341.38
   rule func{C : context, deftype : deftype, functype : functype}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), FUNC_heaptype)
     -- Expand: `%~~%`(deftype, FUNC_comptype(functype))
 
-  ;; 6-typing.watsup:332.1-334.46
+  ;; 6-typing.watsup:343.1-345.46
   rule def{C : context, deftype_1 : deftype, deftype_2 : deftype}:
     `%|-%<:%`(C, (deftype_1 : deftype <: heaptype), (deftype_2 : deftype <: heaptype))
     -- Deftype_sub: `%|-%<:%`(C, deftype_1, deftype_2)
 
-  ;; 6-typing.watsup:336.1-338.53
+  ;; 6-typing.watsup:347.1-349.53
   rule typeidx-l{C : context, typeidx : typeidx, heaptype : heaptype}:
     `%|-%<:%`(C, _IDX_heaptype(typeidx), heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, (C.TYPES_context[typeidx!`%`_typeidx.0] : deftype <: heaptype), heaptype)
 
-  ;; 6-typing.watsup:340.1-342.53
+  ;; 6-typing.watsup:351.1-353.53
   rule typeidx-r{C : context, heaptype : heaptype, typeidx : typeidx}:
     `%|-%<:%`(C, heaptype, _IDX_heaptype(typeidx))
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, (C.TYPES_context[typeidx!`%`_typeidx.0] : deftype <: heaptype))
 
-  ;; 6-typing.watsup:344.1-346.40
+  ;; 6-typing.watsup:355.1-357.40
   rule rec{C : context, i : nat, typeuse* : typeuse*, j : nat, fin : fin, ct : comptype}:
     `%|-%<:%`(C, REC_heaptype(i), (typeuse*{typeuse : typeuse}[j] : typeuse <: heaptype))
     -- if (C.RECS_context[i] = SUB_subtype(fin, typeuse*{typeuse : typeuse}, ct))
 
-  ;; 6-typing.watsup:348.1-350.40
+  ;; 6-typing.watsup:359.1-361.40
   rule none{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NONE_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, ANY_heaptype)
 
-  ;; 6-typing.watsup:352.1-354.41
+  ;; 6-typing.watsup:363.1-365.41
   rule nofunc{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NOFUNC_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, FUNC_heaptype)
 
-  ;; 6-typing.watsup:356.1-358.43
+  ;; 6-typing.watsup:367.1-369.43
   rule noextern{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NOEXTERN_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, EXTERN_heaptype)
 
-  ;; 6-typing.watsup:360.1-361.23
+  ;; 6-typing.watsup:371.1-372.23
   rule bot{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, BOT_heaptype, heaptype)
 }
@@ -19990,13 +20839,13 @@ relation Subtype_ok2: `%|-%:%`(context, subtype, oktypeidxnat)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:135.1-135.105
+;; 6-typing.watsup:136.1-136.105
 relation Rectype_ok2: `%|-%:%`(context, rectype, oktypeidxnat)
-  ;; 6-typing.watsup:213.1-214.24
+  ;; 6-typing.watsup:214.1-215.24
   rule empty{C : context, x : idx, i : nat}:
     `%|-%:%`(C, REC_rectype(`%`_list([])), OK_oktypeidxnat(x, i))
 
-  ;; 6-typing.watsup:216.1-219.55
+  ;; 6-typing.watsup:217.1-220.55
   rule cons{C : context, subtype_1 : subtype, subtype* : subtype*, x : idx, i : nat}:
     `%|-%:%`(C, REC_rectype(`%`_list([subtype_1] :: subtype*{subtype : subtype})), OK_oktypeidxnat(x, i))
     -- Subtype_ok2: `%|-%:%`(C, subtype_1, OK_oktypeidxnat(x, i))
@@ -20006,22 +20855,22 @@ relation Rectype_ok2: `%|-%:%`(context, rectype, oktypeidxnat)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:133.1-133.102
+;; 6-typing.watsup:134.1-134.102
 relation Rectype_ok: `%|-%:%`(context, rectype, oktypeidx)
-  ;; 6-typing.watsup:201.1-202.23
+  ;; 6-typing.watsup:202.1-203.23
   rule empty{C : context, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list([])), OK_oktypeidx(x))
 
-  ;; 6-typing.watsup:204.1-207.48
+  ;; 6-typing.watsup:205.1-208.48
   rule cons{C : context, subtype_1 : subtype, subtype* : subtype*, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list([subtype_1] :: subtype*{subtype : subtype})), OK_oktypeidx(x))
     -- Subtype_ok: `%|-%:%`(C, subtype_1, OK_oktypeidx(x))
     -- Rectype_ok: `%|-%:%`(C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidx(`%`_typeidx((x!`%`_idx.0 + 1))))
 
-  ;; 6-typing.watsup:209.1-211.60
+  ;; 6-typing.watsup:210.1-212.60
   rule rec2{C : context, subtype* : subtype*, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidx(x))
-    -- Rectype_ok2: `%|-%:%`({TYPES [], RECS subtype*{subtype : subtype}, FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []} ++ C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidxnat(x, 0))
+    -- Rectype_ok2: `%|-%:%`({TYPES [], RECS subtype*{subtype : subtype}, FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []} ++ C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidxnat(x, 0))
 }
 
 ;; 6-typing.watsup
@@ -20062,6 +20911,14 @@ relation Memtype_ok: `%|-%:OK`(context, memtype)
     `%|-%:OK`(C, `%PAGE`_memtype(limits))
     -- Limits_ok: `%|-%:%`(C, limits, (2 ^ 16))
 
+;; 6-typing.watsup
+relation Tagtype_ok: `%|-%:OK`(context, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, deftype : deftype, functype : functype}:
+    `%|-%:OK`(C, deftype)
+    -- Deftype_ok: `%|-%:OK`(C, deftype)
+    -- Expand: `%~~%`(deftype, FUNC_comptype(functype))
+
 ;; 6-typing.watsup
 relation Externtype_ok: `%|-%:OK`(context, externtype)
   ;; 6-typing.watsup
@@ -20085,6 +20942,11 @@ relation Externtype_ok: `%|-%:OK`(context, externtype)
     `%|-%:OK`(C, MEM_externtype(memtype))
     -- Memtype_ok: `%|-%:OK`(C, memtype)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, tagtype : tagtype}:
+    `%|-%:OK`(C, TAG_externtype((tagtype : deftype <: typeuse)))
+    -- Tagtype_ok: `%|-%:OK`(C, tagtype)
+
 ;; 6-typing.watsup
 relation Instrtype_sub: `%|-%<:%`(context, instrtype, instrtype)
   ;; 6-typing.watsup
@@ -20132,6 +20994,14 @@ relation Memtype_sub: `%|-%<:%`(context, memtype, memtype)
     `%|-%<:%`(C, `%PAGE`_memtype(limits_1), `%PAGE`_memtype(limits_2))
     -- Limits_sub: `%|-%<:%`(C, limits_1, limits_2)
 
+;; 6-typing.watsup
+relation Tagtype_sub: `%|-%<:%`(context, tagtype, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, deftype_1 : deftype, deftype_2 : deftype}:
+    `%|-%<:%`(C, deftype_1, deftype_2)
+    -- Deftype_sub: `%|-%<:%`(C, deftype_1, deftype_2)
+    -- Deftype_sub: `%|-%<:%`(C, deftype_2, deftype_1)
+
 ;; 6-typing.watsup
 relation Externtype_sub: `%|-%<:%`(context, externtype, externtype)
   ;; 6-typing.watsup
@@ -20154,6 +21024,11 @@ relation Externtype_sub: `%|-%<:%`(context, externtype, externtype)
     `%|-%<:%`(C, MEM_externtype(memtype_1), MEM_externtype(memtype_2))
     -- Memtype_sub: `%|-%<:%`(C, memtype_1, memtype_2)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, tagtype_1 : tagtype, tagtype_2 : tagtype}:
+    `%|-%<:%`(C, TAG_externtype((tagtype_1 : deftype <: typeuse)), TAG_externtype((tagtype_2 : deftype <: typeuse)))
+    -- Tagtype_sub: `%|-%<:%`(C, tagtype_1, tagtype_2)
+
 ;; 6-typing.watsup
 relation Blocktype_ok: `%|-%:%`(context, blocktype, instrtype)
   ;; 6-typing.watsup
@@ -20166,86 +21041,110 @@ relation Blocktype_ok: `%|-%:%`(context, blocktype, instrtype)
     `%|-%:%`(C, _IDX_blocktype(typeidx), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[typeidx!`%`_typeidx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
+;; 6-typing.watsup
+relation Catch_ok: `%|-%:OK`(context, catch)
+  ;; 6-typing.watsup
+  rule catch{C : context, x : idx, l : labelidx, t* : valtype*}:
+    `%|-%:OK`(C, CATCH_catch(x, l))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_ref{C : context, x : idx, l : labelidx, t* : valtype*}:
+    `%|-%:OK`(C, CATCH_REF_catch(x, l))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), EXN_heaptype)], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_all{C : context, l : labelidx}:
+    `%|-%:OK`(C, CATCH_ALL_catch(l))
+    -- Resulttype_sub: `%|-%<:%`(C, [], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_all_ref{C : context, l : labelidx}:
+    `%|-%:OK`(C, CATCH_ALL_REF_catch(l))
+    -- Resulttype_sub: `%|-%<:%`(C, [REF_valtype(`NULL%?`_nul(?()), EXN_heaptype)], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:522.1-522.95
+;; 6-typing.watsup:543.1-543.95
 relation Instr_ok: `%|-%:%`(context, instr, instrtype)
-  ;; 6-typing.watsup:561.1-562.24
+  ;; 6-typing.watsup:582.1-583.24
   rule nop{C : context}:
     `%|-%:%`(C, NOP_instr, `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
 
-  ;; 6-typing.watsup:564.1-566.42
+  ;; 6-typing.watsup:585.1-587.42
   rule unreachable{C : context, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, UNREACHABLE_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:568.1-570.29
+  ;; 6-typing.watsup:589.1-591.29
   rule drop{C : context, t : valtype}:
     `%|-%:%`(C, DROP_instr, `%->_%%`_instrtype(`%`_resulttype([t]), [], `%`_resulttype([])))
     -- Valtype_ok: `%|-%:OK`(C, t)
 
-  ;; 6-typing.watsup:573.1-575.29
+  ;; 6-typing.watsup:594.1-596.29
   rule select-expl{C : context, t : valtype}:
     `%|-%:%`(C, `SELECT()%?`_instr(?([t])), `%->_%%`_instrtype(`%`_resulttype([t t I32_valtype]), [], `%`_resulttype([t])))
     -- Valtype_ok: `%|-%:OK`(C, t)
 
-  ;; 6-typing.watsup:577.1-581.37
+  ;; 6-typing.watsup:598.1-602.37
   rule select-impl{C : context, t : valtype, t' : valtype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, `SELECT()%?`_instr(?()), `%->_%%`_instrtype(`%`_resulttype([t t I32_valtype]), [], `%`_resulttype([t])))
     -- Valtype_ok: `%|-%:OK`(C, t)
     -- Valtype_sub: `%|-%<:%`(C, t, t')
     -- if ((t' = (numtype : numtype <: valtype)) \/ (t' = (vectype : vectype <: valtype)))
 
-  ;; 6-typing.watsup:597.1-600.67
+  ;; 6-typing.watsup:618.1-621.67
   rule block{C : context, bt : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
     `%|-%:%`(C, BLOCK_instr(bt, instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:602.1-605.67
+  ;; 6-typing.watsup:623.1-626.67
   rule loop{C : context, bt : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
     `%|-%:%`(C, LOOP_instr(bt, instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_1*{t_1 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_1*{t_1 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:607.1-611.71
+  ;; 6-typing.watsup:628.1-632.71
   rule if{C : context, bt : blocktype, instr_1* : instr*, instr_2* : instr*, t_1* : valtype*, t_2* : valtype*, x_1* : idx*, x_2* : idx*}:
     `%|-%:%`(C, `IF%%ELSE%`_instr(bt, instr_1*{instr_1 : instr}, instr_2*{instr_2 : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_1*{instr_1 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_1*{instr_1 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:616.1-619.42
+  ;; 6-typing.watsup:637.1-640.42
   rule br{C : context, l : labelidx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, BR_instr(l), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:621.1-623.25
+  ;; 6-typing.watsup:642.1-644.25
   rule br_if{C : context, l : labelidx, t* : valtype*}:
     `%|-%:%`(C, BR_IF_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [I32_valtype]), [], `%`_resulttype(t*{t : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
 
-  ;; 6-typing.watsup:625.1-629.42
+  ;; 6-typing.watsup:646.1-650.42
   rule br_table{C : context, l* : labelidx*, l' : labelidx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, BR_TABLE_instr(l*{l : labelidx}, l'), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- (Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0))*{l : labelidx}
     -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l'!`%`_labelidx.0]!`%`_resulttype.0)
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:631.1-634.31
+  ;; 6-typing.watsup:652.1-655.31
   rule br_on_null{C : context, l : labelidx, t* : valtype*, ht : heaptype}:
     `%|-%:%`(C, BR_ON_NULL_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), ht)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:636.1-638.34
+  ;; 6-typing.watsup:657.1-659.34
   rule br_on_non_null{C : context, l : labelidx, t* : valtype*, ht : heaptype}:
     `%|-%:%`(C, BR_ON_NON_NULL_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype(t*{t : valtype})))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), ht)]))
 
-  ;; 6-typing.watsup:640.1-646.34
+  ;; 6-typing.watsup:661.1-667.34
   rule br_on_cast{C : context, l : labelidx, rt_1 : reftype, rt_2 : reftype, t* : valtype*, rt : reftype}:
     `%|-%:%`(C, BR_ON_CAST_instr(l, rt_1, rt_2), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [(rt_1 : reftype <: valtype)]), [], `%`_resulttype(t*{t : valtype} :: [($diffrt(rt_1, rt_2) : reftype <: valtype)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [(rt : reftype <: valtype)]))
@@ -20254,7 +21153,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt)
 
-  ;; 6-typing.watsup:648.1-654.49
+  ;; 6-typing.watsup:669.1-675.49
   rule br_on_cast_fail{C : context, l : labelidx, rt_1 : reftype, rt_2 : reftype, t* : valtype*, rt : reftype}:
     `%|-%:%`(C, BR_ON_CAST_FAIL_instr(l, rt_1, rt_2), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [(rt_1 : reftype <: valtype)]), [], `%`_resulttype(t*{t : valtype} :: [(rt_2 : reftype <: valtype)])))
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [(rt : reftype <: valtype)]))
@@ -20263,30 +21162,30 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
     -- Reftype_sub: `%|-%<:%`(C, $diffrt(rt_1, rt_2), rt)
 
-  ;; 6-typing.watsup:659.1-661.47
+  ;; 6-typing.watsup:680.1-682.47
   rule call{C : context, x : idx, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, CALL_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.FUNCS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:663.1-665.47
+  ;; 6-typing.watsup:684.1-686.47
   rule call_ref{C : context, x : idx, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, CALL_REF_instr(($idx(x) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:667.1-671.47
+  ;; 6-typing.watsup:688.1-692.47
   rule call_indirect{C : context, x : idx, y : idx, t_1* : valtype*, t_2* : valtype*, lim : limits, rt : reftype}:
     `%|-%:%`(C, CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
     -- Reftype_sub: `%|-%<:%`(C, rt, REF_reftype(`NULL%?`_nul(?(())), FUNC_heaptype))
     -- Expand: `%~~%`(C.TYPES_context[y!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:673.1-676.42
+  ;; 6-typing.watsup:694.1-697.42
   rule return{C : context, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, RETURN_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.RETURN_context = ?(`%`_list(t*{t : valtype})))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:679.1-684.42
+  ;; 6-typing.watsup:700.1-705.42
   rule return_call{C : context, x : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- Expand: `%~~%`(C.FUNCS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
@@ -20294,7 +21193,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:687.1-692.42
+  ;; 6-typing.watsup:708.1-713.42
   rule return_call_ref{C : context, x : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_REF_instr(($idx(x) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
@@ -20302,7 +21201,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:695.1-703.42
+  ;; 6-typing.watsup:716.1-724.42
   rule return_call_indirect{C : context, x : idx, y : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, lim : limits, rt : reftype, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
@@ -20312,452 +21211,470 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:708.1-709.33
+  ;; 6-typing.watsup:731.1-734.42
+  rule throw{C : context, x : idx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
+    `%|-%:%`(C, THROW_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+
+  ;; 6-typing.watsup:736.1-738.42
+  rule throw_ref{C : context, t_1* : valtype*, t_2* : valtype*}:
+    `%|-%:%`(C, THROW_REF_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), EXN_heaptype)]), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+
+  ;; 6-typing.watsup:740.1-744.34
+  rule try_table{C : context, bt : blocktype, catch* : catch*, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
+    `%|-%:%`(C, TRY_TABLE_instr(bt, `%`_list(catch*{catch : catch}), instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- (Catch_ok: `%|-%:OK`(C, catch))*{catch : catch}
+
+  ;; 6-typing.watsup:767.1-768.33
   rule const{C : context, nt : numtype, c_nt : num_(nt)}:
     `%|-%:%`(C, CONST_instr(nt, c_nt), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:711.1-712.34
+  ;; 6-typing.watsup:770.1-771.34
   rule unop{C : context, nt : numtype, unop_nt : unop_(nt)}:
     `%|-%:%`(C, UNOP_instr(nt, unop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype)]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:714.1-715.39
+  ;; 6-typing.watsup:773.1-774.39
   rule binop{C : context, nt : numtype, binop_nt : binop_(nt)}:
     `%|-%:%`(C, BINOP_instr(nt, binop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype) (nt : numtype <: valtype)]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:717.1-718.39
+  ;; 6-typing.watsup:776.1-777.39
   rule testop{C : context, nt : numtype, testop_nt : testop_(nt)}:
     `%|-%:%`(C, TESTOP_instr(nt, testop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:720.1-721.40
+  ;; 6-typing.watsup:779.1-780.40
   rule relop{C : context, nt : numtype, relop_nt : relop_(nt)}:
     `%|-%:%`(C, RELOP_instr(nt, relop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype) (nt : numtype <: valtype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:723.1-724.44
+  ;; 6-typing.watsup:782.1-783.44
   rule cvtop{C : context, nt_1 : numtype, nt_2 : numtype, cvtop : cvtop__(nt_2, nt_1)}:
     `%|-%:%`(C, CVTOP_instr(nt_1, nt_2, cvtop), `%->_%%`_instrtype(`%`_resulttype([(nt_2 : numtype <: valtype)]), [], `%`_resulttype([(nt_1 : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:729.1-731.31
+  ;; 6-typing.watsup:788.1-790.31
   rule ref.null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.NULL_instr(ht), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:733.1-736.20
+  ;; 6-typing.watsup:792.1-795.20
   rule ref.func{C : context, x : idx, dt : deftype}:
     `%|-%:%`(C, REF.FUNC_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), (dt : deftype <: heaptype))])))
     -- if (C.FUNCS_context[x!`%`_idx.0] = dt)
     -- if x <- C.REFS_context
 
-  ;; 6-typing.watsup:738.1-739.34
+  ;; 6-typing.watsup:797.1-798.34
   rule ref.i31{C : context}:
     `%|-%:%`(C, REF.I31_instr, `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), I31_heaptype)])))
 
-  ;; 6-typing.watsup:741.1-743.31
+  ;; 6-typing.watsup:800.1-802.31
   rule ref.is_null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.IS_NULL_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype([I32_valtype])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:745.1-747.31
+  ;; 6-typing.watsup:804.1-806.31
   rule ref.as_non_null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.AS_NON_NULL_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ht)])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:749.1-750.51
+  ;; 6-typing.watsup:808.1-809.51
   rule ref.eq{C : context}:
     `%|-%:%`(C, REF.EQ_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), EQ_heaptype) REF_valtype(`NULL%?`_nul(?(())), EQ_heaptype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:752.1-756.33
+  ;; 6-typing.watsup:811.1-815.33
   rule ref.test{C : context, rt : reftype, rt' : reftype}:
     `%|-%:%`(C, REF.TEST_instr(rt), `%->_%%`_instrtype(`%`_resulttype([(rt' : reftype <: valtype)]), [], `%`_resulttype([I32_valtype])))
     -- Reftype_ok: `%|-%:OK`(C, rt)
     -- Reftype_ok: `%|-%:OK`(C, rt')
     -- Reftype_sub: `%|-%<:%`(C, rt, rt')
 
-  ;; 6-typing.watsup:758.1-762.33
+  ;; 6-typing.watsup:817.1-821.33
   rule ref.cast{C : context, rt : reftype, rt' : reftype}:
     `%|-%:%`(C, REF.CAST_instr(rt), `%->_%%`_instrtype(`%`_resulttype([(rt' : reftype <: valtype)]), [], `%`_resulttype([(rt : reftype <: valtype)])))
     -- Reftype_ok: `%|-%:OK`(C, rt)
     -- Reftype_ok: `%|-%:OK`(C, rt')
     -- Reftype_sub: `%|-%<:%`(C, rt, rt')
 
-  ;; 6-typing.watsup:767.1-768.42
+  ;; 6-typing.watsup:826.1-827.42
   rule i31.get{C : context, sx : sx}:
     `%|-%:%`(C, I31.GET_instr(sx), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), I31_heaptype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:773.1-775.44
+  ;; 6-typing.watsup:832.1-834.44
   rule struct.new{C : context, x : idx, zt* : storagetype*, mut* : mut*}:
     `%|-%:%`(C, STRUCT.NEW_instr(x), `%->_%%`_instrtype(`%`_resulttype($unpack(zt)*{zt : storagetype}), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
 
-  ;; 6-typing.watsup:777.1-780.40
+  ;; 6-typing.watsup:836.1-839.40
   rule struct.new_default{C : context, x : idx, mut* : mut*, zt* : storagetype*, val* : val*}:
     `%|-%:%`(C, STRUCT.NEW_DEFAULT_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
     -- (if ($default_($unpack(zt)) = ?(val)))*{val : val, zt : storagetype}
 
-  ;; 6-typing.watsup:782.1-786.39
+  ;; 6-typing.watsup:841.1-845.39
   rule struct.get{C : context, sx? : sx?, x : idx, i : nat, zt : storagetype, yt* : fieldtype*, mut : mut}:
     `%|-%:%`(C, STRUCT.GET_instr(sx?{sx : sx}, x, `%`_u32(i)), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype([$unpack(zt)])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})))
     -- if (yt*{yt : fieldtype}[i] = `%%`_fieldtype(mut, zt))
     -- if ((sx?{sx : sx} = ?()) <=> (zt = ($unpack(zt) : valtype <: storagetype)))
 
-  ;; 6-typing.watsup:788.1-791.24
+  ;; 6-typing.watsup:847.1-850.24
   rule struct.set{C : context, x : idx, i : nat, zt : storagetype, yt* : fieldtype*}:
     `%|-%:%`(C, STRUCT.SET_instr(x, `%`_u32(i)), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) $unpack(zt)]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})))
     -- if (yt*{yt : fieldtype}[i] = `%%`_fieldtype(`MUT%?`_mut(?(())), zt))
 
-  ;; 6-typing.watsup:796.1-798.42
+  ;; 6-typing.watsup:855.1-857.42
   rule array.new{C : context, x : idx, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.NEW_instr(x), `%->_%%`_instrtype(`%`_resulttype([$unpack(zt) I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 6-typing.watsup:800.1-803.37
+  ;; 6-typing.watsup:859.1-862.37
   rule array.new_default{C : context, x : idx, mut : mut, zt : storagetype, val : val}:
     `%|-%:%`(C, ARRAY.NEW_DEFAULT_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ($default_($unpack(zt)) = ?(val))
 
-  ;; 6-typing.watsup:805.1-807.42
+  ;; 6-typing.watsup:864.1-866.42
   rule array.new_fixed{C : context, x : idx, n : n, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.NEW_FIXED_instr(x, `%`_u32(n)), `%->_%%`_instrtype(`%`_resulttype($unpack(zt)^n{}), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 6-typing.watsup:809.1-812.40
+  ;; 6-typing.watsup:868.1-871.40
   rule array.new_elem{C : context, x : idx, y : idx, mut : mut, rt : reftype}:
     `%|-%:%`(C, ARRAY.NEW_ELEM_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, (rt : reftype <: storagetype))))
     -- Reftype_sub: `%|-%<:%`(C, C.ELEMS_context[y!`%`_idx.0], rt)
 
-  ;; 6-typing.watsup:814.1-818.24
+  ;; 6-typing.watsup:873.1-877.24
   rule array.new_data{C : context, x : idx, y : idx, mut : mut, zt : storagetype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, ARRAY.NEW_DATA_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if (($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:820.1-823.39
+  ;; 6-typing.watsup:879.1-882.39
   rule array.get{C : context, sx? : sx?, x : idx, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.GET_instr(sx?{sx : sx}, x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype]), [], `%`_resulttype([$unpack(zt)])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ((sx?{sx : sx} = ?()) <=> (zt = ($unpack(zt) : valtype <: storagetype)))
 
-  ;; 6-typing.watsup:825.1-827.42
+  ;; 6-typing.watsup:884.1-886.42
   rule array.set{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype $unpack(zt)]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:829.1-831.42
+  ;; 6-typing.watsup:888.1-890.42
   rule array.len{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.LEN_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ARRAY_heaptype)]), [], `%`_resulttype([I32_valtype])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:833.1-835.42
+  ;; 6-typing.watsup:892.1-894.42
   rule array.fill{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype $unpack(zt) I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:837.1-841.40
+  ;; 6-typing.watsup:896.1-900.40
   rule array.copy{C : context, x_1 : idx, x_2 : idx, zt_1 : storagetype, mut : mut, zt_2 : storagetype}:
     `%|-%:%`(C, ARRAY.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x_1) : typevar <: heaptype)) I32_valtype REF_valtype(`NULL%?`_nul(?(())), ($idx(x_2) : typevar <: heaptype)) I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x_1!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt_1)))
     -- Expand: `%~~%`(C.TYPES_context[x_2!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt_2)))
     -- Storagetype_sub: `%|-%<:%`(C, zt_2, zt_1)
 
-  ;; 6-typing.watsup:843.1-846.44
+  ;; 6-typing.watsup:902.1-905.44
   rule array.init_elem{C : context, x : idx, y : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.INIT_ELEM_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
     -- Storagetype_sub: `%|-%<:%`(C, (C.ELEMS_context[y!`%`_idx.0] : reftype <: storagetype), zt)
 
-  ;; 6-typing.watsup:848.1-852.24
+  ;; 6-typing.watsup:907.1-911.24
   rule array.init_data{C : context, x : idx, y : idx, zt : storagetype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, ARRAY.INIT_DATA_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
     -- if (($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:857.1-858.62
+  ;; 6-typing.watsup:916.1-917.62
   rule extern.convert_any{C : context, nul : nul}:
     `%|-%:%`(C, EXTERN.CONVERT_ANY_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(nul, ANY_heaptype)]), [], `%`_resulttype([REF_valtype(nul, EXTERN_heaptype)])))
 
-  ;; 6-typing.watsup:860.1-861.62
+  ;; 6-typing.watsup:919.1-920.62
   rule any.convert_extern{C : context, nul : nul}:
     `%|-%:%`(C, ANY.CONVERT_EXTERN_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(nul, EXTERN_heaptype)]), [], `%`_resulttype([REF_valtype(nul, ANY_heaptype)])))
 
-  ;; 6-typing.watsup:866.1-867.35
+  ;; 6-typing.watsup:925.1-926.35
   rule vconst{C : context, c : vec_(V128_Vnn)}:
     `%|-%:%`(C, VCONST_instr(V128_vectype, c), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:869.1-870.41
+  ;; 6-typing.watsup:928.1-929.41
   rule vvunop{C : context, vvunop : vvunop}:
     `%|-%:%`(C, VVUNOP_instr(V128_vectype, vvunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:872.1-873.48
+  ;; 6-typing.watsup:931.1-932.48
   rule vvbinop{C : context, vvbinop : vvbinop}:
     `%|-%:%`(C, VVBINOP_instr(V128_vectype, vvbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:875.1-876.55
+  ;; 6-typing.watsup:934.1-935.55
   rule vvternop{C : context, vvternop : vvternop}:
     `%|-%:%`(C, VVTERNOP_instr(V128_vectype, vvternop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:878.1-879.44
+  ;; 6-typing.watsup:937.1-938.44
   rule vvtestop{C : context, vvtestop : vvtestop}:
     `%|-%:%`(C, VVTESTOP_instr(V128_vectype, vvtestop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:881.1-882.37
+  ;; 6-typing.watsup:940.1-941.37
   rule vunop{C : context, sh : shape, vunop : vunop_(sh)}:
     `%|-%:%`(C, VUNOP_instr(sh, vunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:884.1-885.44
+  ;; 6-typing.watsup:943.1-944.44
   rule vbinop{C : context, sh : shape, vbinop : vbinop_(sh)}:
     `%|-%:%`(C, VBINOP_instr(sh, vbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:887.1-888.40
+  ;; 6-typing.watsup:946.1-947.40
   rule vtestop{C : context, sh : shape, vtestop : vtestop_(sh)}:
     `%|-%:%`(C, VTESTOP_instr(sh, vtestop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:890.1-891.44
+  ;; 6-typing.watsup:949.1-950.44
   rule vrelop{C : context, sh : shape, vrelop : vrelop_(sh)}:
     `%|-%:%`(C, VRELOP_instr(sh, vrelop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:893.1-894.47
+  ;; 6-typing.watsup:952.1-953.47
   rule vshiftop{C : context, sh : ishape, vshiftop : vshiftop_(sh)}:
     `%|-%:%`(C, VSHIFTOP_instr(sh, vshiftop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype I32_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:896.1-897.33
+  ;; 6-typing.watsup:955.1-956.33
   rule vbitmask{C : context, sh : ishape}:
     `%|-%:%`(C, VBITMASK_instr(sh), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:899.1-900.39
+  ;; 6-typing.watsup:958.1-959.39
   rule vswizzle{C : context, sh : ishape}:
     `%|-%:%`(C, VSWIZZLE_instr(sh), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:902.1-904.29
+  ;; 6-typing.watsup:961.1-963.29
   rule vshuffle{C : context, sh : ishape, i* : nat*}:
     `%|-%:%`(C, VSHUFFLE_instr(sh, `%`_laneidx(i)*{i : nat}), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
     -- (if (i < (2 * $dim((sh : ishape <: shape))!`%`_dim.0)))*{i : nat}
 
-  ;; 6-typing.watsup:906.1-907.44
+  ;; 6-typing.watsup:965.1-966.44
   rule vsplat{C : context, sh : shape}:
     `%|-%:%`(C, VSPLAT_instr(sh), `%->_%%`_instrtype(`%`_resulttype([($unpackshape(sh) : numtype <: valtype)]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:909.1-911.21
+  ;; 6-typing.watsup:968.1-970.21
   rule vextract_lane{C : context, sh : shape, sx? : sx?, i : nat}:
     `%|-%:%`(C, VEXTRACT_LANE_instr(sh, sx?{sx : sx}, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([($unpackshape(sh) : numtype <: valtype)])))
     -- if (i < $dim(sh)!`%`_dim.0)
 
-  ;; 6-typing.watsup:913.1-915.21
+  ;; 6-typing.watsup:972.1-974.21
   rule vreplace_lane{C : context, sh : shape, i : nat}:
     `%|-%:%`(C, VREPLACE_LANE_instr(sh, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([V128_valtype ($unpackshape(sh) : numtype <: valtype)]), [], `%`_resulttype([V128_valtype])))
     -- if (i < $dim(sh)!`%`_dim.0)
 
-  ;; 6-typing.watsup:917.1-918.50
+  ;; 6-typing.watsup:976.1-977.50
   rule vextunop{C : context, sh_1 : ishape, sh_2 : ishape, vextunop : vextunop__(sh_2, sh_1)}:
     `%|-%:%`(C, VEXTUNOP_instr(sh_1, sh_2, vextunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:920.1-921.57
+  ;; 6-typing.watsup:979.1-980.57
   rule vextbinop{C : context, sh_1 : ishape, sh_2 : ishape, vextbinop : vextbinop__(sh_2, sh_1)}:
     `%|-%:%`(C, VEXTBINOP_instr(sh_1, sh_2, vextbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:923.1-924.48
+  ;; 6-typing.watsup:982.1-983.48
   rule vnarrow{C : context, sh_1 : ishape, sh_2 : ishape, sx : sx}:
     `%|-%:%`(C, VNARROW_instr(sh_1, sh_2, sx), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:926.1-927.58
+  ;; 6-typing.watsup:985.1-986.58
   rule vcvtop{C : context, sh_1 : shape, sh_2 : shape, vcvtop : vcvtop__(sh_2, sh_1), half? : half__(sh_2, sh_1)?, zero? : zero__(sh_2, sh_1)?}:
     `%|-%:%`(C, VCVTOP_instr(sh_1, sh_2, vcvtop, half?{half : half__(sh_2, sh_1)}, zero?{zero : zero__(sh_2, sh_1)}), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:932.1-934.28
+  ;; 6-typing.watsup:991.1-993.28
   rule local.get{C : context, x : idx, t : valtype}:
     `%|-%:%`(C, LOCAL.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([t])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(SET_init, t))
 
-  ;; 6-typing.watsup:936.1-938.29
+  ;; 6-typing.watsup:995.1-997.29
   rule local.set{C : context, x : idx, t : valtype, init : init}:
     `%|-%:%`(C, LOCAL.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [x], `%`_resulttype([])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(init, t))
 
-  ;; 6-typing.watsup:940.1-942.29
+  ;; 6-typing.watsup:999.1-1001.29
   rule local.tee{C : context, x : idx, t : valtype, init : init}:
     `%|-%:%`(C, LOCAL.TEE_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [x], `%`_resulttype([t])))
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(init, t))
 
-  ;; 6-typing.watsup:947.1-949.29
+  ;; 6-typing.watsup:1006.1-1008.29
   rule global.get{C : context, x : idx, t : valtype, mut : mut}:
     `%|-%:%`(C, GLOBAL.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([t])))
     -- if (C.GLOBALS_context[x!`%`_idx.0] = `%%`_globaltype(mut, t))
 
-  ;; 6-typing.watsup:951.1-953.29
+  ;; 6-typing.watsup:1010.1-1012.29
   rule global.set{C : context, x : idx, t : valtype}:
     `%|-%:%`(C, GLOBAL.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [], `%`_resulttype([])))
     -- if (C.GLOBALS_context[x!`%`_idx.0] = `%%`_globaltype(`MUT%?`_mut(?(())), t))
 
-  ;; 6-typing.watsup:958.1-960.29
+  ;; 6-typing.watsup:1017.1-1019.29
   rule table.get{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(rt : reftype <: valtype)])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:962.1-964.29
+  ;; 6-typing.watsup:1021.1-1023.29
   rule table.set{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (rt : reftype <: valtype)]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:966.1-968.29
+  ;; 6-typing.watsup:1025.1-1027.29
   rule table.size{C : context, x : idx, lim : limits, rt : reftype}:
     `%|-%:%`(C, TABLE.SIZE_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([I32_valtype])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:970.1-972.29
+  ;; 6-typing.watsup:1029.1-1031.29
   rule table.grow{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.GROW_instr(x), `%->_%%`_instrtype(`%`_resulttype([(rt : reftype <: valtype) I32_valtype]), [], `%`_resulttype([I32_valtype])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:974.1-976.29
+  ;; 6-typing.watsup:1033.1-1035.29
   rule table.fill{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (rt : reftype <: valtype) I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:978.1-982.36
+  ;; 6-typing.watsup:1037.1-1041.36
   rule table.copy{C : context, x_1 : idx, x_2 : idx, lim_1 : limits, rt_1 : reftype, lim_2 : limits, rt_2 : reftype}:
     `%|-%:%`(C, TABLE.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x_1!`%`_idx.0] = `%%`_tabletype(lim_1, rt_1))
     -- if (C.TABLES_context[x_2!`%`_idx.0] = `%%`_tabletype(lim_2, rt_2))
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
 
-  ;; 6-typing.watsup:984.1-988.36
+  ;; 6-typing.watsup:1043.1-1047.36
   rule table.init{C : context, x : idx, y : idx, lim : limits, rt_1 : reftype, rt_2 : reftype}:
     `%|-%:%`(C, TABLE.INIT_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt_1))
     -- if (C.ELEMS_context[y!`%`_idx.0] = rt_2)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
 
-  ;; 6-typing.watsup:990.1-992.24
+  ;; 6-typing.watsup:1049.1-1051.24
   rule elem.drop{C : context, x : idx, rt : reftype}:
     `%|-%:%`(C, ELEM.DROP_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
     -- if (C.ELEMS_context[x!`%`_idx.0] = rt)
 
-  ;; 6-typing.watsup:997.1-999.23
+  ;; 6-typing.watsup:1056.1-1058.23
   rule memory.size{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.SIZE_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([I32_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1001.1-1003.23
+  ;; 6-typing.watsup:1060.1-1062.23
   rule memory.grow{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.GROW_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([I32_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1005.1-1007.23
+  ;; 6-typing.watsup:1064.1-1066.23
   rule memory.fill{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1009.1-1012.27
+  ;; 6-typing.watsup:1068.1-1071.27
   rule memory.copy{C : context, x_1 : idx, x_2 : idx, mt_1 : memtype, mt_2 : memtype}:
     `%|-%:%`(C, MEMORY.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x_1!`%`_idx.0] = mt_1)
     -- if (C.MEMS_context[x_2!`%`_idx.0] = mt_2)
 
-  ;; 6-typing.watsup:1014.1-1017.24
+  ;; 6-typing.watsup:1073.1-1076.24
   rule memory.init{C : context, x : idx, y : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.INIT_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:1019.1-1021.24
+  ;; 6-typing.watsup:1078.1-1080.24
   rule data.drop{C : context, x : idx}:
     `%|-%:%`(C, DATA.DROP_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
     -- if (C.DATAS_context[x!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:1032.1-1035.43
+  ;; 6-typing.watsup:1091.1-1094.43
   rule load-val{C : context, nt : numtype, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, LOAD_instr(nt, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(nt : numtype <: valtype)])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($size(nt) / 8))
 
-  ;; 6-typing.watsup:1037.1-1040.35
+  ;; 6-typing.watsup:1096.1-1099.35
   rule load-pack{C : context, Inn : Inn, M : M, sx : sx, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, LOAD_instr((Inn : Inn <: numtype), ?(`%%`_loadop_(`%`_sz(M), sx)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(Inn : Inn <: valtype)])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (M / 8))
 
-  ;; 6-typing.watsup:1051.1-1054.43
+  ;; 6-typing.watsup:1110.1-1113.43
   rule store-val{C : context, nt : numtype, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, STORE_instr(nt, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (nt : numtype <: valtype)]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($size(nt) / 8))
 
-  ;; 6-typing.watsup:1056.1-1059.35
+  ;; 6-typing.watsup:1115.1-1118.35
   rule store-pack{C : context, Inn : Inn, M : M, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, STORE_instr((Inn : Inn <: numtype), ?(`%`_sz(M)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (Inn : Inn <: valtype)]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (M / 8))
 
-  ;; 6-typing.watsup:1061.1-1064.46
+  ;; 6-typing.watsup:1120.1-1123.46
   rule vload-val{C : context, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($vsize(V128_vectype) / 8))
 
-  ;; 6-typing.watsup:1066.1-1069.39
+  ;; 6-typing.watsup:1125.1-1128.39
   rule vload-pack{C : context, M : M, N : N, sx : sx, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(M), N, sx)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ((M / 8) * N))
 
-  ;; 6-typing.watsup:1071.1-1074.35
+  ;; 6-typing.watsup:1130.1-1133.35
   rule vload-splat{C : context, N : N, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(N))), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
 
-  ;; 6-typing.watsup:1076.1-1079.35
+  ;; 6-typing.watsup:1135.1-1138.35
   rule vload-zero{C : context, N : N, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(N))), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
 
-  ;; 6-typing.watsup:1081.1-1085.21
+  ;; 6-typing.watsup:1140.1-1144.21
   rule vload_lane{C : context, N : N, x : idx, memarg : memarg, i : nat, mt : memtype}:
     `%|-%:%`(C, VLOAD_LANE_instr(V128_vectype, `%`_sz(N), x, memarg, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
     -- if (i < (128 / N))
 
-  ;; 6-typing.watsup:1087.1-1090.46
+  ;; 6-typing.watsup:1146.1-1149.46
   rule vstore{C : context, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VSTORE_instr(V128_vectype, x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($vsize(V128_vectype) / 8))
 
-  ;; 6-typing.watsup:1092.1-1096.21
+  ;; 6-typing.watsup:1151.1-1155.21
   rule vstore_lane{C : context, N : N, x : idx, memarg : memarg, i : nat, mt : memtype}:
     `%|-%:%`(C, VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, memarg, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([])))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
     -- if (i < (128 / N))
 
-;; 6-typing.watsup:523.1-523.96
+;; 6-typing.watsup:544.1-544.96
 relation Instrs_ok: `%|-%:%`(context, instr*, instrtype)
-  ;; 6-typing.watsup:536.1-537.24
+  ;; 6-typing.watsup:557.1-558.24
   rule empty{C : context}:
     `%|-%:%`(C, [], `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
 
-  ;; 6-typing.watsup:540.1-544.82
+  ;; 6-typing.watsup:561.1-565.82
   rule seq{C : context, instr_1 : instr, instr_2* : instr*, t_1* : valtype*, x_1* : idx*, x_2* : idx*, t_3* : valtype*, t_2* : valtype*, init* : init*, t* : valtype*}:
     `%|-%:%`(C, [instr_1] :: instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx} :: x_2*{x_2 : localidx}, `%`_resulttype(t_3*{t_3 : valtype})))
     -- Instr_ok: `%|-%:%`(C, instr_1, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
     -- (if (C.LOCALS_context[x_1!`%`_idx.0] = `%%`_localtype(init, t)))*{init : init, t : valtype, x_1 : idx}
     -- Instrs_ok: `%|-%:%`($with_locals(C, x_1*{x_1 : localidx}, `%%`_localtype(SET_init, t)*{t : valtype}), instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_2*{t_2 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_3*{t_3 : valtype})))
 
-  ;; 6-typing.watsup:546.1-550.33
+  ;; 6-typing.watsup:567.1-571.33
   rule sub{C : context, instr* : instr*, it' : instrtype, it : instrtype}:
     `%|-%:%`(C, instr*{instr : instr}, it')
     -- Instrs_ok: `%|-%:%`(C, instr*{instr : instr}, it)
     -- Instrtype_sub: `%|-%<:%`(C, it, it')
     -- Instrtype_ok: `%|-%:OK`(C, it')
 
-  ;; 6-typing.watsup:553.1-556.33
+  ;; 6-typing.watsup:574.1-577.33
   rule frame{C : context, instr* : instr*, t* : valtype*, t_1* : valtype*, x* : idx*, t_2* : valtype*}:
     `%|-%:%`(C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t*{t : valtype} :: t_2*{t_2 : valtype})))
     -- Instrs_ok: `%|-%:%`(C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
@@ -20854,7 +21771,7 @@ relation Type_ok: `%|-%:%`(context, type, deftype*)
     `%|-%:%`(C, TYPE_type(rectype), dt*{dt : deftype})
     -- if (x = `%`_idx(|C.TYPES_context|))
     -- if (dt*{dt : deftype} = $rolldt(x, rectype))
-    -- Rectype_ok: `%|-%:%`(C ++ {TYPES dt*{dt : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rectype, OK_oktypeidx(x))
+    -- Rectype_ok: `%|-%:%`(C ++ {TYPES dt*{dt : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rectype, OK_oktypeidx(x))
 
 ;; 6-typing.watsup
 relation Local_ok: `%|-%:%`(context, local, localtype)
@@ -20875,7 +21792,7 @@ relation Func_ok: `%|-%:%`(context, func, deftype)
     `%|-%:%`(C, FUNC_func(x, local*{local : local}, expr), C.TYPES_context[x!`%`_idx.0])
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
     -- (Local_ok: `%|-%:%`(C, local, lct))*{lct : localtype, local : local}
-    -- Expr_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS `%%`_localtype(SET_init, t_1)*{t_1 : valtype} :: lct*{lct : localtype}, LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(`%`_resulttype(t_2*{t_2 : valtype})), REFS []}, expr, `%`_resulttype(t_2*{t_2 : valtype}))
+    -- Expr_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS `%%`_localtype(SET_init, t_1)*{t_1 : valtype} :: lct*{lct : localtype}, LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(`%`_resulttype(t_2*{t_2 : valtype})), REFS []}, expr, `%`_resulttype(t_2*{t_2 : valtype}))
 
 ;; 6-typing.watsup
 relation Global_ok: `%|-%:%`(context, global, globaltype)
@@ -20902,6 +21819,13 @@ relation Mem_ok: `%|-%:%`(context, mem, memtype)
     `%|-%:%`(C, MEMORY_mem(memtype), memtype)
     -- Memtype_ok: `%|-%:OK`(C, memtype)
 
+;; 6-typing.watsup
+relation Tag_ok: `%|-%:%`(context, tag, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, x : idx, functype : functype}:
+    `%|-%:%`(C, TAG_tag(x), C.TYPES_context[x!`%`_idx.0])
+    -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(functype))
+
 ;; 6-typing.watsup
 relation Elemmode_ok: `%|-%:%`(context, elemmode, elemtype)
   ;; 6-typing.watsup
@@ -20983,6 +21907,11 @@ relation Externidx_ok: `%|-%:%`(context, externidx, externtype)
     `%|-%:%`(C, MEM_externidx(x), MEM_externtype(mt))
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, x : idx, at : tagtype}:
+    `%|-%:%`(C, TAG_externidx(x), TAG_externtype((at : deftype <: typeuse)))
+    -- if (C.TAGS_context[x!`%`_idx.0] = at)
+
 ;; 6-typing.watsup
 relation Export_ok: `%|-%:%%`(context, export, name, externtype)
   ;; 6-typing.watsup
@@ -20993,33 +21922,33 @@ relation Export_ok: `%|-%:%%`(context, export, name, externtype)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:1288.1-1288.100
+;; 6-typing.watsup:1356.1-1356.100
 relation Globals_ok: `%|-%:%`(context, global*, globaltype*)
-  ;; 6-typing.watsup:1330.1-1331.17
+  ;; 6-typing.watsup:1400.1-1401.17
   rule empty{C : context}:
     `%|-%:%`(C, [], [])
 
-  ;; 6-typing.watsup:1333.1-1336.54
+  ;; 6-typing.watsup:1403.1-1406.54
   rule cons{C : context, global_1 : global, global : global, gt_1 : globaltype, gt* : globaltype*}:
     `%|-%:%`(C, [global_1] :: global*{}, [gt_1] :: gt*{gt : globaltype})
     -- Global_ok: `%|-%:%`(C, global, gt_1)
-    -- Globals_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [gt_1], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, global*{}, gt*{gt : globaltype})
+    -- Globals_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [gt_1], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, global*{}, gt*{gt : globaltype})
 }
 
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:1287.1-1287.98
+;; 6-typing.watsup:1355.1-1355.98
 relation Types_ok: `%|-%:%`(context, type*, deftype*)
-  ;; 6-typing.watsup:1322.1-1323.17
+  ;; 6-typing.watsup:1392.1-1393.17
   rule empty{C : context}:
     `%|-%:%`(C, [], [])
 
-  ;; 6-typing.watsup:1325.1-1328.49
+  ;; 6-typing.watsup:1395.1-1398.49
   rule cons{C : context, type_1 : type, type* : type*, dt_1* : deftype*, dt* : deftype*}:
     `%|-%:%`(C, [type_1] :: type*{type : type}, dt_1*{dt_1 : deftype} :: dt*{dt : deftype})
     -- Type_ok: `%|-%:%`(C, type_1, dt_1*{dt_1 : deftype})
-    -- Types_ok: `%|-%:%`(C ++ {TYPES dt_1*{dt_1 : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt*{dt : deftype})
+    -- Types_ok: `%|-%:%`(C ++ {TYPES dt_1*{dt_1 : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt*{dt : deftype})
 }
 
 ;; 6-typing.watsup
@@ -21029,31 +21958,33 @@ syntax nonfuncs =
 ;; 6-typing.watsup
 def $funcidx_nonfuncs(nonfuncs : nonfuncs) : funcidx*
   ;; 6-typing.watsup
-  def $funcidx_nonfuncs{global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*}(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})) = $funcidx_module(MODULE_module([], [], [], global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, ?(), []))
+  def $funcidx_nonfuncs{global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*}(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})) = $funcidx_module(MODULE_module([], [], [], global*{global : global}, table*{table : table}, mem*{mem : mem}, [], elem*{elem : elem}, data*{data : data}, ?(), []))
 
 ;; 6-typing.watsup
 relation Module_ok: `|-%:%`(module, moduletype)
   ;; 6-typing.watsup
-  rule _{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, C : context, xt_I* : externtype*, xt_E* : externtype*, dt'* : deftype*, C' : context, gt* : globaltype*, tt* : tabletype*, mt* : memtype*, dt* : deftype*, rt* : reftype*, ok* : datatype*, nm* : name*, dt_I* : deftype*, gt_I* : globaltype*, tt_I* : tabletype*, mt_I* : memtype*, x* : idx*}:
-    `|-%:%`(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}), $clos_moduletype(C, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype})))
-    -- Types_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt'*{dt' : deftype})
-    -- (Import_ok: `%|-%:%`({TYPES dt'*{dt' : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, import, xt_I))*{import : import, xt_I : externtype}
+  rule _{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, C : context, xt_I* : externtype*, xt_E* : externtype*, dt'* : deftype*, C' : context, gt* : globaltype*, tt* : tabletype*, mt* : memtype*, at* : tagtype*, dt* : deftype*, rt* : reftype*, ok* : datatype*, nm* : name*, dt_I* : deftype*, gt_I* : globaltype*, tt_I* : tabletype*, mt_I* : memtype*, at_I* : tagtype*, x* : idx*}:
+    `|-%:%`(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}), $clos_moduletype(C, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype})))
+    -- Types_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt'*{dt' : deftype})
+    -- (Import_ok: `%|-%:%`({TYPES dt'*{dt' : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, import, xt_I))*{import : import, xt_I : externtype}
     -- Globals_ok: `%|-%:%`(C', global*{global : global}, gt*{gt : globaltype})
     -- (Table_ok: `%|-%:%`(C', table, tt))*{table : table, tt : tabletype}
     -- (Mem_ok: `%|-%:%`(C', mem, mt))*{mem : mem, mt : memtype}
+    -- (Tag_ok: `%|-%:%`(C', tag, at))*{at : tagtype, tag : tag}
     -- (Func_ok: `%|-%:%`(C, func, dt))*{dt : deftype, func : func}
     -- (Elem_ok: `%|-%:%`(C, elem, rt))*{elem : elem, rt : elemtype}
     -- (Data_ok: `%|-%:%`(C, data, ok))*{data : data, ok : datatype}
     -- (Start_ok: `%|-%:OK`(C, start))?{start : start}
     -- (Export_ok: `%|-%:%%`(C, export, nm, xt_E))*{export : export, nm : name, xt_E : externtype}
     -- if $disjoint_(syntax name, nm*{nm : name})
-    -- if (C = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype} :: gt*{gt : globaltype}, TABLES tt_I*{tt_I : tabletype} :: tt*{tt : tabletype}, MEMS mt_I*{mt_I : memtype} :: mt*{mt : memtype}, ELEMS rt*{rt : elemtype}, DATAS ok*{ok : datatype}, LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
-    -- if (C' = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype}, TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
+    -- if (C = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype} :: gt*{gt : globaltype}, TABLES tt_I*{tt_I : tabletype} :: tt*{tt : tabletype}, MEMS mt_I*{mt_I : memtype} :: mt*{mt : memtype}, TAGS at_I*{at_I : tagtype} :: at*{at : tagtype}, ELEMS rt*{rt : elemtype}, DATAS ok*{ok : datatype}, LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
+    -- if (C' = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype}, TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
     -- if (x*{x : idx} = $funcidx_nonfuncs(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})))
     -- if (dt_I*{dt_I : deftype} = $funcsxt(xt_I*{xt_I : externtype}))
     -- if (gt_I*{gt_I : globaltype} = $globalsxt(xt_I*{xt_I : externtype}))
     -- if (tt_I*{tt_I : tabletype} = $tablesxt(xt_I*{xt_I : externtype}))
     -- if (mt_I*{mt_I : memtype} = $memsxt(xt_I*{xt_I : externtype}))
+    -- if (at_I*{at_I : tagtype} = $tagsxt(xt_I*{xt_I : externtype}))
 
 ;; 7-runtime-typing.watsup
 relation Num_type: `%|-%:%`(store, num, numtype)
@@ -21095,19 +22026,23 @@ relation Ref_type: `%|-%:%`(store, ref, reftype)
     `%|-%:%`(s, REF.FUNC_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), (dt : deftype <: heaptype)))
     -- if (s.FUNCS_store[a].TYPE_funcinst = dt)
 
-  ;; 7-runtime-typing.watsup:35.1-36.39
+  ;; 7-runtime-typing.watsup:35.1-36.38
+  rule exn{s : store, a : addr}:
+    `%|-%:%`(s, REF.EXN_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), EXN_heaptype))
+
+  ;; 7-runtime-typing.watsup:38.1-39.39
   rule host{s : store, a : addr}:
     `%|-%:%`(s, REF.HOST_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), ANY_heaptype))
 
-  ;; 7-runtime-typing.watsup:38.1-39.45
+  ;; 7-runtime-typing.watsup:41.1-42.45
   rule extern{s : store, addrref : addrref}:
     `%|-%:%`(s, REF.EXTERN_ref(addrref), REF_reftype(`NULL%?`_nul(?()), EXTERN_heaptype))
 
-  ;; 7-runtime-typing.watsup:41.1-44.34
+  ;; 7-runtime-typing.watsup:44.1-47.34
   rule sub{s : store, ref : ref, rt : reftype, rt' : reftype}:
     `%|-%:%`(s, ref, rt)
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', rt)
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', rt)
 }
 
 ;; 7-runtime-typing.watsup
@@ -21130,33 +22065,38 @@ relation Val_type: `%|-%:%`(store, val, valtype)
 ;; 7-runtime-typing.watsup
 rec {
 
-;; 7-runtime-typing.watsup:64.1-64.57
-relation Externval_type: `%|-%:%`(store, externval, externtype)
-  ;; 7-runtime-typing.watsup:66.1-68.30
+;; 7-runtime-typing.watsup:67.1-67.59
+relation Externaddr_type: `%|-%:%`(store, externaddr, externtype)
+  ;; 7-runtime-typing.watsup:69.1-71.30
   rule func{s : store, a : addr, funcinst : funcinst}:
-    `%|-%:%`(s, FUNC_externval(a), FUNC_externtype((funcinst.TYPE_funcinst : deftype <: typeuse)))
+    `%|-%:%`(s, FUNC_externaddr(a), FUNC_externtype((funcinst.TYPE_funcinst : deftype <: typeuse)))
     -- if (s.FUNCS_store[a] = funcinst)
 
-  ;; 7-runtime-typing.watsup:70.1-72.34
+  ;; 7-runtime-typing.watsup:73.1-75.34
   rule global{s : store, a : addr, globalinst : globalinst}:
-    `%|-%:%`(s, GLOBAL_externval(a), GLOBAL_externtype(globalinst.TYPE_globalinst))
+    `%|-%:%`(s, GLOBAL_externaddr(a), GLOBAL_externtype(globalinst.TYPE_globalinst))
     -- if (s.GLOBALS_store[a] = globalinst)
 
-  ;; 7-runtime-typing.watsup:74.1-76.32
+  ;; 7-runtime-typing.watsup:77.1-79.32
   rule table{s : store, a : addr, tableinst : tableinst}:
-    `%|-%:%`(s, TABLE_externval(a), TABLE_externtype(tableinst.TYPE_tableinst))
+    `%|-%:%`(s, TABLE_externaddr(a), TABLE_externtype(tableinst.TYPE_tableinst))
     -- if (s.TABLES_store[a] = tableinst)
 
-  ;; 7-runtime-typing.watsup:78.1-80.28
+  ;; 7-runtime-typing.watsup:81.1-83.28
   rule mem{s : store, a : addr, meminst : meminst}:
-    `%|-%:%`(s, MEM_externval(a), MEM_externtype(meminst.TYPE_meminst))
+    `%|-%:%`(s, MEM_externaddr(a), MEM_externtype(meminst.TYPE_meminst))
     -- if (s.MEMS_store[a] = meminst)
 
-  ;; 7-runtime-typing.watsup:82.1-85.37
-  rule sub{s : store, externval : externval, xt : externtype, xt' : externtype}:
-    `%|-%:%`(s, externval, xt)
-    -- Externval_type: `%|-%:%`(s, externval, xt')
-    -- Externtype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, xt', xt)
+  ;; 7-runtime-typing.watsup:85.1-87.28
+  rule tag{s : store, a : addr, taginst : taginst}:
+    `%|-%:%`(s, TAG_externaddr(a), TAG_externtype((taginst.TYPE_taginst : deftype <: typeuse)))
+    -- if (s.TAGS_store[a] = taginst)
+
+  ;; 7-runtime-typing.watsup:89.1-92.37
+  rule sub{s : store, externaddr : externaddr, xt : externtype, xt' : externtype}:
+    `%|-%:%`(s, externaddr, xt)
+    -- Externaddr_type: `%|-%:%`(s, externaddr, xt')
+    -- Externtype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, xt', xt)
 }
 
 ;; 8-reduction.watsup
@@ -21198,15 +22138,19 @@ relation Step_pure: `%~>%`(instr*, instr*)
     `%~>%`([`LABEL_%{%}%`_instr(n, instr*{instr : instr}, (val : val <: instr)*{val : val})], (val : val <: instr)*{val : val})
 
   ;; 8-reduction.watsup
-  rule br-zero{n : n, instr'* : instr*, val'* : val*, val^n : val^n, l : labelidx, instr* : instr*}:
+  rule br-label-zero{n : n, instr'* : instr*, val'* : val*, val^n : val^n, l : labelidx, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val' : val <: instr)*{val' : val} :: (val : val <: instr)^n{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)^n{val : val} :: instr'*{instr' : instr})
     -- if (l = `%`_labelidx(0))
 
   ;; 8-reduction.watsup
-  rule br-succ{n : n, instr'* : instr*, val* : val*, l : labelidx, instr* : instr*}:
+  rule br-label-succ{n : n, instr'* : instr*, val* : val*, l : labelidx, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val : val <: instr)*{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [BR_instr(`%`_labelidx((l!`%`_labelidx.0 - 1)))])
     -- if (l!`%`_labelidx.0 > 0)
 
+  ;; 8-reduction.watsup
+  rule br-handler{n : n, catch* : catch*, val* : val*, l : labelidx, instr* : instr*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [BR_instr(l)])
+
   ;; 8-reduction.watsup
   rule br_if-true{c : num_(I32_numtype), l : labelidx}:
     `%~>%`([CONST_instr(I32_numtype, c) BR_IF_instr(l)], [BR_instr(l)])
@@ -21267,6 +22211,14 @@ relation Step_pure: `%~>%`(instr*, instr*)
   rule return-label{n : n, instr'* : instr*, val* : val*, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val : val <: instr)*{val : val} :: [RETURN_instr] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [RETURN_instr])
 
+  ;; 8-reduction.watsup
+  rule return-handler{n : n, catch* : catch*, val* : val*, instr* : instr*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val} :: [RETURN_instr] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [RETURN_instr])
+
+  ;; 8-reduction.watsup
+  rule handler-vals{n : n, catch* : catch*, val* : val*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val})], (val : val <: instr)*{val : val})
+
   ;; 8-reduction.watsup
   rule trap-vals{val* : val*, instr* : instr*}:
     `%~>%`((val : val <: instr)*{val : val} :: [TRAP_instr] :: instr*{instr : instr}, [TRAP_instr])
@@ -21557,7 +22509,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule br_on_cast-succeed{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype, rt : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) BR_ON_CAST_instr(l, rt_1, rt_2)]), [(ref : ref <: instr) BR_instr(l)])
     -- Ref_type: `%|-%:%`(s, ref, rt)
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
 
   ;; 8-reduction.watsup
   rule br_on_cast-fail{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype}:
@@ -21568,7 +22520,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule br_on_cast_fail-succeed{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype, rt : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) BR_ON_CAST_FAIL_instr(l, rt_1, rt_2)]), [(ref : ref <: instr)])
     -- Ref_type: `%|-%:%`(s, ref, rt)
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
 
   ;; 8-reduction.watsup
   rule br_on_cast_fail-fail{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype}:
@@ -21610,6 +22562,57 @@ relation Step_read: `%~>%`(config, instr*)
     `%~>%`(`%;%`_config(z, [`FRAME_%{%}%`_instr(k, f, (val' : val <: instr)*{val' : val} :: (val : val <: instr)^n{val : val} :: [REF.FUNC_ADDR_instr(a)] :: [RETURN_CALL_REF_instr(yy)] :: instr*{instr : instr})]), (val : val <: instr)^n{val : val} :: [REF.FUNC_ADDR_instr(a) CALL_REF_instr(yy)])
     -- Expand: `%~~%`($funcinst(z)[a].TYPE_funcinst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1^n{t_1 : valtype}), `%`_resulttype(t_2^m{t_2 : valtype}))))
 
+  ;; 8-reduction.watsup
+  rule throw_ref-null{z : state, ht : heaptype}:
+    `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) THROW_REF_instr]), [TRAP_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-vals{z : state, val* : val*, a : addr, instr* : instr*}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)*{val : val} :: [REF.EXN_ADDR_instr(a)] :: [THROW_REF_instr] :: instr*{instr : instr}), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+    -- if ((val*{val : val} =/= []) \/ (instr*{instr : instr} =/= []))
+
+  ;; 8-reduction.watsup
+  rule throw_ref-label{z : state, n : n, instr'* : instr*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-frame{z : state, n : n, f : frame, a : addr}:
+    `%~>%`(`%;%`_config(z, [`FRAME_%{%}%`_instr(n, f, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-empty{z : state, n : n, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [], [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch{z : state, n : n, x : idx, l : labelidx, catch'* : catch*, a : addr, val* : val*}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_catch(x, l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), (val : val <: instr)*{val : val} :: [BR_instr(l)])
+    -- if ($exninst(z)[a].TAG_exninst = $tagaddr(z)[x!`%`_idx.0])
+    -- if (val*{val : val} = $exninst(z)[a].FIELDS_exninst)
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_ref{z : state, n : n, x : idx, l : labelidx, catch'* : catch*, a : addr, val* : val*}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_REF_catch(x, l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), (val : val <: instr)*{val : val} :: [REF.EXN_ADDR_instr(a) BR_instr(l)])
+    -- if ($exninst(z)[a].TAG_exninst = $tagaddr(z)[x!`%`_idx.0])
+    -- if (val*{val : val} = $exninst(z)[a].FIELDS_exninst)
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_all{z : state, n : n, l : labelidx, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_ALL_catch(l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [BR_instr(l)])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_all_ref{z : state, n : n, l : labelidx, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_ALL_REF_catch(l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) BR_instr(l)])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-next{z : state, n : n, catch : catch, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [catch] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [`HANDLER_%{%}%`_instr(n, catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])])
+    -- otherwise
+
+  ;; 8-reduction.watsup
+  rule try_table{z : state, val^m : val^m, m : m, bt : blocktype, catch* : catch*, instr* : instr*, n : n, t_1^m : valtype^m, t_2^n : valtype^n}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)^m{val : val} :: [TRY_TABLE_instr(bt, `%`_list(catch*{catch : catch}), instr*{instr : instr})]), [`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, [`LABEL_%{%}%`_instr(n, [], (val : val <: instr)^m{val : val} :: instr*{instr : instr})])])
+    -- if ($blocktype_(z, bt) = `%->%`_functype(`%`_resulttype(t_1^m{t_1 : valtype}), `%`_resulttype(t_2^n{t_2 : valtype})))
+
   ;; 8-reduction.watsup
   rule ref.null-idx{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(($idx(x) : typevar <: heaptype))]), [REF.NULL_instr(($type(z, x) : deftype <: heaptype))])
@@ -21622,7 +22625,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule ref.test-true{s : store, f : frame, ref : ref, rt : reftype, rt' : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) REF.TEST_instr(rt)]), [CONST_instr(I32_numtype, `%`_num_(1))])
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
 
   ;; 8-reduction.watsup
   rule ref.test-false{s : store, f : frame, ref : ref, rt : reftype}:
@@ -21633,7 +22636,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule ref.cast-succeed{s : store, f : frame, ref : ref, rt : reftype, rt' : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) REF.CAST_instr(rt)]), [(ref : ref <: instr)])
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
 
   ;; 8-reduction.watsup
   rule ref.cast-fail{s : store, f : frame, ref : ref, rt : reftype}:
@@ -22048,135 +23051,142 @@ relation Step: `%~>%`(config, config)
     `%~>%`(`%;%`_config(z, instr*{instr : instr}), `%;%`_config(z, instr'*{instr' : instr}))
     -- Step_read: `%~>%`(`%;%`_config(z, instr*{instr : instr}), instr'*{instr' : instr})
 
-  ;; 8-reduction.watsup:225.1-227.36
+  ;; 8-reduction.watsup:218.1-223.49
+  rule throw{z : state, val^n : val^n, n : n, x : idx, exn : exninst, a : addr, t^n : valtype^n}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [THROW_instr(x)]), `%;%`_config($add_exninst(z, [exn]), [REF.EXN_ADDR_instr(a) THROW_REF_instr]))
+    -- Expand: `%~~%`($tag(z, x).TYPE_taginst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t^n{t : valtype}), `%`_resulttype([]))))
+    -- if (a = |$exninst(z)|)
+    -- if (exn = {TAG $tagaddr(z)[x!`%`_idx.0], FIELDS val^n{val : val}})
+
+  ;; 8-reduction.watsup:285.1-287.36
   rule ctxt-label{z : state, n : n, instr_0* : instr*, instr* : instr*, z' : state, instr'* : instr*}:
     `%~>%`(`%;%`_config(z, [`LABEL_%{%}%`_instr(n, instr_0*{instr_0 : instr}, instr*{instr : instr})]), `%;%`_config(z', [`LABEL_%{%}%`_instr(n, instr_0*{instr_0 : instr}, instr'*{instr' : instr})]))
     -- Step: `%~>%`(`%;%`_config(z, instr*{instr : instr}), `%;%`_config(z', instr'*{instr' : instr}))
 
-  ;; 8-reduction.watsup:229.1-231.44
+  ;; 8-reduction.watsup:289.1-291.44
   rule ctxt-frame{s : store, f : frame, n : n, f' : frame, instr* : instr*, s' : store, instr'* : instr*}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [`FRAME_%{%}%`_instr(n, f', instr*{instr : instr})]), `%;%`_config(`%;%`_state(s', f), [`FRAME_%{%}%`_instr(n, f', instr'*{instr' : instr})]))
     -- Step: `%~>%`(`%;%`_config(`%;%`_state(s, f'), instr*{instr : instr}), `%;%`_config(`%;%`_state(s', f'), instr'*{instr' : instr}))
 
-  ;; 8-reduction.watsup:349.1-353.65
+  ;; 8-reduction.watsup:409.1-413.65
   rule struct.new{z : state, val^n : val^n, n : n, x : idx, si : structinst, a : addr, mut^n : mut^n, zt^n : storagetype^n}:
     `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [STRUCT.NEW_instr(x)]), `%;%`_config($add_structinst(z, [si]), [REF.STRUCT_ADDR_instr(a)]))
     -- Expand: `%~~%`($type(z, x), STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)^n{mut : mut, zt : storagetype})))
     -- if (a = |$structinst(z)|)
     -- if (si = {TYPE $type(z, x), FIELDS $packfield_(zt, val)^n{val : val, zt : storagetype}})
 
-  ;; 8-reduction.watsup:369.1-370.53
+  ;; 8-reduction.watsup:429.1-430.53
   rule struct.set-null{z : state, ht : heaptype, val : val, x : idx, i : nat}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) (val : val <: instr) STRUCT.SET_instr(x, `%`_u32(i))]), `%;%`_config(z, [TRAP_instr]))
 
-  ;; 8-reduction.watsup:372.1-374.45
+  ;; 8-reduction.watsup:432.1-434.45
   rule struct.set-struct{z : state, a : addr, val : val, x : idx, i : nat, zt* : storagetype*, mut* : mut*}:
     `%~>%`(`%;%`_config(z, [REF.STRUCT_ADDR_instr(a) (val : val <: instr) STRUCT.SET_instr(x, `%`_u32(i))]), `%;%`_config($with_struct(z, a, i, $packfield_(zt*{zt : storagetype}[i], val)), []))
     -- Expand: `%~~%`($type(z, x), STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
 
-  ;; 8-reduction.watsup:387.1-392.65
+  ;; 8-reduction.watsup:447.1-452.65
   rule array.new_fixed{z : state, val^n : val^n, n : n, x : idx, ai : arrayinst, a : addr, mut : mut, zt : storagetype}:
     `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [ARRAY.NEW_FIXED_instr(x, `%`_u32(n))]), `%;%`_config($add_arrayinst(z, [ai]), [REF.ARRAY_ADDR_instr(a)]))
     -- Expand: `%~~%`($type(z, x), ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ((a = |$arrayinst(z)|) /\ (ai = {TYPE $type(z, x), FIELDS $packfield_(zt, val)^n{val : val}}))
 
-  ;; 8-reduction.watsup:432.1-433.64
+  ;; 8-reduction.watsup:492.1-493.64
   rule array.set-null{z : state, ht : heaptype, i : nat, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
 
-  ;; 8-reduction.watsup:435.1-437.39
+  ;; 8-reduction.watsup:495.1-497.39
   rule array.set-oob{z : state, a : addr, i : nat, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.ARRAY_ADDR_instr(a) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
     -- if (i >= |$arrayinst(z)[a].FIELDS_arrayinst|)
 
-  ;; 8-reduction.watsup:439.1-442.43
+  ;; 8-reduction.watsup:499.1-502.43
   rule array.set-array{z : state, a : addr, i : nat, val : val, x : idx, zt : storagetype, mut : mut}:
     `%~>%`(`%;%`_config(z, [REF.ARRAY_ADDR_instr(a) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config($with_array(z, a, i, $packfield_(zt, val)), []))
     -- Expand: `%~~%`($type(z, x), ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 8-reduction.watsup:743.1-744.56
+  ;; 8-reduction.watsup:803.1-804.56
   rule local.set{z : state, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [(val : val <: instr) LOCAL.SET_instr(x)]), `%;%`_config($with_local(z, x, val), []))
 
-  ;; 8-reduction.watsup:756.1-757.58
+  ;; 8-reduction.watsup:816.1-817.58
   rule global.set{z : state, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [(val : val <: instr) GLOBAL.SET_instr(x)]), `%;%`_config($with_global(z, x, val), []))
 
-  ;; 8-reduction.watsup:770.1-772.33
+  ;; 8-reduction.watsup:830.1-832.33
   rule table.set-oob{z : state, i : nat, ref : ref, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) (ref : ref <: instr) TABLE.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
     -- if (i >= |$table(z, x).REFS_tableinst|)
 
-  ;; 8-reduction.watsup:774.1-776.32
+  ;; 8-reduction.watsup:834.1-836.32
   rule table.set-val{z : state, i : nat, ref : ref, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) (ref : ref <: instr) TABLE.SET_instr(x)]), `%;%`_config($with_table(z, x, i, ref), []))
     -- if (i < |$table(z, x).REFS_tableinst|)
 
-  ;; 8-reduction.watsup:784.1-787.46
+  ;; 8-reduction.watsup:844.1-847.46
   rule table.grow-succeed{z : state, ref : ref, n : n, x : idx, ti : tableinst}:
     `%~>%`(`%;%`_config(z, [(ref : ref <: instr) CONST_instr(I32_numtype, `%`_num_(n)) TABLE.GROW_instr(x)]), `%;%`_config($with_tableinst(z, x, ti), [CONST_instr(I32_numtype, `%`_num_(|$table(z, x).REFS_tableinst|))]))
     -- if (ti = !($growtable($table(z, x), n, ref)))
 
-  ;; 8-reduction.watsup:789.1-790.81
+  ;; 8-reduction.watsup:849.1-850.81
   rule table.grow-fail{z : state, ref : ref, n : n, x : idx}:
     `%~>%`(`%;%`_config(z, [(ref : ref <: instr) CONST_instr(I32_numtype, `%`_num_(n)) TABLE.GROW_instr(x)]), `%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_($invsigned_(32, - (1 : nat <: int))))]))
 
-  ;; 8-reduction.watsup:850.1-851.51
+  ;; 8-reduction.watsup:910.1-911.51
   rule elem.drop{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [ELEM.DROP_instr(x)]), `%;%`_config($with_elem(z, x, []), []))
 
-  ;; 8-reduction.watsup:934.1-937.60
+  ;; 8-reduction.watsup:994.1-997.60
   rule store-num-oob{z : state, i : nat, nt : numtype, c : num_(nt), x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr(nt, c) STORE_instr(nt, ?(), x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + ($size(nt) / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:939.1-943.29
+  ;; 8-reduction.watsup:999.1-1003.29
   rule store-num-val{z : state, i : nat, nt : numtype, c : num_(nt), x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr(nt, c) STORE_instr(nt, ?(), x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), ($size(nt) / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $nbytes_(nt, c))
 
-  ;; 8-reduction.watsup:945.1-948.52
+  ;; 8-reduction.watsup:1005.1-1008.52
   rule store-pack-oob{z : state, i : nat, Inn : Inn, c : num_((Inn : Inn <: numtype)), nt : numtype, n : n, x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr((Inn : Inn <: numtype), c) STORE_instr(nt, ?(`%`_sz(n)), x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + (n / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:950.1-954.52
+  ;; 8-reduction.watsup:1010.1-1014.52
   rule store-pack-val{z : state, i : nat, Inn : Inn, c : num_((Inn : Inn <: numtype)), nt : numtype, n : n, x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr((Inn : Inn <: numtype), c) STORE_instr(nt, ?(`%`_sz(n)), x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), (n / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $ibytes_(n, $wrap__($size((Inn : Inn <: numtype)), n, c)))
 
-  ;; 8-reduction.watsup:956.1-958.63
+  ;; 8-reduction.watsup:1016.1-1018.63
   rule vstore-oob{z : state, i : nat, c : vec_(V128_Vnn), x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_instr(V128_vectype, x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + ($vsize(V128_vectype) / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:960.1-962.31
+  ;; 8-reduction.watsup:1020.1-1022.31
   rule vstore-val{z : state, i : nat, c : vec_(V128_Vnn), x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_instr(V128_vectype, x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), ($vsize(V128_vectype) / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $vbytes_(V128_vectype, c))
 
-  ;; 8-reduction.watsup:965.1-967.50
+  ;; 8-reduction.watsup:1025.1-1027.50
   rule vstore_lane-oob{z : state, i : nat, c : vec_(V128_Vnn), N : N, x : idx, ao : memarg, j : nat}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, ao, `%`_laneidx(j))]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + N) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:969.1-973.49
+  ;; 8-reduction.watsup:1029.1-1033.49
   rule vstore_lane-val{z : state, i : nat, c : vec_(V128_Vnn), N : N, x : idx, ao : memarg, j : nat, b* : byte*, Jnn : Jnn, M : M}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, ao, `%`_laneidx(j))]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), (N / 8), b*{b : byte}), []))
     -- if (N = $lsize((Jnn : Jnn <: lanetype)))
     -- if (M = (128 / N))
     -- if (b*{b : byte} = $ibytes_(N, `%`_iN($lanes_(`%X%`_shape((Jnn : Jnn <: lanetype), `%`_dim(M)), c)[j]!`%`_lane_.0)))
 
-  ;; 8-reduction.watsup:981.1-984.37
+  ;; 8-reduction.watsup:1041.1-1044.37
   rule memory.grow-succeed{z : state, n : n, x : idx, mi : meminst}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(n)) MEMORY.GROW_instr(x)]), `%;%`_config($with_meminst(z, x, mi), [CONST_instr(I32_numtype, `%`_num_((|$mem(z, x).BYTES_meminst| / (64 * $Ki))))]))
     -- if (mi = !($growmem($mem(z, x), n)))
 
-  ;; 8-reduction.watsup:986.1-987.78
+  ;; 8-reduction.watsup:1046.1-1047.78
   rule memory.grow-fail{z : state, n : n, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(n)) MEMORY.GROW_instr(x)]), `%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_($invsigned_(32, - (1 : nat <: int))))]))
 
-  ;; 8-reduction.watsup:1047.1-1048.51
+  ;; 8-reduction.watsup:1107.1-1108.51
   rule data.drop{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [DATA.DROP_instr(x)]), `%;%`_config($with_data(z, x, []), []))
 }
@@ -22222,7 +23232,7 @@ def $alloctypes(type*) : deftype*
 ;; 9-module.watsup
 def $allocfunc(store : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst) : (store, funcaddr)
   ;; 9-module.watsup
-  def $allocfunc{s : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst, funcinst : funcinst}(s, deftype, funccode, moduleinst) = (s ++ {FUNCS [funcinst], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.FUNCS_store|)
+  def $allocfunc{s : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst, funcinst : funcinst}(s, deftype, funccode, moduleinst) = (s ++ {FUNCS [funcinst], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.FUNCS_store|)
     -- if (funcinst = {TYPE deftype, MODULE moduleinst, CODE funccode})
 
 ;; 9-module.watsup
@@ -22241,7 +23251,7 @@ def $allocfuncs(store : store, deftype*, funccode*, moduleinst*) : (store, funca
 ;; 9-module.watsup
 def $allocglobal(store : store, globaltype : globaltype, val : val) : (store, globaladdr)
   ;; 9-module.watsup
-  def $allocglobal{s : store, globaltype : globaltype, val : val, globalinst : globalinst}(s, globaltype, val) = (s ++ {FUNCS [], GLOBALS [globalinst], TABLES [], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.GLOBALS_store|)
+  def $allocglobal{s : store, globaltype : globaltype, val : val, globalinst : globalinst}(s, globaltype, val) = (s ++ {FUNCS [], GLOBALS [globalinst], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.GLOBALS_store|)
     -- if (globalinst = {TYPE globaltype, VALUE val})
 
 ;; 9-module.watsup
@@ -22260,7 +23270,7 @@ def $allocglobals(store : store, globaltype*, val*) : (store, globaladdr*)
 ;; 9-module.watsup
 def $alloctable(store : store, tabletype : tabletype, ref : ref) : (store, tableaddr)
   ;; 9-module.watsup
-  def $alloctable{s : store, i : nat, j : nat, rt : reftype, ref : ref, tableinst : tableinst}(s, `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), ref) = (s ++ {FUNCS [], GLOBALS [], TABLES [tableinst], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.TABLES_store|)
+  def $alloctable{s : store, i : nat, j : nat, rt : reftype, ref : ref, tableinst : tableinst}(s, `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), ref) = (s ++ {FUNCS [], GLOBALS [], TABLES [tableinst], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.TABLES_store|)
     -- if (tableinst = {TYPE `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), REFS ref^i{}})
 
 ;; 9-module.watsup
@@ -22279,7 +23289,7 @@ def $alloctables(store : store, tabletype*, ref*) : (store, tableaddr*)
 ;; 9-module.watsup
 def $allocmem(store : store, memtype : memtype) : (store, memaddr)
   ;; 9-module.watsup
-  def $allocmem{s : store, i : nat, j : nat, meminst : meminst}(s, `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)))) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [meminst], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.MEMS_store|)
+  def $allocmem{s : store, i : nat, j : nat, meminst : meminst}(s, `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)))) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [meminst], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.MEMS_store|)
     -- if (meminst = {TYPE `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j))), BYTES `%`_byte(0)^(i * (64 * $Ki)){}})
 
 ;; 9-module.watsup
@@ -22295,39 +23305,58 @@ def $allocmems(store : store, memtype*) : (store, memaddr*)
     -- if ((s_2, ma'*{ma' : memaddr}) = $allocmems(s_1, memtype'*{memtype' : memtype}))
 }
 
+;; 9-module.watsup
+def $alloctag(store : store, tagtype : tagtype) : (store, tagaddr)
+  ;; 9-module.watsup
+  def $alloctag{s : store, at : tagtype, taginst : taginst}(s, at) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [taginst], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.TAGS_store|)
+    -- if (taginst = {TYPE at})
+
+;; 9-module.watsup
+rec {
+
+;; 9-module.watsup:64.1-64.82
+def $alloctags(store : store, tagtype*) : (store, tagaddr*)
+  ;; 9-module.watsup:65.1-65.34
+  def $alloctags{s : store}(s, []) = (s, [])
+  ;; 9-module.watsup:66.1-68.44
+  def $alloctags{s : store, at : tagtype, at'* : tagtype*, s_2 : store, aa : tagaddr, aa'* : tagaddr*, s_1 : store}(s, [at] :: at'*{at' : tagtype}) = (s_2, [aa] :: aa'*{aa' : tagaddr})
+    -- if ((s_1, aa) = $alloctag(s, at))
+    -- if ((s_2, aa'*{aa' : tagaddr}) = $alloctags(s_1, at'*{at' : tagtype}))
+}
+
 ;; 9-module.watsup
 def $allocelem(store : store, elemtype : elemtype, ref*) : (store, elemaddr)
   ;; 9-module.watsup
-  def $allocelem{s : store, elemtype : elemtype, ref* : ref*, eleminst : eleminst}(s, elemtype, ref*{ref : ref}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [eleminst], DATAS [], STRUCTS [], ARRAYS []}, |s.ELEMS_store|)
+  def $allocelem{s : store, elemtype : elemtype, ref* : ref*, eleminst : eleminst}(s, elemtype, ref*{ref : ref}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [eleminst], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.ELEMS_store|)
     -- if (eleminst = {TYPE elemtype, REFS ref*{ref : ref}})
 
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:64.1-64.97
+;; 9-module.watsup:75.1-75.97
 def $allocelems(store : store, elemtype*, ref**) : (store, elemaddr*)
-  ;; 9-module.watsup:65.1-65.40
+  ;; 9-module.watsup:76.1-76.40
   def $allocelems{s : store}(s, [], []) = (s, [])
-  ;; 9-module.watsup:66.1-68.55
+  ;; 9-module.watsup:77.1-79.55
   def $allocelems{s : store, rt : reftype, rt'* : reftype*, ref* : ref*, ref'** : ref**, s_2 : store, ea : elemaddr, ea'* : elemaddr*, s_1 : store}(s, [rt] :: rt'*{rt' : elemtype}, [ref*{ref : ref}] :: ref'*{ref' : ref}*{ref' : ref}) = (s_2, [ea] :: ea'*{ea' : elemaddr})
     -- if ((s_1, ea) = $allocelem(s, rt, ref*{ref : ref}))
-    -- if ((s_2, ea'*{ea' : elemaddr}) = $allocelems(s_2, rt'*{rt' : elemtype}, ref'*{ref' : ref}*{ref' : ref}))
+    -- if ((s_2, ea'*{ea' : elemaddr}) = $allocelems(s_1, rt'*{rt' : elemtype}, ref'*{ref' : ref}*{ref' : ref}))
 }
 
 ;; 9-module.watsup
 def $allocdata(store : store, datatype : datatype, byte*) : (store, dataaddr)
   ;; 9-module.watsup
-  def $allocdata{s : store, byte* : byte*, datainst : datainst}(s, OK_datatype, byte*{byte : byte}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [datainst], STRUCTS [], ARRAYS []}, |s.DATAS_store|)
+  def $allocdata{s : store, byte* : byte*, datainst : datainst}(s, OK_datatype, byte*{byte : byte}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [datainst], STRUCTS [], ARRAYS [], EXNS []}, |s.DATAS_store|)
     -- if (datainst = {BYTES byte*{byte : byte}})
 
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:75.1-75.98
+;; 9-module.watsup:86.1-86.98
 def $allocdatas(store : store, datatype*, byte**) : (store, dataaddr*)
-  ;; 9-module.watsup:76.1-76.40
+  ;; 9-module.watsup:87.1-87.40
   def $allocdatas{s : store}(s, [], []) = (s, [])
-  ;; 9-module.watsup:77.1-79.53
+  ;; 9-module.watsup:88.1-90.53
   def $allocdatas{s : store, ok : datatype, ok'* : datatype*, b* : byte*, b'** : byte**, s_2 : store, da : dataaddr, da'* : dataaddr*, s_1 : store}(s, [ok] :: ok'*{ok' : datatype}, [b*{b : byte}] :: b'*{b' : byte}*{b' : byte}) = (s_2, [da] :: da'*{da' : dataaddr})
     -- if ((s_1, da) = $allocdata(s, ok, b*{b : byte}))
     -- if ((s_2, da'*{da' : dataaddr}) = $allocdatas(s_1, ok'*{ok' : datatype}, b'*{b' : byte}*{b' : byte}))
@@ -22336,13 +23365,15 @@ def $allocdatas(store : store, datatype*, byte**) : (store, dataaddr*)
 ;; 9-module.watsup
 def $allocexport(moduleinst : moduleinst, export : export) : exportinst
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, FUNC_externidx(x))) = {NAME name, VALUE FUNC_externval(moduleinst.FUNCS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, FUNC_externidx(x))) = {NAME name, ADDR FUNC_externaddr(moduleinst.FUNCS_moduleinst[x!`%`_idx.0])}
+  ;; 9-module.watsup
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, GLOBAL_externidx(x))) = {NAME name, ADDR GLOBAL_externaddr(moduleinst.GLOBALS_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, GLOBAL_externidx(x))) = {NAME name, VALUE GLOBAL_externval(moduleinst.GLOBALS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TABLE_externidx(x))) = {NAME name, ADDR TABLE_externaddr(moduleinst.TABLES_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TABLE_externidx(x))) = {NAME name, VALUE TABLE_externval(moduleinst.TABLES_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, MEM_externidx(x))) = {NAME name, ADDR MEM_externaddr(moduleinst.MEMS_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, MEM_externidx(x))) = {NAME name, VALUE MEM_externval(moduleinst.MEMS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TAG_externidx(x))) = {NAME name, ADDR TAG_externaddr(moduleinst.TAGS_moduleinst[x!`%`_idx.0])}
 
 ;; 9-module.watsup
 def $allocexports(moduleinst : moduleinst, export*) : exportinst*
@@ -22350,35 +23381,39 @@ def $allocexports(moduleinst : moduleinst, export*) : exportinst*
   def $allocexports{moduleinst : moduleinst, export* : export*}(moduleinst, export*{export : export}) = $allocexport(moduleinst, export)*{export : export}
 
 ;; 9-module.watsup
-def $allocmodule(store : store, module : module, externval*, val*, ref*, ref**) : (store, moduleinst)
+def $allocmodule(store : store, module : module, externaddr*, val*, ref*, ref**) : (store, moduleinst)
   ;; 9-module.watsup
-  def $allocmodule{s : store, module : module, externval* : externval*, val_G* : val*, ref_T* : ref*, ref_E** : ref**, s_6 : store, moduleinst : moduleinst, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, x* : idx*, local** : local**, expr_F* : expr*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, memtype* : memtype*, elemtype* : elemtype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, fa_I* : funcaddr*, ga_I* : globaladdr*, ta_I* : tableaddr*, ma_I* : memaddr*, fa* : funcaddr*, i_F^|func*{func : func}| : nat^|func*{func : func}|, ga* : globaladdr*, i_G^|global*{global : global}| : nat^|global*{global : global}|, ta* : tableaddr*, i_T^|table*{table : table}| : nat^|table*{table : table}|, ma* : memaddr*, i_M^|mem*{mem : mem}| : nat^|mem*{mem : mem}|, ea* : elemaddr*, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, da* : dataaddr*, i_D^|data*{data : data}| : nat^|data*{data : data}|, dt* : deftype*, s_1 : store, s_2 : store, s_3 : store, s_4 : store, s_5 : store, xi* : exportinst*}(s, module, externval*{externval : externval}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}) = (s_6, moduleinst)
-    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
+  def $allocmodule{s : store, module : module, externaddr* : externaddr*, val_G* : val*, ref_T* : ref*, ref_E** : ref**, s_7 : store, moduleinst : moduleinst, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, x* : idx*, local** : local**, expr_F* : expr*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, memtype* : memtype*, y* : idx*, elemtype* : elemtype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, fa_I* : funcaddr*, ga_I* : globaladdr*, ta_I* : tableaddr*, ma_I* : memaddr*, aa_I* : tagaddr*, fa* : nat*, i_F^|func*{func : func}| : nat^|func*{func : func}|, ga* : nat*, i_G^|global*{global : global}| : nat^|global*{global : global}|, ta* : nat*, i_T^|table*{table : table}| : nat^|table*{table : table}|, aa* : nat*, i_A^|tag*{tag : tag}| : nat^|tag*{tag : tag}|, ma* : nat*, i_M^|mem*{mem : mem}| : nat^|mem*{mem : mem}|, ea* : nat*, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, da* : nat*, i_D^|data*{data : data}| : nat^|data*{data : data}|, dt* : deftype*, s_1 : store, s_2 : store, s_3 : store, s_4 : store, s_5 : store, s_6 : store, xi* : exportinst*}(s, module, externaddr*{externaddr : externaddr}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}) = (s_7, moduleinst)
+    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
     -- if (func*{func : func} = FUNC_func(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx})
     -- if (global*{global : global} = GLOBAL_global(globaltype, expr_G)*{expr_G : expr, globaltype : globaltype})
     -- if (table*{table : table} = TABLE_table(tabletype, expr_T)*{expr_T : expr, tabletype : tabletype})
     -- if (mem*{mem : mem} = MEMORY_mem(memtype)*{memtype : memtype})
+    -- if (tag*{tag : tag} = TAG_tag(y)*{y : typeidx})
     -- if (elem*{elem : elem} = ELEM_elem(elemtype, expr_E*{expr_E : expr}, elemmode)*{elemmode : elemmode, elemtype : reftype, expr_E : expr})
     -- if (data*{data : data} = DATA_data(byte*{byte : byte}, datamode)*{byte : byte, datamode : datamode})
-    -- if (fa_I*{fa_I : funcaddr} = $funcsxv(externval*{externval : externval}))
-    -- if (ga_I*{ga_I : globaladdr} = $globalsxv(externval*{externval : externval}))
-    -- if (ta_I*{ta_I : tableaddr} = $tablesxv(externval*{externval : externval}))
-    -- if (ma_I*{ma_I : memaddr} = $memsxv(externval*{externval : externval}))
-    -- if (fa*{fa : funcaddr} = (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat})
-    -- if (ga*{ga : globaladdr} = (|s.GLOBALS_store| + i_G)^(i_G<|global*{global : global}|){i_G : nat})
-    -- if (ta*{ta : tableaddr} = (|s.TABLES_store| + i_T)^(i_T<|table*{table : table}|){i_T : nat})
-    -- if (ma*{ma : memaddr} = (|s.MEMS_store| + i_M)^(i_M<|mem*{mem : mem}|){i_M : nat})
-    -- if (ea*{ea : elemaddr} = (|s.ELEMS_store| + i_E)^(i_E<|elem*{elem : elem}|){i_E : nat})
-    -- if (da*{da : dataaddr} = (|s.DATAS_store| + i_D)^(i_D<|data*{data : data}|){i_D : nat})
+    -- if (fa_I*{fa_I : funcaddr} = $funcsxa(externaddr*{externaddr : externaddr}))
+    -- if (ga_I*{ga_I : globaladdr} = $globalsxa(externaddr*{externaddr : externaddr}))
+    -- if (ta_I*{ta_I : tableaddr} = $tablesxa(externaddr*{externaddr : externaddr}))
+    -- if (ma_I*{ma_I : memaddr} = $memsxa(externaddr*{externaddr : externaddr}))
+    -- if (aa_I*{aa_I : tagaddr} = $tagsxa(externaddr*{externaddr : externaddr}))
+    -- if (fa*{fa : nat} = (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat})
+    -- if (ga*{ga : nat} = (|s.GLOBALS_store| + i_G)^(i_G<|global*{global : global}|){i_G : nat})
+    -- if (ta*{ta : nat} = (|s.TABLES_store| + i_T)^(i_T<|table*{table : table}|){i_T : nat})
+    -- if (aa*{aa : nat} = (|s.TAGS_store| + i_A)^(i_A<|tag*{tag : tag}|){i_A : nat})
+    -- if (ma*{ma : nat} = (|s.MEMS_store| + i_M)^(i_M<|mem*{mem : mem}|){i_M : nat})
+    -- if (ea*{ea : nat} = (|s.ELEMS_store| + i_E)^(i_E<|elem*{elem : elem}|){i_E : nat})
+    -- if (da*{da : nat} = (|s.DATAS_store| + i_D)^(i_D<|data*{data : data}|){i_D : nat})
     -- if (dt*{dt : deftype} = $alloctypes(type*{type : type}))
-    -- if ((s_1, fa*{fa : funcaddr}) = $allocfuncs(s, dt*{dt : deftype}[x!`%`_idx.0]*{x : idx}, FUNC_funccode(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx}, moduleinst^|func*{func : func}|{}))
-    -- if ((s_2, ga*{ga : globaladdr}) = $allocglobals(s_1, globaltype*{globaltype : globaltype}, val_G*{val_G : val}))
-    -- if ((s_3, ta*{ta : tableaddr}) = $alloctables(s_2, tabletype*{tabletype : tabletype}, ref_T*{ref_T : ref}))
-    -- if ((s_4, ma*{ma : memaddr}) = $allocmems(s_3, memtype*{memtype : memtype}))
-    -- if ((s_5, ea*{ea : elemaddr}) = $allocelems(s_4, elemtype*{elemtype : elemtype}, ref_E*{ref_E : ref}*{ref_E : ref}))
-    -- if ((s_6, da*{da : dataaddr}) = $allocdatas(s_5, OK_datatype^|data*{data : data}|{}, byte*{byte : byte}*{byte : byte}))
-    -- if (xi*{xi : exportinst} = $allocexports({TYPES [], FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, ELEMS [], DATAS [], EXPORTS []}, export*{export : export}))
-    -- if (moduleinst = {TYPES dt*{dt : deftype}, FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, ELEMS ea*{ea : elemaddr}, DATAS da*{da : dataaddr}, EXPORTS xi*{xi : exportinst}})
+    -- if ((s_1, fa*{fa : nat}) = $allocfuncs(s, dt*{dt : deftype}[x!`%`_idx.0]*{x : idx}, FUNC_funccode(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx}, moduleinst^|func*{func : func}|{}))
+    -- if ((s_2, ga*{ga : nat}) = $allocglobals(s_1, globaltype*{globaltype : globaltype}, val_G*{val_G : val}))
+    -- if ((s_3, ta*{ta : nat}) = $alloctables(s_2, tabletype*{tabletype : tabletype}, ref_T*{ref_T : ref}))
+    -- if ((s_4, ma*{ma : nat}) = $allocmems(s_3, memtype*{memtype : memtype}))
+    -- if ((s_5, aa*{aa : nat}) = $alloctags(s_4, dt*{dt : deftype}[y!`%`_idx.0]*{y : idx}))
+    -- if ((s_6, ea*{ea : nat}) = $allocelems(s_5, elemtype*{elemtype : elemtype}, ref_E*{ref_E : ref}*{ref_E : ref}))
+    -- if ((s_7, da*{da : nat}) = $allocdatas(s_6, OK_datatype^|data*{data : data}|{}, byte*{byte : byte}*{byte : byte}))
+    -- if (xi*{xi : exportinst} = $allocexports({TYPES [], FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, TAGS aa_I*{aa_I : tagaddr} :: aa*{aa : tagaddr}, ELEMS [], DATAS [], EXPORTS []}, export*{export : export}))
+    -- if (moduleinst = {TYPES dt*{dt : deftype}, FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, TAGS aa_I*{aa_I : tagaddr} :: aa*{aa : tagaddr}, ELEMS ea*{ea : elemaddr}, DATAS da*{da : dataaddr}, EXPORTS xi*{xi : exportinst}})
 
 ;; 9-module.watsup
 def $runelem_(elemidx : elemidx, elem : elem) : instr*
@@ -22399,11 +23434,11 @@ def $rundata_(dataidx : dataidx, data : data) : instr*
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:152.1-152.94
+;; 9-module.watsup:169.1-169.94
 def $evalglobals(state : state, globaltype*, expr*) : (state, val*)
-  ;; 9-module.watsup:153.1-153.41
+  ;; 9-module.watsup:170.1-170.41
   def $evalglobals{z : state}(z, [], []) = (z, [])
-  ;; 9-module.watsup:154.1-159.81
+  ;; 9-module.watsup:171.1-176.81
   def $evalglobals{z : state, gt : globaltype, gt'* : globaltype*, expr : expr, expr'* : expr*, z' : state, val : val, val'* : val*, s : store, f : frame, s' : store, a : addr}(z, [gt] :: gt'*{gt' : globaltype}, [expr] :: expr'*{expr' : expr}) = (z', [val] :: val'*{val' : val})
     -- Eval_expr: `%;%~>*%;%`(z, expr, z, [val])
     -- if (z = `%;%`_state(s, f))
@@ -22412,23 +23447,23 @@ def $evalglobals(state : state, globaltype*, expr*) : (state, val*)
 }
 
 ;; 9-module.watsup
-def $instantiate(store : store, module : module, externval*) : config
+def $instantiate(store : store, module : module, externaddr*) : config
   ;; 9-module.watsup
-  def $instantiate{s : store, module : module, externval* : externval*, s' : store, f : frame, instr_E* : instr*, instr_D* : instr*, instr_S? : instr?, xt_I* : externtype*, xt_E* : externtype*, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, reftype* : reftype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, x? : idx?, moduleinst_0 : moduleinst, i_F^|func*{func : func}| : nat^|func*{func : func}|, z : state, z' : state, val_G* : val*, ref_T* : ref*, ref_E** : ref**, moduleinst : moduleinst, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, i_D^|data*{data : data}| : nat^|data*{data : data}|}(s, module, externval*{externval : externval}) = `%;%`_config(`%;%`_state(s', f), instr_E*{instr_E : instr} :: instr_D*{instr_D : instr} :: instr_S?{instr_S : instr})
+  def $instantiate{s : store, module : module, externaddr* : externaddr*, s' : store, f : frame, instr_E* : instr*, instr_D* : instr*, instr_S? : instr?, xt_I* : externtype*, xt_E* : externtype*, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, reftype* : reftype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, x? : idx?, moduleinst_0 : moduleinst, i_F^|func*{func : func}| : nat^|func*{func : func}|, z : state, z' : state, val_G* : val*, ref_T* : ref*, ref_E** : ref**, moduleinst : moduleinst, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, i_D^|data*{data : data}| : nat^|data*{data : data}|}(s, module, externaddr*{externaddr : externaddr}) = `%;%`_config(`%;%`_state(s', f), instr_E*{instr_E : instr} :: instr_D*{instr_D : instr} :: instr_S?{instr_S : instr})
     -- Module_ok: `|-%:%`(module, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype}))
-    -- (Externval_type: `%|-%:%`(s, externval, xt_I))*{externval : externval, xt_I : externtype}
-    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
+    -- (Externaddr_type: `%|-%:%`(s, externaddr, xt_I))*{externaddr : externaddr, xt_I : externtype}
+    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
     -- if (global*{global : global} = GLOBAL_global(globaltype, expr_G)*{expr_G : expr, globaltype : globaltype})
     -- if (table*{table : table} = TABLE_table(tabletype, expr_T)*{expr_T : expr, tabletype : tabletype})
     -- if (elem*{elem : elem} = ELEM_elem(reftype, expr_E*{expr_E : expr}, elemmode)*{elemmode : elemmode, expr_E : expr, reftype : reftype})
     -- if (data*{data : data} = DATA_data(byte*{byte : byte}, datamode)*{byte : byte, datamode : datamode})
     -- if (start?{start : start} = START_start(x)?{x : funcidx})
-    -- if (moduleinst_0 = {TYPES $alloctypes(type*{type : type}), FUNCS $funcsxv(externval*{externval : externval}) :: (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat}, GLOBALS $globalsxv(externval*{externval : externval}), TABLES [], MEMS [], ELEMS [], DATAS [], EXPORTS []})
+    -- if (moduleinst_0 = {TYPES $alloctypes(type*{type : type}), FUNCS $funcsxa(externaddr*{externaddr : externaddr}) :: (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat}, GLOBALS $globalsxa(externaddr*{externaddr : externaddr}), TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], EXPORTS []})
     -- if (z = `%;%`_state(s, {LOCALS [], MODULE moduleinst_0}))
     -- if ((z', val_G*{val_G : val}) = $evalglobals(z, globaltype*{globaltype : globaltype}, expr_G*{expr_G : expr}))
     -- (Eval_expr: `%;%~>*%;%`(z', expr_T, z', [(ref_T : ref <: val)]))*{expr_T : expr, ref_T : ref}
     -- (Eval_expr: `%;%~>*%;%`(z', expr_E, z', [(ref_E : ref <: val)]))*{expr_E : expr, ref_E : ref}*{expr_E : expr, ref_E : ref}
-    -- if ((s', moduleinst) = $allocmodule(s, module, externval*{externval : externval}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}))
+    -- if ((s', moduleinst) = $allocmodule(s, module, externaddr*{externaddr : externaddr}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}))
     -- if (f = {LOCALS [], MODULE moduleinst})
     -- if (instr_E*{instr_E : instr} = $concat_(syntax instr, $runelem_(`%`_elemidx(i_E), elem*{elem : elem}[i_E])^(i_E<|elem*{elem : elem}|){i_E : nat}))
     -- if (instr_D*{instr_D : instr} = $concat_(syntax instr, $rundata_(`%`_dataidx(i_D), data*{data : data}[i_D])^(i_D<|data*{data : data}|){i_D : nat}))
@@ -22440,7 +23475,7 @@ def $invoke(store : store, funcaddr : funcaddr, val*) : config
   def $invoke{s : store, funcaddr : funcaddr, val* : val*, f : frame, t_1* : valtype*, t_2* : valtype*}(s, funcaddr, val*{val : val}) = `%;%`_config(`%;%`_state(s, f), (val : val <: instr)*{val : val} :: [REF.FUNC_ADDR_instr(funcaddr) CALL_REF_instr((s.FUNCS_store[funcaddr].TYPE_funcinst : deftype <: typeuse))])
     -- Expand: `%~~%`(s.FUNCS_store[funcaddr].TYPE_funcinst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
     -- (Val_type: `%|-%:%`(s, val, t_1))*{t_1 : valtype, val : val}
-    -- if (f = {LOCALS [], MODULE {TYPES [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], EXPORTS []}})
+    -- if (f = {LOCALS [], MODULE {TYPES [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], EXPORTS []}})
 
 ;; A-binary.watsup
 grammar Bbyte : byte
@@ -22543,6 +23578,11 @@ grammar Bmemidx : memidx
   ;; A-binary.watsup
   prod{x : idx} x:Bu32 => x
 
+;; A-binary.watsup
+grammar Btagidx : tagidx
+  ;; A-binary.watsup
+  prod{x : idx} x:Bu32 => x
+
 ;; A-binary.watsup
 grammar Belemidx : elemidx
   ;; A-binary.watsup
@@ -22573,6 +23613,8 @@ grammar Bexternidx : externidx
   prod{x : idx} {0x02 x:Bmemidx} => MEM_externidx(x)
   ;; A-binary.watsup
   prod{x : idx} {0x03 x:Bglobalidx} => GLOBAL_externidx(x)
+  ;; A-binary.watsup
+  prod{x : idx} {0x04 x:Btagidx} => TAG_externidx(x)
 
 ;; A-binary.watsup
 grammar Bnumtype : numtype
@@ -22592,6 +23634,8 @@ grammar Bvectype : vectype
 
 ;; A-binary.watsup
 grammar Babsheaptype : heaptype
+  ;; A-binary.watsup
+  prod 0x69 => EXN_heaptype
   ;; A-binary.watsup
   prod 0x6A => ARRAY_heaptype
   ;; A-binary.watsup
@@ -22612,6 +23656,8 @@ grammar Babsheaptype : heaptype
   prod 0x72 => NOEXTERN_heaptype
   ;; A-binary.watsup
   prod 0x73 => NOFUNC_heaptype
+  ;; A-binary.watsup
+  prod 0x74 => NOEXN_heaptype
 
 ;; A-binary.watsup
 grammar Bheaptype : heaptype
@@ -22717,6 +23763,11 @@ grammar Bmemtype : memtype
   ;; A-binary.watsup
   prod{lim : limits} lim:Blimits => `%PAGE`_memtype(lim)
 
+;; A-binary.watsup
+grammar Btagtype : typeidx
+  ;; A-binary.watsup
+  prod{x : idx} {0x00 x:Btypeidx} => x
+
 ;; A-binary.watsup
 grammar Bexterntype : externtype
   ;; A-binary.watsup
@@ -22727,6 +23778,8 @@ grammar Bexterntype : externtype
   prod{mt : memtype} {0x02 mt:Bmemtype} => MEM_externtype(mt)
   ;; A-binary.watsup
   prod{gt : globaltype} {0x03 gt:Bglobaltype} => GLOBAL_externtype(gt)
+  ;; A-binary.watsup
+  prod{x : idx} {0x04 x:Btagtype} => TAG_externtype(($idx(x) : typevar <: typeuse))
 
 ;; A-binary.watsup
 grammar Bblocktype : blocktype
@@ -22738,6 +23791,17 @@ grammar Bblocktype : blocktype
   prod{i : nat} `%`_s33((i : nat <: int)):Bs33 => _IDX_blocktype(`%`_funcidx(i))
     -- if (i >= 0)
 
+;; A-binary.watsup
+grammar Bcatch : catch
+  ;; A-binary.watsup
+  prod{x : idx, l : labelidx} {0x00 x:Btagidx l:Blabelidx} => CATCH_catch(x, l)
+  ;; A-binary.watsup
+  prod{x : idx, l : labelidx} {0x01 x:Btagidx l:Blabelidx} => CATCH_REF_catch(x, l)
+  ;; A-binary.watsup
+  prod{l : labelidx} {0x02 l:Blabelidx} => CATCH_ALL_catch(l)
+  ;; A-binary.watsup
+  prod{l : labelidx} {0x03 l:Blabelidx} => CATCH_ALL_REF_catch(l)
+
 ;; A-binary.watsup
 syntax castop = (nul, nul)
 
@@ -22772,953 +23836,959 @@ grammar Blaneidx : laneidx
 ;; A-binary.watsup
 rec {
 
-;; A-binary.watsup:963.1-973.66
+;; A-binary.watsup:981.1-991.66
 grammar Binstr : instr
-  ;; A-binary.watsup:206.5-206.24
+  ;; A-binary.watsup:214.5-214.24
   prod 0x00 => UNREACHABLE_instr
-  ;; A-binary.watsup:207.5-207.16
+  ;; A-binary.watsup:215.5-215.16
   prod 0x01 => NOP_instr
-  ;; A-binary.watsup:208.5-208.57
+  ;; A-binary.watsup:216.5-216.57
   prod{bt : blocktype, in* : instr*} {0x02 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => BLOCK_instr(bt, in*{in : instr})
-  ;; A-binary.watsup:209.5-209.56
+  ;; A-binary.watsup:217.5-217.56
   prod{bt : blocktype, in* : instr*} {0x03 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => LOOP_instr(bt, in*{in : instr})
-  ;; A-binary.watsup:210.5-210.63
+  ;; A-binary.watsup:218.5-218.63
   prod{bt : blocktype, in* : instr*} {0x04 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => `IF%%ELSE%`_instr(bt, in*{in : instr}, [])
-  ;; A-binary.watsup:211.5-215.55
+  ;; A-binary.watsup:219.5-223.55
   prod{bt : blocktype, in_1* : instr*, in_2* : instr*} {0x04 bt:Bblocktype in_1:Binstr*{in_1 : instr} 0x05 in_2:Binstr*{in_2 : instr} 0x0B} => `IF%%ELSE%`_instr(bt, in_1*{in_1 : instr}, in_2*{in_2 : instr})
-  ;; A-binary.watsup:216.5-216.29
+  ;; A-binary.watsup:224.5-224.30
+  prod{x : idx} {0x08 x:Btagidx} => THROW_instr(x)
+  ;; A-binary.watsup:225.5-225.22
+  prod 0x0A => THROW_REF_instr
+  ;; A-binary.watsup:226.5-226.29
   prod{l : labelidx} {0x0C l:Blabelidx} => BR_instr(l)
-  ;; A-binary.watsup:217.5-217.32
+  ;; A-binary.watsup:227.5-227.32
   prod{l : labelidx} {0x0D l:Blabelidx} => BR_IF_instr(l)
-  ;; A-binary.watsup:218.5-218.62
+  ;; A-binary.watsup:228.5-228.62
   prod{l* : labelidx*, l_n : labelidx} {0x0E l*{l : labelidx}:Blist(syntax labelidx, grammar Blabelidx) l_n:Blabelidx} => BR_TABLE_instr(l*{l : labelidx}, l_n)
-  ;; A-binary.watsup:219.5-219.19
+  ;; A-binary.watsup:229.5-229.19
   prod 0x0F => RETURN_instr
-  ;; A-binary.watsup:220.5-220.30
+  ;; A-binary.watsup:230.5-230.30
   prod{x : idx} {0x10 x:Bfuncidx} => CALL_instr(x)
-  ;; A-binary.watsup:221.5-221.59
+  ;; A-binary.watsup:231.5-231.59
   prod{y : idx, x : idx} {0x11 y:Btypeidx x:Btableidx} => CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse))
-  ;; A-binary.watsup:222.5-222.37
+  ;; A-binary.watsup:232.5-232.37
   prod{x : idx} {0x12 x:Bfuncidx} => RETURN_CALL_instr(x)
-  ;; A-binary.watsup:223.5-223.66
+  ;; A-binary.watsup:233.5-233.66
   prod{y : idx, x : idx} {0x13 y:Btypeidx x:Btableidx} => RETURN_CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse))
-  ;; A-binary.watsup:238.5-238.37
+  ;; A-binary.watsup:234.5-235.26
+  prod{bt : blocktype, c* : catch*, in* : instr*} {0x1F bt:Bblocktype c*{c : catch}:Blist(syntax catch, grammar Bcatch) in:Binstr*{in : instr} 0x0B} => TRY_TABLE_instr(bt, `%`_list(c*{c : catch}), in*{in : instr})
+  ;; A-binary.watsup:256.5-256.37
   prod{ht : heaptype} {0xD0 ht:Bheaptype} => REF.NULL_instr(ht)
-  ;; A-binary.watsup:239.5-239.24
+  ;; A-binary.watsup:257.5-257.24
   prod 0xD1 => REF.IS_NULL_instr
-  ;; A-binary.watsup:240.5-240.34
+  ;; A-binary.watsup:258.5-258.34
   prod{x : idx} {0xD2 x:Bfuncidx} => REF.FUNC_instr(x)
-  ;; A-binary.watsup:241.5-241.19
+  ;; A-binary.watsup:259.5-259.19
   prod 0xD3 => REF.EQ_instr
-  ;; A-binary.watsup:242.5-242.28
+  ;; A-binary.watsup:260.5-260.28
   prod 0xD4 => REF.AS_NON_NULL_instr
-  ;; A-binary.watsup:243.5-243.37
+  ;; A-binary.watsup:261.5-261.37
   prod{l : labelidx} {0xD5 l:Blabelidx} => BR_ON_NULL_instr(l)
-  ;; A-binary.watsup:244.5-244.41
+  ;; A-binary.watsup:262.5-262.41
   prod{l : labelidx} {0xD6 l:Blabelidx} => BR_ON_NON_NULL_instr(l)
-  ;; A-binary.watsup:248.5-248.43
+  ;; A-binary.watsup:266.5-266.43
   prod{x : idx} {0xFB `%`_u32(0):Bu32 x:Btypeidx} => STRUCT.NEW_instr(x)
-  ;; A-binary.watsup:249.5-249.51
+  ;; A-binary.watsup:267.5-267.51
   prod{x : idx} {0xFB `%`_u32(1):Bu32 x:Btypeidx} => STRUCT.NEW_DEFAULT_instr(x)
-  ;; A-binary.watsup:250.5-250.52
+  ;; A-binary.watsup:268.5-268.52
   prod{x : idx, i : nat} {0xFB `%`_u32(2):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(), x, `%`_u32(i))
-  ;; A-binary.watsup:251.5-251.54
+  ;; A-binary.watsup:269.5-269.54
   prod{x : idx, i : nat} {0xFB `%`_u32(3):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(S_sx), x, `%`_u32(i))
-  ;; A-binary.watsup:252.5-252.54
+  ;; A-binary.watsup:270.5-270.54
   prod{x : idx, i : nat} {0xFB `%`_u32(4):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(U_sx), x, `%`_u32(i))
-  ;; A-binary.watsup:253.5-253.52
+  ;; A-binary.watsup:271.5-271.52
   prod{x : idx, i : nat} {0xFB `%`_u32(5):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.SET_instr(x, `%`_u32(i))
-  ;; A-binary.watsup:257.5-257.42
+  ;; A-binary.watsup:275.5-275.42
   prod{x : idx} {0xFB `%`_u32(6):Bu32 x:Btypeidx} => ARRAY.NEW_instr(x)
-  ;; A-binary.watsup:258.5-258.50
+  ;; A-binary.watsup:276.5-276.50
   prod{x : idx} {0xFB `%`_u32(7):Bu32 x:Btypeidx} => ARRAY.NEW_DEFAULT_instr(x)
-  ;; A-binary.watsup:259.5-259.57
+  ;; A-binary.watsup:277.5-277.57
   prod{x : idx, n : n} {0xFB `%`_u32(8):Bu32 x:Btypeidx `%`_u32(n):Bu32} => ARRAY.NEW_FIXED_instr(x, `%`_u32(n))
-  ;; A-binary.watsup:260.5-260.60
+  ;; A-binary.watsup:278.5-278.60
   prod{x : idx, y : idx} {0xFB `%`_u32(9):Bu32 x:Btypeidx y:Bdataidx} => ARRAY.NEW_DATA_instr(x, y)
-  ;; A-binary.watsup:261.5-261.61
+  ;; A-binary.watsup:279.5-279.61
   prod{x : idx, y : idx} {0xFB `%`_u32(10):Bu32 x:Btypeidx y:Belemidx} => ARRAY.NEW_ELEM_instr(x, y)
-  ;; A-binary.watsup:262.5-262.43
+  ;; A-binary.watsup:280.5-280.43
   prod{x : idx} {0xFB `%`_u32(11):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(), x)
-  ;; A-binary.watsup:263.5-263.45
+  ;; A-binary.watsup:281.5-281.45
   prod{x : idx} {0xFB `%`_u32(12):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(S_sx), x)
-  ;; A-binary.watsup:264.5-264.45
+  ;; A-binary.watsup:282.5-282.45
   prod{x : idx} {0xFB `%`_u32(13):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(U_sx), x)
-  ;; A-binary.watsup:265.5-265.43
+  ;; A-binary.watsup:283.5-283.43
   prod{x : idx} {0xFB `%`_u32(14):Bu32 x:Btypeidx} => ARRAY.SET_instr(x)
-  ;; A-binary.watsup:266.5-266.30
+  ;; A-binary.watsup:284.5-284.30
   prod {0xFB `%`_u32(15):Bu32} => ARRAY.LEN_instr
-  ;; A-binary.watsup:267.5-267.44
+  ;; A-binary.watsup:285.5-285.44
   prod{x : idx} {0xFB `%`_u32(16):Bu32 x:Btypeidx} => ARRAY.FILL_instr(x)
-  ;; A-binary.watsup:268.5-268.65
+  ;; A-binary.watsup:286.5-286.65
   prod{x_1 : idx, x_2 : idx} {0xFB `%`_u32(17):Bu32 x_1:Btypeidx x_2:Btypeidx} => ARRAY.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:269.5-269.62
+  ;; A-binary.watsup:287.5-287.62
   prod{x : idx, y : idx} {0xFB `%`_u32(18):Bu32 x:Btypeidx y:Bdataidx} => ARRAY.INIT_DATA_instr(x, y)
-  ;; A-binary.watsup:270.5-270.62
+  ;; A-binary.watsup:288.5-288.62
   prod{x : idx, y : idx} {0xFB `%`_u32(19):Bu32 x:Btypeidx y:Belemidx} => ARRAY.INIT_ELEM_instr(x, y)
-  ;; A-binary.watsup:274.5-274.51
+  ;; A-binary.watsup:292.5-292.51
   prod{ht : heaptype} {0xFB `%`_u32(20):Bu32 ht:Bheaptype} => REF.TEST_instr(REF_reftype(`NULL%?`_nul(?()), ht))
-  ;; A-binary.watsup:275.5-275.56
+  ;; A-binary.watsup:293.5-293.56
   prod{ht : heaptype} {0xFB `%`_u32(21):Bu32 ht:Bheaptype} => REF.TEST_instr(REF_reftype(`NULL%?`_nul(?(())), ht))
-  ;; A-binary.watsup:276.5-276.51
+  ;; A-binary.watsup:294.5-294.51
   prod{ht : heaptype} {0xFB `%`_u32(22):Bu32 ht:Bheaptype} => REF.CAST_instr(REF_reftype(`NULL%?`_nul(?()), ht))
-  ;; A-binary.watsup:277.5-277.56
+  ;; A-binary.watsup:295.5-295.56
   prod{ht : heaptype} {0xFB `%`_u32(23):Bu32 ht:Bheaptype} => REF.CAST_instr(REF_reftype(`NULL%?`_nul(?(())), ht))
-  ;; A-binary.watsup:278.5-282.94
+  ;; A-binary.watsup:296.5-300.94
   prod{nul1 : nul1, nul2 : nul2, l : labelidx, ht_1 : heaptype, ht_2 : heaptype} {0xFB `%`_u32(24):Bu32 (nul1, nul2):Bcastop l:Blabelidx ht_1:Bheaptype ht_2:Bheaptype} => BR_ON_CAST_instr(l, REF_reftype(nul1, ht_1), REF_reftype(nul2, ht_2))
-  ;; A-binary.watsup:283.5-287.99
+  ;; A-binary.watsup:301.5-305.99
   prod{nul1 : nul1, nul2 : nul2, l : labelidx, ht_1 : heaptype, ht_2 : heaptype} {0xFB `%`_u32(25):Bu32 (nul1, nul2):Bcastop l:Blabelidx ht_1:Bheaptype ht_2:Bheaptype} => BR_ON_CAST_FAIL_instr(l, REF_reftype(nul1, ht_1), REF_reftype(nul2, ht_2))
-  ;; A-binary.watsup:291.5-291.39
+  ;; A-binary.watsup:309.5-309.39
   prod {0xFB `%`_u32(26):Bu32} => ANY.CONVERT_EXTERN_instr
-  ;; A-binary.watsup:292.5-292.39
+  ;; A-binary.watsup:310.5-310.39
   prod {0xFB `%`_u32(27):Bu32} => EXTERN.CONVERT_ANY_instr
-  ;; A-binary.watsup:296.5-296.28
+  ;; A-binary.watsup:314.5-314.28
   prod {0xFB `%`_u32(28):Bu32} => REF.I31_instr
-  ;; A-binary.watsup:297.5-297.30
+  ;; A-binary.watsup:315.5-315.30
   prod {0xFB `%`_u32(29):Bu32} => I31.GET_instr(S_sx)
-  ;; A-binary.watsup:298.5-298.30
+  ;; A-binary.watsup:316.5-316.30
   prod {0xFB `%`_u32(30):Bu32} => I31.GET_instr(U_sx)
-  ;; A-binary.watsup:305.5-305.17
+  ;; A-binary.watsup:323.5-323.17
   prod 0x1A => DROP_instr
-  ;; A-binary.watsup:306.5-306.19
+  ;; A-binary.watsup:324.5-324.19
   prod 0x1B => `SELECT()%?`_instr(?())
-  ;; A-binary.watsup:307.5-307.41
+  ;; A-binary.watsup:325.5-325.41
   prod{ts : valtype} {0x1C [ts]:Blist(syntax valtype, grammar Bvaltype)} => `SELECT()%?`_instr(?([ts]))
-  ;; A-binary.watsup:314.5-314.36
+  ;; A-binary.watsup:332.5-332.36
   prod{x : idx} {0x20 x:Blocalidx} => LOCAL.GET_instr(x)
-  ;; A-binary.watsup:315.5-315.36
+  ;; A-binary.watsup:333.5-333.36
   prod{x : idx} {0x21 x:Blocalidx} => LOCAL.SET_instr(x)
-  ;; A-binary.watsup:316.5-316.36
+  ;; A-binary.watsup:334.5-334.36
   prod{x : idx} {0x22 x:Blocalidx} => LOCAL.TEE_instr(x)
-  ;; A-binary.watsup:320.5-320.38
+  ;; A-binary.watsup:338.5-338.38
   prod{x : idx} {0x23 x:Bglobalidx} => GLOBAL.GET_instr(x)
-  ;; A-binary.watsup:321.5-321.38
+  ;; A-binary.watsup:339.5-339.38
   prod{x : idx} {0x24 x:Bglobalidx} => GLOBAL.SET_instr(x)
-  ;; A-binary.watsup:328.5-328.36
+  ;; A-binary.watsup:346.5-346.36
   prod{x : idx} {0x25 x:Btableidx} => TABLE.GET_instr(x)
-  ;; A-binary.watsup:329.5-329.36
+  ;; A-binary.watsup:347.5-347.36
   prod{x : idx} {0x26 x:Btableidx} => TABLE.SET_instr(x)
-  ;; A-binary.watsup:330.5-330.58
+  ;; A-binary.watsup:348.5-348.58
   prod{y : idx, x : idx} {0xFC `%`_u32(12):Bu32 y:Belemidx x:Btableidx} => TABLE.INIT_instr(x, y)
-  ;; A-binary.watsup:331.5-331.43
+  ;; A-binary.watsup:349.5-349.43
   prod{x : idx} {0xFC `%`_u32(13):Bu32 x:Belemidx} => ELEM.DROP_instr(x)
-  ;; A-binary.watsup:332.5-332.67
+  ;; A-binary.watsup:350.5-350.67
   prod{x_1 : idx, x_2 : idx} {0xFC `%`_u32(14):Bu32 x_1:Btableidx x_2:Btableidx} => TABLE.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:333.5-333.45
+  ;; A-binary.watsup:351.5-351.45
   prod{x : idx} {0xFC `%`_u32(15):Bu32 x:Btableidx} => TABLE.GROW_instr(x)
-  ;; A-binary.watsup:334.5-334.45
+  ;; A-binary.watsup:352.5-352.45
   prod{x : idx} {0xFC `%`_u32(16):Bu32 x:Btableidx} => TABLE.SIZE_instr(x)
-  ;; A-binary.watsup:335.5-335.45
+  ;; A-binary.watsup:353.5-353.45
   prod{x : idx} {0xFC `%`_u32(17):Bu32 x:Btableidx} => TABLE.FILL_instr(x)
-  ;; A-binary.watsup:348.5-348.41
+  ;; A-binary.watsup:366.5-366.41
   prod{x : idx, ao : memarg} {0x28 (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:349.5-349.41
+  ;; A-binary.watsup:367.5-367.41
   prod{x : idx, ao : memarg} {0x29 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:350.5-350.41
+  ;; A-binary.watsup:368.5-368.41
   prod{x : idx, ao : memarg} {0x2A (x, ao):Bmemarg} => LOAD_instr(F32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:351.5-351.41
+  ;; A-binary.watsup:369.5-369.41
   prod{x : idx, ao : memarg} {0x2B (x, ao):Bmemarg} => LOAD_instr(F64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:352.5-352.48
+  ;; A-binary.watsup:370.5-370.48
   prod{x : idx, ao : memarg} {0x2C (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(8), S_sx)), x, ao)
-  ;; A-binary.watsup:353.5-353.48
+  ;; A-binary.watsup:371.5-371.48
   prod{x : idx, ao : memarg} {0x2D (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(8), U_sx)), x, ao)
-  ;; A-binary.watsup:354.5-354.49
+  ;; A-binary.watsup:372.5-372.49
   prod{x : idx, ao : memarg} {0x2E (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(16), S_sx)), x, ao)
-  ;; A-binary.watsup:355.5-355.49
+  ;; A-binary.watsup:373.5-373.49
   prod{x : idx, ao : memarg} {0x2F (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(16), U_sx)), x, ao)
-  ;; A-binary.watsup:356.5-356.48
+  ;; A-binary.watsup:374.5-374.48
   prod{x : idx, ao : memarg} {0x30 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(8), S_sx)), x, ao)
-  ;; A-binary.watsup:357.5-357.48
+  ;; A-binary.watsup:375.5-375.48
   prod{x : idx, ao : memarg} {0x31 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(8), U_sx)), x, ao)
-  ;; A-binary.watsup:358.5-358.49
+  ;; A-binary.watsup:376.5-376.49
   prod{x : idx, ao : memarg} {0x32 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(16), S_sx)), x, ao)
-  ;; A-binary.watsup:359.5-359.49
+  ;; A-binary.watsup:377.5-377.49
   prod{x : idx, ao : memarg} {0x33 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(16), U_sx)), x, ao)
-  ;; A-binary.watsup:360.5-360.49
+  ;; A-binary.watsup:378.5-378.49
   prod{x : idx, ao : memarg} {0x34 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(32), S_sx)), x, ao)
-  ;; A-binary.watsup:361.5-361.49
+  ;; A-binary.watsup:379.5-379.49
   prod{x : idx, ao : memarg} {0x35 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(32), U_sx)), x, ao)
-  ;; A-binary.watsup:362.5-362.42
+  ;; A-binary.watsup:380.5-380.42
   prod{x : idx, ao : memarg} {0x36 (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:363.5-363.42
+  ;; A-binary.watsup:381.5-381.42
   prod{x : idx, ao : memarg} {0x37 (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:364.5-364.42
+  ;; A-binary.watsup:382.5-382.42
   prod{x : idx, ao : memarg} {0x38 (x, ao):Bmemarg} => STORE_instr(F32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:365.5-365.42
+  ;; A-binary.watsup:383.5-383.42
   prod{x : idx, ao : memarg} {0x39 (x, ao):Bmemarg} => STORE_instr(F64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:366.5-366.45
+  ;; A-binary.watsup:384.5-384.45
   prod{x : idx, ao : memarg} {0x3A (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(`%`_sz(8)), x, ao)
-  ;; A-binary.watsup:367.5-367.46
+  ;; A-binary.watsup:385.5-385.46
   prod{x : idx, ao : memarg} {0x3B (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(`%`_sz(16)), x, ao)
-  ;; A-binary.watsup:368.5-368.45
+  ;; A-binary.watsup:386.5-386.45
   prod{x : idx, ao : memarg} {0x3C (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(8)), x, ao)
-  ;; A-binary.watsup:369.5-369.46
+  ;; A-binary.watsup:387.5-387.46
   prod{x : idx, ao : memarg} {0x3D (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(16)), x, ao)
-  ;; A-binary.watsup:370.5-370.46
+  ;; A-binary.watsup:388.5-388.46
   prod{x : idx, ao : memarg} {0x3E (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(32)), x, ao)
-  ;; A-binary.watsup:371.5-371.36
+  ;; A-binary.watsup:389.5-389.36
   prod{x : idx} {0x3F x:Bmemidx} => MEMORY.SIZE_instr(x)
-  ;; A-binary.watsup:372.5-372.36
+  ;; A-binary.watsup:390.5-390.36
   prod{x : idx} {0x40 x:Bmemidx} => MEMORY.GROW_instr(x)
-  ;; A-binary.watsup:373.5-373.56
+  ;; A-binary.watsup:391.5-391.56
   prod{y : idx, x : idx} {0xFC `%`_u32(8):Bu32 y:Bdataidx x:Bmemidx} => MEMORY.INIT_instr(x, y)
-  ;; A-binary.watsup:374.5-374.42
+  ;; A-binary.watsup:392.5-392.42
   prod{x : idx} {0xFC `%`_u32(9):Bu32 x:Bdataidx} => DATA.DROP_instr(x)
-  ;; A-binary.watsup:375.5-375.64
+  ;; A-binary.watsup:393.5-393.64
   prod{x_1 : idx, x_2 : idx} {0xFC `%`_u32(10):Bu32 x_1:Bmemidx x_2:Bmemidx} => MEMORY.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:376.5-376.44
+  ;; A-binary.watsup:394.5-394.44
   prod{x : idx} {0xFC `%`_u32(11):Bu32 x:Bmemidx} => MEMORY.FILL_instr(x)
-  ;; A-binary.watsup:384.5-384.31
+  ;; A-binary.watsup:402.5-402.31
   prod{n : n} {0x41 `%`_u32(n):Bu32} => CONST_instr(I32_numtype, `%`_num_(n))
-  ;; A-binary.watsup:385.5-385.31
+  ;; A-binary.watsup:403.5-403.31
   prod{n : n} {0x42 `%`_u64(n):Bu64} => CONST_instr(I64_numtype, `%`_num_(n))
-  ;; A-binary.watsup:386.5-386.31
+  ;; A-binary.watsup:404.5-404.31
   prod{p : f32} {0x43 p:Bf32} => CONST_instr(F32_numtype, p)
-  ;; A-binary.watsup:387.5-387.31
+  ;; A-binary.watsup:405.5-405.31
   prod{p : f64} {0x44 p:Bf64} => CONST_instr(F64_numtype, p)
-  ;; A-binary.watsup:391.5-391.27
+  ;; A-binary.watsup:409.5-409.27
   prod 0x45 => TESTOP_instr(I32_numtype, EQZ_testop_)
-  ;; A-binary.watsup:395.5-395.25
+  ;; A-binary.watsup:413.5-413.25
   prod 0x46 => RELOP_instr(I32_numtype, EQ_relop_)
-  ;; A-binary.watsup:396.5-396.25
+  ;; A-binary.watsup:414.5-414.25
   prod 0x47 => RELOP_instr(I32_numtype, NE_relop_)
-  ;; A-binary.watsup:397.5-397.29
+  ;; A-binary.watsup:415.5-415.29
   prod 0x48 => RELOP_instr(I32_numtype, LT_relop_(S_sx))
-  ;; A-binary.watsup:398.5-398.29
+  ;; A-binary.watsup:416.5-416.29
   prod 0x49 => RELOP_instr(I32_numtype, LT_relop_(U_sx))
-  ;; A-binary.watsup:399.5-399.29
+  ;; A-binary.watsup:417.5-417.29
   prod 0x4A => RELOP_instr(I32_numtype, GT_relop_(S_sx))
-  ;; A-binary.watsup:400.5-400.29
+  ;; A-binary.watsup:418.5-418.29
   prod 0x4B => RELOP_instr(I32_numtype, GT_relop_(U_sx))
-  ;; A-binary.watsup:401.5-401.29
+  ;; A-binary.watsup:419.5-419.29
   prod 0x4C => RELOP_instr(I32_numtype, LE_relop_(S_sx))
-  ;; A-binary.watsup:402.5-402.29
+  ;; A-binary.watsup:420.5-420.29
   prod 0x4D => RELOP_instr(I32_numtype, LE_relop_(U_sx))
-  ;; A-binary.watsup:403.5-403.29
+  ;; A-binary.watsup:421.5-421.29
   prod 0x4E => RELOP_instr(I32_numtype, GE_relop_(S_sx))
-  ;; A-binary.watsup:404.5-404.29
+  ;; A-binary.watsup:422.5-422.29
   prod 0x4F => RELOP_instr(I32_numtype, GE_relop_(U_sx))
-  ;; A-binary.watsup:408.5-408.27
+  ;; A-binary.watsup:426.5-426.27
   prod 0x50 => TESTOP_instr(I64_numtype, EQZ_testop_)
-  ;; A-binary.watsup:412.5-412.25
+  ;; A-binary.watsup:430.5-430.25
   prod 0x51 => RELOP_instr(I64_numtype, EQ_relop_)
-  ;; A-binary.watsup:413.5-413.25
+  ;; A-binary.watsup:431.5-431.25
   prod 0x52 => RELOP_instr(I64_numtype, NE_relop_)
-  ;; A-binary.watsup:414.5-414.29
+  ;; A-binary.watsup:432.5-432.29
   prod 0x53 => RELOP_instr(I64_numtype, LT_relop_(S_sx))
-  ;; A-binary.watsup:415.5-415.29
+  ;; A-binary.watsup:433.5-433.29
   prod 0x54 => RELOP_instr(I64_numtype, LT_relop_(U_sx))
-  ;; A-binary.watsup:416.5-416.29
+  ;; A-binary.watsup:434.5-434.29
   prod 0x55 => RELOP_instr(I64_numtype, GT_relop_(S_sx))
-  ;; A-binary.watsup:417.5-417.29
+  ;; A-binary.watsup:435.5-435.29
   prod 0x56 => RELOP_instr(I64_numtype, GT_relop_(U_sx))
-  ;; A-binary.watsup:418.5-418.29
+  ;; A-binary.watsup:436.5-436.29
   prod 0x57 => RELOP_instr(I64_numtype, LE_relop_(S_sx))
-  ;; A-binary.watsup:419.5-419.29
+  ;; A-binary.watsup:437.5-437.29
   prod 0x58 => RELOP_instr(I64_numtype, LE_relop_(U_sx))
-  ;; A-binary.watsup:420.5-420.29
+  ;; A-binary.watsup:438.5-438.29
   prod 0x59 => RELOP_instr(I64_numtype, GE_relop_(S_sx))
-  ;; A-binary.watsup:421.5-421.29
+  ;; A-binary.watsup:439.5-439.29
   prod 0x5A => RELOP_instr(I64_numtype, GE_relop_(U_sx))
-  ;; A-binary.watsup:425.5-425.25
+  ;; A-binary.watsup:443.5-443.25
   prod 0x5B => RELOP_instr(F32_numtype, EQ_relop_)
-  ;; A-binary.watsup:426.5-426.25
+  ;; A-binary.watsup:444.5-444.25
   prod 0x5C => RELOP_instr(F32_numtype, NE_relop_)
-  ;; A-binary.watsup:427.5-427.25
+  ;; A-binary.watsup:445.5-445.25
   prod 0x5D => RELOP_instr(F32_numtype, LT_relop_)
-  ;; A-binary.watsup:428.5-428.25
+  ;; A-binary.watsup:446.5-446.25
   prod 0x5E => RELOP_instr(F32_numtype, GT_relop_)
-  ;; A-binary.watsup:429.5-429.25
+  ;; A-binary.watsup:447.5-447.25
   prod 0x5F => RELOP_instr(F32_numtype, LE_relop_)
-  ;; A-binary.watsup:430.5-430.25
+  ;; A-binary.watsup:448.5-448.25
   prod 0x60 => RELOP_instr(F32_numtype, GE_relop_)
-  ;; A-binary.watsup:434.5-434.25
+  ;; A-binary.watsup:452.5-452.25
   prod 0x61 => RELOP_instr(F64_numtype, EQ_relop_)
-  ;; A-binary.watsup:435.5-435.25
+  ;; A-binary.watsup:453.5-453.25
   prod 0x62 => RELOP_instr(F64_numtype, NE_relop_)
-  ;; A-binary.watsup:436.5-436.25
+  ;; A-binary.watsup:454.5-454.25
   prod 0x63 => RELOP_instr(F64_numtype, LT_relop_)
-  ;; A-binary.watsup:437.5-437.25
+  ;; A-binary.watsup:455.5-455.25
   prod 0x64 => RELOP_instr(F64_numtype, GT_relop_)
-  ;; A-binary.watsup:438.5-438.25
+  ;; A-binary.watsup:456.5-456.25
   prod 0x65 => RELOP_instr(F64_numtype, LE_relop_)
-  ;; A-binary.watsup:439.5-439.25
+  ;; A-binary.watsup:457.5-457.25
   prod 0x66 => RELOP_instr(F64_numtype, GE_relop_)
-  ;; A-binary.watsup:443.5-443.25
+  ;; A-binary.watsup:461.5-461.25
   prod 0x67 => UNOP_instr(I32_numtype, CLZ_unop_)
-  ;; A-binary.watsup:444.5-444.25
+  ;; A-binary.watsup:462.5-462.25
   prod 0x68 => UNOP_instr(I32_numtype, CTZ_unop_)
-  ;; A-binary.watsup:445.5-445.28
+  ;; A-binary.watsup:463.5-463.28
   prod 0x69 => UNOP_instr(I32_numtype, POPCNT_unop_)
-  ;; A-binary.watsup:449.5-449.26
+  ;; A-binary.watsup:467.5-467.26
   prod 0x6A => BINOP_instr(I32_numtype, ADD_binop_)
-  ;; A-binary.watsup:450.5-450.26
+  ;; A-binary.watsup:468.5-468.26
   prod 0x6B => BINOP_instr(I32_numtype, SUB_binop_)
-  ;; A-binary.watsup:451.5-451.26
+  ;; A-binary.watsup:469.5-469.26
   prod 0x6C => BINOP_instr(I32_numtype, MUL_binop_)
-  ;; A-binary.watsup:452.5-452.30
+  ;; A-binary.watsup:470.5-470.30
   prod 0x6D => BINOP_instr(I32_numtype, DIV_binop_(S_sx))
-  ;; A-binary.watsup:453.5-453.30
+  ;; A-binary.watsup:471.5-471.30
   prod 0x6E => BINOP_instr(I32_numtype, DIV_binop_(U_sx))
-  ;; A-binary.watsup:454.5-454.30
+  ;; A-binary.watsup:472.5-472.30
   prod 0x6F => BINOP_instr(I32_numtype, REM_binop_(S_sx))
-  ;; A-binary.watsup:455.5-455.30
+  ;; A-binary.watsup:473.5-473.30
   prod 0x70 => BINOP_instr(I32_numtype, REM_binop_(U_sx))
-  ;; A-binary.watsup:456.5-456.26
+  ;; A-binary.watsup:474.5-474.26
   prod 0x71 => BINOP_instr(I32_numtype, AND_binop_)
-  ;; A-binary.watsup:457.5-457.25
+  ;; A-binary.watsup:475.5-475.25
   prod 0x72 => BINOP_instr(I32_numtype, OR_binop_)
-  ;; A-binary.watsup:458.5-458.26
+  ;; A-binary.watsup:476.5-476.26
   prod 0x73 => BINOP_instr(I32_numtype, XOR_binop_)
-  ;; A-binary.watsup:459.5-459.26
+  ;; A-binary.watsup:477.5-477.26
   prod 0x74 => BINOP_instr(I32_numtype, SHL_binop_)
-  ;; A-binary.watsup:460.5-460.30
+  ;; A-binary.watsup:478.5-478.30
   prod 0x75 => BINOP_instr(I32_numtype, SHR_binop_(S_sx))
-  ;; A-binary.watsup:461.5-461.30
+  ;; A-binary.watsup:479.5-479.30
   prod 0x76 => BINOP_instr(I32_numtype, SHR_binop_(U_sx))
-  ;; A-binary.watsup:462.5-462.27
+  ;; A-binary.watsup:480.5-480.27
   prod 0x77 => BINOP_instr(I32_numtype, ROTL_binop_)
-  ;; A-binary.watsup:463.5-463.27
+  ;; A-binary.watsup:481.5-481.27
   prod 0x78 => BINOP_instr(I32_numtype, ROTR_binop_)
-  ;; A-binary.watsup:467.5-467.25
+  ;; A-binary.watsup:485.5-485.25
   prod 0x79 => UNOP_instr(I64_numtype, CLZ_unop_)
-  ;; A-binary.watsup:468.5-468.25
+  ;; A-binary.watsup:486.5-486.25
   prod 0x7A => UNOP_instr(I64_numtype, CTZ_unop_)
-  ;; A-binary.watsup:469.5-469.28
+  ;; A-binary.watsup:487.5-487.28
   prod 0x7B => UNOP_instr(I64_numtype, POPCNT_unop_)
-  ;; A-binary.watsup:473.5-473.33
+  ;; A-binary.watsup:491.5-491.33
   prod 0xC0 => UNOP_instr(I32_numtype, EXTEND_unop_(`%`_sz(8)))
-  ;; A-binary.watsup:474.5-474.34
+  ;; A-binary.watsup:492.5-492.34
   prod 0xC1 => UNOP_instr(I32_numtype, EXTEND_unop_(`%`_sz(16)))
-  ;; A-binary.watsup:478.5-478.33
+  ;; A-binary.watsup:496.5-496.33
   prod 0xC2 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(8)))
-  ;; A-binary.watsup:479.5-479.34
+  ;; A-binary.watsup:497.5-497.34
   prod 0xC3 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(16)))
-  ;; A-binary.watsup:480.5-480.34
+  ;; A-binary.watsup:498.5-498.34
   prod 0xC4 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(32)))
-  ;; A-binary.watsup:484.5-484.26
+  ;; A-binary.watsup:502.5-502.26
   prod 0x7C => BINOP_instr(I64_numtype, ADD_binop_)
-  ;; A-binary.watsup:485.5-485.26
+  ;; A-binary.watsup:503.5-503.26
   prod 0x7D => BINOP_instr(I64_numtype, SUB_binop_)
-  ;; A-binary.watsup:486.5-486.26
+  ;; A-binary.watsup:504.5-504.26
   prod 0x7E => BINOP_instr(I64_numtype, MUL_binop_)
-  ;; A-binary.watsup:487.5-487.30
+  ;; A-binary.watsup:505.5-505.30
   prod 0x7F => BINOP_instr(I64_numtype, DIV_binop_(S_sx))
-  ;; A-binary.watsup:488.5-488.30
+  ;; A-binary.watsup:506.5-506.30
   prod 0x80 => BINOP_instr(I64_numtype, DIV_binop_(U_sx))
-  ;; A-binary.watsup:489.5-489.30
+  ;; A-binary.watsup:507.5-507.30
   prod 0x81 => BINOP_instr(I64_numtype, REM_binop_(S_sx))
-  ;; A-binary.watsup:490.5-490.30
+  ;; A-binary.watsup:508.5-508.30
   prod 0x82 => BINOP_instr(I64_numtype, REM_binop_(U_sx))
-  ;; A-binary.watsup:491.5-491.26
+  ;; A-binary.watsup:509.5-509.26
   prod 0x83 => BINOP_instr(I64_numtype, AND_binop_)
-  ;; A-binary.watsup:492.5-492.25
+  ;; A-binary.watsup:510.5-510.25
   prod 0x84 => BINOP_instr(I64_numtype, OR_binop_)
-  ;; A-binary.watsup:493.5-493.26
+  ;; A-binary.watsup:511.5-511.26
   prod 0x85 => BINOP_instr(I64_numtype, XOR_binop_)
-  ;; A-binary.watsup:494.5-494.26
+  ;; A-binary.watsup:512.5-512.26
   prod 0x86 => BINOP_instr(I64_numtype, SHL_binop_)
-  ;; A-binary.watsup:495.5-495.30
+  ;; A-binary.watsup:513.5-513.30
   prod 0x87 => BINOP_instr(I64_numtype, SHR_binop_(S_sx))
-  ;; A-binary.watsup:496.5-496.30
+  ;; A-binary.watsup:514.5-514.30
   prod 0x88 => BINOP_instr(I64_numtype, SHR_binop_(U_sx))
-  ;; A-binary.watsup:497.5-497.27
+  ;; A-binary.watsup:515.5-515.27
   prod 0x89 => BINOP_instr(I64_numtype, ROTL_binop_)
-  ;; A-binary.watsup:498.5-498.27
+  ;; A-binary.watsup:516.5-516.27
   prod 0x8A => BINOP_instr(I64_numtype, ROTR_binop_)
-  ;; A-binary.watsup:502.5-502.25
+  ;; A-binary.watsup:520.5-520.25
   prod 0x8B => UNOP_instr(F32_numtype, ABS_unop_)
-  ;; A-binary.watsup:503.5-503.25
+  ;; A-binary.watsup:521.5-521.25
   prod 0x8C => UNOP_instr(F32_numtype, NEG_unop_)
-  ;; A-binary.watsup:504.5-504.26
+  ;; A-binary.watsup:522.5-522.26
   prod 0x8D => UNOP_instr(F32_numtype, CEIL_unop_)
-  ;; A-binary.watsup:505.5-505.27
+  ;; A-binary.watsup:523.5-523.27
   prod 0x8E => UNOP_instr(F32_numtype, FLOOR_unop_)
-  ;; A-binary.watsup:506.5-506.27
+  ;; A-binary.watsup:524.5-524.27
   prod 0x8F => UNOP_instr(F32_numtype, TRUNC_unop_)
-  ;; A-binary.watsup:507.5-507.29
+  ;; A-binary.watsup:525.5-525.29
   prod 0x90 => UNOP_instr(F32_numtype, NEAREST_unop_)
-  ;; A-binary.watsup:508.5-508.26
+  ;; A-binary.watsup:526.5-526.26
   prod 0x91 => UNOP_instr(F32_numtype, SQRT_unop_)
-  ;; A-binary.watsup:512.5-512.26
+  ;; A-binary.watsup:530.5-530.26
   prod 0x92 => BINOP_instr(F32_numtype, ADD_binop_)
-  ;; A-binary.watsup:513.5-513.26
+  ;; A-binary.watsup:531.5-531.26
   prod 0x93 => BINOP_instr(F32_numtype, SUB_binop_)
-  ;; A-binary.watsup:514.5-514.26
+  ;; A-binary.watsup:532.5-532.26
   prod 0x94 => BINOP_instr(F32_numtype, MUL_binop_)
-  ;; A-binary.watsup:515.5-515.26
+  ;; A-binary.watsup:533.5-533.26
   prod 0x95 => BINOP_instr(F32_numtype, DIV_binop_)
-  ;; A-binary.watsup:516.5-516.26
+  ;; A-binary.watsup:534.5-534.26
   prod 0x96 => BINOP_instr(F32_numtype, MIN_binop_)
-  ;; A-binary.watsup:517.5-517.26
+  ;; A-binary.watsup:535.5-535.26
   prod 0x97 => BINOP_instr(F32_numtype, MAX_binop_)
-  ;; A-binary.watsup:518.5-518.31
+  ;; A-binary.watsup:536.5-536.31
   prod 0x98 => BINOP_instr(F32_numtype, COPYSIGN_binop_)
-  ;; A-binary.watsup:522.5-522.25
+  ;; A-binary.watsup:540.5-540.25
   prod 0x99 => UNOP_instr(F64_numtype, ABS_unop_)
-  ;; A-binary.watsup:523.5-523.25
+  ;; A-binary.watsup:541.5-541.25
   prod 0x9A => UNOP_instr(F64_numtype, NEG_unop_)
-  ;; A-binary.watsup:524.5-524.26
+  ;; A-binary.watsup:542.5-542.26
   prod 0x9B => UNOP_instr(F64_numtype, CEIL_unop_)
-  ;; A-binary.watsup:525.5-525.27
+  ;; A-binary.watsup:543.5-543.27
   prod 0x9C => UNOP_instr(F64_numtype, FLOOR_unop_)
-  ;; A-binary.watsup:526.5-526.27
+  ;; A-binary.watsup:544.5-544.27
   prod 0x9D => UNOP_instr(F64_numtype, TRUNC_unop_)
-  ;; A-binary.watsup:527.5-527.29
+  ;; A-binary.watsup:545.5-545.29
   prod 0x9E => UNOP_instr(F64_numtype, NEAREST_unop_)
-  ;; A-binary.watsup:528.5-528.26
+  ;; A-binary.watsup:546.5-546.26
   prod 0x9F => UNOP_instr(F64_numtype, SQRT_unop_)
-  ;; A-binary.watsup:532.5-532.26
+  ;; A-binary.watsup:550.5-550.26
   prod 0xA0 => BINOP_instr(F64_numtype, ADD_binop_)
-  ;; A-binary.watsup:533.5-533.26
+  ;; A-binary.watsup:551.5-551.26
   prod 0xA1 => BINOP_instr(F64_numtype, SUB_binop_)
-  ;; A-binary.watsup:534.5-534.26
+  ;; A-binary.watsup:552.5-552.26
   prod 0xA2 => BINOP_instr(F64_numtype, MUL_binop_)
-  ;; A-binary.watsup:535.5-535.26
+  ;; A-binary.watsup:553.5-553.26
   prod 0xA3 => BINOP_instr(F64_numtype, DIV_binop_)
-  ;; A-binary.watsup:536.5-536.26
+  ;; A-binary.watsup:554.5-554.26
   prod 0xA4 => BINOP_instr(F64_numtype, MIN_binop_)
-  ;; A-binary.watsup:537.5-537.26
+  ;; A-binary.watsup:555.5-555.26
   prod 0xA5 => BINOP_instr(F64_numtype, MAX_binop_)
-  ;; A-binary.watsup:538.5-538.31
+  ;; A-binary.watsup:556.5-556.31
   prod 0xA6 => BINOP_instr(F64_numtype, COPYSIGN_binop_)
-  ;; A-binary.watsup:543.5-543.31
+  ;; A-binary.watsup:561.5-561.31
   prod 0xA7 => CVTOP_instr(I32_numtype, I64_numtype, WRAP_cvtop__)
-  ;; A-binary.watsup:544.5-544.36
+  ;; A-binary.watsup:562.5-562.36
   prod 0xA8 => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:545.5-545.36
+  ;; A-binary.watsup:563.5-563.36
   prod 0xA9 => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:546.5-546.36
+  ;; A-binary.watsup:564.5-564.36
   prod 0xAA => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:547.5-547.36
+  ;; A-binary.watsup:565.5-565.36
   prod 0xAB => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:548.5-548.37
+  ;; A-binary.watsup:566.5-566.37
   prod 0xAC => CVTOP_instr(I64_numtype, I32_numtype, EXTEND_cvtop__(S_sx))
-  ;; A-binary.watsup:549.5-549.37
+  ;; A-binary.watsup:567.5-567.37
   prod 0xAD => CVTOP_instr(I64_numtype, I32_numtype, EXTEND_cvtop__(U_sx))
-  ;; A-binary.watsup:550.5-550.36
+  ;; A-binary.watsup:568.5-568.36
   prod 0xAE => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:551.5-551.36
+  ;; A-binary.watsup:569.5-569.36
   prod 0xAF => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:552.5-552.36
+  ;; A-binary.watsup:570.5-570.36
   prod 0xB0 => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:553.5-553.36
+  ;; A-binary.watsup:571.5-571.36
   prod 0xB1 => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:554.5-554.38
+  ;; A-binary.watsup:572.5-572.38
   prod 0xB2 => CVTOP_instr(F32_numtype, I32_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:555.5-555.38
+  ;; A-binary.watsup:573.5-573.38
   prod 0xB3 => CVTOP_instr(F32_numtype, I32_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:556.5-556.38
+  ;; A-binary.watsup:574.5-574.38
   prod 0xB4 => CVTOP_instr(F32_numtype, I64_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:557.5-557.38
+  ;; A-binary.watsup:575.5-575.38
   prod 0xB5 => CVTOP_instr(F32_numtype, I64_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:558.5-558.33
+  ;; A-binary.watsup:576.5-576.33
   prod 0xB6 => CVTOP_instr(F32_numtype, F64_numtype, DEMOTE_cvtop__)
-  ;; A-binary.watsup:559.5-559.38
+  ;; A-binary.watsup:577.5-577.38
   prod 0xB7 => CVTOP_instr(F64_numtype, I32_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:560.5-560.38
+  ;; A-binary.watsup:578.5-578.38
   prod 0xB8 => CVTOP_instr(F64_numtype, I32_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:561.5-561.38
+  ;; A-binary.watsup:579.5-579.38
   prod 0xB9 => CVTOP_instr(F64_numtype, I64_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:562.5-562.38
+  ;; A-binary.watsup:580.5-580.38
   prod 0xBA => CVTOP_instr(F64_numtype, I64_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:563.5-563.34
+  ;; A-binary.watsup:581.5-581.34
   prod 0xBB => CVTOP_instr(F32_numtype, F64_numtype, PROMOTE_cvtop__)
-  ;; A-binary.watsup:564.5-564.38
+  ;; A-binary.watsup:582.5-582.38
   prod 0xBC => CVTOP_instr(I32_numtype, F32_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:565.5-565.38
+  ;; A-binary.watsup:583.5-583.38
   prod 0xBD => CVTOP_instr(I64_numtype, F64_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:566.5-566.38
+  ;; A-binary.watsup:584.5-584.38
   prod 0xBE => CVTOP_instr(F32_numtype, I32_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:567.5-567.38
+  ;; A-binary.watsup:585.5-585.38
   prod 0xBF => CVTOP_instr(F64_numtype, I64_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:571.5-571.47
+  ;; A-binary.watsup:589.5-589.47
   prod {0xFC `%`_u32(0):Bu32} => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:572.5-572.47
+  ;; A-binary.watsup:590.5-590.47
   prod {0xFC `%`_u32(1):Bu32} => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:573.5-573.47
+  ;; A-binary.watsup:591.5-591.47
   prod {0xFC `%`_u32(2):Bu32} => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:574.5-574.47
+  ;; A-binary.watsup:592.5-592.47
   prod {0xFC `%`_u32(3):Bu32} => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:575.5-575.47
+  ;; A-binary.watsup:593.5-593.47
   prod {0xFC `%`_u32(4):Bu32} => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:576.5-576.47
+  ;; A-binary.watsup:594.5-594.47
   prod {0xFC `%`_u32(5):Bu32} => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:577.5-577.47
+  ;; A-binary.watsup:595.5-595.47
   prod {0xFC `%`_u32(6):Bu32} => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:578.5-578.47
+  ;; A-binary.watsup:596.5-596.47
   prod {0xFC `%`_u32(7):Bu32} => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:588.5-588.50
+  ;; A-binary.watsup:606.5-606.50
   prod{x : idx, ao : memarg} {0xFD `%`_u32(0):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(), x, ao)
-  ;; A-binary.watsup:589.5-589.68
+  ;; A-binary.watsup:607.5-607.68
   prod{x : idx, ao : memarg} {0xFD `%`_u32(1):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(8), 8, S_sx)), x, ao)
-  ;; A-binary.watsup:590.5-590.68
+  ;; A-binary.watsup:608.5-608.68
   prod{x : idx, ao : memarg} {0xFD `%`_u32(2):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(8), 8, U_sx)), x, ao)
-  ;; A-binary.watsup:591.5-591.69
+  ;; A-binary.watsup:609.5-609.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(3):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(16), 4, S_sx)), x, ao)
-  ;; A-binary.watsup:592.5-592.69
+  ;; A-binary.watsup:610.5-610.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(4):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(16), 4, U_sx)), x, ao)
-  ;; A-binary.watsup:593.5-593.69
+  ;; A-binary.watsup:611.5-611.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(5):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(32), 2, S_sx)), x, ao)
-  ;; A-binary.watsup:594.5-594.69
+  ;; A-binary.watsup:612.5-612.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(6):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(32), 2, U_sx)), x, ao)
-  ;; A-binary.watsup:595.5-595.61
+  ;; A-binary.watsup:613.5-613.61
   prod{x : idx, ao : memarg} {0xFD `%`_u32(7):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(8))), x, ao)
-  ;; A-binary.watsup:596.5-596.62
+  ;; A-binary.watsup:614.5-614.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(8):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(16))), x, ao)
-  ;; A-binary.watsup:597.5-597.62
+  ;; A-binary.watsup:615.5-615.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(9):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(32))), x, ao)
-  ;; A-binary.watsup:598.5-598.63
+  ;; A-binary.watsup:616.5-616.63
   prod{x : idx, ao : memarg} {0xFD `%`_u32(10):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(64))), x, ao)
-  ;; A-binary.watsup:599.5-599.52
+  ;; A-binary.watsup:617.5-617.52
   prod{x : idx, ao : memarg} {0xFD `%`_u32(11):Bu32 (x, ao):Bmemarg} => VSTORE_instr(V128_vectype, x, ao)
-  ;; A-binary.watsup:600.5-600.72
+  ;; A-binary.watsup:618.5-618.72
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(84):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(8), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:601.5-601.73
+  ;; A-binary.watsup:619.5-619.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(85):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(16), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:602.5-602.73
+  ;; A-binary.watsup:620.5-620.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(86):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(32), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:603.5-603.73
+  ;; A-binary.watsup:621.5-621.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(87):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(64), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:604.5-604.73
+  ;; A-binary.watsup:622.5-622.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(88):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(8), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:605.5-605.74
+  ;; A-binary.watsup:623.5-623.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(89):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(16), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:606.5-606.74
+  ;; A-binary.watsup:624.5-624.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(90):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(32), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:607.5-607.74
+  ;; A-binary.watsup:625.5-625.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(91):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(64), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:608.5-608.62
+  ;; A-binary.watsup:626.5-626.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(92):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(32))), x, ao)
-  ;; A-binary.watsup:609.5-609.62
+  ;; A-binary.watsup:627.5-627.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(93):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(64))), x, ao)
-  ;; A-binary.watsup:613.5-613.71
+  ;; A-binary.watsup:631.5-631.71
   prod{b^16 : byte^16} {0xFD `%`_u32(12):Bu32 b:Bbyte^16{b : byte}} => VCONST_instr(V128_vectype, $invibytes_(128, b^16{b : byte}))
-  ;; A-binary.watsup:617.5-617.58
+  ;; A-binary.watsup:635.5-635.58
   prod{l : labelidx} {0xFD `%`_u32(13):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx^16{}} => VSHUFFLE_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), [`%`_uN(l!`%`_labelidx.0)])
-  ;; A-binary.watsup:618.5-618.40
+  ;; A-binary.watsup:636.5-636.40
   prod {0xFD `%`_u32(14):Bu32} => VSWIZZLE_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)))
-  ;; A-binary.watsup:622.5-622.38
+  ;; A-binary.watsup:640.5-640.38
   prod {0xFD `%`_u32(15):Bu32} => VSPLAT_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)))
-  ;; A-binary.watsup:623.5-623.38
+  ;; A-binary.watsup:641.5-641.38
   prod {0xFD `%`_u32(16):Bu32} => VSPLAT_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)))
-  ;; A-binary.watsup:624.5-624.38
+  ;; A-binary.watsup:642.5-642.38
   prod {0xFD `%`_u32(17):Bu32} => VSPLAT_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)))
-  ;; A-binary.watsup:625.5-625.38
+  ;; A-binary.watsup:643.5-643.38
   prod {0xFD `%`_u32(18):Bu32} => VSPLAT_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)))
-  ;; A-binary.watsup:626.5-626.38
+  ;; A-binary.watsup:644.5-644.38
   prod {0xFD `%`_u32(19):Bu32} => VSPLAT_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)))
-  ;; A-binary.watsup:627.5-627.38
+  ;; A-binary.watsup:645.5-645.38
   prod {0xFD `%`_u32(20):Bu32} => VSPLAT_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)))
-  ;; A-binary.watsup:631.5-631.60
+  ;; A-binary.watsup:649.5-649.60
   prod{l : labelidx} {0xFD `%`_u32(21):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ?(S_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:632.5-632.60
+  ;; A-binary.watsup:650.5-650.60
   prod{l : labelidx} {0xFD `%`_u32(22):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ?(U_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:633.5-633.58
+  ;; A-binary.watsup:651.5-651.58
   prod{l : labelidx} {0xFD `%`_u32(23):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:634.5-634.60
+  ;; A-binary.watsup:652.5-652.60
   prod{l : labelidx} {0xFD `%`_u32(24):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ?(S_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:635.5-635.60
+  ;; A-binary.watsup:653.5-653.60
   prod{l : labelidx} {0xFD `%`_u32(25):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ?(U_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:636.5-636.58
+  ;; A-binary.watsup:654.5-654.58
   prod{l : labelidx} {0xFD `%`_u32(26):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:637.5-637.58
+  ;; A-binary.watsup:655.5-655.58
   prod{l : labelidx} {0xFD `%`_u32(27):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:638.5-638.58
+  ;; A-binary.watsup:656.5-656.58
   prod{l : labelidx} {0xFD `%`_u32(28):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:639.5-639.58
+  ;; A-binary.watsup:657.5-657.58
   prod{l : labelidx} {0xFD `%`_u32(29):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:640.5-640.58
+  ;; A-binary.watsup:658.5-658.58
   prod{l : labelidx} {0xFD `%`_u32(30):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:641.5-641.58
+  ;; A-binary.watsup:659.5-659.58
   prod{l : labelidx} {0xFD `%`_u32(31):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:642.5-642.58
+  ;; A-binary.watsup:660.5-660.58
   prod{l : labelidx} {0xFD `%`_u32(32):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:643.5-643.58
+  ;; A-binary.watsup:661.5-661.58
   prod{l : labelidx} {0xFD `%`_u32(33):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:644.5-644.58
+  ;; A-binary.watsup:662.5-662.58
   prod{l : labelidx} {0xFD `%`_u32(34):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:648.5-648.41
+  ;; A-binary.watsup:666.5-666.41
   prod {0xFD `%`_u32(35):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), EQ_vrelop_)
-  ;; A-binary.watsup:649.5-649.41
+  ;; A-binary.watsup:667.5-667.41
   prod {0xFD `%`_u32(36):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), NE_vrelop_)
-  ;; A-binary.watsup:650.5-650.45
+  ;; A-binary.watsup:668.5-668.45
   prod {0xFD `%`_u32(37):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:651.5-651.45
+  ;; A-binary.watsup:669.5-669.45
   prod {0xFD `%`_u32(38):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:652.5-652.45
+  ;; A-binary.watsup:670.5-670.45
   prod {0xFD `%`_u32(39):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:653.5-653.45
+  ;; A-binary.watsup:671.5-671.45
   prod {0xFD `%`_u32(40):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:654.5-654.45
+  ;; A-binary.watsup:672.5-672.45
   prod {0xFD `%`_u32(41):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:655.5-655.45
+  ;; A-binary.watsup:673.5-673.45
   prod {0xFD `%`_u32(42):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:656.5-656.45
+  ;; A-binary.watsup:674.5-674.45
   prod {0xFD `%`_u32(43):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:657.5-657.45
+  ;; A-binary.watsup:675.5-675.45
   prod {0xFD `%`_u32(44):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:661.5-661.41
+  ;; A-binary.watsup:679.5-679.41
   prod {0xFD `%`_u32(45):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), EQ_vrelop_)
-  ;; A-binary.watsup:662.5-662.41
+  ;; A-binary.watsup:680.5-680.41
   prod {0xFD `%`_u32(46):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), NE_vrelop_)
-  ;; A-binary.watsup:663.5-663.45
+  ;; A-binary.watsup:681.5-681.45
   prod {0xFD `%`_u32(47):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:664.5-664.45
+  ;; A-binary.watsup:682.5-682.45
   prod {0xFD `%`_u32(48):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:665.5-665.45
+  ;; A-binary.watsup:683.5-683.45
   prod {0xFD `%`_u32(49):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:666.5-666.45
+  ;; A-binary.watsup:684.5-684.45
   prod {0xFD `%`_u32(50):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:667.5-667.45
+  ;; A-binary.watsup:685.5-685.45
   prod {0xFD `%`_u32(51):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:668.5-668.45
+  ;; A-binary.watsup:686.5-686.45
   prod {0xFD `%`_u32(52):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:669.5-669.45
+  ;; A-binary.watsup:687.5-687.45
   prod {0xFD `%`_u32(53):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:670.5-670.45
+  ;; A-binary.watsup:688.5-688.45
   prod {0xFD `%`_u32(54):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:674.5-674.41
+  ;; A-binary.watsup:692.5-692.41
   prod {0xFD `%`_u32(55):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), EQ_vrelop_)
-  ;; A-binary.watsup:675.5-675.41
+  ;; A-binary.watsup:693.5-693.41
   prod {0xFD `%`_u32(56):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), NE_vrelop_)
-  ;; A-binary.watsup:676.5-676.45
+  ;; A-binary.watsup:694.5-694.45
   prod {0xFD `%`_u32(57):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:677.5-677.45
+  ;; A-binary.watsup:695.5-695.45
   prod {0xFD `%`_u32(58):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:678.5-678.45
+  ;; A-binary.watsup:696.5-696.45
   prod {0xFD `%`_u32(59):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:679.5-679.45
+  ;; A-binary.watsup:697.5-697.45
   prod {0xFD `%`_u32(60):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:680.5-680.45
+  ;; A-binary.watsup:698.5-698.45
   prod {0xFD `%`_u32(61):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:681.5-681.45
+  ;; A-binary.watsup:699.5-699.45
   prod {0xFD `%`_u32(62):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:682.5-682.45
+  ;; A-binary.watsup:700.5-700.45
   prod {0xFD `%`_u32(63):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:683.5-683.45
+  ;; A-binary.watsup:701.5-701.45
   prod {0xFD `%`_u32(64):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:687.5-687.41
+  ;; A-binary.watsup:705.5-705.41
   prod {0xFD `%`_u32(65):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), EQ_vrelop_)
-  ;; A-binary.watsup:688.5-688.41
+  ;; A-binary.watsup:706.5-706.41
   prod {0xFD `%`_u32(66):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NE_vrelop_)
-  ;; A-binary.watsup:689.5-689.41
+  ;; A-binary.watsup:707.5-707.41
   prod {0xFD `%`_u32(67):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), LT_vrelop_)
-  ;; A-binary.watsup:690.5-690.41
+  ;; A-binary.watsup:708.5-708.41
   prod {0xFD `%`_u32(68):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), GT_vrelop_)
-  ;; A-binary.watsup:691.5-691.41
+  ;; A-binary.watsup:709.5-709.41
   prod {0xFD `%`_u32(69):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), LE_vrelop_)
-  ;; A-binary.watsup:692.5-692.41
+  ;; A-binary.watsup:710.5-710.41
   prod {0xFD `%`_u32(70):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), GE_vrelop_)
-  ;; A-binary.watsup:696.5-696.41
+  ;; A-binary.watsup:714.5-714.41
   prod {0xFD `%`_u32(71):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), EQ_vrelop_)
-  ;; A-binary.watsup:697.5-697.41
+  ;; A-binary.watsup:715.5-715.41
   prod {0xFD `%`_u32(72):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NE_vrelop_)
-  ;; A-binary.watsup:698.5-698.41
+  ;; A-binary.watsup:716.5-716.41
   prod {0xFD `%`_u32(73):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), LT_vrelop_)
-  ;; A-binary.watsup:699.5-699.41
+  ;; A-binary.watsup:717.5-717.41
   prod {0xFD `%`_u32(74):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), GT_vrelop_)
-  ;; A-binary.watsup:700.5-700.41
+  ;; A-binary.watsup:718.5-718.41
   prod {0xFD `%`_u32(75):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), LE_vrelop_)
-  ;; A-binary.watsup:701.5-701.41
+  ;; A-binary.watsup:719.5-719.41
   prod {0xFD `%`_u32(76):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), GE_vrelop_)
-  ;; A-binary.watsup:705.5-705.36
+  ;; A-binary.watsup:723.5-723.36
   prod {0xFD `%`_u32(77):Bu32} => VVUNOP_instr(V128_vectype, NOT_vvunop)
-  ;; A-binary.watsup:709.5-709.37
+  ;; A-binary.watsup:727.5-727.37
   prod {0xFD `%`_u32(78):Bu32} => VVBINOP_instr(V128_vectype, AND_vvbinop)
-  ;; A-binary.watsup:710.5-710.40
+  ;; A-binary.watsup:728.5-728.40
   prod {0xFD `%`_u32(79):Bu32} => VVBINOP_instr(V128_vectype, ANDNOT_vvbinop)
-  ;; A-binary.watsup:711.5-711.36
+  ;; A-binary.watsup:729.5-729.36
   prod {0xFD `%`_u32(80):Bu32} => VVBINOP_instr(V128_vectype, OR_vvbinop)
-  ;; A-binary.watsup:712.5-712.37
+  ;; A-binary.watsup:730.5-730.37
   prod {0xFD `%`_u32(81):Bu32} => VVBINOP_instr(V128_vectype, XOR_vvbinop)
-  ;; A-binary.watsup:716.5-716.44
+  ;; A-binary.watsup:734.5-734.44
   prod {0xFD `%`_u32(82):Bu32} => VVTERNOP_instr(V128_vectype, BITSELECT_vvternop)
-  ;; A-binary.watsup:720.5-720.43
+  ;; A-binary.watsup:738.5-738.43
   prod {0xFD `%`_u32(83):Bu32} => VVTESTOP_instr(V128_vectype, ANY_TRUE_vvtestop)
-  ;; A-binary.watsup:724.5-724.41
+  ;; A-binary.watsup:742.5-742.41
   prod {0xFD `%`_u32(96):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ABS_vunop_)
-  ;; A-binary.watsup:725.5-725.41
+  ;; A-binary.watsup:743.5-743.41
   prod {0xFD `%`_u32(97):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), NEG_vunop_)
-  ;; A-binary.watsup:726.5-726.44
+  ;; A-binary.watsup:744.5-744.44
   prod {0xFD `%`_u32(98):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), POPCNT_vunop_)
-  ;; A-binary.watsup:730.5-730.48
+  ;; A-binary.watsup:748.5-748.48
   prod {0xFD `%`_u32(99):Bu32} => VTESTOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:734.5-734.41
+  ;; A-binary.watsup:752.5-752.41
   prod {0xFD `%`_u32(100):Bu32} => VBITMASK_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)))
-  ;; A-binary.watsup:738.5-738.53
+  ;; A-binary.watsup:756.5-756.53
   prod {0xFD `%`_u32(101):Bu32} => VNARROW_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), S_sx)
-  ;; A-binary.watsup:739.5-739.53
+  ;; A-binary.watsup:757.5-757.53
   prod {0xFD `%`_u32(102):Bu32} => VNARROW_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), U_sx)
-  ;; A-binary.watsup:743.5-743.45
+  ;; A-binary.watsup:761.5-761.45
   prod {0xFD `%`_u32(107):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHL_vshiftop_)
-  ;; A-binary.watsup:744.5-744.49
+  ;; A-binary.watsup:762.5-762.49
   prod {0xFD `%`_u32(108):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:745.5-745.49
+  ;; A-binary.watsup:763.5-763.49
   prod {0xFD `%`_u32(109):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:749.5-749.43
+  ;; A-binary.watsup:767.5-767.43
   prod {0xFD `%`_u32(110):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_vbinop_)
-  ;; A-binary.watsup:750.5-750.51
+  ;; A-binary.watsup:768.5-768.51
   prod {0xFD `%`_u32(111):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:751.5-751.51
+  ;; A-binary.watsup:769.5-769.51
   prod {0xFD `%`_u32(112):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:752.5-752.43
+  ;; A-binary.watsup:770.5-770.43
   prod {0xFD `%`_u32(113):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_vbinop_)
-  ;; A-binary.watsup:753.5-753.51
+  ;; A-binary.watsup:771.5-771.51
   prod {0xFD `%`_u32(114):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:754.5-754.51
+  ;; A-binary.watsup:772.5-772.51
   prod {0xFD `%`_u32(115):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:755.5-755.47
+  ;; A-binary.watsup:773.5-773.47
   prod {0xFD `%`_u32(118):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:756.5-756.47
+  ;; A-binary.watsup:774.5-774.47
   prod {0xFD `%`_u32(119):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:757.5-757.47
+  ;; A-binary.watsup:775.5-775.47
   prod {0xFD `%`_u32(120):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:758.5-758.47
+  ;; A-binary.watsup:776.5-776.47
   prod {0xFD `%`_u32(121):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:759.5-759.48
+  ;; A-binary.watsup:777.5-777.48
   prod {0xFD `%`_u32(123):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), `AVGRU`_vbinop_)
-  ;; A-binary.watsup:763.5-763.72
+  ;; A-binary.watsup:781.5-781.72
   prod {0xFD `%`_u32(124):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTADD_PAIRWISE_vextunop__(S_sx))
-  ;; A-binary.watsup:764.5-764.72
+  ;; A-binary.watsup:782.5-782.72
   prod {0xFD `%`_u32(125):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTADD_PAIRWISE_vextunop__(U_sx))
-  ;; A-binary.watsup:768.5-768.42
+  ;; A-binary.watsup:786.5-786.42
   prod {0xFD `%`_u32(128):Bu32} => VUNOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ABS_vunop_)
-  ;; A-binary.watsup:769.5-769.42
+  ;; A-binary.watsup:787.5-787.42
   prod {0xFD `%`_u32(129):Bu32} => VUNOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), NEG_vunop_)
-  ;; A-binary.watsup:773.5-773.55
+  ;; A-binary.watsup:791.5-791.55
   prod {0xFD `%`_u32(130):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `Q15MULR_SATS`_vbinop_)
-  ;; A-binary.watsup:777.5-777.49
+  ;; A-binary.watsup:795.5-795.49
   prod {0xFD `%`_u32(131):Bu32} => VTESTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:781.5-781.41
+  ;; A-binary.watsup:799.5-799.41
   prod {0xFD `%`_u32(132):Bu32} => VBITMASK_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)))
-  ;; A-binary.watsup:785.5-785.53
+  ;; A-binary.watsup:803.5-803.53
   prod {0xFD `%`_u32(133):Bu32} => VNARROW_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), S_sx)
-  ;; A-binary.watsup:786.5-786.53
+  ;; A-binary.watsup:804.5-804.53
   prod {0xFD `%`_u32(134):Bu32} => VNARROW_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), U_sx)
-  ;; A-binary.watsup:790.5-790.65
+  ;; A-binary.watsup:808.5-808.65
   prod {0xFD `%`_u32(135):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:791.5-791.66
+  ;; A-binary.watsup:809.5-809.66
   prod {0xFD `%`_u32(136):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:792.5-792.65
+  ;; A-binary.watsup:810.5-810.65
   prod {0xFD `%`_u32(137):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:793.5-793.66
+  ;; A-binary.watsup:811.5-811.66
   prod {0xFD `%`_u32(138):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:797.5-797.45
+  ;; A-binary.watsup:815.5-815.45
   prod {0xFD `%`_u32(139):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHL_vshiftop_)
-  ;; A-binary.watsup:798.5-798.49
+  ;; A-binary.watsup:816.5-816.49
   prod {0xFD `%`_u32(140):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:799.5-799.49
+  ;; A-binary.watsup:817.5-817.49
   prod {0xFD `%`_u32(141):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:803.5-803.43
+  ;; A-binary.watsup:821.5-821.43
   prod {0xFD `%`_u32(142):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_vbinop_)
-  ;; A-binary.watsup:804.5-804.51
+  ;; A-binary.watsup:822.5-822.51
   prod {0xFD `%`_u32(143):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:805.5-805.51
+  ;; A-binary.watsup:823.5-823.51
   prod {0xFD `%`_u32(144):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:806.5-806.43
+  ;; A-binary.watsup:824.5-824.43
   prod {0xFD `%`_u32(145):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_vbinop_)
-  ;; A-binary.watsup:807.5-807.51
+  ;; A-binary.watsup:825.5-825.51
   prod {0xFD `%`_u32(146):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:808.5-808.51
+  ;; A-binary.watsup:826.5-826.51
   prod {0xFD `%`_u32(147):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:809.5-809.43
+  ;; A-binary.watsup:827.5-827.43
   prod {0xFD `%`_u32(149):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MUL_vbinop_)
-  ;; A-binary.watsup:810.5-810.47
+  ;; A-binary.watsup:828.5-828.47
   prod {0xFD `%`_u32(150):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:811.5-811.47
+  ;; A-binary.watsup:829.5-829.47
   prod {0xFD `%`_u32(151):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:812.5-812.47
+  ;; A-binary.watsup:830.5-830.47
   prod {0xFD `%`_u32(152):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:813.5-813.47
+  ;; A-binary.watsup:831.5-831.47
   prod {0xFD `%`_u32(153):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:814.5-814.48
+  ;; A-binary.watsup:832.5-832.48
   prod {0xFD `%`_u32(155):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `AVGRU`_vbinop_)
-  ;; A-binary.watsup:818.5-818.68
+  ;; A-binary.watsup:836.5-836.68
   prod {0xFD `%`_u32(156):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:819.5-819.69
+  ;; A-binary.watsup:837.5-837.69
   prod {0xFD `%`_u32(157):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:820.5-820.68
+  ;; A-binary.watsup:838.5-838.68
   prod {0xFD `%`_u32(158):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:821.5-821.69
+  ;; A-binary.watsup:839.5-839.69
   prod {0xFD `%`_u32(159):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:825.5-825.72
+  ;; A-binary.watsup:843.5-843.72
   prod {0xFD `%`_u32(126):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTADD_PAIRWISE_vextunop__(S_sx))
-  ;; A-binary.watsup:826.5-826.72
+  ;; A-binary.watsup:844.5-844.72
   prod {0xFD `%`_u32(127):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTADD_PAIRWISE_vextunop__(U_sx))
-  ;; A-binary.watsup:830.5-830.42
+  ;; A-binary.watsup:848.5-848.42
   prod {0xFD `%`_u32(160):Bu32} => VUNOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ABS_vunop_)
-  ;; A-binary.watsup:831.5-831.42
+  ;; A-binary.watsup:849.5-849.42
   prod {0xFD `%`_u32(161):Bu32} => VUNOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), NEG_vunop_)
-  ;; A-binary.watsup:835.5-835.49
+  ;; A-binary.watsup:853.5-853.49
   prod {0xFD `%`_u32(163):Bu32} => VTESTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:839.5-839.41
+  ;; A-binary.watsup:857.5-857.41
   prod {0xFD `%`_u32(164):Bu32} => VBITMASK_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)))
-  ;; A-binary.watsup:843.5-843.65
+  ;; A-binary.watsup:861.5-861.65
   prod {0xFD `%`_u32(167):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:844.5-844.66
+  ;; A-binary.watsup:862.5-862.66
   prod {0xFD `%`_u32(168):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:845.5-845.65
+  ;; A-binary.watsup:863.5-863.65
   prod {0xFD `%`_u32(169):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:846.5-846.66
+  ;; A-binary.watsup:864.5-864.66
   prod {0xFD `%`_u32(170):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:850.5-850.45
+  ;; A-binary.watsup:868.5-868.45
   prod {0xFD `%`_u32(171):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHL_vshiftop_)
-  ;; A-binary.watsup:851.5-851.49
+  ;; A-binary.watsup:869.5-869.49
   prod {0xFD `%`_u32(172):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:852.5-852.49
+  ;; A-binary.watsup:870.5-870.49
   prod {0xFD `%`_u32(173):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:856.5-856.43
+  ;; A-binary.watsup:874.5-874.43
   prod {0xFD `%`_u32(174):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ADD_vbinop_)
-  ;; A-binary.watsup:857.5-857.43
+  ;; A-binary.watsup:875.5-875.43
   prod {0xFD `%`_u32(177):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), SUB_vbinop_)
-  ;; A-binary.watsup:858.5-858.43
+  ;; A-binary.watsup:876.5-876.43
   prod {0xFD `%`_u32(181):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MUL_vbinop_)
-  ;; A-binary.watsup:859.5-859.47
+  ;; A-binary.watsup:877.5-877.47
   prod {0xFD `%`_u32(182):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:860.5-860.47
+  ;; A-binary.watsup:878.5-878.47
   prod {0xFD `%`_u32(183):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:861.5-861.47
+  ;; A-binary.watsup:879.5-879.47
   prod {0xFD `%`_u32(184):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:862.5-862.47
+  ;; A-binary.watsup:880.5-880.47
   prod {0xFD `%`_u32(185):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:866.5-866.61
+  ;; A-binary.watsup:884.5-884.61
   prod {0xFD `%`_u32(186):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), `DOTS`_vextbinop__)
-  ;; A-binary.watsup:867.5-867.68
+  ;; A-binary.watsup:885.5-885.68
   prod {0xFD `%`_u32(188):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:868.5-868.69
+  ;; A-binary.watsup:886.5-886.69
   prod {0xFD `%`_u32(189):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:869.5-869.68
+  ;; A-binary.watsup:887.5-887.68
   prod {0xFD `%`_u32(190):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:870.5-870.69
+  ;; A-binary.watsup:888.5-888.69
   prod {0xFD `%`_u32(191):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:874.5-874.42
+  ;; A-binary.watsup:892.5-892.42
   prod {0xFD `%`_u32(192):Bu32} => VUNOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ABS_vunop_)
-  ;; A-binary.watsup:875.5-875.42
+  ;; A-binary.watsup:893.5-893.42
   prod {0xFD `%`_u32(193):Bu32} => VUNOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), NEG_vunop_)
-  ;; A-binary.watsup:879.5-879.49
+  ;; A-binary.watsup:897.5-897.49
   prod {0xFD `%`_u32(195):Bu32} => VTESTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:883.5-883.41
+  ;; A-binary.watsup:901.5-901.41
   prod {0xFD `%`_u32(196):Bu32} => VBITMASK_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)))
-  ;; A-binary.watsup:887.5-887.65
+  ;; A-binary.watsup:905.5-905.65
   prod {0xFD `%`_u32(199):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:888.5-888.66
+  ;; A-binary.watsup:906.5-906.66
   prod {0xFD `%`_u32(200):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:889.5-889.65
+  ;; A-binary.watsup:907.5-907.65
   prod {0xFD `%`_u32(201):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:890.5-890.66
+  ;; A-binary.watsup:908.5-908.66
   prod {0xFD `%`_u32(202):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:894.5-894.45
+  ;; A-binary.watsup:912.5-912.45
   prod {0xFD `%`_u32(203):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHL_vshiftop_)
-  ;; A-binary.watsup:895.5-895.49
+  ;; A-binary.watsup:913.5-913.49
   prod {0xFD `%`_u32(204):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:896.5-896.49
+  ;; A-binary.watsup:914.5-914.49
   prod {0xFD `%`_u32(205):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:900.5-900.43
+  ;; A-binary.watsup:918.5-918.43
   prod {0xFD `%`_u32(206):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ADD_vbinop_)
-  ;; A-binary.watsup:901.5-901.43
+  ;; A-binary.watsup:919.5-919.43
   prod {0xFD `%`_u32(209):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), SUB_vbinop_)
-  ;; A-binary.watsup:902.5-902.43
+  ;; A-binary.watsup:920.5-920.43
   prod {0xFD `%`_u32(213):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), MUL_vbinop_)
-  ;; A-binary.watsup:906.5-906.42
+  ;; A-binary.watsup:924.5-924.42
   prod {0xFD `%`_u32(214):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), EQ_vrelop_)
-  ;; A-binary.watsup:907.5-907.42
+  ;; A-binary.watsup:925.5-925.42
   prod {0xFD `%`_u32(215):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), NE_vrelop_)
-  ;; A-binary.watsup:908.5-908.46
+  ;; A-binary.watsup:926.5-926.46
   prod {0xFD `%`_u32(216):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:909.5-909.46
+  ;; A-binary.watsup:927.5-927.46
   prod {0xFD `%`_u32(217):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:910.5-910.46
+  ;; A-binary.watsup:928.5-928.46
   prod {0xFD `%`_u32(218):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:911.5-911.46
+  ;; A-binary.watsup:929.5-929.46
   prod {0xFD `%`_u32(219):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:915.5-915.68
+  ;; A-binary.watsup:933.5-933.68
   prod {0xFD `%`_u32(220):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:916.5-916.69
+  ;; A-binary.watsup:934.5-934.69
   prod {0xFD `%`_u32(221):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:917.5-917.68
+  ;; A-binary.watsup:935.5-935.68
   prod {0xFD `%`_u32(222):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:918.5-918.69
+  ;; A-binary.watsup:936.5-936.69
   prod {0xFD `%`_u32(223):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:922.5-922.43
+  ;; A-binary.watsup:940.5-940.43
   prod {0xFD `%`_u32(103):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), CEIL_vunop_)
-  ;; A-binary.watsup:923.5-923.44
+  ;; A-binary.watsup:941.5-941.44
   prod {0xFD `%`_u32(104):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), FLOOR_vunop_)
-  ;; A-binary.watsup:924.5-924.44
+  ;; A-binary.watsup:942.5-942.44
   prod {0xFD `%`_u32(105):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_vunop_)
-  ;; A-binary.watsup:925.5-925.46
+  ;; A-binary.watsup:943.5-943.46
   prod {0xFD `%`_u32(106):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NEAREST_vunop_)
-  ;; A-binary.watsup:926.5-926.42
+  ;; A-binary.watsup:944.5-944.42
   prod {0xFD `%`_u32(224):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ABS_vunop_)
-  ;; A-binary.watsup:927.5-927.42
+  ;; A-binary.watsup:945.5-945.42
   prod {0xFD `%`_u32(225):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NEG_vunop_)
-  ;; A-binary.watsup:928.5-928.43
+  ;; A-binary.watsup:946.5-946.43
   prod {0xFD `%`_u32(227):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), SQRT_vunop_)
-  ;; A-binary.watsup:932.5-932.43
+  ;; A-binary.watsup:950.5-950.43
   prod {0xFD `%`_u32(228):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ADD_vbinop_)
-  ;; A-binary.watsup:933.5-933.43
+  ;; A-binary.watsup:951.5-951.43
   prod {0xFD `%`_u32(229):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), SUB_vbinop_)
-  ;; A-binary.watsup:934.5-934.43
+  ;; A-binary.watsup:952.5-952.43
   prod {0xFD `%`_u32(230):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MUL_vbinop_)
-  ;; A-binary.watsup:935.5-935.43
+  ;; A-binary.watsup:953.5-953.43
   prod {0xFD `%`_u32(231):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), DIV_vbinop_)
-  ;; A-binary.watsup:936.5-936.43
+  ;; A-binary.watsup:954.5-954.43
   prod {0xFD `%`_u32(232):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MIN_vbinop_)
-  ;; A-binary.watsup:937.5-937.43
+  ;; A-binary.watsup:955.5-955.43
   prod {0xFD `%`_u32(233):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MAX_vbinop_)
-  ;; A-binary.watsup:938.5-938.44
+  ;; A-binary.watsup:956.5-956.44
   prod {0xFD `%`_u32(234):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), PMIN_vbinop_)
-  ;; A-binary.watsup:939.5-939.44
+  ;; A-binary.watsup:957.5-957.44
   prod {0xFD `%`_u32(235):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), PMAX_vbinop_)
-  ;; A-binary.watsup:943.5-943.43
+  ;; A-binary.watsup:961.5-961.43
   prod {0xFD `%`_u32(116):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), CEIL_vunop_)
-  ;; A-binary.watsup:944.5-944.44
+  ;; A-binary.watsup:962.5-962.44
   prod {0xFD `%`_u32(117):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), FLOOR_vunop_)
-  ;; A-binary.watsup:945.5-945.44
+  ;; A-binary.watsup:963.5-963.44
   prod {0xFD `%`_u32(122):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_vunop_)
-  ;; A-binary.watsup:946.5-946.46
+  ;; A-binary.watsup:964.5-964.46
   prod {0xFD `%`_u32(148):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NEAREST_vunop_)
-  ;; A-binary.watsup:947.5-947.42
+  ;; A-binary.watsup:965.5-965.42
   prod {0xFD `%`_u32(236):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ABS_vunop_)
-  ;; A-binary.watsup:948.5-948.42
+  ;; A-binary.watsup:966.5-966.42
   prod {0xFD `%`_u32(237):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NEG_vunop_)
-  ;; A-binary.watsup:949.5-949.43
+  ;; A-binary.watsup:967.5-967.43
   prod {0xFD `%`_u32(239):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), SQRT_vunop_)
-  ;; A-binary.watsup:953.5-953.43
+  ;; A-binary.watsup:971.5-971.43
   prod {0xFD `%`_u32(240):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ADD_vbinop_)
-  ;; A-binary.watsup:954.5-954.43
+  ;; A-binary.watsup:972.5-972.43
   prod {0xFD `%`_u32(241):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), SUB_vbinop_)
-  ;; A-binary.watsup:955.5-955.43
+  ;; A-binary.watsup:973.5-973.43
   prod {0xFD `%`_u32(242):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MUL_vbinop_)
-  ;; A-binary.watsup:956.5-956.43
+  ;; A-binary.watsup:974.5-974.43
   prod {0xFD `%`_u32(243):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), DIV_vbinop_)
-  ;; A-binary.watsup:957.5-957.43
+  ;; A-binary.watsup:975.5-975.43
   prod {0xFD `%`_u32(244):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MIN_vbinop_)
-  ;; A-binary.watsup:958.5-958.43
+  ;; A-binary.watsup:976.5-976.43
   prod {0xFD `%`_u32(245):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MAX_vbinop_)
-  ;; A-binary.watsup:959.5-959.44
+  ;; A-binary.watsup:977.5-977.44
   prod {0xFD `%`_u32(246):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), PMIN_vbinop_)
-  ;; A-binary.watsup:960.5-960.44
+  ;; A-binary.watsup:978.5-978.44
   prod {0xFD `%`_u32(247):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), PMAX_vbinop_)
-  ;; A-binary.watsup:964.5-964.61
+  ;; A-binary.watsup:982.5-982.61
   prod {0xFD `%`_u32(94):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), DEMOTE_vcvtop__, ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:965.5-965.61
+  ;; A-binary.watsup:983.5-983.61
   prod {0xFD `%`_u32(95):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(F32_lanetype, `%`_dim(4)), PROMOTE_vcvtop__, ?(LOW_half__), ?())
-  ;; A-binary.watsup:966.5-966.64
+  ;; A-binary.watsup:984.5-984.64
   prod {0xFD `%`_u32(248):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_SAT_vcvtop__(S_sx), ?(), ?())
-  ;; A-binary.watsup:967.5-967.64
+  ;; A-binary.watsup:985.5-985.64
   prod {0xFD `%`_u32(249):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_SAT_vcvtop__(U_sx), ?(), ?())
-  ;; A-binary.watsup:968.5-968.62
+  ;; A-binary.watsup:986.5-986.62
   prod {0xFD `%`_u32(250):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(S_sx), ?(), ?())
-  ;; A-binary.watsup:969.5-969.62
+  ;; A-binary.watsup:987.5-987.62
   prod {0xFD `%`_u32(251):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(U_sx), ?(), ?())
-  ;; A-binary.watsup:970.5-970.69
+  ;; A-binary.watsup:988.5-988.69
   prod {0xFD `%`_u32(252):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_SAT_vcvtop__(S_sx), ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:971.5-971.69
+  ;; A-binary.watsup:989.5-989.69
   prod {0xFD `%`_u32(253):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_SAT_vcvtop__(U_sx), ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:972.5-972.66
+  ;; A-binary.watsup:990.5-990.66
   prod {0xFD `%`_u32(254):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:973.5-973.66
+  ;; A-binary.watsup:991.5-991.66
   prod {0xFD `%`_u32(255):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(U_sx), ?(LOW_half__), ?())
 }
 
@@ -23907,6 +24977,16 @@ grammar Bdatacntsec : u32?
   ;; A-binary.watsup
   prod{nopt : nopt} nopt:Bsection_(12, syntax u32, grammar Bdatacnt) => $opt_(syntax u32, nopt)
 
+;; A-binary.watsup
+grammar Btag : tag
+  ;; A-binary.watsup
+  prod{x : idx} x:Btypeidx => TAG_tag(x)
+
+;; A-binary.watsup
+grammar Btagsec : tag*
+  ;; A-binary.watsup
+  prod{tag* : tag*} tag*{tag : tag}:Bsection_(13, syntax tag, grammar Blist(syntax tag, grammar Btag)) => tag*{tag : tag}
+
 ;; A-binary.watsup
 grammar Bmagic : ()
   ;; A-binary.watsup
@@ -23920,7 +25000,7 @@ grammar Bversion : ()
 ;; A-binary.watsup
 grammar Bmodule : module
   ;; A-binary.watsup
-  prod{type* : type*, import* : import*, typeidx* : typeidx*, table* : table*, mem* : mem*, global* : global*, export* : export*, start? : start?, elem* : elem*, n? : n?, local** : local**, expr* : expr*, data* : data*, func* : func*} {Bmagic Bversion Bcustomsec*{} type*{type : type}:Btypesec Bcustomsec*{} import*{import : import}:Bimportsec Bcustomsec*{} typeidx*{typeidx : typeidx}:Bfuncsec Bcustomsec*{} table*{table : table}:Btablesec Bcustomsec*{} mem*{mem : mem}:Bmemsec Bcustomsec*{} global*{global : global}:Bglobalsec Bcustomsec*{} export*{export : export}:Bexportsec Bcustomsec*{} start?{start : start}:Bstartsec Bcustomsec*{} elem*{elem : elem}:Belemsec Bcustomsec*{} `%`_u32(n)?{n : nat}:Bdatacntsec Bcustomsec*{} (local*{local : local}, expr)*{expr : expr, local : local}:Bcodesec Bcustomsec*{} data*{data : data}:Bdatasec Bcustomsec*{}} => MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})
+  prod{type* : type*, import* : import*, typeidx* : typeidx*, table* : table*, mem* : mem*, tag* : tag*, global* : global*, export* : export*, start? : start?, elem* : elem*, n? : n?, local** : local**, expr* : expr*, data* : data*, func* : func*} {Bmagic Bversion Bcustomsec*{} type*{type : type}:Btypesec Bcustomsec*{} import*{import : import}:Bimportsec Bcustomsec*{} typeidx*{typeidx : typeidx}:Bfuncsec Bcustomsec*{} table*{table : table}:Btablesec Bcustomsec*{} mem*{mem : mem}:Bmemsec Bcustomsec*{} tag*{tag : tag}:Btagsec Bcustomsec*{} global*{global : global}:Bglobalsec Bcustomsec*{} export*{export : export}:Bexportsec Bcustomsec*{} start?{start : start}:Bstartsec Bcustomsec*{} elem*{elem : elem}:Belemsec Bcustomsec*{} `%`_u32(n)?{n : nat}:Bdatacntsec Bcustomsec*{} (local*{local : local}, expr)*{expr : expr, local : local}:Bcodesec Bcustomsec*{} data*{data : data}:Bdatasec Bcustomsec*{}} => MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})
     -- (if (n = |data*{data : data}|))?{n : n}
     -- if ((n?{n : n} =/= ?()) \/ ($dataidx_funcs(func*{func : func}) = []))
     -- (if (func = FUNC_func(typeidx, local*{local : local}, expr)))*{expr : expr, func : func, local : local, typeidx : typeidx}
@@ -23995,7 +25075,7 @@ relation NotationTypingInstrScheme: `%|-%:%`(context, instr*, functype)
   rule block{C : context, blocktype : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, [BLOCK_instr(blocktype, instr*{instr : instr})], `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, blocktype, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- NotationTypingInstrScheme: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
+    -- NotationTypingInstrScheme: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
 }
 
 ;; C-conventions.watsup
@@ -24393,6 +25473,9 @@ syntax tableidx = idx
 ;; 1-syntax.watsup
 syntax memidx = idx
 
+;; 1-syntax.watsup
+syntax tagidx = idx
+
 ;; 1-syntax.watsup
 syntax elemidx = idx
 
@@ -24449,6 +25532,8 @@ syntax absheaptype =
   | NONE
   | FUNC
   | NOFUNC
+  | EXN
+  | NOEXN
   | EXTERN
   | NOEXTERN
   | BOT
@@ -24464,13 +25549,13 @@ syntax fin =
 ;; 1-syntax.watsup
 rec {
 
-;; 1-syntax.watsup:153.1-154.26
+;; 1-syntax.watsup:155.1-156.26
 syntax typeuse =
   | _IDX{typeidx : typeidx}(typeidx : typeidx)
   | DEF{rectype : rectype, n : n}(rectype : rectype, n : n)
   | REC{n : n}(n : n)
 
-;; 1-syntax.watsup:156.1-157.26
+;; 1-syntax.watsup:158.1-159.26
 syntax heaptype =
   | ANY
   | EQ
@@ -24480,6 +25565,8 @@ syntax heaptype =
   | NONE
   | FUNC
   | NOFUNC
+  | EXN
+  | NOEXN
   | EXTERN
   | NOEXTERN
   | BOT
@@ -24487,7 +25574,7 @@ syntax heaptype =
   | REC{n : n}(n : n)
   | DEF{rectype : rectype, n : n}(rectype : rectype, n : n)
 
-;; 1-syntax.watsup:164.1-165.14
+;; 1-syntax.watsup:166.1-167.14
 syntax valtype =
   | I32
   | I64
@@ -24497,10 +25584,10 @@ syntax valtype =
   | REF{nul : nul, heaptype : heaptype}(nul : nul, heaptype : heaptype)
   | BOT
 
-;; 1-syntax.watsup:194.1-195.16
+;; 1-syntax.watsup:196.1-197.16
 syntax resulttype = list(syntax valtype)
 
-;; 1-syntax.watsup:202.1-202.66
+;; 1-syntax.watsup:204.1-204.66
 syntax storagetype =
   | BOT
   | I32
@@ -24512,31 +25599,31 @@ syntax storagetype =
   | I8
   | I16
 
-;; 1-syntax.watsup:218.1-218.60
+;; 1-syntax.watsup:220.1-220.60
 syntax fieldtype =
   | `%%`{mut : mut, storagetype : storagetype}(mut : mut, storagetype : storagetype)
 
-;; 1-syntax.watsup:220.1-220.90
+;; 1-syntax.watsup:222.1-222.90
 syntax functype =
   | `%->%`{resulttype : resulttype}(resulttype : resulttype, resulttype)
 
-;; 1-syntax.watsup:221.1-221.64
+;; 1-syntax.watsup:223.1-223.64
 syntax structtype = list(syntax fieldtype)
 
-;; 1-syntax.watsup:222.1-222.54
+;; 1-syntax.watsup:224.1-224.54
 syntax arraytype = fieldtype
 
-;; 1-syntax.watsup:224.1-227.18
+;; 1-syntax.watsup:226.1-229.18
 syntax comptype =
   | STRUCT{structtype : structtype}(structtype : structtype)
   | ARRAY{arraytype : arraytype}(arraytype : arraytype)
   | FUNC{functype : functype}(functype : functype)
 
-;; 1-syntax.watsup:229.1-230.30
+;; 1-syntax.watsup:231.1-232.30
 syntax subtype =
   | SUB{fin : fin, typeuse* : typeuse*, comptype : comptype}(fin : fin, typeuse*{typeuse : typeuse} : typeuse*, comptype : comptype)
 
-;; 1-syntax.watsup:232.1-233.22
+;; 1-syntax.watsup:234.1-235.22
 syntax rectype =
   | REC{list : list(syntax subtype)}(list : list(syntax subtype))
 }
@@ -24680,6 +25767,9 @@ syntax tabletype =
 syntax memtype =
   | `%PAGE`{limits : limits}(limits : limits)
 
+;; 1-syntax.watsup
+syntax tagtype = deftype
+
 ;; 1-syntax.watsup
 syntax elemtype = reftype
 
@@ -24693,6 +25783,7 @@ syntax externtype =
   | GLOBAL{globaltype : globaltype}(globaltype : globaltype)
   | TABLE{tabletype : tabletype}(tabletype : tabletype)
   | MEM{memtype : memtype}(memtype : memtype)
+  | TAG{typeuse : typeuse}(typeuse : typeuse)
 
 ;; 1-syntax.watsup
 syntax moduletype =
@@ -25182,6 +26273,9 @@ syntax addr = nat
 ;; 4-runtime.watsup
 syntax arrayaddr = addr
 
+;; 4-runtime.watsup
+syntax exnaddr = addr
+
 ;; 4-runtime.watsup
 syntax funcaddr = addr
 
@@ -25194,16 +26288,24 @@ syntax structaddr = addr
 ;; 4-runtime.watsup
 rec {
 
-;; 4-runtime.watsup:37.1-43.23
+;; 4-runtime.watsup:35.1-42.23
 syntax addrref =
   | REF.I31_NUM{u31 : u31}(u31 : u31)
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
 }
 
+;; 1-syntax.watsup
+syntax catch =
+  | CATCH{tagidx : tagidx, labelidx : labelidx}(tagidx : tagidx, labelidx : labelidx)
+  | CATCH_REF{tagidx : tagidx, labelidx : labelidx}(tagidx : tagidx, labelidx : labelidx)
+  | CATCH_ALL{labelidx : labelidx}(labelidx : labelidx)
+  | CATCH_ALL_REF{labelidx : labelidx}(labelidx : labelidx)
+
 ;; 4-runtime.watsup
 syntax dataaddr = addr
 
@@ -25220,17 +26322,21 @@ syntax memaddr = addr
 syntax tableaddr = addr
 
 ;; 4-runtime.watsup
-syntax externval =
+syntax tagaddr = addr
+
+;; 4-runtime.watsup
+syntax externaddr =
   | FUNC{funcaddr : funcaddr}(funcaddr : funcaddr)
   | GLOBAL{globaladdr : globaladdr}(globaladdr : globaladdr)
   | TABLE{tableaddr : tableaddr}(tableaddr : tableaddr)
   | MEM{memaddr : memaddr}(memaddr : memaddr)
+  | TAG{tagaddr : tagaddr}(tagaddr : tagaddr)
 
 ;; 4-runtime.watsup
 syntax exportinst =
 {
   NAME{name : name} name,
-  VALUE{externval : externval} externval
+  ADDR{externaddr : externaddr} externaddr
 }
 
 ;; 4-runtime.watsup
@@ -25241,6 +26347,7 @@ syntax moduleinst =
   GLOBALS{globaladdr* : globaladdr*} globaladdr*,
   TABLES{tableaddr* : tableaddr*} tableaddr*,
   MEMS{memaddr* : memaddr*} memaddr*,
+  TAGS{tagaddr* : tagaddr*} tagaddr*,
   ELEMS{elemaddr* : elemaddr*} elemaddr*,
   DATAS{dataaddr* : dataaddr*} dataaddr*,
   EXPORTS{exportinst* : exportinst*} exportinst*
@@ -25255,6 +26362,7 @@ syntax val =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
 
@@ -25268,7 +26376,7 @@ syntax frame =
 ;; 4-runtime.watsup
 rec {
 
-;; 4-runtime.watsup:151.1-156.9
+;; 4-runtime.watsup:151.1-157.9
 syntax instr =
   | NOP
   | UNREACHABLE
@@ -25291,6 +26399,9 @@ syntax instr =
   | RETURN_CALL{funcidx : funcidx}(funcidx : funcidx)
   | RETURN_CALL_REF{typeuse : typeuse}(typeuse : typeuse)
   | RETURN_CALL_INDIRECT{tableidx : tableidx, typeuse : typeuse}(tableidx : tableidx, typeuse : typeuse)
+  | THROW{tagidx : tagidx}(tagidx : tagidx)
+  | THROW_REF
+  | TRY_TABLE{blocktype : blocktype, list : list(syntax catch), instr* : instr*}(blocktype : blocktype, list : list(syntax catch), instr*{instr : instr} : instr*)
   | CONST{numtype : numtype, num_ : num_(numtype)}(numtype : numtype, num_ : num_(numtype))
   | UNOP{numtype : numtype, unop_ : unop_(numtype)}(numtype : numtype, unop_ : unop_(numtype))
   | BINOP{numtype : numtype, binop_ : binop_(numtype)}(numtype : numtype, binop_ : binop_(numtype))
@@ -25378,10 +26489,12 @@ syntax instr =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | `LABEL_%{%}%`{n : n, instr* : instr*}(n : n, instr*{instr : instr} : instr*, instr*)
   | `FRAME_%{%}%`{n : n, frame : frame, instr* : instr*}(n : n, frame : frame, instr*{instr : instr} : instr*)
+  | `HANDLER_%{%}%`{n : n, catch* : catch*, instr* : instr*}(n : n, catch*{catch : catch} : catch*, instr*{instr : instr} : instr*)
   | TRAP
 }
 
@@ -25423,6 +26536,10 @@ syntax table =
 syntax mem =
   | MEMORY{memtype : memtype}(memtype : memtype)
 
+;; 1-syntax.watsup
+syntax tag =
+  | TAG{typeidx : typeidx}(typeidx : typeidx)
+
 ;; 1-syntax.watsup
 syntax elem =
   | ELEM{reftype : reftype, expr* : expr*, elemmode : elemmode}(reftype : reftype, expr*{expr : expr} : expr*, elemmode : elemmode)
@@ -25441,6 +26558,7 @@ syntax externidx =
   | GLOBAL{globalidx : globalidx}(globalidx : globalidx)
   | TABLE{tableidx : tableidx}(tableidx : tableidx)
   | MEM{memidx : memidx}(memidx : memidx)
+  | TAG{tagidx : tagidx}(tagidx : tagidx)
 
 ;; 1-syntax.watsup
 syntax export =
@@ -25452,7 +26570,7 @@ syntax import =
 
 ;; 1-syntax.watsup
 syntax module =
-  | MODULE{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*}(type*{type : type} : type*, import*{import : import} : import*, func*{func : func} : func*, global*{global : global} : global*, table*{table : table} : table*, mem*{mem : mem} : mem*, elem*{elem : elem} : elem*, data*{data : data} : data*, start?{start : start} : start?, export*{export : export} : export*)
+  | MODULE{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*}(type*{type : type} : type*, import*{import : import} : import*, func*{func : func} : func*, global*{global : global} : global*, table*{table : table} : table*, mem*{mem : mem} : mem*, tag*{tag : tag} : tag*, elem*{elem : elem} : elem*, data*{data : data} : data*, start?{start : start} : start?, export*{export : export} : export*)
 
 ;; 2-syntax-aux.watsup
 def $IN(N : N) : Inn
@@ -26079,6 +27197,11 @@ def $free_mem(mem : mem) : free
   ;; 2-syntax-aux.watsup
   def $free_mem{memtype : memtype}(MEMORY_mem(memtype)) = $free_memtype(memtype)
 
+;; 2-syntax-aux.watsup
+def $free_tag(tag : tag) : free
+  ;; 2-syntax-aux.watsup
+  def $free_tag{typeidx : typeidx}(TAG_tag(typeidx)) = $free_typeidx(typeidx)
+
 ;; 2-syntax-aux.watsup
 def $free_elemmode(elemmode : elemmode) : free
   ;; 2-syntax-aux.watsup
@@ -26123,7 +27246,7 @@ def $free_import(import : import) : free
 ;; 2-syntax-aux.watsup
 def $free_module(module : module) : free
   ;; 2-syntax-aux.watsup
-  def $free_module{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*}(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})) = $free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})
+  def $free_module{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*}(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})) = $free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_tag(tag)*{tag : tag}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})
 
 ;; 2-syntax-aux.watsup
 def $funcidx_module(module : module) : funcidx*
@@ -26138,14 +27261,14 @@ def $dataidx_funcs(func*) : dataidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:531.1-531.112
+;; 2-syntax-aux.watsup:535.1-535.112
 def $subst_typevar(typevar : typevar, typevar*, typeuse*) : typeuse
-  ;; 2-syntax-aux.watsup:558.1-558.38
+  ;; 2-syntax-aux.watsup:562.1-562.38
   def $subst_typevar{tv : typevar}(tv, [], []) = (tv : typevar <: typeuse)
-  ;; 2-syntax-aux.watsup:559.1-559.95
+  ;; 2-syntax-aux.watsup:563.1-563.95
   def $subst_typevar{tv : typevar, tv_1 : typevar, tv'* : typevar*, tu_1 : typeuse, tu'* : typeuse*}(tv, [tv_1] :: tv'*{tv' : typevar}, [tu_1] :: tu'*{tu' : typeuse}) = tu_1
     -- if (tv = tv_1)
-  ;; 2-syntax-aux.watsup:560.1-560.92
+  ;; 2-syntax-aux.watsup:564.1-564.92
   def $subst_typevar{tv : typevar, tv_1 : typevar, tv'* : typevar*, tu_1 : typeuse, tu'* : typeuse*}(tv, [tv_1] :: tv'*{tv' : typevar}, [tu_1] :: tu'*{tu' : typeuse}) = $subst_typevar(tv, tv'*{tv' : typevar}, tu'*{tu' : typeuse})
     -- otherwise
 }
@@ -26168,78 +27291,78 @@ def $subst_vectype(vectype : vectype, typevar*, typeuse*) : vectype
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:532.1-532.112
+;; 2-syntax-aux.watsup:536.1-536.112
 def $subst_typeuse(typeuse : typeuse, typevar*, typeuse*) : typeuse
-  ;; 2-syntax-aux.watsup:562.1-562.66
+  ;; 2-syntax-aux.watsup:566.1-566.66
   def $subst_typeuse{tv' : typevar, tv* : typevar*, tu* : typeuse*}((tv' : typevar <: typeuse), tv*{tv : typevar}, tu*{tu : typeuse}) = $subst_typevar(tv', tv*{tv : typevar}, tu*{tu : typeuse})
-  ;; 2-syntax-aux.watsup:563.1-563.64
+  ;; 2-syntax-aux.watsup:567.1-567.64
   def $subst_typeuse{dt : deftype, tv* : typevar*, tu* : typeuse*}((dt : deftype <: typeuse), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_deftype(dt, tv*{tv : typevar}, tu*{tu : typeuse}) : deftype <: typeuse)
 
-;; 2-syntax-aux.watsup:536.1-536.112
+;; 2-syntax-aux.watsup:540.1-540.112
 def $subst_heaptype(heaptype : heaptype, typevar*, typeuse*) : heaptype
-  ;; 2-syntax-aux.watsup:568.1-568.67
+  ;; 2-syntax-aux.watsup:572.1-572.67
   def $subst_heaptype{tv' : typevar, tv* : typevar*, tu* : typeuse*}((tv' : typevar <: heaptype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_typevar(tv', tv*{tv : typevar}, tu*{tu : typeuse}) : typeuse <: heaptype)
-  ;; 2-syntax-aux.watsup:569.1-569.65
+  ;; 2-syntax-aux.watsup:573.1-573.65
   def $subst_heaptype{dt : deftype, tv* : typevar*, tu* : typeuse*}((dt : deftype <: heaptype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_deftype(dt, tv*{tv : typevar}, tu*{tu : typeuse}) : deftype <: heaptype)
-  ;; 2-syntax-aux.watsup:570.1-570.53
+  ;; 2-syntax-aux.watsup:574.1-574.53
   def $subst_heaptype{ht : heaptype, tv* : typevar*, tu* : typeuse*}(ht, tv*{tv : typevar}, tu*{tu : typeuse}) = ht
     -- otherwise
 
-;; 2-syntax-aux.watsup:537.1-537.112
+;; 2-syntax-aux.watsup:541.1-541.112
 def $subst_reftype(reftype : reftype, typevar*, typeuse*) : reftype
-  ;; 2-syntax-aux.watsup:572.1-572.83
+  ;; 2-syntax-aux.watsup:576.1-576.83
   def $subst_reftype{nul : nul, ht : heaptype, tv* : typevar*, tu* : typeuse*}(REF_reftype(nul, ht), tv*{tv : typevar}, tu*{tu : typeuse}) = REF_reftype(nul, $subst_heaptype(ht, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:538.1-538.112
+;; 2-syntax-aux.watsup:542.1-542.112
 def $subst_valtype(valtype : valtype, typevar*, typeuse*) : valtype
-  ;; 2-syntax-aux.watsup:574.1-574.64
+  ;; 2-syntax-aux.watsup:578.1-578.64
   def $subst_valtype{nt : numtype, tv* : typevar*, tu* : typeuse*}((nt : numtype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_numtype(nt, tv*{tv : typevar}, tu*{tu : typeuse}) : numtype <: valtype)
-  ;; 2-syntax-aux.watsup:575.1-575.64
+  ;; 2-syntax-aux.watsup:579.1-579.64
   def $subst_valtype{vt : vectype, tv* : typevar*, tu* : typeuse*}((vt : vectype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_vectype(vt, tv*{tv : typevar}, tu*{tu : typeuse}) : vectype <: valtype)
-  ;; 2-syntax-aux.watsup:576.1-576.64
+  ;; 2-syntax-aux.watsup:580.1-580.64
   def $subst_valtype{rt : reftype, tv* : typevar*, tu* : typeuse*}((rt : reftype <: valtype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_reftype(rt, tv*{tv : typevar}, tu*{tu : typeuse}) : reftype <: valtype)
-  ;; 2-syntax-aux.watsup:577.1-577.40
+  ;; 2-syntax-aux.watsup:581.1-581.40
   def $subst_valtype{tv* : typevar*, tu* : typeuse*}(BOT_valtype, tv*{tv : typevar}, tu*{tu : typeuse}) = BOT_valtype
 
-;; 2-syntax-aux.watsup:541.1-541.112
+;; 2-syntax-aux.watsup:545.1-545.112
 def $subst_storagetype(storagetype : storagetype, typevar*, typeuse*) : storagetype
-  ;; 2-syntax-aux.watsup:581.1-581.66
+  ;; 2-syntax-aux.watsup:585.1-585.66
   def $subst_storagetype{t : valtype, tv* : typevar*, tu* : typeuse*}((t : valtype <: storagetype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_valtype(t, tv*{tv : typevar}, tu*{tu : typeuse}) : valtype <: storagetype)
-  ;; 2-syntax-aux.watsup:582.1-582.69
+  ;; 2-syntax-aux.watsup:586.1-586.69
   def $subst_storagetype{pt : packtype, tv* : typevar*, tu* : typeuse*}((pt : packtype <: storagetype), tv*{tv : typevar}, tu*{tu : typeuse}) = ($subst_packtype(pt, tv*{tv : typevar}, tu*{tu : typeuse}) : packtype <: storagetype)
 
-;; 2-syntax-aux.watsup:542.1-542.112
+;; 2-syntax-aux.watsup:546.1-546.112
 def $subst_fieldtype(fieldtype : fieldtype, typevar*, typeuse*) : fieldtype
-  ;; 2-syntax-aux.watsup:584.1-584.80
+  ;; 2-syntax-aux.watsup:588.1-588.80
   def $subst_fieldtype{mut : mut, zt : storagetype, tv* : typevar*, tu* : typeuse*}(`%%`_fieldtype(mut, zt), tv*{tv : typevar}, tu*{tu : typeuse}) = `%%`_fieldtype(mut, $subst_storagetype(zt, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:544.1-544.112
+;; 2-syntax-aux.watsup:548.1-548.112
 def $subst_comptype(comptype : comptype, typevar*, typeuse*) : comptype
-  ;; 2-syntax-aux.watsup:586.1-586.85
+  ;; 2-syntax-aux.watsup:590.1-590.85
   def $subst_comptype{yt* : fieldtype*, tv* : typevar*, tu* : typeuse*}(STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = STRUCT_comptype(`%`_structtype($subst_fieldtype(yt, tv*{tv : typevar}, tu*{tu : typeuse})*{yt : fieldtype}))
-  ;; 2-syntax-aux.watsup:587.1-587.81
+  ;; 2-syntax-aux.watsup:591.1-591.81
   def $subst_comptype{yt : fieldtype, tv* : typevar*, tu* : typeuse*}(ARRAY_comptype(yt), tv*{tv : typevar}, tu*{tu : typeuse}) = ARRAY_comptype($subst_fieldtype(yt, tv*{tv : typevar}, tu*{tu : typeuse}))
-  ;; 2-syntax-aux.watsup:588.1-588.78
+  ;; 2-syntax-aux.watsup:592.1-592.78
   def $subst_comptype{ft : functype, tv* : typevar*, tu* : typeuse*}(FUNC_comptype(ft), tv*{tv : typevar}, tu*{tu : typeuse}) = FUNC_comptype($subst_functype(ft, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:545.1-545.112
+;; 2-syntax-aux.watsup:549.1-549.112
 def $subst_subtype(subtype : subtype, typevar*, typeuse*) : subtype
-  ;; 2-syntax-aux.watsup:590.1-591.71
+  ;; 2-syntax-aux.watsup:594.1-595.71
   def $subst_subtype{fin : fin, tu'* : typeuse*, ct : comptype, tv* : typevar*, tu* : typeuse*}(SUB_subtype(fin, tu'*{tu' : typeuse}, ct), tv*{tv : typevar}, tu*{tu : typeuse}) = SUB_subtype(fin, $subst_typeuse(tu', tv*{tv : typevar}, tu*{tu : typeuse})*{tu' : typeuse}, $subst_comptype(ct, tv*{tv : typevar}, tu*{tu : typeuse}))
 
-;; 2-syntax-aux.watsup:546.1-546.112
+;; 2-syntax-aux.watsup:550.1-550.112
 def $subst_rectype(rectype : rectype, typevar*, typeuse*) : rectype
-  ;; 2-syntax-aux.watsup:593.1-593.76
+  ;; 2-syntax-aux.watsup:597.1-597.76
   def $subst_rectype{st* : subtype*, tv* : typevar*, tu* : typeuse*}(REC_rectype(`%`_list(st*{st : subtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = REC_rectype(`%`_list($subst_subtype(st, tv*{tv : typevar}, tu*{tu : typeuse})*{st : subtype}))
 
-;; 2-syntax-aux.watsup:547.1-547.112
+;; 2-syntax-aux.watsup:551.1-551.112
 def $subst_deftype(deftype : deftype, typevar*, typeuse*) : deftype
-  ;; 2-syntax-aux.watsup:595.1-595.78
+  ;; 2-syntax-aux.watsup:599.1-599.78
   def $subst_deftype{qt : rectype, i : nat, tv* : typevar*, tu* : typeuse*}(DEF_deftype(qt, i), tv*{tv : typevar}, tu*{tu : typeuse}) = DEF_deftype($subst_rectype(qt, tv*{tv : typevar}, tu*{tu : typeuse}), i)
 
-;; 2-syntax-aux.watsup:550.1-550.112
+;; 2-syntax-aux.watsup:554.1-554.112
 def $subst_functype(functype : functype, typevar*, typeuse*) : functype
-  ;; 2-syntax-aux.watsup:598.1-598.113
+  ;; 2-syntax-aux.watsup:602.1-602.113
   def $subst_functype{t_1* : valtype*, t_2* : valtype*, tv* : typevar*, tu* : typeuse*}(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})), tv*{tv : typevar}, tu*{tu : typeuse}) = `%->%`_functype(`%`_resulttype($subst_valtype(t_1, tv*{tv : typevar}, tu*{tu : typeuse})*{t_1 : valtype}), `%`_resulttype($subst_valtype(t_2, tv*{tv : typevar}, tu*{tu : typeuse})*{t_2 : valtype}))
 }
 
@@ -26297,11 +27420,11 @@ def $subst_all_moduletype(moduletype : moduletype, heaptype*) : moduletype
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:620.1-620.98
+;; 2-syntax-aux.watsup:624.1-624.98
 def $subst_all_deftypes(deftype*, heaptype*) : deftype*
-  ;; 2-syntax-aux.watsup:621.1-621.40
+  ;; 2-syntax-aux.watsup:625.1-625.40
   def $subst_all_deftypes{tu* : typeuse*}([], (tu : typeuse <: heaptype)*{tu : typeuse}) = []
-  ;; 2-syntax-aux.watsup:622.1-622.101
+  ;; 2-syntax-aux.watsup:626.1-626.101
   def $subst_all_deftypes{dt_1 : deftype, dt* : deftype*, tu* : typeuse*}([dt_1] :: dt*{dt : deftype}, (tu : typeuse <: heaptype)*{tu : typeuse}) = [$subst_all_deftype(dt_1, (tu : typeuse <: heaptype)*{tu : typeuse})] :: $subst_all_deftypes(dt*{dt : deftype}, (tu : typeuse <: heaptype)*{tu : typeuse})
 }
 
@@ -26345,13 +27468,13 @@ relation Expand: `%~~%`(deftype, comptype)
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:654.1-654.86
+;; 2-syntax-aux.watsup:658.1-658.86
 def $funcsxx(externidx*) : typeidx*
-  ;; 2-syntax-aux.watsup:659.1-659.24
+  ;; 2-syntax-aux.watsup:664.1-664.24
   def $funcsxx([]) = []
-  ;; 2-syntax-aux.watsup:660.1-660.45
+  ;; 2-syntax-aux.watsup:665.1-665.45
   def $funcsxx{x : idx, xx* : externidx*}([FUNC_externidx(x)] :: xx*{xx : externidx}) = [x] :: $funcsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:661.1-661.58
+  ;; 2-syntax-aux.watsup:666.1-666.58
   def $funcsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $funcsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -26359,13 +27482,13 @@ def $funcsxx(externidx*) : typeidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:655.1-655.88
+;; 2-syntax-aux.watsup:659.1-659.88
 def $globalsxx(externidx*) : globalidx*
-  ;; 2-syntax-aux.watsup:663.1-663.26
+  ;; 2-syntax-aux.watsup:668.1-668.26
   def $globalsxx([]) = []
-  ;; 2-syntax-aux.watsup:664.1-664.51
+  ;; 2-syntax-aux.watsup:669.1-669.51
   def $globalsxx{x : idx, xx* : externidx*}([GLOBAL_externidx(x)] :: xx*{xx : externidx}) = [x] :: $globalsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:665.1-665.62
+  ;; 2-syntax-aux.watsup:670.1-670.62
   def $globalsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $globalsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -26373,13 +27496,13 @@ def $globalsxx(externidx*) : globalidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:656.1-656.87
+;; 2-syntax-aux.watsup:660.1-660.87
 def $tablesxx(externidx*) : tableidx*
-  ;; 2-syntax-aux.watsup:667.1-667.25
+  ;; 2-syntax-aux.watsup:672.1-672.25
   def $tablesxx([]) = []
-  ;; 2-syntax-aux.watsup:668.1-668.48
+  ;; 2-syntax-aux.watsup:673.1-673.48
   def $tablesxx{x : idx, xx* : externidx*}([TABLE_externidx(x)] :: xx*{xx : externidx}) = [x] :: $tablesxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:669.1-669.60
+  ;; 2-syntax-aux.watsup:674.1-674.60
   def $tablesxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $tablesxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -26387,13 +27510,13 @@ def $tablesxx(externidx*) : tableidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:657.1-657.85
+;; 2-syntax-aux.watsup:661.1-661.85
 def $memsxx(externidx*) : memidx*
-  ;; 2-syntax-aux.watsup:671.1-671.23
+  ;; 2-syntax-aux.watsup:676.1-676.23
   def $memsxx([]) = []
-  ;; 2-syntax-aux.watsup:672.1-672.42
+  ;; 2-syntax-aux.watsup:677.1-677.42
   def $memsxx{x : idx, xx* : externidx*}([MEM_externidx(x)] :: xx*{xx : externidx}) = [x] :: $memsxx(xx*{xx : externidx})
-  ;; 2-syntax-aux.watsup:673.1-673.56
+  ;; 2-syntax-aux.watsup:678.1-678.56
   def $memsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $memsxx(xx*{xx : externidx})
     -- otherwise
 }
@@ -26401,13 +27524,27 @@ def $memsxx(externidx*) : memidx*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:676.1-676.88
+;; 2-syntax-aux.watsup:662.1-662.85
+def $tagsxx(externidx*) : tagidx*
+  ;; 2-syntax-aux.watsup:680.1-680.23
+  def $tagsxx([]) = []
+  ;; 2-syntax-aux.watsup:681.1-681.42
+  def $tagsxx{x : idx, xx* : externidx*}([TAG_externidx(x)] :: xx*{xx : externidx}) = [x] :: $tagsxx(xx*{xx : externidx})
+  ;; 2-syntax-aux.watsup:682.1-682.56
+  def $tagsxx{externidx : externidx, xx* : externidx*}([externidx] :: xx*{xx : externidx}) = $tagsxx(xx*{xx : externidx})
+    -- otherwise
+}
+
+;; 2-syntax-aux.watsup
+rec {
+
+;; 2-syntax-aux.watsup:685.1-685.88
 def $funcsxt(externtype*) : deftype*
-  ;; 2-syntax-aux.watsup:681.1-681.24
+  ;; 2-syntax-aux.watsup:691.1-691.24
   def $funcsxt([]) = []
-  ;; 2-syntax-aux.watsup:682.1-682.47
+  ;; 2-syntax-aux.watsup:692.1-692.47
   def $funcsxt{dt : deftype, xt* : externtype*}([FUNC_externtype((dt : deftype <: typeuse))] :: xt*{xt : externtype}) = [dt] :: $funcsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:683.1-683.59
+  ;; 2-syntax-aux.watsup:693.1-693.59
   def $funcsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $funcsxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -26415,13 +27552,13 @@ def $funcsxt(externtype*) : deftype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:677.1-677.90
+;; 2-syntax-aux.watsup:686.1-686.90
 def $globalsxt(externtype*) : globaltype*
-  ;; 2-syntax-aux.watsup:685.1-685.26
+  ;; 2-syntax-aux.watsup:695.1-695.26
   def $globalsxt([]) = []
-  ;; 2-syntax-aux.watsup:686.1-686.53
+  ;; 2-syntax-aux.watsup:696.1-696.53
   def $globalsxt{gt : globaltype, xt* : externtype*}([GLOBAL_externtype(gt)] :: xt*{xt : externtype}) = [gt] :: $globalsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:687.1-687.63
+  ;; 2-syntax-aux.watsup:697.1-697.63
   def $globalsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $globalsxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -26429,13 +27566,13 @@ def $globalsxt(externtype*) : globaltype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:678.1-678.89
+;; 2-syntax-aux.watsup:687.1-687.89
 def $tablesxt(externtype*) : tabletype*
-  ;; 2-syntax-aux.watsup:689.1-689.25
+  ;; 2-syntax-aux.watsup:699.1-699.25
   def $tablesxt([]) = []
-  ;; 2-syntax-aux.watsup:690.1-690.50
+  ;; 2-syntax-aux.watsup:700.1-700.50
   def $tablesxt{tt : tabletype, xt* : externtype*}([TABLE_externtype(tt)] :: xt*{xt : externtype}) = [tt] :: $tablesxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:691.1-691.61
+  ;; 2-syntax-aux.watsup:701.1-701.61
   def $tablesxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $tablesxt(xt*{xt : externtype})
     -- otherwise
 }
@@ -26443,17 +27580,31 @@ def $tablesxt(externtype*) : tabletype*
 ;; 2-syntax-aux.watsup
 rec {
 
-;; 2-syntax-aux.watsup:679.1-679.87
+;; 2-syntax-aux.watsup:688.1-688.87
 def $memsxt(externtype*) : memtype*
-  ;; 2-syntax-aux.watsup:693.1-693.23
+  ;; 2-syntax-aux.watsup:703.1-703.23
   def $memsxt([]) = []
-  ;; 2-syntax-aux.watsup:694.1-694.44
+  ;; 2-syntax-aux.watsup:704.1-704.44
   def $memsxt{mt : memtype, xt* : externtype*}([MEM_externtype(mt)] :: xt*{xt : externtype}) = [mt] :: $memsxt(xt*{xt : externtype})
-  ;; 2-syntax-aux.watsup:695.1-695.57
+  ;; 2-syntax-aux.watsup:705.1-705.57
   def $memsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $memsxt(xt*{xt : externtype})
     -- otherwise
 }
 
+;; 2-syntax-aux.watsup
+rec {
+
+;; 2-syntax-aux.watsup:689.1-689.87
+def $tagsxt(externtype*) : tagtype*
+  ;; 2-syntax-aux.watsup:707.1-707.23
+  def $tagsxt([]) = []
+  ;; 2-syntax-aux.watsup:708.1-708.44
+  def $tagsxt{at : tagtype, xt* : externtype*}([TAG_externtype((at : deftype <: typeuse))] :: xt*{xt : externtype}) = [at] :: $tagsxt(xt*{xt : externtype})
+  ;; 2-syntax-aux.watsup:709.1-709.57
+  def $tagsxt{externtype : externtype, xt* : externtype*}([externtype] :: xt*{xt : externtype}) = $tagsxt(xt*{xt : externtype})
+    -- otherwise
+}
+
 ;; 2-syntax-aux.watsup
 def $memarg0 : memarg
   ;; 2-syntax-aux.watsup
@@ -27181,6 +28332,7 @@ syntax ref =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | REF.NULL{heaptype : heaptype}(heaptype : heaptype)
@@ -27188,6 +28340,7 @@ syntax ref =
 ;; 4-runtime.watsup
 syntax result =
   | _VALS{val* : val*}(val*{val : val} : val*)
+  | `_EXN(REF.EXN_ADDR%)THROW_REF`{exnaddr : exnaddr}(exnaddr : exnaddr)
   | TRAP
 
 ;; 4-runtime.watsup
@@ -27228,6 +28381,12 @@ syntax meminst =
   BYTES{byte* : byte*} byte*
 }
 
+;; 4-runtime.watsup
+syntax taginst =
+{
+  TYPE{tagtype : tagtype} tagtype
+}
+
 ;; 4-runtime.watsup
 syntax eleminst =
 {
@@ -27254,6 +28413,7 @@ syntax fieldval =
   | REF.STRUCT_ADDR{structaddr : structaddr}(structaddr : structaddr)
   | REF.ARRAY_ADDR{arrayaddr : arrayaddr}(arrayaddr : arrayaddr)
   | REF.FUNC_ADDR{funcaddr : funcaddr}(funcaddr : funcaddr)
+  | REF.EXN_ADDR{exnaddr : exnaddr}(exnaddr : exnaddr)
   | REF.HOST_ADDR{hostaddr : hostaddr}(hostaddr : hostaddr)
   | REF.EXTERN{addrref : addrref}(addrref : addrref)
   | PACK{packtype : packtype, iN : iN($psizenn(packtype))}(packtype : packtype, iN : iN($psizenn(packtype)))
@@ -27272,6 +28432,13 @@ syntax arrayinst =
   FIELDS{fieldval* : fieldval*} fieldval*
 }
 
+;; 4-runtime.watsup
+syntax exninst =
+{
+  TAG{tagaddr : tagaddr} tagaddr,
+  FIELDS{val* : val*} val*
+}
+
 ;; 4-runtime.watsup
 syntax store =
 {
@@ -27279,10 +28446,12 @@ syntax store =
   GLOBALS{globalinst* : globalinst*} globalinst*,
   TABLES{tableinst* : tableinst*} tableinst*,
   MEMS{meminst* : meminst*} meminst*,
+  TAGS{taginst* : taginst*} taginst*,
   ELEMS{eleminst* : eleminst*} eleminst*,
   DATAS{datainst* : datainst*} datainst*,
   STRUCTS{structinst* : structinst*} structinst*,
-  ARRAYS{arrayinst* : arrayinst*} arrayinst*
+  ARRAYS{arrayinst* : arrayinst*} arrayinst*,
+  EXNS{exninst* : exninst*} exninst*
 }
 
 ;; 4-runtime.watsup
@@ -27335,56 +28504,70 @@ def $unpackfield_(storagetype : storagetype, sx?, fieldval : fieldval) : val
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:46.1-46.86
-def $funcsxv(externval*) : funcaddr*
-  ;; 5-runtime-aux.watsup:51.1-51.24
-  def $funcsxv([]) = []
-  ;; 5-runtime-aux.watsup:52.1-52.47
-  def $funcsxv{fa : funcaddr, xv* : externval*}([FUNC_externval(fa)] :: xv*{xv : externval}) = [fa] :: $funcsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:53.1-53.58
-  def $funcsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $funcsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:46.1-46.87
+def $funcsxa(externaddr*) : funcaddr*
+  ;; 5-runtime-aux.watsup:52.1-52.24
+  def $funcsxa([]) = []
+  ;; 5-runtime-aux.watsup:53.1-53.47
+  def $funcsxa{fa : funcaddr, xa* : externaddr*}([FUNC_externaddr(fa)] :: xa*{xa : externaddr}) = [fa] :: $funcsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:54.1-54.59
+  def $funcsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $funcsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:47.1-47.88
-def $globalsxv(externval*) : globaladdr*
-  ;; 5-runtime-aux.watsup:55.1-55.26
-  def $globalsxv([]) = []
-  ;; 5-runtime-aux.watsup:56.1-56.53
-  def $globalsxv{ga : globaladdr, xv* : externval*}([GLOBAL_externval(ga)] :: xv*{xv : externval}) = [ga] :: $globalsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:57.1-57.62
-  def $globalsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $globalsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:47.1-47.89
+def $globalsxa(externaddr*) : globaladdr*
+  ;; 5-runtime-aux.watsup:56.1-56.26
+  def $globalsxa([]) = []
+  ;; 5-runtime-aux.watsup:57.1-57.53
+  def $globalsxa{ga : globaladdr, xa* : externaddr*}([GLOBAL_externaddr(ga)] :: xa*{xa : externaddr}) = [ga] :: $globalsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:58.1-58.63
+  def $globalsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $globalsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:48.1-48.87
-def $tablesxv(externval*) : tableaddr*
-  ;; 5-runtime-aux.watsup:59.1-59.25
-  def $tablesxv([]) = []
-  ;; 5-runtime-aux.watsup:60.1-60.50
-  def $tablesxv{ta : tableaddr, xv* : externval*}([TABLE_externval(ta)] :: xv*{xv : externval}) = [ta] :: $tablesxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:61.1-61.60
-  def $tablesxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $tablesxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:48.1-48.88
+def $tablesxa(externaddr*) : tableaddr*
+  ;; 5-runtime-aux.watsup:60.1-60.25
+  def $tablesxa([]) = []
+  ;; 5-runtime-aux.watsup:61.1-61.50
+  def $tablesxa{ta : tableaddr, xa* : externaddr*}([TABLE_externaddr(ta)] :: xa*{xa : externaddr}) = [ta] :: $tablesxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:62.1-62.61
+  def $tablesxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $tablesxa(xa*{xa : externaddr})
     -- otherwise
 }
 
 ;; 5-runtime-aux.watsup
 rec {
 
-;; 5-runtime-aux.watsup:49.1-49.85
-def $memsxv(externval*) : memaddr*
-  ;; 5-runtime-aux.watsup:63.1-63.23
-  def $memsxv([]) = []
-  ;; 5-runtime-aux.watsup:64.1-64.44
-  def $memsxv{ma : memaddr, xv* : externval*}([MEM_externval(ma)] :: xv*{xv : externval}) = [ma] :: $memsxv(xv*{xv : externval})
-  ;; 5-runtime-aux.watsup:65.1-65.56
-  def $memsxv{externval : externval, xv* : externval*}([externval] :: xv*{xv : externval}) = $memsxv(xv*{xv : externval})
+;; 5-runtime-aux.watsup:49.1-49.86
+def $memsxa(externaddr*) : memaddr*
+  ;; 5-runtime-aux.watsup:64.1-64.23
+  def $memsxa([]) = []
+  ;; 5-runtime-aux.watsup:65.1-65.44
+  def $memsxa{ma : memaddr, xa* : externaddr*}([MEM_externaddr(ma)] :: xa*{xa : externaddr}) = [ma] :: $memsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:66.1-66.57
+  def $memsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $memsxa(xa*{xa : externaddr})
+    -- otherwise
+}
+
+;; 5-runtime-aux.watsup
+rec {
+
+;; 5-runtime-aux.watsup:50.1-50.86
+def $tagsxa(externaddr*) : tagaddr*
+  ;; 5-runtime-aux.watsup:68.1-68.23
+  def $tagsxa([]) = []
+  ;; 5-runtime-aux.watsup:69.1-69.44
+  def $tagsxa{ha : tagaddr, xa* : externaddr*}([TAG_externaddr(ha)] :: xa*{xa : externaddr}) = [ha] :: $tagsxa(xa*{xa : externaddr})
+  ;; 5-runtime-aux.watsup:70.1-70.57
+  def $tagsxa{externaddr : externaddr, xa* : externaddr*}([externaddr] :: xa*{xa : externaddr}) = $tagsxa(xa*{xa : externaddr})
     -- otherwise
 }
 
@@ -27398,6 +28581,11 @@ def $frame(state : state) : frame
   ;; 5-runtime-aux.watsup
   def $frame{s : store, f : frame}(`%;%`_state(s, f)) = f
 
+;; 5-runtime-aux.watsup
+def $tagaddr(state : state) : tagaddr*
+  ;; 5-runtime-aux.watsup
+  def $tagaddr{s : store, f : frame}(`%;%`_state(s, f)) = f.MODULE_frame.TAGS_moduleinst
+
 ;; 5-runtime-aux.watsup
 def $moduleinst(state : state) : moduleinst
   ;; 5-runtime-aux.watsup
@@ -27423,6 +28611,11 @@ def $meminst(state : state) : meminst*
   ;; 5-runtime-aux.watsup
   def $meminst{s : store, f : frame}(`%;%`_state(s, f)) = s.MEMS_store
 
+;; 5-runtime-aux.watsup
+def $taginst(state : state) : taginst*
+  ;; 5-runtime-aux.watsup
+  def $taginst{s : store, f : frame}(`%;%`_state(s, f)) = s.TAGS_store
+
 ;; 5-runtime-aux.watsup
 def $eleminst(state : state) : eleminst*
   ;; 5-runtime-aux.watsup
@@ -27443,6 +28636,11 @@ def $arrayinst(state : state) : arrayinst*
   ;; 5-runtime-aux.watsup
   def $arrayinst{s : store, f : frame}(`%;%`_state(s, f)) = s.ARRAYS_store
 
+;; 5-runtime-aux.watsup
+def $exninst(state : state) : exninst*
+  ;; 5-runtime-aux.watsup
+  def $exninst{s : store, f : frame}(`%;%`_state(s, f)) = s.EXNS_store
+
 ;; 5-runtime-aux.watsup
 def $type(state : state, typeidx : typeidx) : deftype
   ;; 5-runtime-aux.watsup
@@ -27468,6 +28666,11 @@ def $mem(state : state, memidx : memidx) : meminst
   ;; 5-runtime-aux.watsup
   def $mem{s : store, f : frame, x : idx}(`%;%`_state(s, f), x) = s.MEMS_store[f.MODULE_frame.MEMS_moduleinst[x!`%`_idx.0]]
 
+;; 5-runtime-aux.watsup
+def $tag(state : state, tagidx : tagidx) : taginst
+  ;; 5-runtime-aux.watsup
+  def $tag{s : store, f : frame, x : idx}(`%;%`_state(s, f), x) = s.TAGS_store[f.MODULE_frame.TAGS_moduleinst[x!`%`_idx.0]]
+
 ;; 5-runtime-aux.watsup
 def $elem(state : state, tableidx : tableidx) : eleminst
   ;; 5-runtime-aux.watsup
@@ -27543,6 +28746,11 @@ def $add_arrayinst(state : state, arrayinst*) : state
   ;; 5-runtime-aux.watsup
   def $add_arrayinst{s : store, f : frame, ai* : arrayinst*}(`%;%`_state(s, f), ai*{ai : arrayinst}) = `%;%`_state(s[ARRAYS_store =++ ai*{ai : arrayinst}], f)
 
+;; 5-runtime-aux.watsup
+def $add_exninst(state : state, exninst*) : state
+  ;; 5-runtime-aux.watsup
+  def $add_exninst{s : store, f : frame, exn* : exninst*}(`%;%`_state(s, f), exn*{exn : exninst}) = `%;%`_state(s[EXNS_store =++ exn*{exn : exninst}], f)
+
 ;; 5-runtime-aux.watsup
 def $growtable(tableinst : tableinst, nat : nat, ref : ref) : tableinst?
   ;; 5-runtime-aux.watsup
@@ -27583,6 +28791,7 @@ syntax context =
   GLOBALS{globaltype* : globaltype*} globaltype*,
   TABLES{tabletype* : tabletype*} tabletype*,
   MEMS{memtype* : memtype*} memtype*,
+  TAGS{tagtype* : tagtype*} tagtype*,
   ELEMS{elemtype* : elemtype*} elemtype*,
   DATAS{datatype* : datatype*} datatype*,
   LOCALS{localtype* : localtype*} localtype*,
@@ -27594,22 +28803,22 @@ syntax context =
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:36.1-36.86
+;; 6-typing.watsup:37.1-37.86
 def $with_locals(context : context, localidx*, localtype*) : context
-  ;; 6-typing.watsup:38.1-38.34
+  ;; 6-typing.watsup:39.1-39.34
   def $with_locals{C : context}(C, [], []) = C
-  ;; 6-typing.watsup:39.1-39.90
+  ;; 6-typing.watsup:40.1-40.90
   def $with_locals{C : context, x_1 : idx, x* : idx*, lct_1 : localtype, lct* : localtype*}(C, [x_1] :: x*{x : localidx}, [lct_1] :: lct*{lct : localtype}) = $with_locals(C[LOCALS_context[x_1!`%`_idx.0] = lct_1], x*{x : localidx}, lct*{lct : localtype})
 }
 
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:45.1-45.94
+;; 6-typing.watsup:46.1-46.94
 def $clos_deftypes(deftype*) : deftype*
-  ;; 6-typing.watsup:52.1-52.30
+  ;; 6-typing.watsup:53.1-53.30
   def $clos_deftypes([]) = []
-  ;; 6-typing.watsup:53.1-53.101
+  ;; 6-typing.watsup:54.1-54.101
   def $clos_deftypes{dt* : deftype*, dt_n : deftype, dt'* : deftype*}(dt*{dt : deftype} :: [dt_n]) = dt'*{dt' : deftype} :: [$subst_all_deftype(dt_n, (dt' : deftype <: heaptype)*{dt' : deftype})]
     -- if (dt'*{dt' : deftype} = $clos_deftypes(dt*{dt : deftype}))
 }
@@ -27781,104 +28990,104 @@ relation Numtype_sub: `%|-%<:%`(context, numtype, numtype)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:140.1-140.107
+;; 6-typing.watsup:141.1-141.107
 relation Deftype_sub: `%|-%<:%`(context, deftype, deftype)
-  ;; 6-typing.watsup:451.1-453.66
+  ;; 6-typing.watsup:462.1-464.66
   rule refl{C : context, deftype_1 : deftype, deftype_2 : deftype}:
     `%|-%<:%`(C, deftype_1, deftype_2)
     -- if ($clos_deftype(C, deftype_1) = $clos_deftype(C, deftype_2))
 
-  ;; 6-typing.watsup:455.1-458.49
+  ;; 6-typing.watsup:466.1-469.49
   rule super{C : context, deftype_1 : deftype, deftype_2 : deftype, fin : fin, typeuse* : typeuse*, ct : comptype, i : nat}:
     `%|-%<:%`(C, deftype_1, deftype_2)
     -- if (i < |typeuse*{typeuse : typeuse}|)
     -- if ($unrolldt(deftype_1) = SUB_subtype(fin, typeuse*{typeuse : typeuse}, ct))
     -- Heaptype_sub: `%|-%<:%`(C, (typeuse*{typeuse : typeuse}[i] : typeuse <: heaptype), (deftype_2 : deftype <: heaptype))
 
-;; 6-typing.watsup:288.1-288.104
+;; 6-typing.watsup:299.1-299.104
 relation Heaptype_sub: `%|-%<:%`(context, heaptype, heaptype)
-  ;; 6-typing.watsup:299.1-300.28
+  ;; 6-typing.watsup:310.1-311.28
   rule refl{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, heaptype, heaptype)
 
-  ;; 6-typing.watsup:302.1-306.48
+  ;; 6-typing.watsup:313.1-317.48
   rule trans{C : context, heaptype_1 : heaptype, heaptype_2 : heaptype, heaptype' : heaptype}:
     `%|-%<:%`(C, heaptype_1, heaptype_2)
     -- Heaptype_ok: `%|-%:OK`(C, heaptype')
     -- Heaptype_sub: `%|-%<:%`(C, heaptype_1, heaptype')
     -- Heaptype_sub: `%|-%<:%`(C, heaptype', heaptype_2)
 
-  ;; 6-typing.watsup:308.1-309.17
+  ;; 6-typing.watsup:319.1-320.17
   rule eq-any{C : context}:
     `%|-%<:%`(C, EQ_heaptype, ANY_heaptype)
 
-  ;; 6-typing.watsup:311.1-312.17
+  ;; 6-typing.watsup:322.1-323.17
   rule i31-eq{C : context}:
     `%|-%<:%`(C, I31_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:314.1-315.20
+  ;; 6-typing.watsup:325.1-326.20
   rule struct-eq{C : context}:
     `%|-%<:%`(C, STRUCT_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:317.1-318.19
+  ;; 6-typing.watsup:328.1-329.19
   rule array-eq{C : context}:
     `%|-%<:%`(C, ARRAY_heaptype, EQ_heaptype)
 
-  ;; 6-typing.watsup:320.1-322.42
+  ;; 6-typing.watsup:331.1-333.42
   rule struct{C : context, deftype : deftype, fieldtype* : fieldtype*}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), STRUCT_heaptype)
     -- Expand: `%~~%`(deftype, STRUCT_comptype(`%`_structtype(fieldtype*{fieldtype : fieldtype})))
 
-  ;; 6-typing.watsup:324.1-326.40
+  ;; 6-typing.watsup:335.1-337.40
   rule array{C : context, deftype : deftype, fieldtype : fieldtype}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), ARRAY_heaptype)
     -- Expand: `%~~%`(deftype, ARRAY_comptype(fieldtype))
 
-  ;; 6-typing.watsup:328.1-330.38
+  ;; 6-typing.watsup:339.1-341.38
   rule func{C : context, deftype : deftype, functype : functype}:
     `%|-%<:%`(C, (deftype : deftype <: heaptype), FUNC_heaptype)
     -- Expand: `%~~%`(deftype, FUNC_comptype(functype))
 
-  ;; 6-typing.watsup:332.1-334.46
+  ;; 6-typing.watsup:343.1-345.46
   rule def{C : context, deftype_1 : deftype, deftype_2 : deftype}:
     `%|-%<:%`(C, (deftype_1 : deftype <: heaptype), (deftype_2 : deftype <: heaptype))
     -- Deftype_sub: `%|-%<:%`(C, deftype_1, deftype_2)
 
-  ;; 6-typing.watsup:336.1-338.53
+  ;; 6-typing.watsup:347.1-349.53
   rule typeidx-l{C : context, typeidx : typeidx, heaptype : heaptype}:
     `%|-%<:%`(C, _IDX_heaptype(typeidx), heaptype)
     -- if (typeidx!`%`_typeidx.0 < |C.TYPES_context|)
     -- Heaptype_sub: `%|-%<:%`(C, (C.TYPES_context[typeidx!`%`_typeidx.0] : deftype <: heaptype), heaptype)
 
-  ;; 6-typing.watsup:340.1-342.53
+  ;; 6-typing.watsup:351.1-353.53
   rule typeidx-r{C : context, heaptype : heaptype, typeidx : typeidx}:
     `%|-%<:%`(C, heaptype, _IDX_heaptype(typeidx))
     -- if (typeidx!`%`_typeidx.0 < |C.TYPES_context|)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, (C.TYPES_context[typeidx!`%`_typeidx.0] : deftype <: heaptype))
 
-  ;; 6-typing.watsup:344.1-346.40
+  ;; 6-typing.watsup:355.1-357.40
   rule rec{C : context, i : nat, typeuse* : typeuse*, j : nat, fin : fin, ct : comptype}:
     `%|-%<:%`(C, REC_heaptype(i), (typeuse*{typeuse : typeuse}[j] : typeuse <: heaptype))
     -- if (i < |C.RECS_context|)
     -- if (j < |typeuse*{typeuse : typeuse}|)
     -- if (C.RECS_context[i] = SUB_subtype(fin, typeuse*{typeuse : typeuse}, ct))
 
-  ;; 6-typing.watsup:348.1-350.40
+  ;; 6-typing.watsup:359.1-361.40
   rule none{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NONE_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, ANY_heaptype)
 
-  ;; 6-typing.watsup:352.1-354.41
+  ;; 6-typing.watsup:363.1-365.41
   rule nofunc{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NOFUNC_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, FUNC_heaptype)
 
-  ;; 6-typing.watsup:356.1-358.43
+  ;; 6-typing.watsup:367.1-369.43
   rule noextern{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, NOEXTERN_heaptype, heaptype)
     -- Heaptype_sub: `%|-%<:%`(C, heaptype, EXTERN_heaptype)
 
-  ;; 6-typing.watsup:360.1-361.23
+  ;; 6-typing.watsup:371.1-372.23
   rule bot{C : context, heaptype : heaptype}:
     `%|-%<:%`(C, BOT_heaptype, heaptype)
 }
@@ -28029,13 +29238,13 @@ relation Subtype_ok2: `%|-%:%`(context, subtype, oktypeidxnat)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:135.1-135.105
+;; 6-typing.watsup:136.1-136.105
 relation Rectype_ok2: `%|-%:%`(context, rectype, oktypeidxnat)
-  ;; 6-typing.watsup:213.1-214.24
+  ;; 6-typing.watsup:214.1-215.24
   rule empty{C : context, x : idx, i : nat}:
     `%|-%:%`(C, REC_rectype(`%`_list([])), OK_oktypeidxnat(x, i))
 
-  ;; 6-typing.watsup:216.1-219.55
+  ;; 6-typing.watsup:217.1-220.55
   rule cons{C : context, subtype_1 : subtype, subtype* : subtype*, x : idx, i : nat}:
     `%|-%:%`(C, REC_rectype(`%`_list([subtype_1] :: subtype*{subtype : subtype})), OK_oktypeidxnat(x, i))
     -- Subtype_ok2: `%|-%:%`(C, subtype_1, OK_oktypeidxnat(x, i))
@@ -28045,22 +29254,22 @@ relation Rectype_ok2: `%|-%:%`(context, rectype, oktypeidxnat)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:133.1-133.102
+;; 6-typing.watsup:134.1-134.102
 relation Rectype_ok: `%|-%:%`(context, rectype, oktypeidx)
-  ;; 6-typing.watsup:201.1-202.23
+  ;; 6-typing.watsup:202.1-203.23
   rule empty{C : context, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list([])), OK_oktypeidx(x))
 
-  ;; 6-typing.watsup:204.1-207.48
+  ;; 6-typing.watsup:205.1-208.48
   rule cons{C : context, subtype_1 : subtype, subtype* : subtype*, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list([subtype_1] :: subtype*{subtype : subtype})), OK_oktypeidx(x))
     -- Subtype_ok: `%|-%:%`(C, subtype_1, OK_oktypeidx(x))
     -- Rectype_ok: `%|-%:%`(C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidx(`%`_typeidx((x!`%`_idx.0 + 1))))
 
-  ;; 6-typing.watsup:209.1-211.60
+  ;; 6-typing.watsup:210.1-212.60
   rule rec2{C : context, subtype* : subtype*, x : idx}:
     `%|-%:%`(C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidx(x))
-    -- Rectype_ok2: `%|-%:%`({TYPES [], RECS subtype*{subtype : subtype}, FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []} ++ C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidxnat(x, 0))
+    -- Rectype_ok2: `%|-%:%`({TYPES [], RECS subtype*{subtype : subtype}, FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []} ++ C, REC_rectype(`%`_list(subtype*{subtype : subtype})), OK_oktypeidxnat(x, 0))
 }
 
 ;; 6-typing.watsup
@@ -28101,6 +29310,14 @@ relation Memtype_ok: `%|-%:OK`(context, memtype)
     `%|-%:OK`(C, `%PAGE`_memtype(limits))
     -- Limits_ok: `%|-%:%`(C, limits, (2 ^ 16))
 
+;; 6-typing.watsup
+relation Tagtype_ok: `%|-%:OK`(context, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, deftype : deftype, functype : functype}:
+    `%|-%:OK`(C, deftype)
+    -- Deftype_ok: `%|-%:OK`(C, deftype)
+    -- Expand: `%~~%`(deftype, FUNC_comptype(functype))
+
 ;; 6-typing.watsup
 relation Externtype_ok: `%|-%:OK`(context, externtype)
   ;; 6-typing.watsup
@@ -28124,6 +29341,11 @@ relation Externtype_ok: `%|-%:OK`(context, externtype)
     `%|-%:OK`(C, MEM_externtype(memtype))
     -- Memtype_ok: `%|-%:OK`(C, memtype)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, tagtype : tagtype}:
+    `%|-%:OK`(C, TAG_externtype((tagtype : deftype <: typeuse)))
+    -- Tagtype_ok: `%|-%:OK`(C, tagtype)
+
 ;; 6-typing.watsup
 relation Instrtype_sub: `%|-%<:%`(context, instrtype, instrtype)
   ;; 6-typing.watsup
@@ -28173,6 +29395,14 @@ relation Memtype_sub: `%|-%<:%`(context, memtype, memtype)
     `%|-%<:%`(C, `%PAGE`_memtype(limits_1), `%PAGE`_memtype(limits_2))
     -- Limits_sub: `%|-%<:%`(C, limits_1, limits_2)
 
+;; 6-typing.watsup
+relation Tagtype_sub: `%|-%<:%`(context, tagtype, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, deftype_1 : deftype, deftype_2 : deftype}:
+    `%|-%<:%`(C, deftype_1, deftype_2)
+    -- Deftype_sub: `%|-%<:%`(C, deftype_1, deftype_2)
+    -- Deftype_sub: `%|-%<:%`(C, deftype_2, deftype_1)
+
 ;; 6-typing.watsup
 relation Externtype_sub: `%|-%<:%`(context, externtype, externtype)
   ;; 6-typing.watsup
@@ -28195,6 +29425,11 @@ relation Externtype_sub: `%|-%<:%`(context, externtype, externtype)
     `%|-%<:%`(C, MEM_externtype(memtype_1), MEM_externtype(memtype_2))
     -- Memtype_sub: `%|-%<:%`(C, memtype_1, memtype_2)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, tagtype_1 : tagtype, tagtype_2 : tagtype}:
+    `%|-%<:%`(C, TAG_externtype((tagtype_1 : deftype <: typeuse)), TAG_externtype((tagtype_2 : deftype <: typeuse)))
+    -- Tagtype_sub: `%|-%<:%`(C, tagtype_1, tagtype_2)
+
 ;; 6-typing.watsup
 relation Blocktype_ok: `%|-%:%`(context, blocktype, instrtype)
   ;; 6-typing.watsup
@@ -28208,70 +29443,100 @@ relation Blocktype_ok: `%|-%:%`(context, blocktype, instrtype)
     -- if (typeidx!`%`_typeidx.0 < |C.TYPES_context|)
     -- Expand: `%~~%`(C.TYPES_context[typeidx!`%`_typeidx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
+;; 6-typing.watsup
+relation Catch_ok: `%|-%:OK`(context, catch)
+  ;; 6-typing.watsup
+  rule catch{C : context, x : idx, l : labelidx, t* : valtype*}:
+    `%|-%:OK`(C, CATCH_catch(x, l))
+    -- if (x!`%`_idx.0 < |C.TAGS_context|)
+    -- if (l!`%`_labelidx.0 < |C.LABELS_context|)
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_ref{C : context, x : idx, l : labelidx, t* : valtype*}:
+    `%|-%:OK`(C, CATCH_REF_catch(x, l))
+    -- if (x!`%`_idx.0 < |C.TAGS_context|)
+    -- if (l!`%`_labelidx.0 < |C.LABELS_context|)
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), EXN_heaptype)], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_all{C : context, l : labelidx}:
+    `%|-%:OK`(C, CATCH_ALL_catch(l))
+    -- if (l!`%`_labelidx.0 < |C.LABELS_context|)
+    -- Resulttype_sub: `%|-%<:%`(C, [], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
+  ;; 6-typing.watsup
+  rule catch_all_ref{C : context, l : labelidx}:
+    `%|-%:OK`(C, CATCH_ALL_REF_catch(l))
+    -- if (l!`%`_labelidx.0 < |C.LABELS_context|)
+    -- Resulttype_sub: `%|-%<:%`(C, [REF_valtype(`NULL%?`_nul(?()), EXN_heaptype)], C.LABELS_context[l!`%`_labelidx.0]!`%`_resulttype.0)
+
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:522.1-522.95
+;; 6-typing.watsup:543.1-543.95
 relation Instr_ok: `%|-%:%`(context, instr, instrtype)
-  ;; 6-typing.watsup:561.1-562.24
+  ;; 6-typing.watsup:582.1-583.24
   rule nop{C : context}:
     `%|-%:%`(C, NOP_instr, `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
 
-  ;; 6-typing.watsup:564.1-566.42
+  ;; 6-typing.watsup:585.1-587.42
   rule unreachable{C : context, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, UNREACHABLE_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:568.1-570.29
+  ;; 6-typing.watsup:589.1-591.29
   rule drop{C : context, t : valtype}:
     `%|-%:%`(C, DROP_instr, `%->_%%`_instrtype(`%`_resulttype([t]), [], `%`_resulttype([])))
     -- Valtype_ok: `%|-%:OK`(C, t)
 
-  ;; 6-typing.watsup:573.1-575.29
+  ;; 6-typing.watsup:594.1-596.29
   rule select-expl{C : context, t : valtype}:
     `%|-%:%`(C, `SELECT()%?`_instr(?([t])), `%->_%%`_instrtype(`%`_resulttype([t t I32_valtype]), [], `%`_resulttype([t])))
     -- Valtype_ok: `%|-%:OK`(C, t)
 
-  ;; 6-typing.watsup:577.1-581.37
+  ;; 6-typing.watsup:598.1-602.37
   rule select-impl{C : context, t : valtype, t' : valtype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, `SELECT()%?`_instr(?()), `%->_%%`_instrtype(`%`_resulttype([t t I32_valtype]), [], `%`_resulttype([t])))
     -- Valtype_ok: `%|-%:OK`(C, t)
     -- Valtype_sub: `%|-%<:%`(C, t, t')
     -- if ((t' = (numtype : numtype <: valtype)) \/ (t' = (vectype : vectype <: valtype)))
 
-  ;; 6-typing.watsup:597.1-600.67
+  ;; 6-typing.watsup:618.1-621.67
   rule block{C : context, bt : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
     `%|-%:%`(C, BLOCK_instr(bt, instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:602.1-605.67
+  ;; 6-typing.watsup:623.1-626.67
   rule loop{C : context, bt : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
     `%|-%:%`(C, LOOP_instr(bt, instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_1*{t_1 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_1*{t_1 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:607.1-611.71
+  ;; 6-typing.watsup:628.1-632.71
   rule if{C : context, bt : blocktype, instr_1* : instr*, instr_2* : instr*, t_1* : valtype*, t_2* : valtype*, x_1* : idx*, x_2* : idx*}:
     `%|-%:%`(C, `IF%%ELSE%`_instr(bt, instr_1*{instr_1 : instr}, instr_2*{instr_2 : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_1*{instr_1 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
-    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_1*{instr_1 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:616.1-619.42
+  ;; 6-typing.watsup:637.1-640.42
   rule br{C : context, l : labelidx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, BR_instr(l), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (l!`%`_labelidx.0 < |C.LABELS_context|)
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:621.1-623.25
+  ;; 6-typing.watsup:642.1-644.25
   rule br_if{C : context, l : labelidx, t* : valtype*}:
     `%|-%:%`(C, BR_IF_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [I32_valtype]), [], `%`_resulttype(t*{t : valtype})))
     -- if (l!`%`_labelidx.0 < |C.LABELS_context|)
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
 
-  ;; 6-typing.watsup:625.1-629.42
+  ;; 6-typing.watsup:646.1-650.42
   rule br_table{C : context, l* : labelidx*, l' : labelidx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, BR_TABLE_instr(l*{l : labelidx}, l'), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- (if (l!`%`_labelidx.0 < |C.LABELS_context|))*{l : labelidx}
@@ -28280,20 +29545,20 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t*{t : valtype}, C.LABELS_context[l'!`%`_labelidx.0]!`%`_resulttype.0)
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:631.1-634.31
+  ;; 6-typing.watsup:652.1-655.31
   rule br_on_null{C : context, l : labelidx, t* : valtype*, ht : heaptype}:
     `%|-%:%`(C, BR_ON_NULL_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), ht)])))
     -- if (l!`%`_labelidx.0 < |C.LABELS_context|)
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype}))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:636.1-638.34
+  ;; 6-typing.watsup:657.1-659.34
   rule br_on_non_null{C : context, l : labelidx, t* : valtype*, ht : heaptype}:
     `%|-%:%`(C, BR_ON_NON_NULL_instr(l), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype(t*{t : valtype})))
     -- if (l!`%`_labelidx.0 < |C.LABELS_context|)
     -- if (C.LABELS_context[l!`%`_labelidx.0] = `%`_resulttype(t*{t : valtype} :: [REF_valtype(`NULL%?`_nul(?()), ht)]))
 
-  ;; 6-typing.watsup:640.1-646.34
+  ;; 6-typing.watsup:661.1-667.34
   rule br_on_cast{C : context, l : labelidx, rt_1 : reftype, rt_2 : reftype, t* : valtype*, rt : reftype}:
     `%|-%:%`(C, BR_ON_CAST_instr(l, rt_1, rt_2), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [(rt_1 : reftype <: valtype)]), [], `%`_resulttype(t*{t : valtype} :: [($diffrt(rt_1, rt_2) : reftype <: valtype)])))
     -- if (l!`%`_labelidx.0 < |C.LABELS_context|)
@@ -28303,7 +29568,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt)
 
-  ;; 6-typing.watsup:648.1-654.49
+  ;; 6-typing.watsup:669.1-675.49
   rule br_on_cast_fail{C : context, l : labelidx, rt_1 : reftype, rt_2 : reftype, t* : valtype*, rt : reftype}:
     `%|-%:%`(C, BR_ON_CAST_FAIL_instr(l, rt_1, rt_2), `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: [(rt_1 : reftype <: valtype)]), [], `%`_resulttype(t*{t : valtype} :: [(rt_2 : reftype <: valtype)])))
     -- if (l!`%`_labelidx.0 < |C.LABELS_context|)
@@ -28313,19 +29578,19 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
     -- Reftype_sub: `%|-%<:%`(C, $diffrt(rt_1, rt_2), rt)
 
-  ;; 6-typing.watsup:659.1-661.47
+  ;; 6-typing.watsup:680.1-682.47
   rule call{C : context, x : idx, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, CALL_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (x!`%`_idx.0 < |C.FUNCS_context|)
     -- Expand: `%~~%`(C.FUNCS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:663.1-665.47
+  ;; 6-typing.watsup:684.1-686.47
   rule call_ref{C : context, x : idx, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, CALL_REF_instr(($idx(x) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:667.1-671.47
+  ;; 6-typing.watsup:688.1-692.47
   rule call_indirect{C : context, x : idx, y : idx, t_1* : valtype*, t_2* : valtype*, lim : limits, rt : reftype}:
     `%|-%:%`(C, CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (x!`%`_idx.0 < |C.TABLES_context|)
@@ -28334,13 +29599,13 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Reftype_sub: `%|-%<:%`(C, rt, REF_reftype(`NULL%?`_nul(?(())), FUNC_heaptype))
     -- Expand: `%~~%`(C.TYPES_context[y!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
 
-  ;; 6-typing.watsup:673.1-676.42
+  ;; 6-typing.watsup:694.1-697.42
   rule return{C : context, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, RETURN_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
     -- if (C.RETURN_context = ?(`%`_list(t*{t : valtype})))
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
 
-  ;; 6-typing.watsup:679.1-684.42
+  ;; 6-typing.watsup:700.1-705.42
   rule return_call{C : context, x : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- if (x!`%`_idx.0 < |C.FUNCS_context|)
@@ -28349,7 +29614,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:687.1-692.42
+  ;; 6-typing.watsup:708.1-713.42
   rule return_call_ref{C : context, x : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_REF_instr(($idx(x) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
@@ -28358,7 +29623,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:695.1-703.42
+  ;; 6-typing.watsup:716.1-724.42
   rule return_call_indirect{C : context, x : idx, y : idx, t_3* : valtype*, t_1* : valtype*, t_4* : valtype*, lim : limits, rt : reftype, t_2* : valtype*, t'_2* : valtype*}:
     `%|-%:%`(C, RETURN_CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse)), `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype} :: t_1*{t_1 : valtype} :: [I32_valtype]), [], `%`_resulttype(t_4*{t_4 : valtype})))
     -- if (x!`%`_idx.0 < |C.TABLES_context|)
@@ -28370,36 +29635,55 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Resulttype_sub: `%|-%<:%`(C, t_2*{t_2 : valtype}, t'_2*{t'_2 : valtype})
     -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_3*{t_3 : valtype}), [], `%`_resulttype(t_4*{t_4 : valtype})))
 
-  ;; 6-typing.watsup:708.1-709.33
+  ;; 6-typing.watsup:731.1-734.42
+  rule throw{C : context, x : idx, t_1* : valtype*, t* : valtype*, t_2* : valtype*}:
+    `%|-%:%`(C, THROW_instr(x), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: t*{t : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- if (x!`%`_idx.0 < |C.TAGS_context|)
+    -- Expand: `%~~%`(C.TAGS_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t*{t : valtype}), `%`_resulttype([]))))
+    -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+
+  ;; 6-typing.watsup:736.1-738.42
+  rule throw_ref{C : context, t_1* : valtype*, t_2* : valtype*}:
+    `%|-%:%`(C, THROW_REF_instr, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype} :: [REF_valtype(`NULL%?`_nul(?(())), EXN_heaptype)]), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrtype_ok: `%|-%:OK`(C, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+
+  ;; 6-typing.watsup:740.1-744.34
+  rule try_table{C : context, bt : blocktype, catch* : catch*, instr* : instr*, t_1* : valtype*, t_2* : valtype*, x* : idx*}:
+    `%|-%:%`(C, TRY_TABLE_instr(bt, `%`_list(catch*{catch : catch}), instr*{instr : instr}), `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Blocktype_ok: `%|-%:%`(C, bt, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
+    -- Instrs_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
+    -- (Catch_ok: `%|-%:OK`(C, catch))*{catch : catch}
+
+  ;; 6-typing.watsup:767.1-768.33
   rule const{C : context, nt : numtype, c_nt : num_(nt)}:
     `%|-%:%`(C, CONST_instr(nt, c_nt), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:711.1-712.34
+  ;; 6-typing.watsup:770.1-771.34
   rule unop{C : context, nt : numtype, unop_nt : unop_(nt)}:
     `%|-%:%`(C, UNOP_instr(nt, unop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype)]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:714.1-715.39
+  ;; 6-typing.watsup:773.1-774.39
   rule binop{C : context, nt : numtype, binop_nt : binop_(nt)}:
     `%|-%:%`(C, BINOP_instr(nt, binop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype) (nt : numtype <: valtype)]), [], `%`_resulttype([(nt : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:717.1-718.39
+  ;; 6-typing.watsup:776.1-777.39
   rule testop{C : context, nt : numtype, testop_nt : testop_(nt)}:
     `%|-%:%`(C, TESTOP_instr(nt, testop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:720.1-721.40
+  ;; 6-typing.watsup:779.1-780.40
   rule relop{C : context, nt : numtype, relop_nt : relop_(nt)}:
     `%|-%:%`(C, RELOP_instr(nt, relop_nt), `%->_%%`_instrtype(`%`_resulttype([(nt : numtype <: valtype) (nt : numtype <: valtype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:723.1-724.44
+  ;; 6-typing.watsup:782.1-783.44
   rule cvtop{C : context, nt_1 : numtype, nt_2 : numtype, cvtop : cvtop__(nt_2, nt_1)}:
     `%|-%:%`(C, CVTOP_instr(nt_1, nt_2, cvtop), `%->_%%`_instrtype(`%`_resulttype([(nt_2 : numtype <: valtype)]), [], `%`_resulttype([(nt_1 : numtype <: valtype)])))
 
-  ;; 6-typing.watsup:729.1-731.31
+  ;; 6-typing.watsup:788.1-790.31
   rule ref.null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.NULL_instr(ht), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:733.1-736.20
+  ;; 6-typing.watsup:792.1-795.20
   rule ref.func{C : context, x : idx, dt : deftype}:
     `%|-%:%`(C, REF.FUNC_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), (dt : deftype <: heaptype))])))
     -- if (x!`%`_idx.0 < |C.FUNCS_context|)
@@ -28407,50 +29691,50 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- if (C.FUNCS_context[x!`%`_idx.0] = dt)
     -- if x <- C.REFS_context
 
-  ;; 6-typing.watsup:738.1-739.34
+  ;; 6-typing.watsup:797.1-798.34
   rule ref.i31{C : context}:
     `%|-%:%`(C, REF.I31_instr, `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), I31_heaptype)])))
 
-  ;; 6-typing.watsup:741.1-743.31
+  ;; 6-typing.watsup:800.1-802.31
   rule ref.is_null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.IS_NULL_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype([I32_valtype])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:745.1-747.31
+  ;; 6-typing.watsup:804.1-806.31
   rule ref.as_non_null{C : context, ht : heaptype}:
     `%|-%:%`(C, REF.AS_NON_NULL_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ht)]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ht)])))
     -- Heaptype_ok: `%|-%:OK`(C, ht)
 
-  ;; 6-typing.watsup:749.1-750.51
+  ;; 6-typing.watsup:808.1-809.51
   rule ref.eq{C : context}:
     `%|-%:%`(C, REF.EQ_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), EQ_heaptype) REF_valtype(`NULL%?`_nul(?(())), EQ_heaptype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:752.1-756.33
+  ;; 6-typing.watsup:811.1-815.33
   rule ref.test{C : context, rt : reftype, rt' : reftype}:
     `%|-%:%`(C, REF.TEST_instr(rt), `%->_%%`_instrtype(`%`_resulttype([(rt' : reftype <: valtype)]), [], `%`_resulttype([I32_valtype])))
     -- Reftype_ok: `%|-%:OK`(C, rt)
     -- Reftype_ok: `%|-%:OK`(C, rt')
     -- Reftype_sub: `%|-%<:%`(C, rt, rt')
 
-  ;; 6-typing.watsup:758.1-762.33
+  ;; 6-typing.watsup:817.1-821.33
   rule ref.cast{C : context, rt : reftype, rt' : reftype}:
     `%|-%:%`(C, REF.CAST_instr(rt), `%->_%%`_instrtype(`%`_resulttype([(rt' : reftype <: valtype)]), [], `%`_resulttype([(rt : reftype <: valtype)])))
     -- Reftype_ok: `%|-%:OK`(C, rt)
     -- Reftype_ok: `%|-%:OK`(C, rt')
     -- Reftype_sub: `%|-%<:%`(C, rt, rt')
 
-  ;; 6-typing.watsup:767.1-768.42
+  ;; 6-typing.watsup:826.1-827.42
   rule i31.get{C : context, sx : sx}:
     `%|-%:%`(C, I31.GET_instr(sx), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), I31_heaptype)]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:773.1-775.44
+  ;; 6-typing.watsup:832.1-834.44
   rule struct.new{C : context, x : idx, zt* : storagetype*, mut* : mut*}:
     `%|-%:%`(C, STRUCT.NEW_instr(x), `%->_%%`_instrtype(`%`_resulttype($unpack(zt)*{zt : storagetype}), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
     -- if (|mut*{mut : mut}| = |zt*{zt : storagetype}|)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
 
-  ;; 6-typing.watsup:777.1-780.40
+  ;; 6-typing.watsup:836.1-839.40
   rule struct.new_default{C : context, x : idx, mut* : mut*, zt* : storagetype*, val* : val*}:
     `%|-%:%`(C, STRUCT.NEW_DEFAULT_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
@@ -28459,7 +29743,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
     -- (if ($default_($unpack(zt)) = ?(val)))*{val : val, zt : storagetype}
 
-  ;; 6-typing.watsup:782.1-786.39
+  ;; 6-typing.watsup:841.1-845.39
   rule struct.get{C : context, sx? : sx?, x : idx, i : nat, zt : storagetype, yt* : fieldtype*, mut : mut}:
     `%|-%:%`(C, STRUCT.GET_instr(sx?{sx : sx}, x, `%`_u32(i)), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype))]), [], `%`_resulttype([$unpack(zt)])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
@@ -28468,7 +29752,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- if (yt*{yt : fieldtype}[i] = `%%`_fieldtype(mut, zt))
     -- if ((sx?{sx : sx} = ?()) <=> (zt = ($unpack(zt) : valtype <: storagetype)))
 
-  ;; 6-typing.watsup:788.1-791.24
+  ;; 6-typing.watsup:847.1-850.24
   rule struct.set{C : context, x : idx, i : nat, zt : storagetype, yt* : fieldtype*}:
     `%|-%:%`(C, STRUCT.SET_instr(x, `%`_u32(i)), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) $unpack(zt)]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
@@ -28476,26 +29760,26 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], STRUCT_comptype(`%`_structtype(yt*{yt : fieldtype})))
     -- if (yt*{yt : fieldtype}[i] = `%%`_fieldtype(`MUT%?`_mut(?(())), zt))
 
-  ;; 6-typing.watsup:796.1-798.42
+  ;; 6-typing.watsup:855.1-857.42
   rule array.new{C : context, x : idx, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.NEW_instr(x), `%->_%%`_instrtype(`%`_resulttype([$unpack(zt) I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 6-typing.watsup:800.1-803.37
+  ;; 6-typing.watsup:859.1-862.37
   rule array.new_default{C : context, x : idx, mut : mut, zt : storagetype, val : val}:
     `%|-%:%`(C, ARRAY.NEW_DEFAULT_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ($default_($unpack(zt)) = ?(val))
 
-  ;; 6-typing.watsup:805.1-807.42
+  ;; 6-typing.watsup:864.1-866.42
   rule array.new_fixed{C : context, x : idx, n : n, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.NEW_FIXED_instr(x, `%`_u32(n)), `%->_%%`_instrtype(`%`_resulttype($unpack(zt)^n{}), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 6-typing.watsup:809.1-812.40
+  ;; 6-typing.watsup:868.1-871.40
   rule array.new_elem{C : context, x : idx, y : idx, mut : mut, rt : reftype}:
     `%|-%:%`(C, ARRAY.NEW_ELEM_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
@@ -28503,7 +29787,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, (rt : reftype <: storagetype))))
     -- Reftype_sub: `%|-%<:%`(C, C.ELEMS_context[y!`%`_idx.0], rt)
 
-  ;; 6-typing.watsup:814.1-818.24
+  ;; 6-typing.watsup:873.1-877.24
   rule array.new_data{C : context, x : idx, y : idx, mut : mut, zt : storagetype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, ARRAY.NEW_DATA_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype]), [], `%`_resulttype([REF_valtype(`NULL%?`_nul(?()), ($idx(x) : typevar <: heaptype))])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
@@ -28512,32 +29796,32 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- if (($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:820.1-823.39
+  ;; 6-typing.watsup:879.1-882.39
   rule array.get{C : context, sx? : sx?, x : idx, zt : storagetype, mut : mut}:
     `%|-%:%`(C, ARRAY.GET_instr(sx?{sx : sx}, x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype]), [], `%`_resulttype([$unpack(zt)])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ((sx?{sx : sx} = ?()) <=> (zt = ($unpack(zt) : valtype <: storagetype)))
 
-  ;; 6-typing.watsup:825.1-827.42
+  ;; 6-typing.watsup:884.1-886.42
   rule array.set{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype $unpack(zt)]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:829.1-831.42
+  ;; 6-typing.watsup:888.1-890.42
   rule array.len{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.LEN_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ARRAY_heaptype)]), [], `%`_resulttype([I32_valtype])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:833.1-835.42
+  ;; 6-typing.watsup:892.1-894.42
   rule array.fill{C : context, x : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype $unpack(zt) I32_valtype]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
 
-  ;; 6-typing.watsup:837.1-841.40
+  ;; 6-typing.watsup:896.1-900.40
   rule array.copy{C : context, x_1 : idx, x_2 : idx, zt_1 : storagetype, mut : mut, zt_2 : storagetype}:
     `%|-%:%`(C, ARRAY.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x_1) : typevar <: heaptype)) I32_valtype REF_valtype(`NULL%?`_nul(?(())), ($idx(x_2) : typevar <: heaptype)) I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (x_1!`%`_idx.0 < |C.TYPES_context|)
@@ -28546,7 +29830,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Expand: `%~~%`(C.TYPES_context[x_2!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(mut, zt_2)))
     -- Storagetype_sub: `%|-%<:%`(C, zt_2, zt_1)
 
-  ;; 6-typing.watsup:843.1-846.44
+  ;; 6-typing.watsup:902.1-905.44
   rule array.init_elem{C : context, x : idx, y : idx, zt : storagetype}:
     `%|-%:%`(C, ARRAY.INIT_ELEM_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
@@ -28554,7 +29838,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], ARRAY_comptype(`%%`_arraytype(`MUT%?`_mut(?(())), zt)))
     -- Storagetype_sub: `%|-%<:%`(C, (C.ELEMS_context[y!`%`_idx.0] : reftype <: storagetype), zt)
 
-  ;; 6-typing.watsup:848.1-852.24
+  ;; 6-typing.watsup:907.1-911.24
   rule array.init_data{C : context, x : idx, y : idx, zt : storagetype, numtype : numtype, vectype : vectype}:
     `%|-%:%`(C, ARRAY.INIT_DATA_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([REF_valtype(`NULL%?`_nul(?(())), ($idx(x) : typevar <: heaptype)) I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.TYPES_context|)
@@ -28563,158 +29847,158 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- if (($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:857.1-858.62
+  ;; 6-typing.watsup:916.1-917.62
   rule extern.convert_any{C : context, nul : nul}:
     `%|-%:%`(C, EXTERN.CONVERT_ANY_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(nul, ANY_heaptype)]), [], `%`_resulttype([REF_valtype(nul, EXTERN_heaptype)])))
 
-  ;; 6-typing.watsup:860.1-861.62
+  ;; 6-typing.watsup:919.1-920.62
   rule any.convert_extern{C : context, nul : nul}:
     `%|-%:%`(C, ANY.CONVERT_EXTERN_instr, `%->_%%`_instrtype(`%`_resulttype([REF_valtype(nul, EXTERN_heaptype)]), [], `%`_resulttype([REF_valtype(nul, ANY_heaptype)])))
 
-  ;; 6-typing.watsup:866.1-867.35
+  ;; 6-typing.watsup:925.1-926.35
   rule vconst{C : context, c : vec_(V128_Vnn)}:
     `%|-%:%`(C, VCONST_instr(V128_vectype, c), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:869.1-870.41
+  ;; 6-typing.watsup:928.1-929.41
   rule vvunop{C : context, vvunop : vvunop}:
     `%|-%:%`(C, VVUNOP_instr(V128_vectype, vvunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:872.1-873.48
+  ;; 6-typing.watsup:931.1-932.48
   rule vvbinop{C : context, vvbinop : vvbinop}:
     `%|-%:%`(C, VVBINOP_instr(V128_vectype, vvbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:875.1-876.55
+  ;; 6-typing.watsup:934.1-935.55
   rule vvternop{C : context, vvternop : vvternop}:
     `%|-%:%`(C, VVTERNOP_instr(V128_vectype, vvternop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:878.1-879.44
+  ;; 6-typing.watsup:937.1-938.44
   rule vvtestop{C : context, vvtestop : vvtestop}:
     `%|-%:%`(C, VVTESTOP_instr(V128_vectype, vvtestop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:881.1-882.37
+  ;; 6-typing.watsup:940.1-941.37
   rule vunop{C : context, sh : shape, vunop : vunop_(sh)}:
     `%|-%:%`(C, VUNOP_instr(sh, vunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:884.1-885.44
+  ;; 6-typing.watsup:943.1-944.44
   rule vbinop{C : context, sh : shape, vbinop : vbinop_(sh)}:
     `%|-%:%`(C, VBINOP_instr(sh, vbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:887.1-888.40
+  ;; 6-typing.watsup:946.1-947.40
   rule vtestop{C : context, sh : shape, vtestop : vtestop_(sh)}:
     `%|-%:%`(C, VTESTOP_instr(sh, vtestop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:890.1-891.44
+  ;; 6-typing.watsup:949.1-950.44
   rule vrelop{C : context, sh : shape, vrelop : vrelop_(sh)}:
     `%|-%:%`(C, VRELOP_instr(sh, vrelop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:893.1-894.47
+  ;; 6-typing.watsup:952.1-953.47
   rule vshiftop{C : context, sh : ishape, vshiftop : vshiftop_(sh)}:
     `%|-%:%`(C, VSHIFTOP_instr(sh, vshiftop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype I32_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:896.1-897.33
+  ;; 6-typing.watsup:955.1-956.33
   rule vbitmask{C : context, sh : ishape}:
     `%|-%:%`(C, VBITMASK_instr(sh), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([I32_valtype])))
 
-  ;; 6-typing.watsup:899.1-900.39
+  ;; 6-typing.watsup:958.1-959.39
   rule vswizzle{C : context, sh : ishape}:
     `%|-%:%`(C, VSWIZZLE_instr(sh), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:902.1-904.29
+  ;; 6-typing.watsup:961.1-963.29
   rule vshuffle{C : context, sh : ishape, i* : nat*}:
     `%|-%:%`(C, VSHUFFLE_instr(sh, `%`_laneidx(i)*{i : nat}), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
     -- (if (i < (2 * $dim((sh : ishape <: shape))!`%`_dim.0)))*{i : nat}
 
-  ;; 6-typing.watsup:906.1-907.44
+  ;; 6-typing.watsup:965.1-966.44
   rule vsplat{C : context, sh : shape}:
     `%|-%:%`(C, VSPLAT_instr(sh), `%->_%%`_instrtype(`%`_resulttype([($unpackshape(sh) : numtype <: valtype)]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:909.1-911.21
+  ;; 6-typing.watsup:968.1-970.21
   rule vextract_lane{C : context, sh : shape, sx? : sx?, i : nat}:
     `%|-%:%`(C, VEXTRACT_LANE_instr(sh, sx?{sx : sx}, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([($unpackshape(sh) : numtype <: valtype)])))
     -- if (i < $dim(sh)!`%`_dim.0)
 
-  ;; 6-typing.watsup:913.1-915.21
+  ;; 6-typing.watsup:972.1-974.21
   rule vreplace_lane{C : context, sh : shape, i : nat}:
     `%|-%:%`(C, VREPLACE_LANE_instr(sh, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([V128_valtype ($unpackshape(sh) : numtype <: valtype)]), [], `%`_resulttype([V128_valtype])))
     -- if (i < $dim(sh)!`%`_dim.0)
 
-  ;; 6-typing.watsup:917.1-918.50
+  ;; 6-typing.watsup:976.1-977.50
   rule vextunop{C : context, sh_1 : ishape, sh_2 : ishape, vextunop : vextunop__(sh_2, sh_1)}:
     `%|-%:%`(C, VEXTUNOP_instr(sh_1, sh_2, vextunop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:920.1-921.57
+  ;; 6-typing.watsup:979.1-980.57
   rule vextbinop{C : context, sh_1 : ishape, sh_2 : ishape, vextbinop : vextbinop__(sh_2, sh_1)}:
     `%|-%:%`(C, VEXTBINOP_instr(sh_1, sh_2, vextbinop), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:923.1-924.48
+  ;; 6-typing.watsup:982.1-983.48
   rule vnarrow{C : context, sh_1 : ishape, sh_2 : ishape, sx : sx}:
     `%|-%:%`(C, VNARROW_instr(sh_1, sh_2, sx), `%->_%%`_instrtype(`%`_resulttype([V128_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:926.1-927.58
+  ;; 6-typing.watsup:985.1-986.58
   rule vcvtop{C : context, sh_1 : shape, sh_2 : shape, vcvtop : vcvtop__(sh_2, sh_1), half? : half__(sh_2, sh_1)?, zero? : zero__(sh_2, sh_1)?}:
     `%|-%:%`(C, VCVTOP_instr(sh_1, sh_2, vcvtop, half?{half : half__(sh_2, sh_1)}, zero?{zero : zero__(sh_2, sh_1)}), `%->_%%`_instrtype(`%`_resulttype([V128_valtype]), [], `%`_resulttype([V128_valtype])))
 
-  ;; 6-typing.watsup:932.1-934.28
+  ;; 6-typing.watsup:991.1-993.28
   rule local.get{C : context, x : idx, t : valtype}:
     `%|-%:%`(C, LOCAL.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([t])))
     -- if (x!`%`_idx.0 < |C.LOCALS_context|)
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(SET_init, t))
 
-  ;; 6-typing.watsup:936.1-938.29
+  ;; 6-typing.watsup:995.1-997.29
   rule local.set{C : context, x : idx, t : valtype, init : init}:
     `%|-%:%`(C, LOCAL.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [x], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.LOCALS_context|)
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(init, t))
 
-  ;; 6-typing.watsup:940.1-942.29
+  ;; 6-typing.watsup:999.1-1001.29
   rule local.tee{C : context, x : idx, t : valtype, init : init}:
     `%|-%:%`(C, LOCAL.TEE_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [x], `%`_resulttype([t])))
     -- if (x!`%`_idx.0 < |C.LOCALS_context|)
     -- if (C.LOCALS_context[x!`%`_idx.0] = `%%`_localtype(init, t))
 
-  ;; 6-typing.watsup:947.1-949.29
+  ;; 6-typing.watsup:1006.1-1008.29
   rule global.get{C : context, x : idx, t : valtype, mut : mut}:
     `%|-%:%`(C, GLOBAL.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([t])))
     -- if (x!`%`_idx.0 < |C.GLOBALS_context|)
     -- if (C.GLOBALS_context[x!`%`_idx.0] = `%%`_globaltype(mut, t))
 
-  ;; 6-typing.watsup:951.1-953.29
+  ;; 6-typing.watsup:1010.1-1012.29
   rule global.set{C : context, x : idx, t : valtype}:
     `%|-%:%`(C, GLOBAL.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([t]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.GLOBALS_context|)
     -- if (C.GLOBALS_context[x!`%`_idx.0] = `%%`_globaltype(`MUT%?`_mut(?(())), t))
 
-  ;; 6-typing.watsup:958.1-960.29
+  ;; 6-typing.watsup:1017.1-1019.29
   rule table.get{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.GET_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(rt : reftype <: valtype)])))
     -- if (x!`%`_idx.0 < |C.TABLES_context|)
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:962.1-964.29
+  ;; 6-typing.watsup:1021.1-1023.29
   rule table.set{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.SET_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (rt : reftype <: valtype)]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.TABLES_context|)
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:966.1-968.29
+  ;; 6-typing.watsup:1025.1-1027.29
   rule table.size{C : context, x : idx, lim : limits, rt : reftype}:
     `%|-%:%`(C, TABLE.SIZE_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([I32_valtype])))
     -- if (x!`%`_idx.0 < |C.TABLES_context|)
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:970.1-972.29
+  ;; 6-typing.watsup:1029.1-1031.29
   rule table.grow{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.GROW_instr(x), `%->_%%`_instrtype(`%`_resulttype([(rt : reftype <: valtype) I32_valtype]), [], `%`_resulttype([I32_valtype])))
     -- if (x!`%`_idx.0 < |C.TABLES_context|)
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:974.1-976.29
+  ;; 6-typing.watsup:1033.1-1035.29
   rule table.fill{C : context, x : idx, rt : reftype, lim : limits}:
     `%|-%:%`(C, TABLE.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (rt : reftype <: valtype) I32_valtype]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.TABLES_context|)
     -- if (C.TABLES_context[x!`%`_idx.0] = `%%`_tabletype(lim, rt))
 
-  ;; 6-typing.watsup:978.1-982.36
+  ;; 6-typing.watsup:1037.1-1041.36
   rule table.copy{C : context, x_1 : idx, x_2 : idx, lim_1 : limits, rt_1 : reftype, lim_2 : limits, rt_2 : reftype}:
     `%|-%:%`(C, TABLE.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (x_1!`%`_idx.0 < |C.TABLES_context|)
@@ -28723,7 +30007,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- if (C.TABLES_context[x_2!`%`_idx.0] = `%%`_tabletype(lim_2, rt_2))
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
 
-  ;; 6-typing.watsup:984.1-988.36
+  ;; 6-typing.watsup:1043.1-1047.36
   rule table.init{C : context, x : idx, y : idx, lim : limits, rt_1 : reftype, rt_2 : reftype}:
     `%|-%:%`(C, TABLE.INIT_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.TABLES_context|)
@@ -28732,31 +30016,31 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- if (C.ELEMS_context[y!`%`_idx.0] = rt_2)
     -- Reftype_sub: `%|-%<:%`(C, rt_2, rt_1)
 
-  ;; 6-typing.watsup:990.1-992.24
+  ;; 6-typing.watsup:1049.1-1051.24
   rule elem.drop{C : context, x : idx, rt : reftype}:
     `%|-%:%`(C, ELEM.DROP_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.ELEMS_context|)
     -- if (C.ELEMS_context[x!`%`_idx.0] = rt)
 
-  ;; 6-typing.watsup:997.1-999.23
+  ;; 6-typing.watsup:1056.1-1058.23
   rule memory.size{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.SIZE_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([I32_valtype])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1001.1-1003.23
+  ;; 6-typing.watsup:1060.1-1062.23
   rule memory.grow{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.GROW_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([I32_valtype])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1005.1-1007.23
+  ;; 6-typing.watsup:1064.1-1066.23
   rule memory.fill{C : context, x : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.FILL_instr(x), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
-  ;; 6-typing.watsup:1009.1-1012.27
+  ;; 6-typing.watsup:1068.1-1071.27
   rule memory.copy{C : context, x_1 : idx, x_2 : idx, mt_1 : memtype, mt_2 : memtype}:
     `%|-%:%`(C, MEMORY.COPY_instr(x_1, x_2), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (x_1!`%`_idx.0 < |C.MEMS_context|)
@@ -28764,7 +30048,7 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- if (C.MEMS_context[x_1!`%`_idx.0] = mt_1)
     -- if (C.MEMS_context[x_2!`%`_idx.0] = mt_2)
 
-  ;; 6-typing.watsup:1014.1-1017.24
+  ;; 6-typing.watsup:1073.1-1076.24
   rule memory.init{C : context, x : idx, y : idx, mt : memtype}:
     `%|-%:%`(C, MEMORY.INIT_instr(x, y), `%->_%%`_instrtype(`%`_resulttype([I32_valtype I32_valtype I32_valtype]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
@@ -28772,69 +30056,69 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if (C.DATAS_context[y!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:1019.1-1021.24
+  ;; 6-typing.watsup:1078.1-1080.24
   rule data.drop{C : context, x : idx}:
     `%|-%:%`(C, DATA.DROP_instr(x), `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.DATAS_context|)
     -- if (C.DATAS_context[x!`%`_idx.0] = OK_datatype)
 
-  ;; 6-typing.watsup:1032.1-1035.43
+  ;; 6-typing.watsup:1091.1-1094.43
   rule load-val{C : context, nt : numtype, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, LOAD_instr(nt, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(nt : numtype <: valtype)])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($size(nt) / 8))
 
-  ;; 6-typing.watsup:1037.1-1040.35
+  ;; 6-typing.watsup:1096.1-1099.35
   rule load-pack{C : context, Inn : Inn, M : M, sx : sx, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, LOAD_instr((Inn : Inn <: numtype), ?(`%%`_loadop_(`%`_sz(M), sx)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([(Inn : Inn <: valtype)])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (M / 8))
 
-  ;; 6-typing.watsup:1051.1-1054.43
+  ;; 6-typing.watsup:1110.1-1113.43
   rule store-val{C : context, nt : numtype, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, STORE_instr(nt, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (nt : numtype <: valtype)]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($size(nt) / 8))
 
-  ;; 6-typing.watsup:1056.1-1059.35
+  ;; 6-typing.watsup:1115.1-1118.35
   rule store-pack{C : context, Inn : Inn, M : M, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, STORE_instr((Inn : Inn <: numtype), ?(`%`_sz(M)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype (Inn : Inn <: valtype)]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (M / 8))
 
-  ;; 6-typing.watsup:1061.1-1064.46
+  ;; 6-typing.watsup:1120.1-1123.46
   rule vload-val{C : context, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($vsize(V128_vectype) / 8))
 
-  ;; 6-typing.watsup:1066.1-1069.39
+  ;; 6-typing.watsup:1125.1-1128.39
   rule vload-pack{C : context, M : M, N : N, sx : sx, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(M), N, sx)), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ((M / 8) * N))
 
-  ;; 6-typing.watsup:1071.1-1074.35
+  ;; 6-typing.watsup:1130.1-1133.35
   rule vload-splat{C : context, N : N, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(N))), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
 
-  ;; 6-typing.watsup:1076.1-1079.35
+  ;; 6-typing.watsup:1135.1-1138.35
   rule vload-zero{C : context, N : N, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(N))), x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
 
-  ;; 6-typing.watsup:1081.1-1085.21
+  ;; 6-typing.watsup:1140.1-1144.21
   rule vload_lane{C : context, N : N, x : idx, memarg : memarg, i : nat, mt : memtype}:
     `%|-%:%`(C, VLOAD_LANE_instr(V128_vectype, `%`_sz(N), x, memarg, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([V128_valtype])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
@@ -28842,14 +30126,14 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
     -- if (i < (128 / N))
 
-  ;; 6-typing.watsup:1087.1-1090.46
+  ;; 6-typing.watsup:1146.1-1149.46
   rule vstore{C : context, x : idx, memarg : memarg, mt : memtype}:
     `%|-%:%`(C, VSTORE_instr(V128_vectype, x, memarg), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= ($vsize(V128_vectype) / 8))
 
-  ;; 6-typing.watsup:1092.1-1096.21
+  ;; 6-typing.watsup:1151.1-1155.21
   rule vstore_lane{C : context, N : N, x : idx, memarg : memarg, i : nat, mt : memtype}:
     `%|-%:%`(C, VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, memarg, `%`_laneidx(i)), `%->_%%`_instrtype(`%`_resulttype([I32_valtype V128_valtype]), [], `%`_resulttype([])))
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
@@ -28857,13 +30141,13 @@ relation Instr_ok: `%|-%:%`(context, instr, instrtype)
     -- if ((2 ^ memarg.ALIGN_memarg!`%`_u32.0) <= (N / 8))
     -- if (i < (128 / N))
 
-;; 6-typing.watsup:523.1-523.96
+;; 6-typing.watsup:544.1-544.96
 relation Instrs_ok: `%|-%:%`(context, instr*, instrtype)
-  ;; 6-typing.watsup:536.1-537.24
+  ;; 6-typing.watsup:557.1-558.24
   rule empty{C : context}:
     `%|-%:%`(C, [], `%->_%%`_instrtype(`%`_resulttype([]), [], `%`_resulttype([])))
 
-  ;; 6-typing.watsup:540.1-544.82
+  ;; 6-typing.watsup:561.1-565.82
   rule seq{C : context, instr_1 : instr, instr_2* : instr*, t_1* : valtype*, x_1* : idx*, x_2* : idx*, t_3* : valtype*, t_2* : valtype*, init* : init*, t* : valtype*}:
     `%|-%:%`(C, [instr_1] :: instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x_1*{x_1 : localidx} :: x_2*{x_2 : localidx}, `%`_resulttype(t_3*{t_3 : valtype})))
     -- if (|init*{init : init}| = |t*{t : valtype}|)
@@ -28873,14 +30157,14 @@ relation Instrs_ok: `%|-%:%`(context, instr*, instrtype)
     -- (if (C.LOCALS_context[x_1!`%`_idx.0] = `%%`_localtype(init, t)))*{init : init, t : valtype, x_1 : idx}
     -- Instrs_ok: `%|-%:%`($with_locals(C, x_1*{x_1 : localidx}, `%%`_localtype(SET_init, t)*{t : valtype}), instr_2*{instr_2 : instr}, `%->_%%`_instrtype(`%`_resulttype(t_2*{t_2 : valtype}), x_2*{x_2 : localidx}, `%`_resulttype(t_3*{t_3 : valtype})))
 
-  ;; 6-typing.watsup:546.1-550.33
+  ;; 6-typing.watsup:567.1-571.33
   rule sub{C : context, instr* : instr*, it' : instrtype, it : instrtype}:
     `%|-%:%`(C, instr*{instr : instr}, it')
     -- Instrs_ok: `%|-%:%`(C, instr*{instr : instr}, it)
     -- Instrtype_sub: `%|-%<:%`(C, it, it')
     -- Instrtype_ok: `%|-%:OK`(C, it')
 
-  ;; 6-typing.watsup:553.1-556.33
+  ;; 6-typing.watsup:574.1-577.33
   rule frame{C : context, instr* : instr*, t* : valtype*, t_1* : valtype*, x* : idx*, t_2* : valtype*}:
     `%|-%:%`(C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t*{t : valtype} :: t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t*{t : valtype} :: t_2*{t_2 : valtype})))
     -- Instrs_ok: `%|-%:%`(C, instr*{instr : instr}, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), x*{x : localidx}, `%`_resulttype(t_2*{t_2 : valtype})))
@@ -28980,7 +30264,7 @@ relation Type_ok: `%|-%:%`(context, type, deftype*)
     `%|-%:%`(C, TYPE_type(rectype), dt*{dt : deftype})
     -- if (x = `%`_idx(|C.TYPES_context|))
     -- if (dt*{dt : deftype} = $rolldt(x, rectype))
-    -- Rectype_ok: `%|-%:%`(C ++ {TYPES dt*{dt : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rectype, OK_oktypeidx(x))
+    -- Rectype_ok: `%|-%:%`(C ++ {TYPES dt*{dt : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rectype, OK_oktypeidx(x))
 
 ;; 6-typing.watsup
 relation Local_ok: `%|-%:%`(context, local, localtype)
@@ -29003,7 +30287,7 @@ relation Func_ok: `%|-%:%`(context, func, deftype)
     -- if (|lct*{lct : localtype}| = |local*{local : local}|)
     -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
     -- (Local_ok: `%|-%:%`(C, local, lct))*{lct : localtype, local : local}
-    -- Expr_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS `%%`_localtype(SET_init, t_1)*{t_1 : valtype} :: lct*{lct : localtype}, LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(`%`_resulttype(t_2*{t_2 : valtype})), REFS []}, expr, `%`_resulttype(t_2*{t_2 : valtype}))
+    -- Expr_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS `%%`_localtype(SET_init, t_1)*{t_1 : valtype} :: lct*{lct : localtype}, LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(`%`_resulttype(t_2*{t_2 : valtype})), REFS []}, expr, `%`_resulttype(t_2*{t_2 : valtype}))
 
 ;; 6-typing.watsup
 relation Global_ok: `%|-%:%`(context, global, globaltype)
@@ -29030,6 +30314,14 @@ relation Mem_ok: `%|-%:%`(context, mem, memtype)
     `%|-%:%`(C, MEMORY_mem(memtype), memtype)
     -- Memtype_ok: `%|-%:OK`(C, memtype)
 
+;; 6-typing.watsup
+relation Tag_ok: `%|-%:%`(context, tag, tagtype)
+  ;; 6-typing.watsup
+  rule _{C : context, x : idx, functype : functype}:
+    `%|-%:%`(C, TAG_tag(x), C.TYPES_context[x!`%`_idx.0])
+    -- if (x!`%`_idx.0 < |C.TYPES_context|)
+    -- Expand: `%~~%`(C.TYPES_context[x!`%`_idx.0], FUNC_comptype(functype))
+
 ;; 6-typing.watsup
 relation Elemmode_ok: `%|-%:%`(context, elemmode, elemtype)
   ;; 6-typing.watsup
@@ -29118,6 +30410,12 @@ relation Externidx_ok: `%|-%:%`(context, externidx, externtype)
     -- if (x!`%`_idx.0 < |C.MEMS_context|)
     -- if (C.MEMS_context[x!`%`_idx.0] = mt)
 
+  ;; 6-typing.watsup
+  rule tag{C : context, x : idx, at : tagtype}:
+    `%|-%:%`(C, TAG_externidx(x), TAG_externtype((at : deftype <: typeuse)))
+    -- if (x!`%`_idx.0 < |C.TAGS_context|)
+    -- if (C.TAGS_context[x!`%`_idx.0] = at)
+
 ;; 6-typing.watsup
 relation Export_ok: `%|-%:%%`(context, export, name, externtype)
   ;; 6-typing.watsup
@@ -29128,33 +30426,33 @@ relation Export_ok: `%|-%:%%`(context, export, name, externtype)
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:1288.1-1288.100
+;; 6-typing.watsup:1356.1-1356.100
 relation Globals_ok: `%|-%:%`(context, global*, globaltype*)
-  ;; 6-typing.watsup:1330.1-1331.17
+  ;; 6-typing.watsup:1400.1-1401.17
   rule empty{C : context}:
     `%|-%:%`(C, [], [])
 
-  ;; 6-typing.watsup:1333.1-1336.54
+  ;; 6-typing.watsup:1403.1-1406.54
   rule cons{C : context, global_1 : global, global : global, gt_1 : globaltype, gt* : globaltype*}:
     `%|-%:%`(C, [global_1] :: global*{}, [gt_1] :: gt*{gt : globaltype})
     -- Global_ok: `%|-%:%`(C, global, gt_1)
-    -- Globals_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [gt_1], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, global*{}, gt*{gt : globaltype})
+    -- Globals_ok: `%|-%:%`(C ++ {TYPES [], RECS [], FUNCS [], GLOBALS [gt_1], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, global*{}, gt*{gt : globaltype})
 }
 
 ;; 6-typing.watsup
 rec {
 
-;; 6-typing.watsup:1287.1-1287.98
+;; 6-typing.watsup:1355.1-1355.98
 relation Types_ok: `%|-%:%`(context, type*, deftype*)
-  ;; 6-typing.watsup:1322.1-1323.17
+  ;; 6-typing.watsup:1392.1-1393.17
   rule empty{C : context}:
     `%|-%:%`(C, [], [])
 
-  ;; 6-typing.watsup:1325.1-1328.49
+  ;; 6-typing.watsup:1395.1-1398.49
   rule cons{C : context, type_1 : type, type* : type*, dt_1* : deftype*, dt* : deftype*}:
     `%|-%:%`(C, [type_1] :: type*{type : type}, dt_1*{dt_1 : deftype} :: dt*{dt : deftype})
     -- Type_ok: `%|-%:%`(C, type_1, dt_1*{dt_1 : deftype})
-    -- Types_ok: `%|-%:%`(C ++ {TYPES dt_1*{dt_1 : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt*{dt : deftype})
+    -- Types_ok: `%|-%:%`(C ++ {TYPES dt_1*{dt_1 : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt*{dt : deftype})
 }
 
 ;; 6-typing.watsup
@@ -29164,39 +30462,42 @@ syntax nonfuncs =
 ;; 6-typing.watsup
 def $funcidx_nonfuncs(nonfuncs : nonfuncs) : funcidx*
   ;; 6-typing.watsup
-  def $funcidx_nonfuncs{global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*}(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})) = $funcidx_module(MODULE_module([], [], [], global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, ?(), []))
+  def $funcidx_nonfuncs{global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*}(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})) = $funcidx_module(MODULE_module([], [], [], global*{global : global}, table*{table : table}, mem*{mem : mem}, [], elem*{elem : elem}, data*{data : data}, ?(), []))
 
 ;; 6-typing.watsup
 relation Module_ok: `|-%:%`(module, moduletype)
   ;; 6-typing.watsup
-  rule _{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, C : context, xt_I* : externtype*, xt_E* : externtype*, dt'* : deftype*, C' : context, gt* : globaltype*, tt* : tabletype*, mt* : memtype*, dt* : deftype*, rt* : reftype*, ok* : datatype*, nm* : name*, dt_I* : deftype*, gt_I* : globaltype*, tt_I* : tabletype*, mt_I* : memtype*, x* : idx*}:
-    `|-%:%`(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}), $clos_moduletype(C, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype})))
+  rule _{type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, C : context, xt_I* : externtype*, xt_E* : externtype*, dt'* : deftype*, C' : context, gt* : globaltype*, tt* : tabletype*, mt* : memtype*, at* : tagtype*, dt* : deftype*, rt* : reftype*, ok* : datatype*, nm* : name*, dt_I* : deftype*, gt_I* : globaltype*, tt_I* : tabletype*, mt_I* : memtype*, at_I* : tagtype*, x* : idx*}:
+    `|-%:%`(MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}), $clos_moduletype(C, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype})))
     -- if (|import*{import : import}| = |xt_I*{xt_I : externtype}|)
     -- if (|table*{table : table}| = |tt*{tt : tabletype}|)
     -- if (|mem*{mem : mem}| = |mt*{mt : memtype}|)
+    -- if (|at*{at : tagtype}| = |tag*{tag : tag}|)
     -- if (|dt*{dt : deftype}| = |func*{func : func}|)
     -- if (|elem*{elem : elem}| = |rt*{rt : reftype}|)
     -- if (|data*{data : data}| = |ok*{ok : datatype}|)
     -- if (|export*{export : export}| = |nm*{nm : name}|)
     -- if (|export*{export : export}| = |xt_E*{xt_E : externtype}|)
-    -- Types_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt'*{dt' : deftype})
-    -- (Import_ok: `%|-%:%`({TYPES dt'*{dt' : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, import, xt_I))*{import : import, xt_I : externtype}
+    -- Types_ok: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, type*{type : type}, dt'*{dt' : deftype})
+    -- (Import_ok: `%|-%:%`({TYPES dt'*{dt' : deftype}, RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, import, xt_I))*{import : import, xt_I : externtype}
     -- Globals_ok: `%|-%:%`(C', global*{global : global}, gt*{gt : globaltype})
     -- (Table_ok: `%|-%:%`(C', table, tt))*{table : table, tt : tabletype}
     -- (Mem_ok: `%|-%:%`(C', mem, mt))*{mem : mem, mt : memtype}
+    -- (Tag_ok: `%|-%:%`(C', tag, at))*{at : tagtype, tag : tag}
     -- (Func_ok: `%|-%:%`(C, func, dt))*{dt : deftype, func : func}
     -- (Elem_ok: `%|-%:%`(C, elem, rt))*{elem : elem, rt : elemtype}
     -- (Data_ok: `%|-%:%`(C, data, ok))*{data : data, ok : datatype}
     -- (Start_ok: `%|-%:OK`(C, start))?{start : start}
     -- (Export_ok: `%|-%:%%`(C, export, nm, xt_E))*{export : export, nm : name, xt_E : externtype}
     -- if $disjoint_(syntax name, nm*{nm : name})
-    -- if (C = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype} :: gt*{gt : globaltype}, TABLES tt_I*{tt_I : tabletype} :: tt*{tt : tabletype}, MEMS mt_I*{mt_I : memtype} :: mt*{mt : memtype}, ELEMS rt*{rt : elemtype}, DATAS ok*{ok : datatype}, LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
-    -- if (C' = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype}, TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
+    -- if (C = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype} :: gt*{gt : globaltype}, TABLES tt_I*{tt_I : tabletype} :: tt*{tt : tabletype}, MEMS mt_I*{mt_I : memtype} :: mt*{mt : memtype}, TAGS at_I*{at_I : tagtype} :: at*{at : tagtype}, ELEMS rt*{rt : elemtype}, DATAS ok*{ok : datatype}, LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
+    -- if (C' = {TYPES dt'*{dt' : deftype}, RECS [], FUNCS dt_I*{dt_I : deftype} :: dt*{dt : deftype}, GLOBALS gt_I*{gt_I : globaltype}, TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS x*{x : funcidx}})
     -- if (x*{x : idx} = $funcidx_nonfuncs(`%%%%%`_nonfuncs(global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data})))
     -- if (dt_I*{dt_I : deftype} = $funcsxt(xt_I*{xt_I : externtype}))
     -- if (gt_I*{gt_I : globaltype} = $globalsxt(xt_I*{xt_I : externtype}))
     -- if (tt_I*{tt_I : tabletype} = $tablesxt(xt_I*{xt_I : externtype}))
     -- if (mt_I*{mt_I : memtype} = $memsxt(xt_I*{xt_I : externtype}))
+    -- if (at_I*{at_I : tagtype} = $tagsxt(xt_I*{xt_I : externtype}))
 
 ;; 7-runtime-typing.watsup
 relation Num_type: `%|-%:%`(store, num, numtype)
@@ -29241,19 +30542,23 @@ relation Ref_type: `%|-%:%`(store, ref, reftype)
     -- if (a < |s.FUNCS_store|)
     -- if (s.FUNCS_store[a].TYPE_funcinst = dt)
 
-  ;; 7-runtime-typing.watsup:35.1-36.39
+  ;; 7-runtime-typing.watsup:35.1-36.38
+  rule exn{s : store, a : addr}:
+    `%|-%:%`(s, REF.EXN_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), EXN_heaptype))
+
+  ;; 7-runtime-typing.watsup:38.1-39.39
   rule host{s : store, a : addr}:
     `%|-%:%`(s, REF.HOST_ADDR_ref(a), REF_reftype(`NULL%?`_nul(?()), ANY_heaptype))
 
-  ;; 7-runtime-typing.watsup:38.1-39.45
+  ;; 7-runtime-typing.watsup:41.1-42.45
   rule extern{s : store, addrref : addrref}:
     `%|-%:%`(s, REF.EXTERN_ref(addrref), REF_reftype(`NULL%?`_nul(?()), EXTERN_heaptype))
 
-  ;; 7-runtime-typing.watsup:41.1-44.34
+  ;; 7-runtime-typing.watsup:44.1-47.34
   rule sub{s : store, ref : ref, rt : reftype, rt' : reftype}:
     `%|-%:%`(s, ref, rt)
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', rt)
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', rt)
 }
 
 ;; 7-runtime-typing.watsup
@@ -29276,37 +30581,43 @@ relation Val_type: `%|-%:%`(store, val, valtype)
 ;; 7-runtime-typing.watsup
 rec {
 
-;; 7-runtime-typing.watsup:64.1-64.57
-relation Externval_type: `%|-%:%`(store, externval, externtype)
-  ;; 7-runtime-typing.watsup:66.1-68.30
+;; 7-runtime-typing.watsup:67.1-67.59
+relation Externaddr_type: `%|-%:%`(store, externaddr, externtype)
+  ;; 7-runtime-typing.watsup:69.1-71.30
   rule func{s : store, a : addr, funcinst : funcinst}:
-    `%|-%:%`(s, FUNC_externval(a), FUNC_externtype((funcinst.TYPE_funcinst : deftype <: typeuse)))
+    `%|-%:%`(s, FUNC_externaddr(a), FUNC_externtype((funcinst.TYPE_funcinst : deftype <: typeuse)))
     -- if (a < |s.FUNCS_store|)
     -- if (s.FUNCS_store[a] = funcinst)
 
-  ;; 7-runtime-typing.watsup:70.1-72.34
+  ;; 7-runtime-typing.watsup:73.1-75.34
   rule global{s : store, a : addr, globalinst : globalinst}:
-    `%|-%:%`(s, GLOBAL_externval(a), GLOBAL_externtype(globalinst.TYPE_globalinst))
+    `%|-%:%`(s, GLOBAL_externaddr(a), GLOBAL_externtype(globalinst.TYPE_globalinst))
     -- if (a < |s.GLOBALS_store|)
     -- if (s.GLOBALS_store[a] = globalinst)
 
-  ;; 7-runtime-typing.watsup:74.1-76.32
+  ;; 7-runtime-typing.watsup:77.1-79.32
   rule table{s : store, a : addr, tableinst : tableinst}:
-    `%|-%:%`(s, TABLE_externval(a), TABLE_externtype(tableinst.TYPE_tableinst))
+    `%|-%:%`(s, TABLE_externaddr(a), TABLE_externtype(tableinst.TYPE_tableinst))
     -- if (a < |s.TABLES_store|)
     -- if (s.TABLES_store[a] = tableinst)
 
-  ;; 7-runtime-typing.watsup:78.1-80.28
+  ;; 7-runtime-typing.watsup:81.1-83.28
   rule mem{s : store, a : addr, meminst : meminst}:
-    `%|-%:%`(s, MEM_externval(a), MEM_externtype(meminst.TYPE_meminst))
+    `%|-%:%`(s, MEM_externaddr(a), MEM_externtype(meminst.TYPE_meminst))
     -- if (a < |s.MEMS_store|)
     -- if (s.MEMS_store[a] = meminst)
 
-  ;; 7-runtime-typing.watsup:82.1-85.37
-  rule sub{s : store, externval : externval, xt : externtype, xt' : externtype}:
-    `%|-%:%`(s, externval, xt)
-    -- Externval_type: `%|-%:%`(s, externval, xt')
-    -- Externtype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, xt', xt)
+  ;; 7-runtime-typing.watsup:85.1-87.28
+  rule tag{s : store, a : addr, taginst : taginst}:
+    `%|-%:%`(s, TAG_externaddr(a), TAG_externtype((taginst.TYPE_taginst : deftype <: typeuse)))
+    -- if (a < |s.TAGS_store|)
+    -- if (s.TAGS_store[a] = taginst)
+
+  ;; 7-runtime-typing.watsup:89.1-92.37
+  rule sub{s : store, externaddr : externaddr, xt : externtype, xt' : externtype}:
+    `%|-%:%`(s, externaddr, xt)
+    -- Externaddr_type: `%|-%:%`(s, externaddr, xt')
+    -- Externtype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, xt', xt)
 }
 
 ;; 8-reduction.watsup
@@ -29348,15 +30659,19 @@ relation Step_pure: `%~>%`(instr*, instr*)
     `%~>%`([`LABEL_%{%}%`_instr(n, instr*{instr : instr}, (val : val <: instr)*{val : val})], (val : val <: instr)*{val : val})
 
   ;; 8-reduction.watsup
-  rule br-zero{n : n, instr'* : instr*, val'* : val*, val^n : val^n, l : labelidx, instr* : instr*}:
+  rule br-label-zero{n : n, instr'* : instr*, val'* : val*, val^n : val^n, l : labelidx, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val' : val <: instr)*{val' : val} :: (val : val <: instr)^n{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)^n{val : val} :: instr'*{instr' : instr})
     -- if (l = `%`_labelidx(0))
 
   ;; 8-reduction.watsup
-  rule br-succ{n : n, instr'* : instr*, val* : val*, l : labelidx, instr* : instr*}:
+  rule br-label-succ{n : n, instr'* : instr*, val* : val*, l : labelidx, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val : val <: instr)*{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [BR_instr(`%`_labelidx((l!`%`_labelidx.0 - 1)))])
     -- if (l!`%`_labelidx.0 > 0)
 
+  ;; 8-reduction.watsup
+  rule br-handler{n : n, catch* : catch*, val* : val*, l : labelidx, instr* : instr*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val} :: [BR_instr(l)] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [BR_instr(l)])
+
   ;; 8-reduction.watsup
   rule br_if-true{c : num_(I32_numtype), l : labelidx}:
     `%~>%`([CONST_instr(I32_numtype, c) BR_IF_instr(l)], [BR_instr(l)])
@@ -29417,6 +30732,14 @@ relation Step_pure: `%~>%`(instr*, instr*)
   rule return-label{n : n, instr'* : instr*, val* : val*, instr* : instr*}:
     `%~>%`([`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, (val : val <: instr)*{val : val} :: [RETURN_instr] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [RETURN_instr])
 
+  ;; 8-reduction.watsup
+  rule return-handler{n : n, catch* : catch*, val* : val*, instr* : instr*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val} :: [RETURN_instr] :: instr*{instr : instr})], (val : val <: instr)*{val : val} :: [RETURN_instr])
+
+  ;; 8-reduction.watsup
+  rule handler-vals{n : n, catch* : catch*, val* : val*}:
+    `%~>%`([`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, (val : val <: instr)*{val : val})], (val : val <: instr)*{val : val})
+
   ;; 8-reduction.watsup
   rule trap-vals{val* : val*, instr* : instr*}:
     `%~>%`((val : val <: instr)*{val : val} :: [TRAP_instr] :: instr*{instr : instr}, [TRAP_instr])
@@ -29724,7 +31047,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule br_on_cast-succeed{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype, rt : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) BR_ON_CAST_instr(l, rt_1, rt_2)]), [(ref : ref <: instr) BR_instr(l)])
     -- Ref_type: `%|-%:%`(s, ref, rt)
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
 
   ;; 8-reduction.watsup
   rule br_on_cast-fail{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype}:
@@ -29735,7 +31058,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule br_on_cast_fail-succeed{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype, rt : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) BR_ON_CAST_FAIL_instr(l, rt_1, rt_2)]), [(ref : ref <: instr)])
     -- Ref_type: `%|-%:%`(s, ref, rt)
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt, $inst_reftype(f.MODULE_frame, rt_2))
 
   ;; 8-reduction.watsup
   rule br_on_cast_fail-fail{s : store, f : frame, ref : ref, l : labelidx, rt_1 : reftype, rt_2 : reftype}:
@@ -29783,6 +31106,61 @@ relation Step_read: `%~>%`(config, instr*)
     -- if (a < |$funcinst(z)|)
     -- Expand: `%~~%`($funcinst(z)[a].TYPE_funcinst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1^n{t_1 : valtype}), `%`_resulttype(t_2^m{t_2 : valtype}))))
 
+  ;; 8-reduction.watsup
+  rule throw_ref-null{z : state, ht : heaptype}:
+    `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) THROW_REF_instr]), [TRAP_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-vals{z : state, val* : val*, a : addr, instr* : instr*}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)*{val : val} :: [REF.EXN_ADDR_instr(a)] :: [THROW_REF_instr] :: instr*{instr : instr}), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+    -- if ((val*{val : val} =/= []) \/ (instr*{instr : instr} =/= []))
+
+  ;; 8-reduction.watsup
+  rule throw_ref-label{z : state, n : n, instr'* : instr*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`LABEL_%{%}%`_instr(n, instr'*{instr' : instr}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-frame{z : state, n : n, f : frame, a : addr}:
+    `%~>%`(`%;%`_config(z, [`FRAME_%{%}%`_instr(n, f, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-empty{z : state, n : n, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [], [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) THROW_REF_instr])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch{z : state, n : n, x : idx, l : labelidx, catch'* : catch*, a : addr, val* : val*}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_catch(x, l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), (val : val <: instr)*{val : val} :: [BR_instr(l)])
+    -- if (a < |$exninst(z)|)
+    -- if (x!`%`_idx.0 < |$tagaddr(z)|)
+    -- if ($exninst(z)[a].TAG_exninst = $tagaddr(z)[x!`%`_idx.0])
+    -- if (val*{val : val} = $exninst(z)[a].FIELDS_exninst)
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_ref{z : state, n : n, x : idx, l : labelidx, catch'* : catch*, a : addr, val* : val*}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_REF_catch(x, l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), (val : val <: instr)*{val : val} :: [REF.EXN_ADDR_instr(a) BR_instr(l)])
+    -- if (a < |$exninst(z)|)
+    -- if (x!`%`_idx.0 < |$tagaddr(z)|)
+    -- if ($exninst(z)[a].TAG_exninst = $tagaddr(z)[x!`%`_idx.0])
+    -- if (val*{val : val} = $exninst(z)[a].FIELDS_exninst)
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_all{z : state, n : n, l : labelidx, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_ALL_catch(l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [BR_instr(l)])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-catch_all_ref{z : state, n : n, l : labelidx, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [CATCH_ALL_REF_catch(l)] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [REF.EXN_ADDR_instr(a) BR_instr(l)])
+
+  ;; 8-reduction.watsup
+  rule throw_ref-handler-next{z : state, n : n, catch : catch, catch'* : catch*, a : addr}:
+    `%~>%`(`%;%`_config(z, [`HANDLER_%{%}%`_instr(n, [catch] :: catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])]), [`HANDLER_%{%}%`_instr(n, catch'*{catch' : catch}, [REF.EXN_ADDR_instr(a) THROW_REF_instr])])
+    -- otherwise
+
+  ;; 8-reduction.watsup
+  rule try_table{z : state, val^m : val^m, m : m, bt : blocktype, catch* : catch*, instr* : instr*, n : n, t_1^m : valtype^m, t_2^n : valtype^n}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)^m{val : val} :: [TRY_TABLE_instr(bt, `%`_list(catch*{catch : catch}), instr*{instr : instr})]), [`HANDLER_%{%}%`_instr(n, catch*{catch : catch}, [`LABEL_%{%}%`_instr(n, [], (val : val <: instr)^m{val : val} :: instr*{instr : instr})])])
+    -- if ($blocktype_(z, bt) = `%->%`_functype(`%`_resulttype(t_1^m{t_1 : valtype}), `%`_resulttype(t_2^n{t_2 : valtype})))
+
   ;; 8-reduction.watsup
   rule ref.null-idx{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(($idx(x) : typevar <: heaptype))]), [REF.NULL_instr(($type(z, x) : deftype <: heaptype))])
@@ -29796,7 +31174,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule ref.test-true{s : store, f : frame, ref : ref, rt : reftype, rt' : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) REF.TEST_instr(rt)]), [CONST_instr(I32_numtype, `%`_num_(1))])
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
 
   ;; 8-reduction.watsup
   rule ref.test-false{s : store, f : frame, ref : ref, rt : reftype}:
@@ -29807,7 +31185,7 @@ relation Step_read: `%~>%`(config, instr*)
   rule ref.cast-succeed{s : store, f : frame, ref : ref, rt : reftype, rt' : reftype}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [(ref : ref <: instr) REF.CAST_instr(rt)]), [(ref : ref <: instr)])
     -- Ref_type: `%|-%:%`(s, ref, rt')
-    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
+    -- Reftype_sub: `%|-%<:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [], RETURN ?(), REFS []}, rt', $inst_reftype(f.MODULE_frame, rt))
 
   ;; 8-reduction.watsup
   rule ref.cast-fail{s : store, f : frame, ref : ref, rt : reftype}:
@@ -30242,123 +31620,131 @@ relation Step: `%~>%`(config, config)
     `%~>%`(`%;%`_config(z, instr*{instr : instr}), `%;%`_config(z, instr'*{instr' : instr}))
     -- Step_read: `%~>%`(`%;%`_config(z, instr*{instr : instr}), instr'*{instr' : instr})
 
-  ;; 8-reduction.watsup:225.1-227.36
+  ;; 8-reduction.watsup:218.1-223.49
+  rule throw{z : state, val^n : val^n, n : n, x : idx, exn : exninst, a : addr, t^n : valtype^n}:
+    `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [THROW_instr(x)]), `%;%`_config($add_exninst(z, [exn]), [REF.EXN_ADDR_instr(a) THROW_REF_instr]))
+    -- if (x!`%`_idx.0 < |$tagaddr(z)|)
+    -- Expand: `%~~%`($tag(z, x).TYPE_taginst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t^n{t : valtype}), `%`_resulttype([]))))
+    -- if (a = |$exninst(z)|)
+    -- if (exn = {TAG $tagaddr(z)[x!`%`_idx.0], FIELDS val^n{val : val}})
+
+  ;; 8-reduction.watsup:285.1-287.36
   rule ctxt-label{z : state, n : n, instr_0* : instr*, instr* : instr*, z' : state, instr'* : instr*}:
     `%~>%`(`%;%`_config(z, [`LABEL_%{%}%`_instr(n, instr_0*{instr_0 : instr}, instr*{instr : instr})]), `%;%`_config(z', [`LABEL_%{%}%`_instr(n, instr_0*{instr_0 : instr}, instr'*{instr' : instr})]))
     -- Step: `%~>%`(`%;%`_config(z, instr*{instr : instr}), `%;%`_config(z', instr'*{instr' : instr}))
 
-  ;; 8-reduction.watsup:229.1-231.44
+  ;; 8-reduction.watsup:289.1-291.44
   rule ctxt-frame{s : store, f : frame, n : n, f' : frame, instr* : instr*, s' : store, instr'* : instr*}:
     `%~>%`(`%;%`_config(`%;%`_state(s, f), [`FRAME_%{%}%`_instr(n, f', instr*{instr : instr})]), `%;%`_config(`%;%`_state(s', f), [`FRAME_%{%}%`_instr(n, f', instr'*{instr' : instr})]))
     -- Step: `%~>%`(`%;%`_config(`%;%`_state(s, f'), instr*{instr : instr}), `%;%`_config(`%;%`_state(s', f'), instr'*{instr' : instr}))
 
-  ;; 8-reduction.watsup:349.1-353.65
+  ;; 8-reduction.watsup:409.1-413.65
   rule struct.new{z : state, val^n : val^n, n : n, x : idx, si : structinst, a : addr, mut^n : mut^n, zt^n : storagetype^n}:
     `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [STRUCT.NEW_instr(x)]), `%;%`_config($add_structinst(z, [si]), [REF.STRUCT_ADDR_instr(a)]))
     -- Expand: `%~~%`($type(z, x), STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)^n{mut : mut, zt : storagetype})))
     -- if (a = |$structinst(z)|)
     -- if (si = {TYPE $type(z, x), FIELDS $packfield_(zt, val)^n{val : val, zt : storagetype}})
 
-  ;; 8-reduction.watsup:369.1-370.53
+  ;; 8-reduction.watsup:429.1-430.53
   rule struct.set-null{z : state, ht : heaptype, val : val, x : idx, i : nat}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) (val : val <: instr) STRUCT.SET_instr(x, `%`_u32(i))]), `%;%`_config(z, [TRAP_instr]))
 
-  ;; 8-reduction.watsup:372.1-374.45
+  ;; 8-reduction.watsup:432.1-434.45
   rule struct.set-struct{z : state, a : addr, val : val, x : idx, i : nat, zt* : storagetype*, mut* : mut*}:
     `%~>%`(`%;%`_config(z, [REF.STRUCT_ADDR_instr(a) (val : val <: instr) STRUCT.SET_instr(x, `%`_u32(i))]), `%;%`_config($with_struct(z, a, i, $packfield_(zt*{zt : storagetype}[i], val)), []))
     -- if (|mut*{mut : mut}| = |zt*{zt : storagetype}|)
     -- if (i < |zt*{zt : storagetype}|)
     -- Expand: `%~~%`($type(z, x), STRUCT_comptype(`%`_structtype(`%%`_fieldtype(mut, zt)*{mut : mut, zt : storagetype})))
 
-  ;; 8-reduction.watsup:387.1-392.65
+  ;; 8-reduction.watsup:447.1-452.65
   rule array.new_fixed{z : state, val^n : val^n, n : n, x : idx, ai : arrayinst, a : addr, mut : mut, zt : storagetype}:
     `%~>%`(`%;%`_config(z, (val : val <: instr)^n{val : val} :: [ARRAY.NEW_FIXED_instr(x, `%`_u32(n))]), `%;%`_config($add_arrayinst(z, [ai]), [REF.ARRAY_ADDR_instr(a)]))
     -- Expand: `%~~%`($type(z, x), ARRAY_comptype(`%%`_arraytype(mut, zt)))
     -- if ((a = |$arrayinst(z)|) /\ (ai = {TYPE $type(z, x), FIELDS $packfield_(zt, val)^n{val : val}}))
 
-  ;; 8-reduction.watsup:432.1-433.64
+  ;; 8-reduction.watsup:492.1-493.64
   rule array.set-null{z : state, ht : heaptype, i : nat, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.NULL_instr(ht) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
 
-  ;; 8-reduction.watsup:435.1-437.39
+  ;; 8-reduction.watsup:495.1-497.39
   rule array.set-oob{z : state, a : addr, i : nat, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [REF.ARRAY_ADDR_instr(a) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
     -- if (a < |$arrayinst(z)|)
     -- if (i >= |$arrayinst(z)[a].FIELDS_arrayinst|)
 
-  ;; 8-reduction.watsup:439.1-442.43
+  ;; 8-reduction.watsup:499.1-502.43
   rule array.set-array{z : state, a : addr, i : nat, val : val, x : idx, zt : storagetype, mut : mut}:
     `%~>%`(`%;%`_config(z, [REF.ARRAY_ADDR_instr(a) CONST_instr(I32_numtype, `%`_num_(i)) (val : val <: instr) ARRAY.SET_instr(x)]), `%;%`_config($with_array(z, a, i, $packfield_(zt, val)), []))
     -- Expand: `%~~%`($type(z, x), ARRAY_comptype(`%%`_arraytype(mut, zt)))
 
-  ;; 8-reduction.watsup:743.1-744.56
+  ;; 8-reduction.watsup:803.1-804.56
   rule local.set{z : state, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [(val : val <: instr) LOCAL.SET_instr(x)]), `%;%`_config($with_local(z, x, val), []))
 
-  ;; 8-reduction.watsup:756.1-757.58
+  ;; 8-reduction.watsup:816.1-817.58
   rule global.set{z : state, val : val, x : idx}:
     `%~>%`(`%;%`_config(z, [(val : val <: instr) GLOBAL.SET_instr(x)]), `%;%`_config($with_global(z, x, val), []))
 
-  ;; 8-reduction.watsup:770.1-772.33
+  ;; 8-reduction.watsup:830.1-832.33
   rule table.set-oob{z : state, i : nat, ref : ref, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) (ref : ref <: instr) TABLE.SET_instr(x)]), `%;%`_config(z, [TRAP_instr]))
     -- if (i >= |$table(z, x).REFS_tableinst|)
 
-  ;; 8-reduction.watsup:774.1-776.32
+  ;; 8-reduction.watsup:834.1-836.32
   rule table.set-val{z : state, i : nat, ref : ref, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) (ref : ref <: instr) TABLE.SET_instr(x)]), `%;%`_config($with_table(z, x, i, ref), []))
     -- if (i < |$table(z, x).REFS_tableinst|)
 
-  ;; 8-reduction.watsup:784.1-787.46
+  ;; 8-reduction.watsup:844.1-847.46
   rule table.grow-succeed{z : state, ref : ref, n : n, x : idx, ti : tableinst}:
     `%~>%`(`%;%`_config(z, [(ref : ref <: instr) CONST_instr(I32_numtype, `%`_num_(n)) TABLE.GROW_instr(x)]), `%;%`_config($with_tableinst(z, x, ti), [CONST_instr(I32_numtype, `%`_num_(|$table(z, x).REFS_tableinst|))]))
     -- if ($growtable($table(z, x), n, ref) =/= ?())
     -- if (ti = !($growtable($table(z, x), n, ref)))
 
-  ;; 8-reduction.watsup:789.1-790.81
+  ;; 8-reduction.watsup:849.1-850.81
   rule table.grow-fail{z : state, ref : ref, n : n, x : idx}:
     `%~>%`(`%;%`_config(z, [(ref : ref <: instr) CONST_instr(I32_numtype, `%`_num_(n)) TABLE.GROW_instr(x)]), `%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_($invsigned_(32, - (1 : nat <: int))))]))
 
-  ;; 8-reduction.watsup:850.1-851.51
+  ;; 8-reduction.watsup:910.1-911.51
   rule elem.drop{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [ELEM.DROP_instr(x)]), `%;%`_config($with_elem(z, x, []), []))
 
-  ;; 8-reduction.watsup:934.1-937.60
+  ;; 8-reduction.watsup:994.1-997.60
   rule store-num-oob{z : state, i : nat, nt : numtype, c : num_(nt), x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr(nt, c) STORE_instr(nt, ?(), x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + ($size(nt) / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:939.1-943.29
+  ;; 8-reduction.watsup:999.1-1003.29
   rule store-num-val{z : state, i : nat, nt : numtype, c : num_(nt), x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr(nt, c) STORE_instr(nt, ?(), x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), ($size(nt) / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $nbytes_(nt, c))
 
-  ;; 8-reduction.watsup:945.1-948.52
+  ;; 8-reduction.watsup:1005.1-1008.52
   rule store-pack-oob{z : state, i : nat, Inn : Inn, c : num_((Inn : Inn <: numtype)), nt : numtype, n : n, x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr((Inn : Inn <: numtype), c) STORE_instr(nt, ?(`%`_sz(n)), x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + (n / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:950.1-954.52
+  ;; 8-reduction.watsup:1010.1-1014.52
   rule store-pack-val{z : state, i : nat, Inn : Inn, c : num_((Inn : Inn <: numtype)), nt : numtype, n : n, x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) CONST_instr((Inn : Inn <: numtype), c) STORE_instr(nt, ?(`%`_sz(n)), x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), (n / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $ibytes_(n, $wrap__($size((Inn : Inn <: numtype)), n, c)))
 
-  ;; 8-reduction.watsup:956.1-958.63
+  ;; 8-reduction.watsup:1016.1-1018.63
   rule vstore-oob{z : state, i : nat, c : vec_(V128_Vnn), x : idx, ao : memarg}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_instr(V128_vectype, x, ao)]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + ($vsize(V128_vectype) / 8)) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:960.1-962.31
+  ;; 8-reduction.watsup:1020.1-1022.31
   rule vstore-val{z : state, i : nat, c : vec_(V128_Vnn), x : idx, ao : memarg, b* : byte*}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_instr(V128_vectype, x, ao)]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), ($vsize(V128_vectype) / 8), b*{b : byte}), []))
     -- if (b*{b : byte} = $vbytes_(V128_vectype, c))
 
-  ;; 8-reduction.watsup:965.1-967.50
+  ;; 8-reduction.watsup:1025.1-1027.50
   rule vstore_lane-oob{z : state, i : nat, c : vec_(V128_Vnn), N : N, x : idx, ao : memarg, j : nat}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, ao, `%`_laneidx(j))]), `%;%`_config(z, [TRAP_instr]))
     -- if (((i + ao.OFFSET_memarg!`%`_u32.0) + N) > |$mem(z, x).BYTES_meminst|)
 
-  ;; 8-reduction.watsup:969.1-973.49
+  ;; 8-reduction.watsup:1029.1-1033.49
   rule vstore_lane-val{z : state, i : nat, c : vec_(V128_Vnn), N : N, x : idx, ao : memarg, j : nat, b* : byte*, Jnn : Jnn, M : M}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(i)) VCONST_instr(V128_vectype, c) VSTORE_LANE_instr(V128_vectype, `%`_sz(N), x, ao, `%`_laneidx(j))]), `%;%`_config($with_mem(z, x, (i + ao.OFFSET_memarg!`%`_u32.0), (N / 8), b*{b : byte}), []))
     -- if (j < |$lanes_(`%X%`_shape((Jnn : Jnn <: lanetype), `%`_dim(M)), c)|)
@@ -30366,17 +31752,17 @@ relation Step: `%~>%`(config, config)
     -- if (M = (128 / N))
     -- if (b*{b : byte} = $ibytes_(N, `%`_iN($lanes_(`%X%`_shape((Jnn : Jnn <: lanetype), `%`_dim(M)), c)[j]!`%`_lane_.0)))
 
-  ;; 8-reduction.watsup:981.1-984.37
+  ;; 8-reduction.watsup:1041.1-1044.37
   rule memory.grow-succeed{z : state, n : n, x : idx, mi : meminst}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(n)) MEMORY.GROW_instr(x)]), `%;%`_config($with_meminst(z, x, mi), [CONST_instr(I32_numtype, `%`_num_((|$mem(z, x).BYTES_meminst| / (64 * $Ki))))]))
     -- if ($growmem($mem(z, x), n) =/= ?())
     -- if (mi = !($growmem($mem(z, x), n)))
 
-  ;; 8-reduction.watsup:986.1-987.78
+  ;; 8-reduction.watsup:1046.1-1047.78
   rule memory.grow-fail{z : state, n : n, x : idx}:
     `%~>%`(`%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_(n)) MEMORY.GROW_instr(x)]), `%;%`_config(z, [CONST_instr(I32_numtype, `%`_num_($invsigned_(32, - (1 : nat <: int))))]))
 
-  ;; 8-reduction.watsup:1047.1-1048.51
+  ;; 8-reduction.watsup:1107.1-1108.51
   rule data.drop{z : state, x : idx}:
     `%~>%`(`%;%`_config(z, [DATA.DROP_instr(x)]), `%;%`_config($with_data(z, x, []), []))
 }
@@ -30422,7 +31808,7 @@ def $alloctypes(type*) : deftype*
 ;; 9-module.watsup
 def $allocfunc(store : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst) : (store, funcaddr)
   ;; 9-module.watsup
-  def $allocfunc{s : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst, funcinst : funcinst}(s, deftype, funccode, moduleinst) = (s ++ {FUNCS [funcinst], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.FUNCS_store|)
+  def $allocfunc{s : store, deftype : deftype, funccode : funccode, moduleinst : moduleinst, funcinst : funcinst}(s, deftype, funccode, moduleinst) = (s ++ {FUNCS [funcinst], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.FUNCS_store|)
     -- if (funcinst = {TYPE deftype, MODULE moduleinst, CODE funccode})
 
 ;; 9-module.watsup
@@ -30441,7 +31827,7 @@ def $allocfuncs(store : store, deftype*, funccode*, moduleinst*) : (store, funca
 ;; 9-module.watsup
 def $allocglobal(store : store, globaltype : globaltype, val : val) : (store, globaladdr)
   ;; 9-module.watsup
-  def $allocglobal{s : store, globaltype : globaltype, val : val, globalinst : globalinst}(s, globaltype, val) = (s ++ {FUNCS [], GLOBALS [globalinst], TABLES [], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.GLOBALS_store|)
+  def $allocglobal{s : store, globaltype : globaltype, val : val, globalinst : globalinst}(s, globaltype, val) = (s ++ {FUNCS [], GLOBALS [globalinst], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.GLOBALS_store|)
     -- if (globalinst = {TYPE globaltype, VALUE val})
 
 ;; 9-module.watsup
@@ -30460,7 +31846,7 @@ def $allocglobals(store : store, globaltype*, val*) : (store, globaladdr*)
 ;; 9-module.watsup
 def $alloctable(store : store, tabletype : tabletype, ref : ref) : (store, tableaddr)
   ;; 9-module.watsup
-  def $alloctable{s : store, i : nat, j : nat, rt : reftype, ref : ref, tableinst : tableinst}(s, `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), ref) = (s ++ {FUNCS [], GLOBALS [], TABLES [tableinst], MEMS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.TABLES_store|)
+  def $alloctable{s : store, i : nat, j : nat, rt : reftype, ref : ref, tableinst : tableinst}(s, `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), ref) = (s ++ {FUNCS [], GLOBALS [], TABLES [tableinst], MEMS [], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.TABLES_store|)
     -- if (tableinst = {TYPE `%%`_tabletype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)), rt), REFS ref^i{}})
 
 ;; 9-module.watsup
@@ -30479,7 +31865,7 @@ def $alloctables(store : store, tabletype*, ref*) : (store, tableaddr*)
 ;; 9-module.watsup
 def $allocmem(store : store, memtype : memtype) : (store, memaddr)
   ;; 9-module.watsup
-  def $allocmem{s : store, i : nat, j : nat, meminst : meminst}(s, `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)))) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [meminst], ELEMS [], DATAS [], STRUCTS [], ARRAYS []}, |s.MEMS_store|)
+  def $allocmem{s : store, i : nat, j : nat, meminst : meminst}(s, `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j)))) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [meminst], TAGS [], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.MEMS_store|)
     -- if (meminst = {TYPE `%PAGE`_memtype(`[%..%]`_limits(`%`_u32(i), `%`_u32(j))), BYTES `%`_byte(0)^(i * (64 * $Ki)){}})
 
 ;; 9-module.watsup
@@ -30495,39 +31881,58 @@ def $allocmems(store : store, memtype*) : (store, memaddr*)
     -- if ((s_2, ma'*{ma' : memaddr}) = $allocmems(s_1, memtype'*{memtype' : memtype}))
 }
 
+;; 9-module.watsup
+def $alloctag(store : store, tagtype : tagtype) : (store, tagaddr)
+  ;; 9-module.watsup
+  def $alloctag{s : store, at : tagtype, taginst : taginst}(s, at) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [taginst], ELEMS [], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.TAGS_store|)
+    -- if (taginst = {TYPE at})
+
+;; 9-module.watsup
+rec {
+
+;; 9-module.watsup:64.1-64.82
+def $alloctags(store : store, tagtype*) : (store, tagaddr*)
+  ;; 9-module.watsup:65.1-65.34
+  def $alloctags{s : store}(s, []) = (s, [])
+  ;; 9-module.watsup:66.1-68.44
+  def $alloctags{s : store, at : tagtype, at'* : tagtype*, s_2 : store, aa : tagaddr, aa'* : tagaddr*, s_1 : store}(s, [at] :: at'*{at' : tagtype}) = (s_2, [aa] :: aa'*{aa' : tagaddr})
+    -- if ((s_1, aa) = $alloctag(s, at))
+    -- if ((s_2, aa'*{aa' : tagaddr}) = $alloctags(s_1, at'*{at' : tagtype}))
+}
+
 ;; 9-module.watsup
 def $allocelem(store : store, elemtype : elemtype, ref*) : (store, elemaddr)
   ;; 9-module.watsup
-  def $allocelem{s : store, elemtype : elemtype, ref* : ref*, eleminst : eleminst}(s, elemtype, ref*{ref : ref}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [eleminst], DATAS [], STRUCTS [], ARRAYS []}, |s.ELEMS_store|)
+  def $allocelem{s : store, elemtype : elemtype, ref* : ref*, eleminst : eleminst}(s, elemtype, ref*{ref : ref}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [eleminst], DATAS [], STRUCTS [], ARRAYS [], EXNS []}, |s.ELEMS_store|)
     -- if (eleminst = {TYPE elemtype, REFS ref*{ref : ref}})
 
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:64.1-64.97
+;; 9-module.watsup:75.1-75.97
 def $allocelems(store : store, elemtype*, ref**) : (store, elemaddr*)
-  ;; 9-module.watsup:65.1-65.40
+  ;; 9-module.watsup:76.1-76.40
   def $allocelems{s : store}(s, [], []) = (s, [])
-  ;; 9-module.watsup:66.1-68.55
+  ;; 9-module.watsup:77.1-79.55
   def $allocelems{s : store, rt : reftype, rt'* : reftype*, ref* : ref*, ref'** : ref**, s_2 : store, ea : elemaddr, ea'* : elemaddr*, s_1 : store}(s, [rt] :: rt'*{rt' : elemtype}, [ref*{ref : ref}] :: ref'*{ref' : ref}*{ref' : ref}) = (s_2, [ea] :: ea'*{ea' : elemaddr})
     -- if ((s_1, ea) = $allocelem(s, rt, ref*{ref : ref}))
-    -- if ((s_2, ea'*{ea' : elemaddr}) = $allocelems(s_2, rt'*{rt' : elemtype}, ref'*{ref' : ref}*{ref' : ref}))
+    -- if ((s_2, ea'*{ea' : elemaddr}) = $allocelems(s_1, rt'*{rt' : elemtype}, ref'*{ref' : ref}*{ref' : ref}))
 }
 
 ;; 9-module.watsup
 def $allocdata(store : store, datatype : datatype, byte*) : (store, dataaddr)
   ;; 9-module.watsup
-  def $allocdata{s : store, byte* : byte*, datainst : datainst}(s, OK_datatype, byte*{byte : byte}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [datainst], STRUCTS [], ARRAYS []}, |s.DATAS_store|)
+  def $allocdata{s : store, byte* : byte*, datainst : datainst}(s, OK_datatype, byte*{byte : byte}) = (s ++ {FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [datainst], STRUCTS [], ARRAYS [], EXNS []}, |s.DATAS_store|)
     -- if (datainst = {BYTES byte*{byte : byte}})
 
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:75.1-75.98
+;; 9-module.watsup:86.1-86.98
 def $allocdatas(store : store, datatype*, byte**) : (store, dataaddr*)
-  ;; 9-module.watsup:76.1-76.40
+  ;; 9-module.watsup:87.1-87.40
   def $allocdatas{s : store}(s, [], []) = (s, [])
-  ;; 9-module.watsup:77.1-79.53
+  ;; 9-module.watsup:88.1-90.53
   def $allocdatas{s : store, ok : datatype, ok'* : datatype*, b* : byte*, b'** : byte**, s_2 : store, da : dataaddr, da'* : dataaddr*, s_1 : store}(s, [ok] :: ok'*{ok' : datatype}, [b*{b : byte}] :: b'*{b' : byte}*{b' : byte}) = (s_2, [da] :: da'*{da' : dataaddr})
     -- if ((s_1, da) = $allocdata(s, ok, b*{b : byte}))
     -- if ((s_2, da'*{da' : dataaddr}) = $allocdatas(s_1, ok'*{ok' : datatype}, b'*{b' : byte}*{b' : byte}))
@@ -30536,13 +31941,15 @@ def $allocdatas(store : store, datatype*, byte**) : (store, dataaddr*)
 ;; 9-module.watsup
 def $allocexport(moduleinst : moduleinst, export : export) : exportinst
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, FUNC_externidx(x))) = {NAME name, VALUE FUNC_externval(moduleinst.FUNCS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, FUNC_externidx(x))) = {NAME name, ADDR FUNC_externaddr(moduleinst.FUNCS_moduleinst[x!`%`_idx.0])}
+  ;; 9-module.watsup
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, GLOBAL_externidx(x))) = {NAME name, ADDR GLOBAL_externaddr(moduleinst.GLOBALS_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, GLOBAL_externidx(x))) = {NAME name, VALUE GLOBAL_externval(moduleinst.GLOBALS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TABLE_externidx(x))) = {NAME name, ADDR TABLE_externaddr(moduleinst.TABLES_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TABLE_externidx(x))) = {NAME name, VALUE TABLE_externval(moduleinst.TABLES_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, MEM_externidx(x))) = {NAME name, ADDR MEM_externaddr(moduleinst.MEMS_moduleinst[x!`%`_idx.0])}
   ;; 9-module.watsup
-  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, MEM_externidx(x))) = {NAME name, VALUE MEM_externval(moduleinst.MEMS_moduleinst[x!`%`_idx.0])}
+  def $allocexport{moduleinst : moduleinst, name : name, x : idx}(moduleinst, EXPORT_export(name, TAG_externidx(x))) = {NAME name, ADDR TAG_externaddr(moduleinst.TAGS_moduleinst[x!`%`_idx.0])}
 
 ;; 9-module.watsup
 def $allocexports(moduleinst : moduleinst, export*) : exportinst*
@@ -30550,35 +31957,39 @@ def $allocexports(moduleinst : moduleinst, export*) : exportinst*
   def $allocexports{moduleinst : moduleinst, export* : export*}(moduleinst, export*{export : export}) = $allocexport(moduleinst, export)*{export : export}
 
 ;; 9-module.watsup
-def $allocmodule(store : store, module : module, externval*, val*, ref*, ref**) : (store, moduleinst)
+def $allocmodule(store : store, module : module, externaddr*, val*, ref*, ref**) : (store, moduleinst)
   ;; 9-module.watsup
-  def $allocmodule{s : store, module : module, externval* : externval*, val_G* : val*, ref_T* : ref*, ref_E** : ref**, s_6 : store, moduleinst : moduleinst, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, x* : idx*, local** : local**, expr_F* : expr*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, memtype* : memtype*, elemtype* : elemtype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, fa_I* : funcaddr*, ga_I* : globaladdr*, ta_I* : tableaddr*, ma_I* : memaddr*, fa* : funcaddr*, i_F^|func*{func : func}| : nat^|func*{func : func}|, ga* : globaladdr*, i_G^|global*{global : global}| : nat^|global*{global : global}|, ta* : tableaddr*, i_T^|table*{table : table}| : nat^|table*{table : table}|, ma* : memaddr*, i_M^|mem*{mem : mem}| : nat^|mem*{mem : mem}|, ea* : elemaddr*, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, da* : dataaddr*, i_D^|data*{data : data}| : nat^|data*{data : data}|, dt* : deftype*, s_1 : store, s_2 : store, s_3 : store, s_4 : store, s_5 : store, xi* : exportinst*}(s, module, externval*{externval : externval}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}) = (s_6, moduleinst)
-    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
+  def $allocmodule{s : store, module : module, externaddr* : externaddr*, val_G* : val*, ref_T* : ref*, ref_E** : ref**, s_7 : store, moduleinst : moduleinst, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, x* : idx*, local** : local**, expr_F* : expr*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, memtype* : memtype*, y* : idx*, elemtype* : elemtype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, fa_I* : funcaddr*, ga_I* : globaladdr*, ta_I* : tableaddr*, ma_I* : memaddr*, aa_I* : tagaddr*, fa* : nat*, i_F^|func*{func : func}| : nat^|func*{func : func}|, ga* : nat*, i_G^|global*{global : global}| : nat^|global*{global : global}|, ta* : nat*, i_T^|table*{table : table}| : nat^|table*{table : table}|, aa* : nat*, i_A^|tag*{tag : tag}| : nat^|tag*{tag : tag}|, ma* : nat*, i_M^|mem*{mem : mem}| : nat^|mem*{mem : mem}|, ea* : nat*, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, da* : nat*, i_D^|data*{data : data}| : nat^|data*{data : data}|, dt* : deftype*, s_1 : store, s_2 : store, s_3 : store, s_4 : store, s_5 : store, s_6 : store, xi* : exportinst*}(s, module, externaddr*{externaddr : externaddr}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}) = (s_7, moduleinst)
+    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
     -- if (func*{func : func} = FUNC_func(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx})
     -- if (global*{global : global} = GLOBAL_global(globaltype, expr_G)*{expr_G : expr, globaltype : globaltype})
     -- if (table*{table : table} = TABLE_table(tabletype, expr_T)*{expr_T : expr, tabletype : tabletype})
     -- if (mem*{mem : mem} = MEMORY_mem(memtype)*{memtype : memtype})
+    -- if (tag*{tag : tag} = TAG_tag(y)*{y : typeidx})
     -- if (elem*{elem : elem} = ELEM_elem(elemtype, expr_E*{expr_E : expr}, elemmode)*{elemmode : elemmode, elemtype : reftype, expr_E : expr})
     -- if (data*{data : data} = DATA_data(byte*{byte : byte}, datamode)*{byte : byte, datamode : datamode})
-    -- if (fa_I*{fa_I : funcaddr} = $funcsxv(externval*{externval : externval}))
-    -- if (ga_I*{ga_I : globaladdr} = $globalsxv(externval*{externval : externval}))
-    -- if (ta_I*{ta_I : tableaddr} = $tablesxv(externval*{externval : externval}))
-    -- if (ma_I*{ma_I : memaddr} = $memsxv(externval*{externval : externval}))
-    -- if (fa*{fa : funcaddr} = (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat})
-    -- if (ga*{ga : globaladdr} = (|s.GLOBALS_store| + i_G)^(i_G<|global*{global : global}|){i_G : nat})
-    -- if (ta*{ta : tableaddr} = (|s.TABLES_store| + i_T)^(i_T<|table*{table : table}|){i_T : nat})
-    -- if (ma*{ma : memaddr} = (|s.MEMS_store| + i_M)^(i_M<|mem*{mem : mem}|){i_M : nat})
-    -- if (ea*{ea : elemaddr} = (|s.ELEMS_store| + i_E)^(i_E<|elem*{elem : elem}|){i_E : nat})
-    -- if (da*{da : dataaddr} = (|s.DATAS_store| + i_D)^(i_D<|data*{data : data}|){i_D : nat})
+    -- if (fa_I*{fa_I : funcaddr} = $funcsxa(externaddr*{externaddr : externaddr}))
+    -- if (ga_I*{ga_I : globaladdr} = $globalsxa(externaddr*{externaddr : externaddr}))
+    -- if (ta_I*{ta_I : tableaddr} = $tablesxa(externaddr*{externaddr : externaddr}))
+    -- if (ma_I*{ma_I : memaddr} = $memsxa(externaddr*{externaddr : externaddr}))
+    -- if (aa_I*{aa_I : tagaddr} = $tagsxa(externaddr*{externaddr : externaddr}))
+    -- if (fa*{fa : nat} = (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat})
+    -- if (ga*{ga : nat} = (|s.GLOBALS_store| + i_G)^(i_G<|global*{global : global}|){i_G : nat})
+    -- if (ta*{ta : nat} = (|s.TABLES_store| + i_T)^(i_T<|table*{table : table}|){i_T : nat})
+    -- if (aa*{aa : nat} = (|s.TAGS_store| + i_A)^(i_A<|tag*{tag : tag}|){i_A : nat})
+    -- if (ma*{ma : nat} = (|s.MEMS_store| + i_M)^(i_M<|mem*{mem : mem}|){i_M : nat})
+    -- if (ea*{ea : nat} = (|s.ELEMS_store| + i_E)^(i_E<|elem*{elem : elem}|){i_E : nat})
+    -- if (da*{da : nat} = (|s.DATAS_store| + i_D)^(i_D<|data*{data : data}|){i_D : nat})
     -- if (dt*{dt : deftype} = $alloctypes(type*{type : type}))
-    -- if ((s_1, fa*{fa : funcaddr}) = $allocfuncs(s, dt*{dt : deftype}[x!`%`_idx.0]*{x : idx}, FUNC_funccode(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx}, moduleinst^|func*{func : func}|{}))
-    -- if ((s_2, ga*{ga : globaladdr}) = $allocglobals(s_1, globaltype*{globaltype : globaltype}, val_G*{val_G : val}))
-    -- if ((s_3, ta*{ta : tableaddr}) = $alloctables(s_2, tabletype*{tabletype : tabletype}, ref_T*{ref_T : ref}))
-    -- if ((s_4, ma*{ma : memaddr}) = $allocmems(s_3, memtype*{memtype : memtype}))
-    -- if ((s_5, ea*{ea : elemaddr}) = $allocelems(s_4, elemtype*{elemtype : elemtype}, ref_E*{ref_E : ref}*{ref_E : ref}))
-    -- if ((s_6, da*{da : dataaddr}) = $allocdatas(s_5, OK_datatype^|data*{data : data}|{}, byte*{byte : byte}*{byte : byte}))
-    -- if (xi*{xi : exportinst} = $allocexports({TYPES [], FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, ELEMS [], DATAS [], EXPORTS []}, export*{export : export}))
-    -- if (moduleinst = {TYPES dt*{dt : deftype}, FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, ELEMS ea*{ea : elemaddr}, DATAS da*{da : dataaddr}, EXPORTS xi*{xi : exportinst}})
+    -- if ((s_1, fa*{fa : nat}) = $allocfuncs(s, dt*{dt : deftype}[x!`%`_idx.0]*{x : idx}, FUNC_funccode(x, local*{local : local}, expr_F)*{expr_F : expr, local : local, x : typeidx}, moduleinst^|func*{func : func}|{}))
+    -- if ((s_2, ga*{ga : nat}) = $allocglobals(s_1, globaltype*{globaltype : globaltype}, val_G*{val_G : val}))
+    -- if ((s_3, ta*{ta : nat}) = $alloctables(s_2, tabletype*{tabletype : tabletype}, ref_T*{ref_T : ref}))
+    -- if ((s_4, ma*{ma : nat}) = $allocmems(s_3, memtype*{memtype : memtype}))
+    -- if ((s_5, aa*{aa : nat}) = $alloctags(s_4, dt*{dt : deftype}[y!`%`_idx.0]*{y : idx}))
+    -- if ((s_6, ea*{ea : nat}) = $allocelems(s_5, elemtype*{elemtype : elemtype}, ref_E*{ref_E : ref}*{ref_E : ref}))
+    -- if ((s_7, da*{da : nat}) = $allocdatas(s_6, OK_datatype^|data*{data : data}|{}, byte*{byte : byte}*{byte : byte}))
+    -- if (xi*{xi : exportinst} = $allocexports({TYPES [], FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, TAGS aa_I*{aa_I : tagaddr} :: aa*{aa : tagaddr}, ELEMS [], DATAS [], EXPORTS []}, export*{export : export}))
+    -- if (moduleinst = {TYPES dt*{dt : deftype}, FUNCS fa_I*{fa_I : funcaddr} :: fa*{fa : funcaddr}, GLOBALS ga_I*{ga_I : globaladdr} :: ga*{ga : globaladdr}, TABLES ta_I*{ta_I : tableaddr} :: ta*{ta : tableaddr}, MEMS ma_I*{ma_I : memaddr} :: ma*{ma : memaddr}, TAGS aa_I*{aa_I : tagaddr} :: aa*{aa : tagaddr}, ELEMS ea*{ea : elemaddr}, DATAS da*{da : dataaddr}, EXPORTS xi*{xi : exportinst}})
 
 ;; 9-module.watsup
 def $runelem_(elemidx : elemidx, elem : elem) : instr*
@@ -30599,11 +32010,11 @@ def $rundata_(dataidx : dataidx, data : data) : instr*
 ;; 9-module.watsup
 rec {
 
-;; 9-module.watsup:152.1-152.94
+;; 9-module.watsup:169.1-169.94
 def $evalglobals(state : state, globaltype*, expr*) : (state, val*)
-  ;; 9-module.watsup:153.1-153.41
+  ;; 9-module.watsup:170.1-170.41
   def $evalglobals{z : state}(z, [], []) = (z, [])
-  ;; 9-module.watsup:154.1-159.81
+  ;; 9-module.watsup:171.1-176.81
   def $evalglobals{z : state, gt : globaltype, gt'* : globaltype*, expr : expr, expr'* : expr*, z' : state, val : val, val'* : val*, s : store, f : frame, s' : store, a : addr}(z, [gt] :: gt'*{gt' : globaltype}, [expr] :: expr'*{expr' : expr}) = (z', [val] :: val'*{val' : val})
     -- Eval_expr: `%;%~>*%;%`(z, expr, z, [val])
     -- if (z = `%;%`_state(s, f))
@@ -30612,23 +32023,23 @@ def $evalglobals(state : state, globaltype*, expr*) : (state, val*)
 }
 
 ;; 9-module.watsup
-def $instantiate(store : store, module : module, externval*) : config
+def $instantiate(store : store, module : module, externaddr*) : config
   ;; 9-module.watsup
-  def $instantiate{s : store, module : module, externval* : externval*, s' : store, f : frame, instr_E* : instr*, instr_D* : instr*, instr_S? : instr?, xt_I* : externtype*, xt_E* : externtype*, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, elem* : elem*, data* : data*, start? : start?, export* : export*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, reftype* : reftype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, x? : idx?, moduleinst_0 : moduleinst, i_F^|func*{func : func}| : nat^|func*{func : func}|, z : state, z' : state, val_G* : val*, ref_T* : ref*, ref_E** : ref**, moduleinst : moduleinst, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, i_D^|data*{data : data}| : nat^|data*{data : data}|}(s, module, externval*{externval : externval}) = `%;%`_config(`%;%`_state(s', f), instr_E*{instr_E : instr} :: instr_D*{instr_D : instr} :: instr_S?{instr_S : instr})
+  def $instantiate{s : store, module : module, externaddr* : externaddr*, s' : store, f : frame, instr_E* : instr*, instr_D* : instr*, instr_S? : instr?, xt_I* : externtype*, xt_E* : externtype*, type* : type*, import* : import*, func* : func*, global* : global*, table* : table*, mem* : mem*, tag* : tag*, elem* : elem*, data* : data*, start? : start?, export* : export*, globaltype* : globaltype*, expr_G* : expr*, tabletype* : tabletype*, expr_T* : expr*, reftype* : reftype*, expr_E** : expr**, elemmode* : elemmode*, byte** : byte**, datamode* : datamode*, x? : idx?, moduleinst_0 : moduleinst, i_F^|func*{func : func}| : nat^|func*{func : func}|, z : state, z' : state, val_G* : val*, ref_T* : ref*, ref_E** : ref**, moduleinst : moduleinst, i_E^|elem*{elem : elem}| : nat^|elem*{elem : elem}|, i_D^|data*{data : data}| : nat^|data*{data : data}|}(s, module, externaddr*{externaddr : externaddr}) = `%;%`_config(`%;%`_state(s', f), instr_E*{instr_E : instr} :: instr_D*{instr_D : instr} :: instr_S?{instr_S : instr})
     -- Module_ok: `|-%:%`(module, `%->%`_moduletype(xt_I*{xt_I : externtype}, xt_E*{xt_E : externtype}))
-    -- (Externval_type: `%|-%:%`(s, externval, xt_I))*{externval : externval, xt_I : externtype}
-    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
+    -- (Externaddr_type: `%|-%:%`(s, externaddr, xt_I))*{externaddr : externaddr, xt_I : externtype}
+    -- if (module = MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export}))
     -- if (global*{global : global} = GLOBAL_global(globaltype, expr_G)*{expr_G : expr, globaltype : globaltype})
     -- if (table*{table : table} = TABLE_table(tabletype, expr_T)*{expr_T : expr, tabletype : tabletype})
     -- if (elem*{elem : elem} = ELEM_elem(reftype, expr_E*{expr_E : expr}, elemmode)*{elemmode : elemmode, expr_E : expr, reftype : reftype})
     -- if (data*{data : data} = DATA_data(byte*{byte : byte}, datamode)*{byte : byte, datamode : datamode})
     -- if (start?{start : start} = START_start(x)?{x : funcidx})
-    -- if (moduleinst_0 = {TYPES $alloctypes(type*{type : type}), FUNCS $funcsxv(externval*{externval : externval}) :: (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat}, GLOBALS $globalsxv(externval*{externval : externval}), TABLES [], MEMS [], ELEMS [], DATAS [], EXPORTS []})
+    -- if (moduleinst_0 = {TYPES $alloctypes(type*{type : type}), FUNCS $funcsxa(externaddr*{externaddr : externaddr}) :: (|s.FUNCS_store| + i_F)^(i_F<|func*{func : func}|){i_F : nat}, GLOBALS $globalsxa(externaddr*{externaddr : externaddr}), TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], EXPORTS []})
     -- if (z = `%;%`_state(s, {LOCALS [], MODULE moduleinst_0}))
     -- if ((z', val_G*{val_G : val}) = $evalglobals(z, globaltype*{globaltype : globaltype}, expr_G*{expr_G : expr}))
     -- (Eval_expr: `%;%~>*%;%`(z', expr_T, z', [(ref_T : ref <: val)]))*{expr_T : expr, ref_T : ref}
     -- (Eval_expr: `%;%~>*%;%`(z', expr_E, z', [(ref_E : ref <: val)]))*{expr_E : expr, ref_E : ref}*{expr_E : expr, ref_E : ref}
-    -- if ((s', moduleinst) = $allocmodule(s, module, externval*{externval : externval}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}))
+    -- if ((s', moduleinst) = $allocmodule(s, module, externaddr*{externaddr : externaddr}, val_G*{val_G : val}, ref_T*{ref_T : ref}, ref_E*{ref_E : ref}*{ref_E : ref}))
     -- if (f = {LOCALS [], MODULE moduleinst})
     -- if (instr_E*{instr_E : instr} = $concat_(syntax instr, $runelem_(`%`_elemidx(i_E), elem*{elem : elem}[i_E])^(i_E<|elem*{elem : elem}|){i_E : nat}))
     -- if (instr_D*{instr_D : instr} = $concat_(syntax instr, $rundata_(`%`_dataidx(i_D), data*{data : data}[i_D])^(i_D<|data*{data : data}|){i_D : nat}))
@@ -30640,7 +32051,7 @@ def $invoke(store : store, funcaddr : funcaddr, val*) : config
   def $invoke{s : store, funcaddr : funcaddr, val* : val*, f : frame, t_1* : valtype*, t_2* : valtype*}(s, funcaddr, val*{val : val}) = `%;%`_config(`%;%`_state(s, f), (val : val <: instr)*{val : val} :: [REF.FUNC_ADDR_instr(funcaddr) CALL_REF_instr((s.FUNCS_store[funcaddr].TYPE_funcinst : deftype <: typeuse))])
     -- Expand: `%~~%`(s.FUNCS_store[funcaddr].TYPE_funcinst, FUNC_comptype(`%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype}))))
     -- (Val_type: `%|-%:%`(s, val, t_1))*{t_1 : valtype, val : val}
-    -- if (f = {LOCALS [], MODULE {TYPES [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], EXPORTS []}})
+    -- if (f = {LOCALS [], MODULE {TYPES [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], EXPORTS []}})
 
 ;; A-binary.watsup
 grammar Bbyte : byte
@@ -30743,6 +32154,11 @@ grammar Bmemidx : memidx
   ;; A-binary.watsup
   prod{x : idx} x:Bu32 => x
 
+;; A-binary.watsup
+grammar Btagidx : tagidx
+  ;; A-binary.watsup
+  prod{x : idx} x:Bu32 => x
+
 ;; A-binary.watsup
 grammar Belemidx : elemidx
   ;; A-binary.watsup
@@ -30773,6 +32189,8 @@ grammar Bexternidx : externidx
   prod{x : idx} {0x02 x:Bmemidx} => MEM_externidx(x)
   ;; A-binary.watsup
   prod{x : idx} {0x03 x:Bglobalidx} => GLOBAL_externidx(x)
+  ;; A-binary.watsup
+  prod{x : idx} {0x04 x:Btagidx} => TAG_externidx(x)
 
 ;; A-binary.watsup
 grammar Bnumtype : numtype
@@ -30792,6 +32210,8 @@ grammar Bvectype : vectype
 
 ;; A-binary.watsup
 grammar Babsheaptype : heaptype
+  ;; A-binary.watsup
+  prod 0x69 => EXN_heaptype
   ;; A-binary.watsup
   prod 0x6A => ARRAY_heaptype
   ;; A-binary.watsup
@@ -30812,6 +32232,8 @@ grammar Babsheaptype : heaptype
   prod 0x72 => NOEXTERN_heaptype
   ;; A-binary.watsup
   prod 0x73 => NOFUNC_heaptype
+  ;; A-binary.watsup
+  prod 0x74 => NOEXN_heaptype
 
 ;; A-binary.watsup
 grammar Bheaptype : heaptype
@@ -30917,6 +32339,11 @@ grammar Bmemtype : memtype
   ;; A-binary.watsup
   prod{lim : limits} lim:Blimits => `%PAGE`_memtype(lim)
 
+;; A-binary.watsup
+grammar Btagtype : typeidx
+  ;; A-binary.watsup
+  prod{x : idx} {0x00 x:Btypeidx} => x
+
 ;; A-binary.watsup
 grammar Bexterntype : externtype
   ;; A-binary.watsup
@@ -30927,6 +32354,8 @@ grammar Bexterntype : externtype
   prod{mt : memtype} {0x02 mt:Bmemtype} => MEM_externtype(mt)
   ;; A-binary.watsup
   prod{gt : globaltype} {0x03 gt:Bglobaltype} => GLOBAL_externtype(gt)
+  ;; A-binary.watsup
+  prod{x : idx} {0x04 x:Btagtype} => TAG_externtype(($idx(x) : typevar <: typeuse))
 
 ;; A-binary.watsup
 grammar Bblocktype : blocktype
@@ -30938,6 +32367,17 @@ grammar Bblocktype : blocktype
   prod{i : nat} `%`_s33((i : nat <: int)):Bs33 => _IDX_blocktype(`%`_funcidx(i))
     -- if (i >= 0)
 
+;; A-binary.watsup
+grammar Bcatch : catch
+  ;; A-binary.watsup
+  prod{x : idx, l : labelidx} {0x00 x:Btagidx l:Blabelidx} => CATCH_catch(x, l)
+  ;; A-binary.watsup
+  prod{x : idx, l : labelidx} {0x01 x:Btagidx l:Blabelidx} => CATCH_REF_catch(x, l)
+  ;; A-binary.watsup
+  prod{l : labelidx} {0x02 l:Blabelidx} => CATCH_ALL_catch(l)
+  ;; A-binary.watsup
+  prod{l : labelidx} {0x03 l:Blabelidx} => CATCH_ALL_REF_catch(l)
+
 ;; A-binary.watsup
 syntax castop = (nul, nul)
 
@@ -30972,953 +32412,959 @@ grammar Blaneidx : laneidx
 ;; A-binary.watsup
 rec {
 
-;; A-binary.watsup:963.1-973.66
+;; A-binary.watsup:981.1-991.66
 grammar Binstr : instr
-  ;; A-binary.watsup:206.5-206.24
+  ;; A-binary.watsup:214.5-214.24
   prod 0x00 => UNREACHABLE_instr
-  ;; A-binary.watsup:207.5-207.16
+  ;; A-binary.watsup:215.5-215.16
   prod 0x01 => NOP_instr
-  ;; A-binary.watsup:208.5-208.57
+  ;; A-binary.watsup:216.5-216.57
   prod{bt : blocktype, in* : instr*} {0x02 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => BLOCK_instr(bt, in*{in : instr})
-  ;; A-binary.watsup:209.5-209.56
+  ;; A-binary.watsup:217.5-217.56
   prod{bt : blocktype, in* : instr*} {0x03 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => LOOP_instr(bt, in*{in : instr})
-  ;; A-binary.watsup:210.5-210.63
+  ;; A-binary.watsup:218.5-218.63
   prod{bt : blocktype, in* : instr*} {0x04 bt:Bblocktype in:Binstr*{in : instr} 0x0B} => `IF%%ELSE%`_instr(bt, in*{in : instr}, [])
-  ;; A-binary.watsup:211.5-215.55
+  ;; A-binary.watsup:219.5-223.55
   prod{bt : blocktype, in_1* : instr*, in_2* : instr*} {0x04 bt:Bblocktype in_1:Binstr*{in_1 : instr} 0x05 in_2:Binstr*{in_2 : instr} 0x0B} => `IF%%ELSE%`_instr(bt, in_1*{in_1 : instr}, in_2*{in_2 : instr})
-  ;; A-binary.watsup:216.5-216.29
+  ;; A-binary.watsup:224.5-224.30
+  prod{x : idx} {0x08 x:Btagidx} => THROW_instr(x)
+  ;; A-binary.watsup:225.5-225.22
+  prod 0x0A => THROW_REF_instr
+  ;; A-binary.watsup:226.5-226.29
   prod{l : labelidx} {0x0C l:Blabelidx} => BR_instr(l)
-  ;; A-binary.watsup:217.5-217.32
+  ;; A-binary.watsup:227.5-227.32
   prod{l : labelidx} {0x0D l:Blabelidx} => BR_IF_instr(l)
-  ;; A-binary.watsup:218.5-218.62
+  ;; A-binary.watsup:228.5-228.62
   prod{l* : labelidx*, l_n : labelidx} {0x0E l*{l : labelidx}:Blist(syntax labelidx, grammar Blabelidx) l_n:Blabelidx} => BR_TABLE_instr(l*{l : labelidx}, l_n)
-  ;; A-binary.watsup:219.5-219.19
+  ;; A-binary.watsup:229.5-229.19
   prod 0x0F => RETURN_instr
-  ;; A-binary.watsup:220.5-220.30
+  ;; A-binary.watsup:230.5-230.30
   prod{x : idx} {0x10 x:Bfuncidx} => CALL_instr(x)
-  ;; A-binary.watsup:221.5-221.59
+  ;; A-binary.watsup:231.5-231.59
   prod{y : idx, x : idx} {0x11 y:Btypeidx x:Btableidx} => CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse))
-  ;; A-binary.watsup:222.5-222.37
+  ;; A-binary.watsup:232.5-232.37
   prod{x : idx} {0x12 x:Bfuncidx} => RETURN_CALL_instr(x)
-  ;; A-binary.watsup:223.5-223.66
+  ;; A-binary.watsup:233.5-233.66
   prod{y : idx, x : idx} {0x13 y:Btypeidx x:Btableidx} => RETURN_CALL_INDIRECT_instr(x, ($idx(y) : typevar <: typeuse))
-  ;; A-binary.watsup:238.5-238.37
+  ;; A-binary.watsup:234.5-235.26
+  prod{bt : blocktype, c* : catch*, in* : instr*} {0x1F bt:Bblocktype c*{c : catch}:Blist(syntax catch, grammar Bcatch) in:Binstr*{in : instr} 0x0B} => TRY_TABLE_instr(bt, `%`_list(c*{c : catch}), in*{in : instr})
+  ;; A-binary.watsup:256.5-256.37
   prod{ht : heaptype} {0xD0 ht:Bheaptype} => REF.NULL_instr(ht)
-  ;; A-binary.watsup:239.5-239.24
+  ;; A-binary.watsup:257.5-257.24
   prod 0xD1 => REF.IS_NULL_instr
-  ;; A-binary.watsup:240.5-240.34
+  ;; A-binary.watsup:258.5-258.34
   prod{x : idx} {0xD2 x:Bfuncidx} => REF.FUNC_instr(x)
-  ;; A-binary.watsup:241.5-241.19
+  ;; A-binary.watsup:259.5-259.19
   prod 0xD3 => REF.EQ_instr
-  ;; A-binary.watsup:242.5-242.28
+  ;; A-binary.watsup:260.5-260.28
   prod 0xD4 => REF.AS_NON_NULL_instr
-  ;; A-binary.watsup:243.5-243.37
+  ;; A-binary.watsup:261.5-261.37
   prod{l : labelidx} {0xD5 l:Blabelidx} => BR_ON_NULL_instr(l)
-  ;; A-binary.watsup:244.5-244.41
+  ;; A-binary.watsup:262.5-262.41
   prod{l : labelidx} {0xD6 l:Blabelidx} => BR_ON_NON_NULL_instr(l)
-  ;; A-binary.watsup:248.5-248.43
+  ;; A-binary.watsup:266.5-266.43
   prod{x : idx} {0xFB `%`_u32(0):Bu32 x:Btypeidx} => STRUCT.NEW_instr(x)
-  ;; A-binary.watsup:249.5-249.51
+  ;; A-binary.watsup:267.5-267.51
   prod{x : idx} {0xFB `%`_u32(1):Bu32 x:Btypeidx} => STRUCT.NEW_DEFAULT_instr(x)
-  ;; A-binary.watsup:250.5-250.52
+  ;; A-binary.watsup:268.5-268.52
   prod{x : idx, i : nat} {0xFB `%`_u32(2):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(), x, `%`_u32(i))
-  ;; A-binary.watsup:251.5-251.54
+  ;; A-binary.watsup:269.5-269.54
   prod{x : idx, i : nat} {0xFB `%`_u32(3):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(S_sx), x, `%`_u32(i))
-  ;; A-binary.watsup:252.5-252.54
+  ;; A-binary.watsup:270.5-270.54
   prod{x : idx, i : nat} {0xFB `%`_u32(4):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.GET_instr(?(U_sx), x, `%`_u32(i))
-  ;; A-binary.watsup:253.5-253.52
+  ;; A-binary.watsup:271.5-271.52
   prod{x : idx, i : nat} {0xFB `%`_u32(5):Bu32 x:Btypeidx `%`_u32(i):Bu32} => STRUCT.SET_instr(x, `%`_u32(i))
-  ;; A-binary.watsup:257.5-257.42
+  ;; A-binary.watsup:275.5-275.42
   prod{x : idx} {0xFB `%`_u32(6):Bu32 x:Btypeidx} => ARRAY.NEW_instr(x)
-  ;; A-binary.watsup:258.5-258.50
+  ;; A-binary.watsup:276.5-276.50
   prod{x : idx} {0xFB `%`_u32(7):Bu32 x:Btypeidx} => ARRAY.NEW_DEFAULT_instr(x)
-  ;; A-binary.watsup:259.5-259.57
+  ;; A-binary.watsup:277.5-277.57
   prod{x : idx, n : n} {0xFB `%`_u32(8):Bu32 x:Btypeidx `%`_u32(n):Bu32} => ARRAY.NEW_FIXED_instr(x, `%`_u32(n))
-  ;; A-binary.watsup:260.5-260.60
+  ;; A-binary.watsup:278.5-278.60
   prod{x : idx, y : idx} {0xFB `%`_u32(9):Bu32 x:Btypeidx y:Bdataidx} => ARRAY.NEW_DATA_instr(x, y)
-  ;; A-binary.watsup:261.5-261.61
+  ;; A-binary.watsup:279.5-279.61
   prod{x : idx, y : idx} {0xFB `%`_u32(10):Bu32 x:Btypeidx y:Belemidx} => ARRAY.NEW_ELEM_instr(x, y)
-  ;; A-binary.watsup:262.5-262.43
+  ;; A-binary.watsup:280.5-280.43
   prod{x : idx} {0xFB `%`_u32(11):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(), x)
-  ;; A-binary.watsup:263.5-263.45
+  ;; A-binary.watsup:281.5-281.45
   prod{x : idx} {0xFB `%`_u32(12):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(S_sx), x)
-  ;; A-binary.watsup:264.5-264.45
+  ;; A-binary.watsup:282.5-282.45
   prod{x : idx} {0xFB `%`_u32(13):Bu32 x:Btypeidx} => ARRAY.GET_instr(?(U_sx), x)
-  ;; A-binary.watsup:265.5-265.43
+  ;; A-binary.watsup:283.5-283.43
   prod{x : idx} {0xFB `%`_u32(14):Bu32 x:Btypeidx} => ARRAY.SET_instr(x)
-  ;; A-binary.watsup:266.5-266.30
+  ;; A-binary.watsup:284.5-284.30
   prod {0xFB `%`_u32(15):Bu32} => ARRAY.LEN_instr
-  ;; A-binary.watsup:267.5-267.44
+  ;; A-binary.watsup:285.5-285.44
   prod{x : idx} {0xFB `%`_u32(16):Bu32 x:Btypeidx} => ARRAY.FILL_instr(x)
-  ;; A-binary.watsup:268.5-268.65
+  ;; A-binary.watsup:286.5-286.65
   prod{x_1 : idx, x_2 : idx} {0xFB `%`_u32(17):Bu32 x_1:Btypeidx x_2:Btypeidx} => ARRAY.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:269.5-269.62
+  ;; A-binary.watsup:287.5-287.62
   prod{x : idx, y : idx} {0xFB `%`_u32(18):Bu32 x:Btypeidx y:Bdataidx} => ARRAY.INIT_DATA_instr(x, y)
-  ;; A-binary.watsup:270.5-270.62
+  ;; A-binary.watsup:288.5-288.62
   prod{x : idx, y : idx} {0xFB `%`_u32(19):Bu32 x:Btypeidx y:Belemidx} => ARRAY.INIT_ELEM_instr(x, y)
-  ;; A-binary.watsup:274.5-274.51
+  ;; A-binary.watsup:292.5-292.51
   prod{ht : heaptype} {0xFB `%`_u32(20):Bu32 ht:Bheaptype} => REF.TEST_instr(REF_reftype(`NULL%?`_nul(?()), ht))
-  ;; A-binary.watsup:275.5-275.56
+  ;; A-binary.watsup:293.5-293.56
   prod{ht : heaptype} {0xFB `%`_u32(21):Bu32 ht:Bheaptype} => REF.TEST_instr(REF_reftype(`NULL%?`_nul(?(())), ht))
-  ;; A-binary.watsup:276.5-276.51
+  ;; A-binary.watsup:294.5-294.51
   prod{ht : heaptype} {0xFB `%`_u32(22):Bu32 ht:Bheaptype} => REF.CAST_instr(REF_reftype(`NULL%?`_nul(?()), ht))
-  ;; A-binary.watsup:277.5-277.56
+  ;; A-binary.watsup:295.5-295.56
   prod{ht : heaptype} {0xFB `%`_u32(23):Bu32 ht:Bheaptype} => REF.CAST_instr(REF_reftype(`NULL%?`_nul(?(())), ht))
-  ;; A-binary.watsup:278.5-282.94
+  ;; A-binary.watsup:296.5-300.94
   prod{nul1 : nul1, nul2 : nul2, l : labelidx, ht_1 : heaptype, ht_2 : heaptype} {0xFB `%`_u32(24):Bu32 (nul1, nul2):Bcastop l:Blabelidx ht_1:Bheaptype ht_2:Bheaptype} => BR_ON_CAST_instr(l, REF_reftype(nul1, ht_1), REF_reftype(nul2, ht_2))
-  ;; A-binary.watsup:283.5-287.99
+  ;; A-binary.watsup:301.5-305.99
   prod{nul1 : nul1, nul2 : nul2, l : labelidx, ht_1 : heaptype, ht_2 : heaptype} {0xFB `%`_u32(25):Bu32 (nul1, nul2):Bcastop l:Blabelidx ht_1:Bheaptype ht_2:Bheaptype} => BR_ON_CAST_FAIL_instr(l, REF_reftype(nul1, ht_1), REF_reftype(nul2, ht_2))
-  ;; A-binary.watsup:291.5-291.39
+  ;; A-binary.watsup:309.5-309.39
   prod {0xFB `%`_u32(26):Bu32} => ANY.CONVERT_EXTERN_instr
-  ;; A-binary.watsup:292.5-292.39
+  ;; A-binary.watsup:310.5-310.39
   prod {0xFB `%`_u32(27):Bu32} => EXTERN.CONVERT_ANY_instr
-  ;; A-binary.watsup:296.5-296.28
+  ;; A-binary.watsup:314.5-314.28
   prod {0xFB `%`_u32(28):Bu32} => REF.I31_instr
-  ;; A-binary.watsup:297.5-297.30
+  ;; A-binary.watsup:315.5-315.30
   prod {0xFB `%`_u32(29):Bu32} => I31.GET_instr(S_sx)
-  ;; A-binary.watsup:298.5-298.30
+  ;; A-binary.watsup:316.5-316.30
   prod {0xFB `%`_u32(30):Bu32} => I31.GET_instr(U_sx)
-  ;; A-binary.watsup:305.5-305.17
+  ;; A-binary.watsup:323.5-323.17
   prod 0x1A => DROP_instr
-  ;; A-binary.watsup:306.5-306.19
+  ;; A-binary.watsup:324.5-324.19
   prod 0x1B => `SELECT()%?`_instr(?())
-  ;; A-binary.watsup:307.5-307.41
+  ;; A-binary.watsup:325.5-325.41
   prod{ts : valtype} {0x1C [ts]:Blist(syntax valtype, grammar Bvaltype)} => `SELECT()%?`_instr(?([ts]))
-  ;; A-binary.watsup:314.5-314.36
+  ;; A-binary.watsup:332.5-332.36
   prod{x : idx} {0x20 x:Blocalidx} => LOCAL.GET_instr(x)
-  ;; A-binary.watsup:315.5-315.36
+  ;; A-binary.watsup:333.5-333.36
   prod{x : idx} {0x21 x:Blocalidx} => LOCAL.SET_instr(x)
-  ;; A-binary.watsup:316.5-316.36
+  ;; A-binary.watsup:334.5-334.36
   prod{x : idx} {0x22 x:Blocalidx} => LOCAL.TEE_instr(x)
-  ;; A-binary.watsup:320.5-320.38
+  ;; A-binary.watsup:338.5-338.38
   prod{x : idx} {0x23 x:Bglobalidx} => GLOBAL.GET_instr(x)
-  ;; A-binary.watsup:321.5-321.38
+  ;; A-binary.watsup:339.5-339.38
   prod{x : idx} {0x24 x:Bglobalidx} => GLOBAL.SET_instr(x)
-  ;; A-binary.watsup:328.5-328.36
+  ;; A-binary.watsup:346.5-346.36
   prod{x : idx} {0x25 x:Btableidx} => TABLE.GET_instr(x)
-  ;; A-binary.watsup:329.5-329.36
+  ;; A-binary.watsup:347.5-347.36
   prod{x : idx} {0x26 x:Btableidx} => TABLE.SET_instr(x)
-  ;; A-binary.watsup:330.5-330.58
+  ;; A-binary.watsup:348.5-348.58
   prod{y : idx, x : idx} {0xFC `%`_u32(12):Bu32 y:Belemidx x:Btableidx} => TABLE.INIT_instr(x, y)
-  ;; A-binary.watsup:331.5-331.43
+  ;; A-binary.watsup:349.5-349.43
   prod{x : idx} {0xFC `%`_u32(13):Bu32 x:Belemidx} => ELEM.DROP_instr(x)
-  ;; A-binary.watsup:332.5-332.67
+  ;; A-binary.watsup:350.5-350.67
   prod{x_1 : idx, x_2 : idx} {0xFC `%`_u32(14):Bu32 x_1:Btableidx x_2:Btableidx} => TABLE.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:333.5-333.45
+  ;; A-binary.watsup:351.5-351.45
   prod{x : idx} {0xFC `%`_u32(15):Bu32 x:Btableidx} => TABLE.GROW_instr(x)
-  ;; A-binary.watsup:334.5-334.45
+  ;; A-binary.watsup:352.5-352.45
   prod{x : idx} {0xFC `%`_u32(16):Bu32 x:Btableidx} => TABLE.SIZE_instr(x)
-  ;; A-binary.watsup:335.5-335.45
+  ;; A-binary.watsup:353.5-353.45
   prod{x : idx} {0xFC `%`_u32(17):Bu32 x:Btableidx} => TABLE.FILL_instr(x)
-  ;; A-binary.watsup:348.5-348.41
+  ;; A-binary.watsup:366.5-366.41
   prod{x : idx, ao : memarg} {0x28 (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:349.5-349.41
+  ;; A-binary.watsup:367.5-367.41
   prod{x : idx, ao : memarg} {0x29 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:350.5-350.41
+  ;; A-binary.watsup:368.5-368.41
   prod{x : idx, ao : memarg} {0x2A (x, ao):Bmemarg} => LOAD_instr(F32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:351.5-351.41
+  ;; A-binary.watsup:369.5-369.41
   prod{x : idx, ao : memarg} {0x2B (x, ao):Bmemarg} => LOAD_instr(F64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:352.5-352.48
+  ;; A-binary.watsup:370.5-370.48
   prod{x : idx, ao : memarg} {0x2C (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(8), S_sx)), x, ao)
-  ;; A-binary.watsup:353.5-353.48
+  ;; A-binary.watsup:371.5-371.48
   prod{x : idx, ao : memarg} {0x2D (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(8), U_sx)), x, ao)
-  ;; A-binary.watsup:354.5-354.49
+  ;; A-binary.watsup:372.5-372.49
   prod{x : idx, ao : memarg} {0x2E (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(16), S_sx)), x, ao)
-  ;; A-binary.watsup:355.5-355.49
+  ;; A-binary.watsup:373.5-373.49
   prod{x : idx, ao : memarg} {0x2F (x, ao):Bmemarg} => LOAD_instr(I32_numtype, ?(`%%`_loadop_(`%`_sz(16), U_sx)), x, ao)
-  ;; A-binary.watsup:356.5-356.48
+  ;; A-binary.watsup:374.5-374.48
   prod{x : idx, ao : memarg} {0x30 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(8), S_sx)), x, ao)
-  ;; A-binary.watsup:357.5-357.48
+  ;; A-binary.watsup:375.5-375.48
   prod{x : idx, ao : memarg} {0x31 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(8), U_sx)), x, ao)
-  ;; A-binary.watsup:358.5-358.49
+  ;; A-binary.watsup:376.5-376.49
   prod{x : idx, ao : memarg} {0x32 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(16), S_sx)), x, ao)
-  ;; A-binary.watsup:359.5-359.49
+  ;; A-binary.watsup:377.5-377.49
   prod{x : idx, ao : memarg} {0x33 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(16), U_sx)), x, ao)
-  ;; A-binary.watsup:360.5-360.49
+  ;; A-binary.watsup:378.5-378.49
   prod{x : idx, ao : memarg} {0x34 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(32), S_sx)), x, ao)
-  ;; A-binary.watsup:361.5-361.49
+  ;; A-binary.watsup:379.5-379.49
   prod{x : idx, ao : memarg} {0x35 (x, ao):Bmemarg} => LOAD_instr(I64_numtype, ?(`%%`_loadop_(`%`_sz(32), U_sx)), x, ao)
-  ;; A-binary.watsup:362.5-362.42
+  ;; A-binary.watsup:380.5-380.42
   prod{x : idx, ao : memarg} {0x36 (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:363.5-363.42
+  ;; A-binary.watsup:381.5-381.42
   prod{x : idx, ao : memarg} {0x37 (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:364.5-364.42
+  ;; A-binary.watsup:382.5-382.42
   prod{x : idx, ao : memarg} {0x38 (x, ao):Bmemarg} => STORE_instr(F32_numtype, ?(), x, ao)
-  ;; A-binary.watsup:365.5-365.42
+  ;; A-binary.watsup:383.5-383.42
   prod{x : idx, ao : memarg} {0x39 (x, ao):Bmemarg} => STORE_instr(F64_numtype, ?(), x, ao)
-  ;; A-binary.watsup:366.5-366.45
+  ;; A-binary.watsup:384.5-384.45
   prod{x : idx, ao : memarg} {0x3A (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(`%`_sz(8)), x, ao)
-  ;; A-binary.watsup:367.5-367.46
+  ;; A-binary.watsup:385.5-385.46
   prod{x : idx, ao : memarg} {0x3B (x, ao):Bmemarg} => STORE_instr(I32_numtype, ?(`%`_sz(16)), x, ao)
-  ;; A-binary.watsup:368.5-368.45
+  ;; A-binary.watsup:386.5-386.45
   prod{x : idx, ao : memarg} {0x3C (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(8)), x, ao)
-  ;; A-binary.watsup:369.5-369.46
+  ;; A-binary.watsup:387.5-387.46
   prod{x : idx, ao : memarg} {0x3D (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(16)), x, ao)
-  ;; A-binary.watsup:370.5-370.46
+  ;; A-binary.watsup:388.5-388.46
   prod{x : idx, ao : memarg} {0x3E (x, ao):Bmemarg} => STORE_instr(I64_numtype, ?(`%`_sz(32)), x, ao)
-  ;; A-binary.watsup:371.5-371.36
+  ;; A-binary.watsup:389.5-389.36
   prod{x : idx} {0x3F x:Bmemidx} => MEMORY.SIZE_instr(x)
-  ;; A-binary.watsup:372.5-372.36
+  ;; A-binary.watsup:390.5-390.36
   prod{x : idx} {0x40 x:Bmemidx} => MEMORY.GROW_instr(x)
-  ;; A-binary.watsup:373.5-373.56
+  ;; A-binary.watsup:391.5-391.56
   prod{y : idx, x : idx} {0xFC `%`_u32(8):Bu32 y:Bdataidx x:Bmemidx} => MEMORY.INIT_instr(x, y)
-  ;; A-binary.watsup:374.5-374.42
+  ;; A-binary.watsup:392.5-392.42
   prod{x : idx} {0xFC `%`_u32(9):Bu32 x:Bdataidx} => DATA.DROP_instr(x)
-  ;; A-binary.watsup:375.5-375.64
+  ;; A-binary.watsup:393.5-393.64
   prod{x_1 : idx, x_2 : idx} {0xFC `%`_u32(10):Bu32 x_1:Bmemidx x_2:Bmemidx} => MEMORY.COPY_instr(x_1, x_2)
-  ;; A-binary.watsup:376.5-376.44
+  ;; A-binary.watsup:394.5-394.44
   prod{x : idx} {0xFC `%`_u32(11):Bu32 x:Bmemidx} => MEMORY.FILL_instr(x)
-  ;; A-binary.watsup:384.5-384.31
+  ;; A-binary.watsup:402.5-402.31
   prod{n : n} {0x41 `%`_u32(n):Bu32} => CONST_instr(I32_numtype, `%`_num_(n))
-  ;; A-binary.watsup:385.5-385.31
+  ;; A-binary.watsup:403.5-403.31
   prod{n : n} {0x42 `%`_u64(n):Bu64} => CONST_instr(I64_numtype, `%`_num_(n))
-  ;; A-binary.watsup:386.5-386.31
+  ;; A-binary.watsup:404.5-404.31
   prod{p : f32} {0x43 p:Bf32} => CONST_instr(F32_numtype, p)
-  ;; A-binary.watsup:387.5-387.31
+  ;; A-binary.watsup:405.5-405.31
   prod{p : f64} {0x44 p:Bf64} => CONST_instr(F64_numtype, p)
-  ;; A-binary.watsup:391.5-391.27
+  ;; A-binary.watsup:409.5-409.27
   prod 0x45 => TESTOP_instr(I32_numtype, EQZ_testop_)
-  ;; A-binary.watsup:395.5-395.25
+  ;; A-binary.watsup:413.5-413.25
   prod 0x46 => RELOP_instr(I32_numtype, EQ_relop_)
-  ;; A-binary.watsup:396.5-396.25
+  ;; A-binary.watsup:414.5-414.25
   prod 0x47 => RELOP_instr(I32_numtype, NE_relop_)
-  ;; A-binary.watsup:397.5-397.29
+  ;; A-binary.watsup:415.5-415.29
   prod 0x48 => RELOP_instr(I32_numtype, LT_relop_(S_sx))
-  ;; A-binary.watsup:398.5-398.29
+  ;; A-binary.watsup:416.5-416.29
   prod 0x49 => RELOP_instr(I32_numtype, LT_relop_(U_sx))
-  ;; A-binary.watsup:399.5-399.29
+  ;; A-binary.watsup:417.5-417.29
   prod 0x4A => RELOP_instr(I32_numtype, GT_relop_(S_sx))
-  ;; A-binary.watsup:400.5-400.29
+  ;; A-binary.watsup:418.5-418.29
   prod 0x4B => RELOP_instr(I32_numtype, GT_relop_(U_sx))
-  ;; A-binary.watsup:401.5-401.29
+  ;; A-binary.watsup:419.5-419.29
   prod 0x4C => RELOP_instr(I32_numtype, LE_relop_(S_sx))
-  ;; A-binary.watsup:402.5-402.29
+  ;; A-binary.watsup:420.5-420.29
   prod 0x4D => RELOP_instr(I32_numtype, LE_relop_(U_sx))
-  ;; A-binary.watsup:403.5-403.29
+  ;; A-binary.watsup:421.5-421.29
   prod 0x4E => RELOP_instr(I32_numtype, GE_relop_(S_sx))
-  ;; A-binary.watsup:404.5-404.29
+  ;; A-binary.watsup:422.5-422.29
   prod 0x4F => RELOP_instr(I32_numtype, GE_relop_(U_sx))
-  ;; A-binary.watsup:408.5-408.27
+  ;; A-binary.watsup:426.5-426.27
   prod 0x50 => TESTOP_instr(I64_numtype, EQZ_testop_)
-  ;; A-binary.watsup:412.5-412.25
+  ;; A-binary.watsup:430.5-430.25
   prod 0x51 => RELOP_instr(I64_numtype, EQ_relop_)
-  ;; A-binary.watsup:413.5-413.25
+  ;; A-binary.watsup:431.5-431.25
   prod 0x52 => RELOP_instr(I64_numtype, NE_relop_)
-  ;; A-binary.watsup:414.5-414.29
+  ;; A-binary.watsup:432.5-432.29
   prod 0x53 => RELOP_instr(I64_numtype, LT_relop_(S_sx))
-  ;; A-binary.watsup:415.5-415.29
+  ;; A-binary.watsup:433.5-433.29
   prod 0x54 => RELOP_instr(I64_numtype, LT_relop_(U_sx))
-  ;; A-binary.watsup:416.5-416.29
+  ;; A-binary.watsup:434.5-434.29
   prod 0x55 => RELOP_instr(I64_numtype, GT_relop_(S_sx))
-  ;; A-binary.watsup:417.5-417.29
+  ;; A-binary.watsup:435.5-435.29
   prod 0x56 => RELOP_instr(I64_numtype, GT_relop_(U_sx))
-  ;; A-binary.watsup:418.5-418.29
+  ;; A-binary.watsup:436.5-436.29
   prod 0x57 => RELOP_instr(I64_numtype, LE_relop_(S_sx))
-  ;; A-binary.watsup:419.5-419.29
+  ;; A-binary.watsup:437.5-437.29
   prod 0x58 => RELOP_instr(I64_numtype, LE_relop_(U_sx))
-  ;; A-binary.watsup:420.5-420.29
+  ;; A-binary.watsup:438.5-438.29
   prod 0x59 => RELOP_instr(I64_numtype, GE_relop_(S_sx))
-  ;; A-binary.watsup:421.5-421.29
+  ;; A-binary.watsup:439.5-439.29
   prod 0x5A => RELOP_instr(I64_numtype, GE_relop_(U_sx))
-  ;; A-binary.watsup:425.5-425.25
+  ;; A-binary.watsup:443.5-443.25
   prod 0x5B => RELOP_instr(F32_numtype, EQ_relop_)
-  ;; A-binary.watsup:426.5-426.25
+  ;; A-binary.watsup:444.5-444.25
   prod 0x5C => RELOP_instr(F32_numtype, NE_relop_)
-  ;; A-binary.watsup:427.5-427.25
+  ;; A-binary.watsup:445.5-445.25
   prod 0x5D => RELOP_instr(F32_numtype, LT_relop_)
-  ;; A-binary.watsup:428.5-428.25
+  ;; A-binary.watsup:446.5-446.25
   prod 0x5E => RELOP_instr(F32_numtype, GT_relop_)
-  ;; A-binary.watsup:429.5-429.25
+  ;; A-binary.watsup:447.5-447.25
   prod 0x5F => RELOP_instr(F32_numtype, LE_relop_)
-  ;; A-binary.watsup:430.5-430.25
+  ;; A-binary.watsup:448.5-448.25
   prod 0x60 => RELOP_instr(F32_numtype, GE_relop_)
-  ;; A-binary.watsup:434.5-434.25
+  ;; A-binary.watsup:452.5-452.25
   prod 0x61 => RELOP_instr(F64_numtype, EQ_relop_)
-  ;; A-binary.watsup:435.5-435.25
+  ;; A-binary.watsup:453.5-453.25
   prod 0x62 => RELOP_instr(F64_numtype, NE_relop_)
-  ;; A-binary.watsup:436.5-436.25
+  ;; A-binary.watsup:454.5-454.25
   prod 0x63 => RELOP_instr(F64_numtype, LT_relop_)
-  ;; A-binary.watsup:437.5-437.25
+  ;; A-binary.watsup:455.5-455.25
   prod 0x64 => RELOP_instr(F64_numtype, GT_relop_)
-  ;; A-binary.watsup:438.5-438.25
+  ;; A-binary.watsup:456.5-456.25
   prod 0x65 => RELOP_instr(F64_numtype, LE_relop_)
-  ;; A-binary.watsup:439.5-439.25
+  ;; A-binary.watsup:457.5-457.25
   prod 0x66 => RELOP_instr(F64_numtype, GE_relop_)
-  ;; A-binary.watsup:443.5-443.25
+  ;; A-binary.watsup:461.5-461.25
   prod 0x67 => UNOP_instr(I32_numtype, CLZ_unop_)
-  ;; A-binary.watsup:444.5-444.25
+  ;; A-binary.watsup:462.5-462.25
   prod 0x68 => UNOP_instr(I32_numtype, CTZ_unop_)
-  ;; A-binary.watsup:445.5-445.28
+  ;; A-binary.watsup:463.5-463.28
   prod 0x69 => UNOP_instr(I32_numtype, POPCNT_unop_)
-  ;; A-binary.watsup:449.5-449.26
+  ;; A-binary.watsup:467.5-467.26
   prod 0x6A => BINOP_instr(I32_numtype, ADD_binop_)
-  ;; A-binary.watsup:450.5-450.26
+  ;; A-binary.watsup:468.5-468.26
   prod 0x6B => BINOP_instr(I32_numtype, SUB_binop_)
-  ;; A-binary.watsup:451.5-451.26
+  ;; A-binary.watsup:469.5-469.26
   prod 0x6C => BINOP_instr(I32_numtype, MUL_binop_)
-  ;; A-binary.watsup:452.5-452.30
+  ;; A-binary.watsup:470.5-470.30
   prod 0x6D => BINOP_instr(I32_numtype, DIV_binop_(S_sx))
-  ;; A-binary.watsup:453.5-453.30
+  ;; A-binary.watsup:471.5-471.30
   prod 0x6E => BINOP_instr(I32_numtype, DIV_binop_(U_sx))
-  ;; A-binary.watsup:454.5-454.30
+  ;; A-binary.watsup:472.5-472.30
   prod 0x6F => BINOP_instr(I32_numtype, REM_binop_(S_sx))
-  ;; A-binary.watsup:455.5-455.30
+  ;; A-binary.watsup:473.5-473.30
   prod 0x70 => BINOP_instr(I32_numtype, REM_binop_(U_sx))
-  ;; A-binary.watsup:456.5-456.26
+  ;; A-binary.watsup:474.5-474.26
   prod 0x71 => BINOP_instr(I32_numtype, AND_binop_)
-  ;; A-binary.watsup:457.5-457.25
+  ;; A-binary.watsup:475.5-475.25
   prod 0x72 => BINOP_instr(I32_numtype, OR_binop_)
-  ;; A-binary.watsup:458.5-458.26
+  ;; A-binary.watsup:476.5-476.26
   prod 0x73 => BINOP_instr(I32_numtype, XOR_binop_)
-  ;; A-binary.watsup:459.5-459.26
+  ;; A-binary.watsup:477.5-477.26
   prod 0x74 => BINOP_instr(I32_numtype, SHL_binop_)
-  ;; A-binary.watsup:460.5-460.30
+  ;; A-binary.watsup:478.5-478.30
   prod 0x75 => BINOP_instr(I32_numtype, SHR_binop_(S_sx))
-  ;; A-binary.watsup:461.5-461.30
+  ;; A-binary.watsup:479.5-479.30
   prod 0x76 => BINOP_instr(I32_numtype, SHR_binop_(U_sx))
-  ;; A-binary.watsup:462.5-462.27
+  ;; A-binary.watsup:480.5-480.27
   prod 0x77 => BINOP_instr(I32_numtype, ROTL_binop_)
-  ;; A-binary.watsup:463.5-463.27
+  ;; A-binary.watsup:481.5-481.27
   prod 0x78 => BINOP_instr(I32_numtype, ROTR_binop_)
-  ;; A-binary.watsup:467.5-467.25
+  ;; A-binary.watsup:485.5-485.25
   prod 0x79 => UNOP_instr(I64_numtype, CLZ_unop_)
-  ;; A-binary.watsup:468.5-468.25
+  ;; A-binary.watsup:486.5-486.25
   prod 0x7A => UNOP_instr(I64_numtype, CTZ_unop_)
-  ;; A-binary.watsup:469.5-469.28
+  ;; A-binary.watsup:487.5-487.28
   prod 0x7B => UNOP_instr(I64_numtype, POPCNT_unop_)
-  ;; A-binary.watsup:473.5-473.33
+  ;; A-binary.watsup:491.5-491.33
   prod 0xC0 => UNOP_instr(I32_numtype, EXTEND_unop_(`%`_sz(8)))
-  ;; A-binary.watsup:474.5-474.34
+  ;; A-binary.watsup:492.5-492.34
   prod 0xC1 => UNOP_instr(I32_numtype, EXTEND_unop_(`%`_sz(16)))
-  ;; A-binary.watsup:478.5-478.33
+  ;; A-binary.watsup:496.5-496.33
   prod 0xC2 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(8)))
-  ;; A-binary.watsup:479.5-479.34
+  ;; A-binary.watsup:497.5-497.34
   prod 0xC3 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(16)))
-  ;; A-binary.watsup:480.5-480.34
+  ;; A-binary.watsup:498.5-498.34
   prod 0xC4 => UNOP_instr(I64_numtype, EXTEND_unop_(`%`_sz(32)))
-  ;; A-binary.watsup:484.5-484.26
+  ;; A-binary.watsup:502.5-502.26
   prod 0x7C => BINOP_instr(I64_numtype, ADD_binop_)
-  ;; A-binary.watsup:485.5-485.26
+  ;; A-binary.watsup:503.5-503.26
   prod 0x7D => BINOP_instr(I64_numtype, SUB_binop_)
-  ;; A-binary.watsup:486.5-486.26
+  ;; A-binary.watsup:504.5-504.26
   prod 0x7E => BINOP_instr(I64_numtype, MUL_binop_)
-  ;; A-binary.watsup:487.5-487.30
+  ;; A-binary.watsup:505.5-505.30
   prod 0x7F => BINOP_instr(I64_numtype, DIV_binop_(S_sx))
-  ;; A-binary.watsup:488.5-488.30
+  ;; A-binary.watsup:506.5-506.30
   prod 0x80 => BINOP_instr(I64_numtype, DIV_binop_(U_sx))
-  ;; A-binary.watsup:489.5-489.30
+  ;; A-binary.watsup:507.5-507.30
   prod 0x81 => BINOP_instr(I64_numtype, REM_binop_(S_sx))
-  ;; A-binary.watsup:490.5-490.30
+  ;; A-binary.watsup:508.5-508.30
   prod 0x82 => BINOP_instr(I64_numtype, REM_binop_(U_sx))
-  ;; A-binary.watsup:491.5-491.26
+  ;; A-binary.watsup:509.5-509.26
   prod 0x83 => BINOP_instr(I64_numtype, AND_binop_)
-  ;; A-binary.watsup:492.5-492.25
+  ;; A-binary.watsup:510.5-510.25
   prod 0x84 => BINOP_instr(I64_numtype, OR_binop_)
-  ;; A-binary.watsup:493.5-493.26
+  ;; A-binary.watsup:511.5-511.26
   prod 0x85 => BINOP_instr(I64_numtype, XOR_binop_)
-  ;; A-binary.watsup:494.5-494.26
+  ;; A-binary.watsup:512.5-512.26
   prod 0x86 => BINOP_instr(I64_numtype, SHL_binop_)
-  ;; A-binary.watsup:495.5-495.30
+  ;; A-binary.watsup:513.5-513.30
   prod 0x87 => BINOP_instr(I64_numtype, SHR_binop_(S_sx))
-  ;; A-binary.watsup:496.5-496.30
+  ;; A-binary.watsup:514.5-514.30
   prod 0x88 => BINOP_instr(I64_numtype, SHR_binop_(U_sx))
-  ;; A-binary.watsup:497.5-497.27
+  ;; A-binary.watsup:515.5-515.27
   prod 0x89 => BINOP_instr(I64_numtype, ROTL_binop_)
-  ;; A-binary.watsup:498.5-498.27
+  ;; A-binary.watsup:516.5-516.27
   prod 0x8A => BINOP_instr(I64_numtype, ROTR_binop_)
-  ;; A-binary.watsup:502.5-502.25
+  ;; A-binary.watsup:520.5-520.25
   prod 0x8B => UNOP_instr(F32_numtype, ABS_unop_)
-  ;; A-binary.watsup:503.5-503.25
+  ;; A-binary.watsup:521.5-521.25
   prod 0x8C => UNOP_instr(F32_numtype, NEG_unop_)
-  ;; A-binary.watsup:504.5-504.26
+  ;; A-binary.watsup:522.5-522.26
   prod 0x8D => UNOP_instr(F32_numtype, CEIL_unop_)
-  ;; A-binary.watsup:505.5-505.27
+  ;; A-binary.watsup:523.5-523.27
   prod 0x8E => UNOP_instr(F32_numtype, FLOOR_unop_)
-  ;; A-binary.watsup:506.5-506.27
+  ;; A-binary.watsup:524.5-524.27
   prod 0x8F => UNOP_instr(F32_numtype, TRUNC_unop_)
-  ;; A-binary.watsup:507.5-507.29
+  ;; A-binary.watsup:525.5-525.29
   prod 0x90 => UNOP_instr(F32_numtype, NEAREST_unop_)
-  ;; A-binary.watsup:508.5-508.26
+  ;; A-binary.watsup:526.5-526.26
   prod 0x91 => UNOP_instr(F32_numtype, SQRT_unop_)
-  ;; A-binary.watsup:512.5-512.26
+  ;; A-binary.watsup:530.5-530.26
   prod 0x92 => BINOP_instr(F32_numtype, ADD_binop_)
-  ;; A-binary.watsup:513.5-513.26
+  ;; A-binary.watsup:531.5-531.26
   prod 0x93 => BINOP_instr(F32_numtype, SUB_binop_)
-  ;; A-binary.watsup:514.5-514.26
+  ;; A-binary.watsup:532.5-532.26
   prod 0x94 => BINOP_instr(F32_numtype, MUL_binop_)
-  ;; A-binary.watsup:515.5-515.26
+  ;; A-binary.watsup:533.5-533.26
   prod 0x95 => BINOP_instr(F32_numtype, DIV_binop_)
-  ;; A-binary.watsup:516.5-516.26
+  ;; A-binary.watsup:534.5-534.26
   prod 0x96 => BINOP_instr(F32_numtype, MIN_binop_)
-  ;; A-binary.watsup:517.5-517.26
+  ;; A-binary.watsup:535.5-535.26
   prod 0x97 => BINOP_instr(F32_numtype, MAX_binop_)
-  ;; A-binary.watsup:518.5-518.31
+  ;; A-binary.watsup:536.5-536.31
   prod 0x98 => BINOP_instr(F32_numtype, COPYSIGN_binop_)
-  ;; A-binary.watsup:522.5-522.25
+  ;; A-binary.watsup:540.5-540.25
   prod 0x99 => UNOP_instr(F64_numtype, ABS_unop_)
-  ;; A-binary.watsup:523.5-523.25
+  ;; A-binary.watsup:541.5-541.25
   prod 0x9A => UNOP_instr(F64_numtype, NEG_unop_)
-  ;; A-binary.watsup:524.5-524.26
+  ;; A-binary.watsup:542.5-542.26
   prod 0x9B => UNOP_instr(F64_numtype, CEIL_unop_)
-  ;; A-binary.watsup:525.5-525.27
+  ;; A-binary.watsup:543.5-543.27
   prod 0x9C => UNOP_instr(F64_numtype, FLOOR_unop_)
-  ;; A-binary.watsup:526.5-526.27
+  ;; A-binary.watsup:544.5-544.27
   prod 0x9D => UNOP_instr(F64_numtype, TRUNC_unop_)
-  ;; A-binary.watsup:527.5-527.29
+  ;; A-binary.watsup:545.5-545.29
   prod 0x9E => UNOP_instr(F64_numtype, NEAREST_unop_)
-  ;; A-binary.watsup:528.5-528.26
+  ;; A-binary.watsup:546.5-546.26
   prod 0x9F => UNOP_instr(F64_numtype, SQRT_unop_)
-  ;; A-binary.watsup:532.5-532.26
+  ;; A-binary.watsup:550.5-550.26
   prod 0xA0 => BINOP_instr(F64_numtype, ADD_binop_)
-  ;; A-binary.watsup:533.5-533.26
+  ;; A-binary.watsup:551.5-551.26
   prod 0xA1 => BINOP_instr(F64_numtype, SUB_binop_)
-  ;; A-binary.watsup:534.5-534.26
+  ;; A-binary.watsup:552.5-552.26
   prod 0xA2 => BINOP_instr(F64_numtype, MUL_binop_)
-  ;; A-binary.watsup:535.5-535.26
+  ;; A-binary.watsup:553.5-553.26
   prod 0xA3 => BINOP_instr(F64_numtype, DIV_binop_)
-  ;; A-binary.watsup:536.5-536.26
+  ;; A-binary.watsup:554.5-554.26
   prod 0xA4 => BINOP_instr(F64_numtype, MIN_binop_)
-  ;; A-binary.watsup:537.5-537.26
+  ;; A-binary.watsup:555.5-555.26
   prod 0xA5 => BINOP_instr(F64_numtype, MAX_binop_)
-  ;; A-binary.watsup:538.5-538.31
+  ;; A-binary.watsup:556.5-556.31
   prod 0xA6 => BINOP_instr(F64_numtype, COPYSIGN_binop_)
-  ;; A-binary.watsup:543.5-543.31
+  ;; A-binary.watsup:561.5-561.31
   prod 0xA7 => CVTOP_instr(I32_numtype, I64_numtype, WRAP_cvtop__)
-  ;; A-binary.watsup:544.5-544.36
+  ;; A-binary.watsup:562.5-562.36
   prod 0xA8 => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:545.5-545.36
+  ;; A-binary.watsup:563.5-563.36
   prod 0xA9 => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:546.5-546.36
+  ;; A-binary.watsup:564.5-564.36
   prod 0xAA => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:547.5-547.36
+  ;; A-binary.watsup:565.5-565.36
   prod 0xAB => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:548.5-548.37
+  ;; A-binary.watsup:566.5-566.37
   prod 0xAC => CVTOP_instr(I64_numtype, I32_numtype, EXTEND_cvtop__(S_sx))
-  ;; A-binary.watsup:549.5-549.37
+  ;; A-binary.watsup:567.5-567.37
   prod 0xAD => CVTOP_instr(I64_numtype, I32_numtype, EXTEND_cvtop__(U_sx))
-  ;; A-binary.watsup:550.5-550.36
+  ;; A-binary.watsup:568.5-568.36
   prod 0xAE => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:551.5-551.36
+  ;; A-binary.watsup:569.5-569.36
   prod 0xAF => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:552.5-552.36
+  ;; A-binary.watsup:570.5-570.36
   prod 0xB0 => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_cvtop__(S_sx))
-  ;; A-binary.watsup:553.5-553.36
+  ;; A-binary.watsup:571.5-571.36
   prod 0xB1 => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_cvtop__(U_sx))
-  ;; A-binary.watsup:554.5-554.38
+  ;; A-binary.watsup:572.5-572.38
   prod 0xB2 => CVTOP_instr(F32_numtype, I32_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:555.5-555.38
+  ;; A-binary.watsup:573.5-573.38
   prod 0xB3 => CVTOP_instr(F32_numtype, I32_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:556.5-556.38
+  ;; A-binary.watsup:574.5-574.38
   prod 0xB4 => CVTOP_instr(F32_numtype, I64_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:557.5-557.38
+  ;; A-binary.watsup:575.5-575.38
   prod 0xB5 => CVTOP_instr(F32_numtype, I64_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:558.5-558.33
+  ;; A-binary.watsup:576.5-576.33
   prod 0xB6 => CVTOP_instr(F32_numtype, F64_numtype, DEMOTE_cvtop__)
-  ;; A-binary.watsup:559.5-559.38
+  ;; A-binary.watsup:577.5-577.38
   prod 0xB7 => CVTOP_instr(F64_numtype, I32_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:560.5-560.38
+  ;; A-binary.watsup:578.5-578.38
   prod 0xB8 => CVTOP_instr(F64_numtype, I32_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:561.5-561.38
+  ;; A-binary.watsup:579.5-579.38
   prod 0xB9 => CVTOP_instr(F64_numtype, I64_numtype, CONVERT_cvtop__(S_sx))
-  ;; A-binary.watsup:562.5-562.38
+  ;; A-binary.watsup:580.5-580.38
   prod 0xBA => CVTOP_instr(F64_numtype, I64_numtype, CONVERT_cvtop__(U_sx))
-  ;; A-binary.watsup:563.5-563.34
+  ;; A-binary.watsup:581.5-581.34
   prod 0xBB => CVTOP_instr(F32_numtype, F64_numtype, PROMOTE_cvtop__)
-  ;; A-binary.watsup:564.5-564.38
+  ;; A-binary.watsup:582.5-582.38
   prod 0xBC => CVTOP_instr(I32_numtype, F32_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:565.5-565.38
+  ;; A-binary.watsup:583.5-583.38
   prod 0xBD => CVTOP_instr(I64_numtype, F64_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:566.5-566.38
+  ;; A-binary.watsup:584.5-584.38
   prod 0xBE => CVTOP_instr(F32_numtype, I32_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:567.5-567.38
+  ;; A-binary.watsup:585.5-585.38
   prod 0xBF => CVTOP_instr(F64_numtype, I64_numtype, REINTERPRET_cvtop__)
-  ;; A-binary.watsup:571.5-571.47
+  ;; A-binary.watsup:589.5-589.47
   prod {0xFC `%`_u32(0):Bu32} => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:572.5-572.47
+  ;; A-binary.watsup:590.5-590.47
   prod {0xFC `%`_u32(1):Bu32} => CVTOP_instr(I32_numtype, F32_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:573.5-573.47
+  ;; A-binary.watsup:591.5-591.47
   prod {0xFC `%`_u32(2):Bu32} => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:574.5-574.47
+  ;; A-binary.watsup:592.5-592.47
   prod {0xFC `%`_u32(3):Bu32} => CVTOP_instr(I32_numtype, F64_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:575.5-575.47
+  ;; A-binary.watsup:593.5-593.47
   prod {0xFC `%`_u32(4):Bu32} => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:576.5-576.47
+  ;; A-binary.watsup:594.5-594.47
   prod {0xFC `%`_u32(5):Bu32} => CVTOP_instr(I64_numtype, F32_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:577.5-577.47
+  ;; A-binary.watsup:595.5-595.47
   prod {0xFC `%`_u32(6):Bu32} => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_SAT_cvtop__(S_sx))
-  ;; A-binary.watsup:578.5-578.47
+  ;; A-binary.watsup:596.5-596.47
   prod {0xFC `%`_u32(7):Bu32} => CVTOP_instr(I64_numtype, F64_numtype, TRUNC_SAT_cvtop__(U_sx))
-  ;; A-binary.watsup:588.5-588.50
+  ;; A-binary.watsup:606.5-606.50
   prod{x : idx, ao : memarg} {0xFD `%`_u32(0):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(), x, ao)
-  ;; A-binary.watsup:589.5-589.68
+  ;; A-binary.watsup:607.5-607.68
   prod{x : idx, ao : memarg} {0xFD `%`_u32(1):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(8), 8, S_sx)), x, ao)
-  ;; A-binary.watsup:590.5-590.68
+  ;; A-binary.watsup:608.5-608.68
   prod{x : idx, ao : memarg} {0xFD `%`_u32(2):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(8), 8, U_sx)), x, ao)
-  ;; A-binary.watsup:591.5-591.69
+  ;; A-binary.watsup:609.5-609.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(3):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(16), 4, S_sx)), x, ao)
-  ;; A-binary.watsup:592.5-592.69
+  ;; A-binary.watsup:610.5-610.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(4):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(16), 4, U_sx)), x, ao)
-  ;; A-binary.watsup:593.5-593.69
+  ;; A-binary.watsup:611.5-611.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(5):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(32), 2, S_sx)), x, ao)
-  ;; A-binary.watsup:594.5-594.69
+  ;; A-binary.watsup:612.5-612.69
   prod{x : idx, ao : memarg} {0xFD `%`_u32(6):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(`SHAPE%X%%`_vloadop_(`%`_sz(32), 2, U_sx)), x, ao)
-  ;; A-binary.watsup:595.5-595.61
+  ;; A-binary.watsup:613.5-613.61
   prod{x : idx, ao : memarg} {0xFD `%`_u32(7):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(8))), x, ao)
-  ;; A-binary.watsup:596.5-596.62
+  ;; A-binary.watsup:614.5-614.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(8):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(16))), x, ao)
-  ;; A-binary.watsup:597.5-597.62
+  ;; A-binary.watsup:615.5-615.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(9):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(32))), x, ao)
-  ;; A-binary.watsup:598.5-598.63
+  ;; A-binary.watsup:616.5-616.63
   prod{x : idx, ao : memarg} {0xFD `%`_u32(10):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(SPLAT_vloadop_(`%`_sz(64))), x, ao)
-  ;; A-binary.watsup:599.5-599.52
+  ;; A-binary.watsup:617.5-617.52
   prod{x : idx, ao : memarg} {0xFD `%`_u32(11):Bu32 (x, ao):Bmemarg} => VSTORE_instr(V128_vectype, x, ao)
-  ;; A-binary.watsup:600.5-600.72
+  ;; A-binary.watsup:618.5-618.72
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(84):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(8), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:601.5-601.73
+  ;; A-binary.watsup:619.5-619.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(85):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(16), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:602.5-602.73
+  ;; A-binary.watsup:620.5-620.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(86):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(32), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:603.5-603.73
+  ;; A-binary.watsup:621.5-621.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(87):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VLOAD_LANE_instr(V128_vectype, `%`_sz(64), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:604.5-604.73
+  ;; A-binary.watsup:622.5-622.73
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(88):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(8), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:605.5-605.74
+  ;; A-binary.watsup:623.5-623.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(89):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(16), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:606.5-606.74
+  ;; A-binary.watsup:624.5-624.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(90):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(32), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:607.5-607.74
+  ;; A-binary.watsup:625.5-625.74
   prod{x : idx, ao : memarg, l : labelidx} {0xFD `%`_u32(91):Bu32 (x, ao):Bmemarg `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VSTORE_LANE_instr(V128_vectype, `%`_sz(64), x, ao, `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:608.5-608.62
+  ;; A-binary.watsup:626.5-626.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(92):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(32))), x, ao)
-  ;; A-binary.watsup:609.5-609.62
+  ;; A-binary.watsup:627.5-627.62
   prod{x : idx, ao : memarg} {0xFD `%`_u32(93):Bu32 (x, ao):Bmemarg} => VLOAD_instr(V128_vectype, ?(ZERO_vloadop_(`%`_sz(64))), x, ao)
-  ;; A-binary.watsup:613.5-613.71
+  ;; A-binary.watsup:631.5-631.71
   prod{b^16 : byte^16} {0xFD `%`_u32(12):Bu32 b:Bbyte^16{b : byte}} => VCONST_instr(V128_vectype, $invibytes_(128, b^16{b : byte}))
-  ;; A-binary.watsup:617.5-617.58
+  ;; A-binary.watsup:635.5-635.58
   prod{l : labelidx} {0xFD `%`_u32(13):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx^16{}} => VSHUFFLE_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), [`%`_uN(l!`%`_labelidx.0)])
-  ;; A-binary.watsup:618.5-618.40
+  ;; A-binary.watsup:636.5-636.40
   prod {0xFD `%`_u32(14):Bu32} => VSWIZZLE_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)))
-  ;; A-binary.watsup:622.5-622.38
+  ;; A-binary.watsup:640.5-640.38
   prod {0xFD `%`_u32(15):Bu32} => VSPLAT_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)))
-  ;; A-binary.watsup:623.5-623.38
+  ;; A-binary.watsup:641.5-641.38
   prod {0xFD `%`_u32(16):Bu32} => VSPLAT_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)))
-  ;; A-binary.watsup:624.5-624.38
+  ;; A-binary.watsup:642.5-642.38
   prod {0xFD `%`_u32(17):Bu32} => VSPLAT_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)))
-  ;; A-binary.watsup:625.5-625.38
+  ;; A-binary.watsup:643.5-643.38
   prod {0xFD `%`_u32(18):Bu32} => VSPLAT_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)))
-  ;; A-binary.watsup:626.5-626.38
+  ;; A-binary.watsup:644.5-644.38
   prod {0xFD `%`_u32(19):Bu32} => VSPLAT_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)))
-  ;; A-binary.watsup:627.5-627.38
+  ;; A-binary.watsup:645.5-645.38
   prod {0xFD `%`_u32(20):Bu32} => VSPLAT_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)))
-  ;; A-binary.watsup:631.5-631.60
+  ;; A-binary.watsup:649.5-649.60
   prod{l : labelidx} {0xFD `%`_u32(21):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ?(S_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:632.5-632.60
+  ;; A-binary.watsup:650.5-650.60
   prod{l : labelidx} {0xFD `%`_u32(22):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ?(U_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:633.5-633.58
+  ;; A-binary.watsup:651.5-651.58
   prod{l : labelidx} {0xFD `%`_u32(23):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:634.5-634.60
+  ;; A-binary.watsup:652.5-652.60
   prod{l : labelidx} {0xFD `%`_u32(24):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ?(S_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:635.5-635.60
+  ;; A-binary.watsup:653.5-653.60
   prod{l : labelidx} {0xFD `%`_u32(25):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ?(U_sx), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:636.5-636.58
+  ;; A-binary.watsup:654.5-654.58
   prod{l : labelidx} {0xFD `%`_u32(26):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:637.5-637.58
+  ;; A-binary.watsup:655.5-655.58
   prod{l : labelidx} {0xFD `%`_u32(27):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:638.5-638.58
+  ;; A-binary.watsup:656.5-656.58
   prod{l : labelidx} {0xFD `%`_u32(28):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:639.5-639.58
+  ;; A-binary.watsup:657.5-657.58
   prod{l : labelidx} {0xFD `%`_u32(29):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:640.5-640.58
+  ;; A-binary.watsup:658.5-658.58
   prod{l : labelidx} {0xFD `%`_u32(30):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:641.5-641.58
+  ;; A-binary.watsup:659.5-659.58
   prod{l : labelidx} {0xFD `%`_u32(31):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:642.5-642.58
+  ;; A-binary.watsup:660.5-660.58
   prod{l : labelidx} {0xFD `%`_u32(32):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:643.5-643.58
+  ;; A-binary.watsup:661.5-661.58
   prod{l : labelidx} {0xFD `%`_u32(33):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VEXTRACT_LANE_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ?(), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:644.5-644.58
+  ;; A-binary.watsup:662.5-662.58
   prod{l : labelidx} {0xFD `%`_u32(34):Bu32 `%`_laneidx(l!`%`_labelidx.0):Blaneidx} => VREPLACE_LANE_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%`_laneidx(l!`%`_labelidx.0))
-  ;; A-binary.watsup:648.5-648.41
+  ;; A-binary.watsup:666.5-666.41
   prod {0xFD `%`_u32(35):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), EQ_vrelop_)
-  ;; A-binary.watsup:649.5-649.41
+  ;; A-binary.watsup:667.5-667.41
   prod {0xFD `%`_u32(36):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), NE_vrelop_)
-  ;; A-binary.watsup:650.5-650.45
+  ;; A-binary.watsup:668.5-668.45
   prod {0xFD `%`_u32(37):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:651.5-651.45
+  ;; A-binary.watsup:669.5-669.45
   prod {0xFD `%`_u32(38):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:652.5-652.45
+  ;; A-binary.watsup:670.5-670.45
   prod {0xFD `%`_u32(39):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:653.5-653.45
+  ;; A-binary.watsup:671.5-671.45
   prod {0xFD `%`_u32(40):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:654.5-654.45
+  ;; A-binary.watsup:672.5-672.45
   prod {0xFD `%`_u32(41):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:655.5-655.45
+  ;; A-binary.watsup:673.5-673.45
   prod {0xFD `%`_u32(42):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:656.5-656.45
+  ;; A-binary.watsup:674.5-674.45
   prod {0xFD `%`_u32(43):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:657.5-657.45
+  ;; A-binary.watsup:675.5-675.45
   prod {0xFD `%`_u32(44):Bu32} => VRELOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:661.5-661.41
+  ;; A-binary.watsup:679.5-679.41
   prod {0xFD `%`_u32(45):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), EQ_vrelop_)
-  ;; A-binary.watsup:662.5-662.41
+  ;; A-binary.watsup:680.5-680.41
   prod {0xFD `%`_u32(46):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), NE_vrelop_)
-  ;; A-binary.watsup:663.5-663.45
+  ;; A-binary.watsup:681.5-681.45
   prod {0xFD `%`_u32(47):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:664.5-664.45
+  ;; A-binary.watsup:682.5-682.45
   prod {0xFD `%`_u32(48):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:665.5-665.45
+  ;; A-binary.watsup:683.5-683.45
   prod {0xFD `%`_u32(49):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:666.5-666.45
+  ;; A-binary.watsup:684.5-684.45
   prod {0xFD `%`_u32(50):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:667.5-667.45
+  ;; A-binary.watsup:685.5-685.45
   prod {0xFD `%`_u32(51):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:668.5-668.45
+  ;; A-binary.watsup:686.5-686.45
   prod {0xFD `%`_u32(52):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:669.5-669.45
+  ;; A-binary.watsup:687.5-687.45
   prod {0xFD `%`_u32(53):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:670.5-670.45
+  ;; A-binary.watsup:688.5-688.45
   prod {0xFD `%`_u32(54):Bu32} => VRELOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:674.5-674.41
+  ;; A-binary.watsup:692.5-692.41
   prod {0xFD `%`_u32(55):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), EQ_vrelop_)
-  ;; A-binary.watsup:675.5-675.41
+  ;; A-binary.watsup:693.5-693.41
   prod {0xFD `%`_u32(56):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), NE_vrelop_)
-  ;; A-binary.watsup:676.5-676.45
+  ;; A-binary.watsup:694.5-694.45
   prod {0xFD `%`_u32(57):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:677.5-677.45
+  ;; A-binary.watsup:695.5-695.45
   prod {0xFD `%`_u32(58):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LT_vrelop_(U_sx))
-  ;; A-binary.watsup:678.5-678.45
+  ;; A-binary.watsup:696.5-696.45
   prod {0xFD `%`_u32(59):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:679.5-679.45
+  ;; A-binary.watsup:697.5-697.45
   prod {0xFD `%`_u32(60):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GT_vrelop_(U_sx))
-  ;; A-binary.watsup:680.5-680.45
+  ;; A-binary.watsup:698.5-698.45
   prod {0xFD `%`_u32(61):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:681.5-681.45
+  ;; A-binary.watsup:699.5-699.45
   prod {0xFD `%`_u32(62):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), LE_vrelop_(U_sx))
-  ;; A-binary.watsup:682.5-682.45
+  ;; A-binary.watsup:700.5-700.45
   prod {0xFD `%`_u32(63):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:683.5-683.45
+  ;; A-binary.watsup:701.5-701.45
   prod {0xFD `%`_u32(64):Bu32} => VRELOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), GE_vrelop_(U_sx))
-  ;; A-binary.watsup:687.5-687.41
+  ;; A-binary.watsup:705.5-705.41
   prod {0xFD `%`_u32(65):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), EQ_vrelop_)
-  ;; A-binary.watsup:688.5-688.41
+  ;; A-binary.watsup:706.5-706.41
   prod {0xFD `%`_u32(66):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NE_vrelop_)
-  ;; A-binary.watsup:689.5-689.41
+  ;; A-binary.watsup:707.5-707.41
   prod {0xFD `%`_u32(67):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), LT_vrelop_)
-  ;; A-binary.watsup:690.5-690.41
+  ;; A-binary.watsup:708.5-708.41
   prod {0xFD `%`_u32(68):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), GT_vrelop_)
-  ;; A-binary.watsup:691.5-691.41
+  ;; A-binary.watsup:709.5-709.41
   prod {0xFD `%`_u32(69):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), LE_vrelop_)
-  ;; A-binary.watsup:692.5-692.41
+  ;; A-binary.watsup:710.5-710.41
   prod {0xFD `%`_u32(70):Bu32} => VRELOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), GE_vrelop_)
-  ;; A-binary.watsup:696.5-696.41
+  ;; A-binary.watsup:714.5-714.41
   prod {0xFD `%`_u32(71):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), EQ_vrelop_)
-  ;; A-binary.watsup:697.5-697.41
+  ;; A-binary.watsup:715.5-715.41
   prod {0xFD `%`_u32(72):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NE_vrelop_)
-  ;; A-binary.watsup:698.5-698.41
+  ;; A-binary.watsup:716.5-716.41
   prod {0xFD `%`_u32(73):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), LT_vrelop_)
-  ;; A-binary.watsup:699.5-699.41
+  ;; A-binary.watsup:717.5-717.41
   prod {0xFD `%`_u32(74):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), GT_vrelop_)
-  ;; A-binary.watsup:700.5-700.41
+  ;; A-binary.watsup:718.5-718.41
   prod {0xFD `%`_u32(75):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), LE_vrelop_)
-  ;; A-binary.watsup:701.5-701.41
+  ;; A-binary.watsup:719.5-719.41
   prod {0xFD `%`_u32(76):Bu32} => VRELOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), GE_vrelop_)
-  ;; A-binary.watsup:705.5-705.36
+  ;; A-binary.watsup:723.5-723.36
   prod {0xFD `%`_u32(77):Bu32} => VVUNOP_instr(V128_vectype, NOT_vvunop)
-  ;; A-binary.watsup:709.5-709.37
+  ;; A-binary.watsup:727.5-727.37
   prod {0xFD `%`_u32(78):Bu32} => VVBINOP_instr(V128_vectype, AND_vvbinop)
-  ;; A-binary.watsup:710.5-710.40
+  ;; A-binary.watsup:728.5-728.40
   prod {0xFD `%`_u32(79):Bu32} => VVBINOP_instr(V128_vectype, ANDNOT_vvbinop)
-  ;; A-binary.watsup:711.5-711.36
+  ;; A-binary.watsup:729.5-729.36
   prod {0xFD `%`_u32(80):Bu32} => VVBINOP_instr(V128_vectype, OR_vvbinop)
-  ;; A-binary.watsup:712.5-712.37
+  ;; A-binary.watsup:730.5-730.37
   prod {0xFD `%`_u32(81):Bu32} => VVBINOP_instr(V128_vectype, XOR_vvbinop)
-  ;; A-binary.watsup:716.5-716.44
+  ;; A-binary.watsup:734.5-734.44
   prod {0xFD `%`_u32(82):Bu32} => VVTERNOP_instr(V128_vectype, BITSELECT_vvternop)
-  ;; A-binary.watsup:720.5-720.43
+  ;; A-binary.watsup:738.5-738.43
   prod {0xFD `%`_u32(83):Bu32} => VVTESTOP_instr(V128_vectype, ANY_TRUE_vvtestop)
-  ;; A-binary.watsup:724.5-724.41
+  ;; A-binary.watsup:742.5-742.41
   prod {0xFD `%`_u32(96):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ABS_vunop_)
-  ;; A-binary.watsup:725.5-725.41
+  ;; A-binary.watsup:743.5-743.41
   prod {0xFD `%`_u32(97):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), NEG_vunop_)
-  ;; A-binary.watsup:726.5-726.44
+  ;; A-binary.watsup:744.5-744.44
   prod {0xFD `%`_u32(98):Bu32} => VUNOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), POPCNT_vunop_)
-  ;; A-binary.watsup:730.5-730.48
+  ;; A-binary.watsup:748.5-748.48
   prod {0xFD `%`_u32(99):Bu32} => VTESTOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:734.5-734.41
+  ;; A-binary.watsup:752.5-752.41
   prod {0xFD `%`_u32(100):Bu32} => VBITMASK_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)))
-  ;; A-binary.watsup:738.5-738.53
+  ;; A-binary.watsup:756.5-756.53
   prod {0xFD `%`_u32(101):Bu32} => VNARROW_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), S_sx)
-  ;; A-binary.watsup:739.5-739.53
+  ;; A-binary.watsup:757.5-757.53
   prod {0xFD `%`_u32(102):Bu32} => VNARROW_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), U_sx)
-  ;; A-binary.watsup:743.5-743.45
+  ;; A-binary.watsup:761.5-761.45
   prod {0xFD `%`_u32(107):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHL_vshiftop_)
-  ;; A-binary.watsup:744.5-744.49
+  ;; A-binary.watsup:762.5-762.49
   prod {0xFD `%`_u32(108):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:745.5-745.49
+  ;; A-binary.watsup:763.5-763.49
   prod {0xFD `%`_u32(109):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I8_Jnn, `%`_dim(16)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:749.5-749.43
+  ;; A-binary.watsup:767.5-767.43
   prod {0xFD `%`_u32(110):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_vbinop_)
-  ;; A-binary.watsup:750.5-750.51
+  ;; A-binary.watsup:768.5-768.51
   prod {0xFD `%`_u32(111):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:751.5-751.51
+  ;; A-binary.watsup:769.5-769.51
   prod {0xFD `%`_u32(112):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), ADD_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:752.5-752.43
+  ;; A-binary.watsup:770.5-770.43
   prod {0xFD `%`_u32(113):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_vbinop_)
-  ;; A-binary.watsup:753.5-753.51
+  ;; A-binary.watsup:771.5-771.51
   prod {0xFD `%`_u32(114):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:754.5-754.51
+  ;; A-binary.watsup:772.5-772.51
   prod {0xFD `%`_u32(115):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), SUB_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:755.5-755.47
+  ;; A-binary.watsup:773.5-773.47
   prod {0xFD `%`_u32(118):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:756.5-756.47
+  ;; A-binary.watsup:774.5-774.47
   prod {0xFD `%`_u32(119):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:757.5-757.47
+  ;; A-binary.watsup:775.5-775.47
   prod {0xFD `%`_u32(120):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:758.5-758.47
+  ;; A-binary.watsup:776.5-776.47
   prod {0xFD `%`_u32(121):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:759.5-759.48
+  ;; A-binary.watsup:777.5-777.48
   prod {0xFD `%`_u32(123):Bu32} => VBINOP_instr(`%X%`_shape(I8_lanetype, `%`_dim(16)), `AVGRU`_vbinop_)
-  ;; A-binary.watsup:763.5-763.72
+  ;; A-binary.watsup:781.5-781.72
   prod {0xFD `%`_u32(124):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTADD_PAIRWISE_vextunop__(S_sx))
-  ;; A-binary.watsup:764.5-764.72
+  ;; A-binary.watsup:782.5-782.72
   prod {0xFD `%`_u32(125):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTADD_PAIRWISE_vextunop__(U_sx))
-  ;; A-binary.watsup:768.5-768.42
+  ;; A-binary.watsup:786.5-786.42
   prod {0xFD `%`_u32(128):Bu32} => VUNOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ABS_vunop_)
-  ;; A-binary.watsup:769.5-769.42
+  ;; A-binary.watsup:787.5-787.42
   prod {0xFD `%`_u32(129):Bu32} => VUNOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), NEG_vunop_)
-  ;; A-binary.watsup:773.5-773.55
+  ;; A-binary.watsup:791.5-791.55
   prod {0xFD `%`_u32(130):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `Q15MULR_SATS`_vbinop_)
-  ;; A-binary.watsup:777.5-777.49
+  ;; A-binary.watsup:795.5-795.49
   prod {0xFD `%`_u32(131):Bu32} => VTESTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:781.5-781.41
+  ;; A-binary.watsup:799.5-799.41
   prod {0xFD `%`_u32(132):Bu32} => VBITMASK_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)))
-  ;; A-binary.watsup:785.5-785.53
+  ;; A-binary.watsup:803.5-803.53
   prod {0xFD `%`_u32(133):Bu32} => VNARROW_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), S_sx)
-  ;; A-binary.watsup:786.5-786.53
+  ;; A-binary.watsup:804.5-804.53
   prod {0xFD `%`_u32(134):Bu32} => VNARROW_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), U_sx)
-  ;; A-binary.watsup:790.5-790.65
+  ;; A-binary.watsup:808.5-808.65
   prod {0xFD `%`_u32(135):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:791.5-791.66
+  ;; A-binary.watsup:809.5-809.66
   prod {0xFD `%`_u32(136):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:792.5-792.65
+  ;; A-binary.watsup:810.5-810.65
   prod {0xFD `%`_u32(137):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:793.5-793.66
+  ;; A-binary.watsup:811.5-811.66
   prod {0xFD `%`_u32(138):Bu32} => VCVTOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `%X%`_shape(I8_lanetype, `%`_dim(16)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:797.5-797.45
+  ;; A-binary.watsup:815.5-815.45
   prod {0xFD `%`_u32(139):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHL_vshiftop_)
-  ;; A-binary.watsup:798.5-798.49
+  ;; A-binary.watsup:816.5-816.49
   prod {0xFD `%`_u32(140):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:799.5-799.49
+  ;; A-binary.watsup:817.5-817.49
   prod {0xFD `%`_u32(141):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:803.5-803.43
+  ;; A-binary.watsup:821.5-821.43
   prod {0xFD `%`_u32(142):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_vbinop_)
-  ;; A-binary.watsup:804.5-804.51
+  ;; A-binary.watsup:822.5-822.51
   prod {0xFD `%`_u32(143):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:805.5-805.51
+  ;; A-binary.watsup:823.5-823.51
   prod {0xFD `%`_u32(144):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), ADD_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:806.5-806.43
+  ;; A-binary.watsup:824.5-824.43
   prod {0xFD `%`_u32(145):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_vbinop_)
-  ;; A-binary.watsup:807.5-807.51
+  ;; A-binary.watsup:825.5-825.51
   prod {0xFD `%`_u32(146):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_SAT_vbinop_(S_sx))
-  ;; A-binary.watsup:808.5-808.51
+  ;; A-binary.watsup:826.5-826.51
   prod {0xFD `%`_u32(147):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), SUB_SAT_vbinop_(U_sx))
-  ;; A-binary.watsup:809.5-809.43
+  ;; A-binary.watsup:827.5-827.43
   prod {0xFD `%`_u32(149):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MUL_vbinop_)
-  ;; A-binary.watsup:810.5-810.47
+  ;; A-binary.watsup:828.5-828.47
   prod {0xFD `%`_u32(150):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:811.5-811.47
+  ;; A-binary.watsup:829.5-829.47
   prod {0xFD `%`_u32(151):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:812.5-812.47
+  ;; A-binary.watsup:830.5-830.47
   prod {0xFD `%`_u32(152):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:813.5-813.47
+  ;; A-binary.watsup:831.5-831.47
   prod {0xFD `%`_u32(153):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:814.5-814.48
+  ;; A-binary.watsup:832.5-832.48
   prod {0xFD `%`_u32(155):Bu32} => VBINOP_instr(`%X%`_shape(I16_lanetype, `%`_dim(8)), `AVGRU`_vbinop_)
-  ;; A-binary.watsup:818.5-818.68
+  ;; A-binary.watsup:836.5-836.68
   prod {0xFD `%`_u32(156):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:819.5-819.69
+  ;; A-binary.watsup:837.5-837.69
   prod {0xFD `%`_u32(157):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:820.5-820.68
+  ;; A-binary.watsup:838.5-838.68
   prod {0xFD `%`_u32(158):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:821.5-821.69
+  ;; A-binary.watsup:839.5-839.69
   prod {0xFD `%`_u32(159):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I16_Jnn, `%`_dim(8)), `%X%`_ishape(I8_Jnn, `%`_dim(16)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:825.5-825.72
+  ;; A-binary.watsup:843.5-843.72
   prod {0xFD `%`_u32(126):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTADD_PAIRWISE_vextunop__(S_sx))
-  ;; A-binary.watsup:826.5-826.72
+  ;; A-binary.watsup:844.5-844.72
   prod {0xFD `%`_u32(127):Bu32} => VEXTUNOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTADD_PAIRWISE_vextunop__(U_sx))
-  ;; A-binary.watsup:830.5-830.42
+  ;; A-binary.watsup:848.5-848.42
   prod {0xFD `%`_u32(160):Bu32} => VUNOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ABS_vunop_)
-  ;; A-binary.watsup:831.5-831.42
+  ;; A-binary.watsup:849.5-849.42
   prod {0xFD `%`_u32(161):Bu32} => VUNOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), NEG_vunop_)
-  ;; A-binary.watsup:835.5-835.49
+  ;; A-binary.watsup:853.5-853.49
   prod {0xFD `%`_u32(163):Bu32} => VTESTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:839.5-839.41
+  ;; A-binary.watsup:857.5-857.41
   prod {0xFD `%`_u32(164):Bu32} => VBITMASK_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)))
-  ;; A-binary.watsup:843.5-843.65
+  ;; A-binary.watsup:861.5-861.65
   prod {0xFD `%`_u32(167):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:844.5-844.66
+  ;; A-binary.watsup:862.5-862.66
   prod {0xFD `%`_u32(168):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:845.5-845.65
+  ;; A-binary.watsup:863.5-863.65
   prod {0xFD `%`_u32(169):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:846.5-846.66
+  ;; A-binary.watsup:864.5-864.66
   prod {0xFD `%`_u32(170):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(I16_lanetype, `%`_dim(8)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:850.5-850.45
+  ;; A-binary.watsup:868.5-868.45
   prod {0xFD `%`_u32(171):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHL_vshiftop_)
-  ;; A-binary.watsup:851.5-851.49
+  ;; A-binary.watsup:869.5-869.49
   prod {0xFD `%`_u32(172):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:852.5-852.49
+  ;; A-binary.watsup:870.5-870.49
   prod {0xFD `%`_u32(173):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:856.5-856.43
+  ;; A-binary.watsup:874.5-874.43
   prod {0xFD `%`_u32(174):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), ADD_vbinop_)
-  ;; A-binary.watsup:857.5-857.43
+  ;; A-binary.watsup:875.5-875.43
   prod {0xFD `%`_u32(177):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), SUB_vbinop_)
-  ;; A-binary.watsup:858.5-858.43
+  ;; A-binary.watsup:876.5-876.43
   prod {0xFD `%`_u32(181):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MUL_vbinop_)
-  ;; A-binary.watsup:859.5-859.47
+  ;; A-binary.watsup:877.5-877.47
   prod {0xFD `%`_u32(182):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MIN_vbinop_(S_sx))
-  ;; A-binary.watsup:860.5-860.47
+  ;; A-binary.watsup:878.5-878.47
   prod {0xFD `%`_u32(183):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MIN_vbinop_(U_sx))
-  ;; A-binary.watsup:861.5-861.47
+  ;; A-binary.watsup:879.5-879.47
   prod {0xFD `%`_u32(184):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MAX_vbinop_(S_sx))
-  ;; A-binary.watsup:862.5-862.47
+  ;; A-binary.watsup:880.5-880.47
   prod {0xFD `%`_u32(185):Bu32} => VBINOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), MAX_vbinop_(U_sx))
-  ;; A-binary.watsup:866.5-866.61
+  ;; A-binary.watsup:884.5-884.61
   prod {0xFD `%`_u32(186):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), `DOTS`_vextbinop__)
-  ;; A-binary.watsup:867.5-867.68
+  ;; A-binary.watsup:885.5-885.68
   prod {0xFD `%`_u32(188):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:868.5-868.69
+  ;; A-binary.watsup:886.5-886.69
   prod {0xFD `%`_u32(189):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:869.5-869.68
+  ;; A-binary.watsup:887.5-887.68
   prod {0xFD `%`_u32(190):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:870.5-870.69
+  ;; A-binary.watsup:888.5-888.69
   prod {0xFD `%`_u32(191):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I32_Jnn, `%`_dim(4)), `%X%`_ishape(I16_Jnn, `%`_dim(8)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:874.5-874.42
+  ;; A-binary.watsup:892.5-892.42
   prod {0xFD `%`_u32(192):Bu32} => VUNOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ABS_vunop_)
-  ;; A-binary.watsup:875.5-875.42
+  ;; A-binary.watsup:893.5-893.42
   prod {0xFD `%`_u32(193):Bu32} => VUNOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), NEG_vunop_)
-  ;; A-binary.watsup:879.5-879.49
+  ;; A-binary.watsup:897.5-897.49
   prod {0xFD `%`_u32(195):Bu32} => VTESTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ALL_TRUE_vtestop_)
-  ;; A-binary.watsup:883.5-883.41
+  ;; A-binary.watsup:901.5-901.41
   prod {0xFD `%`_u32(196):Bu32} => VBITMASK_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)))
-  ;; A-binary.watsup:887.5-887.65
+  ;; A-binary.watsup:905.5-905.65
   prod {0xFD `%`_u32(199):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:888.5-888.66
+  ;; A-binary.watsup:906.5-906.66
   prod {0xFD `%`_u32(200):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(S_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:889.5-889.65
+  ;; A-binary.watsup:907.5-907.65
   prod {0xFD `%`_u32(201):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(U_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:890.5-890.66
+  ;; A-binary.watsup:908.5-908.66
   prod {0xFD `%`_u32(202):Bu32} => VCVTOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), EXTEND_vcvtop__(U_sx), ?(HIGH_half__), ?())
-  ;; A-binary.watsup:894.5-894.45
+  ;; A-binary.watsup:912.5-912.45
   prod {0xFD `%`_u32(203):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHL_vshiftop_)
-  ;; A-binary.watsup:895.5-895.49
+  ;; A-binary.watsup:913.5-913.49
   prod {0xFD `%`_u32(204):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHR_vshiftop_(S_sx))
-  ;; A-binary.watsup:896.5-896.49
+  ;; A-binary.watsup:914.5-914.49
   prod {0xFD `%`_u32(205):Bu32} => VSHIFTOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), SHR_vshiftop_(U_sx))
-  ;; A-binary.watsup:900.5-900.43
+  ;; A-binary.watsup:918.5-918.43
   prod {0xFD `%`_u32(206):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), ADD_vbinop_)
-  ;; A-binary.watsup:901.5-901.43
+  ;; A-binary.watsup:919.5-919.43
   prod {0xFD `%`_u32(209):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), SUB_vbinop_)
-  ;; A-binary.watsup:902.5-902.43
+  ;; A-binary.watsup:920.5-920.43
   prod {0xFD `%`_u32(213):Bu32} => VBINOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), MUL_vbinop_)
-  ;; A-binary.watsup:906.5-906.42
+  ;; A-binary.watsup:924.5-924.42
   prod {0xFD `%`_u32(214):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), EQ_vrelop_)
-  ;; A-binary.watsup:907.5-907.42
+  ;; A-binary.watsup:925.5-925.42
   prod {0xFD `%`_u32(215):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), NE_vrelop_)
-  ;; A-binary.watsup:908.5-908.46
+  ;; A-binary.watsup:926.5-926.46
   prod {0xFD `%`_u32(216):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), LT_vrelop_(S_sx))
-  ;; A-binary.watsup:909.5-909.46
+  ;; A-binary.watsup:927.5-927.46
   prod {0xFD `%`_u32(217):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), GT_vrelop_(S_sx))
-  ;; A-binary.watsup:910.5-910.46
+  ;; A-binary.watsup:928.5-928.46
   prod {0xFD `%`_u32(218):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), LE_vrelop_(S_sx))
-  ;; A-binary.watsup:911.5-911.46
+  ;; A-binary.watsup:929.5-929.46
   prod {0xFD `%`_u32(219):Bu32} => VRELOP_instr(`%X%`_shape(I64_lanetype, `%`_dim(2)), GE_vrelop_(S_sx))
-  ;; A-binary.watsup:915.5-915.68
+  ;; A-binary.watsup:933.5-933.68
   prod {0xFD `%`_u32(220):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(S_sx, LOW_half__))
-  ;; A-binary.watsup:916.5-916.69
+  ;; A-binary.watsup:934.5-934.69
   prod {0xFD `%`_u32(221):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(S_sx, HIGH_half__))
-  ;; A-binary.watsup:917.5-917.68
+  ;; A-binary.watsup:935.5-935.68
   prod {0xFD `%`_u32(222):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(U_sx, LOW_half__))
-  ;; A-binary.watsup:918.5-918.69
+  ;; A-binary.watsup:936.5-936.69
   prod {0xFD `%`_u32(223):Bu32} => VEXTBINOP_instr(`%X%`_ishape(I64_Jnn, `%`_dim(2)), `%X%`_ishape(I32_Jnn, `%`_dim(4)), EXTMUL_vextbinop__(U_sx, HIGH_half__))
-  ;; A-binary.watsup:922.5-922.43
+  ;; A-binary.watsup:940.5-940.43
   prod {0xFD `%`_u32(103):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), CEIL_vunop_)
-  ;; A-binary.watsup:923.5-923.44
+  ;; A-binary.watsup:941.5-941.44
   prod {0xFD `%`_u32(104):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), FLOOR_vunop_)
-  ;; A-binary.watsup:924.5-924.44
+  ;; A-binary.watsup:942.5-942.44
   prod {0xFD `%`_u32(105):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_vunop_)
-  ;; A-binary.watsup:925.5-925.46
+  ;; A-binary.watsup:943.5-943.46
   prod {0xFD `%`_u32(106):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NEAREST_vunop_)
-  ;; A-binary.watsup:926.5-926.42
+  ;; A-binary.watsup:944.5-944.42
   prod {0xFD `%`_u32(224):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ABS_vunop_)
-  ;; A-binary.watsup:927.5-927.42
+  ;; A-binary.watsup:945.5-945.42
   prod {0xFD `%`_u32(225):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), NEG_vunop_)
-  ;; A-binary.watsup:928.5-928.43
+  ;; A-binary.watsup:946.5-946.43
   prod {0xFD `%`_u32(227):Bu32} => VUNOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), SQRT_vunop_)
-  ;; A-binary.watsup:932.5-932.43
+  ;; A-binary.watsup:950.5-950.43
   prod {0xFD `%`_u32(228):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), ADD_vbinop_)
-  ;; A-binary.watsup:933.5-933.43
+  ;; A-binary.watsup:951.5-951.43
   prod {0xFD `%`_u32(229):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), SUB_vbinop_)
-  ;; A-binary.watsup:934.5-934.43
+  ;; A-binary.watsup:952.5-952.43
   prod {0xFD `%`_u32(230):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MUL_vbinop_)
-  ;; A-binary.watsup:935.5-935.43
+  ;; A-binary.watsup:953.5-953.43
   prod {0xFD `%`_u32(231):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), DIV_vbinop_)
-  ;; A-binary.watsup:936.5-936.43
+  ;; A-binary.watsup:954.5-954.43
   prod {0xFD `%`_u32(232):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MIN_vbinop_)
-  ;; A-binary.watsup:937.5-937.43
+  ;; A-binary.watsup:955.5-955.43
   prod {0xFD `%`_u32(233):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), MAX_vbinop_)
-  ;; A-binary.watsup:938.5-938.44
+  ;; A-binary.watsup:956.5-956.44
   prod {0xFD `%`_u32(234):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), PMIN_vbinop_)
-  ;; A-binary.watsup:939.5-939.44
+  ;; A-binary.watsup:957.5-957.44
   prod {0xFD `%`_u32(235):Bu32} => VBINOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), PMAX_vbinop_)
-  ;; A-binary.watsup:943.5-943.43
+  ;; A-binary.watsup:961.5-961.43
   prod {0xFD `%`_u32(116):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), CEIL_vunop_)
-  ;; A-binary.watsup:944.5-944.44
+  ;; A-binary.watsup:962.5-962.44
   prod {0xFD `%`_u32(117):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), FLOOR_vunop_)
-  ;; A-binary.watsup:945.5-945.44
+  ;; A-binary.watsup:963.5-963.44
   prod {0xFD `%`_u32(122):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_vunop_)
-  ;; A-binary.watsup:946.5-946.46
+  ;; A-binary.watsup:964.5-964.46
   prod {0xFD `%`_u32(148):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NEAREST_vunop_)
-  ;; A-binary.watsup:947.5-947.42
+  ;; A-binary.watsup:965.5-965.42
   prod {0xFD `%`_u32(236):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ABS_vunop_)
-  ;; A-binary.watsup:948.5-948.42
+  ;; A-binary.watsup:966.5-966.42
   prod {0xFD `%`_u32(237):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), NEG_vunop_)
-  ;; A-binary.watsup:949.5-949.43
+  ;; A-binary.watsup:967.5-967.43
   prod {0xFD `%`_u32(239):Bu32} => VUNOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), SQRT_vunop_)
-  ;; A-binary.watsup:953.5-953.43
+  ;; A-binary.watsup:971.5-971.43
   prod {0xFD `%`_u32(240):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), ADD_vbinop_)
-  ;; A-binary.watsup:954.5-954.43
+  ;; A-binary.watsup:972.5-972.43
   prod {0xFD `%`_u32(241):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), SUB_vbinop_)
-  ;; A-binary.watsup:955.5-955.43
+  ;; A-binary.watsup:973.5-973.43
   prod {0xFD `%`_u32(242):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MUL_vbinop_)
-  ;; A-binary.watsup:956.5-956.43
+  ;; A-binary.watsup:974.5-974.43
   prod {0xFD `%`_u32(243):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), DIV_vbinop_)
-  ;; A-binary.watsup:957.5-957.43
+  ;; A-binary.watsup:975.5-975.43
   prod {0xFD `%`_u32(244):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MIN_vbinop_)
-  ;; A-binary.watsup:958.5-958.43
+  ;; A-binary.watsup:976.5-976.43
   prod {0xFD `%`_u32(245):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), MAX_vbinop_)
-  ;; A-binary.watsup:959.5-959.44
+  ;; A-binary.watsup:977.5-977.44
   prod {0xFD `%`_u32(246):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), PMIN_vbinop_)
-  ;; A-binary.watsup:960.5-960.44
+  ;; A-binary.watsup:978.5-978.44
   prod {0xFD `%`_u32(247):Bu32} => VBINOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), PMAX_vbinop_)
-  ;; A-binary.watsup:964.5-964.61
+  ;; A-binary.watsup:982.5-982.61
   prod {0xFD `%`_u32(94):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), DEMOTE_vcvtop__, ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:965.5-965.61
+  ;; A-binary.watsup:983.5-983.61
   prod {0xFD `%`_u32(95):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(F32_lanetype, `%`_dim(4)), PROMOTE_vcvtop__, ?(LOW_half__), ?())
-  ;; A-binary.watsup:966.5-966.64
+  ;; A-binary.watsup:984.5-984.64
   prod {0xFD `%`_u32(248):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_SAT_vcvtop__(S_sx), ?(), ?())
-  ;; A-binary.watsup:967.5-967.64
+  ;; A-binary.watsup:985.5-985.64
   prod {0xFD `%`_u32(249):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F32_lanetype, `%`_dim(4)), TRUNC_SAT_vcvtop__(U_sx), ?(), ?())
-  ;; A-binary.watsup:968.5-968.62
+  ;; A-binary.watsup:986.5-986.62
   prod {0xFD `%`_u32(250):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(S_sx), ?(), ?())
-  ;; A-binary.watsup:969.5-969.62
+  ;; A-binary.watsup:987.5-987.62
   prod {0xFD `%`_u32(251):Bu32} => VCVTOP_instr(`%X%`_shape(F32_lanetype, `%`_dim(4)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(U_sx), ?(), ?())
-  ;; A-binary.watsup:970.5-970.69
+  ;; A-binary.watsup:988.5-988.69
   prod {0xFD `%`_u32(252):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_SAT_vcvtop__(S_sx), ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:971.5-971.69
+  ;; A-binary.watsup:989.5-989.69
   prod {0xFD `%`_u32(253):Bu32} => VCVTOP_instr(`%X%`_shape(I32_lanetype, `%`_dim(4)), `%X%`_shape(F64_lanetype, `%`_dim(2)), TRUNC_SAT_vcvtop__(U_sx), ?(), ?(ZERO_zero__))
-  ;; A-binary.watsup:972.5-972.66
+  ;; A-binary.watsup:990.5-990.66
   prod {0xFD `%`_u32(254):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(S_sx), ?(LOW_half__), ?())
-  ;; A-binary.watsup:973.5-973.66
+  ;; A-binary.watsup:991.5-991.66
   prod {0xFD `%`_u32(255):Bu32} => VCVTOP_instr(`%X%`_shape(F64_lanetype, `%`_dim(2)), `%X%`_shape(I32_lanetype, `%`_dim(4)), CONVERT_vcvtop__(U_sx), ?(LOW_half__), ?())
 }
 
@@ -32107,6 +33553,16 @@ grammar Bdatacntsec : u32?
   ;; A-binary.watsup
   prod{nopt : nopt} nopt:Bsection_(12, syntax u32, grammar Bdatacnt) => $opt_(syntax u32, nopt)
 
+;; A-binary.watsup
+grammar Btag : tag
+  ;; A-binary.watsup
+  prod{x : idx} x:Btypeidx => TAG_tag(x)
+
+;; A-binary.watsup
+grammar Btagsec : tag*
+  ;; A-binary.watsup
+  prod{tag* : tag*} tag*{tag : tag}:Bsection_(13, syntax tag, grammar Blist(syntax tag, grammar Btag)) => tag*{tag : tag}
+
 ;; A-binary.watsup
 grammar Bmagic : ()
   ;; A-binary.watsup
@@ -32120,7 +33576,7 @@ grammar Bversion : ()
 ;; A-binary.watsup
 grammar Bmodule : module
   ;; A-binary.watsup
-  prod{type* : type*, import* : import*, typeidx* : typeidx*, table* : table*, mem* : mem*, global* : global*, export* : export*, start? : start?, elem* : elem*, n? : n?, local** : local**, expr* : expr*, data* : data*, func* : func*} {Bmagic Bversion Bcustomsec*{} type*{type : type}:Btypesec Bcustomsec*{} import*{import : import}:Bimportsec Bcustomsec*{} typeidx*{typeidx : typeidx}:Bfuncsec Bcustomsec*{} table*{table : table}:Btablesec Bcustomsec*{} mem*{mem : mem}:Bmemsec Bcustomsec*{} global*{global : global}:Bglobalsec Bcustomsec*{} export*{export : export}:Bexportsec Bcustomsec*{} start?{start : start}:Bstartsec Bcustomsec*{} elem*{elem : elem}:Belemsec Bcustomsec*{} `%`_u32(n)?{n : nat}:Bdatacntsec Bcustomsec*{} (local*{local : local}, expr)*{expr : expr, local : local}:Bcodesec Bcustomsec*{} data*{data : data}:Bdatasec Bcustomsec*{}} => MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})
+  prod{type* : type*, import* : import*, typeidx* : typeidx*, table* : table*, mem* : mem*, tag* : tag*, global* : global*, export* : export*, start? : start?, elem* : elem*, n? : n?, local** : local**, expr* : expr*, data* : data*, func* : func*} {Bmagic Bversion Bcustomsec*{} type*{type : type}:Btypesec Bcustomsec*{} import*{import : import}:Bimportsec Bcustomsec*{} typeidx*{typeidx : typeidx}:Bfuncsec Bcustomsec*{} table*{table : table}:Btablesec Bcustomsec*{} mem*{mem : mem}:Bmemsec Bcustomsec*{} tag*{tag : tag}:Btagsec Bcustomsec*{} global*{global : global}:Bglobalsec Bcustomsec*{} export*{export : export}:Bexportsec Bcustomsec*{} start?{start : start}:Bstartsec Bcustomsec*{} elem*{elem : elem}:Belemsec Bcustomsec*{} `%`_u32(n)?{n : nat}:Bdatacntsec Bcustomsec*{} (local*{local : local}, expr)*{expr : expr, local : local}:Bcodesec Bcustomsec*{} data*{data : data}:Bdatasec Bcustomsec*{}} => MODULE_module(type*{type : type}, import*{import : import}, func*{func : func}, global*{global : global}, table*{table : table}, mem*{mem : mem}, tag*{tag : tag}, elem*{elem : elem}, data*{data : data}, start?{start : start}, export*{export : export})
     -- (if (n = |data*{data : data}|))?{n : n}
     -- if ((n?{n : n} =/= ?()) \/ ($dataidx_funcs(func*{func : func}) = []))
     -- (if (func = FUNC_func(typeidx, local*{local : local}, expr)))*{expr : expr, func : func, local : local, typeidx : typeidx}
@@ -32196,7 +33652,7 @@ relation NotationTypingInstrScheme: `%|-%:%`(context, instr*, functype)
   rule block{C : context, blocktype : blocktype, instr* : instr*, t_1* : valtype*, t_2* : valtype*}:
     `%|-%:%`(C, [BLOCK_instr(blocktype, instr*{instr : instr})], `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
     -- Blocktype_ok: `%|-%:%`(C, blocktype, `%->_%%`_instrtype(`%`_resulttype(t_1*{t_1 : valtype}), [], `%`_resulttype(t_2*{t_2 : valtype})))
-    -- NotationTypingInstrScheme: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
+    -- NotationTypingInstrScheme: `%|-%:%`({TYPES [], RECS [], FUNCS [], GLOBALS [], TABLES [], MEMS [], TAGS [], ELEMS [], DATAS [], LOCALS [], LABELS [`%`_resulttype(t_2*{t_2 : valtype})], RETURN ?(), REFS []} ++ C, instr*{instr : instr}, `%->%`_functype(`%`_resulttype(t_1*{t_1 : valtype}), `%`_resulttype(t_2*{t_2 : valtype})))
 }
 
 ;; C-conventions.watsup
diff --git a/spectec/test-prose/TEST.md b/spectec/test-prose/TEST.md
index 1cab38171a..4adecba90f 100644
--- a/spectec/test-prose/TEST.md
+++ b/spectec/test-prose/TEST.md
@@ -1429,86 +1429,86 @@ watsup 0.4 generator
 #. Return :math:`(\mathsf{f{\scriptstyle 64}}{.}\mathsf{const}~{+0})`.
 
 
-:math:`{\mathrm{funcs}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-.............................................................................................
+:math:`{\mathrm{funcs}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+..............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{func}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{func}`, then:
 
-   a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be :math:`{\mathit{externaddr}}_0`.
 
    #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{xv}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
 #. Return :math:`{\mathrm{funcs}}({{\mathit{xv}}^\ast})`.
 
 
-:math:`{\mathrm{globals}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-...............................................................................................
+:math:`{\mathrm{globals}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+................................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{global}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{global}`, then:
 
-   a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be :math:`{\mathit{externaddr}}_0`.
 
    #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{xv}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
 #. Return :math:`{\mathrm{globals}}({{\mathit{xv}}^\ast})`.
 
 
-:math:`{\mathrm{tables}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-..............................................................................................
+:math:`{\mathrm{tables}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+...............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{table}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{table}`, then:
 
-   a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be :math:`{\mathit{externaddr}}_0`.
 
    #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{xv}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
 #. Return :math:`{\mathrm{tables}}({{\mathit{xv}}^\ast})`.
 
 
-:math:`{\mathrm{mems}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-............................................................................................
+:math:`{\mathrm{mems}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+.............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{mem}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{mem}`, then:
 
-   a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be :math:`{\mathit{externaddr}}_0`.
 
    #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{xv}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
 #. Return :math:`{\mathrm{mems}}({{\mathit{xv}}^\ast})`.
 
@@ -1713,88 +1713,88 @@ watsup 0.4 generator
    #. Return :math:`{\mathit{mi}'}`.
 
 
-:math:`{\mathrm{funcs}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-.............................................................................................
+:math:`{\mathrm{funcs}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+..............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{func}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{func}`, then:
 
-   a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{externval}'}^\ast})`.
+   #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{externaddr}'}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{funcs}}({{\mathit{externval}'}^\ast})`.
+#. Return :math:`{\mathrm{funcs}}({{\mathit{externaddr}'}^\ast})`.
 
 
-:math:`{\mathrm{globals}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-...............................................................................................
+:math:`{\mathrm{globals}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+................................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{global}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{global}`, then:
 
-   a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{externval}'}^\ast})`.
+   #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{externaddr}'}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{globals}}({{\mathit{externval}'}^\ast})`.
+#. Return :math:`{\mathrm{globals}}({{\mathit{externaddr}'}^\ast})`.
 
 
-:math:`{\mathrm{tables}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-..............................................................................................
+:math:`{\mathrm{tables}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+...............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{table}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{table}`, then:
 
-   a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{externval}'}^\ast})`.
+   #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{externaddr}'}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{tables}}({{\mathit{externval}'}^\ast})`.
+#. Return :math:`{\mathrm{tables}}({{\mathit{externaddr}'}^\ast})`.
 
 
-:math:`{\mathrm{mems}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-............................................................................................
+:math:`{\mathrm{mems}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+.............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{mem}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{mem}`, then:
 
-   a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{externval}'}^\ast})`.
+   #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{externaddr}'}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{mems}}({{\mathit{externval}'}^\ast})`.
+#. Return :math:`{\mathrm{mems}}({{\mathit{externaddr}'}^\ast})`.
 
 
 :math:`{\mathrm{allocfunc}}({\mathit{moduleinst}}, {\mathit{func}})`
@@ -1937,38 +1937,38 @@ watsup 0.4 generator
 
    a. Let :math:`(\mathsf{func}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{func}~{{\mathit{fa}}^\ast}{}[x]) \}\end{array}`.
+   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{func}~{{\mathit{fa}}^\ast}{}[x]) \}\end{array}`.
 
 #. If :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{global}`, then:
 
    a. Let :math:`(\mathsf{global}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{global}~{{\mathit{ga}}^\ast}{}[x]) \}\end{array}`.
+   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{global}~{{\mathit{ga}}^\ast}{}[x]) \}\end{array}`.
 
 #. If :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{table}`, then:
 
    a. Let :math:`(\mathsf{table}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{table}~{{\mathit{ta}}^\ast}{}[x]) \}\end{array}`.
+   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{table}~{{\mathit{ta}}^\ast}{}[x]) \}\end{array}`.
 
 #. Assert: Due to validation, :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{mem}`.
 
 #. Let :math:`(\mathsf{mem}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-#. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{mem}~{{\mathit{ma}}^\ast}{}[x]) \}\end{array}`.
+#. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{mem}~{{\mathit{ma}}^\ast}{}[x]) \}\end{array}`.
 
 
-:math:`{\mathrm{allocmodule}}({\mathit{module}}, {{\mathit{externval}}^\ast}, {{\mathit{val}}^\ast})`
-.....................................................................................................
+:math:`{\mathrm{allocmodule}}({\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}^\ast})`
+......................................................................................................
 
 
-1. Let :math:`{{\mathit{fa}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{funcs}}({{\mathit{externval}}^\ast})`.
+1. Let :math:`{{\mathit{fa}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{funcs}}({{\mathit{externaddr}}^\ast})`.
 
-#. Let :math:`{{\mathit{ga}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{globals}}({{\mathit{externval}}^\ast})`.
+#. Let :math:`{{\mathit{ga}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{globals}}({{\mathit{externaddr}}^\ast})`.
 
-#. Let :math:`{{\mathit{ma}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{mems}}({{\mathit{externval}}^\ast})`.
+#. Let :math:`{{\mathit{ma}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{mems}}({{\mathit{externaddr}}^\ast})`.
 
-#. Let :math:`{{\mathit{ta}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{tables}}({{\mathit{externval}}^\ast})`.
+#. Let :math:`{{\mathit{ta}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{tables}}({{\mathit{externaddr}}^\ast})`.
 
 #. Assert: Due to validation, :math:`{\mathit{module}}` is of the case :math:`\mathsf{module}`.
 
@@ -2067,8 +2067,8 @@ watsup 0.4 generator
 #. Return.
 
 
-:math:`{\mathrm{instantiate}}(z, {\mathit{module}}, {{\mathit{externval}}^\ast})`
-.................................................................................
+:math:`{\mathrm{instantiate}}(z, {\mathit{module}}, {{\mathit{externaddr}}^\ast})`
+..................................................................................
 
 
 1. Assert: Due to validation, :math:`{\mathit{module}}` is of the case :math:`\mathsf{module}`.
@@ -2097,7 +2097,7 @@ watsup 0.4 generator
 
 #. Let :math:`{(\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}}_{\mathsf{g}})^\ast}` be :math:`{{\mathit{global}}^\ast}`.
 
-#. Let :math:`{\mathit{moduleinst}}_{\mathit{init}}` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~{{\mathit{functype}}^\ast},\; \mathsf{funcs}~{\mathrm{funcs}}({{\mathit{externval}}^\ast})~{{|s{.}\mathsf{funcs}|} + i_{\mathsf{f}}^{i_{\mathsf{f}} |$mem(z, 0).BYTES|), then:
+6. Let t be valtype_u2.
+7. If ((((i + ao.OFFSET) + ($size(t) / 8)) > |$mem(z, 0).BYTES|) and ((valtype_u0 is t) and sz_u1? is not defined)), then:
+  a. Trap.
+8. If ((valtype_u0 is t) and sz_u1? is not defined), then:
+  a. Let b* be $bytes_(t, c).
+  b. Perform $with_mem(z, 0, (i + ao.OFFSET), ($size(t) / 8), b*).
+9. If the type of valtype_u2 is Inn, then:
+  a. Let Inn be valtype_u2.
+  b. If ((valtype_u0 is Inn) and sz_u1? is defined), then:
+    1) Let ?(n) be sz_u1?.
+    2) If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then:
       a) Trap.
-    2) Let b* be $bytes_(t, c).
-    3) Perform $with_mem(z, 0, (i + ao.OFFSET), ($size(t) / 8), b*).
-7. Else:
-  a. Let ?(n) be sz_u2?.
-  b. If the type of valtype_u1 is Inn, then:
-    1) Let Inn be valtype_u1.
-    2) If (valtype_u0 is Inn), then:
-      a) If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then:
-        1. Trap.
-      b) Let b* be $ibytes_(n, $wrap__($size(Inn), n, c)).
-      c) Perform $with_mem(z, 0, (i + ao.OFFSET), (n / 8), b*).
+    3) Let b* be $ibytes_(n, $wrap__($size(Inn), n, c)).
+    4) Perform $with_mem(z, 0, (i + ao.OFFSET), (n / 8), b*).
 
 Step/memory.grow
 1. Let z be the current state.
@@ -7014,86 +7036,86 @@ watsup 0.4 generator
 #. Return :math:`(\mathsf{ref{.}null}~\mathsf{externref})`.
 
 
-:math:`{\mathrm{funcs}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-.............................................................................................
+:math:`{\mathrm{funcs}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+..............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{func}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{func}`, then:
 
-   a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be :math:`{\mathit{externaddr}}_0`.
 
    #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{xv}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
 #. Return :math:`{\mathrm{funcs}}({{\mathit{xv}}^\ast})`.
 
 
-:math:`{\mathrm{globals}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-...............................................................................................
+:math:`{\mathrm{globals}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+................................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{global}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{global}`, then:
 
-   a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be :math:`{\mathit{externaddr}}_0`.
 
    #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{xv}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
 #. Return :math:`{\mathrm{globals}}({{\mathit{xv}}^\ast})`.
 
 
-:math:`{\mathrm{tables}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-..............................................................................................
+:math:`{\mathrm{tables}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+...............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{table}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{table}`, then:
 
-   a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be :math:`{\mathit{externaddr}}_0`.
 
    #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{xv}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
 #. Return :math:`{\mathrm{tables}}({{\mathit{xv}}^\ast})`.
 
 
-:math:`{\mathrm{mems}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-............................................................................................
+:math:`{\mathrm{mems}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+.............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{mem}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{mem}`, then:
 
-   a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be :math:`{\mathit{externaddr}}_0`.
 
    #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{xv}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
 #. Return :math:`{\mathrm{mems}}({{\mathit{xv}}^\ast})`.
 
@@ -7373,88 +7395,88 @@ watsup 0.4 generator
 #. Return :math:`z{.}\mathsf{types}{}[x]`.
 
 
-:math:`{\mathrm{funcs}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-.............................................................................................
+:math:`{\mathrm{funcs}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+..............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{func}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{func}`, then:
 
-   a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{externval}'}^\ast})`.
+   #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{externaddr}'}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{funcs}}({{\mathit{externval}'}^\ast})`.
+#. Return :math:`{\mathrm{funcs}}({{\mathit{externaddr}'}^\ast})`.
 
 
-:math:`{\mathrm{globals}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-...............................................................................................
+:math:`{\mathrm{globals}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+................................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{global}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{global}`, then:
 
-   a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{externval}'}^\ast})`.
+   #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{externaddr}'}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{globals}}({{\mathit{externval}'}^\ast})`.
+#. Return :math:`{\mathrm{globals}}({{\mathit{externaddr}'}^\ast})`.
 
 
-:math:`{\mathrm{tables}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-..............................................................................................
+:math:`{\mathrm{tables}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+...............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{table}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{table}`, then:
 
-   a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{externval}'}^\ast})`.
+   #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{externaddr}'}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{tables}}({{\mathit{externval}'}^\ast})`.
+#. Return :math:`{\mathrm{tables}}({{\mathit{externaddr}'}^\ast})`.
 
 
-:math:`{\mathrm{mems}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-............................................................................................
+:math:`{\mathrm{mems}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+.............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{mem}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{mem}`, then:
 
-   a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{externval}'}^\ast})`.
+   #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{externaddr}'}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{externval}'}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{externaddr}'}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{mems}}({{\mathit{externval}'}^\ast})`.
+#. Return :math:`{\mathrm{mems}}({{\mathit{externaddr}'}^\ast})`.
 
 
 :math:`{\mathrm{allocfunc}}({\mathit{moduleinst}}, {\mathit{func}})`
@@ -7663,38 +7685,38 @@ watsup 0.4 generator
 
    a. Let :math:`(\mathsf{func}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{func}~{{\mathit{fa}}^\ast}{}[x]) \}\end{array}`.
+   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{func}~{{\mathit{fa}}^\ast}{}[x]) \}\end{array}`.
 
 #. If :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{global}`, then:
 
    a. Let :math:`(\mathsf{global}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{global}~{{\mathit{ga}}^\ast}{}[x]) \}\end{array}`.
+   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{global}~{{\mathit{ga}}^\ast}{}[x]) \}\end{array}`.
 
 #. If :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{table}`, then:
 
    a. Let :math:`(\mathsf{table}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{table}~{{\mathit{ta}}^\ast}{}[x]) \}\end{array}`.
+   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{table}~{{\mathit{ta}}^\ast}{}[x]) \}\end{array}`.
 
 #. Assert: Due to validation, :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{mem}`.
 
 #. Let :math:`(\mathsf{mem}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-#. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{mem}~{{\mathit{ma}}^\ast}{}[x]) \}\end{array}`.
+#. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{mem}~{{\mathit{ma}}^\ast}{}[x]) \}\end{array}`.
 
 
-:math:`{\mathrm{allocmodule}}({\mathit{module}}, {{\mathit{externval}}^\ast}, {{\mathit{val}}^\ast}, {{{\mathit{ref}}^\ast}^\ast})`
-...................................................................................................................................
+:math:`{\mathrm{allocmodule}}({\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}^\ast}, {{{\mathit{ref}}^\ast}^\ast})`
+....................................................................................................................................
 
 
-1. Let :math:`{{\mathit{fa}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{funcs}}({{\mathit{externval}}^\ast})`.
+1. Let :math:`{{\mathit{fa}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{funcs}}({{\mathit{externaddr}}^\ast})`.
 
-#. Let :math:`{{\mathit{ga}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{globals}}({{\mathit{externval}}^\ast})`.
+#. Let :math:`{{\mathit{ga}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{globals}}({{\mathit{externaddr}}^\ast})`.
 
-#. Let :math:`{{\mathit{ma}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{mems}}({{\mathit{externval}}^\ast})`.
+#. Let :math:`{{\mathit{ma}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{mems}}({{\mathit{externaddr}}^\ast})`.
 
-#. Let :math:`{{\mathit{ta}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{tables}}({{\mathit{externval}}^\ast})`.
+#. Let :math:`{{\mathit{ta}}_{\mathit{ex}}^\ast}` be :math:`{\mathrm{tables}}({{\mathit{externaddr}}^\ast})`.
 
 #. Assert: Due to validation, :math:`{\mathit{module}}` is of the case :math:`\mathsf{module}`.
 
@@ -7807,8 +7829,8 @@ watsup 0.4 generator
 #. Return :math:`{{\mathit{instr}}^\ast}~(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)~(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n)~(\mathsf{memory{.}init}~i)~(\mathsf{data{.}drop}~i)`.
 
 
-:math:`{\mathrm{instantiate}}(z, {\mathit{module}}, {{\mathit{externval}}^\ast})`
-.................................................................................
+:math:`{\mathrm{instantiate}}(z, {\mathit{module}}, {{\mathit{externaddr}}^\ast})`
+..................................................................................
 
 
 1. Assert: Due to validation, :math:`{\mathit{module}}` is of the case :math:`\mathsf{module}`.
@@ -7841,7 +7863,7 @@ watsup 0.4 generator
 
 #. Let :math:`{{\mathit{instr}}_{\mathsf{e}}^\ast}` be :math:`{\mathrm{concat}}({{\mathrm{runelem}}({{\mathit{elem}}^\ast}{}[i], i)^{i |$mem(z, 0).BYTES|), then:
-    1) Trap.
-  b. Let c be $vbytes__1^-1(V128, $mem(z, 0).BYTES[(i + ao.OFFSET) : ($size(V128) / 8)]).
-  c. Push the value (V128.CONST c) to the stack.
-5. Else:
+4. If ((((i + ao.OFFSET) + ($size(V128) / 8)) > |$mem(z, 0).BYTES|) and vloadop_u0? is not defined), then:
+  a. Trap.
+5. If vloadop_u0? is not defined, then:
+  a. Let c be $vbytes__1^-1(V128, $mem(z, 0).BYTES[(i + ao.OFFSET) : ($size(V128) / 8)]).
+  b. Push the value (V128.CONST c) to the stack.
+6. Else:
   a. Let ?(vloadop_0) be vloadop_u0?.
   b. If vloadop_0 is of the case SHAPE, then:
     1) Let (SHAPE M X N sx) be vloadop_0.
@@ -12135,9 +12178,6 @@ Step_read/memory.init x
   f. Push the value (I32.CONST (n - 1)) to the stack.
   g. Execute the instruction (MEMORY.INIT x).
 
-Step/ctxt
-1. YetI: TODO: It is likely that the value stack of two rules are different.
-
 Step/local.set x
 1. Let z be the current state.
 2. Assert: Due to validation, a value is on the top of the stack.
@@ -12177,28 +12217,26 @@ Step/elem.drop x
 1. Let z be the current state.
 2. Perform $with_elem(z, x, []).
 
-Step/store numtype_u1 sz_u2? ao
+Step/store numtype_u0 sz_u1? ao
 1. Let z be the current state.
-2. Assert: Due to validation, a value of value type numtype_u0 is on the top of the stack.
-3. Pop the value (numtype_u0.CONST c) from the stack.
+2. Assert: Due to validation, a value of value type numtype_u2 is on the top of the stack.
+3. Pop the value (numtype_u2.CONST c) from the stack.
 4. Assert: Due to validation, a value of value type I32 is on the top of the stack.
 5. Pop the value (I32.CONST i) from the stack.
-6. If sz_u2? is not defined, then:
-  a. Let nt be numtype_u1.
-  b. If (numtype_u0 is nt), then:
-    1) If (((i + ao.OFFSET) + ($size(nt) / 8)) > |$mem(z, 0).BYTES|), then:
+6. Let nt be numtype_u2.
+7. If ((((i + ao.OFFSET) + ($size(nt) / 8)) > |$mem(z, 0).BYTES|) and ((numtype_u0 is nt) and sz_u1? is not defined)), then:
+  a. Trap.
+8. If ((numtype_u0 is nt) and sz_u1? is not defined), then:
+  a. Let b* be $nbytes_(nt, c).
+  b. Perform $with_mem(z, 0, (i + ao.OFFSET), ($size(nt) / 8), b*).
+9. If the type of numtype_u2 is Inn, then:
+  a. Let Inn be numtype_u2.
+  b. If ((numtype_u0 is Inn) and sz_u1? is defined), then:
+    1) Let ?(n) be sz_u1?.
+    2) If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then:
       a) Trap.
-    2) Let b* be $nbytes_(nt, c).
-    3) Perform $with_mem(z, 0, (i + ao.OFFSET), ($size(nt) / 8), b*).
-7. Else:
-  a. Let ?(n) be sz_u2?.
-  b. If the type of numtype_u1 is Inn, then:
-    1) Let Inn be numtype_u1.
-    2) If (numtype_u0 is Inn), then:
-      a) If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, 0).BYTES|), then:
-        1. Trap.
-      b) Let b* be $ibytes_(n, $wrap__($size(Inn), n, c)).
-      c) Perform $with_mem(z, 0, (i + ao.OFFSET), (n / 8), b*).
+    3) Let b* be $ibytes_(n, $wrap__($size(Inn), n, c)).
+    4) Perform $with_mem(z, 0, (i + ao.OFFSET), (n / 8), b*).
 
 Step/vstore V128 ao
 1. Let z be the current state.
@@ -12256,10 +12294,10 @@ watsup 0.4 generator
 == IL Validation after pass sideconditions...
 == Translating to AL...
 == Prose Generation...
-6-typing.watsup:194.10-194.32: if_expr_to_instrs: Yet `$before(typeuse, x, i)`
-6-typing.watsup:817.9-817.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
-6-typing.watsup:851.9-851.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
-6-typing.watsup:1309.9-1309.30: if_expr_to_instrs: Yet `$disjoint_(syntax name, nm*{nm : name})`
+6-typing.watsup:195.10-195.32: if_expr_to_instrs: Yet `$before(typeuse, x, i)`
+6-typing.watsup:876.9-876.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
+6-typing.watsup:910.9-910.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
+6-typing.watsup:1378.9-1378.30: if_expr_to_instrs: Yet `$disjoint_(syntax name, nm*{nm : name})`
 
 * :math:`{\mathit{numtype}}` is valid.
 
@@ -12799,6 +12837,14 @@ watsup 0.4 generator
    * :math:`{\mathit{limits}}` is valid with type :math:`{2^{16}}`.
 
 
+* :math:`{\mathit{deftype}}` is valid if and only if:
+
+
+   * :math:`{\mathit{deftype}}` is valid.
+
+   * :math:`{\mathrm{expand}}({\mathit{deftype}})` must be equal to :math:`(\mathsf{func}~{\mathit{functype}})`.
+
+
 * :math:`{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is valid if and only if:
 
 
@@ -12822,7 +12868,11 @@ watsup 0.4 generator
 
       * :math:`{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` must be equal to :math:`(\mathsf{mem}~{\mathit{memtype}})`.
 
-      * :math:`{\mathit{memtype}}` is valid.
+      * :math:`{\mathit{memtype}}` is valid.   * Or:
+
+      * :math:`{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` must be equal to :math:`(\mathsf{tag}~{\mathit{tagtype}})`.
+
+      * :math:`{\mathit{tagtype}}` is valid.
 
 
 * :math:`({t_{11}^\ast}~{\rightarrow}_{{x_1^\ast}}\,{t_{12}^\ast})` matches :math:`({t_{21}^\ast}~{\rightarrow}_{{x_2^\ast}}\,{t_{22}^\ast})` if and only if:
@@ -12891,6 +12941,14 @@ watsup 0.4 generator
    * :math:`{\mathit{limits}}_1` matches :math:`{\mathit{limits}}_2`.
 
 
+* :math:`{\mathit{deftype}}_1` matches :math:`{\mathit{deftype}}_2` if and only if:
+
+
+   * :math:`{\mathit{deftype}}_1` matches :math:`{\mathit{deftype}}_2`.
+
+   * :math:`{\mathit{deftype}}_2` matches :math:`{\mathit{deftype}}_1`.
+
+
 * :math:`{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` matches :math:`{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` if and only if:
 
 
@@ -12920,7 +12978,13 @@ watsup 0.4 generator
 
       * :math:`{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` must be equal to :math:`(\mathsf{mem}~{\mathit{memtype}}_2)`.
 
-      * :math:`{\mathit{memtype}}_1` matches :math:`{\mathit{memtype}}_2`.
+      * :math:`{\mathit{memtype}}_1` matches :math:`{\mathit{memtype}}_2`.   * Or:
+
+      * :math:`{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` must be equal to :math:`(\mathsf{tag}~{\mathit{tagtype}}_1)`.
+
+      * :math:`{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` must be equal to :math:`(\mathsf{tag}~{\mathit{tagtype}}_2)`.
+
+      * :math:`{\mathit{tagtype}}_1` matches :math:`{\mathit{tagtype}}_2`.
 
 
 * :math:`{\mathit{blocktype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is valid with type :math:`({{\mathit{valtype}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}~{\rightarrow}_{\epsilon}\,{{\mathit{valtype}}_{\mathit{u{\kern-0.1em\scriptstyle 2}}}^\ast})` if and only if:
@@ -12951,6 +13015,46 @@ watsup 0.4 generator
       * :math:`{\mathrm{expand}}(C{.}\mathsf{types}{}[{\mathit{typeidx}}])` must be equal to :math:`(\mathsf{func}~({t_1^\ast}~\rightarrow~{t_2^\ast}))`.
 
 
+* :math:`{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is valid if and only if:
+
+
+   * Either:
+
+      * :math:`{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` must be equal to :math:`(\mathsf{catch}~x~l)`.
+
+      * :math:`{|C{.}\mathsf{tags}|}` must be greater than :math:`x`.
+
+      * :math:`{|C{.}\mathsf{labels}|}` must be greater than :math:`l`.
+
+      * :math:`{\mathrm{expand}}(C{.}\mathsf{tags}{}[x])` must be equal to :math:`(\mathsf{func}~({t^\ast}~\rightarrow~\epsilon))`.
+
+      * :math:`{t^\ast}` matches :math:`C{.}\mathsf{labels}{}[l]`.
+
+   * Or:
+
+      * :math:`{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` must be equal to :math:`(\mathsf{catch\_ref}~x~l)`.
+
+      * :math:`{|C{.}\mathsf{tags}|}` must be greater than :math:`x`.
+
+      * :math:`{|C{.}\mathsf{labels}|}` must be greater than :math:`l`.
+
+      * :math:`{\mathrm{expand}}(C{.}\mathsf{tags}{}[x])` must be equal to :math:`(\mathsf{func}~({t^\ast}~\rightarrow~\epsilon))`.
+
+      * :math:`{t^\ast}~(\mathsf{ref}~(\mathsf{null}~\epsilon~{}^?)~\mathsf{exn})` matches :math:`C{.}\mathsf{labels}{}[l]`.   * Or:
+
+      * :math:`{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` must be equal to :math:`(\mathsf{catch\_all}~l)`.
+
+      * :math:`{|C{.}\mathsf{labels}|}` must be greater than :math:`l`.
+
+      * :math:`\epsilon` matches :math:`C{.}\mathsf{labels}{}[l]`.   * Or:
+
+      * :math:`{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` must be equal to :math:`(\mathsf{catch\_all\_ref}~l)`.
+
+      * :math:`{|C{.}\mathsf{labels}|}` must be greater than :math:`l`.
+
+      * :math:`(\mathsf{ref}~(\mathsf{null}~\epsilon~{}^?)~\mathsf{exn})` matches :math:`C{.}\mathsf{labels}{}[l]`.
+
+
 * :math:`\mathsf{nop}` is valid with type :math:`(\epsilon~{\rightarrow}_{\epsilon}\,\epsilon)`.
 
 
@@ -13170,6 +13274,34 @@ watsup 0.4 generator
    * :math:`({t_3^\ast}~{\rightarrow}_{\epsilon}\,{t_4^\ast})` is valid.
 
 
+* :math:`(\mathsf{throw}~x)` is valid with type :math:`({t_1^\ast}~{t^\ast}~{\rightarrow}_{\epsilon}\,{t_2^\ast})` if and only if:
+
+
+   * :math:`{|C{.}\mathsf{tags}|}` must be greater than :math:`x`.
+
+   * :math:`{\mathrm{expand}}(C{.}\mathsf{tags}{}[x])` must be equal to :math:`(\mathsf{func}~({t^\ast}~\rightarrow~\epsilon))`.
+
+   * :math:`({t_1^\ast}~{\rightarrow}_{\epsilon}\,{t_2^\ast})` is valid.
+
+
+* :math:`\mathsf{throw\_ref}` is valid with type :math:`({t_1^\ast}~(\mathsf{ref}~(\mathsf{null}~()~{}^?)~\mathsf{exn})~{\rightarrow}_{\epsilon}\,{t_2^\ast})` if and only if:
+
+
+   * :math:`({t_1^\ast}~{\rightarrow}_{\epsilon}\,{t_2^\ast})` is valid.
+
+
+* :math:`(\mathsf{try\_table}~{\mathit{bt}}~{{\mathit{catch}}^\ast}~{{\mathit{instr}}^\ast})` is valid with type :math:`({t_1^\ast}~{\rightarrow}_{\epsilon}\,{t_2^\ast})` if and only if:
+
+
+   * :math:`{\mathit{bt}}` is valid with type :math:`({t_1^\ast}~{\rightarrow}_{\epsilon}\,{t_2^\ast})`.
+
+   * Under the context :math:`C{}[{.}\mathsf{labels} \mathrel{{=}{\oplus}} {t_2^\ast}]`, :math:`{{\mathit{instr}}^\ast}` is valid with type :math:`({t_1^\ast}~{\rightarrow}_{{x^\ast}}\,{t_2^\ast})`.
+
+   * For all :math:`{\mathit{catch}}` in :math:`{{\mathit{catch}}^\ast}`,
+
+      * :math:`{\mathit{catch}}` is valid.
+
+
 * :math:`({\mathit{nt}}{.}\mathsf{const}~c_{\mathit{nt}})` is valid with type :math:`(\epsilon~{\rightarrow}_{\epsilon}\,{\mathit{nt}})`.
 
 
@@ -13922,6 +14054,14 @@ watsup 0.4 generator
    * :math:`{\mathit{memtype}}` is valid.
 
 
+* :math:`(\mathsf{tag}~x)` is valid with type :math:`C{.}\mathsf{types}{}[x]` if and only if:
+
+
+   * :math:`{|C{.}\mathsf{types}|}` must be greater than :math:`x`.
+
+   * :math:`{\mathrm{expand}}(C{.}\mathsf{types}{}[x])` must be equal to :math:`(\mathsf{func}~{\mathit{functype}})`.
+
+
 * :math:`{\mathit{elemmode}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is valid with type :math:`{\mathit{rt}}` if and only if:
 
 
@@ -14037,7 +14177,15 @@ watsup 0.4 generator
 
       * :math:`{|C{.}\mathsf{mems}|}` must be greater than :math:`x`.
 
-      * :math:`C{.}\mathsf{mems}{}[x]` must be equal to :math:`{\mathit{mt}}`.
+      * :math:`C{.}\mathsf{mems}{}[x]` must be equal to :math:`{\mathit{mt}}`.   * Or:
+
+      * :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` must be equal to :math:`(\mathsf{tag}~x)`.
+
+      * :math:`{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` must be equal to :math:`(\mathsf{tag}~{\mathit{at}})`.
+
+      * :math:`{|C{.}\mathsf{tags}|}` must be greater than :math:`x`.
+
+      * :math:`C{.}\mathsf{tags}{}[x]` must be equal to :math:`{\mathit{at}}`.
 
 
 * :math:`(\mathsf{export}~{\mathit{name}}~{\mathit{externidx}})` is valid with type :math:`{\mathit{name}}` and :math:`{\mathit{xt}}` if and only if:
@@ -14086,7 +14234,7 @@ watsup 0.4 generator
       * Under the context :math:`C{}[{.}\mathsf{types} \mathrel{{=}{\oplus}} {{\mathit{dt}}_1^\ast}]`, :math:`{{\mathit{type}}^\ast}` is valid with type :math:`{{\mathit{dt}}^\ast}`.
 
 
-* :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` is valid with type :math:`{{\mathrm{clos}}}_{C}(({{\mathit{xt}}_{\mathsf{i}}^\ast}~\rightarrow~{{\mathit{xt}}_{\mathsf{e}}^\ast}))` if and only if:
+* :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` is valid with type :math:`{{\mathrm{clos}}}_{C}(({{\mathit{xt}}_{\mathsf{i}}^\ast}~\rightarrow~{{\mathit{xt}}_{\mathsf{e}}^\ast}))` if and only if:
 
 
    * :math:`{|{{\mathit{xt}}_{\mathsf{i}}^\ast}|}` must be equal to :math:`{|{{\mathit{import}}^\ast}|}`.
@@ -14095,6 +14243,8 @@ watsup 0.4 generator
 
    * :math:`{|{{\mathit{mt}}^\ast}|}` must be equal to :math:`{|{{\mathit{mem}}^\ast}|}`.
 
+   * :math:`{|{{\mathit{tag}}^\ast}|}` must be equal to :math:`{|{{\mathit{at}}^\ast}|}`.
+
    * :math:`{|{{\mathit{func}}^\ast}|}` must be equal to :math:`{|{{\mathit{dt}}^\ast}|}`.
 
    * :math:`{|{{\mathit{rt}}^\ast}|}` must be equal to :math:`{|{{\mathit{elem}}^\ast}|}`.
@@ -14105,11 +14255,11 @@ watsup 0.4 generator
 
    * :math:`{|{{\mathit{xt}}_{\mathsf{e}}^\ast}|}` must be equal to :math:`{|{{\mathit{export}}^\ast}|}`.
 
-   * Under the context :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~\epsilon,\; \mathsf{recs}~\epsilon,\; \mathsf{funcs}~\epsilon,\; \mathsf{globals}~\epsilon,\; \mathsf{tables}~\epsilon,\; \mathsf{mems}~\epsilon,\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{locals}~\epsilon,\; \mathsf{labels}~\epsilon,\; \mathsf{return}~\epsilon,\; \mathsf{refs}~\epsilon \}\end{array}`, :math:`{{\mathit{type}}^\ast}` is valid with type :math:`{{\mathit{dt}'}^\ast}`.
+   * Under the context :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~\epsilon,\; \mathsf{recs}~\epsilon,\; \mathsf{funcs}~\epsilon,\; \mathsf{globals}~\epsilon,\; \mathsf{tables}~\epsilon,\; \mathsf{mems}~\epsilon,\; \mathsf{tags}~\epsilon,\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{locals}~\epsilon,\; \mathsf{labels}~\epsilon,\; \mathsf{return}~\epsilon,\; \mathsf{refs}~\epsilon \}\end{array}`, :math:`{{\mathit{type}}^\ast}` is valid with type :math:`{{\mathit{dt}'}^\ast}`.
 
    * For all :math:`{\mathit{import}}` in :math:`{{\mathit{import}}^\ast}` and :math:`{\mathit{xt}}_{\mathsf{i}}` in :math:`{{\mathit{xt}}_{\mathsf{i}}^\ast}`,
 
-      * Under the context :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~{{\mathit{dt}'}^\ast},\; \mathsf{recs}~\epsilon,\; \mathsf{funcs}~\epsilon,\; \mathsf{globals}~\epsilon,\; \mathsf{tables}~\epsilon,\; \mathsf{mems}~\epsilon,\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{locals}~\epsilon,\; \mathsf{labels}~\epsilon,\; \mathsf{return}~\epsilon,\; \mathsf{refs}~\epsilon \}\end{array}`, :math:`{\mathit{import}}` is valid with type :math:`{\mathit{xt}}_{\mathsf{i}}`.
+      * Under the context :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~{{\mathit{dt}'}^\ast},\; \mathsf{recs}~\epsilon,\; \mathsf{funcs}~\epsilon,\; \mathsf{globals}~\epsilon,\; \mathsf{tables}~\epsilon,\; \mathsf{mems}~\epsilon,\; \mathsf{tags}~\epsilon,\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{locals}~\epsilon,\; \mathsf{labels}~\epsilon,\; \mathsf{return}~\epsilon,\; \mathsf{refs}~\epsilon \}\end{array}`, :math:`{\mathit{import}}` is valid with type :math:`{\mathit{xt}}_{\mathsf{i}}`.
 
    * Under the context :math:`{C'}`, :math:`{{\mathit{global}}^\ast}` is valid with type :math:`{{\mathit{gt}}^\ast}`.
 
@@ -14121,6 +14271,10 @@ watsup 0.4 generator
 
       * Under the context :math:`{C'}`, :math:`{\mathit{mem}}` is valid with type :math:`{\mathit{mt}}`.
 
+   * For all :math:`{\mathit{at}}` in :math:`{{\mathit{at}}^\ast}` and :math:`{\mathit{tag}}` in :math:`{{\mathit{tag}}^\ast}`,
+
+      * Under the context :math:`{C'}`, :math:`{\mathit{tag}}` is valid with type :math:`{\mathit{at}}`.
+
    * For all :math:`{\mathit{dt}}` in :math:`{{\mathit{dt}}^\ast}` and :math:`{\mathit{func}}` in :math:`{{\mathit{func}}^\ast}`,
 
       * :math:`{\mathit{func}}` is valid with type :math:`{\mathit{dt}}`.
@@ -14143,9 +14297,9 @@ watsup 0.4 generator
 
    * YetI: $disjoint_(syntax name, nm*{nm : name}).
 
-   * :math:`C` must be equal to :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~{{\mathit{dt}'}^\ast},\; \mathsf{recs}~\epsilon,\; \mathsf{funcs}~{{\mathit{dt}}_{\mathsf{i}}^\ast}~{{\mathit{dt}}^\ast},\; \mathsf{globals}~{{\mathit{gt}}_{\mathsf{i}}^\ast}~{{\mathit{gt}}^\ast},\; \mathsf{tables}~{{\mathit{tt}}_{\mathsf{i}}^\ast}~{{\mathit{tt}}^\ast},\; \mathsf{mems}~{{\mathit{mt}}_{\mathsf{i}}^\ast}~{{\mathit{mt}}^\ast},\; \mathsf{elems}~{{\mathit{rt}}^\ast},\; \mathsf{datas}~{{\mathit{ok}}^\ast},\; \mathsf{locals}~\epsilon,\; \mathsf{labels}~\epsilon,\; \mathsf{return}~\epsilon,\; \mathsf{refs}~{x^\ast} \}\end{array}`.
+   * :math:`C` must be equal to :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~{{\mathit{dt}'}^\ast},\; \mathsf{recs}~\epsilon,\; \mathsf{funcs}~{{\mathit{dt}}_{\mathsf{i}}^\ast}~{{\mathit{dt}}^\ast},\; \mathsf{globals}~{{\mathit{gt}}_{\mathsf{i}}^\ast}~{{\mathit{gt}}^\ast},\; \mathsf{tables}~{{\mathit{tt}}_{\mathsf{i}}^\ast}~{{\mathit{tt}}^\ast},\; \mathsf{mems}~{{\mathit{mt}}_{\mathsf{i}}^\ast}~{{\mathit{mt}}^\ast},\; \mathsf{tags}~{{\mathit{at}}_{\mathsf{i}}^\ast}~{{\mathit{at}}^\ast},\; \mathsf{elems}~{{\mathit{rt}}^\ast},\; \mathsf{datas}~{{\mathit{ok}}^\ast},\; \mathsf{locals}~\epsilon,\; \mathsf{labels}~\epsilon,\; \mathsf{return}~\epsilon,\; \mathsf{refs}~{x^\ast} \}\end{array}`.
 
-   * :math:`{C'}` must be equal to :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~{{\mathit{dt}'}^\ast},\; \mathsf{recs}~\epsilon,\; \mathsf{funcs}~{{\mathit{dt}}_{\mathsf{i}}^\ast}~{{\mathit{dt}}^\ast},\; \mathsf{globals}~{{\mathit{gt}}_{\mathsf{i}}^\ast},\; \mathsf{tables}~\epsilon,\; \mathsf{mems}~\epsilon,\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{locals}~\epsilon,\; \mathsf{labels}~\epsilon,\; \mathsf{return}~\epsilon,\; \mathsf{refs}~{x^\ast} \}\end{array}`.
+   * :math:`{C'}` must be equal to :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~{{\mathit{dt}'}^\ast},\; \mathsf{recs}~\epsilon,\; \mathsf{funcs}~{{\mathit{dt}}_{\mathsf{i}}^\ast}~{{\mathit{dt}}^\ast},\; \mathsf{globals}~{{\mathit{gt}}_{\mathsf{i}}^\ast},\; \mathsf{tables}~\epsilon,\; \mathsf{mems}~\epsilon,\; \mathsf{tags}~\epsilon,\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{locals}~\epsilon,\; \mathsf{labels}~\epsilon,\; \mathsf{return}~\epsilon,\; \mathsf{refs}~{x^\ast} \}\end{array}`.
 
    * :math:`{x^\ast}` must be equal to :math:`{\mathrm{funcidx}}(({{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}))`.
 
@@ -14157,6 +14311,8 @@ watsup 0.4 generator
 
    * :math:`{{\mathit{mt}}_{\mathsf{i}}^\ast}` must be equal to :math:`{\mathrm{mems}}({{\mathit{xt}}_{\mathsf{i}}^\ast})`.
 
+   * :math:`{{\mathit{at}}_{\mathsf{i}}^\ast}` must be equal to :math:`{\mathrm{tags}}({{\mathit{xt}}_{\mathsf{i}}^\ast})`.
+
 
 * :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is valid with type :math:`({{\mathit{valtype}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}~\rightarrow~{{\mathit{valtype}}_{\mathit{u{\kern-0.1em\scriptstyle 3}}}^\ast})` if and only if:
 
@@ -14879,7 +15035,7 @@ watsup 0.4 generator
 
    a. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~\epsilon,\; \mathsf{funcs}~\epsilon,\; \mathsf{globals}~\epsilon,\; \mathsf{tables}~\epsilon,\; \mathsf{mems}~\epsilon,\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{locals}~\epsilon,\; \mathsf{labels}~\epsilon \}\end{array}`.
 
-#. Return `YetE (free ++ $free_list(free'*{free' : free}))`.
+#. Return YetE: free ++ $free_list(free'*{free' : free}).
 
 
 :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`
@@ -15157,7 +15313,7 @@ watsup 0.4 generator
 ..........................................................................................................
 
 
-1. Return `YetE ($free_resulttype(resulttype_1) ++ $free_resulttype(resulttype_2))`.
+1. Return YetE: $free_resulttype(resulttype_1) ++ $free_resulttype(resulttype_2).
 
 
 :math:`{\mathrm{free}}_{\mathit{structtype}}({{\mathit{fieldtype}}^\ast})`
@@ -15201,7 +15357,7 @@ watsup 0.4 generator
 ...........................................................................................................................
 
 
-1. Return `YetE ($free_list($free_typeuse(typeuse)*{typeuse : typeuse}) ++ $free_comptype(comptype))`.
+1. Return YetE: $free_list($free_typeuse(typeuse)*{typeuse : typeuse}) ++ $free_comptype(comptype).
 
 
 :math:`{\mathrm{free}}_{\mathit{globaltype}}(({\mathsf{mut}^?}, {\mathit{valtype}}))`
@@ -15272,7 +15428,7 @@ watsup 0.4 generator
 ..........................................................................................................................
 
 
-1. Return `YetE ($free_list($free_externtype(externtype_1)*{externtype_1 : externtype}) ++ $free_list($free_externtype(externtype_2)*{externtype_2 : externtype}))`.
+1. Return YetE: $free_list($free_externtype(externtype_1)*{externtype_1 : externtype}) ++ $free_list($free_externtype(externtype_2)*{externtype_2 : externtype}).
 
 
 :math:`{\mathrm{free}}_{\mathit{blocktype}}({\mathit{blocktype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}})`
@@ -15351,15 +15507,15 @@ watsup 0.4 generator
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{block}`, then:
 
-   a. Return `YetE ($free_blocktype(blocktype) ++ $free_block(instr*{instr : instr}))`.
+   a. Return YetE: $free_blocktype(blocktype) ++ $free_block(instr*{instr : instr}).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{loop}`, then:
 
-   a. Return `YetE ($free_blocktype(blocktype) ++ $free_block(instr*{instr : instr}))`.
+   a. Return YetE: $free_blocktype(blocktype) ++ $free_block(instr*{instr : instr}).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{if}`, then:
 
-   a. Return `YetE ($free_blocktype(blocktype) ++ $free_block(instr_1*{instr_1 : instr}) ++ $free_block(instr_2*{instr_2 : instr}))`.
+   a. Return YetE: $free_blocktype(blocktype) ++ $free_block(instr_1*{instr_1 : instr}) ++ $free_block(instr_2*{instr_2 : instr}).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{br}`, then:
 
@@ -15375,7 +15531,7 @@ watsup 0.4 generator
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{br\_table}`, then:
 
-   a. Return `YetE ($free_list($free_labelidx(labelidx)*{}) ++ $free_labelidx(labelidx))`.
+   a. Return YetE: $free_list($free_labelidx(labelidx)*{}) ++ $free_labelidx(labelidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{br\_on\_null}`, then:
 
@@ -15391,11 +15547,11 @@ watsup 0.4 generator
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{br\_on\_cast}`, then:
 
-   a. Return `YetE ($free_labelidx(labelidx) ++ $free_reftype(reftype_1) ++ $free_reftype(reftype_2))`.
+   a. Return YetE: $free_labelidx(labelidx) ++ $free_reftype(reftype_1) ++ $free_reftype(reftype_2).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{br\_on\_cast\_fail}`, then:
 
-   a. Return `YetE ($free_labelidx(labelidx) ++ $free_reftype(reftype_1) ++ $free_reftype(reftype_2))`.
+   a. Return YetE: $free_labelidx(labelidx) ++ $free_reftype(reftype_1) ++ $free_reftype(reftype_2).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{call}`, then:
 
@@ -15411,7 +15567,7 @@ watsup 0.4 generator
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{call\_indirect}`, then:
 
-   a. Return `YetE ($free_tableidx(tableidx) ++ $free_typeuse(typeuse))`.
+   a. Return YetE: $free_tableidx(tableidx) ++ $free_typeuse(typeuse).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is :math:`\mathsf{return}`, then:
 
@@ -15431,7 +15587,7 @@ watsup 0.4 generator
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{return\_call\_indirect}`, then:
 
-   a. Return `YetE ($free_tableidx(tableidx) ++ $free_typeuse(typeuse))`.
+   a. Return YetE: $free_tableidx(tableidx) ++ $free_typeuse(typeuse).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{const}`, then:
 
@@ -15465,7 +15621,7 @@ watsup 0.4 generator
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{cvtop}`, then:
 
-   a. Return `YetE ($free_numtype(numtype_1) ++ $free_numtype(numtype_2))`.
+   a. Return YetE: $free_numtype(numtype_1) ++ $free_numtype(numtype_2).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{vconst}`, then:
 
@@ -15547,19 +15703,19 @@ watsup 0.4 generator
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{vextunop}`, then:
 
-   a. Return `YetE ($free_shape((ishape_1 : ishape <: shape)) ++ $free_shape((ishape_2 : ishape <: shape)))`.
+   a. Return YetE: $free_shape((ishape_1 : ishape <: shape)) ++ $free_shape((ishape_2 : ishape <: shape)).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{vextbinop}`, then:
 
-   a. Return `YetE ($free_shape((ishape_1 : ishape <: shape)) ++ $free_shape((ishape_2 : ishape <: shape)))`.
+   a. Return YetE: $free_shape((ishape_1 : ishape <: shape)) ++ $free_shape((ishape_2 : ishape <: shape)).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{vnarrow}`, then:
 
-   a. Return `YetE ($free_shape((ishape_1 : ishape <: shape)) ++ $free_shape((ishape_2 : ishape <: shape)))`.
+   a. Return YetE: $free_shape((ishape_1 : ishape <: shape)) ++ $free_shape((ishape_2 : ishape <: shape)).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{vcvtop}`, then:
 
-   a. Return `YetE ($free_shape(shape_1) ++ $free_shape(shape_2))`.
+   a. Return YetE: $free_shape(shape_1) ++ $free_shape(shape_2).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{vsplat}`, then:
 
@@ -15665,11 +15821,11 @@ watsup 0.4 generator
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{array{.}new\_data}`, then:
 
-   a. Return `YetE ($free_typeidx(typeidx) ++ $free_dataidx(dataidx))`.
+   a. Return YetE: $free_typeidx(typeidx) ++ $free_dataidx(dataidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{array{.}new\_elem}`, then:
 
-   a. Return `YetE ($free_typeidx(typeidx) ++ $free_elemidx(elemidx))`.
+   a. Return YetE: $free_typeidx(typeidx) ++ $free_elemidx(elemidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{array{.}get}`, then:
 
@@ -15695,15 +15851,15 @@ watsup 0.4 generator
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{array{.}copy}`, then:
 
-   a. Return `YetE ($free_typeidx(typeidx_1) ++ $free_typeidx(typeidx_2))`.
+   a. Return YetE: $free_typeidx(typeidx_1) ++ $free_typeidx(typeidx_2).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{array{.}init\_data}`, then:
 
-   a. Return `YetE ($free_typeidx(typeidx) ++ $free_dataidx(dataidx))`.
+   a. Return YetE: $free_typeidx(typeidx) ++ $free_dataidx(dataidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{array{.}init\_elem}`, then:
 
-   a. Return `YetE ($free_typeidx(typeidx) ++ $free_elemidx(elemidx))`.
+   a. Return YetE: $free_typeidx(typeidx) ++ $free_elemidx(elemidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is :math:`\mathsf{extern{.}convert\_any}`, then:
 
@@ -15775,11 +15931,11 @@ watsup 0.4 generator
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{table{.}copy}`, then:
 
-   a. Return `YetE ($free_tableidx(tableidx_1) ++ $free_tableidx(tableidx_2))`.
+   a. Return YetE: $free_tableidx(tableidx_1) ++ $free_tableidx(tableidx_2).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{table{.}init}`, then:
 
-   a. Return `YetE ($free_tableidx(tableidx) ++ $free_elemidx(elemidx))`.
+   a. Return YetE: $free_tableidx(tableidx) ++ $free_elemidx(elemidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{elem{.}drop}`, then:
 
@@ -15793,27 +15949,27 @@ watsup 0.4 generator
 
    #. If :math:`{\mathit{loadop\_{\scriptstyle 0}}}` is defined, then:
 
-      1) Return `YetE ($free_numtype(numtype) ++ $free_memidx(memidx))`.
+      1) Return YetE: $free_numtype(numtype) ++ $free_memidx(memidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{store}`, then:
 
-   a. Return `YetE ($free_numtype(numtype) ++ $free_memidx(memidx))`.
+   a. Return YetE: $free_numtype(numtype) ++ $free_memidx(memidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{vload}`, then:
 
-   a. Return `YetE ($free_vectype(vectype) ++ $free_memidx(memidx))`.
+   a. Return YetE: $free_vectype(vectype) ++ $free_memidx(memidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{vload\_lane}`, then:
 
-   a. Return `YetE ($free_vectype(vectype) ++ $free_memidx(memidx))`.
+   a. Return YetE: $free_vectype(vectype) ++ $free_memidx(memidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{vstore}`, then:
 
-   a. Return `YetE ($free_vectype(vectype) ++ $free_memidx(memidx))`.
+   a. Return YetE: $free_vectype(vectype) ++ $free_memidx(memidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{vstore\_lane}`, then:
 
-   a. Return `YetE ($free_vectype(vectype) ++ $free_memidx(memidx))`.
+   a. Return YetE: $free_vectype(vectype) ++ $free_memidx(memidx).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{memory{.}size}`, then:
 
@@ -15835,11 +15991,11 @@ watsup 0.4 generator
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{memory{.}copy}`, then:
 
-   a. Return `YetE ($free_memidx(memidx_1) ++ $free_memidx(memidx_2))`.
+   a. Return YetE: $free_memidx(memidx_1) ++ $free_memidx(memidx_2).
 
 #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{memory{.}init}`, then:
 
-   a. Return `YetE ($free_memidx(memidx) ++ $free_dataidx(dataidx))`.
+   a. Return YetE: $free_memidx(memidx) ++ $free_dataidx(dataidx).
 
 #. Assert: Due to validation, :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{data{.}drop}`.
 
@@ -15873,21 +16029,21 @@ watsup 0.4 generator
 ...................................................................................................................
 
 
-1. Return `YetE ($free_typeidx(typeidx) ++ $free_list($free_local(local)*{local : local}) ++ $free_block(expr)[LOCALS_free = []])`.
+1. Return YetE: $free_typeidx(typeidx) ++ $free_list($free_local(local)*{local : local}) ++ $free_block(expr)[LOCALS_free = []].
 
 
 :math:`{\mathrm{free}}_{\mathit{global}}((\mathsf{global}~{\mathit{globaltype}}~{\mathit{expr}}))`
 ..................................................................................................
 
 
-1. Return `YetE ($free_globaltype(globaltype) ++ $free_expr(expr))`.
+1. Return YetE: $free_globaltype(globaltype) ++ $free_expr(expr).
 
 
 :math:`{\mathrm{free}}_{\mathit{table}}((\mathsf{table}~{\mathit{tabletype}}~{\mathit{expr}}))`
 ...............................................................................................
 
 
-1. Return `YetE ($free_tabletype(tabletype) ++ $free_expr(expr))`.
+1. Return YetE: $free_tabletype(tabletype) ++ $free_expr(expr).
 
 
 :math:`{\mathrm{free}}_{\mathit{mem}}((\mathsf{memory}~{\mathit{memtype}}))`
@@ -15897,13 +16053,20 @@ watsup 0.4 generator
 1. Return :math:`{\mathrm{free}}_{\mathit{memtype}}({\mathit{memtype}})`.
 
 
+:math:`{\mathrm{free}}_{\mathit{tag}}((\mathsf{tag}~{\mathit{typeidx}}))`
+.........................................................................
+
+
+1. Return :math:`{\mathrm{free}}_{\mathit{typeidx}}({\mathit{typeidx}})`.
+
+
 :math:`{\mathrm{free}}_{\mathit{elemmode}}({\mathit{elemmode}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}})`
 ........................................................................................................
 
 
 1. If :math:`{\mathit{elemmode}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{active}`, then:
 
-   a. Return `YetE ($free_tableidx(tableidx) ++ $free_expr(expr))`.
+   a. Return YetE: $free_tableidx(tableidx) ++ $free_expr(expr).
 
 #. If :math:`{\mathit{elemmode}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is :math:`\mathsf{passive}`, then:
 
@@ -15920,7 +16083,7 @@ watsup 0.4 generator
 
 1. If :math:`{\mathit{datamode}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{active}`, then:
 
-   a. Return `YetE ($free_memidx(memidx) ++ $free_expr(expr))`.
+   a. Return YetE: $free_memidx(memidx) ++ $free_expr(expr).
 
 #. Assert: Due to validation, :math:`{\mathit{datamode}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is :math:`\mathsf{passive}`.
 
@@ -15931,7 +16094,7 @@ watsup 0.4 generator
 ......................................................................................................................
 
 
-1. Return `YetE ($free_reftype(reftype) ++ $free_list($free_expr(expr)*{expr : expr}) ++ $free_elemmode(elemmode))`.
+1. Return YetE: $free_reftype(reftype) ++ $free_list($free_expr(expr)*{expr : expr}) ++ $free_elemmode(elemmode).
 
 
 :math:`{\mathrm{free}}_{\mathit{data}}((\mathsf{data}~{{\mathit{byte}}^\ast}~{\mathit{datamode}}))`
@@ -15962,11 +16125,11 @@ watsup 0.4 generator
 1. Return :math:`{\mathrm{free}}_{\mathit{externtype}}({\mathit{externtype}})`.
 
 
-:math:`{\mathrm{free}}_{\mathit{module}}((\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast}))`
-......................................................................................................................................................................................................................................................................................................
+:math:`{\mathrm{free}}_{\mathit{module}}((\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast}))`
+............................................................................................................................................................................................................................................................................................................................
 
 
-1. Return `YetE ($free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export}))`.
+1. Return YetE: $free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_tag(tag)*{tag : tag}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export}).
 
 
 :math:`{\mathrm{funcidx}}({\mathit{module}})`
@@ -15995,7 +16158,11 @@ watsup 0.4 generator
 
 #. Let :math:`{\mathit{tu}}_1~{{\mathit{tu}'}^\ast}` be :math:`{{\mathit{typeuse}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
 
-#. If :math:`{|{{\mathit{typevar}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}|}` is greater than or equal to :math:`1`, then:
+#. If :math:`{|{{\mathit{typevar}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}|}` is less than :math:`1`, then:
+
+   a. Do nothing.
+
+#. Else:
 
    a. Let :math:`{\mathit{tv}}_1~{{\mathit{tv}'}^\ast}` be :math:`{{\mathit{typevar}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
@@ -16417,6 +16584,27 @@ watsup 0.4 generator
 #. Return :math:`{\mathrm{mems}}({{\mathit{xx}}^\ast})`.
 
 
+:math:`{\mathrm{tags}}({{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+............................................................................................
+
+
+1. If :math:`{{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+
+   a. Return :math:`\epsilon`.
+
+#. Let :math:`{\mathit{externidx}}_0~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+
+#. If :math:`{\mathit{externidx}}_0` is of the case :math:`\mathsf{tag}`, then:
+
+   a. Let :math:`(\mathsf{tag}~x)` be :math:`{\mathit{externidx}}_0`.
+
+   #. Return :math:`x~{\mathrm{tags}}({{\mathit{xx}}^\ast})`.
+
+#. Let :math:`{\mathit{externidx}}~{{\mathit{xx}}^\ast}` be :math:`{{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+
+#. Return :math:`{\mathrm{tags}}({{\mathit{xx}}^\ast})`.
+
+
 :math:`{\mathrm{funcs}}({{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
 ..............................................................................................
 
@@ -16501,18 +16689,39 @@ watsup 0.4 generator
 #. Return :math:`{\mathrm{mems}}({{\mathit{xt}}^\ast})`.
 
 
+:math:`{\mathrm{tags}}({{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+.............................................................................................
 
 
+1. If :math:`{{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
+   a. Return :math:`\epsilon`.
 
-1. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{align}~0,\; \mathsf{offset}~0 \}\end{array}`.
+#. Let :math:`{\mathit{externtype}}_0~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
+#. If :math:`{\mathit{externtype}}_0` is of the case :math:`\mathsf{tag}`, then:
 
-:math:`{{\mathrm{signed}}}_{N}(i)`
-..................................
+   a. Let :math:`(\mathsf{tag}~{\mathit{at}})` be :math:`{\mathit{externtype}}_0`.
 
+   #. Return :math:`{\mathit{at}}~{\mathrm{tags}}({{\mathit{xt}}^\ast})`.
+
+#. Let :math:`{\mathit{externtype}}~{{\mathit{xt}}^\ast}` be :math:`{{\mathit{externtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+
+#. Return :math:`{\mathrm{tags}}({{\mathit{xt}}^\ast})`.
+
+
+
+
+
+
+1. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{align}~0,\; \mathsf{offset}~0 \}\end{array}`.
+
+
+:math:`{{\mathrm{signed}}}_{N}(i)`
+..................................
 
-1. If :math:`0` is less than or equal to :math:`{2^{N - 1}}`, then:
+
+1. If :math:`0` is less than or equal to :math:`{2^{N - 1}}`, then:
 
    a. Return :math:`i`.
 
@@ -18018,88 +18227,109 @@ watsup 0.4 generator
    #. Return :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~{{{{\mathrm{extend}}}_{{|{\mathit{packtype}}|}, 32}^{{\mathit{sx}}}}}{(i)})`.
 
 
-:math:`{\mathrm{funcs}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-.............................................................................................
+:math:`{\mathrm{funcs}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+..............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{func}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{func}`, then:
 
-   a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{func}~{\mathit{fa}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{xv}}^\ast})`.
+   #. Return :math:`{\mathit{fa}}~{\mathrm{funcs}}({{\mathit{xa}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{funcs}}({{\mathit{xv}}^\ast})`.
+#. Return :math:`{\mathrm{funcs}}({{\mathit{xa}}^\ast})`.
+
+
+:math:`{\mathrm{globals}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+................................................................................................
+
+
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+
+   a. Return :math:`\epsilon`.
 
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-:math:`{\mathrm{globals}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{global}`, then:
+
+   a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be :math:`{\mathit{externaddr}}_0`.
+
+   #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{xa}}^\ast})`.
+
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+
+#. Return :math:`{\mathrm{globals}}({{\mathit{xa}}^\ast})`.
+
+
+:math:`{\mathrm{tables}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
 ...............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{global}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{table}`, then:
 
-   a. Let :math:`(\mathsf{global}~{\mathit{ga}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{ga}}~{\mathrm{globals}}({{\mathit{xv}}^\ast})`.
+   #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{xa}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{globals}}({{\mathit{xv}}^\ast})`.
+#. Return :math:`{\mathrm{tables}}({{\mathit{xa}}^\ast})`.
 
 
-:math:`{\mathrm{tables}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-..............................................................................................
+:math:`{\mathrm{mems}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+.............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{table}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{mem}`, then:
 
-   a. Let :math:`(\mathsf{table}~{\mathit{ta}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{ta}}~{\mathrm{tables}}({{\mathit{xv}}^\ast})`.
+   #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{xa}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{tables}}({{\mathit{xv}}^\ast})`.
+#. Return :math:`{\mathrm{mems}}({{\mathit{xa}}^\ast})`.
 
 
-:math:`{\mathrm{mems}}({{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
-............................................................................................
+:math:`{\mathrm{tags}}({{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+.............................................................................................
 
 
-1. If :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+1. If :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
 
    a. Return :math:`\epsilon`.
 
-#. Let :math:`{\mathit{externval}}_0~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}_0~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. If :math:`{\mathit{externval}}_0` is of the case :math:`\mathsf{mem}`, then:
+#. If :math:`{\mathit{externaddr}}_0` is of the case :math:`\mathsf{tag}`, then:
 
-   a. Let :math:`(\mathsf{mem}~{\mathit{ma}})` be :math:`{\mathit{externval}}_0`.
+   a. Let :math:`(\mathsf{tag}~{\mathit{ha}})` be :math:`{\mathit{externaddr}}_0`.
 
-   #. Return :math:`{\mathit{ma}}~{\mathrm{mems}}({{\mathit{xv}}^\ast})`.
+   #. Return :math:`{\mathit{ha}}~{\mathrm{tags}}({{\mathit{xa}}^\ast})`.
 
-#. Let :math:`{\mathit{externval}}~{{\mathit{xv}}^\ast}` be :math:`{{\mathit{externval}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+#. Let :math:`{\mathit{externaddr}}~{{\mathit{xa}}^\ast}` be :math:`{{\mathit{externaddr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
 
-#. Return :math:`{\mathrm{mems}}({{\mathit{xv}}^\ast})`.
+#. Return :math:`{\mathrm{tags}}({{\mathit{xa}}^\ast})`.
 
 
 :math:`{\mathrm{store}}`
@@ -18118,6 +18348,15 @@ watsup 0.4 generator
 #. Return :math:`f`.
 
 
+:math:`{\mathrm{tagaddr}}`
+..........................
+
+
+1. Let :math:`f` be the current frame.
+
+#. Return :math:`f{.}\mathsf{module}{.}\mathsf{tags}`.
+
+
 :math:`{\mathrm{moduleinst}}`
 .............................
 
@@ -18155,6 +18394,13 @@ watsup 0.4 generator
 1. Return :math:`s{.}\mathsf{mems}`.
 
 
+:math:`{\mathrm{taginst}}`
+..........................
+
+
+1. Return :math:`s{.}\mathsf{tags}`.
+
+
 :math:`{\mathrm{eleminst}}`
 ...........................
 
@@ -18183,6 +18429,13 @@ watsup 0.4 generator
 1. Return :math:`s{.}\mathsf{arrays}`.
 
 
+:math:`{\mathrm{exninst}}`
+..........................
+
+
+1. Return :math:`s{.}\mathsf{exns}`.
+
+
 :math:`{\mathrm{type}}(x)`
 ..........................
 
@@ -18228,6 +18481,15 @@ watsup 0.4 generator
 #. Return :math:`s{.}\mathsf{mems}{}[f{.}\mathsf{module}{.}\mathsf{mems}{}[x]]`.
 
 
+:math:`{\mathrm{tag}}(x)`
+.........................
+
+
+1. Let :math:`f` be the current frame.
+
+#. Return :math:`s{.}\mathsf{tags}{}[f{.}\mathsf{module}{.}\mathsf{tags}{}[x]]`.
+
+
 :math:`{\mathrm{elem}}(x)`
 ..........................
 
@@ -18355,6 +18617,13 @@ watsup 0.4 generator
 1. Append :math:`{{\mathit{ai}}^\ast}` to the :math:`s{.}\mathsf{arrays}`.
 
 
+:math:`{\mathrm{add}}_{\mathit{exninst}}({{\mathit{exn}}^\ast})`
+................................................................
+
+
+1. Append :math:`{{\mathit{exn}}^\ast}` to the :math:`s{.}\mathsf{exns}`.
+
+
 :math:`{\mathrm{growtable}}({\mathit{tableinst}}, n, r)`
 ........................................................
 
@@ -18577,6 +18846,36 @@ watsup 0.4 generator
 #. Return :math:`{\mathit{ma}}~{{\mathit{ma}'}^\ast}`.
 
 
+:math:`{\mathrm{alloctag}}({\mathit{at}})`
+..........................................
+
+
+1. Let :math:`{\mathit{taginst}}` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{type}~{\mathit{at}} \}\end{array}`.
+
+#. Let :math:`a` be :math:`{|s{.}\mathsf{tags}|}`.
+
+#. Append :math:`{\mathit{taginst}}` to the :math:`s{.}\mathsf{tags}`.
+
+#. Return :math:`a`.
+
+
+:math:`{\mathrm{alloctags}}({{\mathit{tagtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast})`
+...............................................................................................
+
+
+1. If :math:`{{\mathit{tagtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` is :math:`\epsilon`, then:
+
+   a. Return :math:`\epsilon`.
+
+#. Let :math:`{\mathit{at}}~{{\mathit{at}'}^\ast}` be :math:`{{\mathit{tagtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+
+#. Let :math:`{\mathit{aa}}` be :math:`{\mathrm{alloctag}}({\mathit{at}})`.
+
+#. Let :math:`{{\mathit{aa}'}^\ast}` be :math:`{\mathrm{alloctags}}({{\mathit{at}'}^\ast})`.
+
+#. Return :math:`{\mathit{aa}}~{{\mathit{aa}'}^\ast}`.
+
+
 :math:`{\mathrm{allocelem}}({\mathit{elemtype}}, {{\mathit{ref}}^\ast})`
 ........................................................................
 
@@ -18657,25 +18956,31 @@ watsup 0.4 generator
 
    a. Let :math:`(\mathsf{func}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{func}~{\mathit{moduleinst}}{.}\mathsf{funcs}{}[x]) \}\end{array}`.
+   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{func}~{\mathit{moduleinst}}{.}\mathsf{funcs}{}[x]) \}\end{array}`.
 
 #. If :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{global}`, then:
 
    a. Let :math:`(\mathsf{global}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{global}~{\mathit{moduleinst}}{.}\mathsf{globals}{}[x]) \}\end{array}`.
+   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{global}~{\mathit{moduleinst}}{.}\mathsf{globals}{}[x]) \}\end{array}`.
 
 #. If :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{table}`, then:
 
    a. Let :math:`(\mathsf{table}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{table}~{\mathit{moduleinst}}{.}\mathsf{tables}{}[x]) \}\end{array}`.
+   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{table}~{\mathit{moduleinst}}{.}\mathsf{tables}{}[x]) \}\end{array}`.
 
-#. Assert: Due to validation, :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{mem}`.
+#. If :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{mem}`, then:
 
-#. Let :math:`(\mathsf{mem}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+   a. Let :math:`(\mathsf{mem}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+
+   #. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{mem}~{\mathit{moduleinst}}{.}\mathsf{mems}{}[x]) \}\end{array}`.
+
+#. Assert: Due to validation, :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{tag}`.
+
+#. Let :math:`(\mathsf{tag}~x)` be :math:`{\mathit{externidx}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-#. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{value}~(\mathsf{mem}~{\mathit{moduleinst}}{.}\mathsf{mems}{}[x]) \}\end{array}`.
+#. Return :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{name}~{\mathit{name}},\; \mathsf{addr}~(\mathsf{tag}~{\mathit{moduleinst}}{.}\mathsf{tags}{}[x]) \}\end{array}`.
 
 
 :math:`{{{\mathrm{allocexport}}^\ast}}{({\mathit{moduleinst}}, {{\mathit{export}}^\ast})}`
@@ -18685,21 +18990,23 @@ watsup 0.4 generator
 1. Return :math:`{{\mathrm{allocexport}}({\mathit{moduleinst}}, {\mathit{export}})^\ast}`.
 
 
-:math:`{\mathrm{allocmodule}}({\mathit{module}}, {{\mathit{externval}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast}, {{{\mathit{ref}}_{\mathsf{e}}^\ast}^\ast})`
-.................................................................................................................................................................................................
+:math:`{\mathrm{allocmodule}}({\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast}, {{{\mathit{ref}}_{\mathsf{e}}^\ast}^\ast})`
+..................................................................................................................................................................................................
+
 
+1. Let :math:`{{\mathit{fa}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{funcs}}({{\mathit{externaddr}}^\ast})`.
 
-1. Let :math:`{{\mathit{fa}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{funcs}}({{\mathit{externval}}^\ast})`.
+#. Let :math:`{{\mathit{ga}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{globals}}({{\mathit{externaddr}}^\ast})`.
 
-#. Let :math:`{{\mathit{ga}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{globals}}({{\mathit{externval}}^\ast})`.
+#. Let :math:`{{\mathit{aa}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{tags}}({{\mathit{externaddr}}^\ast})`.
 
-#. Let :math:`{{\mathit{ma}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{mems}}({{\mathit{externval}}^\ast})`.
+#. Let :math:`{{\mathit{ma}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{mems}}({{\mathit{externaddr}}^\ast})`.
 
-#. Let :math:`{{\mathit{ta}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{tables}}({{\mathit{externval}}^\ast})`.
+#. Let :math:`{{\mathit{ta}}_{\mathsf{i}}^\ast}` be :math:`{\mathrm{tables}}({{\mathit{externaddr}}^\ast})`.
 
 #. Assert: Due to validation, :math:`{\mathit{module}}` is of the case :math:`\mathsf{module}`.
 
-#. Let :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` be :math:`{\mathit{module}}`.
+#. Let :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` be :math:`{\mathit{module}}`.
 
 #. Let :math:`{{\mathit{fa}}^\ast}` be :math:`{{|s{.}\mathsf{funcs}|} + i_{\mathsf{f}}^{i_{\mathsf{f}}<{|{{\mathit{func}}^\ast}|}}}`.
 
@@ -18707,6 +19014,8 @@ watsup 0.4 generator
 
 #. Let :math:`{{\mathit{ta}}^\ast}` be :math:`{{|s{.}\mathsf{tables}|} + i_{\mathsf{t}}^{i_{\mathsf{t}}<{|{{\mathit{table}}^\ast}|}}}`.
 
+#. Let :math:`{{\mathit{aa}}^\ast}` be :math:`{{|s{.}\mathsf{tags}|} + i_{\mathsf{a}}^{i_{\mathsf{a}}<{|{{\mathit{tag}}^\ast}|}}}`.
+
 #. Let :math:`{{\mathit{ma}}^\ast}` be :math:`{{|s{.}\mathsf{mems}|} + i_{\mathsf{m}}^{i_{\mathsf{m}}<{|{{\mathit{mem}}^\ast}|}}}`.
 
 #. Let :math:`{{\mathit{ea}}^\ast}` be :math:`{{|s{.}\mathsf{elems}|} + i_{\mathsf{e}}^{i_{\mathsf{e}}<{|{{\mathit{elem}}^\ast}|}}}`.
@@ -18719,6 +19028,10 @@ watsup 0.4 generator
 
 #. Let :math:`{{\mathit{dt}}^\ast}` be :math:`{{{\mathrm{alloctype}}^\ast}}{({{\mathit{type}}^\ast})}`.
 
+#. Assert: Due to validation, for all :math:`{({\mathit{tag}})^\ast}`, :math:`{\mathit{tag}}` is of the case :math:`\mathsf{tag}`.
+
+#. Let :math:`{(\mathsf{tag}~y)^\ast}` be :math:`{{\mathit{tag}}^\ast}`.
+
 #. Assert: Due to validation, for all :math:`{({\mathit{data}})^\ast}`, :math:`{\mathit{data}}` is of the case :math:`\mathsf{data}`.
 
 #. Let :math:`{(\mathsf{data}~{{\mathit{byte}}^\ast}~{\mathit{datamode}})^\ast}` be :math:`{{\mathit{data}}^\ast}`.
@@ -18739,33 +19052,37 @@ watsup 0.4 generator
 
 #. Let :math:`{(\mathsf{func}~x~{{\mathit{local}}^\ast}~{\mathit{expr}}_{\mathsf{f}})^\ast}` be :math:`{{\mathit{func}}^\ast}`.
 
-#. Let :math:`{{\mathit{xi}}^\ast}` be :math:`{{{\mathrm{allocexport}}^\ast}}{(\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~\epsilon,\; \mathsf{funcs}~{{\mathit{fa}}_{\mathsf{i}}^\ast}~{{\mathit{fa}}^\ast},\; \mathsf{globals}~{{\mathit{ga}}_{\mathsf{i}}^\ast}~{{\mathit{ga}}^\ast},\; \mathsf{tables}~{{\mathit{ta}}_{\mathsf{i}}^\ast}~{{\mathit{ta}}^\ast},\; \mathsf{mems}~{{\mathit{ma}}_{\mathsf{i}}^\ast}~{{\mathit{ma}}^\ast},\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{exports}~\epsilon \}\end{array}, {{\mathit{export}}^\ast})}`.
+#. Let :math:`{{\mathit{xi}}^\ast}` be :math:`{{{\mathrm{allocexport}}^\ast}}{(\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~\epsilon,\; \mathsf{funcs}~{{\mathit{fa}}_{\mathsf{i}}^\ast}~{{\mathit{fa}}^\ast},\; \mathsf{globals}~{{\mathit{ga}}_{\mathsf{i}}^\ast}~{{\mathit{ga}}^\ast},\; \mathsf{tables}~{{\mathit{ta}}_{\mathsf{i}}^\ast}~{{\mathit{ta}}^\ast},\; \mathsf{mems}~{{\mathit{ma}}_{\mathsf{i}}^\ast}~{{\mathit{ma}}^\ast},\; \mathsf{tags}~{{\mathit{aa}}_{\mathsf{i}}^\ast}~{{\mathit{aa}}^\ast},\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{exports}~\epsilon \}\end{array}, {{\mathit{export}}^\ast})}`.
 
-#. Let :math:`{\mathit{moduleinst}}` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~{{\mathit{dt}}^\ast},\; \mathsf{funcs}~{{\mathit{fa}}_{\mathsf{i}}^\ast}~{{\mathit{fa}}^\ast},\; \mathsf{globals}~{{\mathit{ga}}_{\mathsf{i}}^\ast}~{{\mathit{ga}}^\ast},\; \mathsf{tables}~{{\mathit{ta}}_{\mathsf{i}}^\ast}~{{\mathit{ta}}^\ast},\; \mathsf{mems}~{{\mathit{ma}}_{\mathsf{i}}^\ast}~{{\mathit{ma}}^\ast},\; \mathsf{elems}~{{\mathit{ea}}^\ast},\; \mathsf{datas}~{{\mathit{da}}^\ast},\; \mathsf{exports}~{{\mathit{xi}}^\ast} \}\end{array}`.
+#. Let :math:`{\mathit{moduleinst}}` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~{{\mathit{dt}}^\ast},\; \mathsf{funcs}~{{\mathit{fa}}_{\mathsf{i}}^\ast}~{{\mathit{fa}}^\ast},\; \mathsf{globals}~{{\mathit{ga}}_{\mathsf{i}}^\ast}~{{\mathit{ga}}^\ast},\; \mathsf{tables}~{{\mathit{ta}}_{\mathsf{i}}^\ast}~{{\mathit{ta}}^\ast},\; \mathsf{mems}~{{\mathit{ma}}_{\mathsf{i}}^\ast}~{{\mathit{ma}}^\ast},\; \mathsf{tags}~{{\mathit{aa}}_{\mathsf{i}}^\ast}~{{\mathit{aa}}^\ast},\; \mathsf{elems}~{{\mathit{ea}}^\ast},\; \mathsf{datas}~{{\mathit{da}}^\ast},\; \mathsf{exports}~{{\mathit{xi}}^\ast} \}\end{array}`.
 
-#. Let :math:`{\mathit{funcaddr}}_0` be :math:`{\mathrm{allocfuncs}}({{{\mathit{dt}}^\ast}{}[x]^\ast}, {(\mathsf{func}~x~{{\mathit{local}}^\ast}~{\mathit{expr}}_{\mathsf{f}})^\ast}, {{\mathit{moduleinst}}^{{|{{\mathit{func}}^\ast}|}}})`.
+#. Let :math:`n_0` be :math:`{\mathrm{allocfuncs}}({{{\mathit{dt}}^\ast}{}[x]^\ast}, {(\mathsf{func}~x~{{\mathit{local}}^\ast}~{\mathit{expr}}_{\mathsf{f}})^\ast}, {{\mathit{moduleinst}}^{{|{{\mathit{func}}^\ast}|}}})`.
 
-#. Assert: Due to validation, :math:`{\mathit{funcaddr}}_0` is :math:`{{\mathit{fa}}^\ast}`.
+#. Assert: Due to validation, :math:`n_0` is :math:`{{\mathit{fa}}^\ast}`.
 
-#. Let :math:`{\mathit{globaladdr}}_0` be :math:`{\mathrm{allocglobals}}({{\mathit{globaltype}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast})`.
+#. Let :math:`n_0` be :math:`{\mathrm{allocglobals}}({{\mathit{globaltype}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast})`.
 
-#. Assert: Due to validation, :math:`{\mathit{globaladdr}}_0` is :math:`{{\mathit{ga}}^\ast}`.
+#. Assert: Due to validation, :math:`n_0` is :math:`{{\mathit{ga}}^\ast}`.
 
-#. Let :math:`{\mathit{tableaddr}}_0` be :math:`{\mathrm{alloctables}}({{\mathit{tabletype}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast})`.
+#. Let :math:`n_0` be :math:`{\mathrm{alloctables}}({{\mathit{tabletype}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast})`.
 
-#. Assert: Due to validation, :math:`{\mathit{tableaddr}}_0` is :math:`{{\mathit{ta}}^\ast}`.
+#. Assert: Due to validation, :math:`n_0` is :math:`{{\mathit{ta}}^\ast}`.
 
-#. Let :math:`{\mathit{memaddr}}_0` be :math:`{\mathrm{allocmems}}({{\mathit{memtype}}^\ast})`.
+#. Let :math:`n_0` be :math:`{\mathrm{allocmems}}({{\mathit{memtype}}^\ast})`.
 
-#. Assert: Due to validation, :math:`{\mathit{memaddr}}_0` is :math:`{{\mathit{ma}}^\ast}`.
+#. Assert: Due to validation, :math:`n_0` is :math:`{{\mathit{ma}}^\ast}`.
 
-#. Let :math:`{\mathit{elemaddr}}_0` be :math:`{\mathrm{allocelems}}({{\mathit{elemtype}}^\ast}, {{{\mathit{ref}}_{\mathsf{e}}^\ast}^\ast})`.
+#. Let :math:`n_0` be :math:`{\mathrm{alloctags}}({{{\mathit{dt}}^\ast}{}[y]^\ast})`.
 
-#. Assert: Due to validation, :math:`{\mathit{elemaddr}}_0` is :math:`{{\mathit{ea}}^\ast}`.
+#. Assert: Due to validation, :math:`n_0` is :math:`{{\mathit{aa}}^\ast}`.
 
-#. Let :math:`{\mathit{dataaddr}}_0` be :math:`{\mathrm{allocdatas}}({\mathsf{ok}^{{|{{\mathit{data}}^\ast}|}}}, {{{\mathit{byte}}^\ast}^\ast})`.
+#. Let :math:`n_0` be :math:`{\mathrm{allocelems}}({{\mathit{elemtype}}^\ast}, {{{\mathit{ref}}_{\mathsf{e}}^\ast}^\ast})`.
 
-#. Assert: Due to validation, :math:`{\mathit{dataaddr}}_0` is :math:`{{\mathit{da}}^\ast}`.
+#. Assert: Due to validation, :math:`n_0` is :math:`{{\mathit{ea}}^\ast}`.
+
+#. Let :math:`n_0` be :math:`{\mathrm{allocdatas}}({\mathsf{ok}^{{|{{\mathit{data}}^\ast}|}}}, {{{\mathit{byte}}^\ast}^\ast})`.
+
+#. Assert: Due to validation, :math:`n_0` is :math:`{{\mathit{da}}^\ast}`.
 
 #. Return :math:`{\mathit{moduleinst}}`.
 
@@ -18835,17 +19152,17 @@ watsup 0.4 generator
 #. Return :math:`{\mathit{val}}~{{\mathit{val}'}^\ast}`.
 
 
-:math:`{\mathrm{instantiate}}(z, {\mathit{module}}, {{\mathit{externval}}^\ast})`
-.................................................................................
+:math:`{\mathrm{instantiate}}(z, {\mathit{module}}, {{\mathit{externaddr}}^\ast})`
+..................................................................................
 
 
 1. Let :math:`({{\mathit{xt}}_{\mathsf{i}}^\ast}~\rightarrow~{{\mathit{xt}}_{\mathsf{e}}^\ast})` be :math:`{\mathrm{Module}}_{\mathit{ok}}({\mathit{module}})`.
 
 #. Assert: Due to validation, :math:`{\mathit{module}}` is of the case :math:`\mathsf{module}`.
 
-#. Let :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` be :math:`{\mathit{module}}`.
+#. Let :math:`(\mathsf{module}~{{\mathit{type}}^\ast}~{{\mathit{import}}^\ast}~{{\mathit{func}}^\ast}~{{\mathit{global}}^\ast}~{{\mathit{table}}^\ast}~{{\mathit{mem}}^\ast}~{{\mathit{tag}}^\ast}~{{\mathit{elem}}^\ast}~{{\mathit{data}}^\ast}~{{\mathit{start}}^?}~{{\mathit{export}}^\ast})` be :math:`{\mathit{module}}`.
 
-#. Assert: Due to validation, for all :math:`{({\mathit{externval}}, {\mathit{xt}}_{\mathsf{i}})^\ast}`, :math:`{\mathrm{Externval}}_{\mathit{type}}({\mathit{externval}})` is :math:`{\mathit{xt}}_{\mathsf{i}}`.
+#. Assert: Due to validation, for all :math:`{({\mathit{externaddr}}, {\mathit{xt}}_{\mathsf{i}})^\ast}`, :math:`{\mathrm{Externaddr}}_{\mathit{type}}({\mathit{externaddr}})` is :math:`{\mathit{xt}}_{\mathsf{i}}`.
 
 #. Let :math:`{{\mathit{instr}}_{\mathsf{d}}^\ast}` be :math:`{\bigoplus}\, {{{\mathrm{rundata}}}_{i_{\mathsf{d}}}({{\mathit{data}}^\ast}{}[i_{\mathsf{d}}])^{i_{\mathsf{d}}<{|{{\mathit{data}}^\ast}|}}}`.
 
@@ -18855,7 +19172,7 @@ watsup 0.4 generator
 
 #. Let :math:`{(\mathsf{start}~x)^?}` be :math:`{{\mathit{start}}^?}`.
 
-#. Let :math:`{\mathit{moduleinst}}_0` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~{{{\mathrm{alloctype}}^\ast}}{({{\mathit{type}}^\ast})},\; \mathsf{funcs}~{\mathrm{funcs}}({{\mathit{externval}}^\ast})~{{|s{.}\mathsf{funcs}|} + i_{\mathsf{f}}^{i_{\mathsf{f}}<{|{{\mathit{func}}^\ast}|}}},\; \mathsf{globals}~{\mathrm{globals}}({{\mathit{externval}}^\ast}),\; \mathsf{tables}~\epsilon,\; \mathsf{mems}~\epsilon,\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{exports}~\epsilon \}\end{array}`.
+#. Let :math:`{\mathit{moduleinst}}_0` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~{{{\mathrm{alloctype}}^\ast}}{({{\mathit{type}}^\ast})},\; \mathsf{funcs}~{\mathrm{funcs}}({{\mathit{externaddr}}^\ast})~{{|s{.}\mathsf{funcs}|} + i_{\mathsf{f}}^{i_{\mathsf{f}}<{|{{\mathit{func}}^\ast}|}}},\; \mathsf{globals}~{\mathrm{globals}}({{\mathit{externaddr}}^\ast}),\; \mathsf{tables}~\epsilon,\; \mathsf{mems}~\epsilon,\; \mathsf{tags}~\epsilon,\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{exports}~\epsilon \}\end{array}`.
 
 #. Assert: Due to validation, for all :math:`{({\mathit{data}})^\ast}`, :math:`{\mathit{data}}` is of the case :math:`\mathsf{data}`.
 
@@ -18893,7 +19210,7 @@ watsup 0.4 generator
 
 #. Pop the activation of :math:`f` from the stack.
 
-#. Let :math:`{\mathit{moduleinst}}` be :math:`{\mathrm{allocmodule}}({\mathit{module}}, {{\mathit{externval}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast}, {{{\mathit{ref}}_{\mathsf{e}}^\ast}^\ast})`.
+#. Let :math:`{\mathit{moduleinst}}` be :math:`{\mathrm{allocmodule}}({\mathit{module}}, {{\mathit{externaddr}}^\ast}, {{\mathit{val}}_{\mathsf{g}}^\ast}, {{\mathit{ref}}_{\mathsf{t}}^\ast}, {{{\mathit{ref}}_{\mathsf{e}}^\ast}^\ast})`.
 
 #. Let :math:`f` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{locals}~\epsilon,\; \mathsf{module}~{\mathit{moduleinst}} \}\end{array}`.
 
@@ -18918,7 +19235,7 @@ watsup 0.4 generator
 .....................................................................
 
 
-1. Let :math:`f` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{locals}~\epsilon,\; \mathsf{module}~\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~\epsilon,\; \mathsf{funcs}~\epsilon,\; \mathsf{globals}~\epsilon,\; \mathsf{tables}~\epsilon,\; \mathsf{mems}~\epsilon,\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{exports}~\epsilon \}\end{array} \}\end{array}`.
+1. Let :math:`f` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{locals}~\epsilon,\; \mathsf{module}~\{ \begin{array}[t]{@{}l@{}}\mathsf{types}~\epsilon,\; \mathsf{funcs}~\epsilon,\; \mathsf{globals}~\epsilon,\; \mathsf{tables}~\epsilon,\; \mathsf{mems}~\epsilon,\; \mathsf{tags}~\epsilon,\; \mathsf{elems}~\epsilon,\; \mathsf{datas}~\epsilon,\; \mathsf{exports}~\epsilon \}\end{array} \}\end{array}`.
 
 #. Assert: Due to validation, :math:`{\mathrm{expand}}(s{.}\mathsf{funcs}{}[{\mathit{funcaddr}}]{.}\mathsf{type})` is of the case :math:`\mathsf{func}`.
 
@@ -19067,35 +19384,53 @@ watsup 0.4 generator
 
 1. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
 
-#. Let :math:`L` be the current label.
+#. If the top of the stack is a :math:`\mathsf{label}`, then:
 
-#. Let :math:`n` be the arity of :math:`L`.
+   a. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
 
-#. Let :math:`{{\mathit{instr}'}^\ast}` be the continuation of :math:`L`.
+   #. Let :math:`L` be the current label.
 
-#. Pop the current label from the stack.
+   #. Let :math:`n` be the arity of :math:`L`.
 
-#. Let :math:`{{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}` be :math:`{{\mathit{val}}^\ast}`.
+   #. Let :math:`{{\mathit{instr}'}^\ast}` be the continuation of :math:`L`.
 
-#. If :math:`{|{{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}|}` is greater than or equal to :math:`n`, then:
+   #. If :math:`l` is :math:`0`, then:
 
-   a. Let :math:`{{\mathit{val}'}^\ast}~{{\mathit{val}}^{n}}` be :math:`{{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+      1) Assert: Due to validation, there are at least :math:`n` values on the top of the stack.
 
-   #. If :math:`l` is :math:`0`, then:
+      #) Pop the values :math:`{{\mathit{val}}^{n}}` from the stack.
 
-      1) Push the values :math:`{{\mathit{val}}^{n}}` to the stack.
+      #) Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack.
+
+      #) Pop the current label from the stack.
+
+      #) Push the values :math:`{{\mathit{val}}^{n}}` to the stack.
 
       #) Execute the instruction :math:`{{\mathit{instr}'}^\ast}`.
 
-#. If for all :math:`{({\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}})^\ast}`, the type of :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is val, then:
+   #. Else:
 
-   a. Let :math:`{{\mathit{val}}^\ast}` be :math:`{{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^\ast}`.
+      1) Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
 
-   #. If :math:`l` is greater than :math:`0`, then:
+      #) If :math:`l` is greater than :math:`0`, then:
 
-      1) Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+         a) Pop the current label from the stack.
+
+         #) Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+         #) Execute the instruction :math:`(\mathsf{br}~l - 1)`.
+
+#. Else if the top of the stack is a :math:`\mathsf{handler}`, then:
 
-      #) Execute the instruction :math:`(\mathsf{br}~l - 1)`.
+   a. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+   #. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
+
+   #. Exit from :math:`\mathsf{handler}`.
+
+   #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+   #. Execute the instruction :math:`(\mathsf{br}~l)`.
 
 
 :math:`\mathsf{br\_if}~l`
@@ -19217,41 +19552,73 @@ watsup 0.4 generator
 
 1. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
 
-#. If a frame is now on the top of the stack, then:
+#. If the top of the stack is a :math:`\mathsf{frame}`, then:
 
-   a. Let :math:`f` be the current frame.
+   a. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+   #. Let :math:`f` be the current frame.
 
    #. Let :math:`n` be the arity of :math:`f`.
 
-   #. Pop the current frame from the stack.
+   #. Assert: Due to validation, there are at least :math:`n` values on the top of the stack.
 
-   #. Let :math:`{{\mathit{val}'}^\ast}~{{\mathit{val}}^{n}}` be :math:`{{\mathit{val}}^\ast}`.
+   #. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack.
+
+   #. Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack.
+
+   #. Pop the current frame from the stack.
 
    #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack.
 
-#. Else if a label is now on the top of the stack, then:
+#. Else if the top of the stack is a :math:`\mathsf{label}`, then:
+
+   a. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+   #. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
 
-   a. Pop the current label from the stack.
+   #. Pop the current label from the stack.
 
    #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
 
    #. Execute the instruction :math:`\mathsf{return}`.
 
+#. Else:
 
-:math:`\mathsf{trap}`
-.....................
+   a. If the top of the stack is a :math:`\mathsf{handler}`, then:
+
+      1) Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+      #) Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
+
+      #) Exit from :math:`\mathsf{handler}`.
 
+      #) Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+      #) Execute the instruction :math:`\mathsf{return}`.
 
-1. YetI: TODO: It is likely that the value stack of two rules are different.
+
+:math:`\mathsf{handler}`
+........................
+
+
+1. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
+
+#. Assert: Due to validation, YetE: a handler is now on the top of the stack.
+
+#. Exit from :math:`\mathsf{handler}`.
+
+#. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
 
 
 :math:`{\mathit{nt}} {.} {\mathit{unop}}`
 .........................................
 
 
-1. Assert: Due to validation, a value of value type :math:`{\mathit{nt}}` is on the top of the stack.
+1. Assert: Due to validation, a value of value type :math:`{\mathit{numtype}}_0` is on the top of the stack.
+
+#. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack.
 
-#. Pop the value :math:`({\mathit{nt}}{.}\mathsf{const}~c_1)` from the stack.
+#. Assert: Due to validation, :math:`{\mathit{numtype}}_0` is :math:`{\mathit{nt}}`.
 
 #. If :math:`{|{{\mathit{unop}}}{{}_{{\mathit{nt}}}(c_1)}|}` is less than or equal to :math:`0`, then:
 
@@ -19266,13 +19633,15 @@ watsup 0.4 generator
 ..........................................
 
 
-1. Assert: Due to validation, a value of value type :math:`{\mathit{nt}}` is on the top of the stack.
+1. Assert: Due to validation, a value of value type :math:`{\mathit{numtype}}_0` is on the top of the stack.
+
+#. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_2)` from the stack.
 
-#. Pop the value :math:`({\mathit{nt}}{.}\mathsf{const}~c_2)` from the stack.
+#. Assert: Due to validation, :math:`{\mathit{numtype}}_0` is :math:`{\mathit{nt}}`.
 
-#. Assert: Due to validation, a value of value type :math:`{\mathit{nt}}` is on the top of the stack.
+#. Assert: Due to validation, a value of value type :math:`{\mathit{numtype}}_0` is on the top of the stack.
 
-#. Pop the value :math:`({\mathit{nt}}{.}\mathsf{const}~c_1)` from the stack.
+#. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack.
 
 #. If :math:`{|{{\mathit{binop}}}{{}_{{\mathit{nt}}}(c_1, c_2)}|}` is less than or equal to :math:`0`, then:
 
@@ -19287,9 +19656,11 @@ watsup 0.4 generator
 ...........................................
 
 
-1. Assert: Due to validation, a value of value type :math:`{\mathit{nt}}` is on the top of the stack.
+1. Assert: Due to validation, a value of value type :math:`{\mathit{numtype}}_0` is on the top of the stack.
 
-#. Pop the value :math:`({\mathit{nt}}{.}\mathsf{const}~c_1)` from the stack.
+#. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack.
+
+#. Assert: Due to validation, :math:`{\mathit{numtype}}_0` is :math:`{\mathit{nt}}`.
 
 #. Let :math:`c` be :math:`{{\mathit{testop}}}{{}_{{\mathit{nt}}}(c_1)}`.
 
@@ -19300,13 +19671,15 @@ watsup 0.4 generator
 ..........................................
 
 
-1. Assert: Due to validation, a value of value type :math:`{\mathit{nt}}` is on the top of the stack.
+1. Assert: Due to validation, a value of value type :math:`{\mathit{numtype}}_0` is on the top of the stack.
+
+#. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_2)` from the stack.
 
-#. Pop the value :math:`({\mathit{nt}}{.}\mathsf{const}~c_2)` from the stack.
+#. Assert: Due to validation, :math:`{\mathit{numtype}}_0` is :math:`{\mathit{nt}}`.
 
-#. Assert: Due to validation, a value of value type :math:`{\mathit{nt}}` is on the top of the stack.
+#. Assert: Due to validation, a value of value type :math:`{\mathit{numtype}}_0` is on the top of the stack.
 
-#. Pop the value :math:`({\mathit{nt}}{.}\mathsf{const}~c_1)` from the stack.
+#. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack.
 
 #. Let :math:`c` be :math:`{{\mathit{relop}}}{{}_{{\mathit{nt}}}(c_1, c_2)}`.
 
@@ -19317,9 +19690,11 @@ watsup 0.4 generator
 ............................................................................
 
 
-1. Assert: Due to validation, a value of value type :math:`{\mathit{nt}}_1` is on the top of the stack.
+1. Assert: Due to validation, a value of value type :math:`{\mathit{numtype}}_0` is on the top of the stack.
 
-#. Pop the value :math:`({\mathit{nt}}_1{.}\mathsf{const}~c_1)` from the stack.
+#. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack.
+
+#. Assert: Due to validation, :math:`{\mathit{numtype}}_0` is :math:`{\mathit{nt}}_1`.
 
 #. If :math:`{|{{\mathit{cvtop}}}{{}_{{\mathit{nt}}_1, {\mathit{nt}}_2}(c_1)}|}` is less than or equal to :math:`0`, then:
 
@@ -19385,9 +19760,19 @@ watsup 0.4 generator
 
 #. Pop the value :math:`{\mathit{ref}}_1` from the stack.
 
-#. If :math:`{\mathit{ref}}_1` is of the case :math:`\mathsf{ref{.}null}` and :math:`{\mathit{ref}}_2` is of the case :math:`\mathsf{ref{.}null}`, then:
+#. If :math:`{\mathit{ref}}_1` is of the case :math:`\mathsf{ref{.}null}`, then:
 
-   a. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~1)` to the stack.
+   a. If :math:`{\mathit{ref}}_2` is of the case :math:`\mathsf{ref{.}null}`, then:
+
+      1) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~1)` to the stack.
+
+   #. Else if :math:`{\mathit{ref}}_1` is :math:`{\mathit{ref}}_2`, then:
+
+      1) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~1)` to the stack.
+
+   #. Else:
+
+      1) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~0)` to the stack.
 
 #. Else if :math:`{\mathit{ref}}_1` is :math:`{\mathit{ref}}_2`, then:
 
@@ -19702,11 +20087,11 @@ watsup 0.4 generator
 .........................................................
 
 
-1. Let :math:`{\mathit{nt}}_0` be :math:`{\mathrm{unpack}}({\mathsf{i}}{N})`.
+1. Assert: Due to validation, a value of value type :math:`{\mathit{numtype}}_0` is on the top of the stack.
 
-#. Assert: Due to validation, a value of value type :math:`{\mathit{nt}}_0` is on the top of the stack.
+#. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_1)` from the stack.
 
-#. Pop the value :math:`({\mathit{nt}}_0{.}\mathsf{const}~c_1)` from the stack.
+#. Assert: Due to validation, :math:`{\mathit{numtype}}_0` is :math:`{\mathrm{unpack}}({\mathsf{i}}{N})`.
 
 #. Let :math:`c` be :math:`{{{{\mathrm{lanes}}}_{({{\mathsf{i}}{N}}{\mathsf{x}}{M})}^{{-1}}}}{({{{\mathrm{pack}}}_{{\mathsf{i}}{N}}(c_1)^{M}})}`.
 
@@ -19750,11 +20135,11 @@ watsup 0.4 generator
 ...................................................................
 
 
-1. Let :math:`{\mathit{nt}}_0` be :math:`{\mathrm{unpack}}({\mathsf{i}}{N})`.
+1. Assert: Due to validation, a value of value type :math:`{\mathit{numtype}}_0` is on the top of the stack.
 
-#. Assert: Due to validation, a value of value type :math:`{\mathit{nt}}_0` is on the top of the stack.
+#. Pop the value :math:`({\mathit{numtype}}_0{.}\mathsf{const}~c_2)` from the stack.
 
-#. Pop the value :math:`({\mathit{nt}}_0{.}\mathsf{const}~c_2)` from the stack.
+#. Assert: Due to validation, :math:`{\mathit{numtype}}_0` is :math:`{\mathrm{unpack}}({\mathsf{i}}{N})`.
 
 #. Assert: Due to validation, a value of value type :math:`\mathsf{v{\scriptstyle 128}}` is on the top of the stack.
 
@@ -19945,187 +20330,529 @@ watsup 0.4 generator
 
 #. Let :math:`L` be the label whose arity is :math:`m` and whose continuation is :math:`(\mathsf{loop}~{\mathit{bt}}~{{\mathit{instr}}^\ast})`.
 
-#. Enter :math:`{{\mathit{val}}^{m}}~{{\mathit{instr}}^\ast}` with label :math:`L`.
+#. Enter :math:`{{\mathit{val}}^{m}}~{{\mathit{instr}}^\ast}` with label :math:`L`.
+
+
+:math:`\mathsf{br\_on\_cast}~l~{\mathit{rt}}_1~{\mathit{rt}}_2`
+...............................................................
+
+
+1. Let :math:`f` be the current frame.
+
+#. Assert: Due to validation, a value is on the top of the stack.
+
+#. Pop the value :math:`{\mathit{ref}}` from the stack.
+
+#. Let :math:`{\mathit{rt}}` be :math:`{\mathrm{Ref}}_{\mathit{type}}({\mathit{ref}})`.
+
+#. Push the value :math:`{\mathit{ref}}` to the stack.
+
+#. If :math:`{\mathit{rt}}` does not match :math:`{{\mathrm{inst}}}_{f{.}\mathsf{module}}({\mathit{rt}}_2)`, then:
+
+   a. Do nothing.
+
+#. Else:
+
+   a. Execute the instruction :math:`(\mathsf{br}~l)`.
+
+
+:math:`\mathsf{br\_on\_cast\_fail}~l~{\mathit{rt}}_1~{\mathit{rt}}_2`
+.....................................................................
+
+
+1. Let :math:`f` be the current frame.
+
+#. Assert: Due to validation, a value is on the top of the stack.
+
+#. Pop the value :math:`{\mathit{ref}}` from the stack.
+
+#. Let :math:`{\mathit{rt}}` be :math:`{\mathrm{Ref}}_{\mathit{type}}({\mathit{ref}})`.
+
+#. Push the value :math:`{\mathit{ref}}` to the stack.
+
+#. If :math:`{\mathit{rt}}` matches :math:`{{\mathrm{inst}}}_{f{.}\mathsf{module}}({\mathit{rt}}_2)`, then:
+
+   a. Do nothing.
+
+#. Else:
+
+   a. Execute the instruction :math:`(\mathsf{br}~l)`.
+
+
+:math:`\mathsf{call}~x`
+.......................
+
+
+1. Let :math:`z` be the current state.
+
+#. Assert: Due to validation, :math:`x` is less than :math:`{|z{.}\mathsf{module}{.}\mathsf{funcs}|}`.
+
+#. Let :math:`a` be :math:`z{.}\mathsf{module}{.}\mathsf{funcs}{}[x]`.
+
+#. Assert: Due to validation, :math:`a` is less than :math:`{|z{.}\mathsf{funcs}|}`.
+
+#. Push the value :math:`(\mathsf{ref{.}func}~a)` to the stack.
+
+#. Execute the instruction :math:`(\mathsf{call\_ref}~z{.}\mathsf{funcs}{}[a]{.}\mathsf{type})`.
+
+
+:math:`\mathsf{call\_ref}~y`
+............................
+
+
+1. Let :math:`z` be the current state.
+
+#. Assert: Due to validation, a value is on the top of the stack.
+
+#. Pop the value :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` from the stack.
+
+#. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}null}`, then:
+
+   a. Trap.
+
+#. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}func}`, then:
+
+   a. Let :math:`(\mathsf{ref{.}func}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+
+   #. If :math:`a` is less than :math:`{|z{.}\mathsf{funcs}|}`, then:
+
+      1) Let :math:`{\mathit{fi}}` be :math:`z{.}\mathsf{funcs}{}[a]`.
+
+      #) Assert: Due to validation, :math:`{\mathit{fi}}{.}\mathsf{code}` is of the case :math:`\mathsf{func}`.
+
+      #) Let :math:`(\mathsf{func}~x~{\mathit{local}}_0~{{\mathit{instr}}^\ast})` be :math:`{\mathit{fi}}{.}\mathsf{code}`.
+
+      #) Assert: Due to validation, :math:`{\mathit{local}}_0` is of the case :math:`\mathsf{local}`.
+
+      #) Let :math:`{(\mathsf{local}~t)^\ast}` be :math:`{\mathit{local}}_0`.
+
+      #) Assert: Due to validation, :math:`{\mathrm{expand}}({\mathit{fi}}{.}\mathsf{type})` is of the case :math:`\mathsf{func}`.
+
+      #) Let :math:`(\mathsf{func}~{\mathit{functype}}_0)` be :math:`{\mathrm{expand}}({\mathit{fi}}{.}\mathsf{type})`.
+
+      #) Let :math:`({t_1^{n}}~\rightarrow~{t_2^{m}})` be :math:`{\mathit{functype}}_0`.
+
+      #) Assert: Due to validation, there are at least :math:`n` values on the top of the stack.
+
+      #) Pop the values :math:`{{\mathit{val}}^{n}}` from the stack.
+
+      #) Let :math:`f` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{locals}~{{\mathit{val}}^{n}}~{{{\mathrm{default}}}_{t}^\ast},\; \mathsf{module}~{\mathit{fi}}{.}\mathsf{module} \}\end{array}`.
+
+      #) Let :math:`F` be the activation of :math:`f` with arity :math:`m`.
+
+      #) Push :math:`F` to the stack.
+
+      #) Let :math:`L` be the label whose arity is :math:`m` and whose continuation is :math:`\epsilon`.
+
+      #) Enter :math:`{{\mathit{instr}}^\ast}` with label :math:`L`.
+
+
+:math:`\mathsf{return\_call}~x`
+...............................
+
+
+1. Let :math:`z` be the current state.
+
+#. Assert: Due to validation, :math:`x` is less than :math:`{|z{.}\mathsf{module}{.}\mathsf{funcs}|}`.
+
+#. Let :math:`a` be :math:`z{.}\mathsf{module}{.}\mathsf{funcs}{}[x]`.
+
+#. Assert: Due to validation, :math:`a` is less than :math:`{|z{.}\mathsf{funcs}|}`.
+
+#. Push the value :math:`(\mathsf{ref{.}func}~a)` to the stack.
+
+#. Execute the instruction :math:`(\mathsf{return\_call\_ref}~z{.}\mathsf{funcs}{}[a]{.}\mathsf{type})`.
+
+
+:math:`\mathsf{return\_call\_ref}~y`
+....................................
+
+
+1. Let :math:`z` be the current state.
+
+#. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
+
+#. If the top of the stack is a :math:`\mathsf{label}`, then:
+
+   a. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+   #. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
+
+   #. Pop the current label from the stack.
+
+   #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+   #. Execute the instruction :math:`(\mathsf{return\_call\_ref}~y)`.
+
+#. Else if the top of the stack is a :math:`\mathsf{frame}`, then:
+
+   a. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+   #. Assert: Due to validation, a value is on the top of the stack.
+
+   #. Pop the value :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` from the stack.
+
+   #. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
+
+   #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}null}`, then:
+
+      1) Pop the current frame from the stack.
+
+      #) Trap.
+
+   #. Assert: Due to validation, a value is on the top of the stack.
+
+   #. Pop the value :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` from the stack.
+
+   #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}func}`, then:
+
+      1) Let :math:`(\mathsf{ref{.}func}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+
+      #) If :math:`a` is less than :math:`{|z{.}\mathsf{funcs}|}`, then:
+
+         a) Assert: Due to validation, :math:`{\mathrm{expand}}(z{.}\mathsf{funcs}{}[a]{.}\mathsf{type})` is of the case :math:`\mathsf{func}`.
+
+         #) Let :math:`(\mathsf{func}~{\mathit{functype}}_0)` be :math:`{\mathrm{expand}}(z{.}\mathsf{funcs}{}[a]{.}\mathsf{type})`.
+
+         #) Let :math:`({t_1^{n}}~\rightarrow~{t_2^{m}})` be :math:`{\mathit{functype}}_0`.
+
+         #) Assert: Due to validation, there are at least :math:`n` values on the top of the stack.
+
+         #) Pop the values :math:`{{\mathit{val}}^{n}}` from the stack.
+
+         #) Pop all values :math:`{{\mathit{val}'}^\ast}` from the top of the stack.
+
+         #) Pop the current frame from the stack.
+
+         #) Push the values :math:`{{\mathit{val}}^{n}}` to the stack.
+
+         #) Push the value :math:`(\mathsf{ref{.}func}~a)` to the stack.
+
+         #) Execute the instruction :math:`(\mathsf{call\_ref}~y)`.
+
+
+:math:`\mathsf{throw\_ref}`
+...........................
+
+
+1. Let :math:`z` be the current state.
+
+#. Assert: Due to validation, a value is on the top of the stack.
+
+#. Pop the value :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` from the stack.
+
+#. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}null}`, then:
+
+   a. Trap.
+
+#. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
+
+#. If :math:`{{\mathit{val}}^\ast}` is not :math:`\epsilon`, then:
+
+   a. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}exn}`, then:
+
+      1) Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+
+      #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
+
+      #) Execute the instruction :math:`\mathsf{throw\_ref}`.
+
+#. Else:
+
+   a. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
+
+   #. If the top of the stack is a :math:`\mathsf{label}`, then:
+
+      1) Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+      #) If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}exn}`, then:
+
+         a) Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+
+         #) Pop the current label from the stack.
+
+         #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
+
+         #) Execute the instruction :math:`\mathsf{throw\_ref}`.
+
+   #. Else if the top of the stack is a :math:`\mathsf{frame}`, then:
+
+      1) Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+      #) If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}exn}`, then:
+
+         a) Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+
+         #) Pop the current frame from the stack.
+
+         #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
+
+         #) Execute the instruction :math:`\mathsf{throw\_ref}`.
+
+   #. Else:
+
+      1) If the top of the stack is a :math:`\mathsf{handler}`, then:
+
+         a) Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+
+         #) Let :math:`({{\mathsf{handler}}_{n}}{\{}~{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}~\})` be the current context.
+
+         #) If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}exn}`, then:
+
+            1. Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+
+            #. If :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}` is :math:`\epsilon`, then:
+
+               a. Exit from :math:`\mathsf{handler}`.
+
+               #. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
+
+               #. Execute the instruction :math:`\mathsf{throw\_ref}`.
+
+            #. Else:
+
+               a. Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+
+               #. If :math:`a` is greater than or equal to :math:`{|z{.}\mathsf{exns}|}`, then:
+
+                  1) Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
+
+                  #) If :math:`{\mathit{catch}}_0` is of the case :math:`\mathsf{catch\_all}`, then:
+
+                     a) Let :math:`(\mathsf{catch\_all}~l)` be :math:`{\mathit{catch}}_0`.
+
+                     #) Exit from :math:`\mathsf{handler}`.
+
+                     #) Execute the instruction :math:`(\mathsf{br}~l)`.
+
+                  #) Else:
+
+                     a) Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+
+                     #) Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
+
+                     #) If :math:`{\mathit{catch}}_0` is of the case :math:`\mathsf{catch\_all\_ref}`, then:
+
+                        1. Let :math:`(\mathsf{catch\_all\_ref}~l)` be :math:`{\mathit{catch}}_0`.
+
+                        #. Exit from :math:`\mathsf{handler}`.
+
+                        #. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
+
+                        #. Execute the instruction :math:`(\mathsf{br}~l)`.
+
+                     #) Else:
+
+                        1. Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+
+                        #. Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
+
+                        #. Exit from :math:`\mathsf{handler}`.
+
+                        #. Let :math:`H` be :math:`({{\mathsf{handler}}_{n}}{\{}~{{\mathit{catch}'}^\ast}~\})`.
+
+                        #. Enter :math:`\mathsf{throw\_ref}~\mathsf{handler}` with label :math:`H`.
+
+                           a. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
+
+               #. Else:
+
+                  1) Let :math:`{{\mathit{val}}^\ast}` be :math:`z{.}\mathsf{exns}{}[a]{.}\mathsf{fields}`.
+
+                  #) Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
+
+                  #) If :math:`{\mathit{catch}}_0` is of the case :math:`\mathsf{catch}`, then:
+
+                     a) Let :math:`(\mathsf{catch}~x~l)` be :math:`{\mathit{catch}}_0`.
+
+                     #) If :math:`x` is less than :math:`{|z{.}\mathsf{tags}|}` and :math:`z{.}\mathsf{exns}{}[a]{.}\mathsf{tag}` is :math:`z{.}\mathsf{tags}{}[x]`, then:
+
+                        1. Exit from :math:`\mathsf{handler}`.
 
+                        #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
 
-:math:`\mathsf{br\_on\_cast}~l~{\mathit{rt}}_1~{\mathit{rt}}_2`
-...............................................................
+                        #. Execute the instruction :math:`(\mathsf{br}~l)`.
 
+                     #) Else:
 
-1. Let :math:`f` be the current frame.
+                        1. Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
 
-#. Assert: Due to validation, a value is on the top of the stack.
+                        #. Do nothing.
 
-#. Pop the value :math:`{\mathit{ref}}` from the stack.
+                        #. If :math:`{\mathit{catch}}_0` is not of the case :math:`\mathsf{catch\_ref}`, then:
 
-#. Let :math:`{\mathit{rt}}` be :math:`{\mathrm{Ref}}_{\mathit{type}}({\mathit{ref}})`.
+                           a. Do nothing.
 
-#. If :math:`{\mathit{rt}}` does not match :math:`{{\mathrm{inst}}}_{f{.}\mathsf{module}}({\mathit{rt}}_2)`, then:
+                        #. Else:
 
-   a. Push the value :math:`{\mathit{ref}}` to the stack.
+                           a. Do nothing.
 
-#. Else:
+                        #. Do nothing.
 
-   a. Push the value :math:`{\mathit{ref}}` to the stack.
+                        #. If :math:`{\mathit{catch}}_0` is of the case :math:`\mathsf{catch\_all}`, then:
 
-   #. Execute the instruction :math:`(\mathsf{br}~l)`.
+                           a. Let :math:`(\mathsf{catch\_all}~l)` be :math:`{\mathit{catch}}_0`.
 
+                           #. Exit from :math:`\mathsf{handler}`.
 
-:math:`\mathsf{br\_on\_cast\_fail}~l~{\mathit{rt}}_1~{\mathit{rt}}_2`
-.....................................................................
+                           #. Execute the instruction :math:`(\mathsf{br}~l)`.
 
+                        #. Else:
 
-1. Let :math:`f` be the current frame.
+                           a. Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-#. Assert: Due to validation, a value is on the top of the stack.
+                           #. Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
 
-#. Pop the value :math:`{\mathit{ref}}` from the stack.
+                           #. If :math:`{\mathit{catch}}_0` is of the case :math:`\mathsf{catch\_all\_ref}`, then:
 
-#. Let :math:`{\mathit{rt}}` be :math:`{\mathrm{Ref}}_{\mathit{type}}({\mathit{ref}})`.
+                              1) Let :math:`(\mathsf{catch\_all\_ref}~l)` be :math:`{\mathit{catch}}_0`.
 
-#. If :math:`{\mathit{rt}}` matches :math:`{{\mathrm{inst}}}_{f{.}\mathsf{module}}({\mathit{rt}}_2)`, then:
+                              #) Exit from :math:`\mathsf{handler}`.
 
-   a. Push the value :math:`{\mathit{ref}}` to the stack.
+                              #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
 
-#. Else:
+                              #) Execute the instruction :math:`(\mathsf{br}~l)`.
 
-   a. Push the value :math:`{\mathit{ref}}` to the stack.
+                           #. Else:
 
-   #. Execute the instruction :math:`(\mathsf{br}~l)`.
+                              1) Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
+                              #) Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
 
-:math:`\mathsf{call}~x`
-.......................
+                              #) Exit from :math:`\mathsf{handler}`.
 
+                              #) Let :math:`H` be :math:`({{\mathsf{handler}}_{n}}{\{}~{{\mathit{catch}'}^\ast}~\})`.
 
-1. Let :math:`z` be the current state.
+                              #) Enter :math:`\mathsf{throw\_ref}~\mathsf{handler}` with label :math:`H`.
 
-#. Assert: Due to validation, :math:`x` is less than :math:`{|z{.}\mathsf{module}{.}\mathsf{funcs}|}`.
+                                 a) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
 
-#. Let :math:`a` be :math:`z{.}\mathsf{module}{.}\mathsf{funcs}{}[x]`.
+                  #) Else:
 
-#. Assert: Due to validation, :math:`a` is less than :math:`{|z{.}\mathsf{funcs}|}`.
+                     a) Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-#. Push the value :math:`(\mathsf{ref{.}func}~a)` to the stack.
+                     #) Let :math:`{{\mathit{val}}^\ast}` be :math:`z{.}\mathsf{exns}{}[a]{.}\mathsf{fields}`.
 
-#. Execute the instruction :math:`(\mathsf{call\_ref}~z{.}\mathsf{funcs}{}[a]{.}\mathsf{type})`.
+                     #) Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
 
+                     #) If :math:`{\mathit{catch}}_0` is not of the case :math:`\mathsf{catch\_ref}`, then:
 
-:math:`\mathsf{call\_ref}~y`
-............................
+                        1. Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
 
+                        #. If :math:`{\mathit{catch}}_0` is of the case :math:`\mathsf{catch\_all}`, then:
 
-1. Let :math:`z` be the current state.
+                           a. Let :math:`(\mathsf{catch\_all}~l)` be :math:`{\mathit{catch}}_0`.
 
-#. Assert: Due to validation, a value is on the top of the stack.
+                           #. Exit from :math:`\mathsf{handler}`.
 
-#. Pop the value :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` from the stack.
+                           #. Execute the instruction :math:`(\mathsf{br}~l)`.
 
-#. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}null}`, then:
+                        #. Else:
 
-   a. Trap.
+                           a. Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-#. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}func}`, then:
+                           #. Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
 
-   a. Let :math:`(\mathsf{ref{.}func}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+                           #. If :math:`{\mathit{catch}}_0` is of the case :math:`\mathsf{catch\_all\_ref}`, then:
 
-   #. If :math:`a` is less than :math:`{|z{.}\mathsf{funcs}|}`, then:
+                              1) Let :math:`(\mathsf{catch\_all\_ref}~l)` be :math:`{\mathit{catch}}_0`.
 
-      1) Let :math:`{\mathit{fi}}` be :math:`z{.}\mathsf{funcs}{}[a]`.
+                              #) Exit from :math:`\mathsf{handler}`.
 
-      #) Assert: Due to validation, :math:`{\mathit{fi}}{.}\mathsf{code}` is of the case :math:`\mathsf{func}`.
+                              #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
 
-      #) Let :math:`(\mathsf{func}~x~{\mathit{local}}_0~{{\mathit{instr}}^\ast})` be :math:`{\mathit{fi}}{.}\mathsf{code}`.
+                              #) Execute the instruction :math:`(\mathsf{br}~l)`.
 
-      #) Assert: Due to validation, :math:`{\mathit{local}}_0` is of the case :math:`\mathsf{local}`.
+                           #. Else:
 
-      #) Let :math:`{(\mathsf{local}~t)^\ast}` be :math:`{\mathit{local}}_0`.
+                              1) Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-      #) Assert: Due to validation, :math:`{\mathrm{expand}}({\mathit{fi}}{.}\mathsf{type})` is of the case :math:`\mathsf{func}`.
+                              #) Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
 
-      #) Let :math:`(\mathsf{func}~{\mathit{functype}}_0)` be :math:`{\mathrm{expand}}({\mathit{fi}}{.}\mathsf{type})`.
+                              #) Exit from :math:`\mathsf{handler}`.
 
-      #) Let :math:`({t_1^{n}}~\rightarrow~{t_2^{m}})` be :math:`{\mathit{functype}}_0`.
+                              #) Let :math:`H` be :math:`({{\mathsf{handler}}_{n}}{\{}~{{\mathit{catch}'}^\ast}~\})`.
 
-      #) Assert: Due to validation, there are at least :math:`n` values on the top of the stack.
+                              #) Enter :math:`\mathsf{throw\_ref}~\mathsf{handler}` with label :math:`H`.
 
-      #) Pop the values :math:`{{\mathit{val}}^{n}}` from the stack.
+                                 a) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
 
-      #) Let :math:`f` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{locals}~{{\mathit{val}}^{n}}~{{{\mathrm{default}}}_{t}^\ast},\; \mathsf{module}~{\mathit{fi}}{.}\mathsf{module} \}\end{array}`.
+                     #) Else:
 
-      #) Let :math:`F` be the activation of :math:`f` with arity :math:`m`.
+                        1. Let :math:`(\mathsf{catch\_ref}~x~l)` be :math:`{\mathit{catch}}_0`.
 
-      #) Push :math:`F` to the stack.
+                        #. If :math:`x` is less than :math:`{|z{.}\mathsf{tags}|}` and :math:`z{.}\mathsf{exns}{}[a]{.}\mathsf{tag}` is :math:`z{.}\mathsf{tags}{}[x]`, then:
 
-      #) Let :math:`L` be the label whose arity is :math:`m` and whose continuation is :math:`\epsilon`.
+                           a. Exit from :math:`\mathsf{handler}`.
 
-      #) Enter :math:`{{\mathit{instr}}^\ast}` with label :math:`L`.
+                           #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
 
+                           #. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
 
-:math:`\mathsf{return\_call}~x`
-...............................
+                           #. Execute the instruction :math:`(\mathsf{br}~l)`.
 
+                        #. Else:
 
-1. Let :math:`z` be the current state.
+                           a. Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
 
-#. Assert: Due to validation, :math:`x` is less than :math:`{|z{.}\mathsf{module}{.}\mathsf{funcs}|}`.
+                           #. If :math:`{\mathit{catch}}_0` is of the case :math:`\mathsf{catch\_all}`, then:
 
-#. Let :math:`a` be :math:`z{.}\mathsf{module}{.}\mathsf{funcs}{}[x]`.
+                              1) Let :math:`(\mathsf{catch\_all}~l)` be :math:`{\mathit{catch}}_0`.
 
-#. Assert: Due to validation, :math:`a` is less than :math:`{|z{.}\mathsf{funcs}|}`.
+                              #) Exit from :math:`\mathsf{handler}`.
 
-#. Push the value :math:`(\mathsf{ref{.}func}~a)` to the stack.
+                              #) Execute the instruction :math:`(\mathsf{br}~l)`.
 
-#. Execute the instruction :math:`(\mathsf{return\_call\_ref}~z{.}\mathsf{funcs}{}[a]{.}\mathsf{type})`.
+                           #. Else:
 
+                              1) Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-:math:`\mathsf{return\_call\_ref}~y`
-....................................
+                              #) Let :math:`{\mathit{catch}}_0~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
 
+                              #) If :math:`{\mathit{catch}}_0` is of the case :math:`\mathsf{catch\_all\_ref}`, then:
 
-1. Let :math:`z` be the current state.
+                                 a) Let :math:`(\mathsf{catch\_all\_ref}~l)` be :math:`{\mathit{catch}}_0`.
 
-#. Pop all values :math:`{{\mathit{val}}^\ast}` from the top of the stack.
+                                 #) Exit from :math:`\mathsf{handler}`.
 
-#. If a label is now on the top of the stack, then:
+                                 #) Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
 
-   a. Pop the current label from the stack.
+                                 #) Execute the instruction :math:`(\mathsf{br}~l)`.
 
-   #. Push the values :math:`{{\mathit{val}}^\ast}` to the stack.
+                              #) Else:
 
-   #. Execute the instruction :math:`(\mathsf{return\_call\_ref}~y)`.
+                                 a) Let :math:`(\mathsf{ref{.}exn}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-#. Else if a frame is now on the top of the stack, then:
+                                 #) Let :math:`{\mathit{catch}}~{{\mathit{catch}'}^\ast}` be :math:`{{\mathit{catch}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
 
-   a. Pop the current frame from the stack.
+                                 #) Exit from :math:`\mathsf{handler}`.
 
-   #. Let :math:`{{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}~{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` be :math:`{{\mathit{val}}^\ast}`.
+                                 #) Let :math:`H` be :math:`({{\mathsf{handler}}_{n}}{\{}~{{\mathit{catch}'}^\ast}~\})`.
 
-   #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}func}`, then:
+                                 #) Enter :math:`\mathsf{throw\_ref}~\mathsf{handler}` with label :math:`H`.
 
-      1) Let :math:`(\mathsf{ref{.}func}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+                                    1. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
 
-      #) If :math:`{|{{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}|}` is greater than or equal to :math:`n`, then:
 
-         a) Let :math:`{{\mathit{val}'}^\ast}~{{\mathit{val}}^{n}}` be :math:`{{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^\ast}`.
+:math:`\mathsf{try\_table}~{\mathit{bt}}~{{\mathit{catch}}^\ast}~{{\mathit{instr}}^\ast}`
+.........................................................................................
 
-         #) If :math:`a` is less than :math:`{|z{.}\mathsf{funcs}|}`, then:
 
-            1. Assert: Due to validation, :math:`{\mathrm{expand}}(z{.}\mathsf{funcs}{}[a]{.}\mathsf{type})` is of the case :math:`\mathsf{func}`.
+1. Let :math:`z` be the current state.
 
-            #. Let :math:`(\mathsf{func}~{\mathit{functype}}_0)` be :math:`{\mathrm{expand}}(z{.}\mathsf{funcs}{}[a]{.}\mathsf{type})`.
+#. Let :math:`({t_1^{m}}~\rightarrow~{t_2^{n}})` be :math:`{{\mathrm{blocktype}}}_{z}({\mathit{bt}})`.
 
-            #. Let :math:`({t_1^{n}}~\rightarrow~{t_2^{m}})` be :math:`{\mathit{functype}}_0`.
+#. Assert: Due to validation, there are at least :math:`m` values on the top of the stack.
 
-            #. Push the values :math:`{{\mathit{val}}^{n}}` to the stack.
+#. Pop the values :math:`{{\mathit{val}}^{m}}` from the stack.
 
-            #. Push the value :math:`(\mathsf{ref{.}func}~a)` to the stack.
+#. Let :math:`H` be :math:`({{\mathsf{handler}}_{n}}{\{}~{{\mathit{catch}}^\ast}~\})`.
 
-            #. Execute the instruction :math:`(\mathsf{call\_ref}~y)`.
+#. Enter :math:`\mathsf{handler}` with label :math:`H`.
 
-   #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}null}` and for all :math:`{({\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}})^\ast}`, the type of :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is val, then:
+   a. Let :math:`L` be the label whose arity is :math:`n` and whose continuation is :math:`\epsilon`.
 
-      1) Trap.
+   #. Enter :math:`{{\mathit{val}}^{m}}~{{\mathit{instr}}^\ast}` with label :math:`L`.
 
 
 :math:`\mathsf{ref{.}null}~x`
@@ -20421,7 +21148,11 @@ watsup 0.4 generator
 
    a. Let :math:`(\mathsf{ref{.}array}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-   #. If :math:`a` is less than :math:`{|z{.}\mathsf{arrays}|}` and :math:`i + n` is greater than :math:`{|z{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}|}`, then:
+   #. If :math:`a` is greater than or equal to :math:`{|z{.}\mathsf{arrays}|}`, then:
+
+      1) Do nothing.
+
+   #. Else if :math:`i + n` is greater than :math:`{|z{.}\mathsf{arrays}{}[a]{.}\mathsf{fields}|}`, then:
 
       1) Trap.
 
@@ -20468,7 +21199,7 @@ watsup 0.4 generator
 
 #. Assert: Due to validation, a value is on the top of the stack.
 
-#. Pop the value :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` from the stack.
+#. Pop the value :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` from the stack.
 
 #. Assert: Due to validation, a value of value type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack.
 
@@ -20476,47 +21207,53 @@ watsup 0.4 generator
 
 #. Assert: Due to validation, a value is on the top of the stack.
 
-#. Pop the value :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` from the stack.
+#. Pop the value :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` from the stack.
 
-#. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}null}` and the type of :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is ref, then:
+#. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is of the case :math:`\mathsf{ref{.}null}` and the type of :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is ref, then:
 
    a. Trap.
 
-#. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is of the case :math:`\mathsf{ref{.}null}` and the type of :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is ref, then:
+#. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}null}` and the type of :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is ref, then:
 
    a. Trap.
 
-#. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}array}`, then:
+#. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is of the case :math:`\mathsf{ref{.}array}`, then:
+
+   a. Let :math:`(\mathsf{ref{.}array}~a_1)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}`.
 
-   a. Let :math:`(\mathsf{ref{.}array}~a_1)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+   #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is not of the case :math:`\mathsf{ref{.}array}`, then:
 
-   #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is of the case :math:`\mathsf{ref{.}array}`, then:
+      1) Do nothing.
+
+   #. Else:
 
       1) If :math:`a_1` is less than :math:`{|z{.}\mathsf{arrays}|}` and :math:`i_1 + n` is greater than :math:`{|z{.}\mathsf{arrays}{}[a_1]{.}\mathsf{fields}|}`, then:
 
          a) Trap.
 
-      #) Let :math:`(\mathsf{ref{.}array}~a_2)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}`.
+      #) Let :math:`(\mathsf{ref{.}array}~a_2)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-      #) If :math:`a_2` is less than :math:`{|z{.}\mathsf{arrays}|}` and :math:`i_2 + n` is greater than :math:`{|z{.}\mathsf{arrays}{}[a_2]{.}\mathsf{fields}|}`, then:
+      #) If :math:`a_2` is greater than or equal to :math:`{|z{.}\mathsf{arrays}|}`, then:
 
-         a) Trap.
+         a) Do nothing.
 
-   #. If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is of the case :math:`\mathsf{ref{.}array}` and :math:`n` is :math:`0`, then:
+      #) Else if :math:`i_2 + n` is greater than :math:`{|z{.}\mathsf{arrays}{}[a_2]{.}\mathsf{fields}|}`, then:
 
-      1) Do nothing.
+         a) Trap.
 
-   #. Else:
+   #. If :math:`n` is not :math:`0`, then:
+
+      1) Let :math:`(\mathsf{ref{.}array}~a_1)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}`.
 
-      1) Let :math:`(\mathsf{ref{.}array}~a_1)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+      #) If :math:`i_1` is greater than :math:`i_2`, then:
 
-      #) If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is of the case :math:`\mathsf{ref{.}array}`, then:
+         a) If :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}array}`, then:
 
-         a) Let :math:`(\mathsf{ref{.}array}~a_2)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}`.
+            1. Let :math:`(\mathsf{ref{.}array}~a_2)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-         #) If :math:`i_1` is less than or equal to :math:`i_2` and :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x_2])` is of the case :math:`\mathsf{array}`, then:
+            #. Assert: Due to validation, :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x_2])` is of the case :math:`\mathsf{array}`.
 
-            1. Let :math:`(\mathsf{array}~{\mathit{arraytype}}_0)` be :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x_2])`.
+            #. Let :math:`(\mathsf{array}~{\mathit{arraytype}}_0)` be :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x_2])`.
 
             #. Let :math:`({\mathsf{mut}^?}, {\mathit{zt}}_2)` be :math:`{\mathit{arraytype}}_0`.
 
@@ -20524,11 +21261,11 @@ watsup 0.4 generator
 
             #. Push the value :math:`(\mathsf{ref{.}array}~a_1)` to the stack.
 
-            #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1)` to the stack.
+            #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1 + n - 1)` to the stack.
 
             #. Push the value :math:`(\mathsf{ref{.}array}~a_2)` to the stack.
 
-            #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2)` to the stack.
+            #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2 + n - 1)` to the stack.
 
             #. Execute the instruction :math:`({\mathsf{array{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~x_2)`.
 
@@ -20536,53 +21273,55 @@ watsup 0.4 generator
 
             #. Push the value :math:`(\mathsf{ref{.}array}~a_1)` to the stack.
 
-            #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1 + 1)` to the stack.
+            #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1)` to the stack.
 
             #. Push the value :math:`(\mathsf{ref{.}array}~a_2)` to the stack.
 
-            #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2 + 1)` to the stack.
+            #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2)` to the stack.
 
             #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack.
 
             #. Execute the instruction :math:`(\mathsf{array{.}copy}~x_1~x_2)`.
 
-         #) Else:
+      #) Else if :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}array}`, then:
 
-            1. Let :math:`(\mathsf{ref{.}array}~a_1)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+         a) Let :math:`(\mathsf{ref{.}array}~a_2)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-            #. Let :math:`(\mathsf{ref{.}array}~a_2)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}`.
+         #) Assert: Due to validation, :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x_2])` is of the case :math:`\mathsf{array}`.
 
-            #. If :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x_2])` is of the case :math:`\mathsf{array}`, then:
+         #) Let :math:`(\mathsf{array}~{\mathit{arraytype}}_0)` be :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x_2])`.
 
-               a. Let :math:`(\mathsf{array}~{\mathit{arraytype}}_0)` be :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x_2])`.
+         #) Let :math:`({\mathsf{mut}^?}, {\mathit{zt}}_2)` be :math:`{\mathit{arraytype}}_0`.
 
-               #. Let :math:`({\mathsf{mut}^?}, {\mathit{zt}}_2)` be :math:`{\mathit{arraytype}}_0`.
+         #) Let :math:`{{\mathit{sx}}^?}` be :math:`{\mathrm{sx}}({\mathit{zt}}_2)`.
 
-               #. Let :math:`{{\mathit{sx}}^?}` be :math:`{\mathrm{sx}}({\mathit{zt}}_2)`.
+         #) Push the value :math:`(\mathsf{ref{.}array}~a_1)` to the stack.
 
-               #. Push the value :math:`(\mathsf{ref{.}array}~a_1)` to the stack.
+         #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1)` to the stack.
 
-               #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1 + n - 1)` to the stack.
+         #) Push the value :math:`(\mathsf{ref{.}array}~a_2)` to the stack.
 
-               #. Push the value :math:`(\mathsf{ref{.}array}~a_2)` to the stack.
+         #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2)` to the stack.
 
-               #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2 + n - 1)` to the stack.
+         #) Execute the instruction :math:`({\mathsf{array{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~x_2)`.
 
-               #. Execute the instruction :math:`({\mathsf{array{.}get}}{\mathsf{\_}}{{{\mathit{sx}}^?}}~x_2)`.
+         #) Execute the instruction :math:`(\mathsf{array{.}set}~x_1)`.
 
-               #. Execute the instruction :math:`(\mathsf{array{.}set}~x_1)`.
+         #) Push the value :math:`(\mathsf{ref{.}array}~a_1)` to the stack.
 
-               #. Push the value :math:`(\mathsf{ref{.}array}~a_1)` to the stack.
+         #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1 + 1)` to the stack.
 
-               #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_1)` to the stack.
+         #) Push the value :math:`(\mathsf{ref{.}array}~a_2)` to the stack.
 
-               #. Push the value :math:`(\mathsf{ref{.}array}~a_2)` to the stack.
+         #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2 + 1)` to the stack.
 
-               #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i_2)` to the stack.
+         #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack.
+
+         #) Execute the instruction :math:`(\mathsf{array{.}copy}~x_1~x_2)`.
 
-               #. Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack.
+   #. Else if :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is of the case :math:`\mathsf{ref{.}array}`, then:
 
-               #. Execute the instruction :math:`(\mathsf{array{.}copy}~x_1~x_2)`.
+      1) Do nothing.
 
 
 :math:`\mathsf{array{.}init\_elem}~x~y`
@@ -20688,7 +21427,11 @@ watsup 0.4 generator
 
       1) Trap.
 
-   #. If :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x])` is of the case :math:`\mathsf{array}`, then:
+   #. If :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x])` is not of the case :math:`\mathsf{array}`, then:
+
+      1) Do nothing.
+
+   #. Else:
 
       1) Let :math:`(\mathsf{array}~{\mathit{arraytype}}_0)` be :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x])`.
 
@@ -20706,31 +21449,31 @@ watsup 0.4 generator
 
       1) Let :math:`(\mathsf{ref{.}array}~a)` be :math:`{\mathit{instr}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
 
-      #) Assert: Due to validation, :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x])` is of the case :math:`\mathsf{array}`.
+      #) If :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x])` is of the case :math:`\mathsf{array}`, then:
 
-      #) Let :math:`(\mathsf{array}~{\mathit{arraytype}}_0)` be :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x])`.
+         a) Let :math:`(\mathsf{array}~{\mathit{arraytype}}_0)` be :math:`{\mathrm{expand}}(z{.}\mathsf{types}{}[x])`.
 
-      #) Let :math:`({\mathsf{mut}^?}, {\mathit{zt}})` be :math:`{\mathit{arraytype}}_0`.
+         #) Let :math:`({\mathsf{mut}^?}, {\mathit{zt}})` be :math:`{\mathit{arraytype}}_0`.
 
-      #) Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathit{zt}}}(c)` :math:`=` :math:`z{.}\mathsf{datas}{}[y]{.}\mathsf{bytes}{}[j : {|{\mathit{zt}}|} / 8]`.
+         #) Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{{\mathit{zt}}}(c)` :math:`=` :math:`z{.}\mathsf{datas}{}[y]{.}\mathsf{bytes}{}[j : {|{\mathit{zt}}|} / 8]`.
 
-      #) Push the value :math:`(\mathsf{ref{.}array}~a)` to the stack.
+         #) Push the value :math:`(\mathsf{ref{.}array}~a)` to the stack.
 
-      #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` to the stack.
+         #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` to the stack.
 
-      #) Push the value :math:`{\mathrm{unpack}}({\mathit{zt}}){.}\mathsf{const}~{{\mathrm{unpack}}}_{{\mathit{zt}}}(c)` to the stack.
+         #) Push the value :math:`{\mathrm{unpack}}({\mathit{zt}}){.}\mathsf{const}~{{\mathrm{unpack}}}_{{\mathit{zt}}}(c)` to the stack.
 
-      #) Execute the instruction :math:`(\mathsf{array{.}set}~x)`.
+         #) Execute the instruction :math:`(\mathsf{array{.}set}~x)`.
 
-      #) Push the value :math:`(\mathsf{ref{.}array}~a)` to the stack.
+         #) Push the value :math:`(\mathsf{ref{.}array}~a)` to the stack.
 
-      #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + 1)` to the stack.
+         #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i + 1)` to the stack.
 
-      #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + {|{\mathit{zt}}|} / 8)` to the stack.
+         #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~j + {|{\mathit{zt}}|} / 8)` to the stack.
 
-      #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack.
+         #) Push the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~n - 1)` to the stack.
 
-      #) Execute the instruction :math:`(\mathsf{array{.}init\_data}~x~y)`.
+         #) Execute the instruction :math:`(\mathsf{array{.}init\_data}~x~y)`.
 
 
 :math:`\mathsf{local{.}get}~x`
@@ -20997,13 +21740,13 @@ watsup 0.4 generator
 
 #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack.
 
-#. If :math:`{{\mathit{vloadop\_u{\kern-0.1em\scriptstyle 0}}}^?}` is not defined, then:
+#. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|\mathsf{v{\scriptstyle 128}}|} / 8` is greater than :math:`{|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}` and :math:`{{\mathit{vloadop\_u{\kern-0.1em\scriptstyle 0}}}^?}` is not defined, then:
 
-   a. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|\mathsf{v{\scriptstyle 128}}|} / 8` is greater than :math:`{|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then:
+   a. Trap.
 
-      1) Trap.
+#. If :math:`{{\mathit{vloadop\_u{\kern-0.1em\scriptstyle 0}}}^?}` is not defined, then:
 
-   #. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{\mathsf{v{\scriptstyle 128}}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|\mathsf{v{\scriptstyle 128}}|} / 8]`.
+   a. Let :math:`c` be the result for which :math:`{{\mathrm{bytes}}}_{\mathsf{v{\scriptstyle 128}}}(c)` :math:`=` :math:`z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|\mathsf{v{\scriptstyle 128}}|} / 8]`.
 
    #. Push the value :math:`(\mathsf{v{\scriptstyle 128}}{.}\mathsf{const}~c)` to the stack.
 
@@ -21261,11 +22004,35 @@ watsup 0.4 generator
    #. Execute the instruction :math:`(\mathsf{memory{.}init}~x~y)`.
 
 
-:math:`\mathsf{ctxt}`
-.....................
+:math:`\mathsf{throw}~x`
+........................
+
 
+1. Let :math:`z` be the current state.
+
+#. Assert: Due to validation, :math:`x` is less than :math:`{|z{.}\mathsf{tags}|}`.
+
+#. Let :math:`a` be :math:`{|z{.}\mathsf{exns}|}`.
+
+#. Assert: Due to validation, :math:`{\mathrm{expand}}(z{.}\mathsf{tags}{}[x]{.}\mathsf{type})` is of the case :math:`\mathsf{func}`.
+
+#. Let :math:`(\mathsf{func}~{\mathit{functype}}_0)` be :math:`{\mathrm{expand}}(z{.}\mathsf{tags}{}[x]{.}\mathsf{type})`.
+
+#. Let :math:`({t^{n}}~\rightarrow~{\mathit{valtype}}_1)` be :math:`{\mathit{functype}}_0`.
+
+#. Assert: Due to validation, :math:`{\mathit{valtype}}_1` is :math:`\epsilon`.
+
+#. Assert: Due to validation, there are at least :math:`n` values on the top of the stack.
+
+#. Pop the values :math:`{{\mathit{val}}^{n}}` from the stack.
+
+#. Let :math:`{\mathit{exn}}` be :math:`\{ \begin{array}[t]{@{}l@{}}\mathsf{tag}~z{.}\mathsf{tags}{}[x],\; \mathsf{fields}~{{\mathit{val}}^{n}} \}\end{array}`.
 
-1. YetI: TODO: It is likely that the value stack of two rules are different.
+#. Perform :math:`z{}[{.}\mathsf{exns} \mathrel{{=}{\oplus}} {\mathit{exn}}]`.
+
+#. Push the value :math:`(\mathsf{ref{.}exn}~a)` to the stack.
+
+#. Execute the instruction :math:`\mathsf{throw\_ref}`.
 
 
 :math:`\mathsf{struct{.}new}~x`
@@ -21473,45 +22240,47 @@ watsup 0.4 generator
 #. Perform :math:`z{}[{.}\mathsf{elems}{}[x]{.}\mathsf{refs} = \epsilon]`.
 
 
-:math:`{{\mathit{nt}}{.}\mathsf{store}}{{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^?}}~x~{\mathit{ao}}`
+:math:`{{\mathit{nt}}{.}\mathsf{store}}{{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^?}}~x~{\mathit{ao}}`
 ...................................................................................................................
 
 
 1. Let :math:`z` be the current state.
 
-#. Assert: Due to validation, a value of value type :math:`{\mathit{numtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is on the top of the stack.
+#. Assert: Due to validation, a value of value type :math:`{\mathit{numtype}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is on the top of the stack.
 
-#. Pop the value :math:`({\mathit{numtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}{.}\mathsf{const}~c)` from the stack.
+#. Pop the value :math:`({\mathit{numtype}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}{.}\mathsf{const}~c)` from the stack.
 
 #. Assert: Due to validation, a value of value type :math:`\mathsf{i{\scriptstyle 32}}` is on the top of the stack.
 
 #. Pop the value :math:`(\mathsf{i{\scriptstyle 32}}{.}\mathsf{const}~i)` from the stack.
 
-#. If :math:`{\mathit{numtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is :math:`{\mathit{nt}}` and :math:`{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^?}` is not defined, then:
+#. If :math:`{\mathit{numtype}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is :math:`{\mathit{nt}}`, then:
 
-   a. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|{\mathit{nt}}|} / 8` is greater than :math:`{|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then:
+   a. If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + {|{\mathit{nt}}|} / 8` is greater than :math:`{|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}` and :math:`{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^?}` is not defined, then:
 
       1) Trap.
 
-   #. Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathit{nt}}}(c)`.
+   #. If :math:`{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^?}` is not defined, then:
 
-   #. Perform :math:`z{}[{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|{\mathit{nt}}|} / 8] = {b^\ast}]`.
+      1) Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathit{nt}}}(c)`.
 
-#. If the type of :math:`{\mathit{numtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}` is Inn, then:
+      #) Perform :math:`z{}[{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}{}[i + {\mathit{ao}}{.}\mathsf{offset} : {|{\mathit{nt}}|} / 8] = {b^\ast}]`.
 
-   a. If :math:`{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^?}` is defined, then:
+#. If the type of :math:`{\mathit{numtype}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}` is Inn, then:
 
-      1) Let :math:`n` be :math:`{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^?}`.
+   a. If :math:`{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^?}` is defined, then:
+
+      1) Let :math:`n` be :math:`{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^?}`.
 
       #) If :math:`i + {\mathit{ao}}{.}\mathsf{offset} + n / 8` is greater than :math:`{|z{.}\mathsf{mems}{}[x]{.}\mathsf{bytes}|}`, then:
 
          a) Trap.
 
-   #. Let :math:`{\mathsf{i}}{N}` be :math:`{\mathit{numtype}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}`.
+   #. Let :math:`{\mathsf{i}}{N}` be :math:`{\mathit{numtype}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}`.
 
-   #. If :math:`{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^?}` is defined, then:
+   #. If :math:`{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^?}` is defined, then:
 
-      1) Let :math:`n` be :math:`{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 1}}}^?}`.
+      1) Let :math:`n` be :math:`{{\mathit{sz}}_{\mathit{u{\kern-0.1em\scriptstyle 0}}}^?}`.
 
       #) Let :math:`{b^\ast}` be :math:`{{\mathrm{bytes}}}_{{\mathsf{i}}{n}}({{\mathrm{wrap}}}_{{|{\mathsf{i}}{N}|}, n}(c))`.
 
@@ -21624,10 +22393,10 @@ watsup 0.4 generator
 == IL Validation after pass sideconditions...
 == Translating to AL...
 == Prose Generation...
-6-typing.watsup:194.10-194.32: if_expr_to_instrs: Yet `$before(typeuse, x, i)`
-6-typing.watsup:817.9-817.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
-6-typing.watsup:851.9-851.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
-6-typing.watsup:1309.9-1309.30: if_expr_to_instrs: Yet `$disjoint_(syntax name, nm*{nm : name})`
+6-typing.watsup:195.10-195.32: if_expr_to_instrs: Yet `$before(typeuse, x, i)`
+6-typing.watsup:876.9-876.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
+6-typing.watsup:910.9-910.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
+6-typing.watsup:1378.9-1378.30: if_expr_to_instrs: Yet `$disjoint_(syntax name, nm*{nm : name})`
 Numtype_ok
 - the number type numtype is valid.
 
@@ -21956,6 +22725,11 @@ Memtype_ok
 - the memory type (limits PAGE) is valid if and only if:
   - the limits limits is valid with the nat (2 ^ 16).
 
+Tagtype_ok
+- the memory type deftype is valid if and only if:
+  - the defined type deftype is valid.
+  - $expanddt(deftype) is (FUNC functype).
+
 Externtype_ok
 - the external type externtype_u0 is valid if and only if:
   - Either:
@@ -21971,6 +22745,9 @@ Externtype_ok
   - Or:
     - externtype_u0 is (MEM memtype).
     - the memory type memtype is valid.
+  - Or:
+    - externtype_u0 is (TAG tagtype).
+    - the memory type tagtype is valid.
 
 Instrtype_sub
 - the instruction type (t_11* ->_ x_1* t_12*) matches the instruction type (t_21* ->_ x_2* t_22*) if and only if:
@@ -22010,6 +22787,11 @@ Memtype_sub
 - the memory type (limits_1 PAGE) matches the memory type (limits_2 PAGE) if and only if:
   - the limits limits_1 matches the limits limits_2.
 
+Tagtype_sub
+- the memory type deftype_1 matches the memory type deftype_2 if and only if:
+  - the defined type deftype_1 matches the defined type deftype_2.
+  - the defined type deftype_2 matches the defined type deftype_1.
+
 Externtype_sub
 - the external type externtype_u0 matches the external type externtype_u1 if and only if:
   - Either:
@@ -22028,6 +22810,10 @@ Externtype_sub
     - externtype_u0 is (MEM memtype_1).
     - externtype_u1 is (MEM memtype_2).
     - the memory type memtype_1 matches the memory type memtype_2.
+  - Or:
+    - externtype_u0 is (TAG tagtype_1).
+    - externtype_u1 is (TAG tagtype_2).
+    - the memory type tagtype_1 matches the memory type tagtype_2.
 
 Blocktype_ok
 - the block type blocktype_u0 is valid with the instruction type (valtype_u1* ->_ [] valtype_u2*) if and only if:
@@ -22044,6 +22830,29 @@ Blocktype_ok
     - |C.TYPES| is greater than typeidx.
     - $expanddt(C.TYPES[typeidx]) is (FUNC (t_1* -> t_2*)).
 
+Catch_ok
+- the catch clause catch_u0 is valid if and only if:
+  - Either:
+    - catch_u0 is (CATCH x l).
+    - |C.TAGS| is greater than x.
+    - |C.LABELS| is greater than l.
+    - $expanddt(C.TAGS[x]) is (FUNC (t* -> [])).
+    - the value type sequence t* matches the result type C.LABELS[l].
+  - Or:
+    - catch_u0 is (CATCH_REF x l).
+    - |C.TAGS| is greater than x.
+    - |C.LABELS| is greater than l.
+    - $expanddt(C.TAGS[x]) is (FUNC (t* -> [])).
+    - the value type sequence t* ++ [(REF (NULL ?() ?) EXN)] matches the result type C.LABELS[l].
+  - Or:
+    - catch_u0 is (CATCH_ALL l).
+    - |C.LABELS| is greater than l.
+    - the value type sequence [] matches the result type C.LABELS[l].
+  - Or:
+    - catch_u0 is (CATCH_ALL_REF l).
+    - |C.LABELS| is greater than l.
+    - the value type sequence [(REF (NULL ?() ?) EXN)] matches the result type C.LABELS[l].
+
 Instr_ok/nop
 - the instr NOP is valid with the instruction type ([] ->_ [] []).
 
@@ -22175,6 +22984,23 @@ Instr_ok/return_call_indirect
   - the value type sequence t_2* matches the value type sequence t'_2*.
   - the instruction type (t_3* ->_ [] t_4*) is valid.
 
+Instr_ok/throw
+- the instr (THROW x) is valid with the instruction type (t_1* ++ t* ->_ [] t_2*) if and only if:
+  - |C.TAGS| is greater than x.
+  - $expanddt(C.TAGS[x]) is (FUNC (t* -> [])).
+  - the instruction type (t_1* ->_ [] t_2*) is valid.
+
+Instr_ok/throw_ref
+- the instr THROW_REF is valid with the instruction type (t_1* ++ [(REF (NULL ?(()) ?) EXN)] ->_ [] t_2*) if and only if:
+  - the instruction type (t_1* ->_ [] t_2*) is valid.
+
+Instr_ok/try_table
+- the instr (TRY_TABLE bt catch* instr*) is valid with the instruction type (t_1* ->_ [] t_2*) if and only if:
+  - the block type bt is valid with the instruction type (t_1* ->_ [] t_2*).
+  - Under the context C with .LABELS prepended by [t_2*], the instr sequence instr* is valid with the instruction type (t_1* ->_ x* t_2*).
+  - For all catch in catch*,
+    - the catch clause catch is valid.
+
 Instr_ok/const
 - the instr (nt.CONST c_nt) is valid with the instruction type ([] ->_ [] [nt]).
 
@@ -22667,6 +23493,11 @@ Mem_ok
 - the memory (MEMORY memtype) is valid with the memory type memtype if and only if:
   - the memory type memtype is valid.
 
+Tag_ok
+- the tag (TAG x) is valid with the memory type C.TYPES[x] if and only if:
+  - |C.TYPES| is greater than x.
+  - $expanddt(C.TYPES[x]) is (FUNC functype).
+
 Elemmode_ok
 - the elemmode elemmode_u0 is valid with the element type rt if and only if:
   - Either:
@@ -22735,6 +23566,11 @@ Externidx_ok
     - externtype_u1 is (MEM mt).
     - |C.MEMS| is greater than x.
     - C.MEMS[x] is mt.
+  - Or:
+    - externidx_u0 is (TAG x).
+    - externtype_u1 is (TAG at).
+    - |C.TAGS| is greater than x.
+    - C.TAGS[x] is at.
 
 Export_ok
 - the export (EXPORT name externidx) is valid with the name name and the external type xt if and only if:
@@ -22763,23 +23599,26 @@ Types_ok
     - Under the context C with .TYPES appended by dt_1*, the type definition sequence type* is valid with the defined type sequence dt*.
 
 Module_ok
-- the module (MODULE type* import* func* global* table* mem* elem* data* start? export*) is valid with the module type $clos_moduletype(C, (xt_I* -> xt_E*)) if and only if:
+- the module (MODULE type* import* func* global* table* mem* tag* elem* data* start? export*) is valid with the module type $clos_moduletype(C, (xt_I* -> xt_E*)) if and only if:
   - |xt_I*| is |import*|.
   - |tt*| is |table*|.
   - |mt*| is |mem*|.
+  - |tag*| is |at*|.
   - |func*| is |dt*|.
   - |rt*| is |elem*|.
   - |ok*| is |data*|.
   - |nm*| is |export*|.
   - |xt_E*| is |export*|.
-  - Under the context { TYPES: []; RECS: []; FUNCS: []; GLOBALS: []; TABLES: []; MEMS: []; ELEMS: []; DATAS: []; LOCALS: []; LABELS: []; RETURN: ?(); REFS: []; }, the type definition sequence type* is valid with the defined type sequence dt'*.
+  - Under the context { TYPES: []; RECS: []; FUNCS: []; GLOBALS: []; TABLES: []; MEMS: []; TAGS: []; ELEMS: []; DATAS: []; LOCALS: []; LABELS: []; RETURN: ?(); REFS: []; }, the type definition sequence type* is valid with the defined type sequence dt'*.
   - For all import in import* and xt_I in xt_I*,
-    - Under the context { TYPES: dt'*; RECS: []; FUNCS: []; GLOBALS: []; TABLES: []; MEMS: []; ELEMS: []; DATAS: []; LOCALS: []; LABELS: []; RETURN: ?(); REFS: []; }, the import import is valid with the external type xt_I.
+    - Under the context { TYPES: dt'*; RECS: []; FUNCS: []; GLOBALS: []; TABLES: []; MEMS: []; TAGS: []; ELEMS: []; DATAS: []; LOCALS: []; LABELS: []; RETURN: ?(); REFS: []; }, the import import is valid with the external type xt_I.
   - Under the context C', the global sequence global* is valid with the global type sequence gt*.
   - For all table in table* and tt in tt*,
     - Under the context C', the table table is valid with the table type tt.
   - For all mem in mem* and mt in mt*,
     - Under the context C', the memory mem is valid with the memory type mt.
+  - For all at in at* and tag in tag*,
+    - Under the context C', the tag tag is valid with the memory type at.
   - For all dt in dt* and func in func*,
     - the function func is valid with the defined type dt.
   - For all elem in elem* and rt in rt*,
@@ -22791,13 +23630,14 @@ Module_ok
   - For all export in export* and nm in nm* and xt_E in xt_E*,
     - the export export is valid with the name nm and the external type xt_E.
   - Yet: $disjoint_(syntax name, nm*{nm : name})
-  - C is { TYPES: dt'*; RECS: []; FUNCS: dt_I* ++ dt*; GLOBALS: gt_I* ++ gt*; TABLES: tt_I* ++ tt*; MEMS: mt_I* ++ mt*; ELEMS: rt*; DATAS: ok*; LOCALS: []; LABELS: []; RETURN: ?(); REFS: x*; }.
-  - C' is { TYPES: dt'*; RECS: []; FUNCS: dt_I* ++ dt*; GLOBALS: gt_I*; TABLES: []; MEMS: []; ELEMS: []; DATAS: []; LOCALS: []; LABELS: []; RETURN: ?(); REFS: x*; }.
+  - C is { TYPES: dt'*; RECS: []; FUNCS: dt_I* ++ dt*; GLOBALS: gt_I* ++ gt*; TABLES: tt_I* ++ tt*; MEMS: mt_I* ++ mt*; TAGS: at_I* ++ at*; ELEMS: rt*; DATAS: ok*; LOCALS: []; LABELS: []; RETURN: ?(); REFS: x*; }.
+  - C' is { TYPES: dt'*; RECS: []; FUNCS: dt_I* ++ dt*; GLOBALS: gt_I*; TABLES: []; MEMS: []; TAGS: []; ELEMS: []; DATAS: []; LOCALS: []; LABELS: []; RETURN: ?(); REFS: x*; }.
   - x* is $funcidx_nonfuncs((global* table* mem* elem* data*)).
   - dt_I* is $funcsxt(xt_I*).
   - gt_I* is $globalsxt(xt_I*).
   - tt_I* is $tablesxt(xt_I*).
   - mt_I* is $memsxt(xt_I*).
+  - at_I* is $tagsxt(xt_I*).
 
 NotationTypingInstrScheme
 - the instr sequence [instr_u0] is valid with the function type (valtype_u1* -> valtype_u3*) if and only if:
@@ -23615,6 +24455,9 @@ free_table (TABLE tabletype expr)
 free_mem (MEMORY memtype)
 1. Return $free_memtype(memtype).
 
+free_tag (TAG typeidx)
+1. Return $free_typeidx(typeidx).
+
 free_elemmode elemmode_u0
 1. If elemmode_u0 is of the case ACTIVE, then:
   a. Return YetE ($free_tableidx(tableidx) ++ $free_expr(expr)).
@@ -23644,8 +24487,8 @@ free_export (EXPORT name externidx)
 free_import (IMPORT name_1 name_2 externtype)
 1. Return $free_externtype(externtype).
 
-free_module (MODULE type* import* func* global* table* mem* elem* data* start? export*)
-1. Return YetE ($free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})).
+free_module (MODULE type* import* func* global* table* mem* tag* elem* data* start? export*)
+1. Return YetE ($free_list($free_type(type)*{type : type}) ++ $free_list($free_import(import)*{import : import}) ++ $free_list($free_func(func)*{func : func}) ++ $free_list($free_global(global)*{global : global}) ++ $free_list($free_table(table)*{table : table}) ++ $free_list($free_mem(mem)*{mem : mem}) ++ $free_list($free_tag(tag)*{tag : tag}) ++ $free_list($free_elem(elem)*{elem : elem}) ++ $free_list($free_data(data)*{data : data}) ++ $free_opt($free_start(start)?{start : start}) ++ $free_list($free_export(export)*{export : export})).
 
 funcidx_module module
 1. Return $free_module(module).FUNCS.
@@ -23658,14 +24501,16 @@ subst_typevar tv typevar_u0* typeuse_u1*
   a. Return tv.
 2. Assert: Due to validation, (|typeuse_u1*| ≥ 1).
 3. Let [tu_1] ++ tu'* be typeuse_u1*.
-4. If (|typevar_u0*| ≥ 1), then:
+4. If (|typevar_u0*| < 1), then:
+  a. Do nothing.
+5. Else:
   a. Let [tv_1] ++ tv'* be typevar_u0*.
   b. If (tv is tv_1), then:
     1) Return tu_1.
-5. Let [tu_1] ++ tu'* be typeuse_u1*.
-6. Assert: Due to validation, (|typevar_u0*| ≥ 1).
-7. Let [tv_1] ++ tv'* be typevar_u0*.
-8. Return $subst_typevar(tv, tv'*, tu'*).
+6. Let [tu_1] ++ tu'* be typeuse_u1*.
+7. Assert: Due to validation, (|typevar_u0*| ≥ 1).
+8. Let [tv_1] ++ tv'* be typevar_u0*.
+9. Return $subst_typevar(tv, tv'*, tu'*).
 
 subst_packtype pt tv* tu*
 1. Return pt.
@@ -23853,6 +24698,16 @@ memsxx externidx_u0*
 4. Let [externidx] ++ xx* be externidx_u0*.
 5. Return $memsxx(xx*).
 
+tagsxx externidx_u0*
+1. If (externidx_u0* is []), then:
+  a. Return [].
+2. Let [externidx_0] ++ xx* be externidx_u0*.
+3. If externidx_0 is of the case TAG, then:
+  a. Let (TAG x) be externidx_0.
+  b. Return [x] ++ $tagsxx(xx*).
+4. Let [externidx] ++ xx* be externidx_u0*.
+5. Return $tagsxx(xx*).
+
 funcsxt externtype_u0*
 1. If (externtype_u0* is []), then:
   a. Return [].
@@ -23893,6 +24748,16 @@ memsxt externtype_u0*
 4. Let [externtype] ++ xt* be externtype_u0*.
 5. Return $memsxt(xt*).
 
+tagsxt externtype_u0*
+1. If (externtype_u0* is []), then:
+  a. Return [].
+2. Let [externtype_0] ++ xt* be externtype_u0*.
+3. If externtype_0 is of the case TAG, then:
+  a. Let (TAG at) be externtype_0.
+  b. Return [at] ++ $tagsxt(xt*).
+4. Let [externtype] ++ xt* be externtype_u0*.
+5. Return $tagsxt(xt*).
+
 memarg0
 1. Return { ALIGN: 0; OFFSET: 0; }.
 
@@ -24636,45 +25501,55 @@ unpackfield_ storagetype_u0 sx_u1? fieldval_u2
   d. Assert: Due to validation, (storagetype_u0 is packtype).
   e. Return (I32.CONST $extend__($psize(packtype), 32, sx, i)).
 
-funcsxv externval_u0*
-1. If (externval_u0* is []), then:
+funcsxa externaddr_u0*
+1. If (externaddr_u0* is []), then:
   a. Return [].
-2. Let [externval_0] ++ xv* be externval_u0*.
-3. If externval_0 is of the case FUNC, then:
-  a. Let (FUNC fa) be externval_0.
-  b. Return [fa] ++ $funcsxv(xv*).
-4. Let [externval] ++ xv* be externval_u0*.
-5. Return $funcsxv(xv*).
-
-globalsxv externval_u0*
-1. If (externval_u0* is []), then:
+2. Let [externaddr_0] ++ xa* be externaddr_u0*.
+3. If externaddr_0 is of the case FUNC, then:
+  a. Let (FUNC fa) be externaddr_0.
+  b. Return [fa] ++ $funcsxa(xa*).
+4. Let [externaddr] ++ xa* be externaddr_u0*.
+5. Return $funcsxa(xa*).
+
+globalsxa externaddr_u0*
+1. If (externaddr_u0* is []), then:
   a. Return [].
-2. Let [externval_0] ++ xv* be externval_u0*.
-3. If externval_0 is of the case GLOBAL, then:
-  a. Let (GLOBAL ga) be externval_0.
-  b. Return [ga] ++ $globalsxv(xv*).
-4. Let [externval] ++ xv* be externval_u0*.
-5. Return $globalsxv(xv*).
-
-tablesxv externval_u0*
-1. If (externval_u0* is []), then:
+2. Let [externaddr_0] ++ xa* be externaddr_u0*.
+3. If externaddr_0 is of the case GLOBAL, then:
+  a. Let (GLOBAL ga) be externaddr_0.
+  b. Return [ga] ++ $globalsxa(xa*).
+4. Let [externaddr] ++ xa* be externaddr_u0*.
+5. Return $globalsxa(xa*).
+
+tablesxa externaddr_u0*
+1. If (externaddr_u0* is []), then:
   a. Return [].
-2. Let [externval_0] ++ xv* be externval_u0*.
-3. If externval_0 is of the case TABLE, then:
-  a. Let (TABLE ta) be externval_0.
-  b. Return [ta] ++ $tablesxv(xv*).
-4. Let [externval] ++ xv* be externval_u0*.
-5. Return $tablesxv(xv*).
-
-memsxv externval_u0*
-1. If (externval_u0* is []), then:
+2. Let [externaddr_0] ++ xa* be externaddr_u0*.
+3. If externaddr_0 is of the case TABLE, then:
+  a. Let (TABLE ta) be externaddr_0.
+  b. Return [ta] ++ $tablesxa(xa*).
+4. Let [externaddr] ++ xa* be externaddr_u0*.
+5. Return $tablesxa(xa*).
+
+memsxa externaddr_u0*
+1. If (externaddr_u0* is []), then:
   a. Return [].
-2. Let [externval_0] ++ xv* be externval_u0*.
-3. If externval_0 is of the case MEM, then:
-  a. Let (MEM ma) be externval_0.
-  b. Return [ma] ++ $memsxv(xv*).
-4. Let [externval] ++ xv* be externval_u0*.
-5. Return $memsxv(xv*).
+2. Let [externaddr_0] ++ xa* be externaddr_u0*.
+3. If externaddr_0 is of the case MEM, then:
+  a. Let (MEM ma) be externaddr_0.
+  b. Return [ma] ++ $memsxa(xa*).
+4. Let [externaddr] ++ xa* be externaddr_u0*.
+5. Return $memsxa(xa*).
+
+tagsxa externaddr_u0*
+1. If (externaddr_u0* is []), then:
+  a. Return [].
+2. Let [externaddr_0] ++ xa* be externaddr_u0*.
+3. If externaddr_0 is of the case TAG, then:
+  a. Let (TAG ha) be externaddr_0.
+  b. Return [ha] ++ $tagsxa(xa*).
+4. Let [externaddr] ++ xa* be externaddr_u0*.
+5. Return $tagsxa(xa*).
 
 store
 1. Return.
@@ -24683,6 +25558,10 @@ frame
 1. Let f be the current frame.
 2. Return f.
 
+tagaddr
+1. Let f be the current frame.
+2. Return f.MODULE.TAGS.
+
 moduleinst
 1. Let f be the current frame.
 2. Return f.MODULE.
@@ -24699,6 +25578,9 @@ tableinst
 meminst
 1. Return s.MEMS.
 
+taginst
+1. Return s.TAGS.
+
 eleminst
 1. Return s.ELEMS.
 
@@ -24711,6 +25593,9 @@ structinst
 arrayinst
 1. Return s.ARRAYS.
 
+exninst
+1. Return s.EXNS.
+
 type x
 1. Let f be the current frame.
 2. Return f.MODULE.TYPES[x].
@@ -24731,6 +25616,10 @@ mem x
 1. Let f be the current frame.
 2. Return s.MEMS[f.MODULE.MEMS[x]].
 
+tag x
+1. Let f be the current frame.
+2. Return s.TAGS[f.MODULE.TAGS[x]].
+
 elem x
 1. Let f be the current frame.
 2. Return s.ELEMS[f.MODULE.ELEMS[x]].
@@ -24787,6 +25676,9 @@ add_structinst si*
 add_arrayinst ai*
 1. Append ai* to the s.ARRAYS.
 
+add_exninst exn*
+1. Append exn* to the s.EXNS.
+
 growtable tableinst n r
 1. Let { TYPE: ((i, j), rt); REFS: r'*; } be tableinst.
 2. If ((|r'*| + n) ≤ j), then:
@@ -24892,6 +25784,20 @@ allocmems memtype_u0*
 4. Let ma'* be $allocmems(memtype'*).
 5. Return [ma] ++ ma'*.
 
+alloctag at
+1. Let taginst be { TYPE: at; }.
+2. Let a be |s.TAGS|.
+3. Append taginst to the s.TAGS.
+4. Return a.
+
+alloctags tagtype_u0*
+1. If (tagtype_u0* is []), then:
+  a. Return [].
+2. Let [at] ++ at'* be tagtype_u0*.
+3. Let aa be $alloctag(at).
+4. Let aa'* be $alloctags(at'*).
+5. Return [aa] ++ aa'*.
+
 allocelem elemtype ref*
 1. Let eleminst be { TYPE: elemtype; REFS: ref*; }.
 2. Let a be |s.ELEMS|.
@@ -24929,61 +25835,70 @@ allocdatas datatype_u0* byte_u1*
 allocexport moduleinst (EXPORT name externidx_u0)
 1. If externidx_u0 is of the case FUNC, then:
   a. Let (FUNC x) be externidx_u0.
-  b. Return { NAME: name; VALUE: (FUNC moduleinst.FUNCS[x]); }.
+  b. Return { NAME: name; ADDR: (FUNC moduleinst.FUNCS[x]); }.
 2. If externidx_u0 is of the case GLOBAL, then:
   a. Let (GLOBAL x) be externidx_u0.
-  b. Return { NAME: name; VALUE: (GLOBAL moduleinst.GLOBALS[x]); }.
+  b. Return { NAME: name; ADDR: (GLOBAL moduleinst.GLOBALS[x]); }.
 3. If externidx_u0 is of the case TABLE, then:
   a. Let (TABLE x) be externidx_u0.
-  b. Return { NAME: name; VALUE: (TABLE moduleinst.TABLES[x]); }.
-4. Assert: Due to validation, externidx_u0 is of the case MEM.
-5. Let (MEM x) be externidx_u0.
-6. Return { NAME: name; VALUE: (MEM moduleinst.MEMS[x]); }.
+  b. Return { NAME: name; ADDR: (TABLE moduleinst.TABLES[x]); }.
+4. If externidx_u0 is of the case MEM, then:
+  a. Let (MEM x) be externidx_u0.
+  b. Return { NAME: name; ADDR: (MEM moduleinst.MEMS[x]); }.
+5. Assert: Due to validation, externidx_u0 is of the case TAG.
+6. Let (TAG x) be externidx_u0.
+7. Return { NAME: name; ADDR: (TAG moduleinst.TAGS[x]); }.
 
 allocexports moduleinst export*
 1. Return $allocexport(moduleinst, export)*.
 
-allocmodule module externval* val_G* ref_T* ref_E**
-1. Let fa_I* be $funcsxv(externval*).
-2. Let ga_I* be $globalsxv(externval*).
-3. Let ma_I* be $memsxv(externval*).
-4. Let ta_I* be $tablesxv(externval*).
-5. Assert: Due to validation, module is of the case MODULE.
-6. Let (MODULE type* import* func* global* table* mem* elem* data* start? export*) be module.
-7. Let fa* be (|s.FUNCS| + i_F)^(i_F<|func*|).
-8. Let ga* be (|s.GLOBALS| + i_G)^(i_G<|global*|).
-9. Let ta* be (|s.TABLES| + i_T)^(i_T<|table*|).
-10. Let ma* be (|s.MEMS| + i_M)^(i_M<|mem*|).
-11. Let ea* be (|s.ELEMS| + i_E)^(i_E<|elem*|).
-12. Let da* be (|s.DATAS| + i_D)^(i_D<|data*|).
-13. Assert: Due to validation, mem is of the case MEMORY*.
-14. Let (MEMORY memtype)* be mem*.
-15. Let dt* be $alloctypes(type*).
-16. Assert: Due to validation, data is of the case DATA*.
-17. Let (DATA byte* datamode)* be data*.
-18. Assert: Due to validation, global is of the case GLOBAL*.
-19. Let (GLOBAL globaltype expr_G)* be global*.
-20. Assert: Due to validation, table is of the case TABLE*.
-21. Let (TABLE tabletype expr_T)* be table*.
-22. Assert: Due to validation, elem is of the case ELEM*.
-23. Let (ELEM elemtype expr_E* elemmode)* be elem*.
-24. Assert: Due to validation, func is of the case FUNC*.
-25. Let (FUNC x local* expr_F)* be func*.
-26. Let xi* be $allocexports({ TYPES: []; FUNCS: fa_I* ++ fa*; GLOBALS: ga_I* ++ ga*; TABLES: ta_I* ++ ta*; MEMS: ma_I* ++ ma*; ELEMS: []; DATAS: []; EXPORTS: []; }, export*).
-27. Let moduleinst be { TYPES: dt*; FUNCS: fa_I* ++ fa*; GLOBALS: ga_I* ++ ga*; TABLES: ta_I* ++ ta*; MEMS: ma_I* ++ ma*; ELEMS: ea*; DATAS: da*; EXPORTS: xi*; }.
-28. Let funcaddr_0 be $allocfuncs(dt*[x]*, (FUNC x local* expr_F)*, moduleinst^|func*|).
-29. Assert: Due to validation, (funcaddr_0 is fa*).
-30. Let globaladdr_0 be $allocglobals(globaltype*, val_G*).
-31. Assert: Due to validation, (globaladdr_0 is ga*).
-32. Let tableaddr_0 be $alloctables(tabletype*, ref_T*).
-33. Assert: Due to validation, (tableaddr_0 is ta*).
-34. Let memaddr_0 be $allocmems(memtype*).
-35. Assert: Due to validation, (memaddr_0 is ma*).
-36. Let elemaddr_0 be $allocelems(elemtype*, ref_E**).
-37. Assert: Due to validation, (elemaddr_0 is ea*).
-38. Let dataaddr_0 be $allocdatas(OK^|data*|, byte**).
-39. Assert: Due to validation, (dataaddr_0 is da*).
-40. Return moduleinst.
+allocmodule module externaddr* val_G* ref_T* ref_E**
+1. Let fa_I* be $funcsxa(externaddr*).
+2. Let ga_I* be $globalsxa(externaddr*).
+3. Let aa_I* be $tagsxa(externaddr*).
+4. Let ma_I* be $memsxa(externaddr*).
+5. Let ta_I* be $tablesxa(externaddr*).
+6. Assert: Due to validation, module is of the case MODULE.
+7. Let (MODULE type* import* func* global* table* mem* tag* elem* data* start? export*) be module.
+8. Let fa* be (|s.FUNCS| + i_F)^(i_F<|func*|).
+9. Let ga* be (|s.GLOBALS| + i_G)^(i_G<|global*|).
+10. Let ta* be (|s.TABLES| + i_T)^(i_T<|table*|).
+11. Let aa* be (|s.TAGS| + i_A)^(i_A<|tag*|).
+12. Let ma* be (|s.MEMS| + i_M)^(i_M<|mem*|).
+13. Let ea* be (|s.ELEMS| + i_E)^(i_E<|elem*|).
+14. Let da* be (|s.DATAS| + i_D)^(i_D<|data*|).
+15. Assert: Due to validation, mem is of the case MEMORY*.
+16. Let (MEMORY memtype)* be mem*.
+17. Let dt* be $alloctypes(type*).
+18. Assert: Due to validation, tag is of the case TAG*.
+19. Let (TAG y)* be tag*.
+20. Assert: Due to validation, data is of the case DATA*.
+21. Let (DATA byte* datamode)* be data*.
+22. Assert: Due to validation, global is of the case GLOBAL*.
+23. Let (GLOBAL globaltype expr_G)* be global*.
+24. Assert: Due to validation, table is of the case TABLE*.
+25. Let (TABLE tabletype expr_T)* be table*.
+26. Assert: Due to validation, elem is of the case ELEM*.
+27. Let (ELEM elemtype expr_E* elemmode)* be elem*.
+28. Assert: Due to validation, func is of the case FUNC*.
+29. Let (FUNC x local* expr_F)* be func*.
+30. Let xi* be $allocexports({ TYPES: []; FUNCS: fa_I* ++ fa*; GLOBALS: ga_I* ++ ga*; TABLES: ta_I* ++ ta*; MEMS: ma_I* ++ ma*; TAGS: aa_I* ++ aa*; ELEMS: []; DATAS: []; EXPORTS: []; }, export*).
+31. Let moduleinst be { TYPES: dt*; FUNCS: fa_I* ++ fa*; GLOBALS: ga_I* ++ ga*; TABLES: ta_I* ++ ta*; MEMS: ma_I* ++ ma*; TAGS: aa_I* ++ aa*; ELEMS: ea*; DATAS: da*; EXPORTS: xi*; }.
+32. Let n_0 be $allocfuncs(dt*[x]*, (FUNC x local* expr_F)*, moduleinst^|func*|).
+33. Assert: Due to validation, (n_0 is fa*).
+34. Let n_0 be $allocglobals(globaltype*, val_G*).
+35. Assert: Due to validation, (n_0 is ga*).
+36. Let n_0 be $alloctables(tabletype*, ref_T*).
+37. Assert: Due to validation, (n_0 is ta*).
+38. Let n_0 be $allocmems(memtype*).
+39. Assert: Due to validation, (n_0 is ma*).
+40. Let n_0 be $alloctags(dt*[y]*).
+41. Assert: Due to validation, (n_0 is aa*).
+42. Let n_0 be $allocelems(elemtype*, ref_E**).
+43. Assert: Due to validation, (n_0 is ea*).
+44. Let n_0 be $allocdatas(OK^|data*|, byte**).
+45. Assert: Due to validation, (n_0 is da*).
+46. Return moduleinst.
 
 runelem_ x (ELEM rt e^n elemmode_u0)
 1. If (elemmode_u0 is PASSIVE), then:
@@ -25016,16 +25931,16 @@ evalglobals z globaltype_u0* expr_u1*
 11. Let val'* be $evalglobals(z, gt'*, expr'*).
 12. Return [val] ++ val'*.
 
-instantiate z module externval*
+instantiate z module externaddr*
 1. Let (xt_I* -> xt_E*) be $Module_ok(module).
 2. Assert: Due to validation, module is of the case MODULE.
-3. Let (MODULE type* import* func* global* table* mem* elem* data* start? export*) be module.
-4. Assert: Due to validation, ($Externval_type(externval) is xt_I)*.
+3. Let (MODULE type* import* func* global* table* mem* tag* elem* data* start? export*) be module.
+4. Assert: Due to validation, ($Externaddr_type(externaddr) is xt_I)*.
 5. Let instr_D* be $concat_(instr, $rundata_(i_D, data*[i_D])^(i_D<|data*|)).
 6. Let instr_E* be $concat_(instr, $runelem_(i_E, elem*[i_E])^(i_E<|elem*|)).
 7. Assert: Due to validation, start is of the case START?.
 8. Let (START x)? be start?.
-9. Let moduleinst_0 be { TYPES: $alloctypes(type*); FUNCS: $funcsxv(externval*) ++ (|s.FUNCS| + i_F)^(i_F<|func*|); GLOBALS: $globalsxv(externval*); TABLES: []; MEMS: []; ELEMS: []; DATAS: []; EXPORTS: []; }.
+9. Let moduleinst_0 be { TYPES: $alloctypes(type*); FUNCS: $funcsxa(externaddr*) ++ (|s.FUNCS| + i_F)^(i_F<|func*|); GLOBALS: $globalsxa(externaddr*); TABLES: []; MEMS: []; TAGS: []; ELEMS: []; DATAS: []; EXPORTS: []; }.
 10. Assert: Due to validation, data is of the case DATA*.
 11. Assert: Due to validation, table is of the case TABLE*.
 12. Let (TABLE tabletype expr_T)* be table*.
@@ -25044,7 +25959,7 @@ instantiate z module externval*
 25. Push the activation of z' to the stack.
 26. Let [ref_E]** be $eval_expr(expr_E)**.
 27. Pop the activation of _f from the stack.
-28. Let moduleinst be $allocmodule(module, externval*, val_G*, ref_T*, ref_E**).
+28. Let moduleinst be $allocmodule(module, externaddr*, val_G*, ref_T*, ref_E**).
 29. Let f be { LOCALS: []; MODULE: moduleinst; }.
 30. Push the activation of f with arity 0 to the stack.
 31. Execute the instruction instr_E*.
@@ -25056,7 +25971,7 @@ instantiate z module externval*
 35. Return f.MODULE.
 
 invoke funcaddr val*
-1. Let f be { LOCALS: []; MODULE: { TYPES: []; FUNCS: []; GLOBALS: []; TABLES: []; MEMS: []; ELEMS: []; DATAS: []; EXPORTS: []; }; }.
+1. Let f be { LOCALS: []; MODULE: { TYPES: []; FUNCS: []; GLOBALS: []; TABLES: []; MEMS: []; TAGS: []; ELEMS: []; DATAS: []; EXPORTS: []; }; }.
 2. Assert: Due to validation, $expanddt(s.FUNCS[funcaddr].TYPE) is of the case FUNC.
 3. Let (FUNC functype_0) be $expanddt(s.FUNCS[funcaddr].TYPE).
 4. Let (t_1* -> t_2*) be functype_0.
@@ -25126,21 +26041,30 @@ Step_pure/label
 
 Step_pure/br l
 1. Pop all values val* from the top of the stack.
-2. Let L be the current label.
-3. Let n be the arity of L.
-4. Let instr'* be the continuation of L.
-5. Pop the current label from the stack.
-6. Let instr_u0* be val*.
-7. If (|instr_u0*| ≥ n), then:
-  a. Let val'* ++ val^n be instr_u0*.
-  b. If (l is 0), then:
-    1) Push the values val^n to the stack.
-    2) Execute the instruction instr'*.
-8. If the type of instr_u0 is val*, then:
-  a. Let val* be instr_u0*.
-  b. If (l > 0), then:
-    1) Push the values val* to the stack.
-    2) Execute the instruction (BR (l - 1)).
+2. If the top of the stack is a LABEL_, then:
+  a. Push the values val* to the stack.
+  b. Let L be the current label.
+  c. Let n be the arity of L.
+  d. Let instr'* be the continuation of L.
+  e. If (l is 0), then:
+    1) Assert: Due to validation, there are at least n values on the top of the stack.
+    2) Pop the values val^n from the stack.
+    3) Pop all values val'* from the top of the stack.
+    4) Pop the current label from the stack.
+    5) Push the values val^n to the stack.
+    6) Execute the instruction instr'*.
+  f. Else:
+    1) Pop all values val* from the top of the stack.
+    2) If (l > 0), then:
+      a) Pop the current label from the stack.
+      b) Push the values val* to the stack.
+      c) Execute the instruction (BR (l - 1)).
+3. Else if the top of the stack is a HANDLER_, then:
+  a. Push the values val* to the stack.
+  b. Pop all values val* from the top of the stack.
+  c. Exit from HANDLER_.
+  d. Push the values val* to the stack.
+  e. Execute the instruction (BR l).
 
 Step_pure/br_if l
 1. Assert: Due to validation, a value of value type I32 is on the top of the stack.
@@ -25197,59 +26121,78 @@ Step_pure/frame
 
 Step_pure/return
 1. Pop all values val* from the top of the stack.
-2. If a frame is now on the top of the stack, then:
-  a. Let f be the current frame.
-  b. Let n be the arity of f.
-  c. Pop the current frame from the stack.
-  d. Let val'* ++ val^n be val*.
-  e. Push the values val^n to the stack.
-3. Else if a label is now on the top of the stack, then:
-  a. Pop the current label from the stack.
-  b. Push the values val* to the stack.
-  c. Execute the instruction RETURN.
-
-Step_pure/trap
-1. YetI: TODO: It is likely that the value stack of two rules are different.
+2. If the top of the stack is a FRAME_, then:
+  a. Push the values val* to the stack.
+  b. Let f be the current frame.
+  c. Let n be the arity of f.
+  d. Assert: Due to validation, there are at least n values on the top of the stack.
+  e. Pop the values val^n from the stack.
+  f. Pop all values val'* from the top of the stack.
+  g. Pop the current frame from the stack.
+  h. Push the values val^n to the stack.
+3. Else if the top of the stack is a LABEL_, then:
+  a. Push the values val* to the stack.
+  b. Pop all values val* from the top of the stack.
+  c. Pop the current label from the stack.
+  d. Push the values val* to the stack.
+  e. Execute the instruction RETURN.
+4. Else if the top of the stack is a HANDLER_, then:
+  a. Push the values val* to the stack.
+  b. Pop all values val* from the top of the stack.
+  c. Exit from HANDLER_.
+  d. Push the values val* to the stack.
+  e. Execute the instruction RETURN.
+
+Step_pure/handler
+1. Pop all values val* from the top of the stack.
+2. Assert: Due to validation, YetE (a handler is now on the top of the stack).
+3. Exit from HANDLER_.
+4. Push the values val* to the stack.
 
 Step_pure/unop nt unop
-1. Assert: Due to validation, a value of value type nt is on the top of the stack.
-2. Pop the value (nt.CONST c_1) from the stack.
-3. If (|$unop_(nt, unop, c_1)| ≤ 0), then:
+1. Assert: Due to validation, a value of value type numtype_0 is on the top of the stack.
+2. Pop the value (numtype_0.CONST c_1) from the stack.
+3. Assert: Due to validation, (numtype_0 is nt).
+4. If (|$unop_(nt, unop, c_1)| ≤ 0), then:
   a. Trap.
-4. Let c be an element of $unop_(nt, unop, c_1).
-5. Push the value (nt.CONST c) to the stack.
+5. Let c be an element of $unop_(nt, unop, c_1).
+6. Push the value (nt.CONST c) to the stack.
 
 Step_pure/binop nt binop
-1. Assert: Due to validation, a value of value type nt is on the top of the stack.
-2. Pop the value (nt.CONST c_2) from the stack.
-3. Assert: Due to validation, a value of value type nt is on the top of the stack.
-4. Pop the value (nt.CONST c_1) from the stack.
-5. If (|$binop_(nt, binop, c_1, c_2)| ≤ 0), then:
+1. Assert: Due to validation, a value of value type numtype_0 is on the top of the stack.
+2. Pop the value (numtype_0.CONST c_2) from the stack.
+3. Assert: Due to validation, (numtype_0 is nt).
+4. Assert: Due to validation, a value of value type numtype_0 is on the top of the stack.
+5. Pop the value (numtype_0.CONST c_1) from the stack.
+6. If (|$binop_(nt, binop, c_1, c_2)| ≤ 0), then:
   a. Trap.
-6. Let c be an element of $binop_(nt, binop, c_1, c_2).
-7. Push the value (nt.CONST c) to the stack.
+7. Let c be an element of $binop_(nt, binop, c_1, c_2).
+8. Push the value (nt.CONST c) to the stack.
 
 Step_pure/testop nt testop
-1. Assert: Due to validation, a value of value type nt is on the top of the stack.
-2. Pop the value (nt.CONST c_1) from the stack.
-3. Let c be $testop_(nt, testop, c_1).
-4. Push the value (I32.CONST c) to the stack.
+1. Assert: Due to validation, a value of value type numtype_0 is on the top of the stack.
+2. Pop the value (numtype_0.CONST c_1) from the stack.
+3. Assert: Due to validation, (numtype_0 is nt).
+4. Let c be $testop_(nt, testop, c_1).
+5. Push the value (I32.CONST c) to the stack.
 
 Step_pure/relop nt relop
-1. Assert: Due to validation, a value of value type nt is on the top of the stack.
-2. Pop the value (nt.CONST c_2) from the stack.
-3. Assert: Due to validation, a value of value type nt is on the top of the stack.
-4. Pop the value (nt.CONST c_1) from the stack.
-5. Let c be $relop_(nt, relop, c_1, c_2).
-6. Push the value (I32.CONST c) to the stack.
+1. Assert: Due to validation, a value of value type numtype_0 is on the top of the stack.
+2. Pop the value (numtype_0.CONST c_2) from the stack.
+3. Assert: Due to validation, (numtype_0 is nt).
+4. Assert: Due to validation, a value of value type numtype_0 is on the top of the stack.
+5. Pop the value (numtype_0.CONST c_1) from the stack.
+6. Let c be $relop_(nt, relop, c_1, c_2).
+7. Push the value (I32.CONST c) to the stack.
 
 Step_pure/cvtop nt_2 nt_1 cvtop
-1. Assert: Due to validation, a value of value type nt_1 is on the top of the stack.
-2. Pop the value (nt_1.CONST c_1) from the stack.
-3. If (|$cvtop__(nt_1, nt_2, cvtop, c_1)| ≤ 0), then:
+1. Assert: Due to validation, a value of value type numtype_0 is on the top of the stack.
+2. Pop the value (numtype_0.CONST c_1) from the stack.
+3. Assert: Due to validation, (numtype_0 is nt_1).
+4. If (|$cvtop__(nt_1, nt_2, cvtop, c_1)| ≤ 0), then:
   a. Trap.
-4. Let c be an element of $cvtop__(nt_1, nt_2, cvtop, c_1).
-5. Push the value (nt_2.CONST c) to the stack.
+5. Let c be an element of $cvtop__(nt_1, nt_2, cvtop, c_1).
+6. Push the value (nt_2.CONST c) to the stack.
 
 Step_pure/ref.i31
 1. Assert: Due to validation, a value of value type I32 is on the top of the stack.
@@ -25276,8 +26219,13 @@ Step_pure/ref.eq
 2. Pop the value ref_2 from the stack.
 3. Assert: Due to validation, a value is on the top of the stack.
 4. Pop the value ref_1 from the stack.
-5. If (ref_1 is of the case REF.NULL and ref_2 is of the case REF.NULL), then:
-  a. Push the value (I32.CONST 1) to the stack.
+5. If ref_1 is of the case REF.NULL, then:
+  a. If ref_2 is of the case REF.NULL, then:
+    1) Push the value (I32.CONST 1) to the stack.
+  b. Else if (ref_1 is ref_2), then:
+    1) Push the value (I32.CONST 1) to the stack.
+  c. Else:
+    1) Push the value (I32.CONST 0) to the stack.
 6. Else if (ref_1 is ref_2), then:
   a. Push the value (I32.CONST 1) to the stack.
 7. Else:
@@ -25426,9 +26374,9 @@ Step_pure/vshuffle (Pnn X M) i*
 9. Push the value (V128.CONST c) to the stack.
 
 Step_pure/vsplat (Lnn X M)
-1. Let nt_0 be $lunpack(Lnn).
-2. Assert: Due to validation, a value of value type nt_0 is on the top of the stack.
-3. Pop the value (nt_0.CONST c_1) from the stack.
+1. Assert: Due to validation, a value of value type numtype_0 is on the top of the stack.
+2. Pop the value (numtype_0.CONST c_1) from the stack.
+3. Assert: Due to validation, (numtype_0 is $lunpack(Lnn)).
 4. Let c be $invlanes_((Lnn X M), $lpacknum_(Lnn, c_1)^M).
 5. Push the value (V128.CONST c) to the stack.
 
@@ -25449,9 +26397,9 @@ Step_pure/vextract_lane (lanetype_u0 X M) sx_u1? i
       b) Push the value (I32.CONST c_2) to the stack.
 
 Step_pure/vreplace_lane (Lnn X M) i
-1. Let nt_0 be $lunpack(Lnn).
-2. Assert: Due to validation, a value of value type nt_0 is on the top of the stack.
-3. Pop the value (nt_0.CONST c_2) from the stack.
+1. Assert: Due to validation, a value of value type numtype_0 is on the top of the stack.
+2. Pop the value (numtype_0.CONST c_2) from the stack.
+3. Assert: Due to validation, (numtype_0 is $lunpack(Lnn)).
 4. Assert: Due to validation, a value of value type V128 is on the top of the stack.
 5. Pop the value (V128.CONST c_1) from the stack.
 6. Let c be $invlanes_((Lnn X M), $lanes_((Lnn X M), c_1) with [i] replaced by $lpacknum_(Lnn, c_2)).
@@ -25550,22 +26498,22 @@ Step_read/br_on_cast l rt_1 rt_2
 2. Assert: Due to validation, a value is on the top of the stack.
 3. Pop the value ref from the stack.
 4. Let rt be $Ref_type(ref).
-5. If rt does not match $inst_reftype(f.MODULE, rt_2), then:
-  a. Push the value ref to the stack.
-6. Else:
-  a. Push the value ref to the stack.
-  b. Execute the instruction (BR l).
+5. Push the value ref to the stack.
+6. If rt does not match $inst_reftype(f.MODULE, rt_2), then:
+  a. Do nothing.
+7. Else:
+  a. Execute the instruction (BR l).
 
 Step_read/br_on_cast_fail l rt_1 rt_2
 1. Let f be the current frame.
 2. Assert: Due to validation, a value is on the top of the stack.
 3. Pop the value ref from the stack.
 4. Let rt be $Ref_type(ref).
-5. If rt matches $inst_reftype(f.MODULE, rt_2), then:
-  a. Push the value ref to the stack.
-6. Else:
-  a. Push the value ref to the stack.
-  b. Execute the instruction (BR l).
+5. Push the value ref to the stack.
+6. If rt matches $inst_reftype(f.MODULE, rt_2), then:
+  a. Do nothing.
+7. Else:
+  a. Execute the instruction (BR l).
 
 Step_read/call x
 1. Let z be the current state.
@@ -25611,26 +26559,195 @@ Step_read/return_call x
 Step_read/return_call_ref yy
 1. Let z be the current state.
 2. Pop all values val* from the top of the stack.
-3. If a label is now on the top of the stack, then:
-  a. Pop the current label from the stack.
-  b. Push the values val* to the stack.
-  c. Execute the instruction (RETURN_CALL_REF yy).
-4. Else if a frame is now on the top of the stack, then:
-  a. Pop the current frame from the stack.
-  b. Let instr_u1* ++ [instr_u0] be val*.
-  c. If instr_u0 is of the case REF.FUNC_ADDR, then:
+3. If the top of the stack is a LABEL_, then:
+  a. Push the values val* to the stack.
+  b. Pop all values val* from the top of the stack.
+  c. Pop the current label from the stack.
+  d. Push the values val* to the stack.
+  e. Execute the instruction (RETURN_CALL_REF yy).
+4. Else if the top of the stack is a FRAME_, then:
+  a. Push the values val* to the stack.
+  b. Assert: Due to validation, a value is on the top of the stack.
+  c. Pop the value instr_u0 from the stack.
+  d. Pop all values val* from the top of the stack.
+  e. If instr_u0 is of the case REF.NULL, then:
+    1) Pop the current frame from the stack.
+    2) Trap.
+  f. Assert: Due to validation, a value is on the top of the stack.
+  g. Pop the value instr_u0 from the stack.
+  h. If instr_u0 is of the case REF.FUNC_ADDR, then:
     1) Let (REF.FUNC_ADDR a) be instr_u0.
-    2) If (|instr_u1*| ≥ n), then:
-      a) Let val'* ++ val^n be instr_u1*.
-      b) If (a < |$funcinst(z)|), then:
-        1. Assert: Due to validation, $expanddt($funcinst(z)[a].TYPE) is of the case FUNC.
-        2. Let (FUNC functype_0) be $expanddt($funcinst(z)[a].TYPE).
-        3. Let (t_1^n -> t_2^m) be functype_0.
-        4. Push the values val^n to the stack.
-        5. Push the value (REF.FUNC_ADDR a) to the stack.
-        6. Execute the instruction (CALL_REF yy).
-  d. If (instr_u0 is of the case REF.NULL and the type of instr_u1 is val*), then:
-    1) Trap.
+    2) If (a < |$funcinst(z)|), then:
+      a) Assert: Due to validation, $expanddt($funcinst(z)[a].TYPE) is of the case FUNC.
+      b) Let (FUNC functype_0) be $expanddt($funcinst(z)[a].TYPE).
+      c) Let (t_1^n -> t_2^m) be functype_0.
+      d) Assert: Due to validation, there are at least n values on the top of the stack.
+      e) Pop the values val^n from the stack.
+      f) Pop all values val'* from the top of the stack.
+      g) Pop the current frame from the stack.
+      h) Push the values val^n to the stack.
+      i) Push the value (REF.FUNC_ADDR a) to the stack.
+      j) Execute the instruction (CALL_REF yy).
+
+Step_read/throw_ref
+1. Let z be the current state.
+2. Assert: Due to validation, a value is on the top of the stack.
+3. Pop the value instr_u0 from the stack.
+4. If instr_u0 is of the case REF.NULL, then:
+  a. Trap.
+5. Pop all values val* from the top of the stack.
+6. If (val* is not []), then:
+  a. If instr_u0 is of the case REF.EXN_ADDR, then:
+    1) Let (REF.EXN_ADDR a) be instr_u0.
+    2) Push the value (REF.EXN_ADDR a) to the stack.
+    3) Execute the instruction THROW_REF.
+7. Else:
+  a. Pop all values val* from the top of the stack.
+  b. If the top of the stack is a LABEL_, then:
+    1) Push the values val* to the stack.
+    2) If instr_u0 is of the case REF.EXN_ADDR, then:
+      a) Let (REF.EXN_ADDR a) be instr_u0.
+      b) Pop the current label from the stack.
+      c) Push the value (REF.EXN_ADDR a) to the stack.
+      d) Execute the instruction THROW_REF.
+  c. Else if the top of the stack is a FRAME_, then:
+    1) Push the values val* to the stack.
+    2) If instr_u0 is of the case REF.EXN_ADDR, then:
+      a) Let (REF.EXN_ADDR a) be instr_u0.
+      b) Pop the current frame from the stack.
+      c) Push the value (REF.EXN_ADDR a) to the stack.
+      d) Execute the instruction THROW_REF.
+  d. Else if the top of the stack is a HANDLER_, then:
+    1) Push the values val* to the stack.
+    2) Let (HANDLER_ n { catch_u1* }) be the current context.
+    3) If instr_u0 is of the case REF.EXN_ADDR, then:
+      a) Let (REF.EXN_ADDR a) be instr_u0.
+      b) If (catch_u1* is []), then:
+        1. Exit from HANDLER_.
+        2. Push the value (REF.EXN_ADDR a) to the stack.
+        3. Execute the instruction THROW_REF.
+      c) Else:
+        1. Let (REF.EXN_ADDR a) be instr_u0.
+        2. If (a ≥ |$exninst(z)|), then:
+          a. Let [catch_0] ++ catch'* be catch_u1*.
+          b. If catch_0 is of the case CATCH_ALL, then:
+            1) Let (CATCH_ALL l) be catch_0.
+            2) Exit from HANDLER_.
+            3) Execute the instruction (BR l).
+          c. Else:
+            1) Let (REF.EXN_ADDR a) be instr_u0.
+            2) Let [catch_0] ++ catch'* be catch_u1*.
+            3) If catch_0 is of the case CATCH_ALL_REF, then:
+              a) Let (CATCH_ALL_REF l) be catch_0.
+              b) Exit from HANDLER_.
+              c) Push the value (REF.EXN_ADDR a) to the stack.
+              d) Execute the instruction (BR l).
+            4) Else:
+              a) Let (REF.EXN_ADDR a) be instr_u0.
+              b) Let [catch] ++ catch'* be catch_u1*.
+              c) Exit from HANDLER_.
+              d) Let H be (HANDLER_ n { catch'* }).
+              e) Enter [THROW_REF, HANDLER_] with label H.
+                1. Push the value (REF.EXN_ADDR a) to the stack.
+        3. Else:
+          a. Let val* be $exninst(z)[a].FIELDS.
+          b. Let [catch_0] ++ catch'* be catch_u1*.
+          c. If catch_0 is of the case CATCH, then:
+            1) Let (CATCH x l) be catch_0.
+            2) If ((x < |$tagaddr(z)|) and ($exninst(z)[a].TAG is $tagaddr(z)[x])), then:
+              a) Exit from HANDLER_.
+              b) Push the values val* to the stack.
+              c) Execute the instruction (BR l).
+            3) Else:
+              a) Let [catch_0] ++ catch'* be catch_u1*.
+              b) Do nothing.
+              c) If catch_0 is not of the case CATCH_REF, then:
+                1. Do nothing.
+              d) Else:
+                1. Do nothing.
+              e) Do nothing.
+              f) If catch_0 is of the case CATCH_ALL, then:
+                1. Let (CATCH_ALL l) be catch_0.
+                2. Exit from HANDLER_.
+                3. Execute the instruction (BR l).
+              g) Else:
+                1. Let (REF.EXN_ADDR a) be instr_u0.
+                2. Let [catch_0] ++ catch'* be catch_u1*.
+                3. If catch_0 is of the case CATCH_ALL_REF, then:
+                  a. Let (CATCH_ALL_REF l) be catch_0.
+                  b. Exit from HANDLER_.
+                  c. Push the value (REF.EXN_ADDR a) to the stack.
+                  d. Execute the instruction (BR l).
+                4. Else:
+                  a. Let (REF.EXN_ADDR a) be instr_u0.
+                  b. Let [catch] ++ catch'* be catch_u1*.
+                  c. Exit from HANDLER_.
+                  d. Let H be (HANDLER_ n { catch'* }).
+                  e. Enter [THROW_REF, HANDLER_] with label H.
+                    1) Push the value (REF.EXN_ADDR a) to the stack.
+          d. Else:
+            1) Let (REF.EXN_ADDR a) be instr_u0.
+            2) Let val* be $exninst(z)[a].FIELDS.
+            3) Let [catch_0] ++ catch'* be catch_u1*.
+            4) If catch_0 is not of the case CATCH_REF, then:
+              a) Let [catch_0] ++ catch'* be catch_u1*.
+              b) If catch_0 is of the case CATCH_ALL, then:
+                1. Let (CATCH_ALL l) be catch_0.
+                2. Exit from HANDLER_.
+                3. Execute the instruction (BR l).
+              c) Else:
+                1. Let (REF.EXN_ADDR a) be instr_u0.
+                2. Let [catch_0] ++ catch'* be catch_u1*.
+                3. If catch_0 is of the case CATCH_ALL_REF, then:
+                  a. Let (CATCH_ALL_REF l) be catch_0.
+                  b. Exit from HANDLER_.
+                  c. Push the value (REF.EXN_ADDR a) to the stack.
+                  d. Execute the instruction (BR l).
+                4. Else:
+                  a. Let (REF.EXN_ADDR a) be instr_u0.
+                  b. Let [catch] ++ catch'* be catch_u1*.
+                  c. Exit from HANDLER_.
+                  d. Let H be (HANDLER_ n { catch'* }).
+                  e. Enter [THROW_REF, HANDLER_] with label H.
+                    1) Push the value (REF.EXN_ADDR a) to the stack.
+            5) Else:
+              a) Let (CATCH_REF x l) be catch_0.
+              b) If ((x < |$tagaddr(z)|) and ($exninst(z)[a].TAG is $tagaddr(z)[x])), then:
+                1. Exit from HANDLER_.
+                2. Push the values val* to the stack.
+                3. Push the value (REF.EXN_ADDR a) to the stack.
+                4. Execute the instruction (BR l).
+              c) Else:
+                1. Let [catch_0] ++ catch'* be catch_u1*.
+                2. If catch_0 is of the case CATCH_ALL, then:
+                  a. Let (CATCH_ALL l) be catch_0.
+                  b. Exit from HANDLER_.
+                  c. Execute the instruction (BR l).
+                3. Else:
+                  a. Let (REF.EXN_ADDR a) be instr_u0.
+                  b. Let [catch_0] ++ catch'* be catch_u1*.
+                  c. If catch_0 is of the case CATCH_ALL_REF, then:
+                    1) Let (CATCH_ALL_REF l) be catch_0.
+                    2) Exit from HANDLER_.
+                    3) Push the value (REF.EXN_ADDR a) to the stack.
+                    4) Execute the instruction (BR l).
+                  d. Else:
+                    1) Let (REF.EXN_ADDR a) be instr_u0.
+                    2) Let [catch] ++ catch'* be catch_u1*.
+                    3) Exit from HANDLER_.
+                    4) Let H be (HANDLER_ n { catch'* }).
+                    5) Enter [THROW_REF, HANDLER_] with label H.
+                      a) Push the value (REF.EXN_ADDR a) to the stack.
+
+Step_read/try_table bt catch* instr*
+1. Let z be the current state.
+2. Let (t_1^m -> t_2^n) be $blocktype_(z, bt).
+3. Assert: Due to validation, there are at least m values on the top of the stack.
+4. Pop the values val^m from the stack.
+5. Let H be (HANDLER_ n { catch* }).
+6. Enter [HANDLER_] with label H.
+  a. Let L be the label_n{[]}.
+  b. Enter val^m ++ instr* with label L.
 
 Step_read/ref.null $idx(x)
 1. Let z be the current state.
@@ -25772,11 +26889,13 @@ Step_read/array.fill x
   a. Trap.
 11. If instr_u0 is of the case REF.ARRAY_ADDR, then:
   a. Let (REF.ARRAY_ADDR a) be instr_u0.
-  b. If ((a < |$arrayinst(z)|) and ((i + n) > |$arrayinst(z)[a].FIELDS|)), then:
+  b. If (a ≥ |$arrayinst(z)|), then:
+    1) Do nothing.
+  c. Else if ((i + n) > |$arrayinst(z)[a].FIELDS|), then:
     1) Trap.
-  c. If (n is 0), then:
+  d. If (n is 0), then:
     1) Do nothing.
-  d. Else:
+  e. Else:
     1) Let (REF.ARRAY_ADDR a) be instr_u0.
     2) Push the value (REF.ARRAY_ADDR a) to the stack.
     3) Push the value (I32.CONST i) to the stack.
@@ -25795,64 +26914,68 @@ Step_read/array.copy x_1 x_2
 4. Assert: Due to validation, a value of value type I32 is on the top of the stack.
 5. Pop the value (I32.CONST i_2) from the stack.
 6. Assert: Due to validation, a value is on the top of the stack.
-7. Pop the value instr_u1 from the stack.
+7. Pop the value instr_u0 from the stack.
 8. Assert: Due to validation, a value of value type I32 is on the top of the stack.
 9. Pop the value (I32.CONST i_1) from the stack.
 10. Assert: Due to validation, a value is on the top of the stack.
-11. Pop the value instr_u0 from the stack.
-12. If (instr_u0 is of the case REF.NULL and the type of instr_u1 is ref), then:
+11. Pop the value instr_u1 from the stack.
+12. If (instr_u1 is of the case REF.NULL and the type of instr_u0 is ref), then:
   a. Trap.
-13. If (instr_u1 is of the case REF.NULL and the type of instr_u0 is ref), then:
+13. If (instr_u0 is of the case REF.NULL and the type of instr_u1 is ref), then:
   a. Trap.
-14. If instr_u0 is of the case REF.ARRAY_ADDR, then:
-  a. Let (REF.ARRAY_ADDR a_1) be instr_u0.
-  b. If instr_u1 is of the case REF.ARRAY_ADDR, then:
+14. If instr_u1 is of the case REF.ARRAY_ADDR, then:
+  a. Let (REF.ARRAY_ADDR a_1) be instr_u1.
+  b. If instr_u0 is not of the case REF.ARRAY_ADDR, then:
+    1) Do nothing.
+  c. Else:
     1) If ((a_1 < |$arrayinst(z)|) and ((i_1 + n) > |$arrayinst(z)[a_1].FIELDS|)), then:
       a) Trap.
-    2) Let (REF.ARRAY_ADDR a_2) be instr_u1.
-    3) If ((a_2 < |$arrayinst(z)|) and ((i_2 + n) > |$arrayinst(z)[a_2].FIELDS|)), then:
+    2) Let (REF.ARRAY_ADDR a_2) be instr_u0.
+    3) If (a_2 ≥ |$arrayinst(z)|), then:
+      a) Do nothing.
+    4) Else if ((i_2 + n) > |$arrayinst(z)[a_2].FIELDS|), then:
       a) Trap.
-  c. If (instr_u1 is of the case REF.ARRAY_ADDR and (n is 0)), then:
+  d. If (n is not 0), then:
+    1) Let (REF.ARRAY_ADDR a_1) be instr_u1.
+    2) If (i_1 > i_2), then:
+      a) If instr_u0 is of the case REF.ARRAY_ADDR, then:
+        1. Let (REF.ARRAY_ADDR a_2) be instr_u0.
+        2. Assert: Due to validation, $expanddt($type(z, x_2)) is of the case ARRAY.
+        3. Let (ARRAY arraytype_0) be $expanddt($type(z, x_2)).
+        4. Let (mut, zt_2) be arraytype_0.
+        5. Let sx? be $sx(zt_2).
+        6. Push the value (REF.ARRAY_ADDR a_1) to the stack.
+        7. Push the value (I32.CONST ((i_1 + n) - 1)) to the stack.
+        8. Push the value (REF.ARRAY_ADDR a_2) to the stack.
+        9. Push the value (I32.CONST ((i_2 + n) - 1)) to the stack.
+        10. Execute the instruction (ARRAY.GET sx? x_2).
+        11. Execute the instruction (ARRAY.SET x_1).
+        12. Push the value (REF.ARRAY_ADDR a_1) to the stack.
+        13. Push the value (I32.CONST i_1) to the stack.
+        14. Push the value (REF.ARRAY_ADDR a_2) to the stack.
+        15. Push the value (I32.CONST i_2) to the stack.
+        16. Push the value (I32.CONST (n - 1)) to the stack.
+        17. Execute the instruction (ARRAY.COPY x_1 x_2).
+    3) Else if instr_u0 is of the case REF.ARRAY_ADDR, then:
+      a) Let (REF.ARRAY_ADDR a_2) be instr_u0.
+      b) Assert: Due to validation, $expanddt($type(z, x_2)) is of the case ARRAY.
+      c) Let (ARRAY arraytype_0) be $expanddt($type(z, x_2)).
+      d) Let (mut, zt_2) be arraytype_0.
+      e) Let sx? be $sx(zt_2).
+      f) Push the value (REF.ARRAY_ADDR a_1) to the stack.
+      g) Push the value (I32.CONST i_1) to the stack.
+      h) Push the value (REF.ARRAY_ADDR a_2) to the stack.
+      i) Push the value (I32.CONST i_2) to the stack.
+      j) Execute the instruction (ARRAY.GET sx? x_2).
+      k) Execute the instruction (ARRAY.SET x_1).
+      l) Push the value (REF.ARRAY_ADDR a_1) to the stack.
+      m) Push the value (I32.CONST (i_1 + 1)) to the stack.
+      n) Push the value (REF.ARRAY_ADDR a_2) to the stack.
+      o) Push the value (I32.CONST (i_2 + 1)) to the stack.
+      p) Push the value (I32.CONST (n - 1)) to the stack.
+      q) Execute the instruction (ARRAY.COPY x_1 x_2).
+  e. Else if instr_u0 is of the case REF.ARRAY_ADDR, then:
     1) Do nothing.
-  d. Else:
-    1) Let (REF.ARRAY_ADDR a_1) be instr_u0.
-    2) If instr_u1 is of the case REF.ARRAY_ADDR, then:
-      a) Let (REF.ARRAY_ADDR a_2) be instr_u1.
-      b) If ((i_1 ≤ i_2) and $expanddt($type(z, x_2)) is of the case ARRAY), then:
-        1. Let (ARRAY arraytype_0) be $expanddt($type(z, x_2)).
-        2. Let (mut, zt_2) be arraytype_0.
-        3. Let sx? be $sx(zt_2).
-        4. Push the value (REF.ARRAY_ADDR a_1) to the stack.
-        5. Push the value (I32.CONST i_1) to the stack.
-        6. Push the value (REF.ARRAY_ADDR a_2) to the stack.
-        7. Push the value (I32.CONST i_2) to the stack.
-        8. Execute the instruction (ARRAY.GET sx? x_2).
-        9. Execute the instruction (ARRAY.SET x_1).
-        10. Push the value (REF.ARRAY_ADDR a_1) to the stack.
-        11. Push the value (I32.CONST (i_1 + 1)) to the stack.
-        12. Push the value (REF.ARRAY_ADDR a_2) to the stack.
-        13. Push the value (I32.CONST (i_2 + 1)) to the stack.
-        14. Push the value (I32.CONST (n - 1)) to the stack.
-        15. Execute the instruction (ARRAY.COPY x_1 x_2).
-      c) Else:
-        1. Let (REF.ARRAY_ADDR a_1) be instr_u0.
-        2. Let (REF.ARRAY_ADDR a_2) be instr_u1.
-        3. If $expanddt($type(z, x_2)) is of the case ARRAY, then:
-          a. Let (ARRAY arraytype_0) be $expanddt($type(z, x_2)).
-          b. Let (mut, zt_2) be arraytype_0.
-          c. Let sx? be $sx(zt_2).
-          d. Push the value (REF.ARRAY_ADDR a_1) to the stack.
-          e. Push the value (I32.CONST ((i_1 + n) - 1)) to the stack.
-          f. Push the value (REF.ARRAY_ADDR a_2) to the stack.
-          g. Push the value (I32.CONST ((i_2 + n) - 1)) to the stack.
-          h. Execute the instruction (ARRAY.GET sx? x_2).
-          i. Execute the instruction (ARRAY.SET x_1).
-          j. Push the value (REF.ARRAY_ADDR a_1) to the stack.
-          k. Push the value (I32.CONST i_1) to the stack.
-          l. Push the value (REF.ARRAY_ADDR a_2) to the stack.
-          m. Push the value (I32.CONST i_2) to the stack.
-          n. Push the value (I32.CONST (n - 1)) to the stack.
-          o. Execute the instruction (ARRAY.COPY x_1 x_2).
 
 Step_read/array.init_elem x y
 1. Let z be the current state.
@@ -25904,28 +27027,30 @@ Step_read/array.init_data x y
   a. Let (REF.ARRAY_ADDR a) be instr_u0.
   b. If ((a < |$arrayinst(z)|) and ((i + n) > |$arrayinst(z)[a].FIELDS|)), then:
     1) Trap.
-  c. If $expanddt($type(z, x)) is of the case ARRAY, then:
+  c. If $expanddt($type(z, x)) is not of the case ARRAY, then:
+    1) Do nothing.
+  d. Else:
     1) Let (ARRAY arraytype_0) be $expanddt($type(z, x)).
     2) Let (mut, zt) be arraytype_0.
     3) If ((j + ((n · $zsize(zt)) / 8)) > |$data(z, y).BYTES|), then:
       a) Trap.
-  d. If (n is 0), then:
+  e. If (n is 0), then:
     1) Do nothing.
-  e. Else:
+  f. Else:
     1) Let (REF.ARRAY_ADDR a) be instr_u0.
-    2) Assert: Due to validation, $expanddt($type(z, x)) is of the case ARRAY.
-    3) Let (ARRAY arraytype_0) be $expanddt($type(z, x)).
-    4) Let (mut, zt) be arraytype_0.
-    5) Let c be $zbytes__1^-1(zt, $data(z, y).BYTES[j : ($zsize(zt) / 8)]).
-    6) Push the value (REF.ARRAY_ADDR a) to the stack.
-    7) Push the value (I32.CONST i) to the stack.
-    8) Push the value $const($cunpack(zt), $cunpacknum_(zt, c)) to the stack.
-    9) Execute the instruction (ARRAY.SET x).
-    10) Push the value (REF.ARRAY_ADDR a) to the stack.
-    11) Push the value (I32.CONST (i + 1)) to the stack.
-    12) Push the value (I32.CONST (j + ($zsize(zt) / 8))) to the stack.
-    13) Push the value (I32.CONST (n - 1)) to the stack.
-    14) Execute the instruction (ARRAY.INIT_DATA x y).
+    2) If $expanddt($type(z, x)) is of the case ARRAY, then:
+      a) Let (ARRAY arraytype_0) be $expanddt($type(z, x)).
+      b) Let (mut, zt) be arraytype_0.
+      c) Let c be $zbytes__1^-1(zt, $data(z, y).BYTES[j : ($zsize(zt) / 8)]).
+      d) Push the value (REF.ARRAY_ADDR a) to the stack.
+      e) Push the value (I32.CONST i) to the stack.
+      f) Push the value $const($cunpack(zt), $cunpacknum_(zt, c)) to the stack.
+      g) Execute the instruction (ARRAY.SET x).
+      h) Push the value (REF.ARRAY_ADDR a) to the stack.
+      i) Push the value (I32.CONST (i + 1)) to the stack.
+      j) Push the value (I32.CONST (j + ($zsize(zt) / 8))) to the stack.
+      k) Push the value (I32.CONST (n - 1)) to the stack.
+      l) Execute the instruction (ARRAY.INIT_DATA x y).
 
 Step_read/local.get x
 1. Let z be the current state.
@@ -26054,12 +27179,12 @@ Step_read/vload V128 vloadop__u0? x ao
 1. Let z be the current state.
 2. Assert: Due to validation, a value of value type I32 is on the top of the stack.
 3. Pop the value (I32.CONST i) from the stack.
-4. If vloadop__u0? is not defined, then:
-  a. If (((i + ao.OFFSET) + ($vsize(V128) / 8)) > |$mem(z, x).BYTES|), then:
-    1) Trap.
-  b. Let c be $vbytes__1^-1(V128, $mem(z, x).BYTES[(i + ao.OFFSET) : ($vsize(V128) / 8)]).
-  c. Push the value (V128.CONST c) to the stack.
-5. Else:
+4. If ((((i + ao.OFFSET) + ($vsize(V128) / 8)) > |$mem(z, x).BYTES|) and vloadop__u0? is not defined), then:
+  a. Trap.
+5. If vloadop__u0? is not defined, then:
+  a. Let c be $vbytes__1^-1(V128, $mem(z, x).BYTES[(i + ao.OFFSET) : ($vsize(V128) / 8)]).
+  b. Push the value (V128.CONST c) to the stack.
+6. Else:
   a. Let ?(vloadop__0) be vloadop__u0?.
   b. If vloadop__0 is of the case SHAPE, then:
     1) Let (SHAPE M X K sx) be vloadop__0.
@@ -26184,8 +27309,20 @@ Step_read/memory.init x y
   f. Push the value (I32.CONST (n - 1)) to the stack.
   g. Execute the instruction (MEMORY.INIT x y).
 
-Step/ctxt
-1. YetI: TODO: It is likely that the value stack of two rules are different.
+Step/throw x
+1. Let z be the current state.
+2. Assert: Due to validation, (x < |$tagaddr(z)|).
+3. Let a be |$exninst(z)|.
+4. Assert: Due to validation, $expanddt($tag(z, x).TYPE) is of the case FUNC.
+5. Let (FUNC functype_0) be $expanddt($tag(z, x).TYPE).
+6. Let (t^n -> valtype_1) be functype_0.
+7. Assert: Due to validation, (valtype_1 is []).
+8. Assert: Due to validation, there are at least n values on the top of the stack.
+9. Pop the values val^n from the stack.
+10. Let exn be { TAG: $tagaddr(z)[x]; FIELDS: val^n; }.
+11. Perform $add_exninst(z, [exn]).
+12. Push the value (REF.EXN_ADDR a) to the stack.
+13. Execute the instruction THROW_REF.
 
 Step/struct.new x
 1. Let z be the current state.
@@ -26285,25 +27422,26 @@ Step/elem.drop x
 1. Let z be the current state.
 2. Perform $with_elem(z, x, []).
 
-Step/store nt sz_u1? x ao
+Step/store nt sz_u0? x ao
 1. Let z be the current state.
-2. Assert: Due to validation, a value of value type numtype_u0 is on the top of the stack.
-3. Pop the value (numtype_u0.CONST c) from the stack.
+2. Assert: Due to validation, a value of value type numtype_u1 is on the top of the stack.
+3. Pop the value (numtype_u1.CONST c) from the stack.
 4. Assert: Due to validation, a value of value type I32 is on the top of the stack.
 5. Pop the value (I32.CONST i) from the stack.
-6. If ((numtype_u0 is nt) and sz_u1? is not defined), then:
-  a. If (((i + ao.OFFSET) + ($size(nt) / 8)) > |$mem(z, x).BYTES|), then:
+6. If (numtype_u1 is nt), then:
+  a. If ((((i + ao.OFFSET) + ($size(nt) / 8)) > |$mem(z, x).BYTES|) and sz_u0? is not defined), then:
     1) Trap.
-  b. Let b* be $nbytes_(nt, c).
-  c. Perform $with_mem(z, x, (i + ao.OFFSET), ($size(nt) / 8), b*).
-7. If the type of numtype_u0 is Inn, then:
-  a. If sz_u1? is defined, then:
-    1) Let ?(n) be sz_u1?.
+  b. If sz_u0? is not defined, then:
+    1) Let b* be $nbytes_(nt, c).
+    2) Perform $with_mem(z, x, (i + ao.OFFSET), ($size(nt) / 8), b*).
+7. If the type of numtype_u1 is Inn, then:
+  a. If sz_u0? is defined, then:
+    1) Let ?(n) be sz_u0?.
     2) If (((i + ao.OFFSET) + (n / 8)) > |$mem(z, x).BYTES|), then:
       a) Trap.
-  b. Let Inn be numtype_u0.
-  c. If sz_u1? is defined, then:
-    1) Let ?(n) be sz_u1?.
+  b. Let Inn be numtype_u1.
+  c. If sz_u0? is defined, then:
+    1) Let ?(n) be sz_u0?.
     2) Let b* be $ibytes_(n, $wrap__($size(Inn), n, c)).
     3) Perform $with_mem(z, x, (i + ao.OFFSET), (n / 8), b*).
 
diff --git a/spectec/test-prose/doc/exec/runtime-in.rst b/spectec/test-prose/doc/exec/runtime-in.rst
index 8c88620bc9..7d831483fe 100644
--- a/spectec/test-prose/doc/exec/runtime-in.rst
+++ b/spectec/test-prose/doc/exec/runtime-in.rst
@@ -179,44 +179,44 @@ Export Instances
 
 $${syntax: exportinst}
 
-.. _syntax-externval:
+.. _syntax-externaddr:
 
-External Values
-~~~~~~~~~~~~~~~
+External Addresses
+~~~~~~~~~~~~~~~~~~
 
-$${syntax: externval}
+$${syntax: externaddr}
 
-.. _def-funcsxv:
+.. _def-funcsxa:
 
-$${definition-prose: funcsxv}
+$${definition-prose: funcsxa}
 
 \
 
-$${definition: funcsxv}
+$${definition: funcsxa}
 
-.. _def-tablesxv:
+.. _def-tablesxa:
 
-$${definition-prose: tablesxv}
+$${definition-prose: tablesxa}
 
 \
 
-$${definition: tablesxv}
+$${definition: tablesxa}
 
-.. _def-memsxv:
+.. _def-memsxa:
 
-$${definition-prose: memsxv}
+$${definition-prose: memsxa}
 
 \
 
-$${definition: memsxv}
+$${definition: memsxa}
 
-.. _def-globalsxv:
+.. _def-globalsxa:
 
-$${definition-prose: globalsxv}
+$${definition-prose: globalsxa}
 
 \
 
-$${definition: globalsxv}
+$${definition: globalsxa}
 
 .. _syntax-structinst:
 .. _syntax-arrayinst:
diff --git a/spectec/test-splice/TEST.md b/spectec/test-splice/TEST.md
index 953579305b..d08b78bf58 100644
--- a/spectec/test-splice/TEST.md
+++ b/spectec/test-splice/TEST.md
@@ -9,10 +9,10 @@ $ (../src/exe-watsup/main.exe ../spec/wasm-3.0/*.watsup -l --splice-latex -p spe
 == IL Validation after pass sideconditions...
 == Translating to AL...
 == Prose Generation...
-../spec/wasm-3.0/6-typing.watsup:194.10-194.32: if_expr_to_instrs: Yet `$before(typeuse, x, i)`
-../spec/wasm-3.0/6-typing.watsup:817.9-817.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
-../spec/wasm-3.0/6-typing.watsup:851.9-851.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
-../spec/wasm-3.0/6-typing.watsup:1309.9-1309.30: if_expr_to_instrs: Yet `$disjoint_(syntax name, nm*{nm : name})`
+../spec/wasm-3.0/6-typing.watsup:195.10-195.32: if_expr_to_instrs: Yet `$before(typeuse, x, i)`
+../spec/wasm-3.0/6-typing.watsup:876.9-876.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
+../spec/wasm-3.0/6-typing.watsup:910.9-910.55: if_expr_to_instrs: Yet `(($unpack(zt) = (numtype : numtype <: valtype)) \/ ($unpack(zt) = (vectype : vectype <: valtype)))`
+../spec/wasm-3.0/6-typing.watsup:1378.9-1378.30: if_expr_to_instrs: Yet `$disjoint_(syntax name, nm*{nm : name})`
 == Splicing...
 \documentclass[a4paper]{scrartcl}
 
@@ -52,7 +52,7 @@ $$
 \mbox{(table type)} & {\mathit{tabletype}} &::=& {\mathit{limits}}~{\mathit{reftype}} \\
 \mbox{(memory type)} & {\mathit{memtype}} &::=& {\mathit{limits}}~\mathsf{page} \\[0.8ex]
 {} \\[-2ex]
-\mbox{(external type)} & {\mathit{externtype}} &::=& \mathsf{func}~{\mathit{typeuse}} ~|~ \mathsf{global}~{\mathit{globaltype}} ~|~ \mathsf{table}~{\mathit{tabletype}} ~|~ \mathsf{mem}~{\mathit{memtype}} \\
+\mbox{(external type)} & {\mathit{externtype}} &::=& \mathsf{func}~{\mathit{typeuse}} ~|~ \mathsf{global}~{\mathit{globaltype}} ~|~ \mathsf{table}~{\mathit{tabletype}} ~|~ \mathsf{mem}~{\mathit{memtype}} ~|~ \mathsf{tag}~{\mathit{typeuse}} \\
 \end{array}
 $$
 
@@ -318,6 +318,7 @@ warning: syntax `blocktype` was never spliced
 warning: syntax `byte` was never spliced
 warning: syntax `callframe` was never spliced
 warning: syntax `castop` was never spliced
+warning: syntax `catch` was never spliced
 warning: syntax `char` was never spliced
 warning: syntax `code` was never spliced
 warning: syntax `comptype` was never spliced
@@ -342,10 +343,12 @@ warning: syntax `elemidx` was never spliced
 warning: syntax `eleminst` was never spliced
 warning: syntax `elemmode` was never spliced
 warning: syntax `elemtype` was never spliced
+warning: syntax `exnaddr` was never spliced
+warning: syntax `exninst` was never spliced
 warning: syntax `export` was never spliced
 warning: syntax `exportinst` was never spliced
+warning: syntax `externaddr` was never spliced
 warning: syntax `externidx` was never spliced
-warning: syntax `externval` was never spliced
 warning: syntax `f32` was never spliced
 warning: syntax `f64` was never spliced
 warning: syntax `fN` was never spliced
@@ -378,6 +381,7 @@ warning: syntax `init` was never spliced
 warning: syntax `instr/parametric` was never spliced
 warning: syntax `instr/br` was never spliced
 warning: syntax `instr/call` was never spliced
+warning: syntax `instr/exn` was never spliced
 warning: syntax `instr/vec` was never spliced
 warning: syntax `instr/ref` was never spliced
 warning: syntax `instr/func` was never spliced
@@ -468,6 +472,11 @@ warning: syntax `table` was never spliced
 warning: syntax `tableaddr` was never spliced
 warning: syntax `tableidx` was never spliced
 warning: syntax `tableinst` was never spliced
+warning: syntax `tag` was never spliced
+warning: syntax `tagaddr` was never spliced
+warning: syntax `tagidx` was never spliced
+warning: syntax `taginst` was never spliced
+warning: syntax `tagtype` was never spliced
 warning: syntax `testop_` was never spliced
 warning: syntax `type` was never spliced
 warning: syntax `typeidx` was never spliced
@@ -514,6 +523,7 @@ warning: grammar `Babsheaptype` was never spliced
 warning: grammar `Bblocktype` was never spliced
 warning: grammar `Bbyte` was never spliced
 warning: grammar `Bcastop` was never spliced
+warning: grammar `Bcatch` was never spliced
 warning: grammar `Bcode` was never spliced
 warning: grammar `Bcodesec` was never spliced
 warning: grammar `Bcomptype` was never spliced
@@ -662,6 +672,10 @@ warning: grammar `Btable` was never spliced
 warning: grammar `Btableidx` was never spliced
 warning: grammar `Btablesec` was never spliced
 warning: grammar `Btabletype` was never spliced
+warning: grammar `Btag` was never spliced
+warning: grammar `Btagidx` was never spliced
+warning: grammar `Btagsec` was never spliced
+warning: grammar `Btagtype` was never spliced
 warning: grammar `Btype` was never spliced
 warning: grammar `Btypeidx` was never spliced
 warning: grammar `Btypesec` was never spliced
@@ -675,6 +689,10 @@ warning: grammar `Bvectype` was never spliced
 warning: grammar `Bversion` was never spliced
 warning: rule `Blocktype_ok/valtype` was never spliced
 warning: rule `Blocktype_ok/typeidx` was never spliced
+warning: rule `Catch_ok/catch` was never spliced
+warning: rule `Catch_ok/catch_ref` was never spliced
+warning: rule `Catch_ok/catch_all` was never spliced
+warning: rule `Catch_ok/catch_all_ref` was never spliced
 warning: rule `Comptype_ok/struct` was never spliced
 warning: rule `Comptype_ok/array` was never spliced
 warning: rule `Comptype_ok/func` was never spliced
@@ -697,23 +715,27 @@ warning: rule `Export_ok` was never spliced
 warning: rule `Expr_const` was never spliced
 warning: rule `Expr_ok` was never spliced
 warning: rule `Expr_ok_const` was never spliced
+warning: rule `Externaddr_type/func` was never spliced
+warning: rule `Externaddr_type/global` was never spliced
+warning: rule `Externaddr_type/table` was never spliced
+warning: rule `Externaddr_type/mem` was never spliced
+warning: rule `Externaddr_type/tag` was never spliced
+warning: rule `Externaddr_type/sub` was never spliced
 warning: rule `Externidx_ok/func` was never spliced
 warning: rule `Externidx_ok/global` was never spliced
 warning: rule `Externidx_ok/table` was never spliced
 warning: rule `Externidx_ok/mem` was never spliced
+warning: rule `Externidx_ok/tag` was never spliced
 warning: rule `Externtype_ok/func` was never spliced
 warning: rule `Externtype_ok/global` was never spliced
 warning: rule `Externtype_ok/table` was never spliced
 warning: rule `Externtype_ok/mem` was never spliced
+warning: rule `Externtype_ok/tag` was never spliced
 warning: rule `Externtype_sub/func` was never spliced
 warning: rule `Externtype_sub/global` was never spliced
 warning: rule `Externtype_sub/table` was never spliced
 warning: rule `Externtype_sub/mem` was never spliced
-warning: rule `Externval_type/func` was never spliced
-warning: rule `Externval_type/global` was never spliced
-warning: rule `Externval_type/table` was never spliced
-warning: rule `Externval_type/mem` was never spliced
-warning: rule `Externval_type/sub` was never spliced
+warning: rule `Externtype_sub/tag` was never spliced
 warning: rule `Fieldtype_ok` was never spliced
 warning: rule `Fieldtype_sub/const` was never spliced
 warning: rule `Fieldtype_sub/var` was never spliced
@@ -777,6 +799,9 @@ warning: rule `Instr_ok/return` was never spliced
 warning: rule `Instr_ok/return_call` was never spliced
 warning: rule `Instr_ok/return_call_ref` was never spliced
 warning: rule `Instr_ok/return_call_indirect` was never spliced
+warning: rule `Instr_ok/throw` was never spliced
+warning: rule `Instr_ok/throw_ref` was never spliced
+warning: rule `Instr_ok/try_table` was never spliced
 warning: rule `Instr_ok/const` was never spliced
 warning: rule `Instr_ok/unop` was never spliced
 warning: rule `Instr_ok/binop` was never spliced
@@ -894,6 +919,7 @@ warning: rule `Ref_type/i31` was never spliced
 warning: rule `Ref_type/struct` was never spliced
 warning: rule `Ref_type/array` was never spliced
 warning: rule `Ref_type/func` was never spliced
+warning: rule `Ref_type/exn` was never spliced
 warning: rule `Ref_type/host` was never spliced
 warning: rule `Ref_type/extern` was never spliced
 warning: rule `Ref_type/sub` was never spliced
@@ -903,6 +929,7 @@ warning: rule `Reftype_sub/null` was never spliced
 warning: rule `Resulttype_ok` was never spliced
 warning: rule `Resulttype_sub` was never spliced
 warning: rule `Start_ok` was never spliced
+warning: rule `Step/throw` was never spliced
 warning: rule `Step/ctxt-label` was never spliced
 warning: rule `Step/ctxt-frame` was never spliced
 warning: rule `Step/struct.new` was never spliced
@@ -938,8 +965,9 @@ warning: rule `Step_pure/select-false` was never spliced
 warning: rule `Step_pure/if-true` was spliced more than once
 warning: rule `Step_pure/if-false` was spliced more than once
 warning: rule `Step_pure/label-vals` was never spliced
-warning: rule `Step_pure/br-zero` was never spliced
-warning: rule `Step_pure/br-succ` was never spliced
+warning: rule `Step_pure/br-label-zero` was never spliced
+warning: rule `Step_pure/br-label-succ` was never spliced
+warning: rule `Step_pure/br-handler` was never spliced
 warning: rule `Step_pure/br_if-true` was never spliced
 warning: rule `Step_pure/br_if-false` was never spliced
 warning: rule `Step_pure/br_table-lt` was never spliced
@@ -953,6 +981,8 @@ warning: rule `Step_pure/return_call_indirect` was never spliced
 warning: rule `Step_pure/frame-vals` was never spliced
 warning: rule `Step_pure/return-frame` was never spliced
 warning: rule `Step_pure/return-label` was never spliced
+warning: rule `Step_pure/return-handler` was never spliced
+warning: rule `Step_pure/handler-vals` was never spliced
 warning: rule `Step_pure/trap-vals` was never spliced
 warning: rule `Step_pure/trap-label` was never spliced
 warning: rule `Step_pure/trap-frame` was never spliced
@@ -1016,6 +1046,17 @@ warning: rule `Step_read/return_call` was never spliced
 warning: rule `Step_read/return_call_ref-label` was never spliced
 warning: rule `Step_read/return_call_ref-frame-null` was never spliced
 warning: rule `Step_read/return_call_ref-frame-addr` was never spliced
+warning: rule `Step_read/throw_ref-null` was never spliced
+warning: rule `Step_read/throw_ref-vals` was never spliced
+warning: rule `Step_read/throw_ref-label` was never spliced
+warning: rule `Step_read/throw_ref-frame` was never spliced
+warning: rule `Step_read/throw_ref-handler-empty` was never spliced
+warning: rule `Step_read/throw_ref-handler-catch` was never spliced
+warning: rule `Step_read/throw_ref-handler-catch_ref` was never spliced
+warning: rule `Step_read/throw_ref-handler-catch_all` was never spliced
+warning: rule `Step_read/throw_ref-handler-catch_all_ref` was never spliced
+warning: rule `Step_read/throw_ref-handler-next` was never spliced
+warning: rule `Step_read/try_table` was never spliced
 warning: rule `Step_read/ref.null-idx` was never spliced
 warning: rule `Step_read/ref.func` was never spliced
 warning: rule `Step_read/ref.test-true` was never spliced
@@ -1107,6 +1148,9 @@ warning: rule `Subtype_ok2` was never spliced
 warning: rule `Table_ok` was never spliced
 warning: rule `Tabletype_ok` was never spliced
 warning: rule `Tabletype_sub` was never spliced
+warning: rule `Tag_ok` was never spliced
+warning: rule `Tagtype_ok` was never spliced
+warning: rule `Tagtype_sub` was never spliced
 warning: rule `Type_ok` was never spliced
 warning: rule `Types_ok/empty` was never spliced
 warning: rule `Types_ok/cons` was never spliced
@@ -1141,6 +1185,7 @@ warning: definition `NULLFUNCREF` was never spliced
 warning: definition `NULLREF` was never spliced
 warning: definition `STRUCTREF` was never spliced
 warning: definition `add_arrayinst` was never spliced
+warning: definition `add_exninst` was never spliced
 warning: definition `add_structinst` was never spliced
 warning: definition `allocX` was never spliced
 warning: definition `allocXs` was never spliced
@@ -1159,6 +1204,8 @@ warning: definition `allocmems` was never spliced
 warning: definition `allocmodule` was never spliced
 warning: definition `alloctable` was never spliced
 warning: definition `alloctables` was never spliced
+warning: definition `alloctag` was never spliced
+warning: definition `alloctags` was never spliced
 warning: definition `alloctypes` was never spliced
 warning: definition `arrayinst` was never spliced
 warning: definition `before` was never spliced
@@ -1189,6 +1236,7 @@ warning: definition `disjoint_` was never spliced
 warning: definition `elem` was never spliced
 warning: definition `eleminst` was never spliced
 warning: definition `evalglobals` was never spliced
+warning: definition `exninst` was never spliced
 warning: definition `expanddt` was never spliced
 warning: definition `expon` was never spliced
 warning: definition `extend__` was never spliced
@@ -1268,6 +1316,7 @@ warning: definition `free_subtype` was never spliced
 warning: definition `free_table` was never spliced
 warning: definition `free_tableidx` was never spliced
 warning: definition `free_tabletype` was never spliced
+warning: definition `free_tag` was never spliced
 warning: definition `free_type` was never spliced
 warning: definition `free_typeidx` was never spliced
 warning: definition `free_typeuse` was never spliced
@@ -1278,14 +1327,14 @@ warning: definition `fsub_` was never spliced
 warning: definition `ftrunc_` was never spliced
 warning: definition `funcidx_module` was never spliced
 warning: definition `funcidx_nonfuncs` was never spliced
+warning: definition `funcsxa` was never spliced
 warning: definition `funcsxt` was never spliced
-warning: definition `funcsxv` was never spliced
 warning: definition `funcsxx` was never spliced
 warning: definition `fzero` was never spliced
 warning: definition `global` was never spliced
 warning: definition `globalinst` was never spliced
+warning: definition `globalsxa` was never spliced
 warning: definition `globalsxt` was never spliced
-warning: definition `globalsxv` was never spliced
 warning: definition `globalsxx` was never spliced
 warning: definition `growmem` was never spliced
 warning: definition `growtable` was never spliced
@@ -1350,8 +1399,8 @@ warning: definition `lunpacknum_` was never spliced
 warning: definition `mem` was never spliced
 warning: definition `memarg0` was never spliced
 warning: definition `meminst` was never spliced
+warning: definition `memsxa` was never spliced
 warning: definition `memsxt` was never spliced
-warning: definition `memsxv` was never spliced
 warning: definition `memsxx` was never spliced
 warning: definition `min` was never spliced
 warning: definition `moduleinst` was never spliced
@@ -1412,9 +1461,15 @@ warning: definition `subst_vectype` was never spliced
 warning: definition `sum` was never spliced
 warning: definition `sx` was never spliced
 warning: definition `tableinst` was never spliced
+warning: definition `tablesxa` was never spliced
 warning: definition `tablesxt` was never spliced
-warning: definition `tablesxv` was never spliced
 warning: definition `tablesxx` was never spliced
+warning: definition `tag` was never spliced
+warning: definition `tagaddr` was never spliced
+warning: definition `taginst` was never spliced
+warning: definition `tagsxa` was never spliced
+warning: definition `tagsxt` was never spliced
+warning: definition `tagsxx` was never spliced
 warning: definition `testop_` was never spliced
 warning: definition `trunc__` was never spliced
 warning: definition `trunc_sat__` was never spliced
@@ -1457,6 +1512,7 @@ warning: definition `zbytes_` was never spliced
 warning: definition `zero` was never spliced
 warning: definition `zsize` was never spliced
 warning: rule prose `Blocktype_ok` was never spliced
+warning: rule prose `Catch_ok` was never spliced
 warning: rule prose `Comptype_ok` was never spliced
 warning: rule prose `Comptype_sub` was never spliced
 warning: rule prose `Data_ok` was never spliced
@@ -1557,6 +1613,9 @@ warning: rule prose `Instr_ok/table.init` was never spliced
 warning: rule prose `Instr_ok/table.set` was never spliced
 warning: rule prose `Instr_ok/table.size` was never spliced
 warning: rule prose `Instr_ok/testop` was never spliced
+warning: rule prose `Instr_ok/throw` was never spliced
+warning: rule prose `Instr_ok/throw_ref` was never spliced
+warning: rule prose `Instr_ok/try_table` was never spliced
 warning: rule prose `Instr_ok/unop` was never spliced
 warning: rule prose `Instr_ok/unreachable` was never spliced
 warning: rule prose `Instr_ok/vbinop` was never spliced
@@ -1607,7 +1666,6 @@ warning: rule prose `Resulttype_sub` was never spliced
 warning: rule prose `Start_ok` was never spliced
 warning: rule prose `Step/array.new_fixed` was never spliced
 warning: rule prose `Step/array.set` was never spliced
-warning: rule prose `Step/ctxt` was never spliced
 warning: rule prose `Step/data.drop` was never spliced
 warning: rule prose `Step/elem.drop` was never spliced
 warning: rule prose `Step/global.set` was never spliced
@@ -1618,6 +1676,7 @@ warning: rule prose `Step/struct.new` was never spliced
 warning: rule prose `Step/struct.set` was never spliced
 warning: rule prose `Step/table.grow` was never spliced
 warning: rule prose `Step/table.set` was never spliced
+warning: rule prose `Step/throw` was never spliced
 warning: rule prose `Step/vstore` was never spliced
 warning: rule prose `Step/vstore_lane` was never spliced
 warning: rule prose `Step_pure/any.convert_extern` was never spliced
@@ -1633,6 +1692,7 @@ warning: rule prose `Step_pure/cvtop` was never spliced
 warning: rule prose `Step_pure/drop` was never spliced
 warning: rule prose `Step_pure/extern.convert_any` was never spliced
 warning: rule prose `Step_pure/frame` was never spliced
+warning: rule prose `Step_pure/handler` was never spliced
 warning: rule prose `Step_pure/i31.get` was never spliced
 warning: rule prose `Step_pure/if` was never spliced
 warning: rule prose `Step_pure/label` was never spliced
@@ -1647,7 +1707,6 @@ warning: rule prose `Step_pure/return` was never spliced
 warning: rule prose `Step_pure/return_call_indirect` was never spliced
 warning: rule prose `Step_pure/select` was never spliced
 warning: rule prose `Step_pure/testop` was never spliced
-warning: rule prose `Step_pure/trap` was never spliced
 warning: rule prose `Step_pure/unop` was never spliced
 warning: rule prose `Step_pure/unreachable` was never spliced
 warning: rule prose `Step_pure/vbinop` was never spliced
@@ -1704,6 +1763,8 @@ warning: rule prose `Step_read/table.fill` was never spliced
 warning: rule prose `Step_read/table.get` was never spliced
 warning: rule prose `Step_read/table.init` was never spliced
 warning: rule prose `Step_read/table.size` was never spliced
+warning: rule prose `Step_read/throw_ref` was never spliced
+warning: rule prose `Step_read/try_table` was never spliced
 warning: rule prose `Step_read/vload` was never spliced
 warning: rule prose `Step_read/vload_lane` was never spliced
 warning: rule prose `Storagetype_ok` was never spliced
@@ -1713,6 +1774,9 @@ warning: rule prose `Subtype_ok2` was never spliced
 warning: rule prose `Table_ok` was never spliced
 warning: rule prose `Tabletype_ok` was never spliced
 warning: rule prose `Tabletype_sub` was never spliced
+warning: rule prose `Tag_ok` was never spliced
+warning: rule prose `Tagtype_ok` was never spliced
+warning: rule prose `Tagtype_sub` was never spliced
 warning: rule prose `Type_ok` was never spliced
 warning: rule prose `Types_ok` was never spliced
 warning: rule prose `Valtype_ok` was never spliced
@@ -1736,6 +1800,7 @@ warning: definition prose `NULLFUNCREF` was never spliced
 warning: definition prose `NULLREF` was never spliced
 warning: definition prose `STRUCTREF` was never spliced
 warning: definition prose `add_arrayinst` was never spliced
+warning: definition prose `add_exninst` was never spliced
 warning: definition prose `add_structinst` was never spliced
 warning: definition prose `allocXs` was never spliced
 warning: definition prose `allocdata` was never spliced
@@ -1753,6 +1818,8 @@ warning: definition prose `allocmems` was never spliced
 warning: definition prose `allocmodule` was never spliced
 warning: definition prose `alloctable` was never spliced
 warning: definition prose `alloctables` was never spliced
+warning: definition prose `alloctag` was never spliced
+warning: definition prose `alloctags` was never spliced
 warning: definition prose `alloctypes` was never spliced
 warning: definition prose `arrayinst` was never spliced
 warning: definition prose `binop_` was never spliced
@@ -1777,6 +1844,7 @@ warning: definition prose `elem` was never spliced
 warning: definition prose `eleminst` was never spliced
 warning: definition prose `eval_expr` was never spliced
 warning: definition prose `evalglobals` was never spliced
+warning: definition prose `exninst` was never spliced
 warning: definition prose `expanddt` was never spliced
 warning: definition prose `expon` was never spliced
 warning: definition prose `fone` was never spliced
@@ -1834,6 +1902,7 @@ warning: definition prose `free_subtype` was never spliced
 warning: definition prose `free_table` was never spliced
 warning: definition prose `free_tableidx` was never spliced
 warning: definition prose `free_tabletype` was never spliced
+warning: definition prose `free_tag` was never spliced
 warning: definition prose `free_type` was never spliced
 warning: definition prose `free_typeidx` was never spliced
 warning: definition prose `free_typeuse` was never spliced
@@ -1842,14 +1911,14 @@ warning: definition prose `free_vectype` was never spliced
 warning: definition prose `func` was never spliced
 warning: definition prose `funcidx_module` was never spliced
 warning: definition prose `funcinst` was never spliced
+warning: definition prose `funcsxa` was never spliced
 warning: definition prose `funcsxt` was never spliced
-warning: definition prose `funcsxv` was never spliced
 warning: definition prose `funcsxx` was never spliced
 warning: definition prose `fzero` was never spliced
 warning: definition prose `global` was never spliced
 warning: definition prose `globalinst` was never spliced
+warning: definition prose `globalsxa` was never spliced
 warning: definition prose `globalsxt` was never spliced
-warning: definition prose `globalsxv` was never spliced
 warning: definition prose `globalsxx` was never spliced
 warning: definition prose `growmem` was never spliced
 warning: definition prose `growtable` was never spliced
@@ -1876,8 +1945,8 @@ warning: definition prose `lunpacknum_` was never spliced
 warning: definition prose `mem` was never spliced
 warning: definition prose `memarg0` was never spliced
 warning: definition prose `meminst` was never spliced
+warning: definition prose `memsxa` was never spliced
 warning: definition prose `memsxt` was never spliced
-warning: definition prose `memsxv` was never spliced
 warning: definition prose `memsxx` was never spliced
 warning: definition prose `min` was never spliced
 warning: definition prose `moduleinst` was never spliced
@@ -1935,9 +2004,15 @@ warning: definition prose `sum` was never spliced
 warning: definition prose `sx` was never spliced
 warning: definition prose `table` was never spliced
 warning: definition prose `tableinst` was never spliced
+warning: definition prose `tablesxa` was never spliced
 warning: definition prose `tablesxt` was never spliced
-warning: definition prose `tablesxv` was never spliced
 warning: definition prose `tablesxx` was never spliced
+warning: definition prose `tag` was never spliced
+warning: definition prose `tagaddr` was never spliced
+warning: definition prose `taginst` was never spliced
+warning: definition prose `tagsxa` was never spliced
+warning: definition prose `tagsxt` was never spliced
+warning: definition prose `tagsxx` was never spliced
 warning: definition prose `testop_` was never spliced
 warning: definition prose `type` was never spliced
 warning: definition prose `unop_` was never spliced
diff --git a/test/core/binary.wast b/test/core/binary.wast
index 04f7cb14d5..9a5122cdbb 100644
--- a/test/core/binary.wast
+++ b/test/core/binary.wast
@@ -118,7 +118,7 @@
     ;; Missing end marker here
     "\0a\04\01\02\00\0b"       ;; Code section: 1 function
   )
-  "illegal opcode"
+  "unexpected end of section or function"
 )
 
 ;; Local number is unsigned 32 bit
@@ -463,7 +463,7 @@
       "\02\04\01"                           ;; import section with single entry
       "\00"                                 ;; string length 0
       "\00"                                 ;; string length 0
-      "\04"                                 ;; malformed import kind
+      "\05"                                 ;; malformed import kind
   )
   "malformed import kind"
 )
@@ -473,7 +473,7 @@
       "\02\05\01"                           ;; import section with single entry
       "\00"                                 ;; string length 0
       "\00"                                 ;; string length 0
-      "\04"                                 ;; malformed import kind
+      "\05"                                 ;; malformed import kind
       "\00"                                 ;; dummy byte
   )
   "malformed import kind"
diff --git a/test/core/call_ref.wast b/test/core/call_ref.wast
index da480a7f23..aa9ac7b873 100644
--- a/test/core/call_ref.wast
+++ b/test/core/call_ref.wast
@@ -206,3 +206,13 @@
   )
   "type mismatch"
 )
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (param $r funcref)
+      (call_ref $t (local.get $r))
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/core/elem.wast b/test/core/elem.wast
index c2a7976ac6..1722a30b81 100644
--- a/test/core/elem.wast
+++ b/test/core/elem.wast
@@ -891,15 +891,6 @@
   "constant expression required"
 )
 
-(assert_invalid
-  (module
-    (func $f (result i32) (i32.const 9))
-    (table 1 funcref)
-    (elem (i32.const 0) funcref (item (call $f)))
-  )
-  "constant expression required"
-)
-
 
 ;; Two elements target the same slot
 
diff --git a/test/core/exports.wast b/test/core/exports.wast
index 80d3ae0742..f27b10a54c 100644
--- a/test/core/exports.wast
+++ b/test/core/exports.wast
@@ -67,6 +67,10 @@
   (module (func) (memory 0) (export "a" (func 0)) (export "a" (memory 0)))
   "duplicate export name"
 )
+(assert_invalid
+  (module (tag $t0 (export "t0")) (tag $t1 (export "t0")))
+  "duplicate export name"
+)
 
 
 ;; Globals
diff --git a/test/core/imports.wast b/test/core/imports.wast
index 110df172f9..cbb41af8ce 100644
--- a/test/core/imports.wast
+++ b/test/core/imports.wast
@@ -16,6 +16,10 @@
   (memory (export "memory-2-inf") 2)
   ;; Multiple memories are not yet supported
   ;; (memory (export "memory-2-4") 2 4)
+  (tag (export "tag"))
+  (tag $tag-i32 (param i32))
+  (export "tag-i32" (tag $tag-i32))
+  (tag (export "tag-f32") (param f32))
 )
 
 (register "test")
@@ -41,6 +45,9 @@
   (func $print_f64-2 (import "spectest" "print_f64") (param f64))
   (import "test" "func-i64->i64" (func $i64->i64 (param i64) (result i64)))
 
+  (tag (import "test" "tag-i32") (param i32))
+  (import "test" "tag-f32" (tag (param f32)))
+
   (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))
@@ -207,6 +214,10 @@
   (module (import "test" "memory-2-inf" (func)))
   "incompatible import type"
 )
+(assert_unlinkable
+  (module (import "test" "tag" (func)))
+  "incompatible import type"
+)
 (assert_unlinkable
   (module (import "spectest" "global_i32" (func)))
   "incompatible import type"
@@ -220,6 +231,27 @@
   "incompatible import type"
 )
 
+(assert_unlinkable
+  (module (tag (import "test" "unknown")))
+  "unknown import"
+)
+(assert_unlinkable
+  (module (tag (import "test" "tag") (param f32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (tag (import "test" "tag-i32")))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (tag (import "test" "tag-i32") (param f32)))
+  "incompatible import type"
+)
+(assert_unlinkable
+  (module (tag (import "test" "func-i32") (param f32)))
+  "incompatible import type"
+)
+
 
 ;; Globals
 
diff --git a/test/core/ref_null.wast b/test/core/ref_null.wast
index 1ffd03f8a4..3faadafbae 100644
--- a/test/core/ref_null.wast
+++ b/test/core/ref_null.wast
@@ -2,15 +2,21 @@
   (type $t (func))
   (func (export "anyref") (result anyref) (ref.null any))
   (func (export "funcref") (result funcref) (ref.null func))
+  (func (export "exnref") (result exnref) (ref.null exn))
+  (func (export "externref") (result externref) (ref.null extern))
   (func (export "ref") (result (ref null $t)) (ref.null $t))
 
   (global anyref (ref.null any))
   (global funcref (ref.null func))
+  (global exnref (ref.null exn))
+  (global externref (ref.null extern))
   (global (ref null $t) (ref.null $t))
 )
 
 (assert_return (invoke "anyref") (ref.null any))
 (assert_return (invoke "funcref") (ref.null func))
+(assert_return (invoke "exnref") (ref.null exn))
+(assert_return (invoke "externref") (ref.null extern))
 (assert_return (invoke "ref") (ref.null))
 
 
@@ -18,11 +24,14 @@
   (type $t (func))
   (global $null nullref (ref.null none))
   (global $nullfunc nullfuncref (ref.null nofunc))
+  (global $nullexn nullexnref (ref.null noexn))
   (global $nullextern nullexternref (ref.null noextern))
   (func (export "anyref") (result anyref) (global.get $null))
   (func (export "nullref") (result nullref) (global.get $null))
   (func (export "funcref") (result funcref) (global.get $nullfunc))
   (func (export "nullfuncref") (result nullfuncref) (global.get $nullfunc))
+  (func (export "exnref") (result exnref) (global.get $nullexn))
+  (func (export "nullexnref") (result nullexnref) (global.get $nullexn))
   (func (export "externref") (result externref) (global.get $nullextern))
   (func (export "nullexternref") (result nullexternref) (global.get $nullextern))
   (func (export "ref") (result (ref null $t)) (global.get $nullfunc))
@@ -31,10 +40,13 @@
   (global anyref (ref.null none))
   (global funcref (ref.null func))
   (global funcref (ref.null nofunc))
+  (global exnref (ref.null exn))
+  (global exnref (ref.null noexn))
   (global externref (ref.null extern))
   (global externref (ref.null noextern))
   (global nullref (ref.null none))
   (global nullfuncref (ref.null nofunc))
+  (global nullexnref (ref.null noexn))
   (global nullexternref (ref.null noextern))
   (global (ref null $t) (ref.null $t))
   (global (ref null $t) (ref.null nofunc))
@@ -52,6 +64,12 @@
 (assert_return (invoke "nullfuncref") (ref.null func))
 (assert_return (invoke "nullfuncref") (ref.null nofunc))
 (assert_return (invoke "nullfuncref") (ref.null))
+(assert_return (invoke "exnref") (ref.null exn))
+(assert_return (invoke "exnref") (ref.null noexn))
+(assert_return (invoke "exnref") (ref.null))
+(assert_return (invoke "nullexnref") (ref.null exn))
+(assert_return (invoke "nullexnref") (ref.null noexn))
+(assert_return (invoke "nullexnref") (ref.null))
 (assert_return (invoke "externref") (ref.null extern))
 (assert_return (invoke "externref") (ref.null noextern))
 (assert_return (invoke "externref") (ref.null))
diff --git a/test/core/return_call_ref.wast b/test/core/return_call_ref.wast
index 327dc84b89..5f5a7cba72 100644
--- a/test/core/return_call_ref.wast
+++ b/test/core/return_call_ref.wast
@@ -375,10 +375,20 @@
   "type mismatch"
 )
 
+(assert_invalid
+  (module
+    (type $t (func))
+    (func $f (param $r funcref)
+      (return_call_ref $t (local.get $r))
+    )
+  )
+  "type mismatch"
+)
+
 (assert_invalid
   (module
     (type $ty (func (result i32 i32)))
-    (func (param funcref) (result i32)
+    (func (param (ref $ty)) (result i32)
       local.get 0
       return_call_ref $ty
     )
diff --git a/test/core/tag.wast b/test/core/tag.wast
new file mode 100644
index 0000000000..3ea8b558cc
--- /dev/null
+++ b/test/core/tag.wast
@@ -0,0 +1,61 @@
+;; Test tag section
+
+(module
+  (tag)
+  (tag (param i32))
+  (tag (export "t2") (param i32))
+  (tag $t3 (param i32 f32))
+  (export "t3" (tag 3))
+)
+
+(register "test")
+
+(module
+  (tag $t0 (import "test" "t2") (param i32))
+  (import "test" "t3" (tag $t1 (param i32 f32)))
+)
+
+(assert_invalid
+  (module (tag (result i32)))
+  "non-empty tag result type"
+)
+
+
+;; Link-time typing
+
+(module
+  (rec
+    (type $t1 (func))
+    (type $t2 (func))
+  )
+  (tag (export "tag") (type $t1))
+)
+
+(register "M")
+
+(module
+  (rec
+    (type $t1 (func))
+    (type $t2 (func))
+  )
+  (tag (import "M" "tag") (type $t1))
+)
+
+(assert_unlinkable
+  (module
+    (rec
+      (type $t1 (func))
+      (type $t2 (func))
+    )
+    (tag (import "M" "tag") (type $t2))
+  )
+  "incompatible import"
+)
+
+(assert_unlinkable
+  (module
+    (type $t (func))
+    (tag (import "M" "tag") (type $t))
+  )
+  "incompatible import"
+)
diff --git a/test/core/throw.wast b/test/core/throw.wast
new file mode 100644
index 0000000000..dc1aa4a98a
--- /dev/null
+++ b/test/core/throw.wast
@@ -0,0 +1,55 @@
+;; Test throw instruction.
+
+(module
+  (tag $e0)
+  (tag $e-i32 (param i32))
+  (tag $e-f32 (param f32))
+  (tag $e-i64 (param i64))
+  (tag $e-f64 (param f64))
+  (tag $e-i32-i32 (param i32 i32))
+
+  (func $throw-if (export "throw-if") (param i32) (result i32)
+    (local.get 0)
+    (i32.const 0) (if (i32.ne) (then (throw $e0)))
+    (i32.const 0)
+  )
+
+  (func (export "throw-param-f32") (param f32) (local.get 0) (throw $e-f32))
+
+  (func (export "throw-param-i64") (param i64) (local.get 0) (throw $e-i64))
+
+  (func (export "throw-param-f64") (param f64) (local.get 0) (throw $e-f64))
+
+  (func (export "throw-polymorphic") (throw $e0) (throw $e-i32))
+
+  (func (export "throw-polymorphic-block") (block (result i32) (throw $e0)) (throw $e-i32))
+
+  (func $throw-1-2 (i32.const 1) (i32.const 2) (throw $e-i32-i32))
+  (func (export "test-throw-1-2")
+    (block $h (result i32 i32)
+      (try_table (catch $e-i32-i32 $h) (call $throw-1-2))
+      (return)
+    )
+    (if (i32.ne (i32.const 2)) (then (unreachable)))
+    (if (i32.ne (i32.const 1)) (then (unreachable)))
+  )
+)
+
+(assert_return (invoke "throw-if" (i32.const 0)) (i32.const 0))
+(assert_exception (invoke "throw-if" (i32.const 10)))
+(assert_exception (invoke "throw-if" (i32.const -1)))
+
+(assert_exception (invoke "throw-param-f32" (f32.const 5.0)))
+(assert_exception (invoke "throw-param-i64" (i64.const 5)))
+(assert_exception (invoke "throw-param-f64" (f64.const 5.0)))
+
+(assert_exception (invoke "throw-polymorphic"))
+(assert_exception (invoke "throw-polymorphic-block"))
+
+(assert_return (invoke "test-throw-1-2"))
+
+(assert_invalid (module (func (throw 0))) "unknown tag 0")
+(assert_invalid (module (tag (param i32)) (func (throw 0)))
+                "type mismatch: instruction requires [i32] but stack has []")
+(assert_invalid (module (tag (param i32)) (func (i64.const 5) (throw 0)))
+                "type mismatch: instruction requires [i32] but stack has [i64]")
diff --git a/test/core/throw_ref.wast b/test/core/throw_ref.wast
new file mode 100644
index 0000000000..f59710a1f9
--- /dev/null
+++ b/test/core/throw_ref.wast
@@ -0,0 +1,118 @@
+;; Test throw_ref instruction.
+
+(module
+  (tag $e0)
+  (tag $e1)
+
+  (func (export "catch-throw_ref-0")
+    (block $h (result exnref)
+      (try_table (catch_ref $e0 $h) (throw $e0))
+      (unreachable)
+    )
+    (throw_ref)
+  )
+
+  (func (export "catch-throw_ref-1") (param i32) (result i32)
+    (block $h (result exnref)
+      (try_table (result i32) (catch_ref $e0 $h) (throw $e0))
+      (return)
+    )
+    (if (param exnref) (i32.eqz (local.get 0))
+      (then (throw_ref))
+      (else (drop))
+    )
+    (i32.const 23)
+  )
+
+  (func (export "catchall-throw_ref-0")
+    (block $h (result exnref)
+      (try_table (result exnref) (catch_all_ref $h) (throw $e0))
+    )
+    (throw_ref)
+  )
+
+  (func (export "catchall-throw_ref-1") (param i32) (result i32)
+    (block $h (result exnref)
+      (try_table (result i32) (catch_all_ref $h) (throw $e0))
+      (return)
+    )
+    (if (param exnref) (i32.eqz (local.get 0))
+      (then (throw_ref))
+      (else (drop))
+    )
+    (i32.const 23)
+  )
+
+  (func (export "throw_ref-nested") (param i32) (result i32)
+    (local $exn1 exnref)
+    (local $exn2 exnref)
+    (block $h1 (result exnref)
+      (try_table (result i32) (catch_ref $e1 $h1) (throw $e1))
+      (return)
+    )
+    (local.set $exn1)
+    (block $h2 (result exnref)
+      (try_table (result i32) (catch_ref $e0 $h2) (throw $e0))
+      (return)
+    )
+    (local.set $exn2)
+    (if (i32.eq (local.get 0) (i32.const 0))
+      (then (throw_ref (local.get $exn1)))
+    )
+    (if (i32.eq (local.get 0) (i32.const 1))
+      (then (throw_ref (local.get $exn2)))
+    )
+    (i32.const 23)
+  )
+
+  (func (export "throw_ref-recatch") (param i32) (result i32)
+    (local $e exnref)
+    (block $h1 (result exnref)
+      (try_table (result i32) (catch_ref $e0 $h1) (throw $e0))
+      (return)
+    )
+    (local.set $e)
+    (block $h2 (result exnref)
+      (try_table (result i32) (catch_ref $e0 $h2)
+        (if (i32.eqz (local.get 0))
+          (then (throw_ref (local.get $e)))
+        )
+        (i32.const 42)
+      )
+      (return)
+    )
+    (drop) (i32.const 23)
+  )
+
+  (func (export "throw_ref-stack-polymorphism")
+    (local $e exnref)
+    (block $h (result exnref)
+      (try_table (result f64) (catch_ref $e0 $h) (throw $e0))
+      (unreachable)
+    )
+    (local.set $e)
+    (i32.const 1)
+    (throw_ref (local.get $e))
+  )
+)
+
+(assert_exception (invoke "catch-throw_ref-0"))
+
+(assert_exception (invoke "catch-throw_ref-1" (i32.const 0)))
+(assert_return (invoke "catch-throw_ref-1" (i32.const 1)) (i32.const 23))
+
+(assert_exception (invoke "catchall-throw_ref-0"))
+
+(assert_exception (invoke "catchall-throw_ref-1" (i32.const 0)))
+(assert_return (invoke "catchall-throw_ref-1" (i32.const 1)) (i32.const 23))
+(assert_exception (invoke "throw_ref-nested" (i32.const 0)))
+(assert_exception (invoke "throw_ref-nested" (i32.const 1)))
+(assert_return (invoke "throw_ref-nested" (i32.const 2)) (i32.const 23))
+
+(assert_return (invoke "throw_ref-recatch" (i32.const 0)) (i32.const 23))
+(assert_return (invoke "throw_ref-recatch" (i32.const 1)) (i32.const 42))
+
+(assert_exception (invoke "throw_ref-stack-polymorphism"))
+
+(assert_invalid (module (func (throw_ref))) "type mismatch")
+(assert_invalid (module (func (block (throw_ref)))) "type mismatch")
diff --git a/test/core/try_table.wast b/test/core/try_table.wast
new file mode 100644
index 0000000000..ed3b88cbc5
--- /dev/null
+++ b/test/core/try_table.wast
@@ -0,0 +1,456 @@
+;; Test try-catch blocks.
+
+(module
+  (tag $e0 (export "e0"))
+  (func (export "throw") (throw $e0))
+)
+
+(register "test")
+
+(module
+  (tag $imported-e0 (import "test" "e0"))
+  (func $imported-throw (import "test" "throw"))
+  (tag $e0)
+  (tag $e1)
+  (tag $e2)
+  (tag $e-i32 (param i32))
+  (tag $e-f32 (param f32))
+  (tag $e-i64 (param i64))
+  (tag $e-f64 (param f64))
+
+  (func $throw-if (param i32) (result i32)
+    (local.get 0)
+    (i32.const 0) (if (i32.ne) (then (throw $e0)))
+    (i32.const 0)
+  )
+
+  (func (export "simple-throw-catch") (param i32) (result i32)
+    (block $h
+      (try_table (result i32) (catch $e0 $h)
+        (if (i32.eqz (local.get 0)) (then (throw $e0)) (else))
+        (i32.const 42)
+      )
+      (return)
+    )
+    (i32.const 23)
+  )
+
+  (func (export "unreachable-not-caught")
+    (block $h
+      (try_table (catch_all $h) (unreachable))
+      (return)
+    )
+  )
+
+  (func $div (param i32 i32) (result i32)
+    (local.get 0) (local.get 1) (i32.div_u)
+  )
+  (func (export "trap-in-callee") (param i32 i32) (result i32)
+    (block $h
+      (try_table (result i32) (catch_all $h)
+        (call $div (local.get 0) (local.get 1))
+      )
+      (return)
+    )
+    (i32.const 11)
+  )
+
+  (func (export "catch-complex-1") (param i32) (result i32)
+    (block $h1
+      (try_table (result i32) (catch $e1 $h1)
+        (block $h0
+          (try_table (result i32) (catch $e0 $h0)
+            (if (i32.eqz (local.get 0))
+              (then (throw $e0))
+              (else
+                (if (i32.eq (local.get 0) (i32.const 1))
+                  (then (throw $e1))
+                  (else (throw $e2))
+                )
+              )
+            )
+            (i32.const 2)
+          )
+          (br 1)
+        )
+        (i32.const 3)
+      )
+      (return)
+    )
+    (i32.const 4)
+  )
+
+  (func (export "catch-complex-2") (param i32) (result i32)
+    (block $h0
+      (block $h1
+        (try_table (result i32) (catch $e0 $h0) (catch $e1 $h1)
+          (if (i32.eqz (local.get 0))
+            (then (throw $e0))
+            (else
+              (if (i32.eq (local.get 0) (i32.const 1))
+                (then (throw $e1))
+                (else (throw $e2))
+              )
+            )
+           )
+          (i32.const 2)
+        )
+        (return)
+      )
+      (return (i32.const 4))
+    )
+    (i32.const 3)
+  )
+
+  (func (export "throw-catch-param-i32") (param i32) (result i32)
+    (block $h (result i32)
+      (try_table (result i32) (catch $e-i32 $h)
+        (throw $e-i32 (local.get 0))
+        (i32.const 2)
+      )
+      (return)
+    )
+    (return)
+  )
+
+  (func (export "throw-catch-param-f32") (param f32) (result f32)
+    (block $h (result f32)
+      (try_table (result f32) (catch $e-f32 $h)
+        (throw $e-f32 (local.get 0))
+        (f32.const 0)
+      )
+      (return)
+    )
+    (return)
+  )
+
+  (func (export "throw-catch-param-i64") (param i64) (result i64)
+    (block $h (result i64)
+      (try_table (result i64) (catch $e-i64 $h)
+        (throw $e-i64 (local.get 0))
+        (i64.const 2)
+      )
+      (return)
+    )
+    (return)
+  )
+
+  (func (export "throw-catch-param-f64") (param f64) (result f64)
+    (block $h (result f64)
+      (try_table (result f64) (catch $e-f64 $h)
+        (throw $e-f64 (local.get 0))
+        (f64.const 0)
+      )
+      (return)
+    )
+    (return)
+  )
+
+  (func (export "throw-catch_ref-param-i32") (param i32) (result i32)
+    (block $h (result i32 exnref)
+      (try_table (result i32) (catch_ref $e-i32 $h)
+        (throw $e-i32 (local.get 0))
+        (i32.const 2)
+      )
+      (return)
+    )
+    (drop) (return)
+  )
+
+  (func (export "throw-catch_ref-param-f32") (param f32) (result f32)
+    (block $h (result f32 exnref)
+      (try_table (result f32) (catch_ref $e-f32 $h)
+        (throw $e-f32 (local.get 0))
+        (f32.const 0)
+      )
+      (return)
+    )
+    (drop) (return)
+  )
+
+  (func (export "throw-catch_ref-param-i64") (param i64) (result i64)
+    (block $h (result i64 exnref)
+      (try_table (result i64) (catch_ref $e-i64 $h)
+        (throw $e-i64 (local.get 0))
+        (i64.const 2)
+      )
+      (return)
+    )
+    (drop) (return)
+  )
+
+  (func (export "throw-catch_ref-param-f64") (param f64) (result f64)
+    (block $h (result f64 exnref)
+      (try_table (result f64) (catch_ref $e-f64 $h)
+        (throw $e-f64 (local.get 0))
+        (f64.const 0)
+      )
+      (return)
+    )
+    (drop) (return)
+  )
+
+  (func $throw-param-i32 (param i32) (throw $e-i32 (local.get 0)))
+  (func (export "catch-param-i32") (param i32) (result i32)
+    (block $h (result i32)
+      (try_table (result i32) (catch $e-i32 $h)
+        (i32.const 0)
+        (call $throw-param-i32 (local.get 0))
+      )
+      (return)
+    )
+  )
+
+  (func (export "catch-imported") (result i32)
+    (block $h
+      (try_table (result i32) (catch $imported-e0 $h)
+        (call $imported-throw (i32.const 1))
+      )
+      (return)
+    )
+    (i32.const 2)
+  )
+
+  (func (export "catchless-try") (param i32) (result i32)
+    (block $h
+      (try_table (result i32) (catch $e0 $h)
+        (try_table (result i32) (call $throw-if (local.get 0)))
+      )
+      (return)
+    )
+    (i32.const 1)
+  )
+
+  (func $throw-void (throw $e0))
+  (func (export "return-call-in-try-catch")
+    (block $h
+      (try_table (catch $e0 $h)
+        (return_call $throw-void)
+      )
+    )
+  )
+
+  (table funcref (elem $throw-void))
+  (func (export "return-call-indirect-in-try-catch")
+    (block $h
+      (try_table (catch $e0 $h)
+        (return_call_indirect (i32.const 0))
+      )
+    )
+  )
+
+  (func (export "try-with-param")
+    (i32.const 0) (try_table (param i32) (drop))
+  )
+)
+
+(assert_return (invoke "simple-throw-catch" (i32.const 0)) (i32.const 23))
+(assert_return (invoke "simple-throw-catch" (i32.const 1)) (i32.const 42))
+
+(assert_trap (invoke "unreachable-not-caught") "unreachable")
+
+(assert_return (invoke "trap-in-callee" (i32.const 7) (i32.const 2)) (i32.const 3))
+(assert_trap (invoke "trap-in-callee" (i32.const 1) (i32.const 0)) "integer divide by zero")
+
+(assert_return (invoke "catch-complex-1" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "catch-complex-1" (i32.const 1)) (i32.const 4))
+(assert_exception (invoke "catch-complex-1" (i32.const 2)))
+
+(assert_return (invoke "catch-complex-2" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "catch-complex-2" (i32.const 1)) (i32.const 4))
+(assert_exception (invoke "catch-complex-2" (i32.const 2)))
+
+(assert_return (invoke "throw-catch-param-i32" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "throw-catch-param-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "throw-catch-param-i32" (i32.const 10)) (i32.const 10))
+
+(assert_return (invoke "throw-catch-param-f32" (f32.const 5.0)) (f32.const 5.0))
+(assert_return (invoke "throw-catch-param-f32" (f32.const 10.5)) (f32.const 10.5))
+
+(assert_return (invoke "throw-catch-param-i64" (i64.const 5)) (i64.const 5))
+(assert_return (invoke "throw-catch-param-i64" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "throw-catch-param-i64" (i64.const -1)) (i64.const -1))
+
+(assert_return (invoke "throw-catch-param-f64" (f64.const 5.0)) (f64.const 5.0))
+(assert_return (invoke "throw-catch-param-f64" (f64.const 10.5)) (f64.const 10.5))
+
+(assert_return (invoke "throw-catch_ref-param-i32" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "throw-catch_ref-param-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "throw-catch_ref-param-i32" (i32.const 10)) (i32.const 10))
+
+(assert_return (invoke "throw-catch_ref-param-f32" (f32.const 5.0)) (f32.const 5.0))
+(assert_return (invoke "throw-catch_ref-param-f32" (f32.const 10.5)) (f32.const 10.5))
+
+(assert_return (invoke "throw-catch_ref-param-i64" (i64.const 5)) (i64.const 5))
+(assert_return (invoke "throw-catch_ref-param-i64" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "throw-catch_ref-param-i64" (i64.const -1)) (i64.const -1))
+
+(assert_return (invoke "throw-catch_ref-param-f64" (f64.const 5.0)) (f64.const 5.0))
+(assert_return (invoke "throw-catch_ref-param-f64" (f64.const 10.5)) (f64.const 10.5))
+
+(assert_return (invoke "catch-param-i32" (i32.const 5)) (i32.const 5))
+
+(assert_return (invoke "catch-imported") (i32.const 2))
+
+(assert_return (invoke "catchless-try" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "catchless-try" (i32.const 1)) (i32.const 1))
+
+(assert_exception (invoke "return-call-in-try-catch"))
+(assert_exception (invoke "return-call-indirect-in-try-catch"))
+
+(assert_return (invoke "try-with-param"))
+
+(module
+  (func $imported-throw (import "test" "throw"))
+  (tag $e0)
+
+  (func (export "imported-mismatch") (result i32)
+    (block $h
+      (try_table (result i32) (catch_all $h)
+        (block $h0
+          (try_table (result i32) (catch $e0 $h0)
+            (i32.const 1)
+            (call $imported-throw)
+          )
+          (return)
+        )
+        (i32.const 2)
+      )
+      (return)
+    )
+    (i32.const 3)
+  )
+)
+
+(assert_return (invoke "imported-mismatch") (i32.const 3))
+
+(assert_malformed
+  (module quote "(module (func (catch_all)))")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(module (tag $e) (func (catch $e)))")
+  "unexpected token"
+)
+
+(module
+  (tag $e)
+  (func (try_table (catch $e 0) (catch $e 0)))
+  (func (try_table (catch_all 0) (catch $e 0)))
+  (func (try_table (catch_all 0) (catch_all 0)))
+  (func (result exnref) (try_table (catch_ref $e 0) (catch_ref $e 0)) (unreachable))
+  (func (result exnref) (try_table (catch_all_ref 0) (catch_ref $e 0)) (unreachable))
+  (func (result exnref) (try_table (catch_all_ref 0) (catch_all_ref 0)) (unreachable))
+)
+
+(assert_invalid
+  (module (func (result i32) (try_table (result i32))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func (result i32) (try_table (result i32) (i64.const 42))))
+  "type mismatch"
+)
+
+(assert_invalid
+  (module (tag) (func (try_table (catch_ref 0 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (tag) (func (result exnref) (try_table (catch 0 0)) (unreachable)))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func (try_table (catch_all_ref 0))))
+  "type mismatch"
+)
+(assert_invalid
+  (module (func (result exnref) (try_table (catch_all 0)) (unreachable)))
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (tag (param i64))
+    (func (result i32 exnref) (try_table (result i32) (catch_ref 0 0) (i32.const 42)))
+  )
+  "type mismatch"
+)
+
+
+(module
+  (type $t (func))
+  (func $dummy)
+  (elem declare func $dummy)
+
+  (tag $e (param (ref $t)))
+  (func $throw (throw $e (ref.func $dummy)))
+
+  (func (export "catch") (result (ref null $t))
+    (block $l (result (ref null $t))
+      (try_table (catch $e $l) (call $throw))
+      (unreachable)
+    )
+  )
+  (func (export "catch_ref1") (result (ref null $t))
+    (block $l (result (ref null $t) (ref exn))
+      (try_table (catch_ref $e $l) (call $throw))
+      (unreachable)
+    )
+    (drop)
+  )
+  (func (export "catch_ref2") (result (ref null $t))
+    (block $l (result (ref null $t) (ref null exn))
+      (try_table (catch_ref $e $l) (call $throw))
+      (unreachable)
+    )
+    (drop)
+  )
+  (func (export "catch_all_ref1")
+    (block $l (result (ref exn))
+      (try_table (catch_all_ref $l) (call $throw))
+      (unreachable)
+    )
+    (drop)
+  )
+  (func (export "catch_all_ref2")
+    (block $l (result (ref null exn))
+      (try_table (catch_all_ref $l) (call $throw))
+      (unreachable)
+    )
+    (drop)
+  )
+)
+
+(assert_return (invoke "catch") (ref.func))
+(assert_return (invoke "catch_ref1") (ref.func))
+(assert_return (invoke "catch_ref2") (ref.func))
+(assert_return (invoke "catch_all_ref1"))
+(assert_return (invoke "catch_all_ref2"))
+
+(assert_invalid
+  (module
+    (type $t (func))
+    (tag $e (param (ref null $t)))
+    (func (export "catch") (result (ref $t))
+      (block $l (result (ref $t))
+        (try_table (catch $e $l))
+        (unreachable)
+      )
+    )
+  )
+  "type mismatch"
+)
+(assert_invalid
+  (module
+    (type $t (func))
+    (tag $e (param (ref null $t)))
+    (func (export "catch_ref") (result (ref $t))
+      (block $l (result (ref $t) (ref exn))
+        (try_table (catch $e $l))
+        (unreachable)
+      )
+    )
+  )
+  "type mismatch"
+)
diff --git a/test/custom/metadata.code.branch_hint/branch_hint.wast b/test/custom/metadata.code.branch_hint/branch_hint.wast
new file mode 100644
index 0000000000..f3c63b32b0
--- /dev/null
+++ b/test/custom/metadata.code.branch_hint/branch_hint.wast
@@ -0,0 +1,99 @@
+(module
+  (type (;0;) (func (param i32)))
+  (memory (;0;) 1 1)
+  (func $dummy)
+  (func $test1 (type 0)
+    (local i32)
+    local.get 1
+    local.get 0
+    i32.eq
+    (@metadata.code.branch_hint "\00" ) if
+      return
+    end
+    return
+  )
+  (func $test2 (type 0)
+    (local i32)
+    local.get 1
+    local.get 0
+    i32.eq
+    (@metadata.code.branch_hint "\01" ) if
+      return
+    end
+    return
+  )
+  (func (export "nested") (param i32 i32) (result i32)
+    (@metadata.code.branch_hint "\00")
+    (if (result i32) (local.get 0)
+      (then
+        (if (local.get 1) (then (call $dummy) (block) (nop)))
+        (if (local.get 1) (then) (else (call $dummy) (block) (nop)))
+        (@metadata.code.branch_hint "\01")
+        (if (result i32) (local.get 1)
+          (then (call $dummy) (i32.const 9))
+          (else (call $dummy) (i32.const 10))
+        )
+      )
+      (else
+        (if (local.get 1) (then (call $dummy) (block) (nop)))
+        (@metadata.code.branch_hint "\00")
+        (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))
+        )
+      )
+    )
+  )
+)
+
+(assert_malformed_custom
+  (module quote
+    "(func $test2 (type 0)"
+    "  (local i32)"
+    "  local.get 1"
+    "  local.get 0"
+    "  i32.eq"
+    "  (@metadata.code.branch_hint \"\\01\" )"
+    "  (@metadata.code.branch_hint \"\\01\" )"
+    "  if"
+    "    return"
+    "  end"
+    "  return"
+    ")"
+  )
+  "@metadata.code.branch_hint annotation: duplicate annotation"
+)
+(assert_malformed_custom
+  (module quote
+    "(module"
+    "  (@metadata.code.branch_hint \"\\01\" )"
+    "  (type (;0;) (func (param i32)))"
+    "  (memory (;0;) 1 1)"
+    "  (func $test (type 0)"
+    "    (local i32)"
+    "    local.get 1"
+    "    local.get 0"
+    "    i32.eq"
+    "    return"
+    "  )"
+    ")"
+  )
+  "@metadata.code.branch_hint annotation: not in a function"
+)
+
+(assert_invalid_custom
+  (module
+    (type (;0;) (func (param i32)))
+    (memory (;0;) 1 1)
+    (func $test (type 0)
+      (local i32)
+      local.get 1
+      local.get 0
+      (@metadata.code.branch_hint "\01" )
+      i32.eq
+      return
+    )
+  )
+  "@metadata.code.branch_hint annotation: invalid target"
+)
diff --git a/test/custom/name/name_annot.wast b/test/custom/name/name_annot.wast
index 7a0e30c003..bf34fd67a1 100644
--- a/test/custom/name/name_annot.wast
+++ b/test/custom/name/name_annot.wast
@@ -18,3 +18,21 @@
   (module quote "(module (start $f (@name \"M\")) (func $f))")
   "misplaced @name annotation"
 )
+
+
+;; Function names
+
+(module
+  (type $t (func))
+  (func (@name "λ") (type $t))
+  (func $lambda (@name "λ") (type $t))
+)
+
+
+;; Tag names
+
+(module
+  (type $t (func))
+  (tag (@name "θ") (type $t))
+  (tag $theta (@name "θ") (type $t))
+)
diff --git a/test/js-api/exception/basic.tentative.any.js b/test/js-api/exception/basic.tentative.any.js
new file mode 100644
index 0000000000..09f8479aa8
--- /dev/null
+++ b/test/js-api/exception/basic.tentative.any.js
@@ -0,0 +1,182 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+function assert_throws_wasm(fn, message) {
+  try {
+    fn();
+    assert_not_reached(`expected to throw with ${message}`);
+  } catch (e) {
+    assert_true(e instanceof WebAssembly.Exception, `Error should be a WebAssembly.Exception with ${message}`);
+  }
+}
+
+promise_test(async () => {
+  const kSig_v_r = makeSig([kWasmExternRef], []);
+  const builder = new WasmModuleBuilder();
+  const tagIndexExternref = builder.addTag(kSig_v_r);
+  builder.addFunction("throw_param", kSig_v_r)
+    .addBody([
+      kExprLocalGet, 0,
+      kExprThrow, tagIndexExternref,
+    ])
+    .exportFunc();
+  const buffer = builder.toBuffer();
+  const {instance} = await WebAssembly.instantiate(buffer, {});
+  const values = [
+    undefined,
+    null,
+    true,
+    false,
+    "test",
+    Symbol(),
+    0,
+    1,
+    4.2,
+    NaN,
+    Infinity,
+    {},
+    () => {},
+  ];
+  for (const v of values) {
+    assert_throws_wasm(() => instance.exports.throw_param(v), String(v));
+  }
+}, "Wasm function throws argument");
+
+promise_test(async () => {
+  const builder = new WasmModuleBuilder();
+  const tagIndexAnyref = builder.addTag(kSig_v_a);
+  builder.addFunction("throw_null", kSig_v_v)
+    .addBody([
+      kExprRefNull, kAnyFuncCode,
+      kExprThrow, tagIndexAnyref,
+    ])
+    .exportFunc();
+  const buffer = builder.toBuffer();
+  const {instance} = await WebAssembly.instantiate(buffer, {});
+  assert_throws_wasm(() => instance.exports.throw_null());
+}, "Wasm function throws null");
+
+promise_test(async () => {
+  const builder = new WasmModuleBuilder();
+  const tagIndexI32 = builder.addTag(kSig_v_i);
+  builder.addFunction("throw_int", kSig_v_v)
+    .addBody([
+      ...wasmI32Const(7),
+      kExprThrow, tagIndexI32,
+    ])
+    .exportFunc();
+  const buffer = builder.toBuffer();
+  const {instance} = await WebAssembly.instantiate(buffer, {});
+  assert_throws_wasm(() => instance.exports.throw_int());
+}, "Wasm function throws integer");
+
+promise_test(async () => {
+  const builder = new WasmModuleBuilder();
+  const fnIndex = builder.addImport("module", "fn", kSig_v_v);
+  const tagIndexExternref = builder.addTag(kSig_v_r);
+
+  builder.addFunction("catch_exception", kSig_r_v)
+    .addBody([
+      kExprBlock, kWasmVoid,
+        kExprBlock, kExternRefCode,
+          kExprTryTable, kWasmVoid, 1,
+            kCatchNoRef, tagIndexExternref, 0,
+            kExprCallFunction, fnIndex,
+          kExprEnd,
+          kExprBr, 1,
+        kExprEnd,
+        kExprReturn,
+      kExprEnd,
+      kExprRefNull, kExternRefCode,
+    ])
+    .exportFunc();
+
+  const buffer = builder.toBuffer();
+
+  const error = new Error();
+  const fn = () => { throw error };
+  const {instance} = await WebAssembly.instantiate(buffer, {
+    module: { fn }
+  });
+  assert_throws_exactly(error, () => instance.exports.catch_exception());
+}, "Imported JS function throws");
+
+promise_test(async () => {
+  const builder = new WasmModuleBuilder();
+  const fnIndex = builder.addImport("module", "fn", kSig_v_v);
+  builder.addFunction("catch_and_rethrow", kSig_r_v)
+    .addBody([
+      kExprBlock, kWasmVoid,
+        kExprBlock, kExnRefCode,
+          kExprTryTable, kWasmVoid, 1,
+            kCatchAllRef, 0,
+            kExprCallFunction, fnIndex,
+          kExprEnd,
+          kExprBr, 1,
+        kExprEnd,
+        kExprThrowRef,
+      kExprEnd,
+      kExprRefNull, kExternRefCode,
+    ])
+    .exportFunc();
+
+  const buffer = builder.toBuffer();
+
+  const error = new Error();
+  const fn = () => { throw error };
+  const {instance} = await WebAssembly.instantiate(buffer, {
+    module: { fn }
+  });
+  assert_throws_exactly(error, () => instance.exports.catch_and_rethrow());
+}, "Imported JS function throws, Wasm catches and rethrows");
+
+promise_test(async () => {
+  const builder = new WasmModuleBuilder();
+  const fnIndex = builder.addImport("module", "fn", kSig_v_v);
+  const tagI32 = new WebAssembly.Tag({ parameters: ["i32"] });
+  const tagIndexI32 = builder.addImportedTag("module", "tagI32", kSig_v_i);
+  const exn = new WebAssembly.Exception(tagI32, [42]);
+  const kSig_ie_v = makeSig([], [kWasmI32, kExnRefCode]);
+  const sig_ie_v = builder.addType(kSig_ie_v);
+
+  builder.addFunction("all_catch_clauses", kSig_i_v)
+    .addBody([
+      kExprBlock, kWasmVoid,
+        kExprBlock, kExnRefCode,
+          kExprBlock, sig_ie_v,
+            kExprBlock, kWasmVoid,
+              kExprBlock, kWasmI32,
+                kExprTryTable, kWasmVoid, 4,
+                  kCatchNoRef, tagIndexI32, 0,
+                  kCatchAllNoRef, 1,
+                  kCatchRef, tagIndexI32, 2,
+                  kCatchAllRef, 3,
+                  kExprCallFunction, fnIndex,
+                kExprEnd,
+                kExprBr, 4,
+              kExprEnd,
+              kExprReturn,
+            kExprEnd,
+            kExprBr, 2,
+          kExprEnd,
+          kExprDrop,
+          kExprDrop,
+          kExprBr, 1,
+        kExprEnd,
+        kExprDrop,
+      kExprEnd,
+      kExprI32Const, 0,
+    ])
+    .exportFunc();
+
+  const buffer = builder.toBuffer();
+
+  const fn = () => {
+    throw exn;
+  };
+  const {instance} = await WebAssembly.instantiate(buffer, {
+    module: { fn, tagI32: tagI32 }
+  });
+  const result = instance.exports.all_catch_clauses();
+  assert_equals(result, 42);
+}, "try-table uses all four kinds of catch clauses, one of which catches an exception");
diff --git a/test/js-api/exception/constructor.tentative.any.js b/test/js-api/exception/constructor.tentative.any.js
new file mode 100644
index 0000000000..a46d1816c3
--- /dev/null
+++ b/test/js-api/exception/constructor.tentative.any.js
@@ -0,0 +1,62 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+// META: script=/wasm/jsapi/assertions.js
+
+test(() => {
+  assert_function_name(
+    WebAssembly.Exception,
+    "Exception",
+    "WebAssembly.Exception"
+  );
+}, "name");
+
+test(() => {
+  assert_function_length(WebAssembly.Exception, 1, "WebAssembly.Exception");
+}, "length");
+
+test(() => {
+  assert_throws_js(TypeError, () => new WebAssembly.Exception());
+}, "No arguments");
+
+test(() => {
+  const tag = new WebAssembly.Tag({ parameters: [] });
+  assert_throws_js(TypeError, () => WebAssembly.Exception(tag));
+}, "Calling");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    false,
+    true,
+    "",
+    "test",
+    Symbol(),
+    1,
+    NaN,
+    {},
+  ];
+  for (const invalidArgument of invalidArguments) {
+    assert_throws_js(
+      TypeError,
+      () => new WebAssembly.Exception(invalidArgument),
+      `new Exception(${format_value(invalidArgument)})`
+    );
+  }
+}, "Invalid descriptor argument");
+
+test(() => {
+  const typesAndArgs = [
+    ["i32", 123n],
+    ["i32", Symbol()],
+    ["f32", 123n],
+    ["f64", 123n],
+    ["i64", undefined],
+  ];
+  for (const typeAndArg of typesAndArgs) {
+    const tag = new WebAssembly.Tag({ parameters: [typeAndArg[0]] });
+    assert_throws_js(
+      TypeError,
+      () => new WebAssembly.Exception(tag, typeAndArg[1])
+    );
+  }
+}, "Invalid exception argument");
diff --git a/test/js-api/exception/getArg.tentative.any.js b/test/js-api/exception/getArg.tentative.any.js
new file mode 100644
index 0000000000..6d56ac8c6a
--- /dev/null
+++ b/test/js-api/exception/getArg.tentative.any.js
@@ -0,0 +1,54 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+// META: script=/wasm/jsapi/memory/assertions.js
+
+test(() => {
+  const tag = new WebAssembly.Tag({ parameters: [] });
+  const exn = new WebAssembly.Exception(tag, []);
+  assert_throws_js(TypeError, () => exn.getArg());
+  assert_throws_js(TypeError, () => exn.getArg(tag));
+}, "Missing arguments");
+
+test(() => {
+  const invalidValues = [undefined, null, true, "", Symbol(), 1, {}];
+  const tag = new WebAssembly.Tag({ parameters: [] });
+  const exn = new WebAssembly.Exception(tag, []);
+  for (argument of invalidValues) {
+    assert_throws_js(TypeError, () => exn.getArg(argument, 0));
+  }
+}, "Invalid exception argument");
+
+test(() => {
+  const tag = new WebAssembly.Tag({ parameters: [] });
+  const exn = new WebAssembly.Exception(tag, []);
+  assert_throws_js(RangeError, () => exn.getArg(tag, 1));
+}, "Index out of bounds");
+
+test(() => {
+  const outOfRangeValues = [
+    undefined,
+    NaN,
+    Infinity,
+    -Infinity,
+    -1,
+    0x100000000,
+    0x1000000000,
+    "0x100000000",
+    {
+      valueOf() {
+        return 0x100000000;
+      },
+    },
+  ];
+
+  const tag = new WebAssembly.Tag({ parameters: [] });
+  const exn = new WebAssembly.Exception(tag, []);
+  for (const value of outOfRangeValues) {
+    assert_throws_js(TypeError, () => exn.getArg(tag, value));
+  }
+}, "Getting out-of-range argument");
+
+test(() => {
+  const tag = new WebAssembly.Tag({ parameters: ["i32"] });
+  const exn = new WebAssembly.Exception(tag, [42]);
+  assert_equals(exn.getArg(tag, 0), 42);
+}, "getArg");
diff --git a/test/js-api/exception/identity.tentative.any.js b/test/js-api/exception/identity.tentative.any.js
new file mode 100644
index 0000000000..802e7053ac
--- /dev/null
+++ b/test/js-api/exception/identity.tentative.any.js
@@ -0,0 +1,201 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+// META: script=/wasm/jsapi/assertions.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  // Tag defined in JavaScript and imported into Wasm
+  const jsTag = new WebAssembly.Tag({ parameters: ["i32"] });
+  const jsTagIndex = builder.addImportedTag("module", "jsTag", kSig_v_i);
+  const jsTagExn = new WebAssembly.Exception(jsTag, [42]);
+  const jsTagExnSamePayload = new WebAssembly.Exception(jsTag, [42]);
+  const jsTagExnDiffPayload = new WebAssembly.Exception(jsTag, [53]);
+  const throwJSTagExnIndex = builder.addImport("module", "throwJSTagExn", kSig_v_v);
+
+  // Tag defined in Wasm and exported to JS
+  const wasmTagIndex = builder.addTag(kSig_v_i);
+  builder.addExportOfKind("wasmTag", kExternalTag, wasmTagIndex);
+  const throwWasmTagExnIndex = builder.addImport("module", "throwWasmTagExn", kSig_v_v);
+  // Will be assigned after an instance is created
+  let wasmTagExn = null;
+  let wasmTagExnSamePayload = null;
+  let wasmTagExnDiffPayload = null;
+
+  const kSig_ie_v = makeSig([], [kWasmI32, kExnRefCode]);
+  const sig_ie_v = builder.addType(kSig_ie_v);
+
+  const imports = {
+    module: {
+      throwJSTagExn: function() { throw jsTagExn; },
+      throwWasmTagExn: function() { throw wasmTagExn; },
+      jsTag: jsTag
+    }
+  };
+
+  // Call a JS function that throws an exception using a JS-defined tag, catches
+  // it with a 'catch_ref' instruction, and rethrows it.
+  builder
+    .addFunction("catch_ref_js_tag_throw_ref", kSig_v_v)
+    .addBody([
+      kExprBlock, kWasmVoid,
+        kExprBlock, sig_ie_v,
+          kExprTryTable, kWasmVoid, 1,
+            kCatchRef, jsTagIndex, 0,
+            kExprCallFunction, throwJSTagExnIndex,
+          kExprEnd,
+          kExprBr, 1,
+        kExprEnd,
+        kExprThrowRef,
+      kExprEnd
+    ])
+    .exportFunc();
+
+  // Call a JS function that throws an exception using a Wasm-defined tag,
+  // catches it with a 'catch_ref' instruction, and rethrows it.
+  builder
+    .addFunction("catch_ref_wasm_tag_throw_ref", kSig_v_v)
+    .addBody([
+      kExprBlock, kWasmVoid,
+        kExprBlock, sig_ie_v,
+          kExprTryTable, kWasmVoid, 1,
+            kCatchRef, wasmTagIndex, 0,
+            kExprCallFunction, throwWasmTagExnIndex,
+          kExprEnd,
+          kExprBr, 1,
+        kExprEnd,
+        kExprThrowRef,
+      kExprEnd
+    ])
+    .exportFunc();
+
+  // Call a JS function that throws an exception using a JS-defined tag, catches
+  // it with a 'catch_all_ref' instruction, and rethrows it.
+  builder
+    .addFunction("catch_all_ref_js_tag_throw_ref", kSig_v_v)
+    .addBody([
+      kExprBlock, kWasmVoid,
+        kExprBlock, kExnRefCode,
+          kExprTryTable, kWasmVoid, 1,
+            kCatchAllRef, 0,
+            kExprCallFunction, throwJSTagExnIndex,
+          kExprEnd,
+          kExprBr, 1,
+        kExprEnd,
+        kExprThrowRef,
+      kExprEnd
+    ])
+    .exportFunc();
+
+  // Call a JS function that throws an exception using a Wasm-defined tag,
+  // catches it with a 'catch_all_ref' instruction, and rethrows it.
+  builder
+    .addFunction("catch_all_ref_wasm_tag_throw_ref", kSig_v_v)
+    .addBody([
+      kExprBlock, kWasmVoid,
+        kExprBlock, kExnRefCode,
+          kExprTryTable, kWasmVoid, 1,
+            kCatchAllRef, 0,
+            kExprCallFunction, throwWasmTagExnIndex,
+          kExprEnd,
+          kExprBr, 1,
+        kExprEnd,
+        kExprThrowRef,
+      kExprEnd
+    ])
+    .exportFunc();
+
+  // Call a JS function that throws an exception, catches it with a 'catch'
+  // instruction, and returns its i32 payload.
+  builder
+    .addFunction("catch_js_tag_return_payload", kSig_i_v)
+    .addBody([
+      kExprBlock, kWasmVoid,
+        kExprBlock, kWasmI32,
+          kExprTryTable, kWasmVoid, 1,
+            kCatchNoRef, jsTagIndex, 0,
+            kExprCallFunction, throwJSTagExnIndex,
+          kExprEnd,
+          kExprBr, 1,
+        kExprEnd,
+        kExprReturn,
+      kExprEnd,
+      kExprI32Const, 0
+    ])
+    .exportFunc();
+
+  // Call a JS function that throws an exception, catches it with a 'catch'
+  // instruction, and throws a new exception using that payload.
+  builder
+    .addFunction("catch_js_tag_throw_payload", kSig_v_v)
+    .addBody([
+      kExprBlock, kWasmVoid,
+        kExprBlock, kWasmI32,
+          kExprTryTable, kWasmVoid, 1,
+            kCatchNoRef, jsTagIndex, 0,
+            kExprCallFunction, throwJSTagExnIndex,
+          kExprEnd,
+          kExprBr, 1,
+        kExprEnd,
+        kExprThrow, jsTagIndex,
+      kExprEnd
+    ])
+    .exportFunc();
+
+  const buffer = builder.toBuffer();
+
+  WebAssembly.instantiate(buffer, imports).then(result => {
+    // The exception object's identity should be preserved across 'rethrow's in
+    // Wasm code. Do tests with a tag defined in JS.
+    try {
+      result.instance.exports.catch_ref_js_tag_throw_ref();
+    } catch (e) {
+      assert_equals(e, jsTagExn);
+      // Even if they have the same payload, they are different objects, so they
+      // shouldn't compare equal.
+      assert_not_equals(e, jsTagExnSamePayload);
+      assert_not_equals(e, jsTagExnDiffPayload);
+    }
+    try {
+      result.instance.exports.catch_all_ref_js_tag_throw_ref();
+    } catch (e) {
+      assert_equals(e, jsTagExn);
+      assert_not_equals(e, jsTagExnSamePayload);
+      assert_not_equals(e, jsTagExnDiffPayload);
+    }
+
+    // Do the same tests with a tag defined in Wasm.
+    const wasmTag = result.instance.exports.wasmTag;
+    wasmTagExn = new WebAssembly.Exception(wasmTag, [42]);
+    wasmTagExnSamePayload = new WebAssembly.Exception(wasmTag, [42]);
+    wasmTagExnDiffPayload = new WebAssembly.Exception(wasmTag, [53]);
+    try {
+      result.instance.exports.catch_ref_wasm_tag_throw_ref();
+    } catch (e) {
+      assert_equals(e, wasmTagExn);
+      assert_not_equals(e, wasmTagExnSamePayload);
+      assert_not_equals(e, wasmTagExnDiffPayload);
+    }
+    try {
+      result.instance.exports.catch_all_ref_wasm_tag_throw_ref();
+    } catch (e) {
+      assert_equals(e, wasmTagExn);
+      assert_not_equals(e, wasmTagExnSamePayload);
+      assert_not_equals(e, wasmTagExnDiffPayload);
+    }
+
+    // This function catches the exception and returns its i32 payload, which
+    // should match the original payload.
+    assert_equals(result.instance.exports.catch_js_tag_return_payload(), 42);
+
+    // This function catches the exception and throws a new exception using the
+    // its payload. Even if the payload is reused, the exception objects should
+    // not compare equal.
+    try {
+      result.instance.exports.catch_js_tag_throw_payload();
+    } catch (e) {
+      assert_equals(e.getArg(jsTag, 0), 42);
+      assert_not_equals(e, jsTagExn);
+    }
+  });
+}, "Identity check");
diff --git a/test/js-api/exception/is.tentative.any.js b/test/js-api/exception/is.tentative.any.js
new file mode 100644
index 0000000000..840d00bf0d
--- /dev/null
+++ b/test/js-api/exception/is.tentative.any.js
@@ -0,0 +1,25 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+// META: script=/wasm/jsapi/memory/assertions.js
+
+test(() => {
+  const tag = new WebAssembly.Tag({ parameters: [] });
+  const exn = new WebAssembly.Exception(tag, []);
+  assert_throws_js(TypeError, () => exn.is());
+}, "Missing arguments");
+
+test(() => {
+  const invalidValues = [undefined, null, true, "", Symbol(), 1, {}];
+  const tag = new WebAssembly.Tag({ parameters: [] });
+  const exn = new WebAssembly.Exception(tag, []);
+  for (argument of invalidValues) {
+    assert_throws_js(TypeError, () => exn.is(argument));
+  }
+}, "Invalid exception argument");
+
+test(() => {
+  const tag1 = new WebAssembly.Tag({ parameters: ["i32"] });
+  const tag2 = new WebAssembly.Tag({ parameters: ["i32"] });
+  const exn = new WebAssembly.Exception(tag1, [42]);
+  assert_true(exn.is(tag1));
+  assert_false(exn.is(tag2));
+}, "is");
diff --git a/test/js-api/exception/jsTag.tentative.any.js b/test/js-api/exception/jsTag.tentative.any.js
new file mode 100644
index 0000000000..c5db553701
--- /dev/null
+++ b/test/js-api/exception/jsTag.tentative.any.js
@@ -0,0 +1,121 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+// META: script=/wasm/jsapi/assertions.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+test(() => {
+  assert_throws_js(TypeError, () => new WebAssembly.Exception(WebAssembly.JSTag, [{}]))
+}, "Creating a WebAssembly.Exception with JSTag explicitly is not allowed");
+
+promise_test(async () => {
+  const builder = new WasmModuleBuilder();
+  const jsTag = builder.addImportedTag("module", "JSTag", kSig_v_r);
+
+  const throwRefFn = builder.addImport("module", "throw_ref", kSig_r_r);
+  const sig_r_v = builder.addType(kSig_r_v);
+  const kSig_re_v = makeSig([], [kExternRefCode, kExnRefCode]);
+  const sig_re_v = builder.addType(kSig_re_v);
+
+  // Calls throw_ref, catches an exception with 'try_table - catch JSTag', and
+  // returns it
+  builder.addFunction("catch_js_tag_and_return", kSig_r_r)
+    .addBody([
+      kExprBlock, sig_r_v,
+        kExprTryTable, sig_r_v, 1,
+          kCatchNoRef, jsTag, 0,
+          kExprLocalGet, 0,
+          kExprCallFunction, throwRefFn,
+        kExprEnd,
+      kExprEnd,
+    ])
+    .exportFunc();
+
+  // Calls throw_ref, catches an exception with 'try_table - catch_ref JSTag',
+  // and returns it
+  builder.addFunction("catch_ref_js_tag_and_return", kSig_r_r)
+    .addBody([
+      kExprBlock, sig_re_v,
+        kExprTryTable, sig_r_v, 1,
+          kCatchRef, jsTag, 0,
+          kExprLocalGet, 0,
+          kExprCallFunction, throwRefFn,
+        kExprEnd,
+        kExprReturn,
+      kExprEnd,
+      kExprDrop,
+    ])
+    .exportFunc();
+
+  // Calls throw_ref, catches an exception with 'try_table - catch_ref JSTag',
+  // and rethrows it (with throw_ref)
+  builder.addFunction("catch_ref_js_tag_and_throw_ref", kSig_r_r)
+    .addBody([
+      kExprBlock, sig_re_v,
+        kExprTryTable, sig_r_v, 1,
+          kCatchRef, jsTag, 0,
+          kExprLocalGet, 0,
+          kExprCallFunction, throwRefFn,
+        kExprEnd,
+        kExprReturn,
+      kExprEnd,
+      kExprThrowRef,
+    ])
+    .exportFunc();
+
+  function throw_ref(x) {
+    throw x;
+  }
+  const buffer = builder.toBuffer();
+  const {instance} = await WebAssembly.instantiate(buffer, {
+    module: { throw_ref, JSTag: WebAssembly.JSTag }
+  });
+
+  const obj = {};
+  const wasmTag = new WebAssembly.Tag({parameters:['externref']});
+  const exn = new WebAssembly.Exception(wasmTag, [obj]);
+
+  // Test catch w/ return:
+  // This throws obj as a JS exception so it should be caught by the program and
+  // be returned as the original obj.
+  assert_equals(obj, instance.exports.catch_js_tag_and_return(obj));
+  // This is a WebAssembly.Exception, so the exception should just pass through
+  // the program without being caught.
+  assert_throws_exactly(exn, () => instance.exports.catch_js_tag_and_return(exn));
+
+  // Test catch_ref w/ return:
+  // This throws obj as a JS exception so it should be caught by the program and
+  // be returned as the original obj.
+  assert_equals(obj, instance.exports.catch_ref_js_tag_and_return(obj));
+  // This is a WebAssembly.Exception, so the exception should just pass through
+  // the program without being caught.
+  assert_throws_exactly(exn, () => instance.exports.catch_ref_js_tag_and_return(exn));
+
+  // Test catch_ref w/ throw_ref:
+  // This throws obj as a JS exception so it should be caught by the program and
+  // be rethrown.
+  assert_throws_exactly(obj, () => instance.exports.catch_ref_js_tag_and_throw_ref(obj));
+  // This is a WebAssembly.Exception, so the exception should just pass through
+  // the program without being caught.
+  assert_throws_exactly(exn, () => instance.exports.catch_ref_js_tag_and_throw_ref(exn));
+}, "JS tag catching tests");
+
+promise_test(async () => {
+  const builder = new WasmModuleBuilder();
+  const jsTag = builder.addImportedTag("module", "JSTag", kSig_v_r);
+
+  // Throw a JS object with WebAssembly.JSTag and check that we can catch it
+  // as-is from JavaScript.
+  builder.addFunction("throw_js_tag", kSig_v_r)
+    .addBody([
+      kExprLocalGet, 0,
+      kExprThrow, jsTag,
+    ])
+    .exportFunc();
+
+  const buffer = builder.toBuffer();
+  const {instance} = await WebAssembly.instantiate(buffer, {
+    module: { JSTag: WebAssembly.JSTag }
+  });
+
+  const obj = {};
+  assert_throws_exactly(obj, () => instance.exports.throw_js_tag(obj));
+}, "JS tag throwing test");
diff --git a/test/js-api/exception/toString.tentative.any.js b/test/js-api/exception/toString.tentative.any.js
new file mode 100644
index 0000000000..6885cf0deb
--- /dev/null
+++ b/test/js-api/exception/toString.tentative.any.js
@@ -0,0 +1,21 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+
+test(() => {
+  const argument = { parameters: [] };
+  const tag = new WebAssembly.Tag(argument);
+  const exn = new WebAssembly.Exception(tag, []);
+  assert_class_string(exn, "WebAssembly.Exception");
+}, "Object.prototype.toString on an Exception");
+
+test(() => {
+  assert_own_property(WebAssembly.Exception.prototype, Symbol.toStringTag);
+
+  const propDesc = Object.getOwnPropertyDescriptor(
+    WebAssembly.Exception.prototype,
+    Symbol.toStringTag
+  );
+  assert_equals(propDesc.value, "WebAssembly.Exception", "value");
+  assert_equals(propDesc.configurable, true, "configurable");
+  assert_equals(propDesc.enumerable, false, "enumerable");
+  assert_equals(propDesc.writable, false, "writable");
+}, "@@toStringTag exists on the prototype with the appropriate descriptor");
diff --git a/test/js-api/tag/constructor.tentative.any.js b/test/js-api/tag/constructor.tentative.any.js
new file mode 100644
index 0000000000..54edf8c8f5
--- /dev/null
+++ b/test/js-api/tag/constructor.tentative.any.js
@@ -0,0 +1,49 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+// META: script=/wasm/jsapi/assertions.js
+
+test(() => {
+  assert_function_name(WebAssembly.Tag, "Tag", "WebAssembly.Tag");
+}, "name");
+
+test(() => {
+  assert_function_length(WebAssembly.Tag, 1, "WebAssembly.Tag");
+}, "length");
+
+test(() => {
+  assert_throws_js(TypeError, () => new WebAssembly.Tag());
+}, "No arguments");
+
+test(() => {
+  const argument = { parameters: [] };
+  assert_throws_js(TypeError, () => WebAssembly.Tag(argument));
+}, "Calling");
+
+test(() => {
+  const invalidArguments = [
+    undefined,
+    null,
+    false,
+    true,
+    "",
+    "test",
+    Symbol(),
+    1,
+    NaN,
+    {},
+  ];
+  for (const invalidArgument of invalidArguments) {
+    assert_throws_js(
+      TypeError,
+      () => new WebAssembly.Tag(invalidArgument),
+      `new Tag(${format_value(invalidArgument)})`
+    );
+  }
+}, "Invalid descriptor argument");
+
+test(() => {
+  const invalidTypes = ["i16", "i128", "f16", "f128", "u32", "u64", "i32\0"];
+  for (const value of invalidTypes) {
+    const argument = { parameters: [value] };
+    assert_throws_js(TypeError, () => new WebAssembly.Tag(argument));
+  }
+}, "Invalid type parameter");
diff --git a/test/js-api/tag/toString.tentative.any.js b/test/js-api/tag/toString.tentative.any.js
new file mode 100644
index 0000000000..76fff0feef
--- /dev/null
+++ b/test/js-api/tag/toString.tentative.any.js
@@ -0,0 +1,20 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+
+test(() => {
+  const argument = { parameters: [] };
+  const tag = new WebAssembly.Tag(argument);
+  assert_class_string(tag, "WebAssembly.Tag");
+}, "Object.prototype.toString on a Tag");
+
+test(() => {
+  assert_own_property(WebAssembly.Tag.prototype, Symbol.toStringTag);
+
+  const propDesc = Object.getOwnPropertyDescriptor(
+    WebAssembly.Tag.prototype,
+    Symbol.toStringTag
+  );
+  assert_equals(propDesc.value, "WebAssembly.Tag", "value");
+  assert_equals(propDesc.configurable, true, "configurable");
+  assert_equals(propDesc.enumerable, false, "enumerable");
+  assert_equals(propDesc.writable, false, "writable");
+}, "@@toStringTag exists on the prototype with the appropriate descriptor");
diff --git a/test/js-api/wasm-module-builder.js b/test/js-api/wasm-module-builder.js
index 104c730c7c..0df0e5a086 100644
--- a/test/js-api/wasm-module-builder.js
+++ b/test/js-api/wasm-module-builder.js
@@ -97,8 +97,8 @@ let kDeclFunctionImport = 0x02;
 let kDeclFunctionLocals = 0x04;
 let kDeclFunctionExport = 0x08;
 
-// Local types
-let kWasmStmt = 0x40;
+// Value types and related
+let kWasmVoid = 0x40;
 let kWasmI32 = 0x7f;
 let kWasmI64 = 0x7e;
 let kWasmF32 = 0x7d;
@@ -114,10 +114,15 @@ let kWasmFuncRef = -0x10;
 let kWasmAnyFunc = kWasmFuncRef;  // Alias named as in the JS API spec
 let kWasmExternRef = -0x11;
 let kWasmAnyRef = -0x12;
+<<<<<<< HEAD
 let kWasmEqRef = -0x13;
 let kWasmI31Ref = -0x14;
 let kWasmStructRef = -0x15;
 let kWasmArrayRef = -0x16;
+=======
+let kWasmExnRef = -0x17;
+let kWasmNullExnRef = -0x0c;
+>>>>>>> exn/main
 
 // Use the positive-byte versions inside function bodies.
 let kLeb128Mask = 0x7f;
@@ -125,21 +130,36 @@ let kFuncRefCode = kWasmFuncRef & kLeb128Mask;
 let kAnyFuncCode = kFuncRefCode;  // Alias named as in the JS API spec
 let kExternRefCode = kWasmExternRef & kLeb128Mask;
 let kAnyRefCode = kWasmAnyRef & kLeb128Mask;
+<<<<<<< HEAD
 let kEqRefCode = kWasmEqRef & kLeb128Mask;
 let kI31RefCode = kWasmI31Ref & kLeb128Mask;
 let kNullExternRefCode = kWasmNullExternRef & kLeb128Mask;
 let kNullFuncRefCode = kWasmNullFuncRef & kLeb128Mask;
 let kStructRefCode = kWasmStructRef & kLeb128Mask;
 let kArrayRefCode = kWasmArrayRef & kLeb128Mask;
+=======
+let kNullExternRefCode = kWasmNullExternRef & kLeb128Mask;
+let kNullFuncRefCode = kWasmNullFuncRef & kLeb128Mask;
+let kExnRefCode = kWasmExnRef & kLeb128Mask;
+let kNullExnRefCode = kWasmNullExnRef & kLeb128Mask;
+>>>>>>> exn/main
 let kNullRefCode = kWasmNullRef & kLeb128Mask;
 
 let kWasmRefNull = 0x63;
 let kWasmRef = 0x64;
+<<<<<<< HEAD
 function wasmRefNullType(heap_type) {
   return {opcode: kWasmRefNull, heap_type: heap_type};
 }
 function wasmRefType(heap_type) {
   return {opcode: kWasmRef, heap_type: heap_type};
+=======
+function wasmRefNullType(heap_type, is_shared = false) {
+  return {opcode: kWasmRefNull, heap_type: heap_type, is_shared: is_shared};
+}
+function wasmRefType(heap_type, is_shared = false) {
+  return {opcode: kWasmRef, heap_type: heap_type, is_shared: is_shared};
+>>>>>>> exn/main
 }
 
 let kExternalFunction = 0;
@@ -152,7 +172,7 @@ let kTableZero = 0;
 let kMemoryZero = 0;
 let kSegmentZero = 0;
 
-let kTagAttribute = 0;
+let kExceptionAttribute = 0;
 
 // Useful signatures
 let kSig_i_i = makeSig([kWasmI32], [kWasmI32]);
@@ -232,10 +252,9 @@ let kExprIf = 0x04;
 let kExprElse = 0x05;
 let kExprTry = 0x06;
 let kExprCatch = 0x07;
-let kExprCatchAll = 0x19;
 let kExprThrow = 0x08;
 let kExprRethrow = 0x09;
-let kExprBrOnExn = 0x0a;
+let kExprThrowRef = 0x0a;
 let kExprEnd = 0x0b;
 let kExprBr = 0x0c;
 let kExprBrIf = 0x0d;
@@ -245,8 +264,10 @@ let kExprCallFunction = 0x10;
 let kExprCallIndirect = 0x11;
 let kExprReturnCall = 0x12;
 let kExprReturnCallIndirect = 0x13;
+let kExprCatchAll = 0x19;
 let kExprDrop = 0x1a;
 let kExprSelect = 0x1b;
+let kExprTryTable = 0x1f;
 let kExprLocalGet = 0x20;
 let kExprLocalSet = 0x21;
 let kExprLocalTee = 0x22;
@@ -549,6 +570,12 @@ let kExprI32x4Eq = 0x2c;
 let kExprS1x4AllTrue = 0x75;
 let kExprF32x4Min = 0x9e;
 
+// Exception handling with exnref.
+let kCatchNoRef = 0x0;
+let kCatchRef = 0x1;
+let kCatchAllNoRef = 0x2;
+let kCatchAllRef = 0x3;
+
 class Binary {
   constructor() {
     this.length = 0;
@@ -636,10 +663,13 @@ class Binary {
     }
   }
 
+<<<<<<< HEAD
   emit_heap_type(heap_type) {
     this.emit_bytes(wasmSignedLeb(heap_type, kMaxVarInt32Size));
   }
 
+=======
+>>>>>>> exn/main
   emit_type(type) {
     if ((typeof type) == 'number') {
       this.emit_u8(type >= 0 ? type : type & kLeb128Mask);
@@ -650,11 +680,14 @@ class Binary {
     }
   }
 
+<<<<<<< HEAD
   emit_init_expr(expr) {
     this.emit_bytes(expr);
     this.emit_u8(kExprEnd);
   }
 
+=======
+>>>>>>> exn/main
   emit_header() {
     this.emit_bytes([
       kWasmH0, kWasmH1, kWasmH2, kWasmH3, kWasmV0, kWasmV1, kWasmV2, kWasmV3
@@ -1090,6 +1123,7 @@ class WasmModuleBuilder {
     if (wasm.types.length > 0) {
       if (debug) print('emitting types @ ' + binary.length);
       binary.emit_section(kTypeSectionCode, section => {
+<<<<<<< HEAD
         let length_with_groups = wasm.types.length;
         for (let group of wasm.rec_groups) {
           length_with_groups -= group.size - 1;
@@ -1137,6 +1171,18 @@ class WasmModuleBuilder {
             for (let result of type.results) {
               section.emit_type(result);
             }
+=======
+        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_type(param);
+          }
+          section.emit_u32v(type.results.length);
+          for (let result of type.results) {
+            section.emit_type(result);
+>>>>>>> exn/main
           }
         }
       });
@@ -1173,7 +1219,7 @@ class WasmModuleBuilder {
             section.emit_u32v(imp.initial); // initial
             if (has_max) section.emit_u32v(imp.maximum); // maximum
           } else if (imp.kind == kExternalTag) {
-            section.emit_u32v(kTagAttribute);
+            section.emit_u32v(kExceptionAttribute);
             section.emit_u32v(imp.type);
           } else {
             throw new Error("unknown/unsupported import kind " + imp.kind);
@@ -1249,7 +1295,7 @@ class WasmModuleBuilder {
       binary.emit_section(kTagSectionCode, section => {
         section.emit_u32v(wasm.tags.length);
         for (let type of wasm.tags) {
-          section.emit_u32v(kTagAttribute);
+          section.emit_u32v(kExceptionAttribute);
           section.emit_u32v(type);
         }
       });
diff --git a/test/legacy/exceptions/core/rethrow.wast b/test/legacy/exceptions/core/rethrow.wast
new file mode 100644
index 0000000000..e41d94b2bb
--- /dev/null
+++ b/test/legacy/exceptions/core/rethrow.wast
@@ -0,0 +1,96 @@
+;; Test rethrow instruction.
+
+(module
+  (tag $e0)
+  (tag $e1)
+
+  (func (export "catch-rethrow-0")
+    (try
+      (do (throw $e0))
+      (catch $e0 (rethrow 0))
+    )
+  )
+
+  (func (export "catch-rethrow-1") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $e0))
+      (catch $e0
+        (if (i32.eqz (local.get 0)) (then (rethrow 1))) (i32.const 23)
+      )
+    )
+  )
+
+  (func (export "catchall-rethrow-0")
+    (try
+      (do (throw $e0))
+      (catch_all (rethrow 0))
+    )
+  )
+
+  (func (export "catchall-rethrow-1") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $e0))
+      (catch_all
+        (if (i32.eqz (local.get 0)) (then (rethrow 1))) (i32.const 23)
+      )
+    )
+  )
+
+  (func (export "rethrow-nested") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $e1))
+      (catch $e1
+        (try (result i32)
+          (do (throw $e0))
+          (catch $e0
+            (if (i32.eq (local.get 0) (i32.const 0)) (then (rethrow 1)))
+            (if (i32.eq (local.get 0) (i32.const 1)) (then (rethrow 2)))
+            (i32.const 23)
+          )
+        )
+      )
+    )
+  )
+
+  (func (export "rethrow-recatch") (param i32) (result i32)
+    (try (result i32)
+      (do (throw $e0))
+      (catch $e0
+        (try (result i32)
+         (do (if (i32.eqz (local.get 0)) (then (rethrow 2))) (i32.const 42))
+         (catch $e0 (i32.const 23))
+        )
+      )
+    )
+  )
+
+  (func (export "rethrow-stack-polymorphism")
+    (try
+      (do (throw $e0))
+      (catch $e0 (i32.const 1) (rethrow 0))
+    )
+  )
+)
+
+(assert_exception (invoke "catch-rethrow-0"))
+
+(assert_exception (invoke "catch-rethrow-1" (i32.const 0)))
+(assert_return (invoke "catch-rethrow-1" (i32.const 1)) (i32.const 23))
+
+(assert_exception (invoke "catchall-rethrow-0"))
+
+(assert_exception (invoke "catchall-rethrow-1" (i32.const 0)))
+(assert_return (invoke "catchall-rethrow-1" (i32.const 1)) (i32.const 23))
+(assert_exception (invoke "rethrow-nested" (i32.const 0)))
+(assert_exception (invoke "rethrow-nested" (i32.const 1)))
+(assert_return (invoke "rethrow-nested" (i32.const 2)) (i32.const 23))
+
+(assert_return (invoke "rethrow-recatch" (i32.const 0)) (i32.const 23))
+(assert_return (invoke "rethrow-recatch" (i32.const 1)) (i32.const 42))
+
+(assert_exception (invoke "rethrow-stack-polymorphism"))
+
+(assert_invalid (module (func (rethrow 0))) "invalid rethrow label")
+(assert_invalid (module (func (block (rethrow 0)))) "invalid rethrow label")
+(assert_invalid (module (func (try (do (rethrow 0)) (delegate 0))))
+                "invalid rethrow label")
diff --git a/test/legacy/exceptions/core/run.py b/test/legacy/exceptions/core/run.py
new file mode 100755
index 0000000000..b2f6c314b3
--- /dev/null
+++ b/test/legacy/exceptions/core/run.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+
+from __future__ import print_function
+import argparse
+import os
+import os.path
+import unittest
+import subprocess
+import glob
+import sys
+
+
+ownDir = os.path.dirname(os.path.abspath(sys.argv[0]))
+inputDir = ownDir
+outputDir = os.path.join(inputDir, "_output")
+
+parser = argparse.ArgumentParser()
+parser.add_argument("--wasm", metavar="", default=os.path.join(os.getcwd(), "wasm"))
+parser.add_argument("--js", metavar="")
+parser.add_argument("--generate-js-only", action='store_true')
+parser.add_argument("--out", metavar="", default=outputDir)
+parser.add_argument("file", nargs='*')
+arguments = parser.parse_args()
+sys.argv = sys.argv[:1]
+
+exceptions_test_files = glob.glob(os.path.join(inputDir, "*.wast"))
+
+wasmCommand = arguments.wasm
+jsCommand = arguments.js
+generateJsOnly = arguments.generate_js_only
+outputDir = arguments.out
+inputFiles = arguments.file if arguments.file else exceptions_test_files
+
+if not os.path.exists(wasmCommand):
+  sys.stderr.write("""\
+Error: The executable '%s' does not exist.
+Provide the correct path with the '--wasm' flag.
+
+""" % (wasmCommand))
+  parser.print_help()
+  sys.exit(1)
+
+
+class RunTests(unittest.TestCase):
+  def _runCommand(self, command, logPath, expectedExitCode = 0):
+    with open(logPath, 'w+') as out:
+      exitCode = subprocess.call(command, shell=True, stdout=out, stderr=subprocess.STDOUT)
+      self.assertEqual(expectedExitCode, exitCode, "failed with exit code %i (expected %i) for %s" % (exitCode, expectedExitCode, command))
+
+  def _auxFile(self, path):
+    if os.path.exists(path):
+      os.remove(path)
+    return path
+
+  def _compareFile(self, expectFile, actualFile):
+    if os.path.exists(expectFile):
+      with open(expectFile) as expect:
+        with open(actualFile) as actual:
+          expectText = expect.read()
+          actualText = actual.read()
+          self.assertEqual(expectText, actualText)
+
+  def _runTestFile(self, inputPath):
+    dir, inputFile = os.path.split(inputPath)
+    outputPath = os.path.join(outputDir, inputFile)
+
+    # Generate JS first, then return early if we are only generating JS.
+    jsPath = self._auxFile(outputPath.replace(".wast", ".js"))
+    logPath = self._auxFile(jsPath + ".log")
+    self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, inputPath, jsPath), logPath)
+
+    if generateJsOnly:
+      return
+
+    # Run original file
+    expectedExitCode = 1 if ".fail." in inputFile else 0
+    logPath = self._auxFile(outputPath + ".log")
+    self._runCommand(('%s "%s"') % (wasmCommand, inputPath), logPath, expectedExitCode)
+
+    if expectedExitCode != 0:
+      return
+
+    # Convert to binary and run again
+    wasmPath = self._auxFile(outputPath + ".bin.wast")
+    logPath = self._auxFile(wasmPath + ".log")
+    self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, inputPath, wasmPath), logPath)
+    self._runCommand(('%s "%s"') % (wasmCommand, wasmPath), logPath)
+
+    # Convert back to text and run again
+    wastPath = self._auxFile(wasmPath + ".wast")
+    logPath = self._auxFile(wastPath + ".log")
+    self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, wasmPath, wastPath), logPath)
+    self._runCommand(('%s "%s"') % (wasmCommand, wastPath), logPath)
+
+    # Convert back to binary once more and compare
+    wasm2Path = self._auxFile(wastPath + ".bin.wast")
+    logPath = self._auxFile(wasm2Path + ".log")
+    self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, wastPath, wasm2Path), logPath)
+    self._compareFile(wasmPath, wasm2Path)
+
+    # Convert back to text once more and compare
+    wast2Path = self._auxFile(wasm2Path + ".wast")
+    logPath = self._auxFile(wast2Path + ".log")
+    self._runCommand(('%s -d "%s" -o "%s"') % (wasmCommand, wasm2Path, wast2Path), logPath)
+    self._compareFile(wastPath, wast2Path)
+
+    if jsCommand != None:
+      self._runCommand(('%s "%s"') % (jsCommand, jsPath), logPath)
+
+
+if __name__ == "__main__":
+  if not os.path.exists(outputDir):
+    os.makedirs(outputDir)
+  for fileName in inputFiles:
+    testName = 'test ' + os.path.basename(fileName)
+    setattr(RunTests, testName, lambda self, file=fileName: self._runTestFile(file))
+  unittest.main()
diff --git a/test/legacy/exceptions/core/throw.wast b/test/legacy/exceptions/core/throw.wast
new file mode 100644
index 0000000000..d53b5b5500
--- /dev/null
+++ b/test/legacy/exceptions/core/throw.wast
@@ -0,0 +1,51 @@
+;; Test throw instruction.
+
+(module
+  (tag $e0)
+  (tag $e-i32 (param i32))
+  (tag $e-f32 (param f32))
+  (tag $e-i64 (param i64))
+  (tag $e-f64 (param f64))
+  (tag $e-i32-i32 (param i32 i32))
+
+  (func $throw-if (export "throw-if") (param i32) (result i32)
+    (local.get 0)
+    (i32.const 0) (if (i32.ne) (then (throw $e0)))
+    (i32.const 0)
+  )
+
+  (func (export "throw-param-f32") (param f32) (local.get 0) (throw $e-f32))
+
+  (func (export "throw-param-i64") (param i64) (local.get 0) (throw $e-i64))
+
+  (func (export "throw-param-f64") (param f64) (local.get 0) (throw $e-f64))
+
+  (func $throw-1-2 (i32.const 1) (i32.const 2) (throw $e-i32-i32))
+  (func (export "test-throw-1-2")
+    (try
+      (do (call $throw-1-2))
+      (catch $e-i32-i32
+        (i32.const 2)
+        (if (i32.ne) (then (unreachable)))
+        (i32.const 1)
+        (if (i32.ne) (then (unreachable)))
+      )
+    )
+  )
+)
+
+(assert_return (invoke "throw-if" (i32.const 0)) (i32.const 0))
+(assert_exception (invoke "throw-if" (i32.const 10)))
+(assert_exception (invoke "throw-if" (i32.const -1)))
+
+(assert_exception (invoke "throw-param-f32" (f32.const 5.0)))
+(assert_exception (invoke "throw-param-i64" (i64.const 5)))
+(assert_exception (invoke "throw-param-f64" (f64.const 5.0)))
+
+(assert_return (invoke "test-throw-1-2"))
+
+(assert_invalid (module (func (throw 0))) "unknown tag 0")
+(assert_invalid (module (tag (param i32)) (func (throw 0)))
+                "type mismatch: instruction requires [i32] but stack has []")
+(assert_invalid (module (tag (param i32)) (func (i64.const 5) (throw 0)))
+                "type mismatch: instruction requires [i32] but stack has [i64]")
diff --git a/test/legacy/exceptions/core/try_catch.wast b/test/legacy/exceptions/core/try_catch.wast
new file mode 100644
index 0000000000..07399f3a51
--- /dev/null
+++ b/test/legacy/exceptions/core/try_catch.wast
@@ -0,0 +1,276 @@
+;; Test try-catch blocks.
+
+(module
+  (tag $e0 (export "e0"))
+  (func (export "throw") (throw $e0))
+)
+
+(register "test")
+
+(module
+  (tag $imported-e0 (import "test" "e0"))
+  (func $imported-throw (import "test" "throw"))
+  (tag $e0)
+  (tag $e1)
+  (tag $e2)
+  (tag $e-i32 (param i32))
+  (tag $e-f32 (param f32))
+  (tag $e-i64 (param i64))
+  (tag $e-f64 (param f64))
+
+  (func $throw-if (param i32) (result i32)
+    (local.get 0)
+    (i32.const 0) (if (i32.ne) (then (throw $e0)))
+    (i32.const 0)
+  )
+
+  (func (export "empty-catch") (try (do) (catch $e0)))
+
+  (func (export "simple-throw-catch") (param i32) (result i32)
+    (try (result i32)
+      (do (local.get 0) (i32.eqz) (if (then (throw $e0)) (else)) (i32.const 42))
+      (catch $e0 (i32.const 23))
+    )
+  )
+
+  (func (export "unreachable-not-caught") (try (do (unreachable)) (catch_all)))
+
+  (func $div (param i32 i32) (result i32)
+    (local.get 0) (local.get 1) (i32.div_u)
+  )
+  (func (export "trap-in-callee") (param i32 i32) (result i32)
+    (try (result i32)
+      (do (local.get 0) (local.get 1) (call $div))
+      (catch_all (i32.const 11))
+    )
+  )
+
+  (func (export "catch-complex-1") (param i32) (result i32)
+    (try (result i32)
+      (do
+        (try (result i32)
+          (do
+            (local.get 0)
+            (i32.eqz)
+            (if
+              (then (throw $e0))
+              (else
+                (local.get 0)
+                (i32.const 1)
+                (i32.eq)
+                (if (then (throw $e1)) (else (throw $e2)))
+              )
+            )
+            (i32.const 2)
+          )
+          (catch $e0 (i32.const 3))
+        )
+      )
+      (catch $e1 (i32.const 4))
+    )
+  )
+
+  (func (export "catch-complex-2") (param i32) (result i32)
+    (try (result i32)
+      (do
+        (local.get 0)
+        (i32.eqz)
+        (if
+          (then (throw $e0))
+          (else
+            (local.get 0)
+            (i32.const 1)
+            (i32.eq)
+            (if (then (throw $e1)) (else (throw $e2)))
+          )
+        )
+        (i32.const 2)
+      )
+      (catch $e0 (i32.const 3))
+      (catch $e1 (i32.const 4))
+    )
+  )
+
+  (func (export "throw-catch-param-i32") (param i32) (result i32)
+    (try (result i32)
+      (do (local.get 0) (throw $e-i32) (i32.const 2))
+      (catch $e-i32 (return))
+    )
+  )
+
+  (func (export "throw-catch-param-f32") (param f32) (result f32)
+    (try (result f32)
+      (do (local.get 0) (throw $e-f32) (f32.const 0))
+      (catch $e-f32 (return))
+    )
+  )
+
+  (func (export "throw-catch-param-i64") (param i64) (result i64)
+    (try (result i64)
+      (do (local.get 0) (throw $e-i64) (i64.const 2))
+      (catch $e-i64 (return))
+    )
+  )
+
+  (func (export "throw-catch-param-f64") (param f64) (result f64)
+    (try (result f64)
+      (do (local.get 0) (throw $e-f64) (f64.const 0))
+      (catch $e-f64 (return))
+    )
+  )
+
+  (func $throw-param-i32 (param i32) (local.get 0) (throw $e-i32))
+  (func (export "catch-param-i32") (param i32) (result i32)
+    (try (result i32)
+      (do (i32.const 0) (local.get 0) (call $throw-param-i32))
+      (catch $e-i32)
+    )
+  )
+
+  (func (export "catch-imported") (result i32)
+    (try (result i32)
+      (do
+        (i32.const 1)
+        (call $imported-throw)
+      )
+      (catch $imported-e0 (i32.const 2))
+    )
+  )
+
+  (func (export "catchless-try") (param i32) (result i32)
+    (try (result i32)
+      (do
+        (try (result i32)
+          (do (local.get 0) (call $throw-if))
+        )
+      )
+      (catch $e0 (i32.const 1))
+    )
+  )
+
+  (func $throw-void (throw $e0))
+  (func (export "return-call-in-try-catch")
+    (try
+      (do
+        (return_call $throw-void)
+      )
+      (catch $e0)
+    )
+  )
+
+  (table funcref (elem $throw-void))
+  (func (export "return-call-indirect-in-try-catch")
+    (try
+      (do
+        (return_call_indirect (param) (i32.const 0))
+      )
+      (catch $e0)
+    )
+  )
+
+  (func (export "break-try-catch")
+    (try (do (br 0)) (catch $e0))
+  )
+
+  (func (export "break-try-catch_all")
+    (try (do (br 0)) (catch_all))
+  )
+)
+
+(assert_return (invoke "empty-catch"))
+
+(assert_return (invoke "simple-throw-catch" (i32.const 0)) (i32.const 23))
+(assert_return (invoke "simple-throw-catch" (i32.const 1)) (i32.const 42))
+
+(assert_trap (invoke "unreachable-not-caught") "unreachable")
+
+(assert_return (invoke "trap-in-callee" (i32.const 7) (i32.const 2)) (i32.const 3))
+(assert_trap (invoke "trap-in-callee" (i32.const 1) (i32.const 0)) "integer divide by zero")
+
+(assert_return (invoke "catch-complex-1" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "catch-complex-1" (i32.const 1)) (i32.const 4))
+(assert_exception (invoke "catch-complex-1" (i32.const 2)))
+
+(assert_return (invoke "catch-complex-2" (i32.const 0)) (i32.const 3))
+(assert_return (invoke "catch-complex-2" (i32.const 1)) (i32.const 4))
+(assert_exception (invoke "catch-complex-2" (i32.const 2)))
+
+(assert_return (invoke "throw-catch-param-i32" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "throw-catch-param-i32" (i32.const 1)) (i32.const 1))
+(assert_return (invoke "throw-catch-param-i32" (i32.const 10)) (i32.const 10))
+
+(assert_return (invoke "throw-catch-param-f32" (f32.const 5.0)) (f32.const 5.0))
+(assert_return (invoke "throw-catch-param-f32" (f32.const 10.5)) (f32.const 10.5))
+
+(assert_return (invoke "throw-catch-param-i64" (i64.const 5)) (i64.const 5))
+(assert_return (invoke "throw-catch-param-i64" (i64.const 0)) (i64.const 0))
+(assert_return (invoke "throw-catch-param-i64" (i64.const -1)) (i64.const -1))
+
+(assert_return (invoke "throw-catch-param-f64" (f64.const 5.0)) (f64.const 5.0))
+(assert_return (invoke "throw-catch-param-f64" (f64.const 10.5)) (f64.const 10.5))
+
+(assert_return (invoke "catch-param-i32" (i32.const 5)) (i32.const 5))
+
+(assert_return (invoke "catch-imported") (i32.const 2))
+
+(assert_return (invoke "catchless-try" (i32.const 0)) (i32.const 0))
+(assert_return (invoke "catchless-try" (i32.const 1)) (i32.const 1))
+
+(assert_exception (invoke "return-call-in-try-catch"))
+(assert_exception (invoke "return-call-indirect-in-try-catch"))
+
+(assert_return (invoke "break-try-catch"))
+(assert_return (invoke "break-try-catch_all"))
+
+(module
+  (func $imported-throw (import "test" "throw"))
+  (tag $e0)
+
+  (func (export "imported-mismatch") (result i32)
+    (try (result i32)
+      (do
+        (try (result i32)
+          (do
+            (i32.const 1)
+            (call $imported-throw)
+          )
+          (catch $e0 (i32.const 2))
+        )
+      )
+      (catch_all (i32.const 3))
+    )
+  )
+)
+
+(assert_return (invoke "imported-mismatch") (i32.const 3))
+
+(assert_malformed
+  (module quote "(module (func (catch_all)))")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(module (tag $e) (func (catch $e)))")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote
+    "(module (func (try (do) (catch_all) (catch_all))))"
+  )
+  "unexpected token"
+)
+
+(assert_invalid (module (func (result i32) (try (result i32) (do))))
+                "type mismatch: instruction requires [i32] but stack has []")
+(assert_invalid (module (func (result i32) (try (result i32) (do (i64.const 42)))))
+                "type mismatch: instruction requires [i32] but stack has [i64]")
+(assert_invalid (module (tag) (func (try (do) (catch 0 (i32.const 42)))))
+                "type mismatch: block requires [] but stack has [i32]")
+(assert_invalid (module
+                  (tag (param i64))
+                  (func (result i32)
+                    (try (result i32) (do (i32.const 42)) (catch 0))))
+                "type mismatch: instruction requires [i32] but stack has [i64]")
+(assert_invalid (module (func (try (do) (catch_all (i32.const 42)))))
+                "type mismatch: block requires [] but stack has [i32]")
diff --git a/test/legacy/exceptions/core/try_delegate.wast b/test/legacy/exceptions/core/try_delegate.wast
new file mode 100644
index 0000000000..39ee09a2b1
--- /dev/null
+++ b/test/legacy/exceptions/core/try_delegate.wast
@@ -0,0 +1,244 @@
+;; Test try-delegate blocks.
+
+(module
+  (tag $e0)
+  (tag $e1)
+
+  (func (export "delegate-no-throw") (result i32)
+    (try $t (result i32)
+      (do (try (result i32) (do (i32.const 1)) (delegate $t)))
+      (catch $e0 (i32.const 2))
+    )
+  )
+
+  (func $throw-if (param i32)
+    (local.get 0)
+    (if (then (throw $e0)) (else))
+  )
+
+  (func (export "delegate-throw") (param i32) (result i32)
+    (try $t (result i32)
+      (do
+        (try (result i32)
+          (do (local.get 0) (call $throw-if) (i32.const 1))
+          (delegate $t)
+        )
+      )
+      (catch $e0 (i32.const 2))
+    )
+  )
+
+  (func (export "delegate-skip") (result i32)
+    (try $t (result i32)
+      (do
+        (try (result i32)
+          (do
+            (try (result i32)
+              (do (throw $e0) (i32.const 1))
+              (delegate $t)
+            )
+          )
+          (catch $e0 (i32.const 2))
+        )
+      )
+      (catch $e0 (i32.const 3))
+    )
+  )
+
+  (func (export "delegate-to-block") (result i32)
+    (try (result i32)
+      (do (block (try (do (throw $e0)) (delegate 0)))
+          (i32.const 0))
+      (catch_all (i32.const 1)))
+  )
+
+  (func (export "delegate-to-catch") (result i32)
+    (try (result i32)
+      (do (try
+            (do (throw $e0))
+            (catch $e0
+              (try (do (rethrow 1)) (delegate 0))))
+          (i32.const 0))
+      (catch_all (i32.const 1)))
+  )
+
+  (func (export "delegate-to-caller-trivial")
+    (try
+      (do (throw $e0))
+      (delegate 0)))
+
+  (func (export "delegate-to-caller-skipping")
+    (try (do (try (do (throw $e0)) (delegate 1))) (catch_all))
+  )
+
+  (func $select-tag (param i32)
+    (block (block (block (local.get 0) (br_table 0 1 2)) (return)) (throw $e0))
+    (throw $e1)
+  )
+
+  (func (export "delegate-merge") (param i32 i32) (result i32)
+    (try $t (result i32)
+      (do
+        (local.get 0)
+        (call $select-tag)
+        (try
+          (result i32)
+          (do (local.get 1) (call $select-tag) (i32.const 1))
+          (delegate $t)
+        )
+      )
+      (catch $e0 (i32.const 2))
+    )
+  )
+
+  (func (export "delegate-throw-no-catch") (result i32)
+    (try (result i32)
+      (do (try (result i32) (do (throw $e0) (i32.const 1)) (delegate 0)))
+      (catch $e1 (i32.const 2))
+    )
+  )
+
+  (func (export "delegate-correct-targets") (result i32)
+    (try (result i32)
+      (do (try $l3
+            (do (try $l2
+                  (do (try $l1
+                        (do (try $l0
+                              (do (try
+                                    (do (throw $e0))
+                                    (delegate $l1)))
+                              (catch_all unreachable)))
+                        (delegate $l3)))
+                  (catch_all unreachable)))
+            (catch_all (try
+                         (do (throw $e0))
+                         (delegate $l3))))
+          unreachable)
+      (catch_all (i32.const 1))))
+
+  (func $throw-void (throw $e0))
+  (func (export "return-call-in-try-delegate")
+    (try $l
+      (do
+        (try
+          (do
+            (return_call $throw-void)
+          )
+          (delegate $l)
+        )
+      )
+      (catch $e0)
+    )
+  )
+
+  (table funcref (elem $throw-void))
+  (func (export "return-call-indirect-in-try-delegate")
+    (try $l
+      (do
+        (try
+          (do
+            (return_call_indirect (param) (i32.const 0))
+          )
+          (delegate $l)
+        )
+      )
+      (catch $e0)
+    )
+  )
+
+  (func (export "break-try-delegate")
+    (try (do (br 0)) (delegate 0))
+  )
+
+  (func (export "break-and-call-throw") (result i32)
+    (try $outer (result i32)
+      (do
+        (try (result i32)
+          (do
+            (block $a
+              (try (do (br $a)) (delegate $outer))
+            )
+            (call $throw-void)
+            (i32.const 0)
+          )
+          (catch $e0 (i32.const 1))
+        )
+      )
+      (catch $e0 (i32.const 2))
+    )
+  )
+
+  (func (export "break-and-throw") (result i32)
+    (try $outer (result i32)
+      (do
+        (try (result i32)
+          (do
+            (block $a
+              (try (do (br $a)) (delegate $outer))
+            )
+            (throw $e0)
+            (i32.const 0)
+          )
+          (catch $e0 (i32.const 1))
+        )
+      )
+      (catch $e0 (i32.const 2))
+    )
+  )
+)
+
+(assert_return (invoke "delegate-no-throw") (i32.const 1))
+
+(assert_return (invoke "delegate-throw" (i32.const 0)) (i32.const 1))
+(assert_return (invoke "delegate-throw" (i32.const 1)) (i32.const 2))
+
+(assert_exception (invoke "delegate-throw-no-catch"))
+
+(assert_return (invoke "delegate-merge" (i32.const 1) (i32.const 0)) (i32.const 2))
+(assert_exception (invoke "delegate-merge" (i32.const 2) (i32.const 0)))
+(assert_return (invoke "delegate-merge" (i32.const 0) (i32.const 1)) (i32.const 2))
+(assert_exception (invoke "delegate-merge" (i32.const 0) (i32.const 2)))
+(assert_return (invoke "delegate-merge" (i32.const 0) (i32.const 0)) (i32.const 1))
+
+(assert_return (invoke "delegate-skip") (i32.const 3))
+
+(assert_return (invoke "delegate-to-block") (i32.const 1))
+(assert_return (invoke "delegate-to-catch") (i32.const 1))
+
+(assert_exception (invoke "delegate-to-caller-trivial"))
+(assert_exception (invoke "delegate-to-caller-skipping"))
+
+(assert_return (invoke "delegate-correct-targets") (i32.const 1))
+
+(assert_exception (invoke "return-call-in-try-delegate"))
+(assert_exception (invoke "return-call-indirect-in-try-delegate"))
+
+(assert_return (invoke "break-try-delegate"))
+
+(assert_return (invoke "break-and-call-throw") (i32.const 1))
+(assert_return (invoke "break-and-throw") (i32.const 1))
+
+(assert_malformed
+  (module quote "(module (func (delegate 0)))")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(module (tag $e) (func (try (do) (catch $e) (delegate 0))))")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(module (func (try (do) (catch_all) (delegate 0))))")
+  "unexpected token"
+)
+
+(assert_malformed
+  (module quote "(module (func (try (do) (delegate) (delegate 0))))")
+  "unexpected token"
+)
+
+(assert_invalid
+  (module (func (try (do) (delegate 1))))
+  "unknown label"
+)
diff --git a/test/legacy/exceptions/js-api/basic.tentative.any.js b/test/legacy/exceptions/js-api/basic.tentative.any.js
new file mode 100644
index 0000000000..81478529a4
--- /dev/null
+++ b/test/legacy/exceptions/js-api/basic.tentative.any.js
@@ -0,0 +1,120 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+function assert_throws_wasm(fn, message) {
+  try {
+    fn();
+    assert_not_reached(`expected to throw with ${message}`);
+  } catch (e) {
+    assert_true(e instanceof WebAssembly.Exception, `Error should be a WebAssembly.Exception with ${message}`);
+  }
+}
+
+promise_test(async () => {
+  const kSig_v_r = makeSig([kWasmExternRef], []);
+  const builder = new WasmModuleBuilder();
+  const tagIndex = builder.addTag(kSig_v_r);
+  builder.addFunction("throw_param", kSig_v_r)
+    .addBody([
+      kExprLocalGet, 0,
+      kExprThrow, tagIndex,
+    ])
+    .exportFunc();
+  const buffer = builder.toBuffer();
+  const {instance} = await WebAssembly.instantiate(buffer, {});
+  const values = [
+    undefined,
+    null,
+    true,
+    false,
+    "test",
+    Symbol(),
+    0,
+    1,
+    4.2,
+    NaN,
+    Infinity,
+    {},
+    () => {},
+  ];
+  for (const v of values) {
+    assert_throws_wasm(() => instance.exports.throw_param(v), String(v));
+  }
+}, "Wasm function throws argument");
+
+promise_test(async () => {
+  const builder = new WasmModuleBuilder();
+  const tagIndex = builder.addTag(kSig_v_a);
+  builder.addFunction("throw_null", kSig_v_v)
+    .addBody([
+      kExprRefNull, kAnyFuncCode,
+      kExprThrow, tagIndex,
+    ])
+    .exportFunc();
+  const buffer = builder.toBuffer();
+  const {instance} = await WebAssembly.instantiate(buffer, {});
+  assert_throws_wasm(() => instance.exports.throw_null());
+}, "Wasm function throws null");
+
+promise_test(async () => {
+  const builder = new WasmModuleBuilder();
+  const tagIndex = builder.addTag(kSig_v_i);
+  builder.addFunction("throw_int", kSig_v_v)
+    .addBody([
+      ...wasmI32Const(7),
+      kExprThrow, tagIndex,
+    ])
+    .exportFunc();
+  const buffer = builder.toBuffer();
+  const {instance} = await WebAssembly.instantiate(buffer, {});
+  assert_throws_wasm(() => instance.exports.throw_int());
+}, "Wasm function throws integer");
+
+promise_test(async () => {
+  const builder = new WasmModuleBuilder();
+  const fnIndex = builder.addImport("module", "fn", kSig_v_v);
+  const tagIndex = builder.addTag(kSig_v_r);
+  builder.addFunction("catch_exception", kSig_r_v)
+    .addBody([
+      kExprTry, kWasmVoid,
+        kExprCallFunction, fnIndex,
+      kExprCatch, tagIndex,
+        kExprReturn,
+      kExprEnd,
+      kExprRefNull, kExternRefCode,
+    ])
+    .exportFunc();
+
+  const buffer = builder.toBuffer();
+
+  const error = new Error();
+  const fn = () => { throw error };
+  const {instance} = await WebAssembly.instantiate(buffer, {
+    module: { fn }
+  });
+  assert_throws_exactly(error, () => instance.exports.catch_exception());
+}, "Imported JS function throws");
+
+promise_test(async () => {
+  const builder = new WasmModuleBuilder();
+  const fnIndex = builder.addImport("module", "fn", kSig_v_v);
+  builder.addFunction("catch_and_rethrow", kSig_r_v)
+    .addBody([
+      kExprTry, kWasmVoid,
+        kExprCallFunction, fnIndex,
+      kExprCatchAll,
+        kExprRethrow, 0x00,
+      kExprEnd,
+      kExprRefNull, kExternRefCode,
+    ])
+    .exportFunc();
+
+  const buffer = builder.toBuffer();
+
+  const error = new Error();
+  const fn = () => { throw error };
+  const {instance} = await WebAssembly.instantiate(buffer, {
+    module: { fn }
+  });
+  assert_throws_exactly(error, () => instance.exports.catch_and_rethrow());
+}, "Imported JS function throws, Wasm catches and rethrows");
diff --git a/test/legacy/exceptions/js-api/identity.tentative.any.js b/test/legacy/exceptions/js-api/identity.tentative.any.js
new file mode 100644
index 0000000000..36651c7d5b
--- /dev/null
+++ b/test/legacy/exceptions/js-api/identity.tentative.any.js
@@ -0,0 +1,170 @@
+// META: global=window,dedicatedworker,jsshell,shadowrealm
+// META: script=/wasm/jsapi/assertions.js
+// META: script=/wasm/jsapi/wasm-module-builder.js
+
+test(() => {
+  const builder = new WasmModuleBuilder();
+
+  // Tag defined in JavaScript and imported into Wasm
+  const jsTag = new WebAssembly.Tag({ parameters: ["i32"] });
+  const jsTagIndex = builder.addImportedTag("module", "jsTag", kSig_v_i);
+  const jsTagExn = new WebAssembly.Exception(jsTag, [42]);
+  const jsTagExnSamePayload = new WebAssembly.Exception(jsTag, [42]);
+  const jsTagExnDiffPayload = new WebAssembly.Exception(jsTag, [53]);
+  const throwJSTagExnIndex = builder.addImport("module", "throwJSTagExn", kSig_v_v);
+
+  // Tag defined in Wasm and exported to JS
+  const wasmTagIndex = builder.addTag(kSig_v_i);
+  builder.addExportOfKind("wasmTag", kExternalTag, wasmTagIndex);
+  const throwWasmTagExnIndex = builder.addImport("module", "throwWasmTagExn", kSig_v_v);
+  // Will be assigned after an instance is created
+  let wasmTagExn = null;
+  let wasmTagExnSamePayload = null;
+  let wasmTagExnDiffPayload = null;
+
+  const imports = {
+    module: {
+      throwJSTagExn: function() { throw jsTagExn; },
+      throwWasmTagExn: function() { throw wasmTagExn; },
+      jsTag: jsTag
+    }
+  };
+
+  // Call a JS function that throws an exception using a JS-defined tag, catches
+  // it with a 'catch' instruction, and rethrows it.
+  builder
+    .addFunction("catch_js_tag_rethrow", kSig_v_v)
+    .addBody([
+      kExprTry, kWasmVoid,
+        kExprCallFunction, throwJSTagExnIndex,
+      kExprCatch, jsTagIndex,
+        kExprDrop,
+        kExprRethrow, 0x00,
+      kExprEnd
+    ])
+    .exportFunc();
+
+  // Call a JS function that throws an exception using a Wasm-defined tag,
+  // catches it with a 'catch' instruction, and rethrows it.
+  builder
+    .addFunction("catch_wasm_tag_rethrow", kSig_v_v)
+    .addBody([
+      kExprTry, kWasmVoid,
+        kExprCallFunction, throwWasmTagExnIndex,
+      kExprCatch, wasmTagIndex,
+        kExprDrop,
+        kExprRethrow, 0x00,
+      kExprEnd
+    ])
+    .exportFunc();
+
+  // Call a JS function that throws an exception using a JS-defined tag, catches
+  // it with a 'catch_all' instruction, and rethrows it.
+  builder
+    .addFunction("catch_all_js_tag_rethrow", kSig_v_v)
+    .addBody([
+      kExprTry, kWasmVoid,
+        kExprCallFunction, throwJSTagExnIndex,
+      kExprCatchAll,
+        kExprRethrow, 0x00,
+      kExprEnd
+    ])
+    .exportFunc();
+
+  // Call a JS function that throws an exception using a Wasm-defined tag,
+  // catches it with a 'catch_all' instruction, and rethrows it.
+  builder
+    .addFunction("catch_all_wasm_tag_rethrow", kSig_v_v)
+    .addBody([
+      kExprTry, kWasmVoid,
+        kExprCallFunction, throwWasmTagExnIndex,
+      kExprCatchAll,
+        kExprRethrow, 0x00,
+      kExprEnd
+    ])
+    .exportFunc();
+
+  // Call a JS function that throws an exception, catches it with a 'catch'
+  // instruction, and returns its i32 payload.
+  builder
+    .addFunction("catch_js_tag_return_payload", kSig_i_v)
+    .addBody([
+      kExprTry, kWasmI32,
+        kExprCallFunction, throwJSTagExnIndex,
+        kExprI32Const, 0x00,
+      kExprCatch, jsTagIndex,
+        kExprReturn,
+      kExprEnd
+    ])
+    .exportFunc();
+
+  // Call a JS function that throws an exception, catches it with a 'catch'
+  // instruction, and throws a new exception using that payload.
+  builder
+    .addFunction("catch_js_tag_throw_payload", kSig_v_v)
+    .addBody([
+      kExprTry, kWasmVoid,
+        kExprCallFunction, throwJSTagExnIndex,
+      kExprCatch, jsTagIndex,
+        kExprThrow, jsTagIndex,
+      kExprEnd
+    ])
+    .exportFunc();
+
+  const buffer = builder.toBuffer();
+
+  WebAssembly.instantiate(buffer, imports).then(result => {
+    // The exception object's identity should be preserved across 'rethrow's in
+    // Wasm code. Do tests with a tag defined in JS.
+    try {
+      result.instance.exports.catch_js_tag_rethrow();
+    } catch (e) {
+      assert_equals(e, jsTagExn);
+      // Even if they have the same payload, they are different objects, so they
+      // shouldn't compare equal.
+      assert_not_equals(e, jsTagExnSamePayload);
+      assert_not_equals(e, jsTagExnDiffPayload);
+    }
+    try {
+      result.instance.exports.catch_all_js_tag_rethrow();
+    } catch (e) {
+      assert_equals(e, jsTagExn);
+      assert_not_equals(e, jsTagExnSamePayload);
+      assert_not_equals(e, jsTagExnDiffPayload);
+    }
+
+    // Do the same tests with a tag defined in Wasm.
+    const wasmTag = result.instance.exports.wasmTag;
+    wasmTagExn = new WebAssembly.Exception(wasmTag, [42]);
+    wasmTagExnSamePayload = new WebAssembly.Exception(wasmTag, [42]);
+    wasmTagExnDiffPayload = new WebAssembly.Exception(wasmTag, [53]);
+    try {
+      result.instance.exports.catch_wasm_tag_rethrow();
+    } catch (e) {
+      assert_equals(e, wasmTagExn);
+      assert_not_equals(e, wasmTagExnSamePayload);
+      assert_not_equals(e, wasmTagExnDiffPayload);
+    }
+    try {
+      result.instance.exports.catch_all_wasm_tag_rethrow();
+    } catch (e) {
+      assert_equals(e, wasmTagExn);
+      assert_not_equals(e, wasmTagExnSamePayload);
+      assert_not_equals(e, wasmTagExnDiffPayload);
+    }
+
+    // This function catches the exception and returns its i32 payload, which
+    // should match the original payload.
+    assert_equals(result.instance.exports.catch_js_tag_return_payload(), 42);
+
+    // This function catches the exception and throws a new exception using the
+    // its payload. Even if the payload is reused, the exception objects should
+    // not compare equal.
+    try {
+      result.instance.exports.catch_js_tag_throw_payload();
+    } catch (e) {
+      assert_equals(e.getArg(jsTag, 0), 42);
+      assert_not_equals(e, jsTagExn);
+    }
+  });
+}, "Identity check");