binary/wat: Implement EHv4 (#2470)

This pull request implements EHv4. Binary is mostly untested until interp is working.
author: Soni L. <EnderMoneyMod@gmail.com> 2024-11-20 14:51:48 -0300
committer: GitHub <noreply@github.com> 2024-11-20 09:51:48 -0800
commit: a0b7abef00b59eeafed58c774195189425d020b0 (patch)
tree: 6f7b0747d3a3ef435bda9ac14ca22d417877796b
parent: 958d0a72030227bf3133c8b99c7c670bcdbc7636 (diff)
download: wabt-a0b7abef00b59eeafed58c774195189425d020b0.tar.gz
wabt-a0b7abef00b59eeafed58c774195189425d020b0.tar.bz2
wabt-a0b7abef00b59eeafed58c774195189425d020b0.zip
43 files changed, 2011 insertions, 1321 deletions
diff --git a/include/wabt/binary-reader-logging.h b/include/wabt/binary-reader-logging.h
index fd166011..4a031f74 100644
--- a/include/wabt/binary-reader-logging.h
+++ b/include/wabt/binary-reader-logging.h
@@ -232,7 +232,10 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
                      Address alignment_log2,
                      Address offset) override;
   Result OnThrowExpr(Index tag_index) override;
+  Result OnThrowRefExpr() override;
   Result OnTryExpr(Type sig_type) override;
+  Result OnTryTableExpr(Type sig_type,
+                        const CatchClauseVector& catches) override;
   Result OnUnaryExpr(Opcode opcode) override;
   Result OnTernaryExpr(Opcode opcode) override;
   Result OnUnreachableExpr() override;
diff --git a/include/wabt/binary-reader-nop.h b/include/wabt/binary-reader-nop.h
index 85906062..fdb7d14a 100644
--- a/include/wabt/binary-reader-nop.h
+++ b/include/wabt/binary-reader-nop.h
@@ -319,7 +319,12 @@ class BinaryReaderNop : public BinaryReaderDelegate {
     return Result::Ok;
   }
   Result OnThrowExpr(Index depth) override { return Result::Ok; }
+  Result OnThrowRefExpr() override { return Result::Ok; }
   Result OnTryExpr(Type sig_type) override { return Result::Ok; }
+  Result OnTryTableExpr(Type sig_type,
+                        const CatchClauseVector& catches) override {
+    return Result::Ok;
+  }
   Result OnUnaryExpr(Opcode opcode) override { return Result::Ok; }
   Result OnTernaryExpr(Opcode opcode) override { return Result::Ok; }
   Result OnUnreachableExpr() override { return Result::Ok; }
diff --git a/include/wabt/binary-reader.h b/include/wabt/binary-reader.h
index 90161264..94b19c11 100644
--- a/include/wabt/binary-reader.h
+++ b/include/wabt/binary-reader.h
@@ -59,6 +59,13 @@ struct TypeMut {
 };
 using TypeMutVector = std::vector<TypeMut>;
 
+struct CatchClause {
+  CatchKind kind;
+  Index tag;
+  Index depth;
+};
+using CatchClauseVector = std::vector<CatchClause>;
+
 class BinaryReaderDelegate {
  public:
   struct State {
@@ -302,7 +309,10 @@ class BinaryReaderDelegate {
                              Address alignment_log2,
                              Address offset) = 0;
   virtual Result OnThrowExpr(Index tag_index) = 0;
+  virtual Result OnThrowRefExpr() = 0;
   virtual Result OnTryExpr(Type sig_type) = 0;
+  virtual Result OnTryTableExpr(Type sig_type,
+                                const CatchClauseVector& catches) = 0;
 
   virtual Result OnUnaryExpr(Opcode opcode) = 0;
   virtual Result OnTernaryExpr(Opcode opcode) = 0;
diff --git a/include/wabt/common.h b/include/wabt/common.h
index 6962f06d..e1411b48 100644
--- a/include/wabt/common.h
+++ b/include/wabt/common.h
@@ -194,6 +194,7 @@ enum class LabelType {
   If,
   Else,
   Try,
+  TryTable,
   Catch,
 
   First = Func,
@@ -239,6 +240,13 @@ enum class SegmentKind {
   Declared,
 };
 
+enum class CatchKind {
+  Catch,
+  CatchRef,
+  CatchAll,
+  CatchAllRef,
+};
+
 // Used in test asserts for special expected values "nan:canonical" and
 // "nan:arithmetic"
 enum class ExpectedNan {
diff --git a/include/wabt/expr-visitor.h b/include/wabt/expr-visitor.h
index cbc317cd..5be78793 100644
--- a/include/wabt/expr-visitor.h
+++ b/include/wabt/expr-visitor.h
@@ -41,6 +41,7 @@ class ExprVisitor {
     IfFalse,
     Loop,
     Try,
+    TryTable,
     Catch,
   };
 
@@ -73,6 +74,8 @@ class ExprVisitor::Delegate {
   virtual Result OnBrExpr(BrExpr*) = 0;
   virtual Result OnBrIfExpr(BrIfExpr*) = 0;
   virtual Result OnBrTableExpr(BrTableExpr*) = 0;
+  virtual Result BeginTryTableExpr(TryTableExpr*) = 0;
+  virtual Result EndTryTableExpr(TryTableExpr*) = 0;
   virtual Result OnCallExpr(CallExpr*) = 0;
   virtual Result OnCallIndirectExpr(CallIndirectExpr*) = 0;
   virtual Result OnCallRefExpr(CallRefExpr*) = 0;
@@ -122,6 +125,7 @@ class ExprVisitor::Delegate {
   virtual Result OnDelegateExpr(TryExpr*) = 0;
   virtual Result EndTryExpr(TryExpr*) = 0;
   virtual Result OnThrowExpr(ThrowExpr*) = 0;
+  virtual Result OnThrowRefExpr(ThrowRefExpr*) = 0;
   virtual Result OnRethrowExpr(RethrowExpr*) = 0;
   virtual Result OnAtomicWaitExpr(AtomicWaitExpr*) = 0;
   virtual Result OnAtomicFenceExpr(AtomicFenceExpr*) = 0;
@@ -147,6 +151,8 @@ class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
   Result OnBrExpr(BrExpr*) override { return Result::Ok; }
   Result OnBrIfExpr(BrIfExpr*) override { return Result::Ok; }
   Result OnBrTableExpr(BrTableExpr*) override { return Result::Ok; }
+  Result BeginTryTableExpr(TryTableExpr*) override { return Result::Ok; }
+  Result EndTryTableExpr(TryTableExpr*) override { return Result::Ok; }
   Result OnCallExpr(CallExpr*) override { return Result::Ok; }
   Result OnCallIndirectExpr(CallIndirectExpr*) override { return Result::Ok; }
   Result OnCallRefExpr(CallRefExpr*) override { return Result::Ok; }
@@ -198,6 +204,7 @@ class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
   Result OnDelegateExpr(TryExpr*) override { return Result::Ok; }
   Result EndTryExpr(TryExpr*) override { return Result::Ok; }
   Result OnThrowExpr(ThrowExpr*) override { return Result::Ok; }
+  Result OnThrowRefExpr(ThrowRefExpr*) override { return Result::Ok; }
   Result OnRethrowExpr(RethrowExpr*) override { return Result::Ok; }
   Result OnAtomicWaitExpr(AtomicWaitExpr*) override { return Result::Ok; }
   Result OnAtomicFenceExpr(AtomicFenceExpr*) override { return Result::Ok; }
diff --git a/include/wabt/ir.h b/include/wabt/ir.h
index e300b66c..25264bcd 100644
--- a/include/wabt/ir.h
+++ b/include/wabt/ir.h
@@ -21,11 +21,11 @@
 #include <cstddef>
 #include <cstdint>
 #include <memory>
+#include <set>
 #include <string>
 #include <string_view>
 #include <type_traits>
 #include <vector>
-#include <set>
 
 #include "wabt/binding-hash.h"
 #include "wabt/common.h"
@@ -422,7 +422,9 @@ enum class ExprType {
   TableFill,
   Ternary,
   Throw,
+  ThrowRef,
   Try,
+  TryTable,
   Unary,
   Unreachable,
 
@@ -460,6 +462,21 @@ struct Catch {
 };
 using CatchVector = std::vector<Catch>;
 
+struct TableCatch {
+  explicit TableCatch(const Location& loc = Location()) : loc(loc) {}
+  Location loc;
+  Var tag;
+  Var target;
+  CatchKind kind;
+  bool IsCatchAll() const {
+    return kind == CatchKind::CatchAll || kind == CatchKind::CatchAllRef;
+  }
+  bool IsRef() const {
+    return kind == CatchKind::CatchRef || kind == CatchKind::CatchAllRef;
+  }
+};
+using TryTableVector = std::vector<TableCatch>;
+
 enum class TryKind { Plain, Catch, Delegate };
 
 class Expr : public intrusive_list_base<Expr> {
@@ -516,6 +533,7 @@ using DropExpr = ExprMixin<ExprType::Drop>;
 using NopExpr = ExprMixin<ExprType::Nop>;
 using ReturnExpr = ExprMixin<ExprType::Return>;
 using UnreachableExpr = ExprMixin<ExprType::Unreachable>;
+using ThrowRefExpr = ExprMixin<ExprType::ThrowRef>;
 
 using MemoryGrowExpr = MemoryExpr<ExprType::MemoryGrow>;
 using MemorySizeExpr = MemoryExpr<ExprType::MemorySize>;
@@ -743,6 +761,15 @@ class IfExpr : public ExprMixin<ExprType::If> {
   Location false_end_loc;
 };
 
+class TryTableExpr : public ExprMixin<ExprType::TryTable> {
+ public:
+  explicit TryTableExpr(const Location& loc = Location())
+      : ExprMixin<ExprType::TryTable>(loc) {}
+
+  Block block;
+  TryTableVector catches;
+};
+
 class TryExpr : public ExprMixin<ExprType::Try> {
  public:
   explicit TryExpr(const Location& loc = Location())
diff --git a/include/wabt/opcode.def b/include/wabt/opcode.def
index bebab458..f8369ea7 100644
--- a/include/wabt/opcode.def
+++ b/include/wabt/opcode.def
@@ -45,6 +45,7 @@ WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x06, Try, "try", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x07, Catch, "catch", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x08, Throw, "throw", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x09, Rethrow, "rethrow", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x0a, ThrowRef, "throw_ref", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x0b, End, "end", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x0c, Br, "br", "")
 WABT_OPCODE(___,  I32,  ___,  ___,  0,  0,    0x0d, BrIf, "br_if", "")
@@ -60,6 +61,7 @@ WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x19, CatchAll, "catch_all", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x1a, Drop, "drop", "")
 WABT_OPCODE(___,  ___,  ___,  I32,  0,  0,    0x1b, Select, "select", "")
 WABT_OPCODE(___,  ___,  ___,  I32,  0,  0,    0x1c, SelectT, "select", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x1f, TryTable, "try_table", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x20, LocalGet, "local.get", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x21, LocalSet, "local.set", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x22, LocalTee, "local.tee", "")
diff --git a/include/wabt/shared-validator.h b/include/wabt/shared-validator.h
index df02b594..fa7f5aba 100644
--- a/include/wabt/shared-validator.h
+++ b/include/wabt/shared-validator.h
@@ -211,7 +211,11 @@ class SharedValidator {
   Result OnTableSize(const Location&, Var table_var);
   Result OnTernary(const Location&, Opcode);
   Result OnThrow(const Location&, Var tag_var);
+  Result OnThrowRef(const Location&);
   Result OnTry(const Location&, Type sig_type);
+  Result BeginTryTable(const Location&, Type sig_type);
+  Result OnTryTableCatch(const Location&, const TableCatch&);
+  Result EndTryTable(const Location&, Type sig_type);
   Result OnUnary(const Location&, Opcode);
   Result OnUnreachable(const Location&);
 
diff --git a/include/wabt/token.def b/include/wabt/token.def
index 53d1fabb..f2f05aec 100644
--- a/include/wabt/token.def
+++ b/include/wabt/token.def
@@ -105,6 +105,8 @@ WABT_TOKEN(CallIndirect, "call_indirect")
 WABT_TOKEN(CallRef, "call_ref")
 WABT_TOKEN(Catch, "catch")
 WABT_TOKEN(CatchAll, "catch_all")
+WABT_TOKEN(CatchRef, "catch_ref")
+WABT_TOKEN(CatchAllRef, "catch_all_ref")
 WABT_TOKEN(Compare, "COMPARE")
 WABT_TOKEN(Const, "CONST")
 WABT_TOKEN(Convert, "CONVERT")
@@ -151,7 +153,9 @@ WABT_TOKEN(TableSet, "table.set")
 WABT_TOKEN(TableSize, "table.size")
 WABT_TOKEN(Ternary, "TERNARY")
 WABT_TOKEN(Throw, "throw")
+WABT_TOKEN(ThrowRef, "throw_ref")
 WABT_TOKEN(Try, "try")
+WABT_TOKEN(TryTable, "try_table")
 WABT_TOKEN(Unary, "UNARY")
 WABT_TOKEN(Unreachable, "unreachable")
 WABT_TOKEN_FIRST(Opcode, AtomicFence)
diff --git a/include/wabt/type-checker.h b/include/wabt/type-checker.h
index 7b3f4192..85575c3c 100644
--- a/include/wabt/type-checker.h
+++ b/include/wabt/type-checker.h
@@ -128,7 +128,12 @@ class TypeChecker {
   Result OnStore(Opcode, const Limits& limits);
   Result OnTernary(Opcode);
   Result OnThrow(const TypeVector& sig);
+  Result OnThrowRef();
   Result OnTry(const TypeVector& param_types, const TypeVector& result_types);
+  Result OnTryTableCatch(const TypeVector& sig, Index);
+  Result BeginTryTable(const TypeVector& param_types);
+  Result EndTryTable(const TypeVector& param_types,
+                     const TypeVector& result_types);
   Result OnUnary(Opcode);
   Result OnUnreachable();
   Result EndFunction();
diff --git a/include/wabt/wast-parser.h b/include/wabt/wast-parser.h
index 8ba71e47..34b73e71 100644
--- a/include/wabt/wast-parser.h
+++ b/include/wabt/wast-parser.h
@@ -203,6 +203,7 @@ class WastParser {
   Result ParseBlock(Block*);
   Result ParseExprList(ExprList*);
   Result ParseExpr(ExprList*);
+  Result ParseTryTableCatches(TryTableVector* catches);
   Result ParseCatchInstrList(CatchVector* catches);
   Result ParseCatchExprList(CatchVector* catches);
   Result ParseGlobalType(Global*);
diff --git a/src/apply-names.cc b/src/apply-names.cc
index 6d531be2..c8516c8c 100644
--- a/src/apply-names.cc
+++ b/src/apply-names.cc
@@ -73,6 +73,8 @@ class NameApplier : public ExprVisitor::DelegateNop {
   Result OnStoreExpr(StoreExpr*) override;
   Result BeginTryExpr(TryExpr*) override;
   Result EndTryExpr(TryExpr*) override;
+  Result BeginTryTableExpr(TryTableExpr*) override;
+  Result EndTryTableExpr(TryTableExpr*) override;
   Result OnCatchExpr(TryExpr*, Catch*) override;
   Result OnDelegateExpr(TryExpr*) override;
   Result OnThrowExpr(ThrowExpr*) override;
@@ -369,6 +371,23 @@ Result NameApplier::EndTryExpr(TryExpr*) {
   return Result::Ok;
 }
 
+Result NameApplier::BeginTryTableExpr(TryTableExpr* expr) {
+  for (TableCatch& catch_ : expr->catches) {
+    if (!catch_.IsCatchAll()) {
+      CHECK_RESULT(UseNameForTagVar(&catch_.tag));
+    }
+    std::string_view label = FindLabelByVar(&catch_.target);
+    UseNameForVar(label, &catch_.target);
+  }
+  PushLabel(expr->block.label);
+  return Result::Ok;
+}
+
+Result NameApplier::EndTryTableExpr(TryTableExpr*) {
+  PopLabel();
+  return Result::Ok;
+}
+
 Result NameApplier::OnCatchExpr(TryExpr*, Catch* expr) {
   if (!expr->IsCatchAll()) {
     CHECK_RESULT(UseNameForTagVar(&expr->var));
diff --git a/src/binary-reader-ir.cc b/src/binary-reader-ir.cc
index 04b2e90b..2029b0f7 100644
--- a/src/binary-reader-ir.cc
+++ b/src/binary-reader-ir.cc
@@ -258,7 +258,10 @@ class BinaryReaderIR : public BinaryReaderNop {
                      Address alignment_log2,
                      Address offset) override;
   Result OnThrowExpr(Index tag_index) override;
+  Result OnThrowRefExpr() override;
   Result OnTryExpr(Type sig_type) override;
+  Result OnTryTableExpr(Type sig_type,
+                        const CatchClauseVector& catches) override;
   Result OnUnaryExpr(Opcode opcode) override;
   Result OnTernaryExpr(Opcode opcode) override;
   Result OnUnreachableExpr() override;
@@ -999,6 +1002,9 @@ Result BinaryReaderIR::OnEndExpr() {
       case LabelType::Try:
         cast<TryExpr>(expr)->block.end_loc = GetLocation();
         break;
+      case LabelType::TryTable:
+        cast<TryTableExpr>(expr)->block.end_loc = GetLocation();
+        break;
 
       case LabelType::InitExpr:
       case LabelType::Func:
@@ -1195,6 +1201,11 @@ Result BinaryReaderIR::OnThrowExpr(Index tag_index) {
   return AppendExpr(std::make_unique<ThrowExpr>(Var(tag_index, GetLocation())));
 }
 
+Result BinaryReaderIR::OnThrowRefExpr() {
+  module_->features_used.exceptions = true;
+  return AppendExpr(std::make_unique<ThrowRefExpr>());
+}
+
 Result BinaryReaderIR::OnLocalTeeExpr(Index local_index) {
   return AppendExpr(
       std::make_unique<LocalTeeExpr>(Var(local_index, GetLocation())));
@@ -1248,6 +1259,27 @@ Result BinaryReaderIR::OnCatchAllExpr() {
   return AppendCatch(Catch(GetLocation()));
 }
 
+Result BinaryReaderIR::OnTryTableExpr(Type sig_type,
+                                      const CatchClauseVector& catches) {
+  auto expr_ptr = std::make_unique<TryTableExpr>();
+  TryTableExpr* expr = expr_ptr.get();
+  expr->catches.reserve(catches.size());
+  SetBlockDeclaration(&expr->block.decl, sig_type);
+  ExprList* expr_list = &expr->block.exprs;
+
+  for (auto& raw_catch : catches) {
+    TableCatch catch_;
+    catch_.kind = raw_catch.kind;
+    catch_.tag = Var(raw_catch.tag, GetLocation());
+    catch_.target = Var(raw_catch.depth, GetLocation());
+    expr->catches.push_back(std::move(catch_));
+  }
+
+  CHECK_RESULT(AppendExpr(std::move(expr_ptr)));
+  module_->features_used.exceptions = true;
+  return PushLabel(LabelType::TryTable, expr_list, expr);
+}
+
 Result BinaryReaderIR::OnDelegateExpr(Index depth) {
   LabelNode* label = nullptr;
   CHECK_RESULT(TopLabel(&label));
diff --git a/src/binary-reader-logging.cc b/src/binary-reader-logging.cc
index 0c3fcda6..0c136225 100644
--- a/src/binary-reader-logging.cc
+++ b/src/binary-reader-logging.cc
@@ -394,6 +394,39 @@ Result BinaryReaderLogging::OnTryExpr(Type sig_type) {
   return reader_->OnTryExpr(sig_type);
 }
 
+Result BinaryReaderLogging::OnTryTableExpr(Type sig_type,
+                                           const CatchClauseVector& catches) {
+  LOGF("OnTryTableExpr(sig: ");
+  LogType(sig_type);
+  Index count = catches.size();
+  LOGF_NOINDENT(", n: %" PRIindex ", catches: [", count);
+
+  for (auto& catch_ : catches) {
+    auto tag = catch_.tag;
+    auto depth = catch_.depth;
+    switch (catch_.kind) {
+      case CatchKind::Catch:
+        LOGF_NOINDENT("catch %" PRIindex " %" PRIindex, tag, depth);
+        break;
+      case CatchKind::CatchRef:
+        LOGF_NOINDENT("catch_ref %" PRIindex " %" PRIindex, tag, depth);
+        break;
+      case CatchKind::CatchAll:
+        LOGF_NOINDENT("catch_all %" PRIindex, depth);
+        break;
+      case CatchKind::CatchAllRef:
+        LOGF_NOINDENT("catch_all_ref %" PRIindex, depth);
+        break;
+    }
+    if (--count != 0) {
+      LOGF_NOINDENT(", ");
+    }
+  }
+  LOGF_NOINDENT("])\n");
+
+  return reader_->OnTryTableExpr(sig_type, catches);
+}
+
 Result BinaryReaderLogging::OnSimdLaneOpExpr(Opcode opcode, uint64_t value) {
   LOGF("OnSimdLaneOpExpr (lane: %" PRIu64 ")\n", value);
   return reader_->OnSimdLaneOpExpr(opcode, value);
@@ -852,6 +885,7 @@ DEFINE_LOAD_STORE_OPCODE(OnLoadZeroExpr);
 DEFINE_LOAD_STORE_OPCODE(OnStoreExpr);
 DEFINE_INDEX_DESC(OnThrowExpr, "tag_index")
 DEFINE0(OnUnreachableExpr)
+DEFINE0(OnThrowRefExpr)
 DEFINE_OPCODE(OnUnaryExpr)
 DEFINE_OPCODE(OnTernaryExpr)
 DEFINE_SIMD_LOAD_STORE_LANE_OPCODE(OnSimdLoadLaneExpr);
diff --git a/src/binary-reader-objdump.cc b/src/binary-reader-objdump.cc
index 52e6d27a..80850541 100644
--- a/src/binary-reader-objdump.cc
+++ b/src/binary-reader-objdump.cc
@@ -548,6 +548,8 @@ class BinaryReaderObjdumpDisassemble : public BinaryReaderObjdumpBase {
   Result OnOpcodeBlockSig(Type sig_type) override;
   Result OnOpcodeType(Type type) override;
 
+  Result OnTryTableExpr(Type sig_type,
+                        const CatchClauseVector& catches) override;
   Result OnBrTableExpr(Index num_targets,
                        Index* target_depths,
                        Index default_target_depth) override;
@@ -903,6 +905,50 @@ Result BinaryReaderObjdumpDisassemble::OnOpcodeType(Type type) {
   return Result::Ok;
 }
 
+Result BinaryReaderObjdumpDisassemble::OnTryTableExpr(
+    Type sig_type,
+    const CatchClauseVector& catches) {
+  if (!in_function_body) {
+    return Result::Ok;
+  }
+
+  std::string buffer = std::string();
+
+  if (sig_type != Type::Void) {
+    buffer.append(BlockSigToString(sig_type).c_str()).append(" ");
+  }
+
+  for (auto& catch_ : catches) {
+    switch (catch_.kind) {
+      case CatchKind::Catch:
+        buffer.append("catch ");
+        break;
+      case CatchKind::CatchRef:
+        buffer.append("catch_ref ");
+        break;
+      case CatchKind::CatchAll:
+        buffer.append("catch_all ");
+        break;
+      case CatchKind::CatchAllRef:
+        buffer.append("catch_all_ref ");
+        break;
+    }
+    if (catch_.kind == CatchKind::Catch || catch_.kind == CatchKind::CatchRef) {
+      buffer.append(std::to_string(catch_.tag));
+    }
+    buffer.append(" ").append(std::to_string(catch_.depth)).append(" ");
+  }
+
+  if (!buffer.empty()) {
+    // remove trailing space
+    buffer.pop_back();
+  }
+
+  LogOpcode("%s", buffer.c_str());
+  indent_level++;
+  return Result::Ok;
+}
+
 Result BinaryReaderObjdumpDisassemble::OnBrTableExpr(
     Index num_targets,
     Index* target_depths,
diff --git a/src/binary-reader.cc b/src/binary-reader.cc
index 18b57e05..7b0b4187 100644
--- a/src/binary-reader.cc
+++ b/src/binary-reader.cc
@@ -192,6 +192,7 @@ class BinaryReader {
   TypeVector result_types_;
   TypeMutVector fields_;
   std::vector<Index> target_depths_;
+  CatchClauseVector catches_;
   const ReadBinaryOptions& options_;
   BinarySection last_known_section_ = BinarySection::Invalid;
   bool did_read_names_section_ = false;
@@ -1524,6 +1525,38 @@ Result BinaryReader::ReadInstructions(Offset end_offset, const char* context) {
         break;
       }
 
+      case Opcode::TryTable: {
+        nested_blocks.push(opcode);
+        Type sig_type;
+        CHECK_RESULT(ReadType(&sig_type, "try_table signature type"));
+        ERROR_UNLESS(IsBlockType(sig_type),
+                     "expected valid block signature type");
+        Index count;
+        CHECK_RESULT(ReadCount(&count, "catch count"));
+
+        catches_.resize(count);
+        for (Index i = 0; i < count; i++) {
+          uint8_t handler;
+          CHECK_RESULT(ReadU8(&handler, "catch handler"));
+          ERROR_UNLESS(handler < 4, "expected valid catch handler");
+          bool is_catch_all = handler & 2;
+          Index tag = kInvalidIndex;
+          if (!(is_catch_all)) {
+            CHECK_RESULT(ReadIndex(&tag, "catch tag"));
+          }
+          Index depth;
+          CHECK_RESULT(ReadIndex(&depth, "catch depth"));
+          CatchClause catch_;
+          catch_.kind = CatchKind(handler);
+          catch_.tag = tag;
+          catch_.depth = depth;
+          catches_[i] = catch_;
+        }
+
+        CALLBACK(OnTryTableExpr, sig_type, catches_);
+        break;
+      }
+
       case Opcode::Catch: {
         Index index;
         CHECK_RESULT(ReadIndex(&index, "tag index"));
@@ -1565,6 +1598,12 @@ Result BinaryReader::ReadInstructions(Offset end_offset, const char* context) {
         break;
       }
 
+      case Opcode::ThrowRef: {
+        CALLBACK(OnThrowRefExpr);
+        CALLBACK(OnOpcodeBare);
+        break;
+      }
+
       case Opcode::I32Extend8S:
       case Opcode::I32Extend16S:
       case Opcode::I64Extend8S:
diff --git a/src/binary-writer.cc b/src/binary-writer.cc
index 60863d62..600154b9 100644
--- a/src/binary-writer.cc
+++ b/src/binary-writer.cc
@@ -1050,6 +1050,9 @@ void BinaryWriter::WriteExpr(const Func* func, const Expr* expr) {
       WriteU32Leb128(stream_, GetTagVarDepth(&cast<ThrowExpr>(expr)->var),
                      "throw tag");
       break;
+    case ExprType::ThrowRef:
+      WriteOpcode(stream_, Opcode::ThrowRef);
+      break;
     case ExprType::Try: {
       auto* try_expr = cast<TryExpr>(expr);
       WriteOpcode(stream_, Opcode::Try);
@@ -1079,6 +1082,26 @@ void BinaryWriter::WriteExpr(const Func* func, const Expr* expr) {
       }
       break;
     }
+    case ExprType::TryTable: {
+      auto* try_table_expr = cast<TryTableExpr>(expr);
+      WriteOpcode(stream_, Opcode::TryTable);
+      WriteBlockDecl(try_table_expr->block.decl);
+      WriteU32Leb128(stream_, try_table_expr->catches.size(), "num catches");
+      for (const TableCatch& catch_ : try_table_expr->catches) {
+        uint8_t catch_type =
+            (catch_.IsCatchAll() ? 2 : 0) | (catch_.IsRef() ? 1 : 0);
+        stream_->WriteU8(catch_type, "catch handler");
+        if (!catch_.IsCatchAll()) {
+          Index tag = GetTagVarDepth(&catch_.tag);
+          WriteU32Leb128(stream_, tag, "catch tag");
+        }
+        Index depth = GetLabelVarDepth(&catch_.target);
+        WriteU32Leb128(stream_, depth, "catch depth");
+      }
+      WriteExprList(func, try_table_expr->block.exprs);
+      WriteOpcode(stream_, Opcode::End);
+      break;
+    }
     case ExprType::Unary:
       WriteOpcode(stream_, cast<UnaryExpr>(expr)->opcode);
       break;
diff --git a/src/c-writer.cc b/src/c-writer.cc
index 76ff52f9..7a0c548b 100644
--- a/src/c-writer.cc
+++ b/src/c-writer.cc
@@ -4129,6 +4129,8 @@ void CWriter::Write(const ExprList& exprs) {
       case ExprType::AtomicWait:
       case ExprType::AtomicNotify:
       case ExprType::CallRef:
+      case ExprType::ThrowRef:
+      case ExprType::TryTable:
         UNIMPLEMENTED("...");
         break;
     }
diff --git a/src/expr-visitor.cc b/src/expr-visitor.cc
index 05cd2798..217d45cc 100644
--- a/src/expr-visitor.cc
+++ b/src/expr-visitor.cc
@@ -90,6 +90,18 @@ Result ExprVisitor::VisitExpr(Expr* root_expr) {
         break;
       }
 
+      case State::TryTable: {
+        auto try_table_expr = cast<TryTableExpr>(expr);
+        auto& iter = expr_iter_stack_.back();
+        if (iter != try_table_expr->block.exprs.end()) {
+          PushDefault(&*iter++);
+        } else {
+          CHECK_RESULT(delegate_->EndTryTableExpr(try_table_expr));
+          PopExprlist();
+        }
+        break;
+      }
+
       case State::Try: {
         auto try_expr = cast<TryExpr>(expr);
         auto& iter = expr_iter_stack_.back();
@@ -386,6 +398,17 @@ Result ExprVisitor::HandleDefaultState(Expr* expr) {
       CHECK_RESULT(delegate_->OnThrowExpr(cast<ThrowExpr>(expr)));
       break;
 
+    case ExprType::ThrowRef:
+      CHECK_RESULT(delegate_->OnThrowRefExpr(cast<ThrowRefExpr>(expr)));
+      break;
+
+    case ExprType::TryTable: {
+      auto try_table_expr = cast<TryTableExpr>(expr);
+      CHECK_RESULT(delegate_->BeginTryTableExpr(try_table_expr));
+      PushExprlist(State::TryTable, expr, try_table_expr->block.exprs);
+      break;
+    }
+
     case ExprType::Try: {
       auto try_expr = cast<TryExpr>(expr);
       CHECK_RESULT(delegate_->BeginTryExpr(try_expr));
diff --git a/src/generate-names.cc b/src/generate-names.cc
index ec3612d7..d029db84 100644
--- a/src/generate-names.cc
+++ b/src/generate-names.cc
@@ -38,6 +38,7 @@ class NameGenerator : public ExprVisitor::DelegateNop {
   // Implementation of ExprVisitor::DelegateNop.
   Result BeginBlockExpr(BlockExpr* expr) override;
   Result BeginTryExpr(TryExpr* expr) override;
+  Result BeginTryTableExpr(TryTableExpr* expr) override;
   Result BeginLoopExpr(LoopExpr* expr) override;
   Result BeginIfExpr(IfExpr* expr) override;
 
@@ -218,6 +219,11 @@ Result NameGenerator::BeginTryExpr(TryExpr* expr) {
   return Result::Ok;
 }
 
+Result NameGenerator::BeginTryTableExpr(TryTableExpr* expr) {
+  MaybeGenerateName("T", label_count_++, &expr->block.label);
+  return Result::Ok;
+}
+
 Result NameGenerator::BeginLoopExpr(LoopExpr* expr) {
   MaybeGenerateName("L", label_count_++, &expr->block.label);
   return Result::Ok;
diff --git a/src/interp/interp.cc b/src/interp/interp.cc
index f93fa5a6..800d81f3 100644
--- a/src/interp/interp.cc
+++ b/src/interp/interp.cc
@@ -1978,6 +1978,8 @@ RunResult Thread::StepInternal(Trap::Ptr* out_trap) {
     case O::Delegate:
     case O::InterpData:
     case O::Invalid:
+    case O::TryTable:
+    case O::ThrowRef:
       WABT_UNREACHABLE;
       break;
   }
diff --git a/src/interp/istream.cc b/src/interp/istream.cc
index 8e5cb5a3..25627ba2 100644
--- a/src/interp/istream.cc
+++ b/src/interp/istream.cc
@@ -794,6 +794,8 @@ Instr Istream::Read(Offset* offset) const {
     case Opcode::Loop:
     case Opcode::Try:
     case Opcode::ReturnCall:
+    case Opcode::TryTable:
+    case Opcode::ThrowRef:
       // Not used.
       break;
   }
diff --git a/src/ir-util.cc b/src/ir-util.cc
index ee9262cc..5266a264 100644
--- a/src/ir-util.cc
+++ b/src/ir-util.cc
@@ -223,9 +223,16 @@ ModuleContext::Arities ModuleContext::GetExprArity(const Expr& expr) const {
       return {operand_count, 0, true};
     }
 
+    case ExprType::ThrowRef: {
+      return {1, 1, true};
+    }
+
     case ExprType::Try:
       return {0, cast<TryExpr>(&expr)->block.decl.sig.GetNumResults()};
 
+    case ExprType::TryTable:
+      return {0, cast<TryTableExpr>(&expr)->block.decl.sig.GetNumResults()};
+
     case ExprType::Ternary:
       return {3, 1};
 
diff --git a/src/ir.cc b/src/ir.cc
index 88db7d5f..a2f9c48e 100644
--- a/src/ir.cc
+++ b/src/ir.cc
@@ -85,7 +85,9 @@ const char* ExprTypeName[] = {
     "TableFill",
     "Ternary",
     "Throw",
+    "ThrowRef",
     "Try",
+    "TryTable",
     "Unary",
     "Unreachable",
 };
diff --git a/src/lexer-keywords.txt b/src/lexer-keywords.txt
index 1c72983b..5923c710 100644
--- a/src/lexer-keywords.txt
+++ b/src/lexer-keywords.txt
@@ -38,6 +38,8 @@ call_ref, TokenType::CallRef, Opcode::CallRef
 call, TokenType::Call, Opcode::Call
 catch, TokenType::Catch, Opcode::Catch
 catch_all, TokenType::CatchAll, Opcode::CatchAll
+catch_ref, TokenType::CatchRef
+catch_all_ref, TokenType::CatchAllRef
 code, TokenType::Code
 data.drop, TokenType::DataDrop, Opcode::DataDrop
 data, TokenType::Data
@@ -584,7 +586,9 @@ table.size, TokenType::TableSize, Opcode::TableSize
 table, TokenType::Table
 then, TokenType::Then
 throw, TokenType::Throw, Opcode::Throw
+throw_ref, TokenType::ThrowRef, Opcode::ThrowRef
 try, TokenType::Try, Opcode::Try
+try_table, TokenType::TryTable, Opcode::TryTable
 type, TokenType::Type
 unreachable, TokenType::Unreachable, Opcode::Unreachable
 v128.andnot, TokenType::Binary, Opcode::V128Andnot
diff --git a/src/opcode.cc b/src/opcode.cc
index 3a62fa71..023ae0b2 100644
--- a/src/opcode.cc
+++ b/src/opcode.cc
@@ -67,6 +67,8 @@ bool Opcode::IsEnabled(const Features& features) const {
     case Opcode::Catch:
     case Opcode::Delegate:
     case Opcode::Throw:
+    case Opcode::ThrowRef:
+    case Opcode::TryTable:
     case Opcode::Rethrow:
       return features.exceptions_enabled();
 
diff --git a/src/prebuilt/lexer-keywords.cc b/src/prebuilt/lexer-keywords.cc
index f04fc537..89f14dba 100644
--- a/src/prebuilt/lexer-keywords.cc
+++ b/src/prebuilt/lexer-keywords.cc
@@ -48,7 +48,7 @@ struct TokenInfo {
     Opcode opcode;
   };
 };
-/* maximum key range = 2481, duplicates = 0 */
+/* maximum key range = 2193, duplicates = 0 */
 
 class Perfect_Hash
 {
@@ -63,32 +63,32 @@ Perfect_Hash::hash (const char *str, size_t len)
 {
   static unsigned short asso_values[] =
     {
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496,    4, 2496, 2496,  683,
-       372,    5,    4,    4,  112,  565,   26, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496,  200,    4,   21,  865,   62,
-        74,    7,  722,    4,  263,  226,   10,    7,    6,  118,
-        43,   70,  510,  645,    5,    6,   15,    4,  663,  504,
-        34,  321,   59, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496, 2496,
-      2496, 2496, 2496, 2496, 2496, 2496, 2496
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230,   13, 2230, 2230,  426,
+       351,   14,   17,   13,  176,  531,   32, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230,  183,   13,   16,  811,   21,
+        68,   16,  326,   13,  347,  223,   20,   13,   15,  140,
+        80,   54,  559,  611,   14,   15,   24,   13,  556,  521,
+       125,  416,  213, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230, 2230,
+      2230, 2230, 2230, 2230, 2230, 2230, 2230
     };
   unsigned int hval = len;
 
@@ -158,1631 +158,1607 @@ Perfect_Hash::InWordSet (const char *str, size_t len)
 {
   enum
     {
-      TOTAL_KEYWORDS = 597,
+      TOTAL_KEYWORDS = 601,
       MIN_WORD_LENGTH = 2,
       MAX_WORD_LENGTH = 35,
-      MIN_HASH_VALUE = 15,
-      MAX_HASH_VALUE = 2495
+      MIN_HASH_VALUE = 37,
+      MAX_HASH_VALUE = 2229
     };
 
   static struct TokenInfo wordlist[] =
     {
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 150 "src/lexer-keywords.txt"
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""},
+#line 35 "src/lexer-keywords.txt"
+      {"br", TokenType::Br, Opcode::Br},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 152 "src/lexer-keywords.txt"
       {"f64", Type::F64},
-      {""}, {""}, {""}, {""}, {""},
-#line 462 "src/lexer-keywords.txt"
+      {""}, {""},
+#line 45 "src/lexer-keywords.txt"
+      {"data", TokenType::Data},
+      {""}, {""}, {""},
+#line 464 "src/lexer-keywords.txt"
       {"i64", Type::I64},
-#line 120 "src/lexer-keywords.txt"
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""},
+#line 122 "src/lexer-keywords.txt"
       {"f32x4", TokenType::F32X4},
-      {""}, {""}, {""}, {""}, {""},
-#line 362 "src/lexer-keywords.txt"
+      {""}, {""}, {""}, {""},
+#line 586 "src/lexer-keywords.txt"
+      {"table", TokenType::Table},
+#line 48 "src/lexer-keywords.txt"
+      {"do", TokenType::Do},
+#line 364 "src/lexer-keywords.txt"
       {"i32x4", TokenType::I32X4},
       {""}, {""}, {""},
-#line 133 "src/lexer-keywords.txt"
+#line 135 "src/lexer-keywords.txt"
       {"f64.ge", TokenType::Compare, Opcode::F64Ge},
-#line 72 "src/lexer-keywords.txt"
+#line 74 "src/lexer-keywords.txt"
       {"f32.ge", TokenType::Compare, Opcode::F32Ge},
-#line 135 "src/lexer-keywords.txt"
+#line 137 "src/lexer-keywords.txt"
       {"f64.le", TokenType::Compare, Opcode::F64Le},
-#line 74 "src/lexer-keywords.txt"
+#line 76 "src/lexer-keywords.txt"
       {"f32.le", TokenType::Compare, Opcode::F32Le},
+      {""}, {""}, {""}, {""}, {""},
+#line 30 "src/lexer-keywords.txt"
+      {"before", TokenType::Before},
+      {""}, {""}, {""}, {""}, {""},
+#line 187 "src/lexer-keywords.txt"
+      {"func", Type::FuncRef, TokenType::Func},
+#line 136 "src/lexer-keywords.txt"
+      {"f64.gt", TokenType::Compare, Opcode::F64Gt},
+#line 75 "src/lexer-keywords.txt"
+      {"f32.gt", TokenType::Compare, Opcode::F32Gt},
+#line 139 "src/lexer-keywords.txt"
+      {"f64.lt", TokenType::Compare, Opcode::F64Lt},
+#line 78 "src/lexer-keywords.txt"
+      {"f32.lt", TokenType::Compare, Opcode::F32Lt},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""},
 #line 43 "src/lexer-keywords.txt"
-      {"data", TokenType::Data},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 98 "src/lexer-keywords.txt"
-      {"f32x4.ge", TokenType::Compare, Opcode::F32X4Ge},
+      {"code", TokenType::Code},
+      {""}, {""}, {""},
+#line 570 "src/lexer-keywords.txt"
+      {"result", TokenType::Result},
       {""},
 #line 100 "src/lexer-keywords.txt"
+      {"f32x4.ge", TokenType::Compare, Opcode::F32X4Ge},
+      {""},
+#line 102 "src/lexer-keywords.txt"
       {"f32x4.le", TokenType::Compare, Opcode::F32X4Le},
+      {""},
+#line 578 "src/lexer-keywords.txt"
+      {"struct", Type::Struct, TokenType::Struct},
+      {""}, {""}, {""}, {""}, {""},
+#line 555 "src/lexer-keywords.txt"
+      {"mut", TokenType::Mut},
+#line 441 "src/lexer-keywords.txt"
+      {"i64.or", TokenType::Binary, Opcode::I64Or},
+#line 298 "src/lexer-keywords.txt"
+      {"i32.or", TokenType::Binary, Opcode::I32Or},
       {""}, {""},
-#line 134 "src/lexer-keywords.txt"
-      {"f64.gt", TokenType::Compare, Opcode::F64Gt},
-#line 73 "src/lexer-keywords.txt"
-      {"f32.gt", TokenType::Compare, Opcode::F32Gt},
-#line 137 "src/lexer-keywords.txt"
-      {"f64.lt", TokenType::Compare, Opcode::F64Lt},
-#line 76 "src/lexer-keywords.txt"
-      {"f32.lt", TokenType::Compare, Opcode::F32Lt},
-#line 328 "src/lexer-keywords.txt"
+#line 581 "src/lexer-keywords.txt"
+      {"table.get", TokenType::TableGet, Opcode::TableGet},
+#line 101 "src/lexer-keywords.txt"
+      {"f32x4.gt", TokenType::Compare, Opcode::F32X4Gt},
+#line 584 "src/lexer-keywords.txt"
+      {"table.set", TokenType::TableSet, Opcode::TableSet},
+#line 103 "src/lexer-keywords.txt"
+      {"f32x4.lt", TokenType::Compare, Opcode::F32X4Lt},
+#line 330 "src/lexer-keywords.txt"
       {"i32x4.ge_u", TokenType::Compare, Opcode::I32X4GeU},
       {""},
-#line 332 "src/lexer-keywords.txt"
+#line 334 "src/lexer-keywords.txt"
       {"i32x4.le_u", TokenType::Compare, Opcode::I32X4LeU},
       {""},
-#line 327 "src/lexer-keywords.txt"
+#line 329 "src/lexer-keywords.txt"
       {"i32x4.ge_s", TokenType::Compare, Opcode::I32X4GeS},
-      {""},
-#line 331 "src/lexer-keywords.txt"
+#line 93 "src/lexer-keywords.txt"
+      {"f32x4.ceil", TokenType::Unary, Opcode::F32X4Ceil},
+#line 333 "src/lexer-keywords.txt"
       {"i32x4.le_s", TokenType::Compare, Opcode::I32X4LeS},
-#line 99 "src/lexer-keywords.txt"
-      {"f32x4.gt", TokenType::Compare, Opcode::F32X4Gt},
-#line 330 "src/lexer-keywords.txt"
+      {""},
+#line 332 "src/lexer-keywords.txt"
       {"i32x4.gt_u", TokenType::Compare, Opcode::I32X4GtU},
-#line 101 "src/lexer-keywords.txt"
-      {"f32x4.lt", TokenType::Compare, Opcode::F32X4Lt},
-#line 340 "src/lexer-keywords.txt"
+      {""},
+#line 342 "src/lexer-keywords.txt"
       {"i32x4.lt_u", TokenType::Compare, Opcode::I32X4LtU},
-#line 568 "src/lexer-keywords.txt"
-      {"result", TokenType::Result},
-#line 329 "src/lexer-keywords.txt"
+      {""},
+#line 331 "src/lexer-keywords.txt"
       {"i32x4.gt_s", TokenType::Compare, Opcode::I32X4GtS},
-#line 553 "src/lexer-keywords.txt"
-      {"mut", TokenType::Mut},
-#line 339 "src/lexer-keywords.txt"
-      {"i32x4.lt_s", TokenType::Compare, Opcode::I32X4LtS},
-      {""}, {""},
-#line 35 "src/lexer-keywords.txt"
-      {"br", TokenType::Br, Opcode::Br},
       {""},
-#line 143 "src/lexer-keywords.txt"
+#line 341 "src/lexer-keywords.txt"
+      {"i32x4.lt_s", TokenType::Compare, Opcode::I32X4LtS},
+#line 145 "src/lexer-keywords.txt"
       {"f64.ne", TokenType::Compare, Opcode::F64Ne},
-#line 82 "src/lexer-keywords.txt"
+#line 84 "src/lexer-keywords.txt"
       {"f32.ne", TokenType::Compare, Opcode::F32Ne},
-#line 142 "src/lexer-keywords.txt"
-      {"f64.neg", TokenType::Unary, Opcode::F64Neg},
-#line 81 "src/lexer-keywords.txt"
-      {"f32.neg", TokenType::Unary, Opcode::F32Neg},
-      {""},
-#line 552 "src/lexer-keywords.txt"
+      {""}, {""}, {""},
+#line 554 "src/lexer-keywords.txt"
       {"module", TokenType::Module},
-#line 438 "src/lexer-keywords.txt"
+      {""},
+#line 440 "src/lexer-keywords.txt"
       {"i64.ne", TokenType::Compare, Opcode::I64Ne},
-#line 295 "src/lexer-keywords.txt"
+#line 297 "src/lexer-keywords.txt"
       {"i32.ne", TokenType::Compare, Opcode::I32Ne},
 #line 46 "src/lexer-keywords.txt"
-      {"do", TokenType::Do},
-#line 106 "src/lexer-keywords.txt"
-      {"f32x4.neg", TokenType::Unary, Opcode::F32X4Neg},
-      {""},
-#line 107 "src/lexer-keywords.txt"
-      {"f32x4.ne", TokenType::Compare, Opcode::F32X4Ne},
-#line 566 "src/lexer-keywords.txt"
-      {"ref.null", TokenType::RefNull, Opcode::RefNull},
-      {""},
-#line 584 "src/lexer-keywords.txt"
-      {"table", TokenType::Table},
-#line 347 "src/lexer-keywords.txt"
-      {"i32x4.neg", TokenType::Unary, Opcode::I32X4Neg},
-      {""},
-#line 348 "src/lexer-keywords.txt"
-      {"i32x4.ne", TokenType::Compare, Opcode::I32X4Ne},
-      {""}, {""},
-#line 30 "src/lexer-keywords.txt"
-      {"before", TokenType::Before},
-#line 41 "src/lexer-keywords.txt"
-      {"code", TokenType::Code},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 439 "src/lexer-keywords.txt"
-      {"i64.or", TokenType::Binary, Opcode::I64Or},
-#line 296 "src/lexer-keywords.txt"
-      {"i32.or", TokenType::Binary, Opcode::I32Or},
-      {""}, {""}, {""}, {""},
-#line 105 "src/lexer-keywords.txt"
-      {"f32x4.nearest", TokenType::Unary, Opcode::F32X4Nearest},
-#line 572 "src/lexer-keywords.txt"
-      {"return", TokenType::Return, Opcode::Return},
-#line 91 "src/lexer-keywords.txt"
-      {"f32x4.ceil", TokenType::Unary, Opcode::F32X4Ceil},
-      {""}, {""}, {""},
-#line 579 "src/lexer-keywords.txt"
-      {"table.get", TokenType::TableGet, Opcode::TableGet},
-      {""},
-#line 582 "src/lexer-keywords.txt"
-      {"table.set", TokenType::TableSet, Opcode::TableSet},
+      {"declare", TokenType::Declare},
       {""},
-#line 141 "src/lexer-keywords.txt"
-      {"f64.nearest", TokenType::Unary, Opcode::F64Nearest},
-#line 80 "src/lexer-keywords.txt"
-      {"f32.nearest", TokenType::Unary, Opcode::F32Nearest},
+#line 144 "src/lexer-keywords.txt"
+      {"f64.neg", TokenType::Unary, Opcode::F64Neg},
+#line 83 "src/lexer-keywords.txt"
+      {"f32.neg", TokenType::Unary, Opcode::F32Neg},
       {""},
-#line 576 "src/lexer-keywords.txt"
-      {"struct", Type::Struct, TokenType::Struct},
-#line 147 "src/lexer-keywords.txt"
+#line 149 "src/lexer-keywords.txt"
       {"f64.store", TokenType::Store, Opcode::F64Store},
-#line 85 "src/lexer-keywords.txt"
+#line 87 "src/lexer-keywords.txt"
       {"f32.store", TokenType::Store, Opcode::F32Store},
-#line 445 "src/lexer-keywords.txt"
+      {""},
+#line 447 "src/lexer-keywords.txt"
       {"i64.rotr", TokenType::Binary, Opcode::I64Rotr},
-#line 302 "src/lexer-keywords.txt"
+#line 304 "src/lexer-keywords.txt"
       {"i32.rotr", TokenType::Binary, Opcode::I32Rotr},
-#line 444 "src/lexer-keywords.txt"
+#line 446 "src/lexer-keywords.txt"
       {"i64.rotl", TokenType::Binary, Opcode::I64Rotl},
-#line 301 "src/lexer-keywords.txt"
+#line 303 "src/lexer-keywords.txt"
       {"i32.rotl", TokenType::Binary, Opcode::I32Rotl},
-#line 452 "src/lexer-keywords.txt"
+#line 454 "src/lexer-keywords.txt"
       {"i64.store", TokenType::Store, Opcode::I64Store},
-#line 308 "src/lexer-keywords.txt"
+#line 310 "src/lexer-keywords.txt"
       {"i32.store", TokenType::Store, Opcode::I32Store},
-#line 44 "src/lexer-keywords.txt"
-      {"declare", TokenType::Declare},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 494 "src/lexer-keywords.txt"
-      {"i64.xor", TokenType::Binary, Opcode::I64Xor},
-#line 371 "src/lexer-keywords.txt"
-      {"i32.xor", TokenType::Binary, Opcode::I32Xor},
-      {""}, {""}, {""},
-#line 185 "src/lexer-keywords.txt"
-      {"func", Type::FuncRef, TokenType::Func},
-      {""}, {""}, {""}, {""}, {""},
-#line 149 "src/lexer-keywords.txt"
-      {"f64.trunc", TokenType::Unary, Opcode::F64Trunc},
-#line 87 "src/lexer-keywords.txt"
-      {"f32.trunc", TokenType::Unary, Opcode::F32Trunc},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 568 "src/lexer-keywords.txt"
+      {"ref.null", TokenType::RefNull, Opcode::RefNull},
+#line 108 "src/lexer-keywords.txt"
+      {"f32x4.neg", TokenType::Unary, Opcode::F32X4Neg},
       {""},
-#line 140 "src/lexer-keywords.txt"
-      {"f64.mul", TokenType::Binary, Opcode::F64Mul},
-#line 79 "src/lexer-keywords.txt"
-      {"f32.mul", TokenType::Binary, Opcode::F32Mul},
+#line 109 "src/lexer-keywords.txt"
+      {"f32x4.ne", TokenType::Compare, Opcode::F32X4Ne},
+      {""}, {""}, {""}, {""},
+#line 349 "src/lexer-keywords.txt"
+      {"i32x4.neg", TokenType::Unary, Opcode::I32X4Neg},
+      {""},
+#line 350 "src/lexer-keywords.txt"
+      {"i32x4.ne", TokenType::Compare, Opcode::I32X4Ne},
       {""}, {""},
-#line 118 "src/lexer-keywords.txt"
-      {"f32x4.trunc", TokenType::Unary, Opcode::F32X4Trunc},
-#line 104 "src/lexer-keywords.txt"
-      {"f32x4.mul", TokenType::Binary, Opcode::F32X4Mul},
-#line 437 "src/lexer-keywords.txt"
-      {"i64.mul", TokenType::Binary, Opcode::I64Mul},
-#line 294 "src/lexer-keywords.txt"
-      {"i32.mul", TokenType::Binary, Opcode::I32Mul},
+#line 151 "src/lexer-keywords.txt"
+      {"f64.trunc", TokenType::Unary, Opcode::F64Trunc},
+#line 89 "src/lexer-keywords.txt"
+      {"f32.trunc", TokenType::Unary, Opcode::F32Trunc},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""}, {""},
+#line 143 "src/lexer-keywords.txt"
+      {"f64.nearest", TokenType::Unary, Opcode::F64Nearest},
+#line 82 "src/lexer-keywords.txt"
+      {"f32.nearest", TokenType::Unary, Opcode::F32Nearest},
       {""}, {""}, {""},
-#line 346 "src/lexer-keywords.txt"
-      {"i32x4.mul", TokenType::Binary, Opcode::I32X4Mul},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 563 "src/lexer-keywords.txt"
-      {"ref.extern", TokenType::RefExtern},
-      {""}, {""},
-#line 451 "src/lexer-keywords.txt"
+#line 120 "src/lexer-keywords.txt"
+      {"f32x4.trunc", TokenType::Unary, Opcode::F32X4Trunc},
+#line 574 "src/lexer-keywords.txt"
+      {"return", TokenType::Return, Opcode::Return},
+      {""}, {""}, {""}, {""}, {""},
+#line 453 "src/lexer-keywords.txt"
       {"i64.store8", TokenType::Store, Opcode::I64Store8},
-#line 307 "src/lexer-keywords.txt"
+#line 309 "src/lexer-keywords.txt"
       {"i32.store8", TokenType::Store, Opcode::I32Store8},
-      {""}, {""}, {""}, {""},
-#line 114 "src/lexer-keywords.txt"
-      {"f32x4.replace_lane", TokenType::SimdLaneOp, Opcode::F32X4ReplaceLane},
-      {""}, {""}, {""}, {""}, {""},
-#line 350 "src/lexer-keywords.txt"
-      {"i32x4.replace_lane", TokenType::SimdLaneOp, Opcode::I32X4ReplaceLane},
-      {""}, {""},
-#line 45 "src/lexer-keywords.txt"
-      {"delegate", TokenType::Delegate},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 90 "src/lexer-keywords.txt"
+#line 142 "src/lexer-keywords.txt"
+      {"f64.mul", TokenType::Binary, Opcode::F64Mul},
+#line 81 "src/lexer-keywords.txt"
+      {"f32.mul", TokenType::Binary, Opcode::F32Mul},
+#line 92 "src/lexer-keywords.txt"
       {"f32x4.add", TokenType::Binary, Opcode::F32X4Add},
+#line 107 "src/lexer-keywords.txt"
+      {"f32x4.nearest", TokenType::Unary, Opcode::F32X4Nearest},
       {""}, {""}, {""},
-#line 102 "src/lexer-keywords.txt"
-      {"f32x4.max", TokenType::Binary, Opcode::F32X4Max},
-      {""},
-#line 321 "src/lexer-keywords.txt"
+#line 439 "src/lexer-keywords.txt"
+      {"i64.mul", TokenType::Binary, Opcode::I64Mul},
+#line 296 "src/lexer-keywords.txt"
+      {"i32.mul", TokenType::Binary, Opcode::I32Mul},
+#line 323 "src/lexer-keywords.txt"
       {"i32x4.add", TokenType::Binary, Opcode::I32X4Add},
+      {""},
 #line 38 "src/lexer-keywords.txt"
       {"call", TokenType::Call, Opcode::Call},
-      {""}, {""}, {""},
-#line 96 "src/lexer-keywords.txt"
-      {"f32x4.extract_lane", TokenType::SimdLaneOp, Opcode::F32X4ExtractLane},
-#line 410 "src/lexer-keywords.txt"
-      {"i64.clz", TokenType::Unary, Opcode::I64Clz},
-#line 272 "src/lexer-keywords.txt"
-      {"i32.clz", TokenType::Unary, Opcode::I32Clz},
-#line 541 "src/lexer-keywords.txt"
-      {"local", TokenType::Local},
-      {""}, {""},
-#line 326 "src/lexer-keywords.txt"
-      {"i32x4.extract_lane", TokenType::SimdLaneOp, Opcode::I32X4ExtractLane},
-#line 124 "src/lexer-keywords.txt"
+      {""},
+#line 126 "src/lexer-keywords.txt"
       {"f64.const", TokenType::Const, Opcode::F64Const},
-#line 62 "src/lexer-keywords.txt"
+#line 64 "src/lexer-keywords.txt"
       {"f32.const", TokenType::Const, Opcode::F32Const},
+      {""}, {""}, {""},
+#line 106 "src/lexer-keywords.txt"
+      {"f32x4.mul", TokenType::Binary, Opcode::F32X4Mul},
       {""},
-#line 412 "src/lexer-keywords.txt"
-      {"i64.ctz", TokenType::Unary, Opcode::I64Ctz},
-#line 274 "src/lexer-keywords.txt"
-      {"i32.ctz", TokenType::Unary, Opcode::I32Ctz},
-      {""},
-#line 411 "src/lexer-keywords.txt"
+#line 413 "src/lexer-keywords.txt"
       {"i64.const", TokenType::Const, Opcode::I64Const},
-#line 273 "src/lexer-keywords.txt"
+#line 275 "src/lexer-keywords.txt"
       {"i32.const", TokenType::Const, Opcode::I32Const},
       {""},
-#line 138 "src/lexer-keywords.txt"
-      {"f64.max", TokenType::Binary, Opcode::F64Max},
-#line 77 "src/lexer-keywords.txt"
-      {"f32.max", TokenType::Binary, Opcode::F32Max},
-      {""}, {""},
-#line 349 "src/lexer-keywords.txt"
-      {"i32x4.relaxed_laneselect", TokenType::Ternary, Opcode::I32X4RelaxedLaneSelect},
-      {""}, {""}, {""}, {""},
-#line 573 "src/lexer-keywords.txt"
+#line 575 "src/lexer-keywords.txt"
       {"select", TokenType::Select, Opcode::Select},
       {""},
+#line 348 "src/lexer-keywords.txt"
+      {"i32x4.mul", TokenType::Binary, Opcode::I32X4Mul},
+      {""},
+#line 543 "src/lexer-keywords.txt"
+      {"local", TokenType::Local},
+      {""}, {""}, {""},
+#line 496 "src/lexer-keywords.txt"
+      {"i64.xor", TokenType::Binary, Opcode::I64Xor},
 #line 373 "src/lexer-keywords.txt"
+      {"i32.xor", TokenType::Binary, Opcode::I32Xor},
+#line 47 "src/lexer-keywords.txt"
+      {"delegate", TokenType::Delegate},
+      {""}, {""}, {""},
+#line 124 "src/lexer-keywords.txt"
+      {"f64.add", TokenType::Binary, Opcode::F64Add},
+#line 62 "src/lexer-keywords.txt"
+      {"f32.add", TokenType::Binary, Opcode::F32Add},
+#line 138 "src/lexer-keywords.txt"
+      {"f64.load", TokenType::Load, Opcode::F64Load},
+#line 77 "src/lexer-keywords.txt"
+      {"f32.load", TokenType::Load, Opcode::F32Load},
+      {""}, {""}, {""},
+#line 374 "src/lexer-keywords.txt"
+      {"i64.add", TokenType::Binary, Opcode::I64Add},
+#line 245 "src/lexer-keywords.txt"
+      {"i32.add", TokenType::Binary, Opcode::I32Add},
+#line 436 "src/lexer-keywords.txt"
+      {"i64.load", TokenType::Load, Opcode::I64Load},
+#line 293 "src/lexer-keywords.txt"
+      {"i32.load", TokenType::Load, Opcode::I32Load},
+      {""}, {""}, {""}, {""},
+#line 116 "src/lexer-keywords.txt"
+      {"f32x4.replace_lane", TokenType::SimdLaneOp, Opcode::F32X4ReplaceLane},
+      {""}, {""}, {""},
+#line 375 "src/lexer-keywords.txt"
       {"i64.and", TokenType::Binary, Opcode::I64And},
-#line 244 "src/lexer-keywords.txt"
+#line 246 "src/lexer-keywords.txt"
       {"i32.and", TokenType::Binary, Opcode::I32And},
-      {""}, {""},
-#line 538 "src/lexer-keywords.txt"
-      {"local.get", TokenType::LocalGet, Opcode::LocalGet},
       {""},
-#line 539 "src/lexer-keywords.txt"
-      {"local.set", TokenType::LocalSet, Opcode::LocalSet},
-#line 540 "src/lexer-keywords.txt"
-      {"local.tee", TokenType::LocalTee, Opcode::LocalTee},
-#line 423 "src/lexer-keywords.txt"
+#line 352 "src/lexer-keywords.txt"
+      {"i32x4.replace_lane", TokenType::SimdLaneOp, Opcode::I32X4ReplaceLane},
+      {""}, {""}, {""},
+#line 425 "src/lexer-keywords.txt"
       {"i64.ge_u", TokenType::Compare, Opcode::I64GeU},
-#line 282 "src/lexer-keywords.txt"
+#line 284 "src/lexer-keywords.txt"
       {"i32.ge_u", TokenType::Compare, Opcode::I32GeU},
-#line 427 "src/lexer-keywords.txt"
+#line 429 "src/lexer-keywords.txt"
       {"i64.le_u", TokenType::Compare, Opcode::I64LeU},
-#line 286 "src/lexer-keywords.txt"
+#line 288 "src/lexer-keywords.txt"
       {"i32.le_u", TokenType::Compare, Opcode::I32LeU},
-#line 422 "src/lexer-keywords.txt"
+#line 424 "src/lexer-keywords.txt"
       {"i64.ge_s", TokenType::Compare, Opcode::I64GeS},
-#line 281 "src/lexer-keywords.txt"
+#line 283 "src/lexer-keywords.txt"
       {"i32.ge_s", TokenType::Compare, Opcode::I32GeS},
-#line 426 "src/lexer-keywords.txt"
+#line 428 "src/lexer-keywords.txt"
       {"i64.le_s", TokenType::Compare, Opcode::I64LeS},
-#line 285 "src/lexer-keywords.txt"
+#line 287 "src/lexer-keywords.txt"
       {"i32.le_s", TokenType::Compare, Opcode::I32LeS},
-#line 425 "src/lexer-keywords.txt"
+#line 427 "src/lexer-keywords.txt"
       {"i64.gt_u", TokenType::Compare, Opcode::I64GtU},
-#line 284 "src/lexer-keywords.txt"
+#line 286 "src/lexer-keywords.txt"
       {"i32.gt_u", TokenType::Compare, Opcode::I32GtU},
-#line 436 "src/lexer-keywords.txt"
+#line 438 "src/lexer-keywords.txt"
       {"i64.lt_u", TokenType::Compare, Opcode::I64LtU},
-#line 293 "src/lexer-keywords.txt"
+#line 295 "src/lexer-keywords.txt"
       {"i32.lt_u", TokenType::Compare, Opcode::I32LtU},
-#line 424 "src/lexer-keywords.txt"
+#line 426 "src/lexer-keywords.txt"
       {"i64.gt_s", TokenType::Compare, Opcode::I64GtS},
-#line 283 "src/lexer-keywords.txt"
+#line 285 "src/lexer-keywords.txt"
       {"i32.gt_s", TokenType::Compare, Opcode::I32GtS},
-#line 435 "src/lexer-keywords.txt"
+#line 437 "src/lexer-keywords.txt"
       {"i64.lt_s", TokenType::Compare, Opcode::I64LtS},
-#line 292 "src/lexer-keywords.txt"
+#line 294 "src/lexer-keywords.txt"
       {"i32.lt_s", TokenType::Compare, Opcode::I32LtS},
+      {""}, {""}, {""},
+#line 540 "src/lexer-keywords.txt"
+      {"local.get", TokenType::LocalGet, Opcode::LocalGet},
       {""},
-#line 122 "src/lexer-keywords.txt"
-      {"f64.add", TokenType::Binary, Opcode::F64Add},
-#line 60 "src/lexer-keywords.txt"
-      {"f32.add", TokenType::Binary, Opcode::F32Add},
-#line 111 "src/lexer-keywords.txt"
-      {"f32x4.relaxed_max", TokenType::Binary, Opcode::F32X4RelaxedMax},
-#line 136 "src/lexer-keywords.txt"
-      {"f64.load", TokenType::Load, Opcode::F64Load},
-#line 75 "src/lexer-keywords.txt"
-      {"f32.load", TokenType::Load, Opcode::F32Load},
-      {""},
-#line 372 "src/lexer-keywords.txt"
-      {"i64.add", TokenType::Binary, Opcode::I64Add},
-#line 243 "src/lexer-keywords.txt"
-      {"i32.add", TokenType::Binary, Opcode::I32Add},
-      {""},
-#line 434 "src/lexer-keywords.txt"
-      {"i64.load", TokenType::Load, Opcode::I64Load},
-#line 291 "src/lexer-keywords.txt"
-      {"i32.load", TokenType::Load, Opcode::I32Load},
-      {""}, {""}, {""}, {""}, {""},
-#line 53 "src/lexer-keywords.txt"
-      {"tag", TokenType::Tag},
-      {""},
-#line 322 "src/lexer-keywords.txt"
-      {"i32x4.all_true", TokenType::Unary, Opcode::I32X4AllTrue},
-      {""},
-#line 112 "src/lexer-keywords.txt"
-      {"f32x4.relaxed_min", TokenType::Binary, Opcode::F32X4RelaxedMin},
-      {""}, {""}, {""}, {""},
-#line 417 "src/lexer-keywords.txt"
-      {"i64.extend16_s", TokenType::Unary, Opcode::I64Extend16S},
-#line 279 "src/lexer-keywords.txt"
-      {"i32.extend16_s", TokenType::Unary, Opcode::I32Extend16S},
-#line 187 "src/lexer-keywords.txt"
-      {"get", TokenType::Get},
+#line 541 "src/lexer-keywords.txt"
+      {"local.set", TokenType::LocalSet, Opcode::LocalSet},
+#line 542 "src/lexer-keywords.txt"
+      {"local.tee", TokenType::LocalTee, Opcode::LocalTee},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""},
-#line 336 "src/lexer-keywords.txt"
-      {"i32x4.relaxed_trunc_f64x2_u_zero", TokenType::Unary, Opcode::I32X4RelaxedTruncF64X2UZero},
       {""},
-#line 335 "src/lexer-keywords.txt"
-      {"i32x4.relaxed_trunc_f64x2_s_zero", TokenType::Unary, Opcode::I32X4RelaxedTruncF64X2SZero},
-      {""}, {""},
-#line 446 "src/lexer-keywords.txt"
-      {"i64.shl", TokenType::Binary, Opcode::I64Shl},
-#line 303 "src/lexer-keywords.txt"
-      {"i32.shl", TokenType::Binary, Opcode::I32Shl},
-      {""}, {""}, {""},
 #line 351 "src/lexer-keywords.txt"
-      {"i32x4.shl", TokenType::Binary, Opcode::I32X4Shl},
-      {""},
-#line 455 "src/lexer-keywords.txt"
-      {"i64.trunc_f32_u", TokenType::Convert, Opcode::I64TruncF32U},
-#line 311 "src/lexer-keywords.txt"
-      {"i32.trunc_f32_u", TokenType::Convert, Opcode::I32TruncF32U},
-      {""}, {""},
-#line 454 "src/lexer-keywords.txt"
-      {"i64.trunc_f32_s", TokenType::Convert, Opcode::I64TruncF32S},
-#line 310 "src/lexer-keywords.txt"
-      {"i32.trunc_f32_s", TokenType::Convert, Opcode::I32TruncF32S},
-#line 567 "src/lexer-keywords.txt"
-      {"register", TokenType::Register},
+      {"i32x4.relaxed_laneselect", TokenType::Ternary, Opcode::I32X4RelaxedLaneSelect},
+#line 324 "src/lexer-keywords.txt"
+      {"i32x4.all_true", TokenType::Unary, Opcode::I32X4AllTrue},
       {""},
-#line 429 "src/lexer-keywords.txt"
-      {"i64.load16_u", TokenType::Load, Opcode::I64Load16U},
-#line 288 "src/lexer-keywords.txt"
-      {"i32.load16_u", TokenType::Load, Opcode::I32Load16U},
-      {""}, {""},
-#line 428 "src/lexer-keywords.txt"
-      {"i64.load16_s", TokenType::Load, Opcode::I64Load16S},
-#line 287 "src/lexer-keywords.txt"
-      {"i32.load16_s", TokenType::Load, Opcode::I32Load16S},
-#line 123 "src/lexer-keywords.txt"
+#line 125 "src/lexer-keywords.txt"
       {"f64.ceil", TokenType::Unary, Opcode::F64Ceil},
-#line 61 "src/lexer-keywords.txt"
+#line 63 "src/lexer-keywords.txt"
       {"f32.ceil", TokenType::Unary, Opcode::F32Ceil},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 583 "src/lexer-keywords.txt"
+#line 585 "src/lexer-keywords.txt"
       {"table.size", TokenType::TableSize, Opcode::TableSize},
-#line 409 "src/lexer-keywords.txt"
+      {""}, {""}, {""},
+#line 104 "src/lexer-keywords.txt"
+      {"f32x4.max", TokenType::Binary, Opcode::F32X4Max},
+#line 535 "src/lexer-keywords.txt"
+      {"if", TokenType::If, Opcode::If},
+#line 411 "src/lexer-keywords.txt"
       {"i64.atomic.store", TokenType::AtomicStore, Opcode::I64AtomicStore},
-#line 271 "src/lexer-keywords.txt"
+#line 273 "src/lexer-keywords.txt"
       {"i32.atomic.store", TokenType::AtomicStore, Opcode::I32AtomicStore},
-#line 402 "src/lexer-keywords.txt"
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 563 "src/lexer-keywords.txt"
+      {"ref", TokenType::Ref},
+      {""}, {""},
+#line 404 "src/lexer-keywords.txt"
       {"i64.atomic.rmw.or", TokenType::AtomicRmw, Opcode::I64AtomicRmwOr},
-#line 265 "src/lexer-keywords.txt"
+#line 267 "src/lexer-keywords.txt"
       {"i32.atomic.rmw.or", TokenType::AtomicRmw, Opcode::I32AtomicRmwOr},
       {""}, {""}, {""}, {""}, {""},
-#line 571 "src/lexer-keywords.txt"
+#line 573 "src/lexer-keywords.txt"
       {"return_call", TokenType::ReturnCall, Opcode::ReturnCall},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 389 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw32.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32SubU},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 443 "src/lexer-keywords.txt"
-      {"i64.rem_u", TokenType::Binary, Opcode::I64RemU},
-#line 300 "src/lexer-keywords.txt"
-      {"i32.rem_u", TokenType::Binary, Opcode::I32RemU},
-#line 442 "src/lexer-keywords.txt"
-      {"i64.rem_s", TokenType::Binary, Opcode::I64RemS},
-#line 299 "src/lexer-keywords.txt"
-      {"i32.rem_s", TokenType::Binary, Opcode::I32RemS},
-      {""},
-#line 113 "src/lexer-keywords.txt"
-      {"f32x4.relaxed_nmadd", TokenType::Ternary, Opcode::F32X4RelaxedNmadd},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 419 "src/lexer-keywords.txt"
-      {"i64.extend8_s", TokenType::Unary, Opcode::I64Extend8S},
-#line 280 "src/lexer-keywords.txt"
-      {"i32.extend8_s", TokenType::Unary, Opcode::I32Extend8S},
+      {""}, {""},
+#line 53 "src/lexer-keywords.txt"
+      {"else", TokenType::Else, Opcode::Else},
       {""}, {""}, {""}, {""}, {""},
-#line 342 "src/lexer-keywords.txt"
-      {"i32x4.max_u", TokenType::Binary, Opcode::I32X4MaxU},
+#line 55 "src/lexer-keywords.txt"
+      {"tag", TokenType::Tag},
       {""},
-#line 341 "src/lexer-keywords.txt"
-      {"i32x4.max_s", TokenType::Binary, Opcode::I32X4MaxS},
-#line 408 "src/lexer-keywords.txt"
-      {"i64.atomic.store8", TokenType::AtomicStore, Opcode::I64AtomicStore8},
-#line 270 "src/lexer-keywords.txt"
-      {"i32.atomic.store8", TokenType::AtomicStore, Opcode::I32AtomicStore8},
-      {""}, {""},
-#line 88 "src/lexer-keywords.txt"
+#line 98 "src/lexer-keywords.txt"
+      {"f32x4.extract_lane", TokenType::SimdLaneOp, Opcode::F32X4ExtractLane},
+#line 565 "src/lexer-keywords.txt"
+      {"ref.extern", TokenType::RefExtern},
+#line 338 "src/lexer-keywords.txt"
+      {"i32x4.relaxed_trunc_f64x2_u_zero", TokenType::Unary, Opcode::I32X4RelaxedTruncF64X2UZero},
+#line 90 "src/lexer-keywords.txt"
       {"f32", Type::F32},
-      {""},
-#line 581 "src/lexer-keywords.txt"
-      {"table.init", TokenType::TableInit, Opcode::TableInit},
-#line 587 "src/lexer-keywords.txt"
-      {"try", TokenType::Try, Opcode::Try},
+#line 337 "src/lexer-keywords.txt"
+      {"i32x4.relaxed_trunc_f64x2_s_zero", TokenType::Unary, Opcode::I32X4RelaxedTruncF64X2SZero},
       {""}, {""},
-#line 318 "src/lexer-keywords.txt"
+#line 328 "src/lexer-keywords.txt"
+      {"i32x4.extract_lane", TokenType::SimdLaneOp, Opcode::I32X4ExtractLane},
+      {""},
+#line 189 "src/lexer-keywords.txt"
+      {"get", TokenType::Get},
+#line 320 "src/lexer-keywords.txt"
       {"i32", Type::I32},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 433 "src/lexer-keywords.txt"
+#line 50 "src/lexer-keywords.txt"
+      {"either", TokenType::Either},
+      {""}, {""},
+#line 391 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw32.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32SubU},
+#line 435 "src/lexer-keywords.txt"
       {"i64.load8_u", TokenType::Load, Opcode::I64Load8U},
-#line 290 "src/lexer-keywords.txt"
+#line 292 "src/lexer-keywords.txt"
       {"i32.load8_u", TokenType::Load, Opcode::I32Load8U},
-#line 432 "src/lexer-keywords.txt"
+#line 434 "src/lexer-keywords.txt"
       {"i64.load8_s", TokenType::Load, Opcode::I64Load8S},
-#line 289 "src/lexer-keywords.txt"
+#line 291 "src/lexer-keywords.txt"
       {"i32.load8_s", TokenType::Load, Opcode::I32Load8S},
-#line 386 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw32.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32AndU},
-      {""}, {""},
-#line 405 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw.xor", TokenType::AtomicRmw, Opcode::I64AtomicRmwXor},
-#line 268 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw.xor", TokenType::AtomicRmw, Opcode::I32AtomicRmwXor},
-      {""},
-#line 158 "src/lexer-keywords.txt"
-      {"f64x2.ge", TokenType::Compare, Opcode::F64X2Ge},
       {""},
-#line 160 "src/lexer-keywords.txt"
-      {"f64x2.le", TokenType::Compare, Opcode::F64X2Le},
-#line 103 "src/lexer-keywords.txt"
-      {"f32x4.min", TokenType::Binary, Opcode::F32X4Min},
-#line 388 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw32.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32OrU},
-#line 110 "src/lexer-keywords.txt"
-      {"f32x4.relaxed_madd", TokenType::Ternary, Opcode::F32X4RelaxedMadd},
+#line 410 "src/lexer-keywords.txt"
+      {"i64.atomic.store8", TokenType::AtomicStore, Opcode::I64AtomicStore8},
+#line 272 "src/lexer-keywords.txt"
+      {"i32.atomic.store8", TokenType::AtomicStore, Opcode::I32AtomicStore8},
+#line 431 "src/lexer-keywords.txt"
+      {"i64.load16_u", TokenType::Load, Opcode::I64Load16U},
+#line 290 "src/lexer-keywords.txt"
+      {"i32.load16_u", TokenType::Load, Opcode::I32Load16U},
 #line 457 "src/lexer-keywords.txt"
-      {"i64.trunc_f64_u", TokenType::Convert, Opcode::I64TruncF64U},
+      {"i64.trunc_f32_u", TokenType::Convert, Opcode::I64TruncF32U},
 #line 313 "src/lexer-keywords.txt"
-      {"i32.trunc_f64_u", TokenType::Convert, Opcode::I32TruncF64U},
-      {""}, {""},
+      {"i32.trunc_f32_u", TokenType::Convert, Opcode::I32TruncF32U},
+#line 430 "src/lexer-keywords.txt"
+      {"i64.load16_s", TokenType::Load, Opcode::I64Load16S},
+#line 289 "src/lexer-keywords.txt"
+      {"i32.load16_s", TokenType::Load, Opcode::I32Load16S},
 #line 456 "src/lexer-keywords.txt"
-      {"i64.trunc_f64_s", TokenType::Convert, Opcode::I64TruncF64S},
+      {"i64.trunc_f32_s", TokenType::Convert, Opcode::I64TruncF32S},
 #line 312 "src/lexer-keywords.txt"
-      {"i32.trunc_f64_s", TokenType::Convert, Opcode::I32TruncF64S},
-      {""},
-#line 473 "src/lexer-keywords.txt"
-      {"i64x2.ge_s", TokenType::Binary, Opcode::I64X2GeS},
+      {"i32.trunc_f32_s", TokenType::Convert, Opcode::I32TruncF32S},
+#line 445 "src/lexer-keywords.txt"
+      {"i64.rem_u", TokenType::Binary, Opcode::I64RemU},
+#line 302 "src/lexer-keywords.txt"
+      {"i32.rem_u", TokenType::Binary, Opcode::I32RemU},
+#line 444 "src/lexer-keywords.txt"
+      {"i64.rem_s", TokenType::Binary, Opcode::I64RemS},
+#line 301 "src/lexer-keywords.txt"
+      {"i32.rem_s", TokenType::Binary, Opcode::I32RemS},
       {""},
-#line 472 "src/lexer-keywords.txt"
-      {"i64x2.le_s", TokenType::Binary, Opcode::I64X2LeS},
-#line 159 "src/lexer-keywords.txt"
-      {"f64x2.gt", TokenType::Compare, Opcode::F64X2Gt},
+#line 54 "src/lexer-keywords.txt"
+      {"end", TokenType::End, Opcode::End},
       {""},
-#line 161 "src/lexer-keywords.txt"
-      {"f64x2.lt", TokenType::Compare, Opcode::F64X2Lt},
+#line 407 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw.xor", TokenType::AtomicRmw, Opcode::I64AtomicRmwXor},
+#line 270 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw.xor", TokenType::AtomicRmw, Opcode::I32AtomicRmwXor},
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 587 "src/lexer-keywords.txt"
+      {"then", TokenType::Then},
+#line 583 "src/lexer-keywords.txt"
+      {"table.init", TokenType::TableInit, Opcode::TableInit},
       {""}, {""},
-#line 471 "src/lexer-keywords.txt"
-      {"i64x2.gt_s", TokenType::Binary, Opcode::I64X2GtS},
+#line 344 "src/lexer-keywords.txt"
+      {"i32x4.max_u", TokenType::Binary, Opcode::I32X4MaxU},
       {""},
-#line 470 "src/lexer-keywords.txt"
-      {"i64x2.lt_s", TokenType::Binary, Opcode::I64X2LtS},
+#line 343 "src/lexer-keywords.txt"
+      {"i32x4.max_s", TokenType::Binary, Opcode::I32X4MaxS},
       {""},
-#line 385 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw32.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32AddU},
-      {""}, {""}, {""}, {""}, {""},
 #line 390 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw32.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32XchgU},
+      {"i64.atomic.rmw32.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32OrU},
+#line 448 "src/lexer-keywords.txt"
+      {"i64.shl", TokenType::Binary, Opcode::I64Shl},
+#line 305 "src/lexer-keywords.txt"
+      {"i32.shl", TokenType::Binary, Opcode::I32Shl},
       {""}, {""},
-#line 391 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw32.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32XorU},
-#line 139 "src/lexer-keywords.txt"
-      {"f64.min", TokenType::Binary, Opcode::F64Min},
-#line 78 "src/lexer-keywords.txt"
-      {"f32.min", TokenType::Binary, Opcode::F32Min},
-#line 166 "src/lexer-keywords.txt"
-      {"f64x2.neg", TokenType::Unary, Opcode::F64X2Neg},
+#line 114 "src/lexer-keywords.txt"
+      {"f32x4.relaxed_min", TokenType::Binary, Opcode::F32X4RelaxedMin},
       {""},
-#line 167 "src/lexer-keywords.txt"
-      {"f64x2.ne", TokenType::Compare, Opcode::F64X2Ne},
-      {""}, {""}, {""},
-#line 475 "src/lexer-keywords.txt"
-      {"i64x2.neg", TokenType::Unary, Opcode::I64X2Neg},
+#line 115 "src/lexer-keywords.txt"
+      {"f32x4.relaxed_nmadd", TokenType::Ternary, Opcode::F32X4RelaxedNmadd},
+#line 140 "src/lexer-keywords.txt"
+      {"f64.max", TokenType::Binary, Opcode::F64Max},
+#line 79 "src/lexer-keywords.txt"
+      {"f32.max", TokenType::Binary, Opcode::F32Max},
+      {""}, {""},
+#line 160 "src/lexer-keywords.txt"
+      {"f64x2.ge", TokenType::Compare, Opcode::F64X2Ge},
       {""},
-#line 469 "src/lexer-keywords.txt"
-      {"i64x2.ne", TokenType::Binary, Opcode::I64X2Ne},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 398 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw8.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8XorU},
-#line 261 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw8.xor_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8XorU},
+#line 162 "src/lexer-keywords.txt"
+      {"f64x2.le", TokenType::Compare, Opcode::F64X2Le},
       {""}, {""},
-#line 377 "src/lexer-keywords.txt"
+#line 387 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw32.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32AddU},
+      {""},
+#line 353 "src/lexer-keywords.txt"
+      {"i32x4.shl", TokenType::Binary, Opcode::I32X4Shl},
+      {""}, {""},
+#line 569 "src/lexer-keywords.txt"
+      {"register", TokenType::Register},
+#line 379 "src/lexer-keywords.txt"
       {"i64.atomic.load", TokenType::AtomicLoad, Opcode::I64AtomicLoad},
-#line 247 "src/lexer-keywords.txt"
+#line 249 "src/lexer-keywords.txt"
       {"i32.atomic.load", TokenType::AtomicLoad, Opcode::I32AtomicLoad},
-      {""}, {""},
-#line 165 "src/lexer-keywords.txt"
-      {"f64x2.nearest", TokenType::Unary, Opcode::F64X2Nearest},
+      {""}, {""}, {""},
+#line 161 "src/lexer-keywords.txt"
+      {"f64x2.gt", TokenType::Compare, Opcode::F64X2Gt},
+#line 388 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw32.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32AndU},
+#line 163 "src/lexer-keywords.txt"
+      {"f64x2.lt", TokenType::Compare, Opcode::F64X2Lt},
       {""},
-#line 153 "src/lexer-keywords.txt"
+#line 58 "src/lexer-keywords.txt"
+      {"exn", Type::ExnRef, TokenType::Exn},
+      {""}, {""},
+#line 475 "src/lexer-keywords.txt"
+      {"i64x2.ge_s", TokenType::Binary, Opcode::I64X2GeS},
+#line 155 "src/lexer-keywords.txt"
       {"f64x2.ceil", TokenType::Unary, Opcode::F64X2Ceil},
-#line 506 "src/lexer-keywords.txt"
-      {"i8x16.ge_u", TokenType::Compare, Opcode::I8X16GeU},
-      {""},
-#line 510 "src/lexer-keywords.txt"
-      {"i8x16.le_u", TokenType::Compare, Opcode::I8X16LeU},
-#line 186 "src/lexer-keywords.txt"
-      {"function", TokenType::Function},
-#line 505 "src/lexer-keywords.txt"
-      {"i8x16.ge_s", TokenType::Compare, Opcode::I8X16GeS},
-      {""},
-#line 509 "src/lexer-keywords.txt"
-      {"i8x16.le_s", TokenType::Compare, Opcode::I8X16LeS},
-      {""},
-#line 508 "src/lexer-keywords.txt"
-      {"i8x16.gt_u", TokenType::Compare, Opcode::I8X16GtU},
-      {""},
-#line 512 "src/lexer-keywords.txt"
-      {"i8x16.lt_u", TokenType::Compare, Opcode::I8X16LtU},
-      {""},
-#line 507 "src/lexer-keywords.txt"
-      {"i8x16.gt_s", TokenType::Compare, Opcode::I8X16GtS},
+#line 474 "src/lexer-keywords.txt"
+      {"i64x2.le_s", TokenType::Binary, Opcode::I64X2LeS},
+      {""}, {""}, {""}, {""}, {""},
+#line 473 "src/lexer-keywords.txt"
+      {"i64x2.gt_s", TokenType::Binary, Opcode::I64X2GtS},
       {""},
-#line 511 "src/lexer-keywords.txt"
-      {"i8x16.lt_s", TokenType::Compare, Opcode::I8X16LtS},
-      {""}, {""}, {""},
-#line 393 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw8.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8AndU},
-#line 256 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw8.and_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8AndU},
+#line 472 "src/lexer-keywords.txt"
+      {"i64x2.lt_s", TokenType::Binary, Opcode::I64X2LtS},
+#line 99 "src/lexer-keywords.txt"
+      {"f32x4.floor", TokenType::Unary, Opcode::F32X4Floor},
       {""}, {""},
-#line 450 "src/lexer-keywords.txt"
-      {"i64.store32", TokenType::Store, Opcode::I64Store32},
-#line 550 "src/lexer-keywords.txt"
-      {"memory.size", TokenType::MemorySize, Opcode::MemorySize},
+#line 185 "src/lexer-keywords.txt"
+      {"field", TokenType::Field},
+#line 112 "src/lexer-keywords.txt"
+      {"f32x4.relaxed_madd", TokenType::Ternary, Opcode::F32X4RelaxedMadd},
+      {""}, {""}, {""}, {""}, {""},
+#line 419 "src/lexer-keywords.txt"
+      {"i64.extend16_s", TokenType::Unary, Opcode::I64Extend16S},
+#line 281 "src/lexer-keywords.txt"
+      {"i32.extend16_s", TokenType::Unary, Opcode::I32Extend16S},
       {""},
-#line 448 "src/lexer-keywords.txt"
-      {"i64.shr_u", TokenType::Binary, Opcode::I64ShrU},
-#line 305 "src/lexer-keywords.txt"
-      {"i32.shr_u", TokenType::Binary, Opcode::I32ShrU},
-#line 447 "src/lexer-keywords.txt"
-      {"i64.shr_s", TokenType::Binary, Opcode::I64ShrS},
-#line 304 "src/lexer-keywords.txt"
-      {"i32.shr_s", TokenType::Binary, Opcode::I32ShrS},
+#line 539 "src/lexer-keywords.txt"
+      {"item", TokenType::Item},
       {""}, {""},
-#line 353 "src/lexer-keywords.txt"
-      {"i32x4.shr_u", TokenType::Binary, Opcode::I32X4ShrU},
-#line 565 "src/lexer-keywords.txt"
-      {"ref.is_null", TokenType::RefIsNull, Opcode::RefIsNull},
-#line 352 "src/lexer-keywords.txt"
-      {"i32x4.shr_s", TokenType::Binary, Opcode::I32X4ShrS},
-#line 519 "src/lexer-keywords.txt"
-      {"i8x16.neg", TokenType::Unary, Opcode::I8X16Neg},
+#line 421 "src/lexer-keywords.txt"
+      {"i64.extend8_s", TokenType::Unary, Opcode::I64Extend8S},
+#line 282 "src/lexer-keywords.txt"
+      {"i32.extend8_s", TokenType::Unary, Opcode::I32Extend8S},
+      {""}, {""},
+#line 566 "src/lexer-keywords.txt"
+      {"ref.func", TokenType::RefFunc, Opcode::RefFunc},
+#line 134 "src/lexer-keywords.txt"
+      {"f64.floor", TokenType::Unary, Opcode::F64Floor},
+#line 73 "src/lexer-keywords.txt"
+      {"f32.floor", TokenType::Unary, Opcode::F32Floor},
+      {""}, {""},
+#line 412 "src/lexer-keywords.txt"
+      {"i64.clz", TokenType::Unary, Opcode::I64Clz},
+#line 274 "src/lexer-keywords.txt"
+      {"i32.clz", TokenType::Unary, Opcode::I32Clz},
+      {""}, {""}, {""}, {""},
+#line 168 "src/lexer-keywords.txt"
+      {"f64x2.neg", TokenType::Unary, Opcode::F64X2Neg},
+#line 105 "src/lexer-keywords.txt"
+      {"f32x4.min", TokenType::Binary, Opcode::F32X4Min},
+#line 169 "src/lexer-keywords.txt"
+      {"f64x2.ne", TokenType::Compare, Opcode::F64X2Ne},
+#line 414 "src/lexer-keywords.txt"
+      {"i64.ctz", TokenType::Unary, Opcode::I64Ctz},
+#line 276 "src/lexer-keywords.txt"
+      {"i32.ctz", TokenType::Unary, Opcode::I32Ctz},
+      {""}, {""},
+#line 477 "src/lexer-keywords.txt"
+      {"i64x2.neg", TokenType::Unary, Opcode::I64X2Neg},
+#line 452 "src/lexer-keywords.txt"
+      {"i64.store32", TokenType::Store, Opcode::I64Store32},
+#line 471 "src/lexer-keywords.txt"
+      {"i64x2.ne", TokenType::Binary, Opcode::I64X2Ne},
       {""},
-#line 521 "src/lexer-keywords.txt"
-      {"i8x16.ne", TokenType::Compare, Opcode::I8X16Ne},
-      {""}, {""}, {""}, {""}, {""},
-#line 400 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw.and", TokenType::AtomicRmw, Opcode::I64AtomicRmwAnd},
-#line 263 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw.and", TokenType::AtomicRmw, Opcode::I32AtomicRmwAnd},
-#line 178 "src/lexer-keywords.txt"
-      {"f64x2.trunc", TokenType::Unary, Opcode::F64X2Trunc},
-#line 164 "src/lexer-keywords.txt"
-      {"f64x2.mul", TokenType::Binary, Opcode::F64X2Mul},
-      {""}, {""}, {""},
-#line 392 "src/lexer-keywords.txt"
+#line 56 "src/lexer-keywords.txt"
+      {"extern", Type::ExternRef, TokenType::Extern},
+#line 394 "src/lexer-keywords.txt"
       {"i64.atomic.rmw8.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8AddU},
-#line 255 "src/lexer-keywords.txt"
+#line 257 "src/lexer-keywords.txt"
       {"i32.atomic.rmw8.add_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8AddU},
-#line 467 "src/lexer-keywords.txt"
-      {"i64x2.mul", TokenType::Binary, Opcode::I64X2Mul},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 562 "src/lexer-keywords.txt"
-      {"quote", TokenType::Quote},
-      {""}, {""}, {""}, {""},
-#line 601 "src/lexer-keywords.txt"
-      {"v128", Type::V128},
-      {""},
-#line 536 "src/lexer-keywords.txt"
-      {"invoke", TokenType::Invoke},
-      {""},
-#line 418 "src/lexer-keywords.txt"
-      {"i64.extend32_s", TokenType::Unary, Opcode::I64Extend32S},
+      {""}, {""},
+#line 392 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw32.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32XchgU},
       {""},
-#line 174 "src/lexer-keywords.txt"
-      {"f64x2.replace_lane", TokenType::SimdLaneOp, Opcode::F64X2ReplaceLane},
-      {""}, {""}, {""},
-#line 399 "src/lexer-keywords.txt"
+#line 113 "src/lexer-keywords.txt"
+      {"f32x4.relaxed_max", TokenType::Binary, Opcode::F32X4RelaxedMax},
+      {""}, {""}, {""}, {""}, {""},
+#line 395 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw8.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8AndU},
+#line 258 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw8.and_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8AndU},
+      {""}, {""},
+#line 188 "src/lexer-keywords.txt"
+      {"function", TokenType::Function},
+#line 401 "src/lexer-keywords.txt"
       {"i64.atomic.rmw.add", TokenType::AtomicRmw, Opcode::I64AtomicRmwAdd},
-#line 262 "src/lexer-keywords.txt"
+#line 264 "src/lexer-keywords.txt"
       {"i32.atomic.rmw.add", TokenType::AtomicRmw, Opcode::I32AtomicRmwAdd},
-#line 483 "src/lexer-keywords.txt"
-      {"i64x2.replace_lane", TokenType::SimdLaneOp, Opcode::I64X2ReplaceLane},
+      {""},
+#line 180 "src/lexer-keywords.txt"
+      {"f64x2.trunc", TokenType::Unary, Opcode::F64X2Trunc},
       {""}, {""},
-#line 558 "src/lexer-keywords.txt"
-      {"output", TokenType::Output},
+#line 393 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw32.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw32XorU},
       {""}, {""},
 #line 557 "src/lexer-keywords.txt"
-      {"offset", TokenType::Offset},
+      {"nan:canonical", TokenType::NanCanonical},
       {""}, {""},
-#line 532 "src/lexer-keywords.txt"
-      {"i8x16", TokenType::I8X16},
-      {""},
-#line 152 "src/lexer-keywords.txt"
+#line 402 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw.and", TokenType::AtomicRmw, Opcode::I64AtomicRmwAnd},
+#line 265 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw.and", TokenType::AtomicRmw, Opcode::I32AtomicRmwAnd},
+#line 154 "src/lexer-keywords.txt"
       {"f64x2.add", TokenType::Binary, Opcode::F64X2Add},
+#line 167 "src/lexer-keywords.txt"
+      {"f64x2.nearest", TokenType::Unary, Opcode::F64X2Nearest},
       {""}, {""}, {""},
-#line 162 "src/lexer-keywords.txt"
-      {"f64x2.max", TokenType::Binary, Opcode::F64X2Max},
-      {""},
-#line 463 "src/lexer-keywords.txt"
+#line 141 "src/lexer-keywords.txt"
+      {"f64.min", TokenType::Binary, Opcode::F64Min},
+#line 80 "src/lexer-keywords.txt"
+      {"f32.min", TokenType::Binary, Opcode::F32Min},
+#line 465 "src/lexer-keywords.txt"
       {"i64x2.add", TokenType::Binary, Opcode::I64X2Add},
-      {""}, {""}, {""}, {""},
-#line 156 "src/lexer-keywords.txt"
-      {"f64x2.extract_lane", TokenType::SimdLaneOp, Opcode::F64X2ExtractLane},
-      {""}, {""}, {""},
-#line 431 "src/lexer-keywords.txt"
-      {"i64.load32_u", TokenType::Load, Opcode::I64Load32U},
-      {""},
-#line 464 "src/lexer-keywords.txt"
-      {"i64x2.extract_lane", TokenType::SimdLaneOp, Opcode::I64X2ExtractLane},
-#line 115 "src/lexer-keywords.txt"
-      {"f32x4.splat", TokenType::Unary, Opcode::F32X4Splat},
-#line 430 "src/lexer-keywords.txt"
-      {"i64.load32_s", TokenType::Load, Opcode::I64Load32S},
-#line 344 "src/lexer-keywords.txt"
-      {"i32x4.min_u", TokenType::Binary, Opcode::I32X4MinU},
-#line 40 "src/lexer-keywords.txt"
-      {"catch_all", TokenType::CatchAll, Opcode::CatchAll},
-#line 343 "src/lexer-keywords.txt"
-      {"i32x4.min_s", TokenType::Binary, Opcode::I32X4MinS},
+      {""}, {""},
+#line 400 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw8.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8XorU},
+#line 263 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw8.xor_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8XorU},
       {""},
-#line 354 "src/lexer-keywords.txt"
-      {"i32x4.splat", TokenType::Unary, Opcode::I32X4Splat},
-      {""}, {""}, {""}, {""},
-#line 32 "src/lexer-keywords.txt"
-      {"block", TokenType::Block, Opcode::Block},
+#line 459 "src/lexer-keywords.txt"
+      {"i64.trunc_f64_u", TokenType::Convert, Opcode::I64TruncF64U},
+#line 315 "src/lexer-keywords.txt"
+      {"i32.trunc_f64_u", TokenType::Convert, Opcode::I32TruncF64U},
       {""},
-#line 482 "src/lexer-keywords.txt"
-      {"i64x2.relaxed_laneselect", TokenType::Ternary, Opcode::I64X2RelaxedLaneSelect},
-#line 334 "src/lexer-keywords.txt"
-      {"i32x4.relaxed_trunc_f32x4_u", TokenType::Unary, Opcode::I32X4RelaxedTruncF32X4U},
+#line 166 "src/lexer-keywords.txt"
+      {"f64x2.mul", TokenType::Binary, Opcode::F64X2Mul},
+#line 458 "src/lexer-keywords.txt"
+      {"i64.trunc_f64_s", TokenType::Convert, Opcode::I64TruncF64S},
+#line 314 "src/lexer-keywords.txt"
+      {"i32.trunc_f64_s", TokenType::Convert, Opcode::I32TruncF64S},
+#line 567 "src/lexer-keywords.txt"
+      {"ref.is_null", TokenType::RefIsNull, Opcode::RefIsNull},
+#line 605 "src/lexer-keywords.txt"
+      {"v128", Type::V128},
       {""}, {""},
-#line 421 "src/lexer-keywords.txt"
-      {"i64.extend_i32_u", TokenType::Convert, Opcode::I64ExtendI32U},
-#line 333 "src/lexer-keywords.txt"
-      {"i32x4.relaxed_trunc_f32x4_s", TokenType::Unary, Opcode::I32X4RelaxedTruncF32X4S},
-#line 420 "src/lexer-keywords.txt"
-      {"i64.extend_i32_s", TokenType::Convert, Opcode::I64ExtendI32S},
-#line 596 "src/lexer-keywords.txt"
-      {"v128.or", TokenType::Binary, Opcode::V128Or},
-      {""},
-#line 555 "src/lexer-keywords.txt"
-      {"nan:canonical", TokenType::NanCanonical},
+#line 469 "src/lexer-keywords.txt"
+      {"i64x2.mul", TokenType::Binary, Opcode::I64X2Mul},
+#line 433 "src/lexer-keywords.txt"
+      {"i64.load32_u", TokenType::Load, Opcode::I64Load32U},
       {""}, {""}, {""},
-#line 376 "src/lexer-keywords.txt"
+#line 432 "src/lexer-keywords.txt"
+      {"i64.load32_s", TokenType::Load, Opcode::I64Load32S},
+      {""}, {""}, {""}, {""},
+#line 556 "src/lexer-keywords.txt"
+      {"nan:arithmetic", TokenType::NanArithmetic},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 538 "src/lexer-keywords.txt"
+      {"invoke", TokenType::Invoke},
+      {""}, {""}, {""}, {""}, {""},
+#line 378 "src/lexer-keywords.txt"
       {"i64.atomic.load8_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad8U},
-#line 246 "src/lexer-keywords.txt"
+#line 248 "src/lexer-keywords.txt"
       {"i32.atomic.load8_u", TokenType::AtomicLoad, Opcode::I32AtomicLoad8U},
-#line 524 "src/lexer-keywords.txt"
-      {"i8x16.replace_lane", TokenType::SimdLaneOp, Opcode::I8X16ReplaceLane},
-#line 39 "src/lexer-keywords.txt"
-      {"catch", TokenType::Catch, Opcode::Catch},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 554 "src/lexer-keywords.txt"
-      {"nan:arithmetic", TokenType::NanArithmetic},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 498 "src/lexer-keywords.txt"
-      {"i8x16.add", TokenType::Binary, Opcode::I8X16Add},
       {""},
-#line 171 "src/lexer-keywords.txt"
-      {"f64x2.relaxed_max", TokenType::Binary, Opcode::F64X2RelaxedMax},
-#line 600 "src/lexer-keywords.txt"
-      {"v128.store", TokenType::Store, Opcode::V128Store},
+#line 176 "src/lexer-keywords.txt"
+      {"f64x2.replace_lane", TokenType::SimdLaneOp, Opcode::F64X2ReplaceLane},
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 485 "src/lexer-keywords.txt"
+      {"i64x2.replace_lane", TokenType::SimdLaneOp, Opcode::I64X2ReplaceLane},
       {""},
-#line 395 "src/lexer-keywords.txt"
+#line 564 "src/lexer-keywords.txt"
+      {"quote", TokenType::Quote},
+#line 32 "src/lexer-keywords.txt"
+      {"block", TokenType::Block, Opcode::Block},
+      {""}, {""},
+#line 450 "src/lexer-keywords.txt"
+      {"i64.shr_u", TokenType::Binary, Opcode::I64ShrU},
+#line 307 "src/lexer-keywords.txt"
+      {"i32.shr_u", TokenType::Binary, Opcode::I32ShrU},
+#line 449 "src/lexer-keywords.txt"
+      {"i64.shr_s", TokenType::Binary, Opcode::I64ShrS},
+#line 306 "src/lexer-keywords.txt"
+      {"i32.shr_s", TokenType::Binary, Opcode::I32ShrS},
+#line 397 "src/lexer-keywords.txt"
       {"i64.atomic.rmw8.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8OrU},
-#line 258 "src/lexer-keywords.txt"
+#line 260 "src/lexer-keywords.txt"
       {"i32.atomic.rmw8.or_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8OrU},
-#line 238 "src/lexer-keywords.txt"
+#line 240 "src/lexer-keywords.txt"
       {"i16x8", TokenType::I16X8},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""},
+#line 355 "src/lexer-keywords.txt"
+      {"i32x4.shr_u", TokenType::Binary, Opcode::I32X4ShrU},
+#line 346 "src/lexer-keywords.txt"
+      {"i32x4.min_u", TokenType::Binary, Opcode::I32X4MinU},
+#line 354 "src/lexer-keywords.txt"
+      {"i32x4.shr_s", TokenType::Binary, Opcode::I32X4ShrS},
+#line 345 "src/lexer-keywords.txt"
+      {"i32x4.min_s", TokenType::Binary, Opcode::I32X4MinS},
+#line 600 "src/lexer-keywords.txt"
+      {"v128.or", TokenType::Binary, Opcode::V128Or},
       {""},
-#line 203 "src/lexer-keywords.txt"
+#line 560 "src/lexer-keywords.txt"
+      {"output", TokenType::Output},
+      {""}, {""},
+#line 559 "src/lexer-keywords.txt"
+      {"offset", TokenType::Offset},
+      {""},
+#line 592 "src/lexer-keywords.txt"
+      {"type", TokenType::Type},
+#line 590 "src/lexer-keywords.txt"
+      {"try", TokenType::Try, Opcode::Try},
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 580 "src/lexer-keywords.txt"
+      {"table.fill", TokenType::TableFill, Opcode::TableFill},
+      {""},
+#line 484 "src/lexer-keywords.txt"
+      {"i64x2.relaxed_laneselect", TokenType::Ternary, Opcode::I64X2RelaxedLaneSelect},
+#line 478 "src/lexer-keywords.txt"
+      {"i64x2.all_true", TokenType::Unary, Opcode::I64X2AllTrue},
+      {""}, {""}, {""}, {""}, {""},
+#line 205 "src/lexer-keywords.txt"
       {"i16x8.ge_u", TokenType::Compare, Opcode::I16X8GeU},
-#line 602 "src/lexer-keywords.txt"
-      {"v128.xor", TokenType::Binary, Opcode::V128Xor},
-#line 207 "src/lexer-keywords.txt"
+#line 420 "src/lexer-keywords.txt"
+      {"i64.extend32_s", TokenType::Unary, Opcode::I64Extend32S},
+#line 209 "src/lexer-keywords.txt"
       {"i16x8.le_u", TokenType::Compare, Opcode::I16X8LeU},
       {""},
-#line 202 "src/lexer-keywords.txt"
+#line 204 "src/lexer-keywords.txt"
       {"i16x8.ge_s", TokenType::Compare, Opcode::I16X8GeS},
-      {""},
-#line 206 "src/lexer-keywords.txt"
+#line 40 "src/lexer-keywords.txt"
+      {"catch_all", TokenType::CatchAll, Opcode::CatchAll},
+#line 208 "src/lexer-keywords.txt"
       {"i16x8.le_s", TokenType::Compare, Opcode::I16X8LeS},
-      {""},
-#line 205 "src/lexer-keywords.txt"
+#line 336 "src/lexer-keywords.txt"
+      {"i32x4.relaxed_trunc_f32x4_u", TokenType::Unary, Opcode::I32X4RelaxedTruncF32X4U},
+#line 207 "src/lexer-keywords.txt"
       {"i16x8.gt_u", TokenType::Compare, Opcode::I16X8GtU},
-#line 476 "src/lexer-keywords.txt"
-      {"i64x2.all_true", TokenType::Unary, Opcode::I64X2AllTrue},
-#line 211 "src/lexer-keywords.txt"
+      {""},
+#line 213 "src/lexer-keywords.txt"
       {"i16x8.lt_u", TokenType::Compare, Opcode::I16X8LtU},
-#line 172 "src/lexer-keywords.txt"
-      {"f64x2.relaxed_min", TokenType::Binary, Opcode::F64X2RelaxedMin},
-#line 204 "src/lexer-keywords.txt"
+#line 335 "src/lexer-keywords.txt"
+      {"i32x4.relaxed_trunc_f32x4_s", TokenType::Unary, Opcode::I32X4RelaxedTruncF32X4S},
+#line 206 "src/lexer-keywords.txt"
       {"i16x8.gt_s", TokenType::Compare, Opcode::I16X8GtS},
       {""},
-#line 210 "src/lexer-keywords.txt"
+#line 212 "src/lexer-keywords.txt"
       {"i16x8.lt_s", TokenType::Compare, Opcode::I16X8LtS},
+      {""}, {""},
+#line 70 "src/lexer-keywords.txt"
+      {"f32.demote_f64", TokenType::Convert, Opcode::F32DemoteF64},
       {""},
-#line 523 "src/lexer-keywords.txt"
-      {"i8x16.relaxed_laneselect", TokenType::Ternary, Opcode::I8X16RelaxedLaneSelect},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 588 "src/lexer-keywords.txt"
-      {"type", TokenType::Type},
-#line 404 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw.xchg", TokenType::AtomicRmw, Opcode::I64AtomicRmwXchg},
-#line 267 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw.xchg", TokenType::AtomicRmw, Opcode::I32AtomicRmwXchg},
+#line 164 "src/lexer-keywords.txt"
+      {"f64x2.max", TokenType::Binary, Opcode::F64X2Max},
       {""},
-#line 595 "src/lexer-keywords.txt"
-      {"v128.not", TokenType::Unary, Opcode::V128Not},
+#line 117 "src/lexer-keywords.txt"
+      {"f32x4.splat", TokenType::Unary, Opcode::F32X4Splat},
+#line 604 "src/lexer-keywords.txt"
+      {"v128.store", TokenType::Store, Opcode::V128Store},
+#line 537 "src/lexer-keywords.txt"
+      {"input", TokenType::Input},
       {""}, {""},
-#line 614 "src/lexer-keywords.txt"
-      {"v128.store64_lane", TokenType::SimdStoreLane, Opcode::V128Store64Lane},
-#line 219 "src/lexer-keywords.txt"
-      {"i16x8.neg", TokenType::Unary, Opcode::I16X8Neg},
+#line 572 "src/lexer-keywords.txt"
+      {"return_call_indirect", TokenType::ReturnCallIndirect, Opcode::ReturnCallIndirect},
       {""},
-#line 221 "src/lexer-keywords.txt"
-      {"i16x8.ne", TokenType::Compare, Opcode::I16X8Ne},
-#line 607 "src/lexer-keywords.txt"
-      {"v128.load8_lane", TokenType::SimdLoadLane, Opcode::V128Load8Lane},
-#line 466 "src/lexer-keywords.txt"
-      {"v128.load32x2_u", TokenType::Load, Opcode::V128Load32X2U},
+#line 356 "src/lexer-keywords.txt"
+      {"i32x4.splat", TokenType::Unary, Opcode::I32X4Splat},
+#line 508 "src/lexer-keywords.txt"
+      {"i8x16.ge_u", TokenType::Compare, Opcode::I8X16GeU},
+#line 33 "src/lexer-keywords.txt"
+      {"br_if", TokenType::BrIf, Opcode::BrIf},
+#line 512 "src/lexer-keywords.txt"
+      {"i8x16.le_u", TokenType::Compare, Opcode::I8X16LeU},
       {""},
-#line 484 "src/lexer-keywords.txt"
-      {"i64x2.shl", TokenType::Binary, Opcode::I64X2Shl},
+#line 507 "src/lexer-keywords.txt"
+      {"i8x16.ge_s", TokenType::Compare, Opcode::I8X16GeS},
       {""},
-#line 465 "src/lexer-keywords.txt"
-      {"v128.load32x2_s", TokenType::Load, Opcode::V128Load32X2S},
-      {""}, {""}, {""},
-#line 209 "src/lexer-keywords.txt"
-      {"v128.load8x8_u", TokenType::Load, Opcode::V128Load8X8U},
+#line 511 "src/lexer-keywords.txt"
+      {"i8x16.le_s", TokenType::Compare, Opcode::I8X16LeS},
       {""},
-#line 208 "src/lexer-keywords.txt"
-      {"v128.load8x8_s", TokenType::Load, Opcode::V128Load8X8S},
-#line 42 "src/lexer-keywords.txt"
-      {"data.drop", TokenType::DataDrop, Opcode::DataDrop},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 535 "src/lexer-keywords.txt"
-      {"input", TokenType::Input},
-      {""}, {""},
-#line 594 "src/lexer-keywords.txt"
+#line 510 "src/lexer-keywords.txt"
+      {"i8x16.gt_u", TokenType::Compare, Opcode::I8X16GtU},
+#line 536 "src/lexer-keywords.txt"
+      {"import", TokenType::Import},
+#line 514 "src/lexer-keywords.txt"
+      {"i8x16.lt_u", TokenType::Compare, Opcode::I8X16LtU},
+      {""},
+#line 509 "src/lexer-keywords.txt"
+      {"i8x16.gt_s", TokenType::Compare, Opcode::I8X16GtS},
+      {""},
+#line 513 "src/lexer-keywords.txt"
+      {"i8x16.lt_s", TokenType::Compare, Opcode::I8X16LtS},
+      {""}, {""}, {""}, {""}, {""},
+#line 598 "src/lexer-keywords.txt"
       {"v128.load", TokenType::Load, Opcode::V128Load},
-#line 606 "src/lexer-keywords.txt"
-      {"v128.load8_splat", TokenType::Load, Opcode::V128Load8Splat},
+#line 158 "src/lexer-keywords.txt"
+      {"f64x2.extract_lane", TokenType::SimdLaneOp, Opcode::F64X2ExtractLane},
+      {""}, {""},
+#line 221 "src/lexer-keywords.txt"
+      {"i16x8.neg", TokenType::Unary, Opcode::I16X8Neg},
       {""},
-#line 534 "src/lexer-keywords.txt"
-      {"import", TokenType::Import},
-      {""}, {""}, {""},
-#line 499 "src/lexer-keywords.txt"
-      {"i8x16.all_true", TokenType::Unary, Opcode::I8X16AllTrue},
-#line 530 "src/lexer-keywords.txt"
-      {"i8x16.sub_sat_u", TokenType::Binary, Opcode::I8X16SubSatU},
-#line 146 "src/lexer-keywords.txt"
+#line 223 "src/lexer-keywords.txt"
+      {"i16x8.ne", TokenType::Compare, Opcode::I16X8Ne},
+#line 423 "src/lexer-keywords.txt"
+      {"i64.extend_i32_u", TokenType::Convert, Opcode::I64ExtendI32U},
+#line 466 "src/lexer-keywords.txt"
+      {"i64x2.extract_lane", TokenType::SimdLaneOp, Opcode::I64X2ExtractLane},
+#line 422 "src/lexer-keywords.txt"
+      {"i64.extend_i32_s", TokenType::Convert, Opcode::I64ExtendI32S},
+      {""}, {""},
+#line 148 "src/lexer-keywords.txt"
       {"f64.sqrt", TokenType::Unary, Opcode::F64Sqrt},
-#line 84 "src/lexer-keywords.txt"
+#line 86 "src/lexer-keywords.txt"
       {"f32.sqrt", TokenType::Unary, Opcode::F32Sqrt},
+#line 211 "src/lexer-keywords.txt"
+      {"v128.load8x8_u", TokenType::Load, Opcode::V128Load8X8U},
       {""},
-#line 529 "src/lexer-keywords.txt"
-      {"i8x16.sub_sat_s", TokenType::Binary, Opcode::I8X16SubSatS},
+#line 210 "src/lexer-keywords.txt"
+      {"v128.load8x8_s", TokenType::Load, Opcode::V128Load8X8S},
+#line 611 "src/lexer-keywords.txt"
+      {"v128.load8_lane", TokenType::SimdLoadLane, Opcode::V128Load8Lane},
+#line 406 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw.xchg", TokenType::AtomicRmw, Opcode::I64AtomicRmwXchg},
+#line 269 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw.xchg", TokenType::AtomicRmw, Opcode::I32AtomicRmwXchg},
+      {""}, {""}, {""},
+#line 184 "src/lexer-keywords.txt"
+      {"f64x2", TokenType::F64X2},
       {""}, {""},
-#line 116 "src/lexer-keywords.txt"
+#line 610 "src/lexer-keywords.txt"
+      {"v128.load8_splat", TokenType::Load, Opcode::V128Load8Splat},
+      {""},
+#line 599 "src/lexer-keywords.txt"
+      {"v128.not", TokenType::Unary, Opcode::V128Not},
+#line 618 "src/lexer-keywords.txt"
+      {"v128.store64_lane", TokenType::SimdStoreLane, Opcode::V128Store64Lane},
+#line 495 "src/lexer-keywords.txt"
+      {"i64x2", TokenType::I64X2},
+#line 118 "src/lexer-keywords.txt"
       {"f32x4.sqrt", TokenType::Unary, Opcode::F32X4Sqrt},
-#line 570 "src/lexer-keywords.txt"
-      {"return_call_indirect", TokenType::ReturnCallIndirect, Opcode::ReturnCallIndirect},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 397 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw8.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8XchgU},
-#line 260 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw8.xchg_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8XchgU},
       {""},
-#line 374 "src/lexer-keywords.txt"
-      {"i64.atomic.load16_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad16U},
-#line 245 "src/lexer-keywords.txt"
-      {"i32.atomic.load16_u", TokenType::AtomicLoad, Opcode::I32AtomicLoad16U},
-      {""}, {""},
-#line 108 "src/lexer-keywords.txt"
-      {"f32x4.pmax", TokenType::Binary, Opcode::F32X4PMax},
-      {""}, {""}, {""}, {""},
-#line 593 "src/lexer-keywords.txt"
-      {"v128.const", TokenType::Const, Opcode::V128Const},
-#line 173 "src/lexer-keywords.txt"
-      {"f64x2.relaxed_nmadd", TokenType::Ternary, Opcode::F64X2RelaxedNmadd},
+#line 521 "src/lexer-keywords.txt"
+      {"i8x16.neg", TokenType::Unary, Opcode::I8X16Neg},
       {""},
-#line 525 "src/lexer-keywords.txt"
-      {"i8x16.shl", TokenType::Binary, Opcode::I8X16Shl},
+#line 523 "src/lexer-keywords.txt"
+      {"i8x16.ne", TokenType::Compare, Opcode::I8X16Ne},
+#line 44 "src/lexer-keywords.txt"
+      {"data.drop", TokenType::DataDrop, Opcode::DataDrop},
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 451 "src/lexer-keywords.txt"
+      {"i64.store16", TokenType::Store, Opcode::I64Store16},
+#line 308 "src/lexer-keywords.txt"
+      {"i32.store16", TokenType::Store, Opcode::I32Store16},
       {""},
-#line 591 "src/lexer-keywords.txt"
-      {"v128.and", TokenType::Binary, Opcode::V128And},
-#line 533 "src/lexer-keywords.txt"
-      {"if", TokenType::If, Opcode::If},
-#line 561 "src/lexer-keywords.txt"
-      {"ref", TokenType::Ref},
+#line 186 "src/lexer-keywords.txt"
+      {"funcref", Type::FuncRef},
+#line 196 "src/lexer-keywords.txt"
+      {"i16x8.add", TokenType::Binary, Opcode::I16X8Add},
       {""}, {""}, {""},
-#line 551 "src/lexer-keywords.txt"
-      {"memory", TokenType::Memory},
+#line 597 "src/lexer-keywords.txt"
+      {"v128.const", TokenType::Const, Opcode::V128Const},
       {""},
-#line 109 "src/lexer-keywords.txt"
-      {"f32x4.pmin", TokenType::Binary, Opcode::F32X4PMin},
-#line 216 "src/lexer-keywords.txt"
-      {"i16x8.mul", TokenType::Binary, Opcode::I16X8Mul},
-      {""}, {""}, {""}, {""},
-#line 590 "src/lexer-keywords.txt"
-      {"v128.andnot", TokenType::Binary, Opcode::V128Andnot},
-#line 51 "src/lexer-keywords.txt"
-      {"else", TokenType::Else, Opcode::Else},
-#line 48 "src/lexer-keywords.txt"
-      {"either", TokenType::Either},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 182 "src/lexer-keywords.txt"
-      {"f64x2", TokenType::F64X2},
+#line 606 "src/lexer-keywords.txt"
+      {"v128.xor", TokenType::Binary, Opcode::V128Xor},
       {""}, {""}, {""}, {""}, {""},
-#line 493 "src/lexer-keywords.txt"
-      {"i64x2", TokenType::I64X2},
-      {""},
-#line 324 "src/lexer-keywords.txt"
-      {"i32x4.relaxed_dot_i8x16_i7x16_add_s", TokenType::Ternary, Opcode::I32X4DotI8X16I7X16AddS},
-#line 224 "src/lexer-keywords.txt"
-      {"i16x8.replace_lane", TokenType::SimdLaneOp, Opcode::I16X8ReplaceLane},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 585 "src/lexer-keywords.txt"
-      {"then", TokenType::Then},
+#line 174 "src/lexer-keywords.txt"
+      {"f64x2.relaxed_min", TokenType::Binary, Opcode::F64X2RelaxedMin},
       {""},
-#line 612 "src/lexer-keywords.txt"
-      {"v128.store16_lane", TokenType::SimdStoreLane, Opcode::V128Store16Lane},
-      {""}, {""}, {""}, {""},
-#line 163 "src/lexer-keywords.txt"
-      {"f64x2.min", TokenType::Binary, Opcode::F64X2Min},
+#line 175 "src/lexer-keywords.txt"
+      {"f64x2.relaxed_nmadd", TokenType::Ternary, Opcode::F64X2RelaxedNmadd},
       {""},
-#line 170 "src/lexer-keywords.txt"
-      {"f64x2.relaxed_madd", TokenType::Ternary, Opcode::F64X2RelaxedMadd},
-#line 194 "src/lexer-keywords.txt"
-      {"i16x8.add", TokenType::Binary, Opcode::I16X8Add},
+#line 218 "src/lexer-keywords.txt"
+      {"i16x8.mul", TokenType::Binary, Opcode::I16X8Mul},
       {""},
-#line 31 "src/lexer-keywords.txt"
-      {"binary", TokenType::Bin},
-#line 497 "src/lexer-keywords.txt"
-      {"i8x16.add_sat_u", TokenType::Binary, Opcode::I8X16AddSatU},
-#line 387 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw32.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw32CmpxchgU},
+#line 376 "src/lexer-keywords.txt"
+      {"i64.atomic.load16_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad16U},
+#line 247 "src/lexer-keywords.txt"
+      {"i32.atomic.load16_u", TokenType::AtomicLoad, Opcode::I32AtomicLoad16U},
+      {""}, {""}, {""},
+#line 39 "src/lexer-keywords.txt"
+      {"catch", TokenType::Catch, Opcode::Catch},
       {""}, {""},
-#line 496 "src/lexer-keywords.txt"
-      {"i8x16.add_sat_s", TokenType::Binary, Opcode::I8X16AddSatS},
-#line 416 "src/lexer-keywords.txt"
-      {"i64.eqz", TokenType::Convert, Opcode::I64Eqz},
-#line 278 "src/lexer-keywords.txt"
-      {"i32.eqz", TokenType::Convert, Opcode::I32Eqz},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 514 "src/lexer-keywords.txt"
-      {"i8x16.max_u", TokenType::Binary, Opcode::I8X16MaxU},
+#line 486 "src/lexer-keywords.txt"
+      {"i64x2.shl", TokenType::Binary, Opcode::I64X2Shl},
+      {""}, {""},
+#line 500 "src/lexer-keywords.txt"
+      {"i8x16.add", TokenType::Binary, Opcode::I8X16Add},
       {""},
-#line 513 "src/lexer-keywords.txt"
-      {"i8x16.max_s", TokenType::Binary, Opcode::I8X16MaxS},
+#line 595 "src/lexer-keywords.txt"
+      {"v128.and", TokenType::Binary, Opcode::V128And},
+      {""}, {""}, {""}, {""},
+#line 534 "src/lexer-keywords.txt"
+      {"i8x16", TokenType::I8X16},
       {""}, {""},
 #line 52 "src/lexer-keywords.txt"
-      {"end", TokenType::End, Opcode::End},
+      {"elem", TokenType::Elem},
       {""},
-#line 222 "src/lexer-keywords.txt"
-      {"i16x8.relaxed_laneselect", TokenType::Ternary, Opcode::I16X8RelaxedLaneSelect},
-      {""}, {""}, {""},
-#line 190 "src/lexer-keywords.txt"
-      {"global", TokenType::Global},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 57 "src/lexer-keywords.txt"
+      {"externref", Type::ExternRef},
+      {""}, {""},
+#line 594 "src/lexer-keywords.txt"
+      {"v128.andnot", TokenType::Binary, Opcode::V128Andnot},
+      {""}, {""},
+#line 384 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw16.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16SubU},
+#line 254 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw16.sub_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16SubU},
       {""},
-#line 54 "src/lexer-keywords.txt"
-      {"extern", Type::ExternRef, TokenType::Extern},
-      {""}, {""}, {""}, {""}, {""}, {""},
+#line 226 "src/lexer-keywords.txt"
+      {"i16x8.replace_lane", TokenType::SimdLaneOp, Opcode::I16X8ReplaceLane},
+      {""}, {""},
+#line 159 "src/lexer-keywords.txt"
+      {"f64x2.floor", TokenType::Unary, Opcode::F64X2Floor},
+      {""}, {""},
+#line 468 "src/lexer-keywords.txt"
+      {"v128.load32x2_u", TokenType::Load, Opcode::V128Load32X2U},
+#line 172 "src/lexer-keywords.txt"
+      {"f64x2.relaxed_madd", TokenType::Ternary, Opcode::F64X2RelaxedMadd},
+      {""}, {""},
+#line 467 "src/lexer-keywords.txt"
+      {"v128.load32x2_s", TokenType::Load, Opcode::V128Load32X2S},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""},
 #line 36 "src/lexer-keywords.txt"
       {"call_indirect", TokenType::CallIndirect, Opcode::CallIndirect},
-#line 97 "src/lexer-keywords.txt"
-      {"f32x4.floor", TokenType::Unary, Opcode::F32X4Floor},
-      {""}, {""}, {""},
-#line 504 "src/lexer-keywords.txt"
-      {"i8x16.extract_lane_u", TokenType::SimdLaneOp, Opcode::I8X16ExtractLaneU},
-      {""},
-#line 503 "src/lexer-keywords.txt"
-      {"i8x16.extract_lane_s", TokenType::SimdLaneOp, Opcode::I8X16ExtractLaneS},
-#line 56 "src/lexer-keywords.txt"
-      {"exn", Type::ExnRef, TokenType::Exn},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 188 "src/lexer-keywords.txt"
-      {"global.get", TokenType::GlobalGet, Opcode::GlobalGet},
       {""},
-#line 189 "src/lexer-keywords.txt"
-      {"global.set", TokenType::GlobalSet, Opcode::GlobalSet},
-      {""}, {""}, {""},
-#line 537 "src/lexer-keywords.txt"
-      {"item", TokenType::Item},
-      {""}, {""}, {""},
-#line 195 "src/lexer-keywords.txt"
-      {"i16x8.all_true", TokenType::Unary, Opcode::I16X8AllTrue},
-#line 230 "src/lexer-keywords.txt"
-      {"i16x8.sub_sat_u", TokenType::Binary, Opcode::I16X8SubSatU},
-      {""},
-#line 577 "src/lexer-keywords.txt"
-      {"table.copy", TokenType::TableCopy, Opcode::TableCopy},
-      {""},
-#line 229 "src/lexer-keywords.txt"
-      {"i16x8.sub_sat_s", TokenType::Binary, Opcode::I16X8SubSatS},
-      {""},
-#line 522 "src/lexer-keywords.txt"
-      {"i8x16.relaxed_swizzle", TokenType::Binary, Opcode::I8X16RelaxedSwizzle},
-      {""}, {""},
-#line 604 "src/lexer-keywords.txt"
-      {"v128.load32_splat", TokenType::Load, Opcode::V128Load32Splat},
+#line 526 "src/lexer-keywords.txt"
+      {"i8x16.replace_lane", TokenType::SimdLaneOp, Opcode::I8X16ReplaceLane},
       {""}, {""}, {""}, {""}, {""},
-#line 486 "src/lexer-keywords.txt"
-      {"i64x2.shr_u", TokenType::Binary, Opcode::I64X2ShrU},
-      {""},
-#line 485 "src/lexer-keywords.txt"
-      {"i64x2.shr_s", TokenType::Binary, Opcode::I64X2ShrS},
-#line 611 "src/lexer-keywords.txt"
-      {"v128.store8_lane", TokenType::SimdStoreLane, Opcode::V128Store8Lane},
-      {""},
-#line 183 "src/lexer-keywords.txt"
-      {"field", TokenType::Field},
-      {""},
-#line 609 "src/lexer-keywords.txt"
-      {"v128.load32_lane", TokenType::SimdLoadLane, Opcode::V128Load32Lane},
+#line 165 "src/lexer-keywords.txt"
+      {"f64x2.min", TokenType::Binary, Opcode::F64X2Min},
+#line 383 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw16.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16OrU},
+#line 253 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw16.or_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16OrU},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 224 "src/lexer-keywords.txt"
+      {"i16x8.relaxed_laneselect", TokenType::Ternary, Opcode::I16X8RelaxedLaneSelect},
+#line 197 "src/lexer-keywords.txt"
+      {"i16x8.all_true", TokenType::Unary, Opcode::I16X8AllTrue},
       {""}, {""},
 #line 21 "src/lexer-keywords.txt"
       {"after", TokenType::After},
-      {""}, {""}, {""}, {""},
-#line 225 "src/lexer-keywords.txt"
-      {"i16x8.shl", TokenType::Binary, Opcode::I16X8Shl},
-#line 132 "src/lexer-keywords.txt"
-      {"f64.floor", TokenType::Unary, Opcode::F64Floor},
-#line 71 "src/lexer-keywords.txt"
-      {"f32.floor", TokenType::Unary, Opcode::F32Floor},
-#line 560 "src/lexer-keywords.txt"
-      {"param", TokenType::Param},
+#line 552 "src/lexer-keywords.txt"
+      {"memory.size", TokenType::MemorySize, Opcode::MemorySize},
+#line 173 "src/lexer-keywords.txt"
+      {"f64x2.relaxed_max", TokenType::Binary, Opcode::F64X2RelaxedMax},
+#line 380 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw16.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16AddU},
+#line 250 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw16.add_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16AddU},
+#line 399 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw8.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8XchgU},
+#line 262 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw8.xchg_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8XchgU},
+#line 232 "src/lexer-keywords.txt"
+      {"i16x8.sub_sat_u", TokenType::Binary, Opcode::I16X8SubSatU},
+      {""}, {""}, {""},
+#line 231 "src/lexer-keywords.txt"
+      {"i16x8.sub_sat_s", TokenType::Binary, Opcode::I16X8SubSatS},
+      {""}, {""}, {""},
+#line 381 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw16.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16AndU},
+#line 251 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw16.and_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16AndU},
+#line 347 "src/lexer-keywords.txt"
+      {"i32x4.dot_i16x8_s", TokenType::Binary, Opcode::I32X4DotI16X8S},
       {""},
-#line 549 "src/lexer-keywords.txt"
-      {"memory.init", TokenType::MemoryInit, Opcode::MemoryInit},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 117 "src/lexer-keywords.txt"
-      {"f32x4.sub", TokenType::Binary, Opcode::F32X4Sub},
+#line 389 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw32.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw32CmpxchgU},
+      {""}, {""}, {""}, {""}, {""},
+#line 525 "src/lexer-keywords.txt"
+      {"i8x16.relaxed_laneselect", TokenType::Ternary, Opcode::I8X16RelaxedLaneSelect},
+#line 501 "src/lexer-keywords.txt"
+      {"i8x16.all_true", TokenType::Unary, Opcode::I8X16AllTrue},
       {""}, {""}, {""}, {""},
-#line 598 "src/lexer-keywords.txt"
-      {"v128.load32_zero", TokenType::Load, Opcode::V128Load32Zero},
-#line 355 "src/lexer-keywords.txt"
-      {"i32x4.sub", TokenType::Binary, Opcode::I32X4Sub},
-      {""}, {""}, {""},
-#line 564 "src/lexer-keywords.txt"
-      {"ref.func", TokenType::RefFunc, Opcode::RefFunc},
+#line 577 "src/lexer-keywords.txt"
+      {"start", TokenType::Start},
       {""},
-#line 121 "src/lexer-keywords.txt"
+#line 123 "src/lexer-keywords.txt"
       {"f64.abs", TokenType::Unary, Opcode::F64Abs},
-#line 59 "src/lexer-keywords.txt"
+#line 61 "src/lexer-keywords.txt"
       {"f32.abs", TokenType::Unary, Opcode::F32Abs},
-#line 575 "src/lexer-keywords.txt"
-      {"start", TokenType::Start},
-#line 449 "src/lexer-keywords.txt"
-      {"i64.store16", TokenType::Store, Opcode::I64Store16},
-#line 306 "src/lexer-keywords.txt"
-      {"i32.store16", TokenType::Store, Opcode::I32Store16},
-#line 89 "src/lexer-keywords.txt"
-      {"f32x4.abs", TokenType::Unary, Opcode::F32X4Abs},
-      {""}, {""}, {""}, {""}, {""},
-#line 320 "src/lexer-keywords.txt"
-      {"i32x4.abs", TokenType::Unary, Opcode::I32X4Abs},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 527 "src/lexer-keywords.txt"
-      {"i8x16.shr_u", TokenType::Binary, Opcode::I8X16ShrU},
       {""},
-#line 526 "src/lexer-keywords.txt"
-      {"i8x16.shr_s", TokenType::Binary, Opcode::I8X16ShrS},
+#line 532 "src/lexer-keywords.txt"
+      {"i8x16.sub_sat_u", TokenType::Binary, Opcode::I8X16SubSatU},
       {""}, {""}, {""},
-#line 597 "src/lexer-keywords.txt"
-      {"v128.any_true", TokenType::Unary, Opcode::V128AnyTrue},
+#line 531 "src/lexer-keywords.txt"
+      {"i8x16.sub_sat_s", TokenType::Binary, Opcode::I8X16SubSatS},
+#line 616 "src/lexer-keywords.txt"
+      {"v128.store16_lane", TokenType::SimdStoreLane, Opcode::V128Store16Lane},
       {""}, {""}, {""}, {""}, {""}, {""},
-#line 193 "src/lexer-keywords.txt"
-      {"i16x8.add_sat_u", TokenType::Binary, Opcode::I16X8AddSatU},
+#line 119 "src/lexer-keywords.txt"
+      {"f32x4.sub", TokenType::Binary, Opcode::F32X4Sub},
       {""}, {""},
-#line 175 "src/lexer-keywords.txt"
-      {"f64x2.splat", TokenType::Unary, Opcode::F64X2Splat},
-#line 192 "src/lexer-keywords.txt"
-      {"i16x8.add_sat_s", TokenType::Binary, Opcode::I16X8AddSatS},
-      {""}, {""}, {""}, {""},
-#line 487 "src/lexer-keywords.txt"
-      {"i64x2.splat", TokenType::Unary, Opcode::I64X2Splat},
-      {""}, {""}, {""}, {""}, {""},
-#line 213 "src/lexer-keywords.txt"
-      {"i16x8.max_u", TokenType::Binary, Opcode::I16X8MaxU},
+#line 91 "src/lexer-keywords.txt"
+      {"f32x4.abs", TokenType::Unary, Opcode::F32X4Abs},
       {""},
-#line 212 "src/lexer-keywords.txt"
-      {"i16x8.max_s", TokenType::Binary, Opcode::I16X8MaxS},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""},
-#line 605 "src/lexer-keywords.txt"
-      {"v128.load64_splat", TokenType::Load, Opcode::V128Load64Splat},
-      {""}, {""}, {""},
-#line 375 "src/lexer-keywords.txt"
-      {"i64.atomic.load32_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad32U},
+#line 608 "src/lexer-keywords.txt"
+      {"v128.load32_splat", TokenType::Load, Opcode::V128Load32Splat},
+#line 562 "src/lexer-keywords.txt"
+      {"param", TokenType::Param},
+#line 357 "src/lexer-keywords.txt"
+      {"i32x4.sub", TokenType::Binary, Opcode::I32X4Sub},
+#line 96 "src/lexer-keywords.txt"
+      {"f32x4.div", TokenType::Binary, Opcode::F32X4Div},
+#line 602 "src/lexer-keywords.txt"
+      {"v128.load32_zero", TokenType::Load, Opcode::V128Load32Zero},
+#line 322 "src/lexer-keywords.txt"
+      {"i32x4.abs", TokenType::Unary, Opcode::I32X4Abs},
 #line 34 "src/lexer-keywords.txt"
       {"br_table", TokenType::BrTable, Opcode::BrTable},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 610 "src/lexer-keywords.txt"
-      {"v128.load64_lane", TokenType::SimdLoadLane, Opcode::V128Load64Lane},
-#line 94 "src/lexer-keywords.txt"
-      {"f32x4.div", TokenType::Binary, Opcode::F32X4Div},
       {""}, {""}, {""},
-#line 201 "src/lexer-keywords.txt"
-      {"i16x8.extract_lane_u", TokenType::SimdLaneOp, Opcode::I16X8ExtractLaneU},
-      {""},
-#line 200 "src/lexer-keywords.txt"
-      {"i16x8.extract_lane_s", TokenType::SimdLaneOp, Opcode::I16X8ExtractLaneS},
+#line 195 "src/lexer-keywords.txt"
+      {"i16x8.add_sat_u", TokenType::Binary, Opcode::I16X8AddSatU},
+      {""}, {""}, {""},
+#line 194 "src/lexer-keywords.txt"
+      {"i16x8.add_sat_s", TokenType::Binary, Opcode::I16X8AddSatS},
       {""},
-#line 401 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw.cmpxchg", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmwCmpxchg},
-#line 264 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw.cmpxchg", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmwCmpxchg},
+#line 111 "src/lexer-keywords.txt"
+      {"f32x4.pmin", TokenType::Binary, Opcode::F32X4PMin},
+#line 31 "src/lexer-keywords.txt"
+      {"binary", TokenType::Bin},
       {""}, {""}, {""}, {""}, {""}, {""},
-#line 548 "src/lexer-keywords.txt"
-      {"memory.grow", TokenType::MemoryGrow, Opcode::MemoryGrow},
-#line 516 "src/lexer-keywords.txt"
-      {"i8x16.min_u", TokenType::Binary, Opcode::I8X16MinU},
+#line 463 "src/lexer-keywords.txt"
+      {"i64.trunc_sat_f64_u", TokenType::Convert, Opcode::I64TruncSatF64U},
+#line 319 "src/lexer-keywords.txt"
+      {"i32.trunc_sat_f64_u", TokenType::Convert, Opcode::I32TruncSatF64U},
+#line 385 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw16.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16XchgU},
+#line 255 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw16.xchg_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16XchgU},
+#line 462 "src/lexer-keywords.txt"
+      {"i64.trunc_sat_f64_s", TokenType::Convert, Opcode::I64TruncSatF64S},
+#line 318 "src/lexer-keywords.txt"
+      {"i32.trunc_sat_f64_s", TokenType::Convert, Opcode::I32TruncSatF64S},
+      {""}, {""},
+#line 613 "src/lexer-keywords.txt"
+      {"v128.load32_lane", TokenType::SimdLoadLane, Opcode::V128Load32Lane},
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 499 "src/lexer-keywords.txt"
+      {"i8x16.add_sat_u", TokenType::Binary, Opcode::I8X16AddSatU},
+#line 377 "src/lexer-keywords.txt"
+      {"i64.atomic.load32_u", TokenType::AtomicLoad, Opcode::I64AtomicLoad32U},
       {""},
-#line 515 "src/lexer-keywords.txt"
-      {"i8x16.min_s", TokenType::Binary, Opcode::I8X16MinS},
+#line 615 "src/lexer-keywords.txt"
+      {"v128.store8_lane", TokenType::SimdStoreLane, Opcode::V128Store8Lane},
+#line 498 "src/lexer-keywords.txt"
+      {"i8x16.add_sat_s", TokenType::Binary, Opcode::I8X16AddSatS},
       {""},
-#line 528 "src/lexer-keywords.txt"
-      {"i8x16.splat", TokenType::Unary, Opcode::I8X16Splat},
-      {""}, {""},
-#line 599 "src/lexer-keywords.txt"
-      {"v128.load64_zero", TokenType::Load, Opcode::V128Load64Zero},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 586 "src/lexer-keywords.txt"
-      {"throw", TokenType::Throw, Opcode::Throw},
+#line 386 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw16.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16XorU},
+#line 256 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw16.xor_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16XorU},
       {""},
-#line 68 "src/lexer-keywords.txt"
-      {"f32.demote_f64", TokenType::Convert, Opcode::F32DemoteF64},
-      {""}, {""},
-#line 382 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw16.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16SubU},
-#line 252 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw16.sub_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16SubU},
+#line 192 "src/lexer-keywords.txt"
+      {"global", TokenType::Global},
+#line 215 "src/lexer-keywords.txt"
+      {"i16x8.max_u", TokenType::Binary, Opcode::I16X8MaxU},
       {""},
-#line 47 "src/lexer-keywords.txt"
-      {"drop", TokenType::Drop, Opcode::Drop},
-      {""}, {""}, {""},
-#line 613 "src/lexer-keywords.txt"
-      {"v128.store32_lane", TokenType::SimdStoreLane, Opcode::V128Store32Lane},
-      {""}, {""}, {""}, {""}, {""},
-#line 574 "src/lexer-keywords.txt"
-      {"shared", TokenType::Shared},
-#line 616 "src/lexer-keywords.txt"
-      {"i8x16.swizzle", TokenType::Binary, Opcode::I8X16Swizzle},
+#line 214 "src/lexer-keywords.txt"
+      {"i16x8.max_s", TokenType::Binary, Opcode::I16X8MaxS},
       {""}, {""}, {""}, {""},
-#line 578 "src/lexer-keywords.txt"
-      {"table.fill", TokenType::TableFill, Opcode::TableFill},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 394 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw8.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw8CmpxchgU},
-#line 257 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw8.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmw8CmpxchgU},
-#line 119 "src/lexer-keywords.txt"
-      {"f32x4.demote_f64x2_zero", TokenType::Unary, Opcode::F32X4DemoteF64X2Zero},
+#line 488 "src/lexer-keywords.txt"
+      {"i64x2.shr_u", TokenType::Binary, Opcode::I64X2ShrU},
+      {""},
+#line 487 "src/lexer-keywords.txt"
+      {"i64x2.shr_s", TokenType::Binary, Opcode::I64X2ShrS},
+      {""},
+#line 549 "src/lexer-keywords.txt"
+      {"memory.fill", TokenType::MemoryFill, Opcode::MemoryFill},
+      {""}, {""}, {""}, {""},
+#line 326 "src/lexer-keywords.txt"
+      {"i32x4.relaxed_dot_i8x16_i7x16_add_s", TokenType::Ternary, Opcode::I32X4DotI8X16I7X16AddS},
+#line 41 "src/lexer-keywords.txt"
+      {"catch_ref", TokenType::CatchRef},
       {""}, {""}, {""},
-#line 589 "src/lexer-keywords.txt"
-      {"unreachable", TokenType::Unreachable, Opcode::Unreachable},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 579 "src/lexer-keywords.txt"
+      {"table.copy", TokenType::TableCopy, Opcode::TableCopy},
+      {""},
+#line 227 "src/lexer-keywords.txt"
+      {"i16x8.shl", TokenType::Binary, Opcode::I16X8Shl},
       {""}, {""}, {""}, {""}, {""},
-#line 176 "src/lexer-keywords.txt"
-      {"f64x2.sqrt", TokenType::Unary, Opcode::F64X2Sqrt},
-      {""}, {""},
-#line 407 "src/lexer-keywords.txt"
-      {"i64.atomic.store32", TokenType::AtomicStore, Opcode::I64AtomicStore32},
+#line 516 "src/lexer-keywords.txt"
+      {"i8x16.max_u", TokenType::Binary, Opcode::I8X16MaxU},
       {""},
-#line 128 "src/lexer-keywords.txt"
+#line 515 "src/lexer-keywords.txt"
+      {"i8x16.max_s", TokenType::Binary, Opcode::I8X16MaxS},
+      {""}, {""},
+#line 576 "src/lexer-keywords.txt"
+      {"shared", TokenType::Shared},
+#line 130 "src/lexer-keywords.txt"
       {"f64.convert_i64_u", TokenType::Convert, Opcode::F64ConvertI64U},
-#line 66 "src/lexer-keywords.txt"
+#line 68 "src/lexer-keywords.txt"
       {"f32.convert_i64_u", TokenType::Convert, Opcode::F32ConvertI64U},
-#line 379 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw16.and_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16AndU},
-#line 249 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw16.and_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16AndU},
-#line 127 "src/lexer-keywords.txt"
+      {""}, {""},
+#line 129 "src/lexer-keywords.txt"
       {"f64.convert_i64_s", TokenType::Convert, Opcode::F64ConvertI64S},
-#line 65 "src/lexer-keywords.txt"
+#line 67 "src/lexer-keywords.txt"
       {"f32.convert_i64_s", TokenType::Convert, Opcode::F32ConvertI64S},
-      {""}, {""}, {""},
-#line 227 "src/lexer-keywords.txt"
-      {"i16x8.shr_u", TokenType::Binary, Opcode::I16X8ShrU},
-#line 168 "src/lexer-keywords.txt"
-      {"f64x2.pmax", TokenType::Binary, Opcode::F64X2PMax},
-#line 226 "src/lexer-keywords.txt"
-      {"i16x8.shr_s", TokenType::Binary, Opcode::I16X8ShrS},
-#line 381 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw16.or_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16OrU},
-#line 251 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw16.or_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16OrU},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 569 "src/lexer-keywords.txt"
-      {"rethrow", TokenType::Rethrow, Opcode::Rethrow},
-      {""}, {""}, {""},
-#line 580 "src/lexer-keywords.txt"
-      {"table.grow", TokenType::TableGrow, Opcode::TableGrow},
-#line 345 "src/lexer-keywords.txt"
-      {"i32x4.dot_i16x8_s", TokenType::Binary, Opcode::I32X4DotI16X8S},
-      {""}, {""},
-#line 169 "src/lexer-keywords.txt"
-      {"f64x2.pmin", TokenType::Binary, Opcode::F64X2PMin},
-      {""}, {""}, {""}, {""},
-#line 378 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw16.add_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16AddU},
-#line 248 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw16.add_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16AddU},
-#line 366 "src/lexer-keywords.txt"
-      {"i32x4.extend_high_i16x8_u", TokenType::Unary, Opcode::I32X4ExtendHighI16X8U},
+      {""}, {""}, {""}, {""}, {""},
+#line 60 "src/lexer-keywords.txt"
+      {"export", TokenType::Export},
+      {""}, {""}, {""}, {""}, {""},
+#line 527 "src/lexer-keywords.txt"
+      {"i8x16.shl", TokenType::Binary, Opcode::I8X16Shl},
+#line 553 "src/lexer-keywords.txt"
+      {"memory", TokenType::Memory},
+#line 593 "src/lexer-keywords.txt"
+      {"unreachable", TokenType::Unreachable, Opcode::Unreachable},
       {""},
-#line 365 "src/lexer-keywords.txt"
-      {"i32x4.extend_high_i16x8_s", TokenType::Unary, Opcode::I32X4ExtendHighI16X8S},
+#line 177 "src/lexer-keywords.txt"
+      {"f64x2.splat", TokenType::Unary, Opcode::F64X2Splat},
+#line 110 "src/lexer-keywords.txt"
+      {"f32x4.pmax", TokenType::Binary, Opcode::F32X4PMax},
+#line 372 "src/lexer-keywords.txt"
+      {"i32x4.trunc_sat_f64x2_u_zero", TokenType::Unary, Opcode::I32X4TruncSatF64X2UZero},
       {""},
-#line 383 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw16.xchg_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16XchgU},
-#line 253 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw16.xchg_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16XchgU},
+#line 371 "src/lexer-keywords.txt"
+      {"i32x4.trunc_sat_f64x2_s_zero", TokenType::Unary, Opcode::I32X4TruncSatF64X2SZero},
       {""},
-#line 384 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw16.xor_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw16XorU},
-#line 254 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw16.xor_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw16XorU},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 520 "src/lexer-keywords.txt"
-      {"i8x16.popcnt", TokenType::Unary, Opcode::I8X16Popcnt},
+#line 190 "src/lexer-keywords.txt"
+      {"global.get", TokenType::GlobalGet, Opcode::GlobalGet},
+#line 489 "src/lexer-keywords.txt"
+      {"i64x2.splat", TokenType::Unary, Opcode::I64X2Splat},
+#line 191 "src/lexer-keywords.txt"
+      {"global.set", TokenType::GlobalSet, Opcode::GlobalSet},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""},
-#line 542 "src/lexer-keywords.txt"
-      {"loop", TokenType::Loop, Opcode::Loop},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""},
-#line 500 "src/lexer-keywords.txt"
-      {"i8x16.avgr_u", TokenType::Binary, Opcode::I8X16AvgrU},
-      {""},
-#line 361 "src/lexer-keywords.txt"
-      {"i32x4.extmul_high_i16x8_u", TokenType::Binary, Opcode::I32X4ExtmulHighI16X8U},
-      {""},
-#line 359 "src/lexer-keywords.txt"
-      {"i32x4.extmul_high_i16x8_s", TokenType::Binary, Opcode::I32X4ExtmulHighI16X8S},
-#line 547 "src/lexer-keywords.txt"
-      {"memory.fill", TokenType::MemoryFill, Opcode::MemoryFill},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 409 "src/lexer-keywords.txt"
+      {"i64.atomic.store32", TokenType::AtomicStore, Opcode::I64AtomicStore32},
       {""}, {""},
-#line 215 "src/lexer-keywords.txt"
-      {"i16x8.min_u", TokenType::Binary, Opcode::I16X8MinU},
-      {""},
-#line 214 "src/lexer-keywords.txt"
-      {"i16x8.min_s", TokenType::Binary, Opcode::I16X8MinS},
-      {""},
-#line 228 "src/lexer-keywords.txt"
-      {"i16x8.splat", TokenType::Unary, Opcode::I16X8Splat},
+#line 59 "src/lexer-keywords.txt"
+      {"exnref", Type::ExnRef},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""},
-#line 26 "src/lexer-keywords.txt"
-      {"assert_return", TokenType::AssertReturn},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 609 "src/lexer-keywords.txt"
+      {"v128.load64_splat", TokenType::Load, Opcode::V128Load64Splat},
+#line 617 "src/lexer-keywords.txt"
+      {"v128.store32_lane", TokenType::SimdStoreLane, Opcode::V128Store32Lane},
+#line 178 "src/lexer-keywords.txt"
+      {"f64x2.sqrt", TokenType::Unary, Opcode::F64X2Sqrt},
+#line 588 "src/lexer-keywords.txt"
+      {"throw", TokenType::Throw, Opcode::Throw},
+#line 603 "src/lexer-keywords.txt"
+      {"v128.load64_zero", TokenType::Load, Opcode::V128Load64Zero},
       {""}, {""}, {""}, {""},
-#line 145 "src/lexer-keywords.txt"
-      {"f64.reinterpret_i64", TokenType::Convert, Opcode::F64ReinterpretI64},
-      {""}, {""}, {""},
-#line 414 "src/lexer-keywords.txt"
+#line 37 "src/lexer-keywords.txt"
+      {"call_ref", TokenType::CallRef, Opcode::CallRef},
+      {""}, {""},
+#line 551 "src/lexer-keywords.txt"
+      {"memory.init", TokenType::MemoryInit, Opcode::MemoryInit},
+#line 416 "src/lexer-keywords.txt"
       {"i64.div_u", TokenType::Binary, Opcode::I64DivU},
-#line 276 "src/lexer-keywords.txt"
+#line 278 "src/lexer-keywords.txt"
       {"i32.div_u", TokenType::Binary, Opcode::I32DivU},
-#line 413 "src/lexer-keywords.txt"
+#line 415 "src/lexer-keywords.txt"
       {"i64.div_s", TokenType::Binary, Opcode::I64DivS},
-#line 275 "src/lexer-keywords.txt"
+#line 277 "src/lexer-keywords.txt"
       {"i32.div_s", TokenType::Binary, Opcode::I32DivS},
       {""}, {""}, {""}, {""},
-#line 157 "src/lexer-keywords.txt"
-      {"f64x2.floor", TokenType::Unary, Opcode::F64X2Floor},
+#line 418 "src/lexer-keywords.txt"
+      {"i64.eqz", TokenType::Convert, Opcode::I64Eqz},
+#line 280 "src/lexer-keywords.txt"
+      {"i32.eqz", TokenType::Convert, Opcode::I32Eqz},
+      {""}, {""},
+#line 589 "src/lexer-keywords.txt"
+      {"throw_ref", TokenType::ThrowRef, Opcode::ThrowRef},
       {""},
-#line 357 "src/lexer-keywords.txt"
-      {"i32x4.extadd_pairwise_i16x8_u", TokenType::Unary, Opcode::I32X4ExtaddPairwiseI16X8U},
+#line 203 "src/lexer-keywords.txt"
+      {"i16x8.extract_lane_u", TokenType::SimdLaneOp, Opcode::I16X8ExtractLaneU},
       {""},
-#line 356 "src/lexer-keywords.txt"
-      {"i32x4.extadd_pairwise_i16x8_s", TokenType::Unary, Opcode::I32X4ExtaddPairwiseI16X8S},
-      {""}, {""}, {""},
-#line 440 "src/lexer-keywords.txt"
-      {"i64.popcnt", TokenType::Unary, Opcode::I64Popcnt},
-#line 297 "src/lexer-keywords.txt"
-      {"i32.popcnt", TokenType::Unary, Opcode::I32Popcnt},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""},
-#line 559 "src/lexer-keywords.txt"
-      {"pagesize", TokenType::PageSize},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 556 "src/lexer-keywords.txt"
-      {"nop", TokenType::Nop, Opcode::Nop},
+#line 202 "src/lexer-keywords.txt"
+      {"i16x8.extract_lane_s", TokenType::SimdLaneOp, Opcode::I16X8ExtractLaneS},
       {""}, {""},
+#line 614 "src/lexer-keywords.txt"
+      {"v128.load64_lane", TokenType::SimdLoadLane, Opcode::V128Load64Lane},
 #line 396 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw8.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8SubU},
+      {"i64.atomic.rmw8.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw8CmpxchgU},
 #line 259 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw8.sub_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8SubU},
-      {""}, {""}, {""},
-#line 406 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw8.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmw8CmpxchgU},
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 408 "src/lexer-keywords.txt"
       {"i64.atomic.store16", TokenType::AtomicStore, Opcode::I64AtomicStore16},
-#line 269 "src/lexer-keywords.txt"
+#line 271 "src/lexer-keywords.txt"
       {"i32.atomic.store16", TokenType::AtomicStore, Opcode::I32AtomicStore16},
-      {""}, {""}, {""},
-#line 480 "src/lexer-keywords.txt"
-      {"i64x2.extend_low_i32x4_u", TokenType::Unary, Opcode::I64X2ExtendLowI32X4U},
-      {""},
-#line 478 "src/lexer-keywords.txt"
-      {"i64x2.extend_low_i32x4_s", TokenType::Unary, Opcode::I64X2ExtendLowI32X4S},
       {""}, {""},
-#line 370 "src/lexer-keywords.txt"
-      {"i32x4.trunc_sat_f64x2_u_zero", TokenType::Unary, Opcode::I32X4TruncSatF64X2UZero},
+#line 591 "src/lexer-keywords.txt"
+      {"try_table", TokenType::TryTable, Opcode::TryTable},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 601 "src/lexer-keywords.txt"
+      {"v128.any_true", TokenType::Unary, Opcode::V128AnyTrue},
       {""},
-#line 369 "src/lexer-keywords.txt"
-      {"i32x4.trunc_sat_f64x2_s_zero", TokenType::Unary, Opcode::I32X4TruncSatF64X2SZero},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 461 "src/lexer-keywords.txt"
-      {"i64.trunc_sat_f64_u", TokenType::Convert, Opcode::I64TruncSatF64U},
-#line 317 "src/lexer-keywords.txt"
-      {"i32.trunc_sat_f64_u", TokenType::Convert, Opcode::I32TruncSatF64U},
+#line 506 "src/lexer-keywords.txt"
+      {"i8x16.extract_lane_u", TokenType::SimdLaneOp, Opcode::I8X16ExtractLaneU},
+#line 366 "src/lexer-keywords.txt"
+      {"i32x4.trunc_sat_f32x4_u", TokenType::Unary, Opcode::I32X4TruncSatF32X4U},
+#line 505 "src/lexer-keywords.txt"
+      {"i8x16.extract_lane_s", TokenType::SimdLaneOp, Opcode::I8X16ExtractLaneS},
+      {""}, {""},
+#line 365 "src/lexer-keywords.txt"
+      {"i32x4.trunc_sat_f32x4_s", TokenType::Unary, Opcode::I32X4TruncSatF32X4S},
+      {""}, {""}, {""}, {""},
+#line 49 "src/lexer-keywords.txt"
+      {"drop", TokenType::Drop, Opcode::Drop},
+      {""}, {""}, {""},
+#line 582 "src/lexer-keywords.txt"
+      {"table.grow", TokenType::TableGrow, Opcode::TableGrow},
+      {""}, {""},
+#line 571 "src/lexer-keywords.txt"
+      {"rethrow", TokenType::Rethrow, Opcode::Rethrow},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""},
-#line 323 "src/lexer-keywords.txt"
-      {"i32x4.bitmask", TokenType::Unary, Opcode::I32X4Bitmask},
-#line 460 "src/lexer-keywords.txt"
-      {"i64.trunc_sat_f64_s", TokenType::Convert, Opcode::I64TruncSatF64S},
-#line 316 "src/lexer-keywords.txt"
-      {"i32.trunc_sat_f64_s", TokenType::Convert, Opcode::I32TruncSatF64S},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 177 "src/lexer-keywords.txt"
-      {"f64x2.sub", TokenType::Binary, Opcode::F64X2Sub},
+#line 229 "src/lexer-keywords.txt"
+      {"i16x8.shr_u", TokenType::Binary, Opcode::I16X8ShrU},
+#line 217 "src/lexer-keywords.txt"
+      {"i16x8.min_u", TokenType::Binary, Opcode::I16X8MinU},
+#line 228 "src/lexer-keywords.txt"
+      {"i16x8.shr_s", TokenType::Binary, Opcode::I16X8ShrS},
+#line 216 "src/lexer-keywords.txt"
+      {"i16x8.min_s", TokenType::Binary, Opcode::I16X8MinS},
       {""}, {""}, {""}, {""}, {""},
-#line 488 "src/lexer-keywords.txt"
-      {"i64x2.sub", TokenType::Binary, Opcode::I64X2Sub},
+#line 403 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw.cmpxchg", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmwCmpxchg},
+#line 266 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw.cmpxchg", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmwCmpxchg},
+      {""},
+#line 121 "src/lexer-keywords.txt"
+      {"f32x4.demote_f64x2_zero", TokenType::Unary, Opcode::F32X4DemoteF64X2Zero},
+      {""}, {""},
+#line 42 "src/lexer-keywords.txt"
+      {"catch_all_ref", TokenType::CatchAllRef},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 491 "src/lexer-keywords.txt"
-      {"i64x2.extmul_low_i32x4_u", TokenType::Binary, Opcode::I64X2ExtmulLowI32X4U},
-#line 151 "src/lexer-keywords.txt"
-      {"f64x2.abs", TokenType::Unary, Opcode::F64X2Abs},
-#line 489 "src/lexer-keywords.txt"
-      {"i64x2.extmul_low_i32x4_s", TokenType::Binary, Opcode::I64X2ExtmulLowI32X4S},
       {""}, {""}, {""}, {""},
-#line 474 "src/lexer-keywords.txt"
-      {"i64x2.abs", TokenType::Unary, Opcode::I64X2Abs},
+#line 529 "src/lexer-keywords.txt"
+      {"i8x16.shr_u", TokenType::Binary, Opcode::I8X16ShrU},
+#line 518 "src/lexer-keywords.txt"
+      {"i8x16.min_u", TokenType::Binary, Opcode::I8X16MinU},
+#line 528 "src/lexer-keywords.txt"
+      {"i8x16.shr_s", TokenType::Binary, Opcode::I8X16ShrS},
+#line 517 "src/lexer-keywords.txt"
+      {"i8x16.min_s", TokenType::Binary, Opcode::I8X16MinS},
       {""}, {""}, {""},
-#line 129 "src/lexer-keywords.txt"
-      {"f64.copysign", TokenType::Binary, Opcode::F64Copysign},
-#line 67 "src/lexer-keywords.txt"
-      {"f32.copysign", TokenType::Binary, Opcode::F32Copysign},
+#line 26 "src/lexer-keywords.txt"
+      {"assert_return", TokenType::AssertReturn},
+#line 550 "src/lexer-keywords.txt"
+      {"memory.grow", TokenType::MemoryGrow, Opcode::MemoryGrow},
       {""}, {""}, {""}, {""},
-#line 319 "src/lexer-keywords.txt"
-      {"i32.wrap_i64", TokenType::Convert, Opcode::I32WrapI64},
+#line 398 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw8.sub_u", TokenType::AtomicRmw, Opcode::I64AtomicRmw8SubU},
+#line 261 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw8.sub_u", TokenType::AtomicRmw, Opcode::I32AtomicRmw8SubU},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 131 "src/lexer-keywords.txt"
-      {"f64.eq", TokenType::Compare, Opcode::F64Eq},
-#line 70 "src/lexer-keywords.txt"
-      {"f32.eq", TokenType::Compare, Opcode::F32Eq},
-      {""},
-#line 196 "src/lexer-keywords.txt"
-      {"i16x8.avgr_u", TokenType::Binary, Opcode::I16X8AvgrU},
       {""}, {""},
-#line 415 "src/lexer-keywords.txt"
-      {"i64.eq", TokenType::Compare, Opcode::I64Eq},
-#line 277 "src/lexer-keywords.txt"
-      {"i32.eq", TokenType::Compare, Opcode::I32Eq},
+#line 198 "src/lexer-keywords.txt"
+      {"i16x8.avgr_u", TokenType::Binary, Opcode::I16X8AvgrU},
+#line 230 "src/lexer-keywords.txt"
+      {"i16x8.splat", TokenType::Unary, Opcode::I16X8Splat},
+      {""}, {""}, {""},
+#line 340 "src/lexer-keywords.txt"
+      {"v128.load16x4_u", TokenType::Load, Opcode::V128Load16X4U},
       {""},
-#line 546 "src/lexer-keywords.txt"
-      {"memory.copy", TokenType::MemoryCopy, Opcode::MemoryCopy},
+#line 558 "src/lexer-keywords.txt"
+      {"nop", TokenType::Nop, Opcode::Nop},
       {""},
-#line 95 "src/lexer-keywords.txt"
-      {"f32x4.eq", TokenType::Compare, Opcode::F32X4Eq},
-      {""}, {""}, {""}, {""}, {""},
-#line 325 "src/lexer-keywords.txt"
-      {"i32x4.eq", TokenType::Compare, Opcode::I32X4Eq},
-      {""}, {""},
-#line 531 "src/lexer-keywords.txt"
-      {"i8x16.sub", TokenType::Binary, Opcode::I8X16Sub},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 339 "src/lexer-keywords.txt"
+      {"v128.load16x4_s", TokenType::Load, Opcode::V128Load16X4S},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 179 "src/lexer-keywords.txt"
+      {"f64x2.sub", TokenType::Binary, Opcode::F64X2Sub},
       {""}, {""},
-#line 198 "src/lexer-keywords.txt"
-      {"i16x8.relaxed_dot_i8x16_i7x16_s", TokenType::Binary, Opcode::I16X8DotI8X16I7X16S},
-      {""}, {""}, {""}, {""},
-#line 495 "src/lexer-keywords.txt"
-      {"i8x16.abs", TokenType::Unary, Opcode::I8X16Abs},
-      {""},
-#line 338 "src/lexer-keywords.txt"
-      {"v128.load16x4_u", TokenType::Load, Opcode::V128Load16X4U},
+#line 153 "src/lexer-keywords.txt"
+      {"f64x2.abs", TokenType::Unary, Opcode::F64X2Abs},
       {""}, {""}, {""},
-#line 337 "src/lexer-keywords.txt"
-      {"v128.load16x4_s", TokenType::Load, Opcode::V128Load16X4S},
-      {""},
-#line 154 "src/lexer-keywords.txt"
+#line 490 "src/lexer-keywords.txt"
+      {"i64x2.sub", TokenType::Binary, Opcode::I64X2Sub},
+#line 156 "src/lexer-keywords.txt"
       {"f64x2.div", TokenType::Binary, Opcode::F64X2Div},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 25 "src/lexer-keywords.txt"
-      {"assert_malformed", TokenType::AssertMalformed},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 58 "src/lexer-keywords.txt"
-      {"export", TokenType::Export},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""},
-#line 364 "src/lexer-keywords.txt"
-      {"i32x4.trunc_sat_f32x4_u", TokenType::Unary, Opcode::I32X4TruncSatF32X4U},
+      {""},
+#line 476 "src/lexer-keywords.txt"
+      {"i64x2.abs", TokenType::Unary, Opcode::I64X2Abs},
+#line 502 "src/lexer-keywords.txt"
+      {"i8x16.avgr_u", TokenType::Binary, Opcode::I8X16AvgrU},
+#line 530 "src/lexer-keywords.txt"
+      {"i8x16.splat", TokenType::Unary, Opcode::I8X16Splat},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 171 "src/lexer-keywords.txt"
+      {"f64x2.pmin", TokenType::Binary, Opcode::F64X2PMin},
+      {""}, {""},
+#line 544 "src/lexer-keywords.txt"
+      {"loop", TokenType::Loop, Opcode::Loop},
+      {""}, {""}, {""}, {""}, {""},
+#line 461 "src/lexer-keywords.txt"
+      {"i64.trunc_sat_f32_u", TokenType::Convert, Opcode::I64TruncSatF32U},
+#line 317 "src/lexer-keywords.txt"
+      {"i32.trunc_sat_f32_u", TokenType::Convert, Opcode::I32TruncSatF32U},
+#line 133 "src/lexer-keywords.txt"
+      {"f64.eq", TokenType::Compare, Opcode::F64Eq},
+#line 72 "src/lexer-keywords.txt"
+      {"f32.eq", TokenType::Compare, Opcode::F32Eq},
+#line 460 "src/lexer-keywords.txt"
+      {"i64.trunc_sat_f32_s", TokenType::Convert, Opcode::I64TruncSatF32S},
+#line 316 "src/lexer-keywords.txt"
+      {"i32.trunc_sat_f32_s", TokenType::Convert, Opcode::I32TruncSatF32S},
       {""}, {""}, {""},
-#line 363 "src/lexer-keywords.txt"
-      {"i32x4.trunc_sat_f32x4_s", TokenType::Unary, Opcode::I32X4TruncSatF32X4S},
+#line 417 "src/lexer-keywords.txt"
+      {"i64.eq", TokenType::Compare, Opcode::I64Eq},
+#line 279 "src/lexer-keywords.txt"
+      {"i32.eq", TokenType::Compare, Opcode::I32Eq},
+#line 325 "src/lexer-keywords.txt"
+      {"i32x4.bitmask", TokenType::Unary, Opcode::I32X4Bitmask},
+      {""}, {""}, {""}, {""},
+#line 442 "src/lexer-keywords.txt"
+      {"i64.popcnt", TokenType::Unary, Opcode::I64Popcnt},
+#line 299 "src/lexer-keywords.txt"
+      {"i32.popcnt", TokenType::Unary, Opcode::I32Popcnt},
+      {""}, {""},
+#line 382 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw16.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw16CmpxchgU},
+#line 252 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw16.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmw16CmpxchgU},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 218 "src/lexer-keywords.txt"
-      {"i16x8.narrow_i32x4_u", TokenType::Binary, Opcode::I16X8NarrowI32X4U},
+      {""}, {""}, {""}, {""},
+#line 97 "src/lexer-keywords.txt"
+      {"f32x4.eq", TokenType::Compare, Opcode::F32X4Eq},
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 327 "src/lexer-keywords.txt"
+      {"i32x4.eq", TokenType::Compare, Opcode::I32X4Eq},
+      {""}, {""}, {""}, {""}, {""},
+#line 482 "src/lexer-keywords.txt"
+      {"i64x2.extend_low_i32x4_u", TokenType::Unary, Opcode::I64X2ExtendLowI32X4U},
       {""},
-#line 217 "src/lexer-keywords.txt"
-      {"i16x8.narrow_i32x4_s", TokenType::Binary, Opcode::I16X8NarrowI32X4S},
-#line 126 "src/lexer-keywords.txt"
+#line 480 "src/lexer-keywords.txt"
+      {"i64x2.extend_low_i32x4_s", TokenType::Unary, Opcode::I64X2ExtendLowI32X4S},
+#line 522 "src/lexer-keywords.txt"
+      {"i8x16.popcnt", TokenType::Unary, Opcode::I8X16Popcnt},
+      {""}, {""},
+#line 607 "src/lexer-keywords.txt"
+      {"v128.load16_splat", TokenType::Load, Opcode::V128Load16Splat},
+      {""}, {""}, {""}, {""}, {""},
+#line 128 "src/lexer-keywords.txt"
       {"f64.convert_i32_u", TokenType::Convert, Opcode::F64ConvertI32U},
-#line 64 "src/lexer-keywords.txt"
+#line 66 "src/lexer-keywords.txt"
       {"f32.convert_i32_u", TokenType::Convert, Opcode::F32ConvertI32U},
-      {""},
-#line 223 "src/lexer-keywords.txt"
-      {"i16x8.relaxed_q15mulr_s", TokenType::Binary, Opcode::I16X8RelaxedQ15mulrS},
-#line 125 "src/lexer-keywords.txt"
+      {""}, {""},
+#line 127 "src/lexer-keywords.txt"
       {"f64.convert_i32_s", TokenType::Convert, Opcode::F64ConvertI32S},
-#line 63 "src/lexer-keywords.txt"
+#line 65 "src/lexer-keywords.txt"
       {"f32.convert_i32_s", TokenType::Convert, Opcode::F32ConvertI32S},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 481 "src/lexer-keywords.txt"
-      {"i64x2.extend_high_i32x4_u", TokenType::Unary, Opcode::I64X2ExtendHighI32X4U},
-      {""},
-#line 479 "src/lexer-keywords.txt"
-      {"i64x2.extend_high_i32x4_s", TokenType::Unary, Opcode::I64X2ExtendHighI32X4S},
       {""},
-#line 615 "src/lexer-keywords.txt"
-      {"i8x16.shuffle", TokenType::SimdShuffleOp, Opcode::I8X16Shuffle},
-#line 380 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw16.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I64AtomicRmw16CmpxchgU},
-#line 250 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw16.cmpxchg_u", TokenType::AtomicRmwCmpxchg, Opcode::I32AtomicRmw16CmpxchgU},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 368 "src/lexer-keywords.txt"
+      {"i32x4.extend_high_i16x8_u", TokenType::Unary, Opcode::I32X4ExtendHighI16X8U},
       {""},
-#line 242 "src/lexer-keywords.txt"
-      {"i16x8.extend_low_i8x16_u", TokenType::Unary, Opcode::I16X8ExtendLowI8X16U},
-#line 93 "src/lexer-keywords.txt"
-      {"f32x4.convert_i32x4_u", TokenType::Unary, Opcode::F32X4ConvertI32X4U},
-#line 241 "src/lexer-keywords.txt"
-      {"i16x8.extend_low_i8x16_s", TokenType::Unary, Opcode::I16X8ExtendLowI8X16S},
-#line 92 "src/lexer-keywords.txt"
-      {"f32x4.convert_i32x4_s", TokenType::Unary, Opcode::F32X4ConvertI32X4S},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 231 "src/lexer-keywords.txt"
-      {"i16x8.sub", TokenType::Binary, Opcode::I16X8Sub},
+#line 367 "src/lexer-keywords.txt"
+      {"i32x4.extend_high_i16x8_s", TokenType::Unary, Opcode::I32X4ExtendHighI16X8S},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""},
+#line 170 "src/lexer-keywords.txt"
+      {"f64x2.pmax", TokenType::Binary, Opcode::F64X2PMax},
       {""}, {""}, {""}, {""},
-#line 492 "src/lexer-keywords.txt"
-      {"i64x2.extmul_high_i32x4_u", TokenType::Binary, Opcode::I64X2ExtmulHighI32X4U},
-      {""},
-#line 490 "src/lexer-keywords.txt"
-      {"i64x2.extmul_high_i32x4_s", TokenType::Binary, Opcode::I64X2ExtmulHighI32X4S},
-#line 191 "src/lexer-keywords.txt"
-      {"i16x8.abs", TokenType::Unary, Opcode::I16X8Abs},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 33 "src/lexer-keywords.txt"
-      {"br_if", TokenType::BrIf, Opcode::BrIf},
-      {""},
-#line 55 "src/lexer-keywords.txt"
-      {"externref", Type::ExternRef},
-#line 20 "src/lexer-keywords.txt"
-      {"array", Type::Array, TokenType::Array},
-      {""},
-#line 236 "src/lexer-keywords.txt"
-      {"i16x8.extmul_low_i8x16_u", TokenType::Binary, Opcode::I16X8ExtmulLowI8X16U},
+#line 612 "src/lexer-keywords.txt"
+      {"v128.load16_lane", TokenType::SimdLoadLane, Opcode::V128Load16Lane},
+      {""}, {""},
+#line 619 "src/lexer-keywords.txt"
+      {"i8x16.shuffle", TokenType::SimdShuffleOp, Opcode::I8X16Shuffle},
+      {""}, {""},
+#line 359 "src/lexer-keywords.txt"
+      {"i32x4.extadd_pairwise_i16x8_u", TokenType::Unary, Opcode::I32X4ExtaddPairwiseI16X8U},
       {""},
-#line 234 "src/lexer-keywords.txt"
-      {"i16x8.extmul_low_i8x16_s", TokenType::Binary, Opcode::I16X8ExtmulLowI8X16S},
+#line 358 "src/lexer-keywords.txt"
+      {"i32x4.extadd_pairwise_i16x8_s", TokenType::Unary, Opcode::I32X4ExtaddPairwiseI16X8S},
+      {""}, {""},
+#line 25 "src/lexer-keywords.txt"
+      {"assert_malformed", TokenType::AssertMalformed},
+      {""}, {""}, {""},
+#line 51 "src/lexer-keywords.txt"
+      {"elem.drop", TokenType::ElemDrop, Opcode::ElemDrop},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""},
-#line 184 "src/lexer-keywords.txt"
-      {"funcref", Type::FuncRef},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 603 "src/lexer-keywords.txt"
-      {"v128.load16_splat", TokenType::Load, Opcode::V128Load16Splat},
+#line 493 "src/lexer-keywords.txt"
+      {"i64x2.extmul_low_i32x4_u", TokenType::Binary, Opcode::I64X2ExtmulLowI32X4U},
+#line 524 "src/lexer-keywords.txt"
+      {"i8x16.relaxed_swizzle", TokenType::Binary, Opcode::I8X16RelaxedSwizzle},
+#line 491 "src/lexer-keywords.txt"
+      {"i64x2.extmul_low_i32x4_s", TokenType::Binary, Opcode::I64X2ExtmulLowI32X4S},
       {""}, {""}, {""}, {""}, {""},
-#line 368 "src/lexer-keywords.txt"
+#line 370 "src/lexer-keywords.txt"
       {"i32x4.extend_low_i16x8_u", TokenType::Unary, Opcode::I32X4ExtendLowI16X8U},
       {""},
-#line 367 "src/lexer-keywords.txt"
+#line 369 "src/lexer-keywords.txt"
       {"i32x4.extend_low_i16x8_s", TokenType::Unary, Opcode::I32X4ExtendLowI16X8S},
-      {""}, {""}, {""}, {""},
-#line 608 "src/lexer-keywords.txt"
-      {"v128.load16_lane", TokenType::SimdLoadLane, Opcode::V128Load16Lane},
-      {""}, {""}, {""}, {""}, {""}, {""},
-#line 50 "src/lexer-keywords.txt"
-      {"elem", TokenType::Elem},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 363 "src/lexer-keywords.txt"
+      {"i32x4.extmul_high_i16x8_u", TokenType::Binary, Opcode::I32X4ExtmulHighI16X8U},
       {""},
-#line 360 "src/lexer-keywords.txt"
-      {"i32x4.extmul_low_i16x8_u", TokenType::Binary, Opcode::I32X4ExtmulLowI16X8U},
+#line 361 "src/lexer-keywords.txt"
+      {"i32x4.extmul_high_i16x8_s", TokenType::Binary, Opcode::I32X4ExtmulHighI16X8S},
       {""},
-#line 358 "src/lexer-keywords.txt"
-      {"i32x4.extmul_low_i16x8_s", TokenType::Binary, Opcode::I32X4ExtmulLowI16X8S},
+#line 147 "src/lexer-keywords.txt"
+      {"f64.reinterpret_i64", TokenType::Convert, Opcode::F64ReinterpretI64},
+      {""}, {""},
+#line 321 "src/lexer-keywords.txt"
+      {"i32.wrap_i64", TokenType::Convert, Opcode::I32WrapI64},
+      {""}, {""}, {""}, {""},
+#line 620 "src/lexer-keywords.txt"
+      {"i8x16.swizzle", TokenType::Binary, Opcode::I8X16Swizzle},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 545 "src/lexer-keywords.txt"
-      {"memory.atomic.wait64", TokenType::AtomicWait, Opcode::MemoryAtomicWait64},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 459 "src/lexer-keywords.txt"
-      {"i64.trunc_sat_f32_u", TokenType::Convert, Opcode::I64TruncSatF32U},
-#line 315 "src/lexer-keywords.txt"
-      {"i32.trunc_sat_f32_u", TokenType::Convert, Opcode::I32TruncSatF32U},
-#line 477 "src/lexer-keywords.txt"
-      {"i64x2.bitmask", TokenType::Unary, Opcode::I64X2Bitmask},
-      {""},
-#line 458 "src/lexer-keywords.txt"
-      {"i64.trunc_sat_f32_s", TokenType::Convert, Opcode::I64TruncSatF32S},
-#line 314 "src/lexer-keywords.txt"
-      {"i32.trunc_sat_f32_s", TokenType::Convert, Opcode::I32TruncSatF32S},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""},
-#line 130 "src/lexer-keywords.txt"
+#line 132 "src/lexer-keywords.txt"
       {"f64.div", TokenType::Binary, Opcode::F64Div},
-#line 69 "src/lexer-keywords.txt"
+#line 71 "src/lexer-keywords.txt"
       {"f32.div", TokenType::Binary, Opcode::F32Div},
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 233 "src/lexer-keywords.txt"
+      {"i16x8.sub", TokenType::Binary, Opcode::I16X8Sub},
+      {""}, {""},
+#line 193 "src/lexer-keywords.txt"
+      {"i16x8.abs", TokenType::Unary, Opcode::I16X8Abs},
+      {""},
+#line 561 "src/lexer-keywords.txt"
+      {"pagesize", TokenType::PageSize},
+      {""}, {""},
+#line 95 "src/lexer-keywords.txt"
+      {"f32x4.convert_i32x4_u", TokenType::Unary, Opcode::F32X4ConvertI32X4U},
+      {""},
+#line 94 "src/lexer-keywords.txt"
+      {"f32x4.convert_i32x4_s", TokenType::Unary, Opcode::F32X4ConvertI32X4S},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""},
-#line 27 "src/lexer-keywords.txt"
-      {"assert_trap", TokenType::AssertTrap},
-      {""}, {""}, {""}, {""},
-#line 592 "src/lexer-keywords.txt"
-      {"v128.bitselect", TokenType::Ternary, Opcode::V128BitSelect},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""},
+#line 362 "src/lexer-keywords.txt"
+      {"i32x4.extmul_low_i16x8_u", TokenType::Binary, Opcode::I32X4ExtmulLowI16X8U},
       {""},
-#line 501 "src/lexer-keywords.txt"
-      {"i8x16.bitmask", TokenType::Unary, Opcode::I8X16Bitmask},
+#line 360 "src/lexer-keywords.txt"
+      {"i32x4.extmul_low_i16x8_s", TokenType::Binary, Opcode::I32X4ExtmulLowI16X8S},
       {""}, {""},
-#line 144 "src/lexer-keywords.txt"
-      {"f64.promote_f32", TokenType::Convert, Opcode::F64PromoteF32},
+#line 131 "src/lexer-keywords.txt"
+      {"f64.copysign", TokenType::Binary, Opcode::F64Copysign},
+#line 69 "src/lexer-keywords.txt"
+      {"f32.copysign", TokenType::Binary, Opcode::F32Copysign},
+#line 533 "src/lexer-keywords.txt"
+      {"i8x16.sub", TokenType::Binary, Opcode::I8X16Sub},
       {""}, {""},
-#line 441 "src/lexer-keywords.txt"
-      {"i64.reinterpret_f64", TokenType::Convert, Opcode::I64ReinterpretF64},
-#line 155 "src/lexer-keywords.txt"
-      {"f64x2.eq", TokenType::Compare, Opcode::F64X2Eq},
+#line 497 "src/lexer-keywords.txt"
+      {"i8x16.abs", TokenType::Unary, Opcode::I8X16Abs},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""},
+#line 225 "src/lexer-keywords.txt"
+      {"i16x8.relaxed_q15mulr_s", TokenType::Binary, Opcode::I16X8RelaxedQ15mulrS},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""},
-#line 468 "src/lexer-keywords.txt"
-      {"i64x2.eq", TokenType::Binary, Opcode::I64X2Eq},
+#line 200 "src/lexer-keywords.txt"
+      {"i16x8.relaxed_dot_i8x16_i7x16_s", TokenType::Binary, Opcode::I16X8DotI8X16I7X16S},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 23 "src/lexer-keywords.txt"
-      {"assert_exhaustion", TokenType::AssertExhaustion},
+#line 443 "src/lexer-keywords.txt"
+      {"i64.reinterpret_f64", TokenType::Convert, Opcode::I64ReinterpretF64},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""},
+#line 244 "src/lexer-keywords.txt"
+      {"i16x8.extend_low_i8x16_u", TokenType::Unary, Opcode::I16X8ExtendLowI8X16U},
+      {""},
+#line 243 "src/lexer-keywords.txt"
+      {"i16x8.extend_low_i8x16_s", TokenType::Unary, Opcode::I16X8ExtendLowI8X16S},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""},
-#line 502 "src/lexer-keywords.txt"
-      {"i8x16.eq", TokenType::Compare, Opcode::I8X16Eq},
-      {""}, {""},
-#line 148 "src/lexer-keywords.txt"
-      {"f64.sub", TokenType::Binary, Opcode::F64Sub},
-#line 86 "src/lexer-keywords.txt"
-      {"f32.sub", TokenType::Binary, Opcode::F32Sub},
-      {""}, {""}, {""}, {""},
-#line 453 "src/lexer-keywords.txt"
-      {"i64.sub", TokenType::Binary, Opcode::I64Sub},
-#line 309 "src/lexer-keywords.txt"
-      {"i32.sub", TokenType::Binary, Opcode::I32Sub},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 220 "src/lexer-keywords.txt"
+      {"i16x8.narrow_i32x4_u", TokenType::Binary, Opcode::I16X8NarrowI32X4U},
+      {""},
+#line 219 "src/lexer-keywords.txt"
+      {"i16x8.narrow_i32x4_s", TokenType::Binary, Opcode::I16X8NarrowI32X4S},
       {""}, {""},
-#line 240 "src/lexer-keywords.txt"
-      {"i16x8.extend_high_i8x16_u", TokenType::Unary, Opcode::I16X8ExtendHighI8X16U},
+#line 238 "src/lexer-keywords.txt"
+      {"i16x8.extmul_low_i8x16_u", TokenType::Binary, Opcode::I16X8ExtmulLowI8X16U},
       {""},
-#line 239 "src/lexer-keywords.txt"
-      {"i16x8.extend_high_i8x16_s", TokenType::Unary, Opcode::I16X8ExtendHighI8X16S},
+#line 236 "src/lexer-keywords.txt"
+      {"i16x8.extmul_low_i8x16_s", TokenType::Binary, Opcode::I16X8ExtmulLowI8X16S},
+      {""}, {""}, {""},
+#line 548 "src/lexer-keywords.txt"
+      {"memory.copy", TokenType::MemoryCopy, Opcode::MemoryCopy},
+      {""},
+#line 479 "src/lexer-keywords.txt"
+      {"i64x2.bitmask", TokenType::Unary, Opcode::I64X2Bitmask},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""},
-#line 22 "src/lexer-keywords.txt"
-      {"assert_exception", TokenType::AssertException},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 83 "src/lexer-keywords.txt"
-      {"f32.reinterpret_i32", TokenType::Convert, Opcode::F32ReinterpretI32},
+      {""}, {""}, {""}, {""}, {""},
+#line 157 "src/lexer-keywords.txt"
+      {"f64x2.eq", TokenType::Compare, Opcode::F64X2Eq},
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 470 "src/lexer-keywords.txt"
+      {"i64x2.eq", TokenType::Binary, Opcode::I64X2Eq},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 237 "src/lexer-keywords.txt"
-      {"i16x8.extmul_high_i8x16_u", TokenType::Binary, Opcode::I16X8ExtmulHighI8X16U},
+#line 483 "src/lexer-keywords.txt"
+      {"i64x2.extend_high_i32x4_u", TokenType::Unary, Opcode::I64X2ExtendHighI32X4U},
       {""},
-#line 235 "src/lexer-keywords.txt"
-      {"i16x8.extmul_high_i8x16_s", TokenType::Binary, Opcode::I16X8ExtmulHighI8X16S},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 481 "src/lexer-keywords.txt"
+      {"i64x2.extend_high_i32x4_s", TokenType::Unary, Opcode::I64X2ExtendHighI32X4S},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 20 "src/lexer-keywords.txt"
+      {"array", Type::Array, TokenType::Array},
       {""}, {""},
-#line 197 "src/lexer-keywords.txt"
-      {"i16x8.bitmask", TokenType::Unary, Opcode::I16X8Bitmask},
+#line 27 "src/lexer-keywords.txt"
+      {"assert_trap", TokenType::AssertTrap},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 596 "src/lexer-keywords.txt"
+      {"v128.bitselect", TokenType::Ternary, Opcode::V128BitSelect},
       {""}, {""}, {""}, {""}, {""}, {""},
-#line 37 "src/lexer-keywords.txt"
-      {"call_ref", TokenType::CallRef, Opcode::CallRef},
+#line 150 "src/lexer-keywords.txt"
+      {"f64.sub", TokenType::Binary, Opcode::F64Sub},
+#line 88 "src/lexer-keywords.txt"
+      {"f32.sub", TokenType::Binary, Opcode::F32Sub},
+      {""}, {""}, {""}, {""}, {""},
+#line 455 "src/lexer-keywords.txt"
+      {"i64.sub", TokenType::Binary, Opcode::I64Sub},
+#line 311 "src/lexer-keywords.txt"
+      {"i32.sub", TokenType::Binary, Opcode::I32Sub},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""},
-#line 233 "src/lexer-keywords.txt"
-      {"i16x8.extadd_pairwise_i8x16_u", TokenType::Unary, Opcode::I16X8ExtaddPairwiseI8X16U},
-      {""},
-#line 232 "src/lexer-keywords.txt"
-      {"i16x8.extadd_pairwise_i8x16_s", TokenType::Unary, Opcode::I16X8ExtaddPairwiseI8X16S},
-      {""}, {""}, {""}, {""},
-#line 544 "src/lexer-keywords.txt"
-      {"memory.atomic.wait32", TokenType::AtomicWait, Opcode::MemoryAtomicWait32},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 146 "src/lexer-keywords.txt"
+      {"f64.promote_f32", TokenType::Convert, Opcode::F64PromoteF32},
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 494 "src/lexer-keywords.txt"
+      {"i64x2.extmul_high_i32x4_u", TokenType::Binary, Opcode::I64X2ExtmulHighI32X4U},
+      {""},
+#line 492 "src/lexer-keywords.txt"
+      {"i64x2.extmul_high_i32x4_s", TokenType::Binary, Opcode::I64X2ExtmulHighI32X4S},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 199 "src/lexer-keywords.txt"
-      {"i16x8.eq", TokenType::Compare, Opcode::I16X8Eq},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""},
+#line 22 "src/lexer-keywords.txt"
+      {"assert_exception", TokenType::AssertException},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 199 "src/lexer-keywords.txt"
+      {"i16x8.bitmask", TokenType::Unary, Opcode::I16X8Bitmask},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""},
-#line 518 "src/lexer-keywords.txt"
-      {"i8x16.narrow_i16x8_u", TokenType::Binary, Opcode::I8X16NarrowI16X8U},
+      {""}, {""},
+#line 23 "src/lexer-keywords.txt"
+      {"assert_exhaustion", TokenType::AssertExhaustion},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 503 "src/lexer-keywords.txt"
+      {"i8x16.bitmask", TokenType::Unary, Opcode::I8X16Bitmask},
       {""},
-#line 517 "src/lexer-keywords.txt"
-      {"i8x16.narrow_i16x8_s", TokenType::Binary, Opcode::I8X16NarrowI16X8S},
+#line 201 "src/lexer-keywords.txt"
+      {"i16x8.eq", TokenType::Compare, Opcode::I16X8Eq},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""},
+#line 504 "src/lexer-keywords.txt"
+      {"i8x16.eq", TokenType::Compare, Opcode::I8X16Eq},
+      {""}, {""}, {""}, {""}, {""},
+#line 547 "src/lexer-keywords.txt"
+      {"memory.atomic.wait64", TokenType::AtomicWait, Opcode::MemoryAtomicWait64},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""},
-#line 28 "src/lexer-keywords.txt"
-      {"assert_unlinkable", TokenType::AssertUnlinkable},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""},
-#line 403 "src/lexer-keywords.txt"
-      {"i64.atomic.rmw.sub", TokenType::AtomicRmw, Opcode::I64AtomicRmwSub},
-#line 266 "src/lexer-keywords.txt"
-      {"i32.atomic.rmw.sub", TokenType::AtomicRmw, Opcode::I32AtomicRmwSub},
+      {""}, {""}, {""},
+#line 85 "src/lexer-keywords.txt"
+      {"f32.reinterpret_i32", TokenType::Convert, Opcode::F32ReinterpretI32},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 543 "src/lexer-keywords.txt"
-      {"memory.atomic.notify", TokenType::AtomicNotify, Opcode::MemoryAtomicNotify},
-      {""}, {""},
+      {""}, {""}, {""}, {""}, {""},
 #line 24 "src/lexer-keywords.txt"
       {"assert_invalid", TokenType::AssertInvalid},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""},
-#line 49 "src/lexer-keywords.txt"
-      {"elem.drop", TokenType::ElemDrop, Opcode::ElemDrop},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 405 "src/lexer-keywords.txt"
+      {"i64.atomic.rmw.sub", TokenType::AtomicRmw, Opcode::I64AtomicRmwSub},
+#line 268 "src/lexer-keywords.txt"
+      {"i32.atomic.rmw.sub", TokenType::AtomicRmw, Opcode::I32AtomicRmwSub},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""}, {""}, {""}, {""},
+#line 545 "src/lexer-keywords.txt"
+      {"memory.atomic.notify", TokenType::AtomicNotify, Opcode::MemoryAtomicNotify},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 242 "src/lexer-keywords.txt"
+      {"i16x8.extend_high_i8x16_u", TokenType::Unary, Opcode::I16X8ExtendHighI8X16U},
+      {""},
+#line 241 "src/lexer-keywords.txt"
+      {"i16x8.extend_high_i8x16_s", TokenType::Unary, Opcode::I16X8ExtendHighI8X16S},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 180 "src/lexer-keywords.txt"
+      {""},
+#line 28 "src/lexer-keywords.txt"
+      {"assert_unlinkable", TokenType::AssertUnlinkable},
+      {""}, {""},
+#line 300 "src/lexer-keywords.txt"
+      {"i32.reinterpret_f32", TokenType::Convert, Opcode::I32ReinterpretF32},
+      {""}, {""}, {""}, {""},
+#line 182 "src/lexer-keywords.txt"
       {"f64x2.convert_low_i32x4_u", TokenType::Unary, Opcode::F64X2ConvertLowI32X4U},
       {""},
-#line 179 "src/lexer-keywords.txt"
+#line 181 "src/lexer-keywords.txt"
       {"f64x2.convert_low_i32x4_s", TokenType::Unary, Opcode::F64X2ConvertLowI32X4S},
+      {""},
+#line 235 "src/lexer-keywords.txt"
+      {"i16x8.extadd_pairwise_i8x16_u", TokenType::Unary, Opcode::I16X8ExtaddPairwiseI8X16U},
+      {""},
+#line 234 "src/lexer-keywords.txt"
+      {"i16x8.extadd_pairwise_i8x16_s", TokenType::Unary, Opcode::I16X8ExtaddPairwiseI8X16S},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""},
-#line 57 "src/lexer-keywords.txt"
-      {"exnref", Type::ExnRef},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""},
+#line 546 "src/lexer-keywords.txt"
+      {"memory.atomic.wait32", TokenType::AtomicWait, Opcode::MemoryAtomicWait32},
       {""}, {""}, {""}, {""}, {""},
-#line 220 "src/lexer-keywords.txt"
+#line 520 "src/lexer-keywords.txt"
+      {"i8x16.narrow_i16x8_u", TokenType::Binary, Opcode::I8X16NarrowI16X8U},
+      {""},
+#line 519 "src/lexer-keywords.txt"
+      {"i8x16.narrow_i16x8_s", TokenType::Binary, Opcode::I8X16NarrowI16X8S},
+      {""},
+#line 222 "src/lexer-keywords.txt"
       {"i16x8.q15mulr_sat_s", TokenType::Binary, Opcode::I16X8Q15mulrSatS},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 298 "src/lexer-keywords.txt"
-      {"i32.reinterpret_f32", TokenType::Convert, Opcode::I32ReinterpretF32},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+      {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
+#line 29 "src/lexer-keywords.txt"
+      {"atomic.fence", TokenType::AtomicFence, Opcode::AtomicFence},
+      {""}, {""}, {""}, {""},
+#line 239 "src/lexer-keywords.txt"
+      {"i16x8.extmul_high_i8x16_u", TokenType::Binary, Opcode::I16X8ExtmulHighI8X16U},
+      {""},
+#line 237 "src/lexer-keywords.txt"
+      {"i16x8.extmul_high_i8x16_s", TokenType::Binary, Opcode::I16X8ExtmulHighI8X16S},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
@@ -1795,14 +1771,11 @@ Perfect_Hash::InWordSet (const char *str, size_t len)
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-      {""}, {""}, {""}, {""},
-#line 29 "src/lexer-keywords.txt"
-      {"atomic.fence", TokenType::AtomicFence, Opcode::AtomicFence},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
       {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""}, {""},
-#line 181 "src/lexer-keywords.txt"
+#line 183 "src/lexer-keywords.txt"
       {"f64x2.promote_low_f32x4", TokenType::Unary, Opcode::F64X2PromoteLowF32X4}
     };
 
diff --git a/src/resolve-names.cc b/src/resolve-names.cc
index 9fc8e443..67fc44e9 100644
--- a/src/resolve-names.cc
+++ b/src/resolve-names.cc
@@ -75,6 +75,8 @@ class NameResolver : public ExprVisitor::DelegateNop {
   Result OnStoreExpr(StoreExpr*) override;
   Result BeginTryExpr(TryExpr*) override;
   Result EndTryExpr(TryExpr*) override;
+  Result BeginTryTableExpr(TryTableExpr*) override;
+  Result EndTryTableExpr(TryTableExpr*) override;
   Result OnThrowExpr(ThrowExpr*) override;
   Result OnRethrowExpr(RethrowExpr*) override;
   Result OnSimdLoadLaneExpr(SimdLoadLaneExpr*) override;
@@ -442,6 +444,23 @@ Result NameResolver::EndTryExpr(TryExpr*) {
   return Result::Ok;
 }
 
+Result NameResolver::BeginTryTableExpr(TryTableExpr* expr) {
+  for (TableCatch& catch_ : expr->catches) {
+    if (!catch_.IsCatchAll()) {
+      ResolveTagVar(&catch_.tag);
+    }
+    ResolveLabelVar(&catch_.target);
+  }
+  PushLabel(expr->block.label);
+  ResolveBlockDeclarationVar(&expr->block.decl);
+  return Result::Ok;
+}
+
+Result NameResolver::EndTryTableExpr(TryTableExpr*) {
+  PopLabel();
+  return Result::Ok;
+}
+
 Result NameResolver::OnCatchExpr(TryExpr*, Catch* catch_) {
   if (!catch_->IsCatchAll()) {
     ResolveTagVar(&catch_->var);
diff --git a/src/shared-validator.cc b/src/shared-validator.cc
index 6492cbeb..bdf6eb71 100644
--- a/src/shared-validator.cc
+++ b/src/shared-validator.cc
@@ -1219,6 +1219,12 @@ Result SharedValidator::OnThrow(const Location& loc, Var tag_var) {
   return result;
 }
 
+Result SharedValidator::OnThrowRef(const Location& loc) {
+  Result result = CheckInstr(Opcode::ThrowRef, loc);
+  result |= typechecker_.OnThrowRef();
+  return result;
+}
+
 Result SharedValidator::OnTry(const Location& loc, Type sig_type) {
   Result result = CheckInstr(Opcode::Try, loc);
   TypeVector param_types, result_types;
@@ -1228,6 +1234,40 @@ Result SharedValidator::OnTry(const Location& loc, Type sig_type) {
   return result;
 }
 
+Result SharedValidator::BeginTryTable(const Location& loc, Type sig_type) {
+  Result result = CheckInstr(Opcode::TryTable, loc);
+  TypeVector param_types, result_types;
+  result |= CheckBlockSignature(loc, Opcode::TryTable, sig_type, &param_types,
+                                &result_types);
+  result |= typechecker_.BeginTryTable(param_types);
+  return result;
+}
+
+Result SharedValidator::OnTryTableCatch(const Location& loc,
+                                        const TableCatch& catch_) {
+  Result result = Result::Ok;
+  TagType tag_type;
+  expr_loc_ = loc;
+  if (!catch_.IsCatchAll()) {
+    result |= CheckTagIndex(catch_.tag, &tag_type);
+  }
+  if (catch_.IsRef()) {
+    tag_type.params.push_back(Type::ExnRef);
+  }
+  result |=
+      typechecker_.OnTryTableCatch(tag_type.params, catch_.target.index());
+  return result;
+}
+
+Result SharedValidator::EndTryTable(const Location& loc, Type sig_type) {
+  Result result = CheckInstr(Opcode::TryTable, loc);
+  TypeVector param_types, result_types;
+  result |= CheckBlockSignature(loc, Opcode::TryTable, sig_type, &param_types,
+                                &result_types);
+  result |= typechecker_.EndTryTable(param_types, result_types);
+  return result;
+}
+
 Result SharedValidator::OnUnary(const Location& loc, Opcode opcode) {
   Result result = CheckInstr(opcode, loc);
   result |= typechecker_.OnUnary(opcode);
diff --git a/src/type-checker.cc b/src/type-checker.cc
index 8d6c3a11..96e4153c 100644
--- a/src/type-checker.cc
+++ b/src/type-checker.cc
@@ -644,7 +644,8 @@ Result TypeChecker::OnEnd() {
   Result result = Result::Ok;
   static const char* s_label_type_name[] = {
       "function", "initializer expression", "block", "loop",
-      "if",       "`if false` branch",      "try",   "try catch"};
+      "if",       "`if false` branch",      "try",   "try table",
+      "try catch"};
   WABT_STATIC_ASSERT(WABT_ARRAY_SIZE(s_label_type_name) == kLabelTypeCount);
   Label* label;
   CHECK_RESULT(TopLabel(&label));
@@ -835,6 +836,13 @@ Result TypeChecker::OnThrow(const TypeVector& sig) {
   return result;
 }
 
+Result TypeChecker::OnThrowRef() {
+  Result result = Result::Ok;
+  result |= PopAndCheck1Type(Type::ExnRef, "throw_ref");
+  CHECK_RESULT(SetUnreachable());
+  return result;
+}
+
 Result TypeChecker::OnReturn() {
   Result result = Result::Ok;
   Label* func_label;
@@ -882,6 +890,31 @@ Result TypeChecker::OnTry(const TypeVector& param_types,
   return result;
 }
 
+Result TypeChecker::BeginTryTable(const TypeVector& param_types) {
+  Result result = PopAndCheckSignature(param_types, "try_table");
+  return result;
+}
+
+Result TypeChecker::OnTryTableCatch(const TypeVector& sig, Index depth) {
+  Result result = Result::Ok;
+  Label* label;
+  CHECK_RESULT(GetLabel(depth, &label));
+  TypeVector& label_sig = label->br_types();
+  result |= CheckTypes(label_sig, sig);
+  if (Failed(result)) {
+    PrintError("catch signature doesn't match target: expected %s, got %s",
+               TypesToString(sig).c_str(), TypesToString(label_sig).c_str());
+  }
+  return result;
+}
+
+Result TypeChecker::EndTryTable(const TypeVector& param_types,
+                                const TypeVector& result_types) {
+  PushLabel(LabelType::TryTable, param_types, result_types);
+  PushTypes(param_types);
+  return Result::Ok;
+}
+
 Result TypeChecker::OnUnary(Opcode opcode) {
   return CheckOpcode1(opcode);
 }
diff --git a/src/validator.cc b/src/validator.cc
index 71c78411..8ccfa407 100644
--- a/src/validator.cc
+++ b/src/validator.cc
@@ -147,7 +147,10 @@ class Validator : public ExprVisitor::Delegate {
   Result OnCatchExpr(TryExpr*, Catch*) override;
   Result OnDelegateExpr(TryExpr*) override;
   Result EndTryExpr(TryExpr*) override;
+  Result BeginTryTableExpr(TryTableExpr*) override;
+  Result EndTryTableExpr(TryTableExpr*) override;
   Result OnThrowExpr(ThrowExpr*) override;
+  Result OnThrowRefExpr(ThrowRefExpr*) override;
   Result OnRethrowExpr(RethrowExpr*) override;
   Result OnAtomicWaitExpr(AtomicWaitExpr*) override;
   Result OnAtomicFenceExpr(AtomicFenceExpr*) override;
@@ -564,11 +567,32 @@ Result Validator::EndTryExpr(TryExpr* expr) {
   return Result::Ok;
 }
 
+Result Validator::BeginTryTableExpr(TryTableExpr* expr) {
+  result_ |=
+      validator_.BeginTryTable(expr->loc, GetDeclarationType(expr->block.decl));
+  for (const TableCatch& catch_ : expr->catches) {
+    result_ |= validator_.OnTryTableCatch(expr->loc, catch_);
+  }
+  result_ |=
+      validator_.EndTryTable(expr->loc, GetDeclarationType(expr->block.decl));
+  return Result::Ok;
+}
+
+Result Validator::EndTryTableExpr(TryTableExpr* expr) {
+  result_ |= validator_.OnEnd(expr->block.end_loc);
+  return Result::Ok;
+}
+
 Result Validator::OnThrowExpr(ThrowExpr* expr) {
   result_ |= validator_.OnThrow(expr->loc, expr->var);
   return Result::Ok;
 }
 
+Result Validator::OnThrowRefExpr(ThrowRefExpr* expr) {
+  result_ |= validator_.OnThrowRef(expr->loc);
+  return Result::Ok;
+}
+
 Result Validator::OnRethrowExpr(RethrowExpr* expr) {
   result_ |= validator_.OnRethrow(expr->loc, expr->var);
   return Result::Ok;
diff --git a/src/wast-parser.cc b/src/wast-parser.cc
index 0868a217..a1dc32f3 100644
--- a/src/wast-parser.cc
+++ b/src/wast-parser.cc
@@ -191,6 +191,7 @@ bool IsPlainInstr(TokenType token_type) {
     case TokenType::TableSize:
     case TokenType::TableFill:
     case TokenType::Throw:
+    case TokenType::ThrowRef:
     case TokenType::Rethrow:
     case TokenType::RefFunc:
     case TokenType::RefNull:
@@ -219,6 +220,7 @@ bool IsBlockInstr(TokenType token_type) {
     case TokenType::Loop:
     case TokenType::If:
     case TokenType::Try:
+    case TokenType::TryTable:
       return true;
     default:
       return false;
@@ -245,6 +247,12 @@ bool IsCatch(TokenType token_type) {
   return token_type == TokenType::Catch || token_type == TokenType::CatchAll;
 }
 
+bool IsTryTableCatch(TokenTypePair pair) {
+  return pair[0] == TokenType::Lpar &&
+         (pair[1] == TokenType::Catch || pair[1] == TokenType::CatchAll ||
+          pair[1] == TokenType::CatchRef || pair[1] == TokenType::CatchAllRef);
+}
+
 bool IsModuleField(TokenTypePair pair) {
   if (pair[0] != TokenType::Lpar) {
     return false;
@@ -913,7 +921,7 @@ Result WastParser::ParseValueType(Var* out_type) {
 
   if (!is_value_type && !is_ref_type) {
     return ErrorExpected(
-        {"i32", "i64", "f32", "f64", "v128", "externref", "funcref"});
+        {"i32", "i64", "f32", "f64", "v128", "externref", "exnref", "funcref"});
   }
 
   if (is_ref_type) {
@@ -1001,7 +1009,7 @@ Result WastParser::ParseRefKind(Type* out_type) {
 Result WastParser::ParseRefType(Type* out_type) {
   WABT_TRACE(ParseRefType);
   if (!PeekMatch(TokenType::ValueType)) {
-    return ErrorExpected({"funcref", "externref"});
+    return ErrorExpected({"funcref", "externref", "exnref"});
   }
 
   Token token = Consume();
@@ -2513,6 +2521,11 @@ Result WastParser::ParsePlainInstr(std::unique_ptr<Expr>* out_expr) {
       CHECK_RESULT(ParsePlainInstrVar<ThrowExpr>(loc, out_expr));
       break;
 
+    case TokenType::ThrowRef:
+      ErrorUnlessOpcodeEnabled(Consume());
+      out_expr->reset(new ThrowRefExpr(loc));
+      break;
+
     case TokenType::Rethrow:
       ErrorUnlessOpcodeEnabled(Consume());
       CHECK_RESULT(ParsePlainInstrVar<RethrowExpr>(loc, out_expr));
@@ -3035,6 +3048,19 @@ Result WastParser::ParseBlockInstr(std::unique_ptr<Expr>* out_expr) {
       break;
     }
 
+    case TokenType::TryTable: {
+      ErrorUnlessOpcodeEnabled(Consume());
+      auto expr = std::make_unique<TryTableExpr>(loc);
+      CHECK_RESULT(ParseLabelOpt(&expr->block.label));
+      CHECK_RESULT(ParseBlockDeclaration(&expr->block.decl));
+      CHECK_RESULT(ParseTryTableCatches(&expr->catches));
+      CHECK_RESULT(ParseInstrList(&expr->block.exprs));
+      EXPECT(End);
+      CHECK_RESULT(ParseEndLabelOpt(expr->block.label));
+      *out_expr = std::move(expr);
+      break;
+    }
+
     default:
       assert(
           !"ParseBlockInstr should only be called when IsBlockInstr() is true");
@@ -3212,6 +3238,19 @@ Result WastParser::ParseExpr(ExprList* exprs) {
         break;
       }
 
+      case TokenType::TryTable: {
+        Consume();
+        ErrorUnlessOpcodeEnabled(Consume());
+        auto expr = std::make_unique<TryTableExpr>(loc);
+        CHECK_RESULT(ParseLabelOpt(&expr->block.label));
+        CHECK_RESULT(ParseBlockDeclaration(&expr->block.decl));
+        CHECK_RESULT(ParseTryTableCatches(&expr->catches));
+        CHECK_RESULT(ParseInstrList(&expr->block.exprs));
+        expr->block.end_loc = GetLocation();
+        exprs->push_back(std::move(expr));
+        break;
+      }
+
       default:
         assert(!"ParseExpr should only be called when IsExpr() is true");
         return Result::Error;
@@ -3279,6 +3318,40 @@ Result WastParser::ParseCatchExprList(CatchVector* catches) {
   return Result::Ok;
 }
 
+Result WastParser::ParseTryTableCatches(TryTableVector* catches) {
+  WABT_TRACE(ParseTryTableCatches);
+
+  while (IsTryTableCatch(PeekPair())) {
+    Consume();
+    TableCatch catch_(GetLocation());
+    auto token = Consume();
+    switch (token.token_type()) {
+      case TokenType::Catch:
+        catch_.kind = CatchKind::Catch;
+        break;
+      case TokenType::CatchRef:
+        catch_.kind = CatchKind::CatchRef;
+        break;
+      case TokenType::CatchAll:
+        catch_.kind = CatchKind::CatchAll;
+        break;
+      case TokenType::CatchAllRef:
+        catch_.kind = CatchKind::CatchAllRef;
+        break;
+      default:
+        WABT_UNREACHABLE;
+    }
+    if (catch_.kind == CatchKind::Catch || catch_.kind == CatchKind::CatchRef) {
+      CHECK_RESULT(ParseVar(&catch_.tag));
+    }
+    CHECK_RESULT(ParseVar(&catch_.target));
+    EXPECT(Rpar);
+    catches->push_back(std::move(catch_));
+  }
+
+  return Result::Ok;
+}
+
 Result WastParser::ParseGlobalType(Global* global) {
   WABT_TRACE(ParseGlobalType);
   if (MatchLpar(TokenType::Mut)) {
diff --git a/src/wat-writer.cc b/src/wat-writer.cc
index a013717a..f19e3c3c 100644
--- a/src/wat-writer.cc
+++ b/src/wat-writer.cc
@@ -600,10 +600,13 @@ class WatWriter::ExprVisitorDelegate : public ExprVisitor::Delegate {
   Result OnUnaryExpr(UnaryExpr*) override;
   Result OnUnreachableExpr(UnreachableExpr*) override;
   Result BeginTryExpr(TryExpr*) override;
+  Result BeginTryTableExpr(TryTableExpr*) override;
+  Result EndTryTableExpr(TryTableExpr*) override;
   Result OnCatchExpr(TryExpr*, Catch*) override;
   Result OnDelegateExpr(TryExpr*) override;
   Result EndTryExpr(TryExpr*) override;
   Result OnThrowExpr(ThrowExpr*) override;
+  Result OnThrowRefExpr(ThrowRefExpr*) override;
   Result OnRethrowExpr(RethrowExpr*) override;
   Result OnAtomicWaitExpr(AtomicWaitExpr*) override;
   Result OnAtomicFenceExpr(AtomicFenceExpr*) override;
@@ -950,6 +953,52 @@ Result WatWriter::ExprVisitorDelegate::OnUnreachableExpr(
   return Result::Ok;
 }
 
+Result WatWriter::ExprVisitorDelegate::BeginTryTableExpr(TryTableExpr* expr) {
+  // copied from WriteBeginBlock, try_table needs to push label *after*
+  // writing catches
+  writer_->WritePutsSpace(Opcode::TryTable_Opcode.GetName());
+  bool has_label = !expr->block.label.empty();
+  if (has_label) {
+    writer_->WriteString(expr->block.label, NextChar::Space);
+  }
+  writer_->WriteTypes(expr->block.decl.sig.param_types, "param");
+  writer_->WriteTypes(expr->block.decl.sig.result_types, "result");
+  if (!has_label) {
+    writer_->Writef(" ;; label = @%" PRIindex, writer_->GetLabelStackSize());
+  }
+  writer_->WriteNewline(FORCE_NEWLINE);
+  writer_->Indent();
+  for (const auto& catch_ : expr->catches) {
+    writer_->WritePuts("(", NextChar::None);
+    switch (catch_.kind) {
+      case CatchKind::Catch:
+        writer_->WritePutsSpace("catch");
+        break;
+      case CatchKind::CatchRef:
+        writer_->WritePutsSpace("catch_ref");
+        break;
+      case CatchKind::CatchAll:
+        writer_->WritePutsSpace("catch_all");
+        break;
+      case CatchKind::CatchAllRef:
+        writer_->WritePutsSpace("catch_all_ref");
+        break;
+    }
+    if (catch_.kind == CatchKind::Catch || catch_.kind == CatchKind::CatchRef) {
+      writer_->WriteVar(catch_.tag, NextChar::Space);
+    }
+    writer_->WriteBrVar(catch_.target, NextChar::None);
+    writer_->WritePuts(")", NextChar::Newline);
+  }
+  writer_->BeginBlock(LabelType::TryTable, expr->block);
+  return Result::Ok;
+}
+
+Result WatWriter::ExprVisitorDelegate::EndTryTableExpr(TryTableExpr* expr) {
+  writer_->WriteEndBlock();
+  return Result::Ok;
+}
+
 Result WatWriter::ExprVisitorDelegate::BeginTryExpr(TryExpr* expr) {
   writer_->WriteBeginBlock(LabelType::Try, expr->block,
                            Opcode::Try_Opcode.GetName());
@@ -989,6 +1038,11 @@ Result WatWriter::ExprVisitorDelegate::OnThrowExpr(ThrowExpr* expr) {
   return Result::Ok;
 }
 
+Result WatWriter::ExprVisitorDelegate::OnThrowRefExpr(ThrowRefExpr* expr) {
+  writer_->WritePutsNewline(Opcode::ThrowRef_Opcode.GetName());
+  return Result::Ok;
+}
+
 Result WatWriter::ExprVisitorDelegate::OnRethrowExpr(RethrowExpr* expr) {
   writer_->WritePutsSpace(Opcode::Rethrow_Opcode.GetName());
   writer_->WriteBrVar(expr->var, NextChar::Newline);
@@ -1260,6 +1314,58 @@ void WatWriter::FlushExprTree(const ExprTree& expr_tree) {
       break;
     }
 
+    case ExprType::TryTable: {
+      auto try_table_expr = cast<TryTableExpr>(expr_tree.expr);
+
+      WritePuts("(", NextChar::None);
+      // copied from WriteBeginBlock, try_table needs to push label *after*
+      // writing catches
+      WritePutsSpace(Opcode::TryTable_Opcode.GetName());
+      bool has_label = !try_table_expr->block.label.empty();
+      if (has_label) {
+        WriteString(try_table_expr->block.label, NextChar::Space);
+      }
+      WriteTypes(try_table_expr->block.decl.sig.param_types, "param");
+      WriteTypes(try_table_expr->block.decl.sig.result_types, "result");
+      if (!has_label) {
+        Writef(" ;; label = @%" PRIindex, GetLabelStackSize());
+      }
+      WriteNewline(FORCE_NEWLINE);
+      Indent();
+
+      for (const auto& catch_ : try_table_expr->catches) {
+        WritePuts("(", NextChar::None);
+        switch (catch_.kind) {
+          case CatchKind::Catch:
+            WritePutsSpace("catch");
+            break;
+          case CatchKind::CatchRef:
+            WritePutsSpace("catch_ref");
+            break;
+          case CatchKind::CatchAll:
+            WritePutsSpace("catch_all");
+            break;
+          case CatchKind::CatchAllRef:
+            WritePutsSpace("catch_all_ref");
+            break;
+        }
+        if (catch_.kind == CatchKind::Catch ||
+            catch_.kind == CatchKind::CatchRef) {
+          WriteVar(catch_.tag, NextChar::Space);
+        }
+        WriteBrVar(catch_.target, NextChar::None);
+        WritePuts(")", NextChar::Newline);
+      }
+
+      BeginBlock(LabelType::TryTable, try_table_expr->block);
+
+      WriteFoldedExprList(try_table_expr->block.exprs);
+      FlushExprTreeStack();
+      WriteCloseNewline();
+      EndBlock();
+      break;
+    }
+
     default: {
       WritePuts("(", NextChar::None);
       WriteExpr(expr_tree.expr);
diff --git a/test/parse/expr/try-table.txt b/test/parse/expr/try-table.txt
new file mode 100644
index 00000000..ee5b4b2c
--- /dev/null
+++ b/test/parse/expr/try-table.txt
@@ -0,0 +1,21 @@
+;;; TOOL: wat2wasm
+;;; ARGS: --enable-exceptions
+(module
+  (tag $e1 (param i32))
+  (tag $e2 (param i32 i32))
+
+  (func $func
+    block $a
+      block $b (result i32)
+        block $c (result i32 i32)
+          try_table (catch $e1 $b) (catch $e2 $c) (catch_all $a)
+            nop
+          end
+          i32.const 0
+          i32.const 0
+        end
+        drop
+      end
+      drop
+    end)
+)
diff --git a/test/parse/func/bad-local-binding-no-type.txt b/test/parse/func/bad-local-binding-no-type.txt
index 599a20cd..611833ec 100644
--- a/test/parse/func/bad-local-binding-no-type.txt
+++ b/test/parse/func/bad-local-binding-no-type.txt
@@ -2,7 +2,7 @@
 ;;; ERROR: 1
 (module (func (local $n)))
 (;; STDERR ;;;
-out/test/parse/func/bad-local-binding-no-type.txt:3:24: error: unexpected token ")", expected i32, i64, f32, f64, v128, externref or funcref.
+out/test/parse/func/bad-local-binding-no-type.txt:3:24: error: unexpected token ")", expected i32, i64, f32, f64, v128, externref, exnref or funcref.
 (module (func (local $n)))
                        ^
 ;;; STDERR ;;)
diff --git a/test/parse/func/bad-local-binding.txt b/test/parse/func/bad-local-binding.txt
index 8e99be47..3f6dc6d4 100644
--- a/test/parse/func/bad-local-binding.txt
+++ b/test/parse/func/bad-local-binding.txt
@@ -2,7 +2,7 @@
 ;;; ERROR: 1
 (module (func (local $foo $bar)))
 (;; STDERR ;;;
-out/test/parse/func/bad-local-binding.txt:3:27: error: unexpected token "$bar", expected i32, i64, f32, f64, v128, externref or funcref.
+out/test/parse/func/bad-local-binding.txt:3:27: error: unexpected token "$bar", expected i32, i64, f32, f64, v128, externref, exnref or funcref.
 (module (func (local $foo $bar)))
                           ^^^^
 ;;; STDERR ;;)
diff --git a/test/parse/func/bad-param-binding.txt b/test/parse/func/bad-param-binding.txt
index f4d830e2..db1613a8 100644
--- a/test/parse/func/bad-param-binding.txt
+++ b/test/parse/func/bad-param-binding.txt
@@ -2,7 +2,7 @@
 ;;; ERROR: 1
 (module (func (param $bar $baz)))
 (;; STDERR ;;;
-out/test/parse/func/bad-param-binding.txt:3:27: error: unexpected token "$baz", expected i32, i64, f32, f64, v128, externref or funcref.
+out/test/parse/func/bad-param-binding.txt:3:27: error: unexpected token "$baz", expected i32, i64, f32, f64, v128, externref, exnref or funcref.
 (module (func (param $bar $baz)))
                           ^^^^
 ;;; STDERR ;;)
diff --git a/test/parse/module/bad-array-no-fields.txt b/test/parse/module/bad-array-no-fields.txt
index 90a5f222..8b60fd7b 100644
--- a/test/parse/module/bad-array-no-fields.txt
+++ b/test/parse/module/bad-array-no-fields.txt
@@ -3,7 +3,7 @@
 ;;; ERROR: 1
 (type (array))
 (;; STDERR ;;;
-out/test/parse/module/bad-array-no-fields.txt:4:13: error: unexpected token ")", expected i32, i64, f32, f64, v128, externref or funcref.
+out/test/parse/module/bad-array-no-fields.txt:4:13: error: unexpected token ")", expected i32, i64, f32, f64, v128, externref, exnref or funcref.
 (type (array))
             ^
 ;;; STDERR ;;)
diff --git a/test/roundtrip/fold-try-table.txt b/test/roundtrip/fold-try-table.txt
new file mode 100644
index 00000000..9b15234b
--- /dev/null
+++ b/test/roundtrip/fold-try-table.txt
@@ -0,0 +1,35 @@
+;;; TOOL: run-roundtrip
+;;; ARGS: --stdout --fold-exprs --enable-exceptions --debug-names
+(module
+  (func (result i32)
+    try_table (result i32)
+      i32.const 6
+    end
+    drop
+    block
+      try_table (result i32) (catch_all 0)
+        nop
+        i32.const 7
+        br 2
+      end
+      drop
+    end
+    i32.const 8
+  )
+)
+(;; STDOUT ;;;
+(module
+  (type (;0;) (func (result i32)))
+  (func (;0;) (type 0) (result i32)
+    (drop
+      (try_table (result i32)  ;; label = @1
+        (i32.const 6)))
+    (block  ;; label = @1
+      (drop
+        (try_table (result i32)  ;; label = @2
+          (catch_all 0 (;@1;))
+          (nop)
+          (br 2 (;@0;)
+            (i32.const 7)))))
+    (i32.const 8)))
+;;; STDOUT ;;)
diff --git a/test/roundtrip/fold-unreachable.txt b/test/roundtrip/fold-unreachable.txt
index 69988f1f..3ed77bcd 100644
--- a/test/roundtrip/fold-unreachable.txt
+++ b/test/roundtrip/fold-unreachable.txt
@@ -1,5 +1,5 @@
 ;;; TOOL: run-roundtrip
-;;; ARGS: --stdout --fold-exprs
+;;; ARGS: --stdout --enable-exceptions --fold-exprs
 (module
   (func (result i32)
     i32.const 1
@@ -26,7 +26,13 @@
   (func (result i32)
     i32.const 0
     return
-    i32.eqz))
+    i32.eqz)
+
+  (func
+    ref.null exn
+    throw_ref
+    drop
+  ))
 (;; STDOUT ;;;
 (module
   (type (;0;) (func (result i32)))
@@ -50,5 +56,9 @@
   (func (;3;) (type 0) (result i32)
     (i32.eqz
       (return
-        (i32.const 0)))))
+        (i32.const 0))))
+  (func (;4;) (type 1)
+    (drop
+      (throw_ref
+        (ref.null exn)))))
 ;;; STDOUT ;;)
diff --git a/test/roundtrip/try-table.txt b/test/roundtrip/try-table.txt
new file mode 100644
index 00000000..62e09866
--- /dev/null
+++ b/test/roundtrip/try-table.txt
@@ -0,0 +1,38 @@
+;;; TOOL: run-roundtrip
+;;; ARGS: --stdout --enable-exceptions --debug-names
+(module
+  (func (result i32)
+    try_table (result i32)
+      i32.const 6
+    end
+    drop
+    block
+      try_table (result i32) (catch_all 0)
+        nop
+        i32.const 7
+        br 2
+      end
+      drop
+    end
+    i32.const 8
+  )
+)
+(;; STDOUT ;;;
+(module
+  (type (;0;) (func (result i32)))
+  (func (;0;) (type 0) (result i32)
+    try_table (result i32)  ;; label = @1
+      i32.const 6
+    end
+    drop
+    block  ;; label = @1
+      try_table (result i32)  ;; label = @2
+        (catch_all 0 (;@1;))
+        nop
+        i32.const 7
+        br 2 (;@0;)
+      end
+      drop
+    end
+    i32.const 8))
+;;; STDOUT ;;)
diff --git a/test/spec/obsolete-keywords.txt b/test/spec/obsolete-keywords.txt
index e102ff46..a536a505 100644
--- a/test/spec/obsolete-keywords.txt
+++ b/test/spec/obsolete-keywords.txt
@@ -28,7 +28,7 @@ out/test/spec/obsolete-keywords.wast:34: assert_malformed passed:
   (func (local $i i32) (drop (tee_local $i (i32.const 0))))
                                                          ^
 out/test/spec/obsolete-keywords.wast:41: assert_malformed passed:
-  out/test/spec/obsolete-keywords/obsolete-keywords.5.wat:1:12: error: unexpected token "anyfunc", expected i32, i64, f32, f64, v128, externref or funcref.
+  out/test/spec/obsolete-keywords/obsolete-keywords.5.wat:1:12: error: unexpected token "anyfunc", expected i32, i64, f32, f64, v128, externref, exnref or funcref.
   (global $g anyfunc (ref.null func))
              ^^^^^^^
 out/test/spec/obsolete-keywords.wast:48: assert_malformed passed:
diff --git a/test/update-spec-tests.py b/test/update-spec-tests.py
index 0a600c6c..f33cff08 100755
--- a/test/update-spec-tests.py
+++ b/test/update-spec-tests.py
@@ -106,7 +106,6 @@ def main(args):
         'function-references',
         'threads',
         'annotations',
-        'exception-handling',
     ])
 
     # sanity check to verify that all flags are valid
author	Soni L. <EnderMoneyMod@gmail.com>	2024-11-20 14:51:48 -0300
committer	GitHub <noreply@github.com>	2024-11-20 09:51:48 -0800
commit	a0b7abef00b59eeafed58c774195189425d020b0 (patch)
tree	6f7b0747d3a3ef435bda9ac14ca22d417877796b
parent	958d0a72030227bf3133c8b99c7c670bcdbc7636 (diff)
download	wabt-a0b7abef00b59eeafed58c774195189425d020b0.tar.gz wabt-a0b7abef00b59eeafed58c774195189425d020b0.tar.bz2 wabt-a0b7abef00b59eeafed58c774195189425d020b0.zip